Refactored team launching code.

bin/HFO

@@ -34,8 +34,6 @@ def main(args):
   if args.logging and not os.path.exists(args.logDir):
     os.makedirs(args.logDir)
   num_agents   = args.offenseAgents + args.defenseAgents
-  team1        = args.offenseTeam
-  team2        = args.defenseTeam
   binary_dir   = os.path.dirname(os.path.realpath(__file__))
   server_port  = args.port + num_agents
   coach_port   = args.port + num_agents + 1
@@ -58,7 +56,7 @@ def main(args):
                     args.logDir, args.logDir, args.logDir,
                     args.sync, args.fullstate, args.fullstate,
                     args.maxFramesPerTrial, args.numTrials, args.numFrames,
-                    args.offenseOnBall, args.seed, args.maxUntouchedTime, 
+                    args.offenseOnBall, args.seed, args.maxUntouchedTime,
                     args.messageSize)
                   # server::record_messages=on -- useful for debug
   try:
@@ -76,12 +74,8 @@ def main(args):
     from Trainer import Trainer
     trainer = Trainer(args=args, server_port=server_port, coach_port=coach_port)
     trainer.initComm()
-    # Add Team1
-    trainer.addTeam(team1)
-    # Add Team2
-    trainer.addTeam(team2)
     # Run
-    trainer.run(necProcesses)
+    trainer.run(necProcesses, args.offenseTeam, args.defenseTeam)
   except KeyboardInterrupt:
     print '[start.py] Exiting for CTRL-C'
   finally:
@@ -96,6 +90,8 @@ def main(args):
 
 def parseArgs():
   import argparse
