Initial commit.

Author: sdl1

AI/DumbAI.py

@@ -0,0 +1,6 @@
+from Robots import *
+import Move
+
+class AI(RobotAI):
+  def getMove(self, robotstate, worldstate):
+      return Move.TURN_RIGHT

AI/ExampleAI.py

@@ -0,0 +1,38 @@
+from Robots import *
+import Move
+
+class AI(RobotAI):
+  def __init__(self):
+    self.firedMissileAgo = 0
+  def getMove(self, robotstate, worldstate):
+    # Get up to speed
+    if(robotstate.speed < robotstate.maxspeed):
+      return Move.SPEED_UP
+    # If just fired missile, evade so don't shoot missile
+    if(self.firedMissileAgo < 10):
+      self.firedMissileAgo += 1
+      return Move.TURN_RIGHT
+    # Track missiles and robots in view
+    objects = worldstate.objectsInView
+    if( len(objects)>0 and ( (objects[0].isARobot and objects[0].colour != robotstate.colour) or objects[0].isAMissile) ):
+      targetPos = worldstate.objectsInView[0].relativePosition
+      alpha = robotstate.direction.angleBetween(targetPos)
+      if(alpha > 0.1):
+        return Move.TURN_RIGHT
+      elif(alpha < -0.1):
+        return Move.TURN_LEFT
+      if(robotstate.missilesLeft<=0 or abs(alpha) < 0.05 or objects[0].isAMissile):
+        return Move.FIRE_LASER
+      else:
+        self.firedMissileAgo = 0
+        return Move.FIRE_MISSILE
+    # Otherwise move randomly
+    else:
+      i = random.randint(0, 100)
+      if(i<30):
+        return Move.TURN_LEFT
+      elif(i<60):
+        return Move.TURN_RIGHT
+      else:
+
+        return Move.NONE

AI/Human.py

@@ -0,0 +1,39 @@
+from Robots import *
+import Move
+
+import Tkinter as tk
+root = tk.Tk()
+move = -4
+def keypress(event):
+    global move
+    if event.keysym == 'Escape':
+        move = Move.RESIGN
+        root.destroy()
+    x = event.char
+    if x == "w":
+        move = Move.SPEED_UP
+    elif x == "a":
+        move = Move.TURN_LEFT
+    elif x == "s":
+        move = Move.SLOW_DOWN
+    elif x == "d":
+        move = Move.TURN_RIGHT
+    elif x == " ":
+        move = Move.FIRE_LASER
+    elif x == "m":
+        move = Move.FIRE_MISSILE
+    else:
+        print x
+    root.quit()
+
+class AI(RobotAI):
+    def __init__(self):
+        print "Press a key (Escape key to exit):"
+        root.bind_all('<Key>', keypress)
+        # don't show the tk window
+        #root.withdraw()
+        #root.mainloop()
+    def getMove(self, robotstate, worldstate):
+        root.mainloop()
+        return move
+# respond to a key without the need to press enter

AI/Hunter.py

