wip

Author: Debilski

pelita/game.py

@@ -15,7 +15,7 @@
 from .network import setup_controller, ZMQPublisher
 from .base_utils import default_rng
 from .team import make_team
-from .spec import GameState
+from .spec import GameState, Layout, Pos
 from .viewer import ProgressViewer, AsciiViewer, ReplyToViewer, ReplayWriter, ResultPrinter
 
 _logger = logging.getLogger(__name__)
@@ -276,7 +276,7 @@ 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),
@@ -324,118 +324,118 @@ def setup_game(team_specs, *, layout_dict, max_rounds=300, rng=None,
 
     # Initialize the game state.
 
-    game_state: GameState = 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
         #: 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': ([], []),
 
         #: Errors
-        errors=[{}, {}],
+        'errors': ({}, {}),
 
         ### Configuration
         #: Maximum number of rounds, int
-        max_rounds=max_rounds,
+        'max_rounds': max_rounds,
 
         #: Time till timeout, int
-        timeout=3,
+        'timeout': 3,
 
         #: 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
     # We then can send the initial maze
@@ -596,20 +596,20 @@ def prepare_bot_state(game_state, idx=None):
         'error_count': [len(e) for e in game_state['errors'][:]],
         '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 bot_initialization:
         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
@@ -1036,8 +1036,8 @@ def check_exit_remote_teams(game_state):
                 pass
 
 
-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/spec.py

@@ -7,6 +7,12 @@
 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
@@ -17,17 +23,17 @@ class GameState(TypedDict):
     gameover: bool
     whowins: None|int
     bots: list[Pos]
-    score: list[int]
+    score: tuple[int, int]
     fatal_errors: tuple[list[Any], list[Any]]
     errors: tuple[Any, Any]
     max_rounds: int
     timeout: int
     noise_radius: int
     sight_distance: int
-    max_food_age: int
+    max_food_age: float|int
     shadow_distance: int
     layout_name: str
-    team_names: tuple[str, str]
+    team_names: tuple[None|str, None|str]
     team_infos: tuple[None|str, None|str]
     team_time: tuple[float, float]
     deaths: list[int]