General small optimizations to the core engine.

Author: eriq-augustine

pacai/core/board.py

@@ -359,6 +359,15 @@ def __init__(self,
         self._walls: set[Position] = set()
         """ The walls for this board. """
 
+        self._neighbor_cache: dict[Position, list[tuple[pacai.core.action.Action, Position]]]  = {}
+        """
+        Keep a cache of all neighbor locations.
+        Note that neighbors only depend on the size of the board and walls.
+        Computing neighbors is a high-throughput activity, and therefore justifies a cache.
+        Neighbors will be shallow copied when a board is copied,
+        therefore all successor boards will share the same cache.
+        """
+
         self._nonwall_objects: dict[Marker, set[Position]] = {}
         """ All the non-wall objects that appear on the board. """
 
@@ -533,7 +542,11 @@ def remove_marker(self, marker: Marker, position: Position) -> None:
         self._check_bounds(position)
         self._copy_on_write()
 
-        self._nonwall_objects.get(marker, set()).discard(position)
+        markers = self._nonwall_objects.get(marker)
+        if (markers is None):
+            return
+
+        markers.discard(position)
 
     def place_marker(self, marker: Marker, position: Position) -> None:
         """
@@ -553,8 +566,14 @@ def get_neighbors(self, position: Position) -> list[tuple[pacai.core.action.Acti
         Get positions that are directly touching (via cardinal directions) the given position
         without being inside a wall,
         and the action it would take to get there.
+
+        Note that this is a high-throughput piece of code, and may contain optimizations.
         """
 
+        # Check the neighbor cache.
+        if (position in self._neighbor_cache):
+            return self._neighbor_cache[position]
+
         neighbors = []
         for (action, offset) in CARDINAL_OFFSETS.items():
             neighbor = position.add(offset)
@@ -567,6 +586,9 @@ def get_neighbors(self, position: Position) -> list[tuple[pacai.core.action.Acti
 
             neighbors.append((action, neighbor))
 
+        # Save to the neighbor cache.
+        self._neighbor_cache[position] = neighbors
+
         return neighbors
 
     def get_adjacency(self, position: Position, marker: Marker) -> AdjacencyString:

pacai/core/gamestate.py

@@ -104,9 +104,9 @@ def copy(self) -> 'GameState':
         new_state = copy.copy(self)
 
         new_state.board = self.board.copy()
+        new_state.agent_actions = {agent_index: actions.copy() for (agent_index, actions) in self.agent_actions.items()}
         new_state.move_delays = self.move_delays.copy()
         new_state.tickets = self.tickets.copy()
-        new_state.agent_actions = {agent_index: actions.copy() for (agent_index, actions) in self.agent_actions.items()}
 
         return new_state
 

pacai/core/ticket.py

@@ -6,6 +6,7 @@ class Ticket(pacai.util.json.DictConverter):
     """
     An agent's Ticket determines when they will move next.
     A ticket is a tuple of three values: (next move time, last move time, number of moves).
+    Tickets should be treated as immutable.
     The agent with the lowest ticket (starting with the first value and moving to the next on a tie) gets to move next.
     All "time" values represented by a ticket are abstract and do not relate to any actual time units.
     """

pacai/pacman/gamestate.py

@@ -86,7 +86,7 @@ def is_scared(self, agent_index: int = -1) -> bool:
         if (agent_index == -1):
             agent_index = self.agent_index
 
-        return self.scared_timers.get(agent_index, 0) > 0
+        return ((agent_index in self.scared_timers) and (self.scared_timers[agent_index] > 0))
 
     def compute_move_delay(self, agent_index: int) -> int:
         move_delay = super().compute_move_delay(agent_index)