pacclient.py

# pacclient.py
# ------------
# Licensing Information: Please do not distribute or publish solutions to this
# project. You are free to use and extend these projects for educational
# purposes. The Pacman AI projects were developed at UC Berkeley, primarily by
# John DeNero (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
# For more info, see http://inst.eecs.berkeley.edu/~cs188/sp09/pacman.html

"""
Pacclient provides an interface to the server.

This code is NOT being used for Autumn 2011. It's not 100% functional.

You should not need to change any of this code, but
you can read about the command line options in readCommand.

If you choose to use another language besides python or to
not use our starter files, this is the object you need to
interface with.  It is the only object that talks to the server.

"""

from capture import *
import cPickle, asyncore, socket
import re, time
import threading
import game

SERVER_CONNECTION_TIMEOUT = 30 # seconds

def debugl(s):
  # print s
  return

def secs():
  return '%0.2f' % (time.time() % 100)

class TeamThread(threading.Thread):

  def __init__(self, agents, pacClient):
    threading.Thread.__init__(self)
    self.gotGameStateEvent = threading.Event()
    self.gameState = None # Slot filled by PacClient
    self.gotTimeout = False
    self.agentIndex = 0
    self.stateNumber = 0
    self.agents = agents
    self.semaphore = threading.Semaphore()
    self.gameOver = False
    self.pacClient = pacClient  # For sending actions
    self.rules = CaptureRules()
    self.setDaemon(True)

  def run(self):
    while not self.gameOver:
      debugl( "Waiting for event.." )
      self.gotGameStateEvent.wait(SERVER_CONNECTION_TIMEOUT)
      if not self.gotGameStateEvent.isSet():
        print >>sys.stderr, 'Lost connection with server'
        self.pacClient.finishGame()
        return
      if self.gameOver: return

      # Grab the next state
      self.semaphore.acquire()
      localGS = self.gameState
      localIndex = self.agentIndex
      localMoveNumber = self.stateNumber
      self.gotGameStateEvent.clear()
      self.semaphore.release()

      # Check for the end of the game
      self.rules.process(localGS, self)
      if self.gameOver: return

      agent = self.agents[localIndex]
      action = agent.getAction(localGS)
      debugl(action)
      self.pacClient.sendAction(localMoveNumber, action)

