| Team | Kills | Cause of Death'] + for tank in tanks: + if tank is winner: + rowStyle = 'style="color:red;"' + else: + rowStyle = '' + html.append(' |
|---|---|---|
| %s | %d | %s' % + (rowStyle, + xml.sax.saxutils.escape(tank.name), + len(kills[tank]), + xml.sax.saxutils.escape(tank.deathReason))) + + html.append(' |
+Your program should be separated into Setup and AI commands. The definitions +section lets you designated the behaviors of its sensors and memory. +Each setup command must begin with a '>'. Placing setup commands after +the first AI command is a violation of protocol. +Here are some examples of correct setup commands: +
>addsensor(80, 90, 33); +>addsensor(50, 0, 10, 1); +>addtimer(3);+ +The AI section will act as the brain of your tank. Each AI line is +separated into a group of conditions functions and a group of action +functions. If all the conditions are satisfactory (true), all of the actions +are given as orders. Conditions are separated by ampersands, actions separated +by periods. Here are some examples of AI commands: +
+sensor(1) & sensor(2) & fireready() : fire(); +sensor(0,0)&sin(5): move(40, 30) . turretcw(50); +sensor(4) & random(4,5) : led(1).settoggle(0,1);+ +Your tank will check its program each turn, and attempt to the best of its +abilities to carry out its orders (or die trying). Like any military mind, +your tank may receive a plethora of often conflicting orders and information. +This a SMART TANK, however. It knows that the proper thing to do with each +subsystem is to have that subsystem follow only the last order given each turn. +""" + +import conditions +import actions +import setup + +class Statement(object): + """Represents a single program statement. If all the condition Functions + evaluate to True, the actions are all executed in order.""" + + def __init__(self, lineNum, line, conditions, actions): + self.lineNum = lineNum + self.line = line + self._conditions = conditions + self._actions = actions + + def __call__(self, tank): + success = True + for condition in self._conditions: + if not condition(tank): + success = False + break + + if success: + for action in self._actions: + action(tank) + +class Program(object): + """This parses and represents a Tank program.""" + CONDITION_SEP = '&' + ACTION_SEP = '.' + + def __init__(self, text): + """Initialize this program, parsing the given text.""" + self.errors = [] + + self._program, self._setup = self._parse(text) + + def setup(self, tank): + """Execute all the setup actions.""" + for action in self._setup: + try: + action(tank) + except Exception, msg: + self.errors.append("Bad setup action, line %d, msg: %s" % \ + (action.lineNum, msg)) + + def __call__(self, tank): + """Execute this program on the given tank.""" + for statement in self._program: + try: + statement(tank) + except Exception, msg: + self.errors.append('Error executing program. \n' + '(%d) - %s\n' + 'msg: %s\n' % + (statement.lineNum, statement.line, msg) ) + + def _parse(self, text): + """Parse the text of the given program.""" + program = [] + setup = [] + inSetup = True + lines = text.split(';') + lineNum = 0 + for line in lines: + lineNum = lineNum + 1 + + originalLine = line + + # Remove Comments + parts = line.split('\n') + for i in range(len(parts)): + comment = parts[i].find('#') + if comment != -1: + parts[i] = parts[i][:comment] + # Remove all whitespace + line = ''.join(parts) + line = line.replace('\r', '') + line = line.replace('\t', '') + line = line.replace(' ', '') + + if line == '': + continue + + if line.startswith('>'): + if inSetup: + if '>' in line[1:] or ':' in line: + self.errors.append('(%d) Missing semicolon: %s' % + (lineNum, line)) + continue + + try: + setupAction = self._parseSection(line[1:], 'setup')[0] + setupAction.lineNum = lineNum + setup.append(setupAction) + except Exception, msg: + self.errors.append('(%d) Error parsing setup line: %s' + '\nThe error was: %s' % + (lineNum, originalLine, msg)) + + continue + else: + self.errors.append('(%d) Setup lines aren\'t allowed ' + 'after the first command: %s' % + (lineNum, originalLine)) + else: + # We've hit the first non-blank, non-comment, non-setup + # line + inSetup = False + + semicolons = line.count(':') + if semicolons > 1: + self.errors.append('(%d) Missing semicolon: %s' % + (lineNum, line)) + continue + elif semicolons == 1: + conditions, actions = line.split(':') + else: + self.errors.append('(%d) Invalid Line, no ":" seperator: %s'% + (lineNum, line) ) + + try: + conditions = self._parseSection(conditions, 'condition') + except Exception, msg: + self.errors.append('(%d) %s - "%s"' % + (lineNum, msg, line) ) + continue + + try: + actions = self._parseSection(actions, 'action') + except Exception, msg: + self.errors.append('(%d) %s - "%s"' % + (lineNum, msg, originalLine) ) + continue + program.append(Statement(lineNum, line, conditions, actions)) + + return program, setup + + def _parseSection(self, section, sectionType): + """Parses either the action or condition section of each command. +@param section: The text of the section of the command to be parsed. +@param sectionType: The type of section to be parsed. Should be: + 'condition', 'action', or 'setup'. +@raises ValueError: Raises ValueErrors when parsing errors occur. +@returns: Returns a list of parsed section components (Function objects). + """ + + if sectionType == 'condition': + parts = section.split(self.CONDITION_SEP) + functions = conditions.conditions + if section == '': + return [] + elif sectionType == 'action': + parts = section.split(self.ACTION_SEP) + functions = actions.actions + if section == '': + raise ValueError("The action section cannot be empty.") + elif sectionType == 'setup': + parts = [section] + functions = setup.setup + else: + raise ValueError('Invalid section Type - Contact Contest Admin') + + parsed = [] + for part in parts: + + pos = part.find('(') + if pos == -1: + raise ValueError("Missing open paren in %s: %s" % + (sectionType, part) ) + funcName = part[:pos] + + if funcName not in functions: + raise ValueError("%s function %s is not accepted." % + (sectionType.capitalize(), funcName) ) + + if part[-1] != ')': + raise ValueError("Missing closing paren in %s: %s" % + (condition, sectionType) ) + + args = part[pos+1:-1] + if args != '': + args = args.split(',') + for i in range(len(args)): + args[i] = int(args[i]) + else: + args = [] + + parsed.append(functions[funcName](*args)) + + return parsed diff --git a/tanks/lib/Tank.py b/tanks/lib/Tank.py new file mode 100644 index 0000000..dffa85e --- /dev/null +++ b/tanks/lib/Tank.py @@ -0,0 +1,537 @@ +import math +import random +from PIL import Image +from PIL import ImageDraw + +import GameMath as gm +import Program + +class Tank(object): + + # How often, in turns, that we can fire. + FIRE_RATE = 20 + # How far the laser shoots from the center of the tank + FIRE_RANGE = 45.0 + # The radius of the tank, from the center of the turret. + # This is what is used for collision and hit detection. + RADIUS = 7.5 + # Max speed, in pixels + SPEED = 7.0 + # Max acceleration, as a fraction of speed. + ACCEL = 35 + # Sensor range, in pixels + SENSOR_RANGE = 90.0 + # Max turret turn rate, in radians + TURRET_TURN_RATE = math.pi/10 + + # The max number of sensors/timers/toggles + SENSOR_LIMIT = 10 + + def __init__(self, name, pos, color, boardSize, angle=None, tAngle=None, + testMode=True): + """Create a new tank. +@param name: The name name of the tank. Stored in self.name. +@param pos: The starting position of the tank (x,y) +@param color: The color of the tank. +@param boardSize: The size of the board. (maxX, maxY) +@param angle: The starting angle of the tank, defaults to random. +@param tAngle: The starting turretAngle of the tank, defaults to random. +@param testMode: When True, extra debugging information is displayed. Namely, + arcs for each sensor are drawn, which turn white when + activated. + """ + + # Keep track of what turn number it is for this tank. + self._turn = 0 + + self.name = name + self._testMode = testMode + + assert len(pos) == 2 and pos[0] > 0 and pos[1] > 0, \ + 'Bad starting position: %s' % str(pos) + self.pos = pos + + # The last speed of each tread (left, right) + self._lastSpeed = 0.0, 0.0 + # The next speed that the tank should try to attain. + self._nextMove = 0,0 + + # When set, the led is drawn on the tank. + self.led = False + + assert len(boardSize) == 2 and boardSize[0] > 0 and boardSize[1] > 0 + # The limits of the playfield (maxX, maxY) + self._limits = boardSize + + # The current angle of the tank. + if angle is None: + self._angle = random.random()*2*math.pi + else: + self._angle = angle + + # The current angle of the turret + if tAngle is None: + self._tAngle = random.random()*2*math.pi + else: + self._tAngle = tAngle + + self._color = color + + # You can't fire until fireReady is 0. + self._fireReady = self.FIRE_RATE + # Means the tank will fire at it's next opportunity. + self._fireNow = False + # True when the tank has fired this turn (for drawing purposes) + self._fired = False + + # What the desired turret angle should be (from the front of the tank). + # None means the turret should stay stationary. + self._tGoal = None + + # Holds the properties of each sensor + self._sensors = [] + # Holds the state of each sensor + self._sensorState = [] + + # The tanks toggle memory + self.toggles = [] + + # The tanks timers + self._timers = [] + + # Is this tank dead? + self.isDead = False + # The frame of the death animation. + self._deadFrame = 10 + # Death reason + self.deathReason = 'survived' + + def __repr__(self): + return '
| %s | ||
|---|---|---|
| Bad object' % \
+ xml.sax.saxutils.escape(str(object))
+ continue
+ text = object.__doc__
+ lines = text.split('\n')
+ head = lines[0].strip()
+ head = xml.sax.saxutils.escape(head)
+
+ body = []
+ for line in lines[1:]:
+ line = line.strip() #xml.sax.saxutils.escape( line.strip() )
+ line = line.replace('.', '. ') + body.append(line) + + body = '\n'.join(body) + print '
| ||
| %s | Intentionally blank | |
| %s' % (head, body) + print ' | ||
+range - The range of the sensor, as a percent of the tanks max range. +angle - The angle of the center of the sensor, in degrees. +width - The width of the sensor, in percent (100 is a full circle). +turretAttached - Normally, the angle is relative to the front of the +tank. When this is set, the angle is relative to the current turret +direction. +
+Sensors are drawn for each tank, but not in the way you might expect. +Instead of drawing a pie slice (the actual shap of the sensor), an arc with +the end points connected by a line is drawn. Sensors with 0 width don't show +up, but still work. +""" + + def __init__(self, range, angle, width, turretAttached=False): + + self._checkRange(range, 'sensor range') + + self._range = range / 100.0 + self._width = self._convertAngle(width, 'sensor width') + self._angle = self._convertAngle(angle, 'sensor angle') + self._turretAttached = turretAttached + + def __call__(self, tank): + tank.addSensor(self._range, self._angle, self._width, + self._turretAttached) + +class AddToggle(Function.Function): + """addtoggle([state]) +Add a toggle to the tank. The state of the toggle defaults to 0 (False). +These essentially act as a single bit of memory. +Use the toggle() condition to check its state and the settoggle, cleartoggle, +and toggle actions to change the state. Toggles are named numerically, +starting at 0. +""" + def __init__(self, state=0): + self._state = state + + def __call__(self, tank): + if len(tank.toggles) >= tank.SENSOR_LIMIT: + raise ValueError('You can not have more than 10 toggles.') + + tank.toggles.append[self._state] + +class AddTimer(Function.Function): + """addtimer(timeout) +Add a new timer (they're numbered in the order added, starting from 0), +with the given timeout. The timeout is in number of turns. The timer +is created in inactive mode. You'll need to do a starttimer() action +to reset and start the timer. When the timer expires, the timer() +condition will begin to return True.""" + def __init__(self, timeout): + self._timeout = timeout + def __call__(self, tank): + tank.addTimer(timeout) + +setup = {'addsensor': AddSensor, + 'addtoggle': AddToggle, + 'addtimer': AddTimer} diff --git a/tanks/log.run b/tanks/log.run new file mode 100755 index 0000000..e69de29 diff --git a/tanks/run b/tanks/run new file mode 100755 index 0000000..e69de29 diff --git a/tanks/www/ctf.css b/tanks/www/ctf.css new file mode 100644 index 0000000..ca7c9f6 --- /dev/null +++ b/tanks/www/ctf.css @@ -0,0 +1,99 @@ +/**** document ****/ + +html { + background: #222 url(grunge.png) repeat-x; +} + +body { + font-family: sans-serif; + color: #eee; + margin: 50px 0 0 100px; + padding: 10px; + max-width: 700px; +} + +/**** heading ****/ + +h1:first-child { + text-transform: lowercase; + font-size: 1.6em; +/* background-color: #222; */ +/* opacity: 0.9; */ + padding: 3px; + color: #2a2; + margin: 0 0 1em 70px; +} + +h1:first-child:before { + color: #fff; + letter-spacing: -0.1em; + content: "Capture The Flag: "; +} + +/**** body ****/ + +a img { + border: 0px; +} + +a { + text-decoration: none; + color: #2a2; + font-weight: bold; +} + +a:hover { + color: #fff; + background: #2a2; + font-weight: bold; +} + + +h1, h2, h3 { + color: #999; + letter-spacing: -0.05em; +} + +code, pre, .readme { + color: #fff; + background-color: #555; + margin: 1em; +} + +th, td { + vertical-align: top; +} + +.scoreboard td { + height: 400px; +} + +p { + line-height: 1.4em; + margin-bottom: 20px; + color: #f4f4f4; +} + +dt { + white-space: pre; +} + +dt div.tab { + background-color: #333; + display: inline-block; + padding: 5px; + border: 3px solid green; + border-bottom: none; + font-weight: bold; +} + +dd { + border: 3px solid green; + margin: 0px; + padding: 5px; + background-color: #282828; +} + +fieldset * { + margin: 3px; +} diff --git a/tanks/www/docs.cgi b/tanks/www/docs.cgi new file mode 100755 index 0000000..26eb752 --- /dev/null +++ b/tanks/www/docs.cgi @@ -0,0 +1,37 @@ +#!/usr/bin/python + +print """Content-Type: text/html\n\n""" +print """\n\n""" +import cgitb; cgitb.enable() +import os +import sys + +try: + from Tanks import Program, setup, conditions, actions, docs +except: + path = os.getcwd().split('/') + path.pop() + path.append('lib') + sys.path.append(os.path.join('/', *path)) + import Program, setup, conditions, actions, docs + +print open('head.html').read() % "Documentation" +print '
' +print '" +docs.mkDocTable(setup.setup.values()) + +print '
' +docs.mkDocTable(conditions.conditions.values()) + +print '
' +docs.mkDocTable(actions.actions.values()) + +print '' diff --git a/tanks/www/grunge.png b/tanks/www/grunge.png new file mode 100644 index 0000000..2b98730 Binary files /dev/null and b/tanks/www/grunge.png differ diff --git a/tanks/www/head.html b/tanks/www/head.html new file mode 100644 index 0000000..b98713e --- /dev/null +++ b/tanks/www/head.html @@ -0,0 +1,5 @@ + +
+ ' +The data directory does not exist.' + games = [] + +if not games: + print "
No games have occurred yet." +gameNums = [] +for game in games: + try: + num = int(game) + path = os.path.join( 'data', "results", game, 'results.html') + if os.path.exists( path ): + gameNums.append( int(num) ) + else: + continue + + except: + continue + +gameNums.sort(reverse=True) + +for num in gameNums: + print '
%d - ' % num, + print 'v' % num, + print 'r' % num diff --git a/tanks/www/style.css b/tanks/www/style.css new file mode 100644 index 0000000..ac787f0 --- /dev/null +++ b/tanks/www/style.css @@ -0,0 +1,16 @@ +body { background-color : #000000; + color : #E0E0E0; + } + +table { + border : 2px solid #00EE00; + border-collapse : collapse; + margin : 3px; + } + +table td { border : 1px solid #00BB00; + padding-left: 3px; + padding-right: 3px; + text-align: left; + vertical-align: top; + } diff --git a/tanks/www/submit.cgi b/tanks/www/submit.cgi new file mode 100755 index 0000000..01ad8c8 --- /dev/null +++ b/tanks/www/submit.cgi @@ -0,0 +1,53 @@ +#!/usr/bin/python + +import cgi +import cgitb; cgitb.enable() +import os + +try: + from urllib.parse import quote +except: + from urllib import quote + +try: + from ctf import teams +except: + import sys + path = '/home/pflarr/repos/gctf/' + sys.path.append(path) + from ctf import teams + +print """Content-Type: text/html\n\n""" +print """\n\n""" +head = open('head.html').read() % "Submission Results" +print head +print "
No team specified'; done() +elif not passwd: + print '
No password given'; done() +elif not code: + print '
No program given.'; done() + +if team not in teams.teams: + print '
Team is not registered.'; done() + +if passwd != teams.teams[team][0]: + print '
Invalid password.'; done() + +path = os.path.join('data/ai/players', encode(team) ) +file = open(path, 'w') +file.write(code) +file.close() + +done() diff --git a/tanks/www/submit.html b/tanks/www/submit.html new file mode 100644 index 0000000..86cc13c --- /dev/null +++ b/tanks/www/submit.html @@ -0,0 +1,21 @@ + +
+ ' +Submit | Results | Documentation + +
+ +