@@ -0,0 +1,140 @@
+from Robots import *
+import Move
+
+class AI(RobotAI):
+  def __init__(self):
+    self.firedMissileAgo = 0
+
+  def steerTowards(self, robotstate, relpos):
+    alpha = robotstate.direction.angleBetween(relpos)
+    if(alpha > 0.0):
+      return Move.TURN_LEFT
+    else:
+      return Move.TURN_RIGHT
+  def steerAway(self, robotstate, relpos):
+    alpha = robotstate.direction.angleBetween(relpos)
+    if(alpha > 0.0):
+      return Move.TURN_RIGHT
+    else:
+      return Move.TURN_LEFT
+
+  def getMove(self, robotstate, worldstate):
+
+    # Get up to speed
+    if(robotstate.speed < robotstate.maxspeed):
+      return Move.SPEED_UP
+
+    # If just fired missile, evade so don't shoot missile
+    if(self.firedMissileAgo < 20):
+      self.firedMissileAgo += 1
+      return Move.TURN_RIGHT
+
+    objects = worldstate.objectsInView
+
+    # Friendly robots in view
+    friends = [r for r in objects if (r.isARobot and r.colour==robotstate.colour)]
+    # Enemy robots in view
+    enemies = [r for r in objects if (r.isARobot and r.colour!=robotstate.colour)]
+    # Missiles in view
+    missiles = [r for r in objects if r.isAMissile]
+
+    # If friend directly in front and close, nudge left
+    if(len(friends)>0):
+      friendangles = [ robotstate.direction.angleBetween(f.relativePosition) for f in friends if f.relativePosition.length()<60]
+      critangles = [a for a in friendangles if abs(a)<0.2]
+      if(len(critangles)>0):
+        if critangles[0]>0:
+          return Move.TURN_LEFT
+        else:
+          return Move.TURN_RIGHT
+
+
+
+    # If friend in view signalling red, signal green and go towards him
+    redfriends = [r for r in friends if r.signal==Move.Signals.RED]
+    if len(redfriends)>0 and len(enemies)==0:
+      if robotstate.signal!=Move.Signals.GREEN: return Move.SIGNAL_GREEN
+      return self.steerTowards(robotstate, redfriends[0].relativePosition)
+
+    # Turn off signal if no enemies or red friends in view
+    if len(enemies)==0 and len(redfriends)==0 and robotstate.signal!=Move.Signals.NONE: return Move.SIGNAL_NONE
+
+    # If friend in view signalling green, go towards him
+    greenfriends = [r for r in friends if r.signal==Move.Signals.GREEN]
+    if len(greenfriends)>0 and len(enemies)==0:
+      return self.steerTowards(robotstate, greenfriends[0].relativePosition)
+
+    # Signal red iff enemy in view
+    if len(enemies)!=0 and robotstate.signal!=Move.Signals.RED: return Move.SIGNAL_RED
+
+
+    # Flock
+    if(len(friends)>0 and len(enemies)==0):
+      # Min distance to a friend
+      minfriend = None
+      mindist = 999999
+      for f in friends:
+        if(f.relativePosition.norm() < mindist):
+          minfriend = f
+          mindist = f.relativePosition.norm()
+      # Separation
+      if(mindist<50):
+        return self.steerAway(robotstate, f.relativePosition)
+      # Average heading of friends
+      heading = Vec2d(0,0)
+      for f in friends:
+        heading += f.direction
+      heading.normalise()
+      # Average position of friends
+      relposition = Vec2d(0,0)
+      for f in friends:
+        relposition += f.relativePosition
+
+      if(random.random()<0.5):
+        # Alignment
+        return self.steerTowards(robotstate, heading)
+      else:
+        # Cohesion
+        return self.steerTowards(robotstate, relposition)
+
+
+    # Track missiles and robots in view
+    # TODO track missiles
+    if( len(enemies)>0 or len(missiles)>0 ):
+      # Prioritise enemies
+      if(len(enemies)>0):
+        target = enemies[0]
+        for e in enemies:
+          if(e.relativePosition.length()<target.relativePosition.length()):
+            target = e
+      else:
+        target = missiles[0]
+
+      targetPos = target.relativePosition
+      # Track target
+      alpha = robotstate.direction.angleBetween(targetPos)
+      if(alpha > 0.05):
+        return Move.TURN_RIGHT
+      elif(alpha < -0.05):
+        return Move.TURN_LEFT
+
+      # Target far away
+      if(targetPos.length()>400):
+        return Move.NONE
+
+      # Fire
+      if(robotstate.missilesLeft<=0 or target.isAMissile):
+        return Move.FIRE_LASER
+      else:
+        self.firedMissileAgo = 0
+        return Move.FIRE_MISSILE
+    # Nothing in view. Move randomly
+    else:
+      i = random.randint(0, 100)
+      if(i<30):
+        return Move.TURN_LEFT
+      elif(i<60):
+        return Move.TURN_RIGHT
+      else:
+
+        return Move.NONE

AI/__init__.py