class PacClient(asyncore.dispatcher):

  def __init__(self, server, port, agentFactoryBuilder, display, user, password, gamename):
    asyncore.dispatcher.__init__(self)
    self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
    print >>sys.stderr, "Connecting to server(%s:%d)..." % (server, port)
    self.connect((server, port))
    self.bufSema = threading.Semaphore()
    self.sendbuf = ""
    self.recvbuf = ""
    self.__pickled = False
    self.responses = {200:self.userpass,
                      202:self.notify,
                      203:self.notify,
                      250:self.joingame,
                      400:self.error,
                      401:self.error,
                      402:self.error,
                      404:self.error,
                      350:self.notify,
                      500:self.startgame,
                      501:self.setAgent,
                      502:self.gogogadgetpickle,
                      504:self.ok,
                      505:self.win,
                      506:self.lose,
                      510:self.notify,
                      511:self.badness}
    self.agentFactoryBuilder = agentFactoryBuilder
    self.gameState = None
    self.statesReceived = 0
    self.display = display
    self.user = user
    self.password = password
    self.layout = None
    if gamename != '':
      self.gamename = gamename
      self.anygame = False
    else:
      self.anygame = True
      self.gamename = False
    self.teamThread = None # Created on launch of game
    asyncore.loop()

  def handle_connect(self):
    pass

  def handle_close(self):
    print "Server closed connection"
    self.close()

  def handle_read(self):
    stuff = self.recv(4096)
    self.recvbuf += stuff
    self.parse_read(stuff)

  def parse_read(self,stuff):
    debugl("Received "+str(len(stuff))+" chars, now "+str(len(self.recvbuf))+" in buffer")
    if(self.__pickled):
      debugl("Searching for a pickle...")
      rxp = re.compile("(.*?)(\r\n511: EOP \(End of Pickle\))\r\n",re.DOTALL)
      m = rxp.match(self.recvbuf)
      if(m):
        debugl("Found a pickle!")
        self.__pickled = False
        self.handle_pickle(m.group(1))
        self.recvbuf = self.recvbuf[len(m.group(1))+len(m.group(2))+2:]
        self.parse_read("")
      else:
        debugl("No pickle :(")
    else:
      rxp = re.compile("(.*?)\r\n")
      m = rxp.match(self.recvbuf)
      if(m):
        debugl("Found a command!")
        self.recvbuf = self.recvbuf[len(m.group(1))+2:]
        self.parse_line(m.group(1))
        self.parse_read("")

  def parse_line(self,line):
    if int(line.split(":")[0]) in self.responses.keys():
      code = int(line.split(":")[0])
      debugl( "Dispatching to "+str(code))
      self.responses[code](code,line)
    else:
      debugl("line \""+line+"\" didn't give me a code I understand :(")

  def error(self,code,line):
    print >>sys.stderr, "General error: "
    print >>sys.stderr, line

  def notify(self,code,line):
    print >>sys.stderr, "The server requests our attention:"
    print >>sys.stderr, line

  def userpass(self,code,line):
    print >>sys.stderr, "Logging in..."
    if not self.user:
      print "Please enter your username:"
      self.user = sys.stdin.readline().strip()
    if not self.password:
      print "Please enter your password:"
      self.password = sys.stdin.readline().strip()
    self.bufline("201:"+self.user+":"+self.password)

  def joingame(self, code,line):
    if not self.anygame and not self.gamename:
      print line.split(":")[1:]
      print "If you know the name of the game you are trying to reach, please press 1, now. If you would like to wait for a game, please press 2, now."
      choice = sys.stdin.readline().strip()
      print "Thank you. Your input is important to us."
      if (int(choice) == 1):
        print "Please enter the extension of the game you are trying to reach... now."
        gamename = sys.stdin.readline().strip()
        self.bufline("300:" + self.gamename)
      else:
        print "All our games are currently busy. Please hold. You will be matched with a game as soon as one is available."
        self.bufline("301:ANYGAME")
    elif self.gamename:
      self.bufline("300:" + self.gamename)
    elif self.anygame:
      self.bufline("301:ANYGAME")

  def gogogadgetpickle(self,code,line):
    self.__pickled = True
    debugl("Waiting for a pickle...")

  def setAgent(self, code, line):
    if self.lastAction:
      a, gs, agentIndex = self.lastAction, self.gameState, self.realAgent
      legals = gs.getLegalActions(agentIndex)
      if a in legals:
        self.display.update(gs.generateSuccessor(agentIndex, a).data)
    debugl("Agent " + line.split(":")[1])
    self.agentNum = int(int(line.split(":")[1])/2)
    self.realAgent = int(line.split(":")[1])

  def startgame(self,code,line):
    print "Initializing agents..."
    agentIndexBase = int(line.split(":")[1])
    self.lastAction = None
    self.isBlue = (agentIndexBase == 1)
    self.agents = self.agentFactoryBuilder(not self.isBlue)
    for agent in self.agents:
      if 'registerTeam' in dir(agent):
        agent.registerTeam(self.agents)
    self.teamThread = TeamThread(self.agents, self)
    self.teamThread.gotTimeout = False
    self.teamThread.daemon = True
    self.teamThread.start()

  def handle_pickle(self, pickle):
    # TODO Add error handling for a bad pickle
    stateNumber, gameState = cPickle.loads(pickle)
    # print secs(), 'Received:', stateNumber
    # Cache and reconstitute states
    if gameState.data.layout:
      self.layout = gameState.data.layout
    else:
      gameState.data.layout = self.layout
    gameState.data.food = game.reconstituteGrid(gameState.data.food)

    if not self.gameState: self.registerInitialState(gameState)
    self.gameState = gameState

    debugl(gameState.data._agentMoved)
    self.display.update(gameState.data)
    self.gameState = gameState
    self.pushState(stateNumber, gameState) # Send state to agent

  def ok(self,code,line):
    debugl("You don't say what to do with 'ok'")

  def badness(self,code,line):
    debugl("We were not expecting a "+line+" here ???")

  def win(self,code,line):
    print "You Win!"
    self.finishGame()
    self.close()

  def lose(self,code,line):
    print "You Lose :("
    self.finishGame()
    self.close()

  def bufline(self, s):
    self.sendbuf += (s + "\r\n")

  def writable(self):
    return (len(self.sendbuf) > 0)

  def handle_write(self):
    sent = self.send(self.sendbuf)
    self.sendbuf = self.sendbuf[sent:]

  def registerInitialState(self, gameState):
    """
    Registers the initial state
    """
    self.display.initialize(gameState.data, self.isBlue)
    for agent in self.agents[:len(gameState.data.agentStates)/2]:
      if 'registerInitialState' in dir(agent):
        agent.registerInitialState(gameState)

  def pushState(self, stateNumber, gameState):
    debugl("storing a state...")
    self.teamThread.semaphore.acquire()
    self.teamThread.agentIndex = self.agentNum
    self.teamThread.stateNumber = stateNumber
    self.teamThread.gameState = gameState
    self.teamThread.semaphore.release()
    self.teamThread.gotGameStateEvent.set()
    agent = self.teamThread.agents[self.agentNum]
    if '_distributions' in dir(agent): self.display.updateDistributions(agent._distributions)


  def sendAction(self, stateNumber, action):
    self.lastAction = action
    self.bufline("503:"+str(stateNumber) + ':' + action)
    self.handle_write()

  def finishGame(self):
    self.teamThread.gameOver = True
    self.teamThread.gotGameStateEvent.set()
    self.display.finish()

  def run(self):
    print "PacClient is running!"
    asyncore.loop()

