wip

Author: Debilski

pelita/game.py

@@ -679,8 +679,8 @@ def prepare_bot_state(game_state: GameState, team_idx=None) -> TeamState | TeamI
                 'timeout_length': game_state['timeout_length'],
             }
             return team_state_initial
-        case "RUNNING":
 
+        case "RUNNING":
             turn = game_state['turn']
 
             bot_position = game_state['bots'][turn]
@@ -728,14 +728,12 @@ def prepare_bot_state(game_state: GameState, team_idx=None) -> TeamState | TeamI
                 'team_time': game_state['team_time'][:],
                 'is_noisy': is_noisy,
                 'round': game_state['round'],
-                'turn': turn,
+                'turn': game_state['turn'],
             }
             return bot_state
 
         case "FINISHED":
             # Called for remote players in _exit
-            turn = team_idx
-            # TODO: is turn needed?
 
             team_state_final: TeamStateFinished = {
                 'bots': game_state['bots'][:],
@@ -747,10 +745,14 @@ def prepare_bot_state(game_state: GameState, team_idx=None) -> TeamState | TeamI
                 'food': [list(team_food) for team_food in game_state['food']],
                 'team_time': game_state['team_time'][:],
                 'round': game_state['round'],
-                'turn': turn,
+                'turn': game_state['turn'],
+                'whowins': game_state['whowins']
             }
             return team_state_final
 
+        case "FAILURE":
+            raise PelitaIllegalGameState(game_state)
+
     raise PelitaIllegalGameState("Got bad game_state in prepare_bot_state")
 
 

pelita/player/SmartEatingPlayer.py

@@ -1,10 +1,11 @@
 
 from pelita.game import apply_move, next_round_turn
 from pelita.player import food_eating_player
+from pelita.spec import FullTeamState
 from pelita.team import Bot, _ensure_list_tuples, make_bots
 
 def simulate_move(bot: Bot, next_pos):
-    game_state = bot._game_state
+    game_state: FullTeamState = dict(bot._game_state)
     game_state['bots'] = _ensure_list_tuples(game_state['bots'])
     game_state['error_limit'] = 0
     game_state['gameover'] = False
@@ -14,7 +15,12 @@ def simulate_move(bot: Bot, next_pos):
     game_state['errors'] = [[], []]
     game_state['game_phase'] = 'RUNNING'
 
+    print(bot)
+    print(game_state)
     game_state = apply_move(game_state, next_pos)
+    if not game_state['game_phase'] == 'RUNNING':
+        return None
+
     game_state.update(next_round_turn(game_state))
 
 
@@ -47,8 +53,8 @@ def simulate_move(bot: Bot, next_pos):
 
 
 def smart_eating_player(bot, state):
-
-    print(simulate_move(bot, next_pos=bot.position))
+    for pos in bot.legal_positions:
+        print(simulate_move(bot, next_pos=pos))
 
     # 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)

pelita/spec.py

@@ -84,3 +84,5 @@ class TeamStateFinished(TypedDict):
     round: int|None
     turn: int
 
+class FullTeamState(TeamInitial, TeamState):
+    pass

pelita/team.py

@@ -168,7 +168,7 @@ def __init__(self, team_move: typing.Callable[[typing.Any, typing.Any], typing.T
         self._bot_track = [[], []]
 
 
-    def set_initial(self, team_id, game_state):
+    def set_initial(self, team_id, initial_state):
         """ Sets the bot indices for the team and returns the team name.
         Currently, we do not call _set_initial on the user side.
 
@@ -182,24 +182,26 @@ def set_initial(self, team_id, game_state):
         # Reset the team state
         self._state.clear()
 
-        self._game_state = {}
-        self._game_state.update(game_state)
+        self._team_id = team_id
+
+        self._initial_state = {}
+        self._initial_state.update(initial_state)
 
         # Initialize the random number generator
         # with the seed that we received from game
-        self._rng = Random(game_state['seed'])
+        self._rng = Random(initial_state['seed'])
 
         # Reset the bot tracks
         self._bot_track = [[], []]
 
         # Store the walls, which are only transmitted once
-        self._walls = _ensure_tuple_tuples(game_state['walls'])
+        self._walls = _ensure_tuple_tuples(initial_state['walls'])
 
         # Store the shape, which is only transmitted once
-        self._shape = tuple(game_state['shape'])
+        self._shape = tuple(initial_state['shape'])
 
-        self._team_names = tuple(game_state['team_names'])
-        self._max_rounds = game_state['max_rounds']
+        self._team_names = tuple(initial_state['team_names'])
+        self._max_rounds = initial_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)
@@ -253,8 +255,8 @@ def get_move(self, game_state):
                        rng=self._rng,
                        graph=self._graph)
 
-        self._game_state.update(game_state)
-        me._game_state = self._game_state
+        me._game_state = dict(game_state)
+        me._game_state.update(self._initial_state)
         team = me._team
 
         for idx, mybot in enumerate(team):
@@ -396,7 +398,7 @@ def set_initial(self, team_id, game_state):
         self.request_timeout = timeout_length
 
         msg_id = self.conn.send_req("set_initial", {"team_id": team_id,
-                                                "game_state": game_state})
+                                                "initial_state": game_state})
         reply = self.conn.recv_reply(msg_id, timeout_length)
         # reply should be None