+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:
+
' % (self.name, self.pos[0], self.pos[1])
+
+ def fire(self, near):
+ """Shoots, if ordered to and able. Returns the set of tanks
+ destroyed."""
+
+ killed = set()
+ if self._fireReady > 0:
+ # Ignore the shoot order
+ self._fireNow = False
+
+ if self._fireNow:
+ self._fireNow = False
+ self._fireReady = self.FIRE_RATE
+ self._fired = True
+
+
+ firePoint = gm.polar2cart(self.FIRE_RANGE,
+ self._angle + self._tAngle)
+ for tank in near:
+ enemyPos = gm.minShift(self.pos, tank.pos, self._limits)
+ if gm.segmentCircleCollision(((0,0), firePoint), enemyPos,
+ self.RADIUS):
+ killed.add(tank)
+
+ return killed
+
+ def addSensor(self, range, angle, width, attachedTurret=False):
+ """Add a sensor to this tank.
+@param angle: The angle, from the tanks front and going clockwise,
+ of the center of the sensor. (radians)
+@param width: The width of the sensor (percent).
+@param range: The range of the sensor (percent)
+@param attachedTurret: If set, the sensor moves with the turret.
+ """
+ assert range >=0 and range <= 1, "Invalid range value."
+
+ if len(self._sensors) >= self.SENSOR_LIMIT:
+ raise ValueError("You can only have 10 sensors.")
+
+ range = range * self.SENSOR_RANGE
+
+ if attachedTurret:
+ attachedTurret = True
+ else:
+ attachedTurret = False
+
+ self._sensors.append((range, angle, width, attachedTurret))
+ self._sensorState.append(False)
+
+ def getSensorState(self, key):
+ return self._sensorState[key]
+
+ @property
+ def turn(self):
+ return self._turn
+
+ def setMove(self, left, right):
+ """Parse the speed values given, and set them for the next move."""
+
+ self._nextMove = left, right
+
+ def setTurretAngle(self, angle=None):
+ """Set the desired angle of the turret. No angle means the turret
+ should remain stationary."""
+
+ if angle is None:
+ self._tGoal = None
+ else:
+ self._tGoal = gm.reduceAngle(angle)
+
+ def setFire(self):
+ """Set the tank to fire, next turn."""
+ self._fireNow = True
+
+ def fireReady(self):
+ """Returns True if the tank can fire now."""
+ return self._fireReady == 0
+
+ def addTimer(self, period):
+ """Add a timer with timeout period 'period'."""
+
+ if len(self._timers) >= self.SENSOR_LIMIT:
+ raise ValueError('You can only have 10 timers')
+
+ self._timers.append(None)
+ self._timerPeriods.append(period)
+
+ def resetTimer(self, key):
+ """Reset, and start the given timer, but only if it is inactive.
+ If it is active, raise a ValueError."""
+ if self._timer[key] is None:
+ self._timer[key] = self._timerPeriods[key]
+ else:
+ raise ValueError("You can't reset an active timer (#%d)" % key)
+
+ def clearTimer(self, key):
+ """Clear the timer."""
+ self._timer[key] = None
+
+ def checkTimer(self, key):
+ """Returns True if the timer has expired."""
+ return self._timer[key] == 0
+
+ def _manageTimers(self):
+ """Decrement each active timer."""
+ for i in range(len(self._timers)):
+ if self._timers[i] is not None and \
+ self._timers[i] > 0:
+ self._timers[i] = self._timers[i] - 1
+
+ def program(self, text):
+ """Set the program for this tank."""
+
+ self._program = Program.Program(text)
+ self._program.setup(self)
+
+ def execute(self):
+ """Execute this tanks program."""
+
+ # Decrement the active timers
+ self._manageTimers()
+ self.led = False
+
+ self._program(self)
+
+ self._move(self._nextMove[0], self._nextMove[1])
+ self._moveTurret()
+ if self._fireReady > 0:
+ self._fireReady = self._fireReady - 1
+
+ self._turn = self._turn + 1
+
+ def sense(self, near):
+ """Detect collisions and trigger sensors. Returns the set of
+ tanks collided with, plus this one. We do both these steps at once
+ mainly because all the data is available."""
+
+ near = list(near)
+ polar = []
+ for tank in near:
+ polar.append(gm.relativePolar(self.pos, tank.pos, self._limits))
+
+ for sensorId in range(len(self._sensors)):
+ # Reset the sensor
+ self._sensorState[sensorId] = False
+
+ dist, sensorAngle, width, tSens = self._sensors[sensorId]
+
+ # Adjust the sensor angles according to the tanks angles.
+ sensorAngle = sensorAngle + self._angle
+ # If the angle is tied to the turret, add that too.
+ if tSens:
+ sensorAngle = sensorAngle + self._tAngle
+
+ while sensorAngle >= 2*math.pi:
+ sensorAngle = sensorAngle - 2*math.pi
+
+ for i in range(len(near)):
+ r, theta = polar[i]
+ # Find the difference between the object angle and the sensor.
+ # The max this can be is pi, so adjust for that.
+ dAngle = gm.angleDiff(theta, sensorAngle)
+
+ rCoord = gm.polar2cart(dist, sensorAngle - width/2)
+ lCoord = gm.polar2cart(dist, sensorAngle + width/2)
+ rightLine = ((0,0), rCoord)
+ leftLine = ((0,0), lCoord)
+ tankRelPos = gm.minShift(self.pos, near[i].pos, self._limits)
+ if r < (dist + self.RADIUS):
+ if abs(dAngle) <= (width/2) or \
+ gm.segmentCircleCollision(rightLine, tankRelPos,
+ self.RADIUS) or \
+ gm.segmentCircleCollision(leftLine, tankRelPos,
+ self.RADIUS):
+
+ self._sensorState[sensorId] = True
+ break
+
+ # Check for collisions here, since we already have all the data.
+ collided = set()
+ for i in range(len(near)):
+ r, theta = polar[i]
+ if r < (self.RADIUS + near[i].RADIUS):
+ collided.add(near[i])
+
+ # Add this tank (a collision kills both, after all
+ if collided:
+ collided.add(self)
+
+ return collided
+
+ def die(self, reason):
+ self.isDead = True
+ self.deathReason = reason
+
+ def _moveTurret(self):
+ if self._tGoal is None or self._tAngle == self._tGoal:
+ return
+
+ diff = gm.angleDiff(self._tGoal, self._tAngle)
+
+ if abs(diff) < self.TURRET_TURN_RATE:
+ self._tAngle = self._tGoal
+ elif diff > 0:
+ self._tAngle = gm.reduceAngle(self._tAngle - self.TURRET_TURN_RATE)
+ else:
+ self._tAngle = gm.reduceAngle(self._tAngle + self.TURRET_TURN_RATE)
+
+ def _move(self, lSpeed, rSpeed):
+
+ assert abs(lSpeed) <= 100, "Bad speed value: %s" % lSpeed
+ assert abs(rSpeed) <= 100, "Bad speed value: %s" % rSpeed
+
+ # Handle acceleration
+ if self._lastSpeed[0] < lSpeed and \
+ self._lastSpeed[0] + self.ACCEL < lSpeed:
+ lSpeed = self._lastSpeed[0] + self.ACCEL
+ elif self._lastSpeed[0] > lSpeed and \
+ self._lastSpeed[0] - self.ACCEL > lSpeed:
+ lSpeed = self._lastSpeed[0] - self.ACCEL
+
+ if self._lastSpeed[1] < rSpeed and \
+ self._lastSpeed[1] + self.ACCEL < rSpeed:
+ rSpeed = self._lastSpeed[1] + self.ACCEL
+ elif self._lastSpeed[1] > rSpeed and \
+ self._lastSpeed[1] - self.ACCEL > rSpeed:
+ rSpeed = self._lastSpeed[1] - self.ACCEL
+
+ self._lastSpeed = lSpeed, rSpeed
+
+ # The simple case
+ if lSpeed == rSpeed:
+ fSpeed = self.SPEED*lSpeed/100
+ x = fSpeed*math.cos(self._angle)
+ y = fSpeed*math.sin(self._angle)
+ # Adjust our position
+ self._reposition((x,y), 0)
+ return
+
+ # The works as follows:
+ # The tank drives around in a circle of radius r, which is some
+ # offset on a line perpendicular to the tank. The distance it travels
+ # around the circle varies with the speed of each tread, and is
+ # such that each side of the tank moves an equal angle around the
+ # circle.
+ L = self.SPEED * lSpeed/100.0
+ R = self.SPEED * rSpeed/100.0
+ friction = .75 * abs(L-R)/(2.0*self.SPEED)
+ L = L * (1 - friction)
+ R = R * (1 - friction)
+
+ # Si is the speed of the tread on the inside of the turn,
+ # So is the speed on the outside of the turn.
+ # dir is to note the direction of rotation.
+ if abs(L) > abs(R):
+ Si = R; So = L
+ dir = 1
+ else:
+ Si = L; So = R
+ dir = -1
+
+ # The width of the tank...
+ w = self.RADIUS * 2
+
+ # This is the angle that will determine the circle the tank travels
+ # around.
+# theta = math.atan((So - Sl)/w)
+ # This is the distance from the outer tread to the center of the
+ # circle formed by it's movement.
+ r = w*So/(So - Si)
+
+ # The fraction of the circle traveled is equal to the speed of
+ # the outer tread over the circumference of the circle.
+ # Ft = So/(2*pi*r)
+ # The angle traveled is equal to the Fraction traveled * 2 * pi
+ # This reduces to a simple: So/r
+ # We multiply it by dir to adjust for the direction of rotation
+ theta = So/r * dir
+
+ # These are the offsets from the center of the circle, given that
+ # the tank is turned in some direction. The tank is facing
+ # perpendicular to the circle
+ # So far everything has been relative to the outer tread. At this
+ # point, however, we need to move relative to the center of the
+ # tank. Hence the adjustment in r.
+ x = -math.cos( self._angle + math.pi/2*dir ) * (r - w/2.0)
+ y = -math.sin( self._angle + math.pi/2*dir ) * (r - w/2.0)
+
+ # Now we just rotate the tank's position around the center of the
+ # circle to get the change in coordinates.
+ mx, my = gm.rotatePoint((x,y), theta)
+ mx = mx - x
+ my = my - y
+
+ # Finally, we shift the tank relative to the playing field, and
+ # rotate it by theta.
+ self._reposition((mx, my), theta)
+
+ def _reposition(self, move, angleChange):
+ """Move the tank by x,y = move, and change it's angle by angle.
+ I assume the tanks move slower than the boardSize."""
+
+ x = self.pos[0] + move[0]
+ y = self.pos[1] + move[1]
+ self._angle = self._angle + angleChange
+
+ if x < 0:
+ x = self._limits[0] + x
+ elif x > self._limits[0]:
+ x = x - self._limits[0]
+
+ if y < 0:
+ y = self._limits[1] + y
+ elif y > self._limits[1]:
+ y = y - self._limits[1]
+
+ self.pos = round(x), round(y)
+
+ while self._angle < 0:
+ self._angle = self._angle + math.pi * 2
+
+ while self._angle > math.pi * 2:
+ self._angle = self._angle - math.pi * 2
+
+ # A rectangle starting 2 pixels past the tank front, and two pixels to the
+ # side. width = 4, height = 18.
+ tread1 = [(9,-9), (9, -5), (-8, -5), (-8, -9)]
+ # Same as tread one, except to the right.
+ tread2 = [(9, 9), (9,5), (-8,5), (-8,9)]
+ # A circle of radius 7.5 centered on center
+ body = [(-6,-6), (6,6)]
+ gun = [(0, -2), (0,2), (12,1), (12,-1)]
+ ledPoly = [(0, -2), (0,2), (-2,2), (-2,-2)]
+ hood = [(8, -6), (8, 6), (-7, 6), (-7, -6)]
+ laser = [(12,2), (FIRE_RANGE, 2), (FIRE_RANGE,-2), (12, -2)]
+ treadColor = '#777777'
+ def draw(self, image):
+
+ d = ImageDraw.Draw(image)
+
+ if self.isDead:
+ if self._deadFrame > 0:
+ # Draw the explosion instead of the normal art
+ self._drawExplosion(d)
+ self._drawLaser(d)
+ return image
+
+ if self._testMode:
+ self._drawSensors(d)
+
+ hood = gm.rotatePoly(self.hood, self._angle)
+ tread1 = gm.rotatePoly(self.tread1, self._angle)
+ tread2 = gm.rotatePoly(self.tread2, self._angle)
+ gun = gm.rotatePoly( self.gun, self._angle + self._tAngle )
+ led = gm.rotatePoly( self.ledPoly, self._angle + self._tAngle )
+
+ # The base body rectangle.
+ for poly in gm.displacePoly(hood, self.pos, self._limits):
+ d.polygon( poly, fill=self._color )
+
+ # The treads
+ for poly in gm.displacePoly(tread1, self.pos, self._limits) + \
+ gm.displacePoly(tread2, self.pos, self._limits):
+ d.polygon( poly, fill=self.treadColor )
+
+ # The turret circle
+ for poly in gm.displacePoly(self.body, self.pos, self._limits):
+ d.ellipse( poly, fill=self._color, outline='black')
+
+ self._drawLaser(d)
+
+ for poly in gm.displacePoly(gun, self.pos, self._limits):
+ d.polygon( poly, fill='#000000')
+
+ if self.led:
+ for poly in gm.displacePoly(led, self.pos, self._limits):
+ d.polygon( poly, fill='#ffffff')
+
+ def _drawLaser(self, drawing):
+ """Draw the laser line if we shot this turn."""
+ if self._fired:
+ laser = gm.rotatePoly( self.laser, self._angle + self._tAngle )
+ for poly in gm.displacePoly(laser, self.pos, self._limits):
+ drawing.polygon(poly, fill=self._color)
+
+ self._fired = False
+
+ def _drawExplosion(self, drawing):
+ """Draw the tank exploding."""
+
+ self._deadFrame = self._deadFrame - 1
+ innerBoom = []
+ outerBoom = []
+ points = 20
+ for i in range(points):
+ if i%2 == 1:
+ radius = 1.5 * self.RADIUS / 2
+ else:
+ radius = 1.5 * self.RADIUS
+ innerBoom.append(gm.polar2cart(radius/2, i*2*math.pi/points))
+ outerBoom.append(gm.polar2cart(radius, i*2*math.pi/points))
+
+ for poly in gm.displacePoly(outerBoom, self.pos, self._limits):
+ drawing.polygon(poly, fill='red')
+ for poly in gm.displacePoly(innerBoom, self.pos, self._limits):
+ drawing.polygon(poly, fill='orange')
+
+ def _drawSensors(self, drawing):
+ """Draw sensor arcs for all of the defined sensors."""
+
+ for i in range( len( self._sensors) ):
+ if self._sensorState[i]:
+ color = '#000000'
+ else:
+ color = self._color
+
+ r, angle, width, tAttached = self._sensors[i]
+ r = int(r)
+ sensorCircle = [(-r, -r), (r, r)]
+ angle = angle + self._angle
+ if tAttached:
+ angle = angle + self._tAngle
+ min = int( math.degrees( angle - width/2 ) )
+ max = int( math.degrees( angle + width/2 ) )
+ for poly in gm.displacePoly(sensorCircle, self.pos, self._limits,
+ coordSequence=True):
+ drawing.chord(poly, min, max, outline=color)
diff --git a/tanks/lib/__init__.py b/tanks/lib/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tanks/lib/actions.py b/tanks/lib/actions.py
new file mode 100644
index 0000000..790afab
--- /dev/null
+++ b/tanks/lib/actions.py
@@ -0,0 +1,123 @@
+"""Define new action Functions here. They should inherit from the
+Function.Function class. To make an action usable, add it to the
+actions dictionary at the end of this file."""
+
+import Function
+
+class Move(Function.Function):
+ """move(left tread speed, right tread speed)
+ Set the speeds for the tanks right and left treads. The speeds should
+ be a number (percent power) between -100 and 100."""
+
+ def __init__(self, left, right):
+ self._checkRange(left, 'left tread speed', min=-100)
+ self._checkRange(right, 'right tread speed', min=-100)
+
+ self._left = left
+ self._right = right
+
+ def __call__(self, tank):
+ tank.setMove(self._left, self._right)
+
+class TurretCounterClockwise(Function.Function):
+ """turretccw([percent speed])
+ Rotate the turret counter clockwise as a percentage of the max speed."""
+ def __init__(self, speed=100):
+ self._checkRange(speed, 'turret percent speed')
+ self._speed = speed/100.0
+ def __call__(self, tank):
+ tank.setTurretAngle(tank._tAngle - tank.TURRET_TURN_RATE*self._speed)
+
+class TurretClockwise(Function.Function):
+ """turretcw([percent speed])
+ Rotate the turret clockwise at a rate preportional to speed."""
+
+ def __init__(self, speed=100):
+ self._checkRange(speed, 'turret percent speed')
+ self._speed = speed/100.0
+ def __call__(self, tank):
+ tank.setTurretAngle(tank._tAngle + tank.TURRET_TURN_RATE*self._speed)
+
+class TurretSet(Function.Function):
+ """turretset([angle])
+ Set the turret to the given angle, in degrees, relative to the front of
+ the tank. Angles increase counterclockwise.
+ The angle can be left out; in that case, this locks the turret
+ to it's current position."""
+
+ def __init__(self, angle=None):
+ # Convert the angle to radians
+ if angle is not None:
+ angle = self._convertAngle(angle, 'turret angle')
+
+ self._angle = angle
+
+ def __call__(self, tank):
+ tank.setTurretAngle(self._angle)
+
+class Fire(Function.Function):
+ """fire()
+ Attempt to fire the tanks laser cannon."""
+
+ def __call__(self, tank):
+ tank.setFire()
+
+class SetToggle(Function.Function):
+ """settoggle(key, state)
+Set toggle 'key' to 'state'.
+"""
+ def __init__(self, key, state):
+ self._key = key
+ self._state = state
+ def __call__(self, tank):
+ tank.toggles[self._key] = self._state
+
+class Toggle(Function.Function):
+ """toggle(key)
+Toggle the value of toggle 'key'.
+"""
+ def __init__(self, key):
+ self._key = key
+ def __call__(self, tank):
+ tank.toggles[key] = not tank.toggles[key]
+
+class LED(Function.Function):
+ """led(state)
+Set the tanks LED to state (true is on, false is off).
+The led is a light that appears behind the tanks turret.
+It remains on for a single turn."""
+ def __init__(self, state=1):
+ self._state = state
+ def __call__(self, tank):
+ tank.led = self._state
+
+class StartTimer(Function.Function):
+ """starttimer(#)
+Start (and reset) the given timer, but only if it is inactive.
+"""
+ def __init__(self, key):
+ self._key = key
+ def __call__(self, tank):
+ tank.resetTimer(key)
+
+class ClearTimer(Function.Function):
+ """cleartimer(#)
+Clear the given timer such that it is no longer active (inactive timers
+are always False)."""
+ def __init__(self, key):
+ self._key = key
+ def __call__(self, tank):
+ tank.clearTimer(self._key)
+
+### When adding names to this dict, make sure they are lower case and alpha
+### numeric.
+actions = {'move': Move,
+ 'turretccw': TurretCounterClockwise,
+ 'turretcw': TurretClockwise,
+ 'turretset': TurretSet,
+ 'fire': Fire,
+ 'settoggle': SetToggle,
+ 'toggle': Toggle,
+ 'led': LED,
+ 'starttimer': StartTimer,
+ 'cleartimer': ClearTimer}
diff --git a/tanks/lib/conditions.py b/tanks/lib/conditions.py
new file mode 100644
index 0000000..3a6c0ac
--- /dev/null
+++ b/tanks/lib/conditions.py
@@ -0,0 +1,125 @@
+"""Define new condition functions here. Add it to the conditions dictionary
+at the end to make it usable by Program.Program. These should inherit from
+Function.Function."""
+
+import Function
+import random
+
+class Sense(Function.Function):
+ """sense(#, [invert])
+ Takes a Sensor number as an argument.
+ Returns True if the given sensor is currently activated, False otherwise.
+ If the option argument invert is set to true then logic is inverted,
+ and then sensor returns True when it is NOT activated, and False when
+ it is. Invert is false by default.
+ """
+
+ def __init__(self, sensor, invert=0):
+ self._sensor = sensor
+ self._invert = invert
+
+ def __call__(self, tank):
+ state = tank.getSensorState(self._sensor)
+ if self._invert:
+ return not state
+ else:
+ return state
+
+class Toggle(Function.Function):
+ """toggle(#)
+Returns True if the given toggle is set, False otherwise. """
+ def __init__(self, toggle):
+ self._toggle = toggle
+ def __call__(self, tank):
+ return tank.toggles[toggle]
+
+class TimerCheck(Function.Function):
+ """timer(#, [invert])
+Checks the state of timer # 'key'. Returns True if time has run out.
+If invert is given (and true), then True is returned if the timer has
+yet to expire.
+"""
+ def __init__(self, key, invert=0):
+ self._key = key
+ self._invert = invert
+ def __call__(self, tank):
+ state = tank.checkTimer(self._key)
+ if invert:
+ return not state
+ else:
+ return state
+
+class Random(Function.Function):
+ """random(n,m)
+ Takes two arguments, n and m. Generates a random number between 1
+ and m (inclusive) each time it's checked. If the random number is less
+ than or equal
+ to n, then the condition returns True. Returns False otherwise."""
+
+ def __init__(self, n, m):
+ self._n = n
+ self._m = m
+
+ def __call__(self, tank):
+ if random.randint(1,self._m) <= self._n:
+ return True
+ else:
+ return False
+
+class Sin(Function.Function):
+ """sin(T)
+ A sin wave of period T (in turns). Returns True when the wave is positive.
+ A wave with period 1 or 2 is always False (it's 0 each turn), only
+ at periods of 3 or more does this become useful."""
+
+ def __init__(self, T):
+ self._T = T
+
+ def __call__(self, tank):
+ turn = tank.turn
+ factor = math.pi/self._T
+ if math.sin(turn * factor) > 0:
+ return True
+ else:
+ return False
+
+class Cos(Function.Function):
+ """cos(T)
+ A cos wave with period T (in turns). Returns True when the wave is
+ positive. A wave of period 1 is always True. Period 2 is True every
+ other turn, etc."""
+
+ def __init__(self, T):
+ self._T = T
+
+ def __call__(self, tank):
+
+ turn = tank.turn
+ factor = math.pi/self._T
+ if math.cos(turn * factor) > 0:
+ return True
+ else:
+ return False
+
+class FireReady(Function.Function):
+ """fireready()
+ True when the tank can fire."""
+ def __call__(self, tank):
+ return tank.fireReady()
+
+class FireNotReady(Function.Function):
+ """firenotready()
+ True when the tank can not fire."""
+ def __call__(self, tank):
+ return not tank.fireReady()
+
+### When adding names to this dict, make sure they are lower case and alpha
+### numeric.
+conditions = {'sense': Sense,
+ 'random': Random,
+ 'toggle': Toggle,
+ 'sin': Sin,
+ 'cos': Cos,
+ 'fireready': FireReady,
+ 'firenotready': FireNotReady,
+ 'timer': TimerCheck }
diff --git a/tanks/lib/docs.py b/tanks/lib/docs.py
new file mode 100644
index 0000000..1724d52
--- /dev/null
+++ b/tanks/lib/docs.py
@@ -0,0 +1,27 @@
+import xml.sax.saxutils
+
+def mkDocTable(objects):
+ objects.sort(lambda o1, o2: cmp(o1.__doc__, o2.__doc__))
+
+ for object in objects:
+ print ''
+ if object.__doc__ is None:
+ print '| %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 - %s
' % (head, body)
+ #print ' |
| %s | Intentionally blank | |
|---|
| %s' % (head, body)
+ print ' |
'
+
diff --git a/tanks/lib/setup.py b/tanks/lib/setup.py
new file mode 100644
index 0000000..29bc861
--- /dev/null
+++ b/tanks/lib/setup.py
@@ -0,0 +1,72 @@
+"""Each of these classes provides a function for configuring a tank.
+They should inherit from Function.Function.
+To make one available to the tank programmer, add it to the dictionary at
+the end of this file."""
+
+import Function
+
+class AddSensor(Function.Function):
+ """addsensor(range, angle, width, [turretAttached])
+Add a new sensor to the tank. Sensors are an arc (pie slice) centered on
+the tank that detect other tanks within their sweep.
+A sensor is 'on' if another tank is within this arc.
+Sensors are numbered, starting at 0, in the order they are added.
+
+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..c4eff97
--- /dev/null
+++ b/tanks/log.run
@@ -0,0 +1,3 @@
+#! /bin/sh
+
+exec logger -t tanks
diff --git a/tanks/report_score.py b/tanks/report_score.py
new file mode 100755
index 0000000..32e958e
--- /dev/null
+++ b/tanks/report_score.py
@@ -0,0 +1,16 @@
+#!/usr/bin/python3.0
+
+from ctf.flagd import Flagger
+
+key = 'tanks:::2bac5e912ff2e1ad559b177eb5aeecca'
+
+f = Flagger.Flagger('localhost', key)
+
+while 1:
+ time.sleep(1)
+ try:
+ winner = open('/var/lib/tanks/winner').read()
+ except:
+ winner = None
+
+ f.set_flag(winner)
diff --git a/tanks/run b/tanks/run
new file mode 100755
index 0000000..a8157be
--- /dev/null
+++ b/tanks/run
@@ -0,0 +1,6 @@
+#! /bin/sh
+
+[ -f /var/lib/ctf/disabled/tanks ] && exit 0
+
+envuidgid ctf python2.6 run_tanks.py /var/lib/tanks/ easy 100 &
+envuidgid ctf report_score.py
diff --git a/tanks/run_tanks.py b/tanks/run_tanks.py
new file mode 100644
index 0000000..4263e15
--- /dev/null
+++ b/tanks/run_tanks.py
@@ -0,0 +1,20 @@
+import time
+from tanks import Pflanzarr
+import sys
+
+T = 60*5
+
+try:
+ while 1:
+ start = time.time()
+ p = Pflanzarr(sys.argv[1], sys.argv[2])
+ p.run(int(sys.argv[3]))
+
+ diff = time.time() - start
+ if diff - T > 0:
+ time.sleep( diff - T )
+
+except:
+ print 'Usage: python2.6 run_tanks.py data_dir easy|medium|hard max_turns'
+
+
diff --git a/tanks/www/Config.py b/tanks/www/Config.py
new file mode 100644
index 0000000..4821f03
--- /dev/null
+++ b/tanks/www/Config.py
@@ -0,0 +1 @@
+DATA_PATH = '/var/lib/tanks/'
diff --git a/tanks/www/ctf.css b/tanks/www/ctf.css
new file mode 100644
index 0000000..f3b91d1
--- /dev/null
+++ b/tanks/www/ctf.css
@@ -0,0 +1,100 @@
+/**** 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, div.errors {
+ 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..8ceb4d0
--- /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 'Pflanzarr Documentation
'
+print open('links.html').read()
+print Program.__doc__
+
+print 'Setup Actions:
'
+print 'These functions can be used to setup your tank. Abuse of these functions has, in the past, resulted in mine sweeping duty. With a broom.'
+print ""
+docs.mkDocTable(setup.setup.values())
+
+print '
Conditions:
'
+print 'These functions are used to check the state of reality. If reality stops being real, refer to chapter 5 in your girl scout handbook.'
+docs.mkDocTable(conditions.conditions.values())
+
+print '
Actions:
'
+print 'These actions are not for cowards. Remember, if actions contradict, your tank will simply do the last thing it was told in a turn. If ordered to hop on a plane to hell it will gladly do so. If order to make tea shortly afterwards, it will serve it politely and with cookies instead.'
+docs.mkDocTable(actions.actions.values())
+
+print ''
diff --git a/tanks/www/errors.cgi b/tanks/www/errors.cgi
new file mode 100755
index 0000000..1359cc9
--- /dev/null
+++ b/tanks/www/errors.cgi
@@ -0,0 +1,69 @@
+#!/usr/bin/python
+
+print """Content-Type: text/html\n\n"""
+print """\n\n"""
+import cgi
+import cgitb; cgitb.enable()
+import os
+
+import Config
+
+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
+teams.build_teams()
+
+head = open('head.html').read() % "Error Report"
+print head
+print open('links.html').read()
+
+def done():
+ print '