+  team_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'teams')
+  installed_teams = os.listdir(team_dir)
   p = argparse.ArgumentParser(description='Start Half Field Offense.',
                               formatter_class=argparse.RawTextHelpFormatter)
   p.add_argument('--headless', dest='headless', action='store_true',
@@ -121,9 +117,9 @@ def parseArgs():
   p.add_argument('--defense-npcs', dest='defenseNPCs', type=int, default=0,
                  help='Number of defensive uncontrolled players. Default: 0.')
   p.add_argument('--offense-team', dest='offenseTeam', type=str, default='base',
-                 help='Team name to pull offensive NPCs from. Options: {base, helios} Default: base.') 
+                 help='Offense team binary. Options: '+str(installed_teams)+'. Default: base.') 
   p.add_argument('--defense-team', dest='defenseTeam', type=str, default='base',
-                 help='Team name to pull defensive NPCs from. Options: {base, helios} Default: base')
+                 help='Defense team binary. Options: '+str(installed_teams)+'. Default: base.')
   p.add_argument('--no-sync', dest='sync', action='store_false', default=True,
                  help='Run server in non-sync mode.')
   p.add_argument('--port', dest='port', type=int, default=6000,
@@ -169,6 +165,10 @@ def parseArgs():
     p.error('Defense players (defense-agents + defense-npcs): '\
             'invalid choice: ' + str(args.defenseAgents + args.defenseNPCs) +\
             ' (choose from [0,11])')
+  if args.offenseTeam not in installed_teams:
+    p.error('Unrecognized offense team: ' + str(args.offenseTeam))
+  if args.defenseTeam not in installed_teams:
+    p.error('Unrecognized defense team: ' + str(args.defenseTeam))
   return args
 
 if __name__ == '__main__':

bin/teams.py → bin/Teams.py

@@ -3,18 +3,19 @@
 import os, subprocess
 
 class Team(object):
-  """ Abstract class. Handles launching players from 3rd party binaries. 
-  """
-  def __init__(self, name, binaryPath, libDir, options, offenseOrder, defenseOrder):
-    """ 
-      Creates a team
+  """ Abstract class. Handles launching players from 3rd party binaries. """
 
-      name: name of the team
-      binaryPath: absolute path of the executable
-      libDir: library dependencies directory
-      options: team-specific parameters for executable in string format
-      offenseOrder: order to prioritize offensive unums (do not include 0)
-      defenseOrder: order to prioritize defensive unums (do not include 0)
+  def __init__(self, name, binaryPath, libDir, options, offenseOrder,
+               defenseOrder):
+    """
+    Creates a team.
+
+    name: name of the team
+    binaryPath: absolute path of the executable
+    libDir: library dependencies directory
+    options: team-specific parameters for executable in string format
+    offenseOrder: order to prioritize offensive unums (do not include 0)
+    defenseOrder: order to prioritize defensive unums (do not include 0)
     """
     self._name = name
     self._binary_path = binaryPath
@@ -25,18 +26,20 @@ class Team(object):
 
   def launch_npc(self, player_num):
     """
-      Abstract method that should be overrided by subclasses. Launches an npc with player number player_num.
-      The method that overrides this should call start_npc_process. See examples below. 
+    Abstract method that should be overrided by subclasses. Launches an
+    npc with player number player_num.  The method that overrides this
+    should call start_npc_process. See examples below.
     """
     pass
 
   def start_npc_proc(self, launchOpts=None):
-    """Launches a player using the team-specific binary
-       launchOpts should be used to append player specific options 
-       (e.g., helios uses '-g' to signify launching a goalie )
+    """
+    Launches a player using the team-specific binary launchOpts
+    should be used to append player specific options (e.g., helios
+    uses '-g' to signify launching a goalie )
 
     Returns a Popen process object
-    """   
+    """
     player_cmd = self._binary_path
     player_cmd += ' %s' % (self._options)
     if launchOpts != None:
@@ -51,16 +54,18 @@ class Team(object):
 
 
 class Agent2d(Team):
-
-  def __init__(self, name, baseDir, libDir, binaryName, logDir, record, host='localhost', port=6000):
-
+  def __init__(self, name, baseDir, libDir, binaryName, logDir, record,
+               host='localhost', port=6000):
     binaryPath = os.path.join(baseDir, binaryName)
-    options = '-t %s -p %i --config_dir %s/config/formations-dt --log_dir %s --player-config %s/config/player.conf' % (name, port, baseDir, logDir, baseDir)
+    options = '-t %s -p %i --config_dir %s/config/formations-dt --log_dir %s'\
+              '--player-config %s/config/player.conf'\
+              % (name, port, baseDir, logDir, baseDir)
     if record:
       options += ' --record'
     offenseOrder =  [11,7,8,9,10,6,3,2,4,5]
     defenseOrder =  [2,3,4,5,6,7,8,11,9,10]
-    super(Agent2d, self).__init__(name, binaryPath, libDir, options, offenseOrder, defenseOrder)
+    super(Agent2d, self).__init__(name, binaryPath, libDir, options,
+                                  offenseOrder, defenseOrder)
 
   def launch_npc(self, player_num):
     launchOpts = None
@@ -69,15 +74,26 @@ class Agent2d(Team):
     print 'Launch npc %s-%d' % (self._name, player_num)
     return self.start_npc_proc(launchOpts)
 
-class Helios(Team):
-
-  def __init__(self, name, baseDir, libDir, binaryName, host='localhost', port=6000):
 
+class Helios(Team):
+  def __init__(self, name, baseDir, libDir, binaryName, host='localhost',
+               port=6000):
     binaryPath = os.path.join(baseDir, binaryName)
-    options = '--player-config %s/player.conf -h %s -t %s --formation-conf-dir %s/data/formations --role-conf %s/data/role.conf --ball-table %s/data/ball_table.dat --chain-search-method BestFirstSearch --evaluator-name Default --max-chain-length 4 --max-evaluate-size 1000 --sirm-evaluator-param-dir %s/data/sirm_evaluator/ --goalie-position-dir %s/data/goalie_position/ --intercept-conf-dir %s/data/intercept_probability/ --opponent-data-dir %s/data/opponent_data/ -p %d' % (baseDir, host, name, baseDir, baseDir, baseDir, baseDir, baseDir, baseDir, baseDir, port)
+    options = '--player-config %s/player.conf -h %s -t %s '\
+              '--formation-conf-dir %s/data/formations '\
+              '--role-conf %s/data/role.conf --ball-table %s/data/ball_table.dat '\
+              '--chain-search-method BestFirstSearch --evaluator-name Default '\
+              '--max-chain-length 4 --max-evaluate-size 1000 '\
+              '--sirm-evaluator-param-dir %s/data/sirm_evaluator/ '\
+              '--goalie-position-dir %s/data/goalie_position/ '\
+              '--intercept-conf-dir %s/data/intercept_probability/ '\
+              '--opponent-data-dir %s/data/opponent_data/ -p %d'\
+              % (baseDir, host, name, baseDir, baseDir, baseDir, baseDir,
+                 baseDir, baseDir, baseDir, port)
     offenseOrder =  [11,7,8,9,10,6,3,2,4,5]
     defenseOrder =  [2,3,4,5,6,7,8,11,9,10]
-    super(Helios, self).__init__(name, binaryPath, libDir, options, offenseOrder, defenseOrder)
+    super(Helios, self).__init__(name, binaryPath, libDir, options,
+                                 offenseOrder, defenseOrder)
 
   def launch_npc(self, player_num):
     launchOpts = None
@@ -85,8 +101,3 @@ class Helios(Team):
       launchOpts = '-g'
     print 'Launch npc %s-%d' % (self._name, player_num)
     return self.start_npc_proc(launchOpts)
-
-
-
-
-

bin/Trainer.py

 #!/usr/bin/env python
 # encoding: utf-8
 
-import sys, numpy, time, os, subprocess, teams
+import sys, numpy, time, os, subprocess, Teams
 from Communicator import ClientCommunicator, TimeoutError
 
 class DoneError(Exception):
@@ -97,44 +97,39 @@ class Trainer(object):
       self.waitOnPlayer(agent_ext_num, play_offense)
     return p
 
-  def addTeam(self, team_name):
-    """ Adds a team to the team list"""
-    # Check whether team name valid, and map to a format acceptable to third party binary
-    nameMap = {'base':'base', 'helios':'HELIOS'}
-    if team_name not in nameMap.keys():
-      print 'Invalid team name: ', team_name 
-      sys.exit(1)
-    # Create side specific team  
-    if len(self._teams) == 0: 
-      self._teams.append(nameMap[team_name] + '_left')
-    elif len(self._teams) == 1:
-      self._teams.append(nameMap[team_name] + '_right')
-    else:
-      print 'Too many teams added!'
-      sys.exit(1)
-
-  def createTeam(self, name):
-    teamDir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'teams')   
-    if 'HELIOS' in name:
-      print 'Creating team HELIOS'
-      return teams.Helios(name, os.path.join(teamDir, 'helios', 'helios-13Eindhoven'), os.path.join(teamDir, 'helios', 'local', 'lib'), 'helios_player', host='localhost', port=self._serverPort)
-    elif 'base' in name:
+  def createTeam(self, requested_team_name, play_offense):
+    """ Given a team name, returns the team object. """
+    teams_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'teams')
+    if requested_team_name == 'helios':
+      print 'Creating team Helios'
+      team_name = 'HELIOS_' + ('left' if play_offense else 'right')
+      team_dir = os.path.join(teams_dir, 'helios', 'helios-13Eindhoven')
+      lib_dir = os.path.join(teams_dir, 'helios', 'local', 'lib')
+      return Teams.Helios(team_name, team_dir, lib_dir,
+                          binaryName='helios_player', host='localhost',
+                          port=self._serverPort)
+    elif requested_team_name == 'base':
       print 'Creating team Agent2d (base)'
-      return teams.Agent2d(name, os.path.join(teamDir, 'base'), None, 'sample_player', self._logDir, self._record, host='localhost', port=self._serverPort)
+      team_name = 'base_' + ('left' if play_offense else 'right')
+      team_dir = os.path.join(teams_dir, 'base')
+      lib_dir = None
+      return Teams.Agent2d(team_name, team_dir, lib_dir,
+                           binaryName='sample_player', logDir=self._logDir,
+                           record=self._record, host='localhost',
+                           port=self._serverPort)
     else:
-      print 'Invalid team found'
+      print 'Unknown team requested: ' + requested_team_name
       sys.exit(1)
 
-  def getTeams(self):
+  def getTeams(self, offense_team_name, defense_team_name):
     """ Sets the offensive and defensive teams and player rosters. """
-    self._offenseTeamInd = 0
-    self._offenseTeamName = self._teams[self._offenseTeamInd]
-    self._defenseTeamName = self._teams[1-self._offenseTeamInd]
-    # set up offense
-    offenseTeam = self.createTeam(self._offenseTeamName)    
+    # Set up offense team
+    offenseTeam = self.createTeam(offense_team_name, play_offense=True)
+    self._offenseTeamName = offenseTeam._name
     self._offenseOrder = [1] + offenseTeam._offense_order # 1 for goalie
-    # set up defense
-    defenseTeam = self.createTeam(self._defenseTeamName)
+    # Set up defense team
+    defenseTeam = self.createTeam(defense_team_name, play_offense=False)
+    self._defenseTeamName = defenseTeam._name
     self._defenseOrder = [1] + defenseTeam._defense_order # 1 for goalie
     return (offenseTeam, defenseTeam)
 
@@ -397,10 +392,10 @@ class Trainer(object):
         return False
     return True
 
-  def run(self, necProcesses):
+  def run(self, necProcesses, offense_team_name, defense_team_name):
     """ Run the trainer """
     try:
-      (offenseTeam, defenseTeam) = self.getTeams()
+      (offenseTeam, defenseTeam) = self.getTeams(offense_team_name, defense_team_name)
       offense_unums = self._offenseOrder[1: self._numOffense + 1]
       sorted_offense_agent_unums = sorted(self._offenseOrder[1:self._offenseAgents+1])
       defense_unums = self._defenseOrder[: self._numDefense]