#!/usr/bin/env python3

import sys, socket, time, math

class Vector:
       def __init__(self, x, y):
               self.x, self.y = x, y

       def __repr__(self):
               return '<Vector({x}, {y})>'.format(x = self.x, y = self.y)

       def __add__(self, other):
               return Vector(self.x + other.x, self.y + other.y)

       def __sub__(self, other):
               return Vector(self.x - other.x, self.y - other.y)

       def __mul__(self, other):
               return Vector(self.x * other, self.y * other)

       def __truediv__(self, other):
               return Vector(self.x / other, self.y / other)

       def length(self):
               return math.sqrt(self.x**2 + self.y**2)

       def dot(self, v):
               return self.x*v.x + self.y*v.y

class Cloud:
       def __init__(self, px, py, vx, vy, vapor):
               self.px, self.py, self.vx, self.vy, self.vapor = px, py, vx, vy, vapor
               self.pos = Vector(px, py)
               self.vel = Vector(vx, vy)

       def cloud_repr(self, name):
               return '<{name}({pos}, {vel}, {vapor}>'.format(
                               name = name, pos = self.pos,
                               vel = self.vel, vapor = self.vapor)

       def get_radius(self):
               return int(math.floor(math.sqrt(self.vapor)))

       def overlap(self, cloud):
               return (self.pos - cloud.pos).length() < self.get_radius() + cloud.get_radius()

       def intersection(self, cloud):
               a = cloud.vel.x * self.vel.x - cloud.vel.y * self.vel.x
               b = cloud.vel.x * (cloud.pos.y - self.pos.y) - cloud.vel.y * (cloud.pos.x - self.pos.x)
               if a == 0 and b == 0:
                       print('overlap')
                       return True
               elif a != 0:
                       v = Vector(self.pos.x + b/a * self.vel.x, self.pos.y + b/a * self.vel.y)
                       print('collision:', v)
                       return True
               return False

class Thunderstorm(Cloud):
       def __repr__(self):
               return Cloud.cloud_repr(self, 'Thunderstorm')

class Raincloud(Cloud):
       def __repr__(self):
               return Cloud.cloud_repr(self, 'Raincloud')

class State:
       def __init__(self, host, port):
               family = socket.AF_INET
               #if socket.has_ipv6:
               #       family |= socket.AF_INET6
               self.sock = socket.socket(family)
               self.sock.connect((host, port))
               self.s = self.sock.makefile(mode = 'rw', newline = '\n')

       def readline(self):
               return self.s.readline().strip()

       def writeline(self, s):
               self.s.write(s + '\n')
               self.s.flush()

       def read_state(self):
               self.writeline('GET_STATE')
               s = self.readline()
               if not len(s):
                       raise Exception('blah')
               you = -1
               storms = []
               clouds = []
               while s != 'END_STATE':
                       cmd, data = s.split(None, 1)
                       if cmd == 'YOU':
                               you = int(data)
                       elif cmd == 'THUNDERSTORM':
                               storms.append(Thunderstorm(*[float(x) for x in data.split()]))
                       elif cmd == 'RAINCLOUD':
                               clouds.append(Raincloud(*[float(x) for x in data.split()]))
                       s = self.readline()
               self.storms = storms
               self.clouds = clouds
               self.you = you
               self.me = self.storms[you]

       def nearest_cloud(self, v):
               storms = list(self.storms)
               del storms[self.you]
               clouds = self.clouds + storms
               return sorted(clouds, key = lambda c: (c.pos - v).length())

               nearest = -1
               nearest_len = 0
               for i, c in enumerate(self.clouds):
                       if nearest == -1 or (c.pos - v).length() < nearest_len:
                               nearest = i
                               nearest_len = (c.pos - v).length()
               return self.clouds[nearest]

       def wind(self, direction):
               self.writeline('WIND {x} {y}'.format(x = direction.x, y = direction.y))
               print('WIND {x} {y} ({s}, vapor is {v})'.format(x = direction.x, y = direction.y, s = direction.length(), v = self.me.vapor))
               s = self.readline()
               print(s)
               return s == 'OK'

state = State('localhost', 1986)
state.writeline('NAME {0}'.format(sys.argv[0]))
print(state.readline())
print(state.sock.getpeername())

flying = False
dest = Vector(0, 0)

last_dist = 0

def get_vector(dest_cloud, me):
       dest = dest_cloud.pos
       direction = dest - me.pos
       last_dist = direction.length()
       #direction /= direction.length()
       #direction *= 300
       if direction.length() > me.vapor / 2:
               direction /= direction.length()
               direction *= me.vapor / 3
       return direction - me.vel + dest_cloud.vel

while 1:
       start = time.time()
       state.read_state()

       me = state.storms[state.you]
       nearest = state.nearest_cloud(me.pos)
       dest_nearest = state.nearest_cloud(dest)

       if not flying:# or (flying and (dest_nearest[0].pos - me.pos).length() > 100):
               nearest.sort(key = lambda t: math.sqrt(1280**2 + 720**2)-t.vapor)
               vec = Vector(0, 0)
               for dest_cloud in nearest:
                       if dest_cloud.vapor > me.vapor - 310:
                               continue
                       vec = get_vector(dest_cloud, me)
                       dest = dest_cloud.pos
                       last_dist = (me.pos - dest).length()
                       v = dest_cloud.pos - me.pos
                       use = True
                       # try to avoid collision course with big clouds
                       for dc in nearest:
                               if dc == dest_cloud:
                                       continue
                               w = dc.pos - me.pos
                               pb = me.pos + (v * (w.dot(v) / v.dot(v)))
                               if pb.length() <= math.sqrt(me.vapor) + math.sqrt(dc.vapor):
                                       use = False
                                       break
                       if use:
                               print('dest: {0}: {1}, {2}: {3}, dist: {4}'.format(dest, dest_cloud.vapor, me.pos, me.vapor, (me.pos - dest).length()))
                               break

               ##dest_cloud = nearest[0]
               ##dest = dest_cloud.pos
               #me.intersection(dest_cloud)
               # direction to cloud
               ##direction = dest - me.pos
               ##last_dist = direction.length()
               ##direction /= direction.length()
               ##direction *= 100

               # TODO: fix
               ##temp = dest_cloud.vel * 60
               #temp = Vector(sum([dest_cloud.vel.x * (0.999**i) for i in range(1, 11)]),
                               #sum([dest_cloud.vel.y * (0.999**i) for i in range(1, 11)]))
               ##print(temp)
               #direction += temp

               #direction /= direction.length() / 120
               # direction we need to fire in
               #real_dir = direction - me.vel
               ##real_dir = direction - me.vel
               #real_dir += dest_cloud.vel
               #real_dir /= real_dir.length()
               ##strength = real_dir.length()
               #if strength < 1:
                       #strength = 1
               #elif strength > me.vapor / 2:
                       #strength = me.vapor / 2
               #flying = state.wind(dest - me.pos, 100)
               flying = state.wind(vec)
               print('flying =', flying)
       else:
               dest_cloud = dest_nearest[0]
               if me.overlap(dest_cloud):
                       pass
                       #flying = False
               else:
                       dist = (dest_cloud.pos - me.pos).length()
                       if dist > last_dist + 1:
                               flying = False
                       else:
                               last_dist = dist

       t = time.time() - start
       # use 0.11 seconds as base to make sure we don't break the rules
       time.sleep(0.11 - t)

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.