|
|
|
#!/usr/bin/env python3
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Callable, Iterable, Optional, List, Set
|
|
|
|
import collections
|
|
|
|
import enum
|
|
|
|
import json
|
|
|
|
import sys
|
|
|
|
|
|
|
|
|
|
|
|
# Třídy reprezentující hru
|
|
|
|
|
|
|
|
class Direction(enum.Enum):
|
|
|
|
UP = 0
|
|
|
|
LEFT = 1
|
|
|
|
DOWN = 2
|
|
|
|
RIGHT = 3
|
|
|
|
STAY = None
|
|
|
|
|
|
|
|
def combine(self, other) -> Direction:
|
|
|
|
return Direction((self.value + other.value)%4)
|
|
|
|
|
|
|
|
def invert(self) -> Direction:
|
|
|
|
if self == Direction.STAY:
|
|
|
|
return self
|
|
|
|
return self.combine(Direction.DOWN)
|
|
|
|
|
|
|
|
def __str__(self) -> str:
|
|
|
|
return self.name.lower()
|
|
|
|
|
|
|
|
|
|
|
|
class Team:
|
|
|
|
home: 'Field'
|
|
|
|
|
|
|
|
def __init__(self, id: int, is_me: bool) -> None:
|
|
|
|
self.id: int = id
|
|
|
|
self.is_me = is_me
|
|
|
|
self.protected_fields: List[Field] = []
|
|
|
|
self.occupied: List[Field] = []
|
|
|
|
self.members: List[Member] = []
|
|
|
|
|
|
|
|
def __eq__(self, other: Field) -> bool:
|
|
|
|
return (self.id) == (other.id)
|
|
|
|
|
|
|
|
def __hash__(self) -> int:
|
|
|
|
return hash(self.id)
|
|
|
|
|
|
|
|
|
|
|
|
class Member:
|
|
|
|
def __init__(self, field: Field, team: int, id: int) -> None:
|
|
|
|
self.field = field
|
|
|
|
self.team = team
|
|
|
|
self.id = id
|
|
|
|
self.action = Direction.STAY
|
|
|
|
|
|
|
|
|
|
|
|
class Field:
|
|
|
|
members: List[Member]
|
|
|
|
|
|
|
|
def __init__(self, i: int, j: int, hill: bool,
|
|
|
|
home_for_team: Optional[Team],
|
|
|
|
occupied_by_team: Optional[Team],
|
|
|
|
protected_for_team: Optional[Team],) -> None:
|
|
|
|
self.i: int = i
|
|
|
|
self.j: int = j
|
|
|
|
self.hill: bool = hill
|
|
|
|
self.home_for_team: Optional[Team] = home_for_team
|
|
|
|
self.occupied_by_team: Optional[Team] = occupied_by_team
|
|
|
|
self.protected_for_team: Optional[Team] = protected_for_team
|
|
|
|
|
|
|
|
def __eq__(self, other: Field) -> bool:
|
|
|
|
return (self.i, self.j) == (other.i, other.j)
|
|
|
|
|
|
|
|
def __hash__(self) -> int:
|
|
|
|
return hash((self.i, self.j))
|
|
|
|
|
|
|
|
def get_neighbour_field(self, action: Direction) -> Field:
|
|
|
|
if action == Direction.UP:
|
|
|
|
neighbour_i = self.i - 1
|
|
|
|
neighbour_j = self.j
|
|
|
|
elif action == Direction.DOWN:
|
|
|
|
neighbour_i = self.i + 1
|
|
|
|
neighbour_j = self.j
|
|
|
|
elif action == Direction.LEFT:
|
|
|
|
neighbour_i = self.i
|
|
|
|
neighbour_j = self.j - 1
|
|
|
|
elif action == Direction.RIGHT:
|
|
|
|
neighbour_i = self.i
|
|
|
|
neighbour_j = self.j + 1
|
|
|
|
else:
|
|
|
|
neighbour_i = self.i
|
|
|
|
neighbour_j = self.j
|
|
|
|
# ensure coords are in bounds
|
|
|
|
neighbour_i %= len(state.world)
|
|
|
|
neighbour_j %= len(state.world[0])
|
|
|
|
return state.world[neighbour_i][neighbour_j]
|
|
|
|
|
|
|
|
def is_accessible(self, team: Team) -> bool:
|
|
|
|
"""If this field is accessible for the given team."""
|
|
|
|
|
|
|
|
if self.hill:
|
|
|
|
return False
|
|
|
|
if (self.protected_for_team is not None and
|
|
|
|
self.protected_for_team != team):
|
|
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
|
|
# Celý stav hry včetně parsování a vypisování
|
|
|
|
|
|
|
|
class State:
|
|
|
|
def __init__(self, state: dict) -> None:
|
|
|
|
self.teams = [Team(i, i==state["team_id"]) for i in range(state["teams_count"])]
|
|
|
|
self.world = self._parse_world(state["state"]["world"])
|
|
|
|
self.my_team: Team = self.teams[state["team_id"]]
|
|
|
|
self.round_number: int = state["round"]
|
|
|
|
self.time_to_response: Optional[int] = state["time_to_response"]
|
|
|
|
|
|
|
|
def _parse_world(self, world: dict) -> List[List[Field]]:
|
|
|
|
def get_team(team_id):
|
|
|
|
return None if team_id is None else self.teams[team_id]
|
|
|
|
|
|
|
|
fields = []
|
|
|
|
for i, row in enumerate(world):
|
|
|
|
fields_row = []
|
|
|
|
for j, field in enumerate(row):
|
|
|
|
parsed_field = Field(
|
|
|
|
i, j,
|
|
|
|
field["hill"],
|
|
|
|
get_team(field["home_for_team"]),
|
|
|
|
get_team(field["occupied_by_team"]),
|
|
|
|
get_team(field["protected_for_team"]),
|
|
|
|
)
|
|
|
|
if parsed_field.home_for_team:
|
|
|
|
parsed_field.home_for_team.home = parsed_field
|
|
|
|
if parsed_field.occupied_by_team:
|
|
|
|
parsed_field.occupied_by_team.occupied.append(parsed_field)
|
|
|
|
if parsed_field.protected_for_team:
|
|
|
|
parsed_field.protected_for_team.protected_fields.append(parsed_field)
|
|
|
|
members = []
|
|
|
|
for member in field["members"]:
|
|
|
|
m = Member(
|
|
|
|
parsed_field,
|
|
|
|
self.teams[member["team"]],
|
|
|
|
member["id"],
|
|
|
|
)
|
|
|
|
members.append(m)
|
|
|
|
m.team.members.append(m)
|
|
|
|
parsed_field.members = members
|
|
|
|
fields_row.append(parsed_field)
|
|
|
|
|
|
|
|
fields.append(fields_row)
|
|
|
|
return fields
|
|
|
|
|
|
|
|
|
|
|
|
def build_turn(self) -> dict:
|
|
|
|
for team in self.teams:
|
|
|
|
if not team.is_me:
|
|
|
|
for member in team.members:
|
|
|
|
if member.action is not Direction.STAY:
|
|
|
|
raise Exception("Akce přiřazena cizímu týmu")
|
|
|
|
return {
|
|
|
|
"members": [
|
|
|
|
{"id": member.id, "action": str(member.action)}
|
|
|
|
for member in self.my_team.members
|
|
|
|
]
|
|
|
|
}
|
|
|
|
|
|
|
|
state: State
|
|
|
|
|
|
|
|
# Algoritmy
|
|
|
|
|
|
|
|
def find_fields(predicate: Callable[[Field], bool]) -> List[Field]:
|
|
|
|
"""Find all fields that satisfy the given predicate."""
|
|
|
|
|
|
|
|
result = []
|
|
|
|
for row in state.world:
|
|
|
|
for field in row:
|
|
|
|
if predicate(field):
|
|
|
|
result.append(field)
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
|
|
def pathfind(member: Member, goal: Field) -> Direction:
|
|
|
|
"""Find the shortest path from member position to goal.
|
|
|
|
|
|
|
|
Returns the first action to take.
|
|
|
|
If there is no path, returns Action.STAY.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# BFS from goal to member
|
|
|
|
# this direction makes it easier to realize that no path exists
|
|
|
|
explored: Set[Field] = set()
|
|
|
|
queue = collections.deque([goal])
|
|
|
|
while queue:
|
|
|
|
field = queue.popleft()
|
|
|
|
for action in Direction:
|
|
|
|
neighbour = field.get_neighbour_field(action)
|
|
|
|
if (neighbour in explored or
|
|
|
|
not neighbour.is_accessible(member.team)):
|
|
|
|
continue
|
|
|
|
if neighbour == member.field:
|
|
|
|
return action.invert()
|
|
|
|
queue.append(neighbour)
|
|
|
|
explored.add(neighbour)
|
|
|
|
return Direction.STAY
|
|
|
|
|
|
|
|
# main (zde doplňte kód)
|
|
|
|
|
|
|
|
def main() -> None:
|
|
|
|
global state
|
|
|
|
state = State(json.loads(sys.stdin.read()))
|
|
|
|
|
|
|
|
# TODO: set actions for all yours members
|
|
|
|
# example: all members go up
|
|
|
|
for member in state.teams[1].members:
|
|
|
|
member.action = Direction.UP
|
|
|
|
|
|
|
|
print(json.dumps(state.build_turn()))
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
main()
|