Made the capture timeout options settable in the CLI.

Author: eriq-augustine

.gitignore

@@ -7,3 +7,4 @@ __pycache__
 /html/
 /*.gif
 /._site/
+/build/

pacai/agents/capture/timeout.py

@@ -0,0 +1,37 @@
+import random
+import time
+
+from pacai.agents.capture.capture import CaptureAgent
+
+DEFAULT_WAIT_DURATION_SECS = 0
+
+class TimeoutAgent(CaptureAgent):
+    """
+    An agent that always waits a specified duration before making a random move.
+    """
+
+    # The duration to wait.
+    # Testers may edit this directly (and reset() when done).
+    waitMoveDurationSecs = DEFAULT_WAIT_DURATION_SECS
+    waitInitDurationSecs = DEFAULT_WAIT_DURATION_SECS
+
+    def reset():
+        TimeoutAgent.waitMoveDurationSecs = DEFAULT_WAIT_DURATION_SECS
+        TimeoutAgent.waitInitDurationSecs = DEFAULT_WAIT_DURATION_SECS
+
+    def __init__(self, index, **kwargs):
+        super().__init__(index, **kwargs)
+
+    def registerInitialState(self, gameState):
+        # Wait first.
+        time.sleep(TimeoutAgent.waitInitDurationSecs)
+
+        super().registerInitialState(gameState)
+
+    def chooseAction(self, gameState):
+        # Wait first.
+        time.sleep(TimeoutAgent.waitMoveDurationSecs)
+
+        # Take a random action.
+        actions = gameState.getLegalActions(self.index)
+        return random.choice(actions)

pacai/bin/capture.py

@@ -38,6 +38,25 @@
 
 SCARED_TIME = 40
 
+# The number of moves shared between all agents.
+DEFAULT_MAX_MOVES = 1200
+
+# Total time allowed for an agent,
+# move limits generally stop this from happening.
+DEFAULT_MAX_TOTAL_AGENT_TIME_SECS = 900
+
+# Time allowed for registerInitialState().
+DEFAULT_MAX_STARTUP_TIME_SECS = 15
+
+# Some number of warnings will cause a forfeit.
+DEFAULT_MOVE_WARNING_TIME_SECS = 1
+
+# Any violation of this is an instant forfeit.
+DEFAULT_MOVE_TIMEOUT_TIME_SECS = 3
+
+# Next violation causes a forfeit.
+DEFAULT_MAX_MOVE_WARNINGS = 2
+
 class CaptureGameState(AbstractGameState):
     """
     A game state specific to capture.
@@ -246,7 +265,13 @@ class CaptureRules:
     and how the game starts and ends.
     """
 
-    def newGame(self, layout, agents, display, length, catchExceptions):
+    def newGame(self, layout, agents, display, length, catchExceptions,
+            maxTotalAgentTimeSecs = DEFAULT_MAX_TOTAL_AGENT_TIME_SECS,
+            maxStartupTimeSecs = DEFAULT_MAX_STARTUP_TIME_SECS,
+            moveWarningTimeSecs = DEFAULT_MOVE_WARNING_TIME_SECS,
+            moveTimeoutTimeSecs = DEFAULT_MOVE_TIMEOUT_TIME_SECS,
+            maxMoveWarnings = DEFAULT_MAX_MOVE_WARNINGS,
+            **kwargs):
         initState = CaptureGameState(layout, length)
         starter = random.randint(0, 1)
         logging.info('%s team starts' % ['Red', 'Blue'][starter])
@@ -258,6 +283,12 @@ def newGame(self, layout, agents, display, length, catchExceptions):
         self._totalBlueFood = initState.getBlueFood().count()
         self._totalRedFood = initState.getRedFood().count()
 
+        self._maxTotalAgentTimeSecs = maxTotalAgentTimeSecs
+        self._maxStartupTimeSecs = maxStartupTimeSecs
+        self._moveWarningTimeSecs = moveWarningTimeSecs
+        self._moveTimeoutTimeSecs = moveTimeoutTimeSecs
+        self._maxMoveWarnings = maxMoveWarnings
+
         return game
 
     def process(self, state, game):
@@ -313,20 +344,20 @@ def agentCrash(self, game, agentIndex):
             logging.error("Blue agent crashed.")
             game.state.setScore(1)
 
-    def getMaxTotalTime(self, agentIndex):
-        return 900  # Move limits should prevent this from ever happening
+    def getMaxTotalAgentTime(self, agentIndex):
+        return self._maxTotalAgentTimeSecs
 
     def getMaxStartupTime(self, agentIndex):
-        return 15  # 15 seconds for registerInitialState
+        return self._maxStartupTimeSecs
 
     def getMoveWarningTime(self, agentIndex):
-        return 1  # One second per move
+        return self._moveWarningTimeSecs
 
     def getMoveTimeout(self, agentIndex):
-        return 3  # Three seconds results in instant forfeit
+        return self._moveTimeoutTimeSecs
 
     def getMaxTimeWarnings(self, agentIndex):
-        return 2  # Third violation loses the game
+        return self._maxMoveWarnings
 
 class AgentRules:
     """
@@ -536,14 +567,34 @@ def readCommand(argv):
             help = 'make agent 3 (second blue player) a keyboard agent (default: %(default)s)')
 
     parser.add_argument('--max-moves', dest = 'maxMoves',
-            action = 'store', type = int, default = 1200,
-            help = 'set maximum number of moves in a game (default: %(default)s)')
+            action = 'store', type = int, default = DEFAULT_MAX_MOVES,
+            help = 'set maximum number of moves between all agents in a game (default: %(default)s)')
 
     parser.add_argument('--red-args', dest = 'redArgs',
             action = 'store', type = str, default = None,
             help = 'comma separated arguments to be passed to red team (e.g. \'opt1=val1,opt2\') '
                 + '(default: %(default)s)')
 
+    parser.add_argument('--max-total-agent-time', dest = 'maxTotalAgentTimeSecs',
+            action = 'store', type = float, default = DEFAULT_MAX_TOTAL_AGENT_TIME_SECS,
+            help = 'set maximum number of seconds a game can run (default: %(default)s)')
+
+    parser.add_argument('--max-startup-time', dest = 'maxStartupTimeSecs',
+            action = 'store', type = float, default = DEFAULT_MAX_STARTUP_TIME_SECS,
+            help = 'set maximum number of seconds allowed for registerInitialState() (default: %(default)s)')
+
+    parser.add_argument('--move-warning-time', dest = 'moveWarningTimeSecs',
+            action = 'store', type = float, default = DEFAULT_MOVE_WARNING_TIME_SECS,
+            help = 'set maximum number of seconds an agent can take on a move before a warning is issued (default: %(default)s)')
+
+    parser.add_argument('--move-timeout-time', dest = 'moveTimeoutTimeSecs',
+            action = 'store', type = float, default = DEFAULT_MOVE_TIMEOUT_TIME_SECS,
+            help = 'set maximum number of seconds an agent can take on a move before forfeiting (default: %(default)s)')
+
+    parser.add_argument('--max-move-warnings', dest = 'maxMoveWarnings',
+            action = 'store', type = int, default = DEFAULT_MAX_MOVE_WARNINGS,
+            help = 'set maximum number of warnings issued to an agent before that agent is disqualified (default: %(default)s)')
+
     options, otherjunk = parser.parse_known_args(argv)
     args = dict()
 
@@ -639,6 +690,11 @@ def readCommand(argv):
     args['record'] = options.record
     args['catchExceptions'] = options.catchExceptions
     args['replay'] = options.replay
+    args['maxTotalAgentTimeSecs'] = options.maxTotalAgentTimeSecs
+    args['maxStartupTimeSecs'] = options.maxStartupTimeSecs
+    args['moveWarningTimeSecs'] = options.moveWarningTimeSecs
+    args['moveTimeoutTimeSecs'] = options.moveTimeoutTimeSecs
+    args['maxMoveWarnings'] = options.maxMoveWarnings
 
     return args
 
@@ -660,10 +716,10 @@ def loadAgents(isRed, agentModule, textgraphics, args):
 
     return createTeamFunction(indices[0], indices[1], isRed, **args)
 
-def replayGame(layout, agents, actions, display, length, redTeamName, blueTeamName):
+def replayGame(layout, agents, actions, display, length, redTeamName, blueTeamName, **kwargs):
     agents = [DummyAgent(index) for index in range(len(agents))]
     rules = CaptureRules()
-    game = rules.newGame(layout, agents, display, length, False)
+    game = rules.newGame(layout, agents, display, length, False, **kwargs)
     state = game.state
     display.redTeam = redTeamName
     display.blueTeam = blueTeamName
@@ -698,7 +754,7 @@ def runGames(layout, agents, display, length, numGames, record, numTraining,
         else:
             gameDisplay = display
 
-        g = rules.newGame(layout, agents, gameDisplay, length, catchExceptions)
+        g = rules.newGame(layout, agents, gameDisplay, length, catchExceptions, **kwargs)
         g.run()
 
         if (not isTraining):

pacai/bin/pacman.py

@@ -187,7 +187,7 @@ def agentCrash(self, game, agentIndex):
         else:
             logging.error('A ghost crashed')
 
-    def getMaxTotalTime(self, agentIndex):
+    def getMaxTotalAgentTime(self, agentIndex):
         return self.timeout
 
     def getMaxStartupTime(self, agentIndex):

pacai/core/game.py

@@ -141,7 +141,7 @@ def _checkForTimeouts(self, agentIndex, timeTaken):
                 return True
 
         # Check if the agent has used too much time overall.
-        maxTotalTime = self.rules.getMaxTotalTime(agentIndex)
+        maxTotalTime = self.rules.getMaxTotalAgentTime(agentIndex)
         if (self.totalAgentTimes[agentIndex] > maxTotalTime):
             logging.warning('Agent %d ran out of time! (time: %1.2f)' %
                     (agentIndex, self.totalAgentTimes[agentIndex]))
@@ -164,7 +164,7 @@ def _registerInitialState(self):
                 self._agentCrash(agentIndex)
                 return False
 
-            maxStartupTime = int(self.rules.getMaxStartupTime(agentIndex))
+            maxStartupTime = float(self.rules.getMaxStartupTime(agentIndex))
             startTime = time.time()
 
             try:

pacai/core/timeoutTeam.py

@@ -0,0 +1,16 @@
+from pacai.util import reflection
+
+def createTeam(firstIndex, secondIndex, isRed,
+        first = 'pacai.agents.capture.timeout.TimeoutAgent',
+        second = 'pacai.agents.capture.timeout.TimeoutAgent'):
+    """
+    A team for testing timeouts.
+    """
+
+    firstAgent = reflection.qualifiedImport(first)
+    secondAgent = reflection.qualifiedImport(second)
+
+    return [
+        firstAgent(firstIndex),
+        secondAgent(secondIndex),
+    ]

tests/test_bin.py

@@ -4,10 +4,10 @@
 from pacai.bin import gridworld
 from pacai.bin import pacman
 
-"""
-This is a test class to assess the executables of this project.
-"""
 class BinTest(unittest.TestCase):
+    """
+    This is a test class to assess the executables of this project.
+    """
 
     def test_pacman(self):
         # Run game of pacman with valid agent.
@@ -31,7 +31,10 @@ def test_pacman_help(self):
 
     def test_capture(self):
         # Run game of capture with default agents.
-        capture.main(['--null-graphics'])
+        capture.main([
+            '--null-graphics',
+            '--max-moves', '16',
+        ])
 
     def test_capture_help(self):
         # Show all capture arguments.
@@ -62,10 +65,18 @@ def test_seeded_runs(self):
 
     def test_capture_seeded_maze_generations(self):
         # Run game of capture with random generated map without seed value.
-        capture.main(['--null-graphics', '--layout', 'RANDOM']) 
+        capture.main([
+            '--null-graphics',
+            '--layout', 'RANDOM',
+            '--max-moves', '16',
+        ])
 
         # Run game of capture with random generated map with seed value.
-        capture.main(['--null-graphics', '--layout', 'RANDOM94'])
+        capture.main([
+            '--null-graphics',
+            '--layout', 'RANDOM94',
+            '--max-moves', '16',
+        ])
 
 if __name__ == '__main__':
     unittest.main()

tests/test_capture.py

@@ -0,0 +1,94 @@
+import unittest
+
+from pacai.bin import capture
+from pacai.agents.capture.timeout import TimeoutAgent
+
+class CaptureTest(unittest.TestCase):
+    def test_base(self):
+        games = capture.main([
+            '--null-graphics',
+            '--catch-exceptions',
+            '--max-moves', '16',
+        ])
+
+        self.assertTrue(games[0].gameOver)
+        self.assertFalse(games[0].agentCrashed)
+        self.assertFalse(games[0].agentTimeout)
+
+    def test_full_game_timeout(self):
+        games = capture.main([
+            '--null-graphics',
+            '--catch-exceptions',
+            '--max-total-agent-time', '0.01',
+        ])
+
+        self.assertTrue(games[0].gameOver)
+        self.assertTrue(games[0].agentCrashed)
+        self.assertTrue(games[0].agentTimeout)
+
+    def test_no_timeout(self):
+        games = capture.main([
+            '--null-graphics',
+            '--catch-exceptions',
+            '--blue', 'pacai.core.timeoutTeam',
+            '--max-moves', '16',
+        ])
+
+        self.assertTrue(games[0].gameOver)
+        self.assertFalse(games[0].agentCrashed)
+        self.assertFalse(games[0].agentTimeout)
+
+    def test_init_timeout(self):
+        try:
+            TimeoutAgent.waitInitDurationSecs = 0.5
+
+            games = capture.main([
+                '--null-graphics',
+                '--catch-exceptions',
+                '--blue', 'pacai.core.timeoutTeam',
+                '--max-startup-time', '0.1',
+            ])
+        finally:
+            TimeoutAgent.reset()
+
+        self.assertTrue(games[0].gameOver)
+        self.assertTrue(games[0].agentCrashed)
+        self.assertTrue(games[0].agentTimeout)
+
+    def test_move_timeout(self):
+        try:
+            TimeoutAgent.waitMoveDurationSecs = 0.5
+
+            games = capture.main([
+                '--null-graphics',
+                '--catch-exceptions',
+                '--blue', 'pacai.core.timeoutTeam',
+                '--move-timeout-time', '0.1',
+            ])
+        finally:
+            TimeoutAgent.reset()
+
+        self.assertTrue(games[0].gameOver)
+        self.assertTrue(games[0].agentCrashed)
+        self.assertTrue(games[0].agentTimeout)
+
+    def test_move_warnings(self):
+        try:
+            TimeoutAgent.waitMoveDurationSecs = 0.1
+
+            games = capture.main([
+                '--null-graphics',
+                '--catch-exceptions',
+                '--blue', 'pacai.core.timeoutTeam',
+                '--move-warning-time', '0.05',
+            ])
+        finally:
+            TimeoutAgent.reset()
+
+        self.assertTrue(games[0].gameOver)
+        self.assertTrue(games[0].agentCrashed)
+        self.assertTrue(games[0].agentTimeout)
+
+        # Each blue agent should get a warning on every turn.
+        # The game ends right away at the third warning an agent gets.
+        self.assertEqual(5, sum(games[0].totalAgentTimeWarnings))