def readCommand( argv ):
  """
  Processes the command used to run pacman from the command line.
  """
  from optparse import OptionParser
  usageStr = """
  USAGE:      python pacclient.py <options>
  EXAMPLES:   (1) python pacclient.py
                  - starts an interactive game with a random teammate.
  EXAMPLES:   (2) python pacclient.py -2 OffenseAgent
                  - starts an interactive game with a random teammate.
  """
  parser = OptionParser(usageStr)

  parser.add_option('-a', '--agents', help=default('Your team'),
                    default='BaselineAgents')
  parser.add_option('--agentOpts', help=default('Arguments passed to the factory'),
                    default='')
  parser.add_option('-t', '--textgraphics', action='store_true',
                    help='Display output as text only', default=False)
  parser.add_option('-q', '--quiet', action='store_true',
                    help='Display minimal output', default=False)
  # parser.add_option('-G', '--pygame', action='store_true', dest='pygame',
  #                   help='Display output with Pygame graphics (faster)', default=False)
  parser.add_option('-z', '--zoom', type='float',
                    help=default('Zoom in the graphics'), default=1)
  parser.add_option('-s', '--server',
                    help=default('The SERVER to connect to'), default='robots.stanford.edu')
  parser.add_option('-p', '--port', type='int',
                    help=default('The PORT to connect to'), default=7226)
  parser.add_option('-U', '--user',
                    help=default('Your username'), default='guest')
  parser.add_option('-P', '--password',
                    help=default('Your password'), default='guest')
  parser.add_option('-g', '--gamename',
                    help=default('The name of the game you wish to contact'), default='')
  parser.add_option('-f', '--fixRandomSeed', action='store_true',
                    help='Fixes the random seed to always play the same game', default=False)

  options, otherjunk = parser.parse_args()
  if len(otherjunk) != 0: raise Exception("Illegal args: " + otherjunk)
  args = dict()

  agentArgs = parseAgentArgs(options.agentOpts)
  args['agentFactoryBuilder'] = loadAgentAccessor(options.agents, agentArgs)

  # Choose a display format
  #if options.pygame:
  # import pygameDisplay
  #  args['display'] = pygameDisplay.PacmanGraphics()
  if options.quiet:
    import textDisplay
    args['display'] = textDisplay.NullGraphics()
  elif options.textgraphics:
    import textDisplay
    args['display'] = textDisplay.PacmanGraphics()
  else:
    import graphicsDisplay
    args['display'] = graphicsDisplay.PacmanGraphics(options.zoom, 0, True)

  if options.fixRandomSeed: random.seed('cs188')

  args['server'] = options.server
  args['port'] = options.port
  args['user'] = options.user
  args['password'] = options.password
  args['gamename'] = options.gamename

  return args

def loadAgentAccessor(factory, args):
  "Returns a function that takes isRed and returns a list of agents"
  # Looks through all pythonPath Directories for the right module,
  return lambda isRed: loadAgents(isRed, factory, False, args)

if __name__ == '__main__':
  """
  The main function called when pacman.py is run
  from the command line:

  > python pacclient.py

  See the usage string for more details.

  > python pacclient.py --help
  """
  args = readCommand( sys.argv[1:] ) # Get game components based on input=======
  PacClient(**args)