@@ -0,0 +1,129 @@
+#!/usr/bin/python
+from lib.PodSixNet.PodSixNet.Connection import connection, ConnectionListener
+import time
+import WorldStates
+import Robots
+import Move
+import sys
+import signal
+import getopt
+
+class Client(ConnectionListener):
+  def __init__(self, ai, colour, addr=("127.0.0.1", 12345), verbose=True):
+    self.ai = ai
+    self.colour = colour
+    self.verbose = verbose
+    self.Connect(addr)
+    self.speak("Client connecting to " + addr[0] +  ":" + str(addr[1]))
+    self.speak("Ctrl-C to exit")
+    self.sendRobot()
+    signal.signal(signal.SIGINT, self.resign)
+
+  def speak(self, text):
+    if self.verbose:
+      print "[client]", text
+
+  def Network(self, data):
+    pass
+  def Network_chat(self, data):
+    if self.verbose: print "[server]", data["text"]
+  # Called when server requests a move
+  def Network_requestMove(self, data):
+    worldstatepacked = data["worldstate"]
+    robotstatepacked = data["robotstate"]
+    robotstate = Robots.RobotState.unpack( robotstatepacked )
+    worldstate = WorldStates.WorldState.unpack( worldstatepacked )
+    move = self.ai.getMove(robotstate, worldstate)
+    self.sendMove(move)
+    if move==Move.RESIGN:
+        time.sleep(0.1)
+        sys.exit(0)
+  # Called when dead / game over
+  def Network_kick(self, data):
+    self.speak("Got kicked (" + data["reason"] + ")")
+    sys.exit(0)
+  def Network_informRobotUID(self, data):
+    self.speak("Got robot UID " + str(data["uid"]))
+
+
+  # Send a move to the server
+  def sendMove(self, move):
+    connection.Send({"action": "move", "move": move})
+    connection.Pump()
+    self.Pump()
+  # Send my robot to the server
+  def sendRobot(self):
+    connection.Send({"action": "placeRobot", "colour": self.colour})
+    self.Pump()
+    connection.Pump()
+  # Send my resignation (and wait for kick message)
+  def resign(self, handler, frame):
+    self.speak("Sending resignation.")
+    connection.Send({"action": "resign"})
+    self.Pump()
+    connection.Pump()
+    # Sleep for a small amount of time
+    # to allow server to process request,
+    # so it doesn't try to write to closed connection
+    time.sleep(0.1)
+    sys.exit(0)
+
+  def Loop(self):
+    while True:
+      self.Pump()
+      connection.Pump()
+      time.sleep(0.0001)
+
+# Get around __import__ only importing top-level module
+def my_import(name):
+  mod = __import__(name)
+  components = name.split('.')
+  for comp in components[1:]:
+    mod = getattr(mod, comp)
+  return mod
+
+def usage():
+    print "Usage: " + sys.argv[0] + " [-a AIname, --ai=AIname] [-t team, --team=team] [-s host:port, --server=host:port]"
+
+if __name__ == "__main__":
+  try:
+    opts, args = getopt.getopt(sys.argv[1:], "hva:t:s:", ["help", "ai=", "team=", "server="])
+  except getopt.GetoptError, err:
+    # print help information and exit:
+    print str(err) # will print something like "option -a not recognized"
+    usage()
+    sys.exit(2)
+  aiName = "ExampleAI"
+  verbose = False
+  team = 0
+  server = "localhost:12345"
+  for o, a in opts:
+    if o == "-v":
+      verbose = True
+    elif o in ("-h", "--help"):
+      usage()
+      sys.exit()
+    elif o in ("-a", "--ai"):
+      aiName = a
+    elif o in ("-t", "--team"):
+      team = int(a) % Robots.Teams.num
+    elif o in ("-s", "--server"):
+      server = a
+    else:
+      assert False, "unhandled option"
+
+  aiString = "AI." + aiName
+  aiModule = my_import(aiString)
+  ai = aiModule.AI()
+
+  host, port = server.split(":")
+  addr = (host, int(port))
+
+  print "Using AI module", aiModule
+  print "Joining " + Robots.Teams.Name[team] + " team on " + server
+  
+  client = Client(ai, team, addr, verbose)
+  client.Loop()
+
+
+