refact the acquiring phase

carribean/script.py

@@ -1,877 +1,866 @@
-'''
-
-@author: olivier.massot, 2019
-'''
-import heapq
-import sys
-
-
-# TODO:
-# * add an esquive manoeuvre / try to avoid cannonballs
-# * consider targeting rum barrels if an ennemy is nearer
-# * compute first and second target instead of only one to anticipate the next move
-# * if an enemy is near a mine, shoot the mine instead of the ship
-
-debug = True
-
-def log(*msg):
-    if debug:
-        print(*msg, file=sys.stderr)
-
-current_turn = 0
-
-class DidNotAct(Exception):
-    pass
-
-class Queue():
-    def __init__(self):
-        self.items = []
-
-    def put(self, item, priority):
-        heapq.heappush(self.items, (priority, item))
-
-    def get(self):
-        return heapq.heappop(self.items)[1]
-
-    @classmethod
-    def merge(cls, *args, reverse=False):
-        q = cls()
-        q.items = list(heapq.merge(*[a.items for a in args], key=lambda x: x[1], reverse=reverse))
-        return q
-
-class InterestQueue(Queue):
-    def __add__(self, other):
-        self.items += other.items
-        return self
-    
-    def __bool__(self):
-        return bool(self.items)
-    
-    def put(self, item):
-        heapq.heappush(self.items, item)
-        
-    def get(self):
-        return heapq.heappop(self.items)
-    
-    @classmethod
-    def merge(cls, *args, reverse=False):
-        q = cls()
-        q.items = list(heapq.merge(*[a.items for a in args], reverse=reverse))
-        return q
-    
-class ObjectivesQueue(InterestQueue):
-    pass
-
-    
-class Base():
-    def __repr__(self):
-        return f"<{self.__class__.__name__}: {self.__dict__}>"
-
-class Objective(Base):
-    def __init__(self, ship, target):
-        self.ship = ship
-        self.target = target
-        self.interest = 0
-
-    def __lt__(self, other):
-        return self.interest < other.interest
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__}({self.target.id})>"
-
-    def update_interest(self, from_= None):
-        # the lower the better
-        if from_ is None:
-            from_ = self.ship.next_pos
-        self.interest = Grid.manhattan(from_, self.target.pos)
-
-class GetBarrel(Objective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.distance = 0
-        self.alignment = 0
-        
-    def update_interest(self, from_= None, orientation=None):
-        if from_ is None:
-            from_ = self.ship.next_pos
-        if orientation is None:
-            orientation = self.ship.orientation
-        distance = Grid.manhattan(from_, self.target.pos)
-        alignment = abs(Grid.diff_directions(Grid.direction_to(*from_, *self.target.pos), orientation))
-        
-        self.interest = 6 * distance + 9 * alignment + 3 * self.target.dispersal + self.target.mine_threat ** 2 - 36 * self.target.ennemy_near
-
-class Attack(Objective):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.distance = 0
-        self.alignment = 0
-        
-    def update_interest(self, from_= None, orientation=None):
-        if from_ is None:
-            from_ = self.ship.next_pos
-        if orientation is None:
-            orientation = self.ship.orientation
-        distance = Grid.manhattan(from_, self.target.next_pos)
-        alignment = abs(Grid.diff_directions(Grid.direction_to(*from_, *self.target.next_pos), orientation))
-        
-        self.interest = 7 * distance + 3 * alignment - 20 * self.target.blocked_since - 10 * self.target.same_traject_since
-
-class PathNode(tuple):
-    def __new__(self, x, y, parent=None):
-        n = tuple.__new__(self, (x, y))
-        n.parent = parent
-        n.cost = 0
-        n.orientation = 0
-        return n
-    
-    def __repr__(self):
-        return f"<{self[0]}, {self[1]}, c:{self.cost}, o:{self.orientation}>"
-
-class Grid(Base):
-    def __init__(self):
-        self.w = 23
-        self.h = 21
-        
-        self._neighbors = {}
-        for x in range(-1, self.w + 1):
-            for y in range(-1, self.h + 1):
-                self.cache_neighbors(x, y)
- 
-        self.load_entities({})
-        
-    def __contains__(self, key):
-        return 0 <= key[0] < self.w and 0 <= key[1] < self.h
-
-    def __iter__(self):
-        for item in ((x, y) for x in range(self.w) for y in range(self.h)):
-            yield item
-
-    # data
-    
-    def load_entities(self, entities):
-        
-        # special: mines too far from ships are not recorded but still exist
-        ghost_mines = []
-        if hasattr(self, "mines"):
-            for m in self.mines:
-                if not m.pos in [e.pos for e in entities.values() if type(e) is Mine]:
-                    if all((self.manhattan(m.pos, ship.pos) > 5) for ship in self.owned_ships):
-                        m.ghost = True
-                        ghost_mines.append(m)
-
-        self.entities = entities
-        self.index = {}
-        self.ships = []
-        self.owned_ships = []
-        self.ennemy_ships = []
-        self.ships = []
-        self.barrels = []
-        self.mines = []
-        self.cannonballs = []
-        
-        for e in list(entities.values()) + ghost_mines:
-            self.index[e.pos] = e
-            type_ = type(e)
-            
-            if type_ is Ship:
-                self.ships.append(e)
-                if e.owned:
-                    self.owned_ships.append(e)
-                else:
-                    self.ennemy_ships.append(e)
-
-            elif type_ is Barrel:
-                self.barrels.append(e)
-
-            elif type_ is Mine:
-                self.mines.append(e)
-
-            elif type_ is Cannonball:
-                self.cannonballs.append(e)
-                
-        
-    def at(self, x, y):
-        try:
-            return self.index[(x, y)]
-        except KeyError:
-            return None
-        
-    def collision_at(self, x, y):
-        e = self.at(x, y)
-        return type(e) in [Mine, Ship, Cannonball] or not (x, y) in self.__iter__()
-        
-    def barrels_gravity_center(self):
-        wx, wy, wtotal = 0,0,0
-        for b in self.barrels:
-            wx += (b.x * b.amount) 
-            wy += (b.y * b.amount)
-            wtotal += b.amount
-        return (wx // wtotal, wy // wtotal) if wtotal else None
-
-    def pre_eval_barrels(self):
-        grav_center = self.barrels_gravity_center()
-        for b in self.barrels:
-            b.dispersal = Grid.manhattan(grav_center, b.pos) if grav_center != None else 0
-            b.mine_threat = any(type(self.at(*c)) is Mine for c in self.neighbors(*b.pos))
-            b.ennemy_near = any(b.pos in e.next_area for e in self.ennemy_ships)
-
-    def eval_objectives(self):
-        objectives = {GetBarrel: {}, Attack: {}}
-        
-        for b in self.barrels:
-            for s in self.owned_ships:
-                obj = GetBarrel(s, b)
-                obj.update_interest()
-                if not s in objectives[GetBarrel]:
-                    objectives[GetBarrel][s] = ObjectivesQueue()
-                objectives[GetBarrel][s].put(obj)
-                
-        for s in self.owned_ships:
-            objectives[Attack][s] = ObjectivesQueue()
-            for e in self.ennemy_ships:
-                obj = Attack(s, e)
-                obj.update_interest()
-                objectives[Attack][s].put(obj)
-                
-        return objectives
-    
-    def update_moving_costs(self):
-        base_costs = {}
-        
-        for x in range(-1, self.w + 1):
-            for y in range(-1, self.h + 1):
-                if x in (0, self.w) or y in (0, self.h):
-                    base_costs[(x, y)] = 15 # borders are a little more expensive
-                elif x in (-1, self.w + 1) or y in (-1, self.h + 1):
-                    base_costs[(x, y)] = 1000 # out of the map
-                else:
-                    base_costs[(x, y)] = 10 # base moving cost
-        
-        for m in self.mines:
-            for n in self.neighbors(*m.pos):
-                base_costs[n] += 30
-        for m in self.mines:
-            base_costs[m.pos] += 1000
-        for c in self.cannonballs:
-            base_costs[c.pos] += (100 + (5 - c.countdown) * 200)
-        
-        for ship in self.ships:
-            ship._moving_costs = base_costs
-            for other in self.ships:
-                if other is ship:
-                    continue
-                dist = self.manhattan(ship.pos, other.pos)
-                if dist > 8:
-                    continue
-                for c in self.neighbors(*other.pos):
-                    ship._moving_costs[c] += 100 * abs(3 - other.speed)
-                for c in self.zone(other.next_pos, 4):
-                    ship._moving_costs[c] += 20
-
-    def shooting_spot(self, ship, target):
-        shooting_spots = Queue()
-        target_pos = target.next_pos if type(target) is Ship else target.pos
-        
-        for x, y in self.zone(target_pos, 10):
-            if ship.moving_cost(x, y) > 10:
-                continue
-            if self.manhattan((x, y), target_pos) < 2:
-                continue
-            
-            interest = 0 # the lower the better
-            
-            # avoid cells too close from borders
-            if not (3 <= x <= (self.w - 3) and 3 <= y < (self.h - 3)):
-                interest += 10
-            
-            # priorize spots at distance 5 from active ship
-            interest -= 10 * abs(5 - self.manhattan((x, y), ship.pos))
-            
-            shooting_spots.put((x, y), interest)
-
-        return shooting_spots.get()
-
-    # geometrical algorithms
-    @staticmethod
-    def from_cubic(xu, yu, zu):
-        return (zu, int(xu + (zu - (zu & 1)) / 2))
-
-    @staticmethod
-    def to_cubic(x, y):
-        zu = x
-        xu = int(y - (x - (x & 1)) / 2)
-        yu = int(-xu - zu)
-        return (xu, yu, zu)
-
-    @staticmethod
-    def manhattan(from_, to_):
-        xa, ya = from_
-        xb, yb = to_
-        return abs(xa - xb) + abs(ya - yb) 
-
-    def zone(self, center, radius):
-        buffer = frozenset([center])
-        for _ in range(0, radius):
-            current = buffer
-            for x, y in current:
-                buffer |= frozenset(self.neighbors(x, y))
-        return [c for c in buffer if 0 <= c[0] < self.w and 0 <= c[1] < self.h]       
-
-    @staticmethod
-    def closest(from_, in_):
-        return min(in_, key=lambda x: Grid.manhattan(from_, x.pos))
-
-    @staticmethod
-    def directions(y):
-        if y % 2 == 0:
-            return [(1, 0), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1)]
-        else:
-            return [(1, 0), (1,-1), (0,-1), (-1, 0), (0, 1), (1, 1)]
-
-    @staticmethod
-    def direction_to(x0, y0, x, y):
-        dx, dy = (x - x0), (y - y0)
-        if dx > 0:
-            if dy == 0:
-                return 0
-            elif dy > 0:
-                return 5
-            else:
-                return 1
-        elif dx < 0:
-            if dy == 0:
-                return 3
-            elif dy > 0:
-                return 4
-            else:
-                return 2
-        else:
-            if dy > 0:
-                return 5 if y0 % 2 == 0 else 4
-            else:
-                return 1 if y0 % 2 == 0 else 2
-
-    @staticmethod
-    def diff_directions(d1, d2):
-        d = d2 - d1
-        if d <= -3:
-            d += 6
-        elif d > 3:
-            d -= 6
-        return d
-    
-    @staticmethod
-    def symetry(d):
-        return d + 3 if d < 3 else d - 3
-    
-    @staticmethod
-    def abs_neighbors(x, y):
-        return ((x + dx, y + dy) for dx, dy in Grid.directions(y))
-    
-    def cache_neighbors(self, xc, yc):
-        self._neighbors[(xc, yc)] = [(x, y) for x, y in Grid.abs_neighbors(xc, yc) if 0 <= x < self.w and 0 <= y < self.h]
-
-    def neighbors(self, x, y):
-        try:
-            return self._neighbors[(x, y)]
-        except KeyError:
-            self.cache_neighbors(x, y)
-            return self._neighbors[(x, y)]
-        
-    def rotate(self, center, coordinates, rotations):
-        if coordinates == [center] or rotations % 6 == 0:
-            return coordinates
-        x0, y0 = center
-        xu0, yu0, zu0 = self.to_cubic(x0, y0)
-        result = []
-
-        for x, y in coordinates:
-            xu, yu, zu = self.to_cubic(x, y)
-            dxu, dyu, dzu = xu - xu0, yu - yu0, zu - zu0
-            for _ in range(rotations):
-                dxu, dyu, dzu = -dzu, -dxu, -dyu
-            xru, yru, zru = dxu + xu0, dyu + yu0, dzu + zu0
-            xr, yr = self.from_cubic(xru, yru, zru)
-            result.append((xr, yr))
-        return result
-
-    # pathfinding
-    def path(self, origin, orientat0, target, moving_costs={}, incl_start=False, limit=10000):
-        nodes = Queue()
-        break_on, iteration = limit, 0
-        
-        
-        origin = PathNode(*origin)
-        origin.orientation = orientat0
-        
-        nodes.put(origin, 0)
-        neighbors = []
-
-        while nodes:
-            current = nodes.get()
-
-            if current == target:
-                path = []
-                previous = current
-                while previous:
-                    if previous != origin or incl_start:
-                        path.insert(0, previous)
-                    previous = previous.parent
-                return path
-
-            neighbors = self.neighbors(*current)
-
-            for x, y in neighbors:
-                
-                if (x, y) == current.parent:
-                    continue
-                
-                iteration += 1
-                if break_on > 0 and iteration >= break_on:
-                    return None
-                
-                moving_cost = moving_costs[(x, y)]
-                if moving_cost >= 1000:
-                    continue
-                
-                d = Grid.direction_to(*current, x, y)
-                diff = abs(Grid.diff_directions(current.orientation, d))
-                if diff > 1:
-                    # change direction one degree at a time
-                    continue
-                    
-                cost = current.cost + moving_cost + diff * 10
-                if diff != 0 and any(moving_costs[c] >= 1000 for c in neighbors):
-                    # a direction change here is dangerous
-                    cost += 50
-                
-                priority = cost + 10 * Grid.manhattan((x, y), target)
-
-                node = PathNode(x, y, current)
-                node.cost = cost
-                node.orientation = d
-                nodes.put(node, priority)
-        else:
-            return None
-
-class Entity(Base):
-    def __init__(self, ent_id):
-        self.id = int(ent_id)
-        self.x, self.y = 0, 0
-        self.args = [0,0,0,0]
-
-    def update(self, x, y, *args):
-        self.x, self.y = int(x), int(y)
-        
-    @property
-    def pos(self):
-        return (self.x, self.y)
-    
-    def __lt__(self, other):
-        # default comparison, used to avoid errors when used with queues and priorities are equals
-        return self.id < other.id
-    
-    
-class Ship(Entity):
-    MAX_SPEED = 2
-    SCOPE = 10
-    
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.x, self.y = 0, 0
-        self.orientation = 0
-        self.speed = 0
-        self.stock = 0
-        self.owned = 0
-        
-        self.next_cell = None
-        self.next_pos = None
-        self.last_fire = None
-        self.last_mining = None
-        self.blocked_since = 0
-        self.same_traject_since = 0
-        self.last_action = ""
-        self._moving_costs = {}
-        
-        self.target = None
-        self.second_target = None
-        self.path = []
-        
-        self.distance = 0
-        self.alignment = 0
-        
-    def __repr__(self):
-        return f"<Ship {self.id}: pos=({self.x}, {self.y}), orientation={self.orientation}, speed={self.speed}, blocked={self.blocked_since}, last_fire={self.last_fire}, next_pos={self.next_pos}, area={self.area}>"
-
-    def update(self, x, y, *args):
-        previous_state = self.state()
-        previous_traject = self.traject()
-        
-        super().update(x, y)
-        self.orientation, self.speed, self.stock, self.owned = map(int, args)
-
-        self.objective = None
-        self.objective_next = None
-        self.objective_fallback = None
-        self.path = []
-        
-        self.area = Ship.get_area(self.x, self.y, self.orientation)
-        self.prow, _, self.stern = self.area
-        
-        self.next_cell = self.get_next_cell()
-        self.next_pos = self.get_next_pos()
-        self.next_area = Ship.get_area(*self.next_pos, self.orientation)
-        
-        self.mobility_zone = list(set(self.area + self.next_area))
-            
-        if self.traject() != previous_traject:
-            self.same_traject_since += 1
-        else:
-            self.same_traject_since = 0
-    
-        if self.state() == previous_state:
-            self.blocked_since += 1
-        else:
-            self.blocked_since = 0
-
-    def traject(self):
-        return (self.orientation, self.speed)
-
-    def state(self):
-        return (self.x, self.y, self.orientation, self.speed)
-
-    @classmethod
-    def get_area(cls, x, y, orientation):
-        dx, dy = Grid.directions(y)[((orientation + 3) % 6)]
-        stern = (x + dx, y + dy)
-        
-        dx, dy = Grid.directions(y)[orientation]
-        prow = (x + dx, y + dy)
-        
-        return [prow, (x, y), stern]
-
-    def get_next_pos(self, in_=1):
-        x, y = self.x, self.y
-        for _ in range(in_):
-            for _ in range(self.speed):
-                dx, dy = Grid.directions(y)[self.orientation]
-                x, y = x + dx, y + dy
-        return x, y
-    
-    def get_next_cell(self, in_=1):
-        x, y = self.x, self.y
-        for _ in range(in_):
-            dx, dy = Grid.directions(y)[self.orientation]
-            x, y = x + dx, y + dy
-        return x, y
-
-    def in_current_direction(self, x, y):
-        return self.orientation == Grid.direction_to(*self.pos, x, y)
-
-    def moving_cost(self, x, y):
-        return self._moving_costs[(x, y)]
-    
-    def move(self, *args, **kwargs):
-        try:
-            self._move(*args, **kwargs)
-            return True
-        except DidNotAct:
-            return False
-
-    def _move(self, path):
-        
-        if path is None:
-            log(f"(!) broken: automove to {goto}")
-            ship.auto_move(*goto)
-            return
-        elif not path:
-            raise DidNotAct()
-        
-        # <--- special: avoid blocking situations
-        if current_turn > 1 and self.blocked_since >= 1:
-            dx, dy = Grid.directions(self.y)[((self.orientation + 1) % 6)]
-            if self.moving_cost(self.x + dx, self.y + dy) <= 50:
-                self.turn_left()
-            else:
-                self.turn_right()
-            return
-        # --->
-        
-        # speed shall be at 1 when arriving on the "flag"
-        next_flag = next((i for i, n in enumerate(path) if n.orientation != self.orientation), None)
-        if next_flag is None:
-            next_flag = len(path)
-        
-        if next_flag < (2 * self.speed):
-            # the end of the path or a direction change is coming
-            diff = Grid.diff_directions(self.orientation, path[0].orientation)
-            
-            # <--- special: avoid the left/right hesitation when stopped
-            if diff and not self.speed and self.last_action in ["STARBOARD",  "PORT"]:
-                self.speed_up()
-                return
-            # --->
-            
-            if diff > 0:
-                self.turn_left()
-                return
-                
-            elif diff < 0:
-                self.turn_right()
-                return
-        
-            elif self.speed > 1:
-                self.slow_down()
-                return
-        
-        else:
-            if not self.speed or (next_flag > (2 * self.speed + 1) and self.speed < self.MAX_SPEED):
-                # long path and no direction change coming: speed up
-                self.speed_up()
-                return
-        
-        raise DidNotAct()
-           
-    def fire_at_will(self, *args, **kwargs):
-        try:
-            self._fire_at_will(*args, **kwargs)
-            return True
-        except DidNotAct:
-            return False
-           
-    def _fire_at_will(self, target, allies = []):
-        if not self.can_fire():
-            raise DidNotAct()
-        
-        log("** fire at will")
-        
-        next_positions = [target.get_next_pos(i) for i in range(1, 3)]
-        log(f"ennemy next pos: {next_positions}")
-        
-        avoid = []
-        if not self in allies:
-            allies.append(self)
-        for ally in allies:
-            avoid += ally.mobility_zone
-
-        log(f"avoid: {avoid}")
-
-        for i, p in enumerate(next_positions):
-            turn = i + 1
-            
-            if p in avoid:
-                continue
-            
-            dist_p = Grid.manhattan(self.prow, p)
-            
-            if dist_p > self.SCOPE:
-                continue
-            
-            if (1 + round(dist_p / 3)) == turn:
-                log(f"Precision: {p}, {dist_p}, {turn}")
-                ship.fire(*p)
-                return
-        
-        next_pos = next_positions[0]
-        dist_p = Grid.manhattan(self.prow, next_pos)
-        if dist_p <= self.SCOPE:
-            ship.fire(*p)
-            return
-        
-        raise DidNotAct()
-            
-    def can_mine(self):
-        return self.last_mining is None or (current_turn - self.last_mining) >= 4
-        
-    def can_fire(self):
-        return self.last_fire is None or (current_turn - self.last_fire) >= 1
-            
-    # --- Basic commands
-    def auto_move(self, x, y):
-        self.last_action = "MOVE"
-        print(f"MOVE {x} {y}")
-        
-    def speed_up(self):
-        self.last_action = "FASTER"
-        print("FASTER")
-        
-    def slow_down(self):
-        self.last_action = "SLOWER"
-        print("SLOWER")    
-    
-    def turn_right(self):
-        self.last_action = "STARBOARD"
-        print("STARBOARD")
-    
-    def turn_left(self):
-        self.last_action = "PORT"
-        print("PORT")
-        
-    def wait(self):
-        self.last_action = "WAIT"
-        print("WAIT")
-        
-    def mine(self):
-        self.last_mining = current_turn
-        self.last_action = "MINE"
-        print("MINE")
-        
-    def fire(self, x, y):
-        self.last_fire = current_turn
-        self.last_action = "FIRE"
-        print(f"FIRE {x} {y}")
-
-class Barrel(Entity):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.amount = 0
-
-        self.dispersal = 0
-        self.mine_threat = False
-        self.ennemy_near = False
-
-    def __repr__(self):
-        return f"<Barrel {self.id}: pos=({self.x}, {self.y}), amount={self.amount}>"
-        
-    def update(self, x, y, *args):
-        super().update(x, y)
-        self.amount = int(args[0])
-
-class Mine(Entity):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.ghost = False
-
-    def __repr__(self):
-        return f"<Mine {self.id}: pos=({self.x}, {self.y}), ghost={self.ghost}>"
-
-class Cannonball(Entity):
-
-    def update(self, x, y, *args):
-        super().update(x, y)
-        self.sender, self.countdown = int(args[0]), int(args[1])
-
-
-entities = {}
-map_entity = {"SHIP": Ship, 
-             "BARREL": Barrel,
-             "MINE": Mine,
-             "CANNONBALL": Cannonball}
-
-grid = Grid()
-
-
-while True:
-    seen = []
-    current_turn += 1
-    
-    # <--- get input
-    my_ship_count, entity_count = int(input()), int(input())
-    for _ in range(entity_count):
-        ent_id, ent_type, *data = input().split()
-        ent_id = int(ent_id)
-        seen.append(ent_id)
-           
-        if not ent_id in entities:
-            entities[ent_id] = map_entity[ent_type](ent_id)
-               
-        ent = entities[ent_id]
-        ent.update(*data)
-     
-    entities = {k: v for k, v in entities.items() if k in seen}
-    # --->
-    
-    grid.load_entities(entities)
-    
-    log(f"### TURN {current_turn}")
-    
-#     log(f"Owned Ships: {grid.owned_ships}")
-    log(f"Ennemy Ships: {grid.ennemy_ships}")
-#     log(f"Barrels: {grid.barrels}")
-#     log(f"Mines: {grid.mines}")
-    log(f"Cannonballs: {grid.cannonballs}")
-
-
-    ### Evaluate
-    grid.pre_eval_barrels()
-    
-    objectives = grid.eval_objectives()
-    
-    grid.update_moving_costs()
-    
-    ### Acquire
-    log("# Acquiring")
-    
-    if objectives[GetBarrel]:
-        # objectives are shared between allies by priority
-        merged_objs = ObjectivesQueue.merge(*[obj_lst for ship, obj_lst in objectives[GetBarrel].items() if ship.owned])
-        aimed = []
-        
-        # first objective
-        obj = merged_objs.get()
-        while not all(s.objective for s in grid.owned_ships):
-            if not obj.ship.objective and not obj.target in aimed:
-                obj.ship.objective = obj
-                aimed.append(obj.target)
-            if not merged_objs:
-                break
-            obj = merged_objs.get()
-            
-        del merged_objs, aimed
-
-    if objectives[Attack]:
-        for ship in grid.owned_ships:
-            ship.objective_fallback = objectives[Attack][ship].get()
-    else:
-        log("ERROR: no objectives")
-    
-    for ship in grid.owned_ships:
-        log(f"Ship {ship.id}: obj: {ship.objective}; next: {ship.objective_next}; fallback: {ship.objective_fallback}")
-    
-    ### Plan
-    log("# Planning")
-    
-    for ship in grid.owned_ships:
-        
-        log(f"---- ship {ship.id} ---")
-        log(f"ship: {ship}")
-        
-        if ship.objective:
-            goto = ship.objective.target.pos
-        elif ship.objective_fallback:
-            goto = grid.shooting_spot(ship, ship.objective_fallback.target)
-        else:
-            log("ERROR: No target")
-            continue
-        
-        log(f"goto: {goto}")
-        
-        ship.path = grid.path(ship.next_pos, ship.orientation, goto, ship._moving_costs, limit=6000 // len(grid.owned_ships))
-        
-        if ship.objective_next and ship.path:
-            ship.path += grid.path(goto, 
-                                   ship.path[-1].orientation, 
-                                   ship.objective_next.target.pos, 
-                                   ship._moving_costs,
-                                   limit=6000 // len(grid.owned_ships)) or []
-        
-        log(f"path: {ship.path}")
-        
-    ### Process
-    log("# Processing")
-    
-    for ship in grid.owned_ships:
-        if not ship.objective and not ship.objective_fallback:
-            log("No target: wait")
-            ship.wait()
-        
-        if ship.move(ship.path):
-            continue
-        
-        # no movement was required, can fire
-        if ship.fire_at_will(ship.objective_fallback.target, allies=grid.owned_ships):
-            continue
-        
-        log("ERROR: Did not act, wait")
-        ship.wait()
+'''
+
+@author: olivier.massot, 2019
+'''
+import heapq
+import sys
+
+
+# TODO:
+# * add an esquive manoeuvre / try to avoid cannonballs
+# * consider targeting rum barrels if an ennemy is nearer
+# * compute first and second target instead of only one to anticipate the next move
+# * if an enemy is near a mine, shoot the mine instead of the ship
+# * compute the probabilities of presence of an ennemy on dirrefent coords at next turn
+
+debug = True
+
+def log(*msg):
+    if debug:
+        print(*msg, file=sys.stderr)
+
+current_turn = 0
+
+class DidNotAct(Exception):
+    pass
+
+class Queue():
+    def __init__(self):
+        self.items = []
+
+    def put(self, item, priority):
+        heapq.heappush(self.items, (priority, item))
+
+    def get(self):
+        return heapq.heappop(self.items)[1]
+
+    @classmethod
+    def merge(cls, *args, reverse=False):
+        q = cls()
+        q.items = list(heapq.merge(*[a.items for a in args], key=lambda x: x[1], reverse=reverse))
+        return q
+
+class InterestQueue(Queue):
+    def __add__(self, other):
+        self.items += other.items
+        return self
+    
+    def __bool__(self):
+        return bool(self.items)
+    
+    def put(self, item):
+        heapq.heappush(self.items, item)
+        
+    def get(self):
+        return heapq.heappop(self.items)
+    
+    @classmethod
+    def merge(cls, *args, reverse=False):
+        q = cls()
+        q.items = list(heapq.merge(*[a.items for a in args], reverse=reverse))
+        return q
+    
+class ObjectivesQueue(InterestQueue):
+    pass
+
+    
+class Base():
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {self.__dict__}>"
+
+
+
+class BaseObjective(Base):
+    def __init__(self, target):
+        self.target = target
+        self.interest = 0
+
+    def __lt__(self, other):
+        return self.interest < other.interest
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}({self.target.id})>"
+
+    def eval(self, pos = None, d = None):
+        self.distance = Grid.manhattan(pos, self.target.pos) if pos is not None else 0
+        self.alignment = abs(Grid.diff_directions(Grid.direction_to(*pos, *self.target.pos), d)) if d is not None else 0
+        self._compute_interest()
+        
+    def _compute_interest(self):
+        self.interest = 7 * self.distance + 3 * self.alignment
+        
+class GetBarrel(BaseObjective):
+    def _compute_interest(self):
+        self.interest = 6 * self.distance + 9 * self.alignment + 3 * self.target.dispersal + self.target.mine_threat ** 2 - 36 * self.target.ennemy_near
+
+class Attack(BaseObjective):
+    def _compute_interest(self):
+        self.interest = 7 * self.distance + 3 * self.alignment - 20 * self.target.blocked_since - 10 * self.target.same_traject_since
+
+
+
+class PathNode(tuple):
+    def __new__(self, x, y, parent=None):
+        n = tuple.__new__(self, (x, y))
+        n.parent = parent
+        n.cost = 0
+        n.orientation = 0
+        return n
+    
+    def __repr__(self):
+        return f"<{self[0]}, {self[1]}, c:{self.cost}, o:{self.orientation}>"
+
+class Grid(Base):
+    def __init__(self):
+        self.w = 23
+        self.h = 21
+        
+        self._neighbors = {}
+        for x in range(-1, self.w + 1):
+            for y in range(-1, self.h + 1):
+                self.cache_neighbors(x, y)
+ 
+        self.load_entities({})
+        
+    def __contains__(self, key):
+        return 0 <= key[0] < self.w and 0 <= key[1] < self.h
+
+    def __iter__(self):
+        for item in ((x, y) for x in range(self.w) for y in range(self.h)):
+            yield item
+
+    # data
+    
+    def load_entities(self, entities):
+        
+        # special: mines too far from ships are not recorded but still exist
+        ghost_mines = []
+        if hasattr(self, "mines"):
+            for m in self.mines:
+                if not m.pos in [e.pos for e in entities.values() if type(e) is Mine]:
+                    if all((self.manhattan(m.pos, ship.pos) > 5) for ship in self.owned_ships):
+                        m.ghost = True
+                        ghost_mines.append(m)
+
+        self.entities = entities
+        self.index = {}
+        self.ships = []
+        self.owned_ships = []
+        self.ennemy_ships = []
+        self.ships = []
+        self.barrels = []
+        self.mines = []
+        self.cannonballs = []
+        
+        for e in list(entities.values()) + ghost_mines:
+            self.index[e.pos] = e
+            type_ = type(e)
+            
+            if type_ is Ship:
+                self.ships.append(e)
+                if e.owned:
+                    self.owned_ships.append(e)
+                else:
+                    self.ennemy_ships.append(e)
+
+            elif type_ is Barrel:
+                self.barrels.append(e)
+
+            elif type_ is Mine:
+                self.mines.append(e)
+
+            elif type_ is Cannonball:
+                self.cannonballs.append(e)
+                
+        for s in self.owned_ships:
+            s.allies = [other for other in self.owned_ships if other is not s]
+                
+        grav_center = self.barrels_gravity_center()
+        for b in self.barrels:
+            b.dispersal = Grid.manhattan(grav_center, b.pos) if grav_center != None else 0
+            b.mine_threat = any(type(self.at(*c)) is Mine for c in self.neighbors(*b.pos))
+            b.ennemy_near = any(b.pos in e.next_area for e in self.ennemy_ships)
+                
+        for s in self.owned_ships:
+            
+            for b in self.barrels:
+                obj = GetBarrel(b)
+                obj.eval(s.next_pos, s.orientation)
+                s.objectives.put(obj)
+                
+            for e in self.ennemy_ships:
+                obj = Attack(e)
+                obj.eval(s.next_pos, s.orientation)
+                s.ennemies.put(obj)
+
+
+    def at(self, x, y):
+        try:
+            return self.index[(x, y)]
+        except KeyError:
+            return None
+        
+    def collision_at(self, x, y):
+        e = self.at(x, y)
+        return type(e) in [Mine, Ship, Cannonball] or not (x, y) in self.__iter__()
+        
+    def barrels_gravity_center(self):
+        wx, wy, wtotal = 0,0,0
+        for b in self.barrels:
+            wx += (b.x * b.amount) 
+            wy += (b.y * b.amount)
+            wtotal += b.amount
+        return (wx // wtotal, wy // wtotal) if wtotal else None
+
+    def update_moving_costs(self):
+        base_costs = {}
+        
+        for x in range(-1, self.w + 1):
+            for y in range(-1, self.h + 1):
+                if x in (0, self.w) or y in (0, self.h):
+                    base_costs[(x, y)] = 15 # borders are a little more expensive
+                elif x in (-1, self.w + 1) or y in (-1, self.h + 1):
+                    base_costs[(x, y)] = 1000 # out of the map
+                else:
+                    base_costs[(x, y)] = 10 # base moving cost
+        
+        for m in self.mines:
+            for n in self.neighbors(*m.pos):
+                base_costs[n] += 30
+        for m in self.mines:
+            base_costs[m.pos] += 1000
+        for c in self.cannonballs:
+            base_costs[c.pos] += (100 + (5 - c.countdown) * 200)
+        
+        for ship in self.ships:
+            ship._moving_costs = base_costs
+            for other in self.ships:
+                if other is ship:
+                    continue
+                dist = self.manhattan(ship.pos, other.pos)
+                if dist > 8:
+                    continue
+                for c in self.neighbors(*other.pos):
+                    ship._moving_costs[c] += 100 * abs(3 - other.speed)
+                for c in self.zone(other.next_pos, 4):
+                    ship._moving_costs[c] += 20
+
+    def shooting_spot(self, ship, target):
+        shooting_spots = Queue()
+        target_pos = target.next_pos if type(target) is Ship else target.pos
+        
+        for x, y in self.zone(target_pos, 10):
+            if ship.moving_cost(x, y) > 10:
+                continue
+            if self.manhattan((x, y), target_pos) < 2:
+                continue
+            
+            interest = 0 # the lower the better
+            
+            # avoid cells too close from borders
+            if not (3 <= x <= (self.w - 3) and 3 <= y < (self.h - 3)):
+                interest += 10
+            
+            # priorize spots at distance 5 from active ship
+            interest -= 10 * abs(5 - self.manhattan((x, y), ship.pos))
+            
+            shooting_spots.put((x, y), interest)
+
+        return shooting_spots.get()
+
+    # geometrical algorithms
+    @staticmethod
+    def from_cubic(xu, yu, zu):
+        return (zu, int(xu + (zu - (zu & 1)) / 2))
+
+    @staticmethod
+    def to_cubic(x, y):
+        zu = x
+        xu = int(y - (x - (x & 1)) / 2)
+        yu = int(-xu - zu)
+        return (xu, yu, zu)
+
+    @staticmethod
+    def manhattan(from_, to_):
+        xa, ya = from_
+        xb, yb = to_
+        return abs(xa - xb) + abs(ya - yb) 
+
+    def zone(self, center, radius):
+        buffer = frozenset([center])
+        for _ in range(0, radius):
+            current = buffer
+            for x, y in current:
+                buffer |= frozenset(self.neighbors(x, y))
+        return [c for c in buffer if 0 <= c[0] < self.w and 0 <= c[1] < self.h]       
+
+    @staticmethod
+    def closest(from_, in_):
+        return min(in_, key=lambda x: Grid.manhattan(from_, x.pos))
+
+    @staticmethod
+    def directions(y):
+        if y % 2 == 0:
+            return [(1, 0), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1)]
+        else:
+            return [(1, 0), (1,-1), (0,-1), (-1, 0), (0, 1), (1, 1)]
+
+    @staticmethod
+    def direction_to(x0, y0, x, y):
+        dx, dy = (x - x0), (y - y0)
+        if dx > 0:
+            if dy == 0:
+                return 0
+            elif dy > 0:
+                return 5
+            else:
+                return 1
+        elif dx < 0:
+            if dy == 0:
+                return 3
+            elif dy > 0:
+                return 4
+            else:
+                return 2
+        else:
+            if dy > 0:
+                return 5 if y0 % 2 == 0 else 4
+            else:
+                return 1 if y0 % 2 == 0 else 2
+
+    @staticmethod
+    def diff_directions(d1, d2):
+        d = d2 - d1
+        if d <= -3:
+            d += 6
+        elif d > 3:
+            d -= 6
+        return d
+    
+    @staticmethod
+    def symetry(d):
+        return d + 3 if d < 3 else d - 3
+    
+    @staticmethod
+    def abs_neighbors(x, y):
+        return ((x + dx, y + dy) for dx, dy in Grid.directions(y))
+    
+    def cache_neighbors(self, xc, yc):
+        self._neighbors[(xc, yc)] = [(x, y) for x, y in Grid.abs_neighbors(xc, yc) if 0 <= x < self.w and 0 <= y < self.h]
+
+    def neighbors(self, x, y):
+        try:
+            return self._neighbors[(x, y)]
+        except KeyError:
+            self.cache_neighbors(x, y)
+            return self._neighbors[(x, y)]
+        
+    def rotate(self, center, coordinates, rotations):
+        if coordinates == [center] or rotations % 6 == 0:
+            return coordinates
+        x0, y0 = center
+        xu0, yu0, zu0 = self.to_cubic(x0, y0)
+        result = []
+
+        for x, y in coordinates:
+            xu, yu, zu = self.to_cubic(x, y)
+            dxu, dyu, dzu = xu - xu0, yu - yu0, zu - zu0
+            for _ in range(rotations):
+                dxu, dyu, dzu = -dzu, -dxu, -dyu
+            xru, yru, zru = dxu + xu0, dyu + yu0, dzu + zu0
+            xr, yr = self.from_cubic(xru, yru, zru)
+            result.append((xr, yr))
+        return result
+
+    # pathfinding
+    def path(self, origin, orientat0, target, moving_costs={}, incl_start=False, limit=10000):
+        nodes = Queue()
+        break_on, iteration = limit, 0
+        
+        
+        origin = PathNode(*origin)
+        origin.orientation = orientat0
+        
+        nodes.put(origin, 0)
+        neighbors = []
+
+        while nodes:
+            current = nodes.get()
+
+            if current == target:
+                path = []
+                previous = current
+                while previous:
+                    if previous != origin or incl_start:
+                        path.insert(0, previous)
+                    previous = previous.parent
+                return path
+
+            neighbors = self.neighbors(*current)
+
+            for x, y in neighbors:
+                
+                if (x, y) == current.parent:
+                    continue
+                
+                iteration += 1
+                if break_on > 0 and iteration >= break_on:
+                    return None
+                
+                moving_cost = moving_costs[(x, y)]
+                if moving_cost >= 1000:
+                    continue
+                
+                d = Grid.direction_to(*current, x, y)
+                diff = abs(Grid.diff_directions(current.orientation, d))
+                if diff > 1:
+                    # change direction one degree at a time
+                    continue
+                    
+                cost = current.cost + moving_cost + diff * 10
+                if diff != 0 and any(moving_costs[c] >= 1000 for c in neighbors):
+                    # a direction change here is dangerous
+                    cost += 50
+                
+                priority = cost + 10 * Grid.manhattan((x, y), target)
+
+                node = PathNode(x, y, current)
+                node.cost = cost
+                node.orientation = d
+                nodes.put(node, priority)
+        else:
+            return None
+
+class Entity(Base):
+    def __init__(self, ent_id):
+        self.id = int(ent_id)
+        self.x, self.y = 0, 0
+        self.args = [0,0,0,0]
+
+    def update(self, x, y, *args):
+        self.x, self.y = int(x), int(y)
+        
+    @property
+    def pos(self):
+        return (self.x, self.y)
+    
+    def __lt__(self, other):
+        # default comparison, used to avoid errors when used with queues and priorities are equals
+        return self.id < other.id
+    
+    
+class Ship(Entity):
+    MAX_SPEED = 2
+    SCOPE = 10
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.x, self.y = 0, 0
+        self.orientation = 0
+        self.speed = 0
+        self.stock = 0
+        self.owned = 0
+        
+        self.next_cell = None
+        self.next_pos = None
+        self.last_fire = None
+        self.last_mining = None
+        self.blocked_since = 0
+        self.same_traject_since = 0
+        self.last_action = ""
+        self.allies = []
+        self._moving_costs = {}
+        
+        self.objectives = ObjectivesQueue()
+        self.ennemies = ObjectivesQueue()
+        
+        self.objective = None
+        self.objective_next = None
+        self.target_ennemy = None
+        
+        self.path = []
+        
+        self.distance = 0
+        self.alignment = 0
+        
+    def __repr__(self):
+        return f"<Ship {self.id}: pos=({self.x}, {self.y}), orientation={self.orientation}, speed={self.speed}, blocked={self.blocked_since}, last_fire={self.last_fire}, next_pos={self.next_pos}, area={self.area}>"
+
+    def update(self, x, y, *args):
+        previous_state = self.state()
+        previous_traject = self.traject()
+        
+        super().update(x, y)
+        self.orientation, self.speed, self.stock, self.owned = map(int, args)
+
+        self.objectives = ObjectivesQueue()
+        self.ennemies = ObjectivesQueue()
+        
+        self.objective = None
+        self.objective_next = None
+        self.target_ennemy = None
+        self.path = []
+        
+        self.area = Ship.get_area(self.x, self.y, self.orientation)
+        self.prow, _, self.stern = self.area
+        
+        self.next_cell = self.get_next_cell()
+        self.next_pos = self.get_next_pos()
+        self.next_area = Ship.get_area(*self.next_pos, self.orientation)
+        
+        self.mobility_zone = list(set(self.area + self.next_area))
+            
+        if self.traject() != previous_traject:
+            self.same_traject_since += 1
+        else:
+            self.same_traject_since = 0
+    
+        if self.state() == previous_state:
+            self.blocked_since += 1
+        else:
+            self.blocked_since = 0
+
+    def traject(self):
+        return (self.orientation, self.speed)
+
+    def state(self):
+        return (self.x, self.y, self.orientation, self.speed)
+
+    @classmethod
+    def get_area(cls, x, y, orientation):
+        dx, dy = Grid.directions(y)[((orientation + 3) % 6)]
+        stern = (x + dx, y + dy)
+        
+        dx, dy = Grid.directions(y)[orientation]
+        prow = (x + dx, y + dy)
+        
+        return [prow, (x, y), stern]
+
+    def get_next_pos(self, in_=1):
+        x, y = self.x, self.y
+        for _ in range(in_):
+            for _ in range(self.speed):
+                dx, dy = Grid.directions(y)[self.orientation]
+                x, y = x + dx, y + dy
+        return x, y
+    
+    def get_next_cell(self, in_=1):
+        x, y = self.x, self.y
+        for _ in range(in_):
+            dx, dy = Grid.directions(y)[self.orientation]
+            x, y = x + dx, y + dy
+        return x, y
+
+    def in_current_direction(self, x, y):
+        return self.orientation == Grid.direction_to(*self.pos, x, y)
+
+    def moving_cost(self, x, y):
+        return self._moving_costs[(x, y)]
+    
+    def move(self, *args, **kwargs):
+        try:
+            self._move(*args, **kwargs)
+            return True
+        except DidNotAct:
+            return False
+
+    def _move(self, path):
+        
+        if path is None:
+            log(f"(!) broken: automove to {goto}")
+            ship.auto_move(*goto)
+            return
+        elif not path:
+            raise DidNotAct()
+        
+        # <--- special: avoid blocking situations
+        if current_turn > 1 and self.blocked_since >= 1:
+            dx, dy = Grid.directions(self.y)[((self.orientation + 1) % 6)]
+            if self.moving_cost(self.x + dx, self.y + dy) <= 50:
+                self.turn_left()
+            else:
+                self.turn_right()
+            return
+        # --->
+        
+        # speed shall be at 1 when arriving on the "flag"
+        next_flag = next((i for i, n in enumerate(path) if n.orientation != self.orientation), None)
+        if next_flag is None:
+            next_flag = len(path)
+        
+        if next_flag < (2 * self.speed):
+            # the end of the path or a direction change is coming
+            diff = Grid.diff_directions(self.orientation, path[0].orientation)
+            
+            # <--- special: avoid the left/right hesitation when stopped
+            if diff and not self.speed and self.last_action in ["STARBOARD",  "PORT"]:
+                self.speed_up()
+                return
+            # --->
+            
+            if diff > 0:
+                self.turn_left()
+                return
+                
+            elif diff < 0:
+                self.turn_right()
+                return
+        
+            elif self.speed > 1:
+                self.slow_down()
+                return
+        
+        else:
+            if not self.speed or (next_flag > (2 * self.speed + 1) and self.speed < self.MAX_SPEED):
+                # long path and no direction change coming: speed up
+                self.speed_up()
+                return
+        
+        raise DidNotAct()
+           
+    def fire_at_will(self, *args, **kwargs):
+        try:
+            self._fire_at_will(*args, **kwargs)
+            return True
+        except DidNotAct:
+            return False
+           
+    def _fire_at_will(self, target, allies = []):
+        if not self.can_fire():
+            raise DidNotAct()
+        
+        log("** fire at will")
+        
+        next_positions = [target.get_next_pos(i) for i in range(1, 3)]
+        log(f"ennemy next pos: {next_positions}")
+        
+        avoid = []
+        if not self in allies:
+            allies.append(self)
+        for ally in allies:
+            avoid += ally.mobility_zone
+
+        log(f"avoid: {avoid}")
+
+        for i, p in enumerate(next_positions):
+            turn = i + 1
+            
+            if p in avoid:
+                continue
+            
+            dist_p = Grid.manhattan(self.prow, p)
+            
+            if dist_p > self.SCOPE:
+                continue
+            
+            if (1 + round(dist_p / 3)) == turn:
+                log(f"Precision: {p}, {dist_p}, {turn}")
+                ship.fire(*p)
+                return
+        
+        next_pos = next_positions[0]
+        dist_p = Grid.manhattan(self.prow, next_pos)
+        if dist_p <= self.SCOPE:
+            ship.fire(*p)
+            return
+        
+        raise DidNotAct()
+            
+    def can_mine(self):
+        return self.last_mining is None or (current_turn - self.last_mining) >= 4
+        
+    def can_fire(self):
+        return self.last_fire is None or (current_turn - self.last_fire) >= 1
+            
+    # --- Basic commands
+    def auto_move(self, x, y):
+        self.last_action = "MOVE"
+        print(f"MOVE {x} {y}")
+        
+    def speed_up(self):
+        self.last_action = "FASTER"
+        print("FASTER")
+        
+    def slow_down(self):
+        self.last_action = "SLOWER"
+        print("SLOWER")    
+    
+    def turn_right(self):
+        self.last_action = "STARBOARD"
+        print("STARBOARD")
+    
+    def turn_left(self):
+        self.last_action = "PORT"
+        print("PORT")
+        
+    def wait(self):
+        self.last_action = "WAIT"
+        print("WAIT")
+        
+    def mine(self):
+        self.last_mining = current_turn
+        self.last_action = "MINE"
+        print("MINE")
+        
+    def fire(self, x, y):
+        self.last_fire = current_turn
+        self.last_action = "FIRE"
+        print(f"FIRE {x} {y}")
+
+class Barrel(Entity):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.amount = 0
+
+        self.dispersal = 0
+        self.mine_threat = False
+        self.ennemy_near = False
+
+    def __repr__(self):
+        return f"<Barrel {self.id}: pos=({self.x}, {self.y}), amount={self.amount}>"
+        
+    def update(self, x, y, *args):
+        super().update(x, y)
+        self.amount = int(args[0])
+
+class Mine(Entity):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.ghost = False
+
+    def __repr__(self):
+        return f"<Mine {self.id}: pos=({self.x}, {self.y}), ghost={self.ghost}>"
+
+class Cannonball(Entity):
+
+    def update(self, x, y, *args):
+        super().update(x, y)
+        self.sender, self.countdown = int(args[0]), int(args[1])
+
+
+entities = {}
+map_entity = {"SHIP": Ship, 
+             "BARREL": Barrel,
+             "MINE": Mine,
+             "CANNONBALL": Cannonball}
+
+grid = Grid()
+
+
+
+### *** Main Loop ***
+
+while True:
+    seen = []
+    current_turn += 1
+    
+    # <--- get input
+    my_ship_count, entity_count = int(input()), int(input())
+    for _ in range(entity_count):
+        ent_id, ent_type, *data = input().split()
+        ent_id = int(ent_id)
+        seen.append(ent_id)
+           
+        if not ent_id in entities:
+            entities[ent_id] = map_entity[ent_type](ent_id)
+               
+        ent = entities[ent_id]
+        ent.update(*data)
+     
+    entities = {k: v for k, v in entities.items() if k in seen}
+    # --->
+    
+    grid.load_entities(entities)
+    
+    log(f"### TURN {current_turn}")
+    
+#     log(f"Owned Ships: {grid.owned_ships}")
+    log(f"Ennemy Ships: {grid.ennemy_ships}")
+#     log(f"Barrels: {grid.barrels}")
+#     log(f"Mines: {grid.mines}")
+    log(f"Cannonballs: {grid.cannonballs}")
+
+
+    ### Evaluate
+    grid.update_moving_costs()
+    
+    ### Acquire
+    log("# Acquiring")
+    
+    # main objective
+    while not all(s.objective for s in grid.owned_ships):
+        try:
+            acquired = sorted([(s, s.objectives.get()) for s in grid.owned_ships if not s.objective], key= lambda x: x[1].interest)
+            
+            for s, o in acquired:
+                if not s.objective and not any(al.objective.target is o.target for al in s.allies):
+                    s.objective = o
+            
+        except IndexError:
+            break
+        
+    # after_that objective
+    for s in grid.owned_ships:
+        if not s.objective: 
+            continue
+        after_that = ObjectivesQueue()
+        for b in grid.barrels:
+            obj = GetBarrel(b)
+            obj.eval(s.objective.target.pos)
+            after_that.put(obj)
+        if after_that:
+            s.objective_next = after_that.get()
+    
+    # targetted ennemy
+    for s in grid.owned_ships:
+        s.target_ennemy = s.ennemies.get()
+        
+    for ship in grid.owned_ships:
+        log(f"Ship {ship.id}: obj: {ship.objective}; next: {ship.objective_next}; target: {ship.target_ennemy}")
+    
+    ### Plan
+    log("# Planning")
+    
+    for ship in grid.owned_ships:
+        
+        log(f"---- ship {ship.id} ---")
+        log(f"ship: {ship}")
+        
+        if ship.objective:
+            goto = ship.objective.target.pos
+        elif ship.target_ennemy:
+            goto = grid.shooting_spot(ship, ship.target_ennemy.target)
+        else:
+            log("ERROR: No target")
+            continue
+        
+        log(f"goto: {goto}")
+        
+        ship.path = grid.path(ship.next_pos, ship.orientation, goto, ship._moving_costs, limit=6000 // len(grid.owned_ships))
+        
+        if ship.objective_next and ship.path:
+            ship.path += grid.path(goto, 
+                                   ship.path[-1].orientation, 
+                                   ship.objective_next.target.pos, 
+                                   ship._moving_costs,
+                                   limit=6000 // len(grid.owned_ships)) or []
+        
+        log(f"path: {ship.path}")
+        
+    ### Process
+    log("# Processing")
+    
+    for ship in grid.owned_ships:
+        if not ship.objective and not ship.target_ennemy:
+            log("No target: wait")
+            ship.wait()
+        
+        if ship.move(ship.path):
+            continue
+        
+        # no movement was required, can fire
+        if ship.fire_at_will(ship.target_ennemy.target, allies=grid.owned_ships):
+            continue
+        
+        log("ERROR: Did not act, wait")
+        ship.wait()