Move work on the core engine.

Author: eriq-augustine

pacai/core/agent.py

@@ -3,22 +3,27 @@
 
 import pacai.core.action
 import pacai.core.gamestate
+import pacai.core.time
 
 DEFAULT_MOVE_DELAY: int = 100
-""" The defaut delay between agent moves. """
+""" The default delay between agent moves. """
 
 class AgentArguments:
-    def __init__(self, name: str = '', move_delay: int = DEFAULT_MOVE_DELAY, **kwargs) -> None:
-        self.name: str = name.strip()
-        self.move_delay: int = move_delay
-        self.other_arguments: dict[str, typing.Any] = kwargs
-
-        if (len(self.name) == 0):
+    def __init__(self, name: str = '',
+            move_delay: int = DEFAULT_MOVE_DELAY,
+            **kwargs) -> None:
+        name = name.strip()
+        if (len(name) == 0):
             raise ValueError("Agent name cannot be empty.")
 
-        if (self.move_delay <= 0):
+        if (move_delay <= 0):
             raise ValueError("Agent move delay must be > 0.")
 
+        self.name: str = name
+        self.move_delay: int = move_delay
+
+        self.other_arguments: dict[str, typing.Any] = kwargs
+
 class Agent(abc.ABC):
     """ The base for all agents in the pacai system. """
 
@@ -43,12 +48,12 @@ def get_action(self, state: pacai.core.gamestate.GameState) -> pacai.core.action
 
     # TEST
     @abc.abstractmethod
-    def game_start(self, agent_index: int, game_state: pacai.core.gamestate.GameState) -> None:
+    def game_start(self, agent_index: int, suggested_seed: int, initial_state: pacai.core.gamestate.GameState) -> None:
         pass
 
     # TEST
     @abc.abstractmethod
-    def game_complete(self, game_state: pacai.core.gamestate.GameState) -> None:
+    def game_complete(self, final_state: pacai.core.gamestate.GameState) -> None:
         pass
 
 class Ticket(typing.NamedTuple):
@@ -68,6 +73,33 @@ class Ticket(typing.NamedTuple):
     num_moves: int
     """ The total number of times this agent has moved so far. """
 
+    def next(self, move_delay: int) -> 'Ticket':
+        """ Get the next ticket in the sequence for this agent. """
+
+        return Ticket(
+            next_time = self.next_time + move_delay,
+            last_time = self.next_time,
+            num_moves = self.num_moves + 1,
+        )
+
+class ActionRecord(typing.NamedTuple):
+    """
+    The result of requesting an action from an agent.
+    Aside from the action, this also includes timing and crashing information.
+    """
+
+    agent_index: int
+    """ The index of the agent making this action. """
+
+    action: pacai.core.action.Action
+    """ The action returned by the agent (or pacai.core.action.STOP on a crash). """
+
+    duration: pacai.core.time.Duration
+    """ The duration (in MS) the agent took to compute this action. """
+
+    crashed: bool
+    """ Whether or not the agent crashed (e.g., raised an exception) when computing this action. """
+
 def load(arguments: AgentArguments) -> Agent:
     # TEST
     raise NotImplementedError()

pacai/core/game.py

@@ -1,28 +1,21 @@
 import abc
+import logging
 import random
 
 import pacai.core.action
 import pacai.core.agent
 import pacai.core.isolation
 import pacai.core.time
 
-class MoveHistoryRecord:
-    """ A record of a single move made by an agent. """
-
-    def __init__(self, index: int, action: pacai.core.action.Action, duration: pacai.core.time.Duration) -> None:
-        self.index: int = index
-        """ The index of the agent making this move. """
-
-        self.action: pacai.core.action.Action = action
-        """ The action made by the agent. """
-
-        self.duration: pacai.core.time.Duration = duration
-        """ How long the agent took to compute the this move. """
-
 class GameResult:
     """ The result of running a game. """
 
     def __init__(self, id: int, seed: int, agent_args: list[pacai.core.agent.AgentArguments]) -> None:
+        """
+        Create a new game result.
+        This class is mutable and will be modified as the game progresses.
+        """
+
         self.id: int = id
         """ The ID of the game. """
 
