import math import random import sys from enum import Enum, IntEnum from typing import List, Sequence, Optional, Dict DEFAULT_SHOOT_WAIT = 2 DEFAULT_MINE_WAIT = 4 class EntityType(Enum): BARREL = 'BARREL' SHIP = 'SHIP' MINE = 'MINE' CANNONBALL = 'CANNONBALL' class Orientation(IntEnum): RIGHT, TOP_RIGHT, TOP_LEFT, LEFT, BOTTOM_LEFT, BOTTOM_RIGHT = range(6) class Action(Enum): MINE = 'MINE' MOVE = 'MOVE' FIRE = 'FIRE' WAIT = 'WAIT' SLOWER = 'SLOWER' class GameMap: def __init__(self, barrels: List['Barrel'] = None, my_ships: Dict[int, 'Ship'] = None, opponent_ships: List['Ship'] = None, mines: List['Mine'] = None, cannonballs: List['Cannonball'] = None): if opponent_ships is None: opponent_ships = [] if cannonballs is None: cannonballs = [] if mines is None: mines = [] if my_ships is None: my_ships = {} if barrels is None: barrels = [] self.opponent_ships = opponent_ships self.cannonballs = cannonballs self.mines = mines self.my_ships = my_ships self.barrels = barrels self.map = {} def reset(self): self.opponent_ships = [] self.cannonballs = [] self.mines = [] self.barrels = [] self.map = {} def add_opponent_ship(self, opponent: 'Ship'): self.opponent_ships.append(opponent) self._add_to_map(opponent) def add_my_ship(self, ship: 'Ship'): my_ship = self.my_ships.get(ship.id, None) if my_ship: my_ship.x = ship.x my_ship.y = ship.y my_ship.orientation = ship.orientation my_ship.speed = ship.speed my_ship.stock = ship.stock else: self.my_ships[ship.id] = ship self._add_to_map(ship) def add_mine(self, mine: 'Mine'): self.mines.append(mine) self._add_to_map(mine) def add_barrel(self, barrel: 'Barrel'): self.barrels.append(barrel) self._add_to_map(barrel) def add_cannonball(self, cannonball: 'Cannonball'): self.cannonballs.append(cannonball) self._add_to_map(cannonball) def _add_to_map(self, entity: 'Entity'): self.map[entity.coord] = entity def get_at(self, tile: 'Tile'): return self.map.get(tile.coord, Tile(tile.x, tile.y)) class Tile: def __init__(self, x: int, y: int): self.y = y self.x = x def distance(self, other: 'Tile') -> float: return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5 @property def coord(self): return '{};{}'.format(self.x, self.y) def top_left(self): y = self.y - 1 x = self.x if self.y % 2 == 0: x -= 1 return Tile(x, y) def top_right(self): y = self.y - 1 x = self.x if self.y % 2 != 0: x += 1 return Tile(x, y) def left(self): return Tile(self.x - 1, self.y) def right(self): return Tile(self.x + 1, self.y) def bottom_left(self): y = self.y + 1 x = self.x if self.y % 2 == 0: x -= 1 return Tile(x, y) def bottom_right(self): y = self.y + 1 x = self.x if self.y % 2 != 0: x += 1 return Tile(x, y) def __repr__(self): return 'Tile(x={}, y={})'.format(self.x, self.y) class Entity(Tile): def __init__(self, game_map: GameMap, entity_id: int, x: int, y: int): super().__init__(x, y) self.game_map = game_map self.id = entity_id @property def nearest_barrel(self) -> Optional['Barrel']: return self.nearest(self.game_map.barrels) @property def nearest_opponent(self) -> Optional['Ship']: return self.nearest(self.game_map.opponent_ships) @property def nearest_mine(self) -> Optional['Mine']: return self.nearest(self.game_map.mines) def nearest(self, entities: Sequence['Entity']) -> Optional['Entity']: nearest = None best_dist = math.inf for entity in entities: dist = self.distance(entity) if dist < best_dist: best_dist = dist nearest = entity return nearest def __repr__(self): return 'Entity(id={}, x={}, y={})'.format(self.id, self.x, self.y) class Barrel(Entity): def __init__(self, game_map: GameMap, entity_id: int, x: int, y: int, quantity: int): super().__init__(game_map, entity_id, x, y) self.quantity = quantity def __repr__(self): return 'Barrel(id={}, x={}, y={}, quantity={})'.format(self.id, self.x, self.y, self.quantity) class Ship(Entity): def __init__(self, game_map: GameMap, entity_id: int, x: int, y: int, orientation: int, speed: int, stock: int, mine: bool = True): super().__init__(game_map, entity_id, x, y) self.orientation = Orientation(orientation) self.speed = speed self.stock = stock self.mine = mine self.mine_wait = DEFAULT_MINE_WAIT self.shoot_wait = DEFAULT_SHOOT_WAIT def play_turn(self): action = None target = None rand = random.random() perr('rand', rand) perr('pos', self.tile) perr('mine_wait', self.mine_wait) perr('shoot_wait', self.shoot_wait) perr('on path', self.tiles_on_path) perr('distance oppo', self.distance(self.nearest_opponent)) for tile in self.tiles_on_path: if isinstance(tile, Mine) or isinstance(tile, Cannonball): action, target = self.avoid(tile) break if not action: if 0.2 < rand <= 0.4 and self.shoot_wait <= 0 and self.distance(self.nearest_opponent.tiles_on_path[-1]) < 10: action = Action.FIRE target = self.nearest_opponent.tiles_on_path[-1] elif rand <= 0.2 and self.mine_wait <= 0: action = Action.MINE else: target = Tile(random.randint(0, 23), random.randint(0, 21)) if self.game_map.barrels: target = self.nearest_barrel action = Action.MOVE if action is Action.MINE: self.mine_wait = DEFAULT_MINE_WAIT elif action is Action.FIRE: self.shoot_wait = DEFAULT_SHOOT_WAIT if target: print('{} {} {}'.format(action.value, target.x, target.y)) else: print(action.value) self.mine_wait -= 1 self.shoot_wait -= 1 def avoid(self, tile: Tile): action = Action.MOVE target = None if self.orientation is Orientation.RIGHT: target = tile.top_left() elif self.orientation is Orientation.TOP_RIGHT: target = tile.left() elif self.orientation is Orientation.TOP_LEFT: target = tile.bottom_left() elif self.orientation is Orientation.LEFT: target = tile.bottom_right() elif self.orientation is Orientation.BOTTOM_LEFT: target = tile.right() elif self.orientation is Orientation.BOTTOM_RIGHT: target = tile.top_right() return action, target @property def tile(self): return Tile(self.x, self.y) @property def tiles_on_path(self): tile = self.tile tiles = [tile] if self.speed == 0: return tiles for _ in range(self.speed + 2): if self.orientation is Orientation.RIGHT: tile = tile.right() elif self.orientation is Orientation.TOP_RIGHT: tile = tile.top_right() elif self.orientation is Orientation.TOP_LEFT: tile = tile.top_left() elif self.orientation is Orientation.LEFT: tile = tile.left() elif self.orientation is Orientation.BOTTOM_LEFT: tile = tile.bottom_left() elif self.orientation is Orientation.BOTTOM_RIGHT: tile = tile.bottom_right() tiles.append(self.game_map.get_at(tile)) return tiles def __repr__(self): return ('Ship(id={}, x={}, y={}, orientation={}, speed={}, stock={}, mine={})' .format(self.id, self.x, self.y, self.orientation, self.speed, self.stock, self.mine)) class Mine(Entity): def __init__(self, game_map: GameMap, entity_id: int, x: int, y: int): super().__init__(game_map, entity_id, x, y) def __repr__(self): return 'Mine(id={}, x={}, y={})'.format(self.id, self.x, self.y) class Cannonball(Entity): def __init__(self, game_map: GameMap, entity_id: int, x: int, y: int, shooter_id: int, turns_before_impact: int): super().__init__(game_map, entity_id, x, y) self.turns_before_impact = turns_before_impact self.shooter_id = shooter_id def __repr__(self): return 'Barrel(id={}, x={}, y={}, shooter={}, before_impact={})'.format(self.id, self.x, self.y, self.shooter_id, self.turns_before_impact) def main(): random.seed() game_map = GameMap() while True: my_ship_count = int(input()) # the number of remaining ships entity_count = int(input()) # the number of entities (e.g. ships, mines or cannonballs) game_map.reset() # Fetch info for i in range(entity_count): entity_id, entity_type, x, y, arg_1, arg_2, arg_3, arg_4 = input().split() entity_id = int(entity_id) x = int(x) y = int(y) entity_type = EntityType(entity_type) if entity_type is EntityType.BARREL: rhum_quantity = int(arg_1) game_map.add_barrel(Barrel(game_map, entity_id, x, y, rhum_quantity)) elif entity_type is EntityType.SHIP: orientation = int(arg_1) speed = int(arg_2) rhum_stock = int(arg_3) mine = int(arg_4) == 1 ship = Ship(game_map, entity_id, x, y, orientation, speed, rhum_stock, mine) if mine: game_map.add_my_ship(ship) else: game_map.add_opponent_ship(ship) elif entity_type is EntityType.MINE: game_map.add_mine(Mine(game_map, entity_id, x, y)) elif entity_type is EntityType.CANNONBALL: shooter_id = int(arg_1) turns_before_impact = int(arg_2) game_map.add_cannonball(Cannonball(game_map, entity_id, x, y, shooter_id, turns_before_impact)) perr('detected cannonball', Cannonball(game_map, entity_id, x, y, shooter_id, turns_before_impact)) perr(game_map.map) # Play for ship in game_map.my_ships.values(): ship.play_turn() def perr(*args): print(*args, file=sys.stderr, flush=True) if __name__ == '__main__': main()