WIP: Typing

Author: Debilski

pelita/game.py

@@ -16,6 +16,7 @@
 from .gamestate_filters import noiser, relocate_expired_food, update_food_age, in_homezone
 from .layout import get_legal_positions, initial_positions
 from .network import Controller, RemotePlayerFailure, RemotePlayerRecvTimeout, RemotePlayerSendError, ZMQPublisher
+from .spec import GameState, Layout, Pos
 from .team import RemoteTeam, make_team
 from .viewer import (AsciiViewer, ProgressViewer, ReplayWriter, ReplyToViewer,
                      ResultPrinter)
@@ -280,11 +281,11 @@ def setup_viewers(viewers, print_result=True):
     return viewer_state
 
 
-def setup_game(team_specs, *, layout_dict, max_rounds=300, rng=None,
+def setup_game(team_specs, *, layout_dict: Layout, max_rounds=300, rng=None,
                allow_camping=False, error_limit=5, timeout_length=3,
                viewers=None, store_output=False,
                team_names=(None, None), team_infos=(None, None),
-               raise_bot_exceptions=False, print_result=True):
+               raise_bot_exceptions=False, print_result=True) -> GameState:
     """ Generates a game state for the given teams and layout with otherwise default values. """
     if viewers is None:
         viewers = []
@@ -328,124 +329,124 @@ def setup_game(team_specs, *, layout_dict, max_rounds=300, rng=None,
 
     # Initialize the game state.
 
-    game_state = dict(
+    game_state: GameState = {
         ### The layout attributes
         #: Walls. Set of (int, int)
-        walls=set(layout_dict['walls']),
+        'walls': set(layout_dict['walls']),
 
         #: Shape of the maze. (int, int)
-        shape=layout_dict['shape'],
+        'shape': layout_dict['shape'],
 
         #: Food per team. List of sets of (int, int)
-        food=food,
+        'food': food,
 
         #: Food ages per team. Dict of (int, int) to int
-        food_age=[{}, {}],
+        'food_age': ({}, {}),
 
         ### Round/turn information
         #: Phase
-        game_phase='INIT',
+        'game_phase': 'INIT',
 
         #: Current bot, int, None
-        turn=None,
+        'turn': None,
 
         #: Current round, int, None
-        round=None,
+        'round': None,
 
         #: Is the game finished? bool
-        gameover=False,
+        'gameover': False,
 
         #: Who won? int, None
-        whowins=None,
+        'whowins': None,
 
         ### Bot/team status
         #: Positions of all bots. List of (int, int)
-        bots=layout_dict['bots'][:],
+        'bots': layout_dict['bots'][:],
 
         #: Score of the teams. List of int
-        score=[0] * 2,
+        'score': (0, 0),
 
         #: Fatal errors
-        fatal_errors=[[], []],
+        'fatal_errors': ([], []),
 
         #: Number of timeouts for a team
-        timeouts=[{}, {}],
+        'timeouts': ({}, {}),
 
         ### Configuration
         #: Maximum number of rounds, int
-        max_rounds=max_rounds,
+        'max_rounds': max_rounds,
 
         #: Time till timeout, int
-        timeout=3,
+        'timeout': 3,
 
         #: Initial timeout, int
-        initial_timeout=6,
+        'initial_timeout': 6,
 
         #: Noise radius, int
-        noise_radius=NOISE_RADIUS,
+        'noise_radius': NOISE_RADIUS,
 
         #: Sight distance, int
-        sight_distance=SIGHT_DISTANCE,
+        'sight_distance': SIGHT_DISTANCE,
 
         #: Max food age
-        max_food_age=max_food_age,
+        'max_food_age': max_food_age,
 
         #: Shadow distance, int
-        shadow_distance=SHADOW_DISTANCE,
+        'shadow_distance': SHADOW_DISTANCE,
 
         ### Informative
 
         #: Name of the teams. Tuple of str
-        team_names=team_names,
+        'team_names': team_names,
 
         #: Additional team info. Tuple of str|None
-        team_infos=team_infos,
+        'team_infos': team_infos,
 
         #: Time each team needed, list of float
-        team_time=[0, 0],
+        'team_time': [0.0, 0.0],
 
         # List of bot deaths, which counts the number of deaths per bot
         # In other words, deaths[bot_idx] is the number of times the bot
         # bot_idx has been killed until now.
-        deaths = [0]*4,
+        'deaths': [0] * 4,
 
         # List of bot kills, which counts the number of kills per bot
         # In other words, kills[bot_idx] is the number of times the bot
         # bot_idx has killed another bot until now.
-        kills = [0]*4,
+        'kills': [0] * 4,
 
         # List of boolean flags weather bot has been eaten since its last move
-        bot_was_killed = [False]*4,
+        'bot_was_killed':  [False]*4,
 
         # The noisy positions that the bot in `turn` has currently been shown.
         # None, if not noisy
-        noisy_positions = [None] * 4,
+        'noisy_positions':  [None] * 4,
 
         #: The moves that the bots returned. Keeps only the recent one at the respective bot’s index.
-        requested_moves=[None] * 4,
+        'requested_moves': [None] * 4,
 
         #: Messages the bots say. Keeps only the recent one at the respective bot’s index.
-        say=[""] * 4,
+        'say': [""] * 4,
 
         ### Internal
         #: Internal team representation
-        teams=[None] * 2,
+        'teams': [None] * 2,
 
         #: Random number generator
-        rng=rng,
+        'rng': rng,
 
         #: Timeout length, int, None
-        timeout_length=timeout_length,
+        'timeout_length': timeout_length,
 
         #: Error limit. A team loses when the limit is reached, int
-        error_limit=error_limit,
+        'error_limit': error_limit,
 
         #: Viewers, list
-        viewers=viewer_state['viewers'],
+        'viewers': viewer_state['viewers'],
 
         #: Controller
-        controller=viewer_state['controller']
-    )
+        'controller': viewer_state['controller']
+    }
 
 
     # Wait until the controller tells us that it is ready
@@ -711,20 +712,20 @@ def prepare_bot_state(game_state, team_idx=None):
         'error_count': [len(e) for e in game_state['timeouts'][:]],
         'food': [list(team_food) for team_food in game_state['food']],
         'shaded_food': shaded_food,
-        'team_names': game_state['team_names'][:],
         'team_time': game_state['team_time'][:],
         'is_noisy': is_noisy,
         'round': game_state['round'],
         'turn': turn,
         'timeout_length': game_state['timeout_length'],
-        'max_rounds': game_state['max_rounds'],
     }
 
     if game_state['game_phase'] == 'INIT':
         bot_state.update({
             'walls': game_state['walls'], # only in initial round
             'shape': game_state['shape'], # only in initial round
-            'seed': seed # only used in set_initial phase
+            'seed': seed, # only used in set_initial phase
+            'max_rounds': game_state['max_rounds'],
+            'team_names': game_state['team_names'][:],
         })
 
     return bot_state