@@ -32,9 +25,14 @@ def __init__(self, id: int, seed: int, agent_args: list[pacai.core.agent.AgentAr
         self.agent_args: list[pacai.core.agent.AgentArguments] = []
         """ The arguments used to construct each agent. """
 
-        self.history: list[MoveHistoryRecord] = []
+        self.history: list[pacai.core.agent.ActionRecord] = []
         """ The history of actions taken by each agent in this game. """
 
+    def add_action(self, action_record: pacai.core.agent.ActionRecord) -> None:
+        """ Add an action to the result's game history. """
+
+        self.history.append(action_record)
+
 class Game(abc.ABC):
     """
     A game that can be run in pacai.
@@ -71,14 +69,23 @@ def _setup(self) -> None:
         pass
 
     @abc.abstractmethod
-    def process_move(self, move: MoveHistoryRecord) -> None:
-        """ Process the given move and update the game's state. """
+    def get_initial_state(self, rng: random.Random) -> pacai.core.gamestate.GameState:
+        """ Create the initial state for this game. """
+
+        pass
+
+    @abc.abstractmethod
+    def process_action(self, state: pacai.core.gamestate.GameState, action_record: pacai.core.agent.ActionRecord) -> pacai.core.gamestate.GameState:
+        """ Process the given move and return an updated game state. """
 
         pass
 
     @abc.abstractmethod
-    def get_initial_state(self, rng: random.Random) -> pacai.core.gamestate.GameState:
-        """ Create the initial state for this game. """
+    def check_end(self, state: pacai.core.gamestate.GameState) -> bool:
+        """
+        Check to see if the game is over.
+        Return True if the game is now over, False otherwise.
+        """
 
         pass
 
@@ -93,12 +100,14 @@ def run(self) -> GameResult:
          and 5) update the display.
         """
 
+        logging.debug("Starting a game with seed: %d.", self._seed)
+
         # Create a new random number generator just for this game.
         rng = random.Random(self._seed)
 
         # Initialize the agent isolator.
         isolator = self._isolation_level.get_isolator()
-        isolator.game_init(self._agent_args)
+        isolator.init_agents(self._agent_args)
 
         # Assign initial tickets to all the agents.
         tickets = []
@@ -113,24 +122,31 @@ def run(self) -> GameResult:
         state = self.get_initial_state(rng)
 
         # Notify agents about the start of the game.
-        isolator.game_start(state)
+        isolator.game_start(rng, state)
 
         turn_count = 0
         while (True):
+            # Choose the next agent to move.
             agent_index = self._get_next_agent_index(tickets)
 
+            logging.debug("Turn %d, agent %d, state: '%s'.", turn_count, agent_index, state)
+
             # Get the next action from the agent.
-            next_action = isolator.get_action(agent_index, state)
+            action_record = isolator.get_action(agent_index, state)
 
-            # Execute the next action.
+            # Execute the next action and update the state.
+            state = self.process_action(state, action_record)
 
             # Update the move history.
-
-            # Update the game state.
+            result.add_action(action_record)
 
             # Check for game ending conditions.
+            game_over = self.check_end(state)
+            if (game_over):
+                break
 
             # Issue the agent a new ticket.
+            tickets[agent_index] = tickets[agent_index].next(self._agent_args[agent_index].move_delay)
 
             # Increment the turn count.
             turn_count += 1

pacai/core/isolation.py

@@ -1,11 +1,14 @@
 import abc
 import enum
+import logging
+import random
 
 import pacai.core.action
 import pacai.core.agent
 import pacai.core.gamestate
+import pacai.core.time
 
-class Isolator(abc.ABC):
+class AgentIsolator(abc.ABC):
     """
     An isolator isolates an agent instance from the game being played.
     This "isolation" allows the game to hide or protect state from a agent.
@@ -16,16 +19,15 @@ class Isolator(abc.ABC):
     """
 
     @abc.abstractmethod
-    def game_init(self, agent_args: list[pacai.core.agent.AgentArguments]) -> None:
+    def init_agents(self, agent_args: list[pacai.core.agent.AgentArguments]) -> None:
         """
-        Initialize the isolator with the given agent arguments.
-        Called when a game is just preparing to start.
+        Initialize the agents this isolator will be responsible for.
         """
 
         pass
 
     @abc.abstractmethod
-    def game_start(self, initial_state: pacai.core.gamestate.GameState) -> None:
+    def game_start(self, rng: random.Random, initial_state: pacai.core.gamestate.GameState) -> None:
         """
         Pass along the initial game state to each agent and all them the allotted time to start.
         """
@@ -41,9 +43,17 @@ def game_complete(self, final_state: pacai.core.gamestate.GameState) -> None:
         pass
 
     @abc.abstractmethod
-    def get_action(self, agent_index: int, state: pacai.core.gamestate.GameState) -> pacai.core.action.Action:
+    def get_action(self, agent_index: int, state: pacai.core.gamestate.GameState) -> pacai.core.agent.ActionRecord:
         """
-        Get an agent's next action.
+        Get an agent's next action and how long it took to decide on that action.
+        """
+
+        pass
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        """
+        Close the isolator and release all owned resources.
         """
 
         pass
@@ -53,26 +63,81 @@ class Level(enum.Enum):
     PROCESS = 1
     TCP = 2
 
-    def get_isolator(self) -> Isolator:
+    def get_isolator(self, **kwargs) -> AgentIsolator:
         """ Get an isolator matching the given level. """
 
         if (self.value == Level.NONE):
-            return NoneIsolator()
+            return NoneIsolator(**kwargs)
         if (self.value == Level.PROCESS):
-            return ProcessIsolator()
+            return ProcessIsolator(**kwargs)
         if (self.value == Level.TCP):
-            return TCPIsolator()
+            return TCPIsolator(**kwargs)
         else:
             raise ValueError(f"Unknown isolation level '{self.value}'.")
 
-# TEST
-class NoneIsolator(abc.ABC):
-    pass
+class NoneIsolator(AgentIsolator):
+    """
+    An isolator that does not do any isolation between the engine and agents.
+    All agents will be run in the same thread (and therefore processes space).
+    This is the simplest and fastest of all isolators, but offers the least control and protection.
+    Agents cannot be timed out (since they run on the same thread).
+    Agents can also access any memory or disk that the core engine has access to.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        self._agents: list[pacai.core.agent.Agent] | None = None
+
+    def init_agents(self, agent_args: list[pacai.core.agent.AgentArguments]) -> None:
+        self._agents = [pacai.core.agent.load(args) for args in agent_args]
+
+    def game_start(self, rng: random.Random, initial_state: pacai.core.gamestate.GameState) -> None:
+        if (self._agents is None):
+            raise ValueError("Isolator agents has not been initialized.")
+
+        for i in range(len(self._agents)):
+            suggested_seed = rng.randint(0, 2**64)
+            self._agents[i].game_start(i, suggested_seed, initial_state)
+
+    def game_complete(self, final_state: pacai.core.gamestate.GameState) -> None:
+        if (self._agents is None):
+            raise ValueError("Isolator agents has not been initialized.")
+
+        for agent in self._agents:
+            agent.game_complete(final_state)
+
+    def get_action(self, agent_index: int, state: pacai.core.gamestate.GameState) -> pacai.core.agent.ActionRecord:
+        if (self._agents is None):
+            raise ValueError("Isolator agents has not been initialized.")
+
+        agent = self._agents[agent_index]
+        crashed = False
+
+        start_time = pacai.core.time.now()
+
+        try:
+            action = agent.get_action(state)
+        except Exception as ex:
+            logging.warning("Agent '%s' (%d) crashed.", agent.name, agent_index, exc_info = ex)
+
+            crashed = True
+            action = pacai.core.action.STOP
+
+        end_time = pacai.core.time.now()
+
+        return pacai.core.agent.ActionRecord(
+                agent_index = agent_index,
+                action = action,
+                duration = end_time.sub(start_time),
+                crashed = crashed)
+
+
+    def close(self) -> None:
+        self._agents = None
 
 # TEST
-class ProcessIsolator(abc.ABC):
+class ProcessIsolator(AgentIsolator):
     pass
 
 # TEST
-class TCPIsolator(abc.ABC):
+class TCPIsolator(AgentIsolator):
     pass