@@ -787,7 +788,8 @@ def prepare_viewer_state(game_state):
 
     return viewer_state
 
-def play_turn(game_state, raise_bot_exceptions=False):
+
+def play_turn(game_state: GameState, raise_bot_exceptions=False):
     """ Plays the next turn of the game.
 
     This function increases the round and turn counters, requests a move
@@ -910,7 +912,7 @@ def apply_bot_kills(game_state):
 
     return state
 
-def apply_move(gamestate, bot_position):
+def apply_move(gamestate: GameState, bot_position):
     """Plays a single step of a bot by applying the game rules to the game state. The rules are:
     - if the playing team has an error count of >4 or a fatal error they lose
     - a legal step must not be on a wall, else the error count is increased by 1 and a random move is chosen for the bot
@@ -1184,8 +1186,8 @@ def exit_remote_teams(game_state):
 
 
 
-def split_food(width, food):
-    team_food = [set(), set()]
+def split_food(width, food: list[Pos]):
+    team_food: tuple[set[Pos], set[Pos]] = (set(), set())
     for pos in food:
         idx = pos[0] // (width // 2)
         team_food[idx].add(pos)

pelita/player/SmartEatingPlayer.py

@@ -1,8 +1,55 @@
 
+from pelita.game import apply_move, next_round_turn
 from pelita.player import food_eating_player
+from pelita.team import Bot, _ensure_list_tuples, make_bots
+
+def simulate_move(bot: Bot, next_pos):
+    game_state = bot._game_state
+    game_state['bots'] = _ensure_list_tuples(game_state['bots'])
+    game_state['error_limit'] = 0
+    game_state['gameover'] = False
+    game_state['walls'] = bot.walls
+    game_state['shape'] = bot.shape
+    game_state['fatal_errors'] = [[], []]
+    game_state['errors'] = [[], []]
+    game_state['game_phase'] = 'RUNNING'
+
+    game_state = apply_move(game_state, next_pos)
+    game_state.update(next_round_turn(game_state))
+
+
+    for tidx in range(2):
+        game_state['food'][tidx] = _ensure_list_tuples(game_state['food'][tidx])
+        game_state['shaded_food'][tidx] = _ensure_list_tuples(game_state['shaded_food'][tidx])
+
+    next_bot = make_bots(bot_positions=game_state['bots'],
+                        is_noisy=game_state['is_noisy'],
+                        walls=bot.walls,
+                        shape=bot.shape,
+                        food=game_state['food'],
+                        shaded_food=game_state['shaded_food'],
+                        round=game_state['round'],
+                        turn=game_state['turn'],
+                        score=game_state['score'],
+                        deaths=game_state['deaths'],
+                        kills=game_state['kills'],
+                        bot_was_killed=game_state['bot_was_killed'],
+                        error_count=game_state['error_count'],
+                        initial_positions=[bot._initial_position, bot.other._initial_position, bot._initial_position, bot.other._initial_position],
+                        homezone=[bot.other.homezone, bot.homezone],
+                        team_names=game_state['team_names'],
+                        team_time=game_state['team_time'],
+                        rng="bot._rng",
+                        graph=bot.graph)
+
+    return next_bot
+
 
 
 def smart_eating_player(bot, state):
+
+    print(simulate_move(bot, next_pos=bot.position))
+
     # food eating player but won’t do kamikaze (although a sufficiently smart
     # enemy will be able to kill the bot in its next turn as it doesn’t flee)
     next_pos = food_eating_player(bot, state)

pelita/spec.py

@@ -0,0 +1,51 @@
+from typing import Literal, TypeAlias, TypedDict, Any
+from random import Random
+
+from .team import Team
+
+Shape: TypeAlias = tuple[int, int]
+Pos: TypeAlias = tuple[int, int]
+FoodAges: TypeAlias = dict[Pos, int]
+
+class Layout(TypedDict):
+    bots: list[Pos]
+    walls: set[Pos]
+    shape: Shape
+    food: tuple[set[Pos], set[Pos]]
+
+class GameState(TypedDict):
+    walls: set[Pos]
+    shape: Shape
+    food: tuple[set[Pos], set[Pos]]
+    food_age: tuple[FoodAges, FoodAges]
+    game_phase: Literal["INIT", "RUNNING", "FAILURE", "FINISHED"]
+    turn: None|int
+    round: None|int
+    gameover: bool
+    whowins: None|int
+    bots: list[Pos]
+    score: tuple[int, int]
+    fatal_errors: tuple[list[Any], list[Any]]
+    timeouts: tuple[Any, Any]
+    max_rounds: int
+    timeout: int
+    initial_timeout: int
+    noise_radius: int
+    sight_distance: int
+    max_food_age: float|int
+    shadow_distance: int
+    team_names: tuple[None|str, None|str]
+    team_infos: tuple[None|str, None|str]
+    team_time: list[float]
+    deaths: list[int]
+    kills: list[int]
+    bot_was_killed: list[bool]
+    noisy_positions: list[None|Pos]
+    requested_moves: list[None|Pos]
+    say: list[str]
+    teams: list[None|Team]
+    rng: Random
+    timeout_length: int
+    error_limit: int
+    viewers: list[Any]
+    controller: None|Any

pelita/team.py

@@ -181,6 +181,9 @@ def set_initial(self, team_id, game_state):
         # Reset the team state
         self._state.clear()
 
+        self._game_state = {}
+        self._game_state.update(game_state)
+
         # Initialize the random number generator
         # with the seed that we received from game
         self._rng = Random(game_state['seed'])
@@ -194,6 +197,9 @@ def set_initial(self, team_id, game_state):
         # Store the shape, which is only transmitted once
         self._shape = tuple(game_state['shape'])
 
+        self._team_names = tuple(game_state['team_names'])
+        self._max_rounds = game_state['max_rounds']
+
         # Cache the initial positions so that we don’t have to calculate them at each step
         self._initial_positions = layout.initial_positions(self._walls, self._shape)
 
@@ -241,11 +247,13 @@ def get_move(self, game_state):
                        error_count=game_state['error_count'],
                        initial_positions=self._initial_positions,
                        homezone=self._homezone,
-                       team_names=game_state['team_names'],
+                       team_names=self._team_names,
                        team_time=game_state['team_time'],
                        rng=self._rng,
                        graph=self._graph)
 
+        self._game_state.update(game_state)
+        me._game_state = self._game_state
         team = me._team
 
         for idx, mybot in enumerate(team):