def Tick(self):
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# if a component is in the smart zone but not the chassis, wait to find chassis before firing weapons
if self.compinzone == 1 and self.botinzone == 0:
self.comptimer += 1
if self.botinzone == 1:
self.comptimer = 0
if self.weapons and (self.botinzone == 1 or (self.comptimer >= self.NoChassisTime and self.compinzone == 1)):
if not self.IsUpsideDown():
if self.GetMotorAngle(self.servo) <= self.servostopangle:
self.Input("Servo", 0, 100)
else:
self.Input("Servo", 0, 0)
if self.botinzone == 0 and (self.comptimer < self.NoChassisTime or self.compinzone == 0):
#retract servo arm when not in use
if self.GetMotorAngle(self.servo) >= self.servostopangle or self.GetMotorAngle(self.servo) =< -math.pi*0.5:
self.Input("Servo", 0, 100)
if 0 > self.GetMotorAngle(self.servo) >= -math.pi*0.2 or 0 < self.GetMotorAngle(self.servo) =< self.servostopangle:
self.Input("Servo", 0, -100)
def Tick(self):
#self.tauntbox.get("taunt1").setText("Nose: " + str(self.fNoseOffset))
# this doesn't seem to do anything, but what the heck, it's not doing any harm either.
#if plus.getTimeElapsed() > 3 and self.fNoseOffset == self.originose:
if not self.weapons and self.fNoseOffset == self.originose:
plus.AI.__setattr__fNoseOffset__(self, (self.originose + math.pi))
# fire weapon
if self.weapons:
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
if AI.SuperAI.debugging:
speed = self.GetSpeed()
self.DebugString(4, "Speed = " + str(speed))
turning_speed = self.GetTurning()
self.DebugString(5, "TSpeed = " + str(turning_speed))
for trigger in self.secondary:
self.Input(trigger, 0, 0)
for trigger in self.triggers:
self.Input(trigger, 0, 0)
Target, range = self.GetNearestEnemy()
if Target != None:
Winkel = (self.GetHeadingToID(Target, False) + self.GetMotorAngle(self.Motor) * self.DSL)
self.DebugString(6, str(self.GetHeadingToID(Target, False)))
self.DebugString(7, str(-self.GetMotorAngle(self.Motor)))
self.DebugString(8, str(Winkel))
if self.AimTowards(Winkel):
for trigger in self.triggers:
self.Input(trigger, 0, 1)
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
if len(targets) > 0:
for trigger in self.secondary:
self.Input(trigger, 0, 100)
return AI.SuperAI.Tick(self)
def Tick(self):
# Don't try to self right if any part of the srimech breaks.
if not self.weapons or not self.sweapons or not self.tweapons or not self.qweapons:
self.bInvertible = True
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# if a component is in the smart zone but not the chassis, wait to find chassis before firing weapons
if self.compinzone == 1 and self.botinzone == 0:
self.comptimer += 1
if self.botinzone == 1:
self.comptimer = 0
if self.botinzone == 1 or (self.comptimer >= self.NoChassisTime
and self.compinzone == 1):
if self.weapons or self.sweapons:
for trigger in self.triggers1:
self.Input(trigger, 0, 1)
else:
for trigger in self.triggers2:
self.Input(trigger, 0, 1)
# Hit bots underneath
if self.botinzone2 == 1:
for trigger in self.triggers4:
self.Input(trigger, 0, 1)
bReturn = AI.SuperAI.Tick(self)
return bReturn
def Tick(self):
# Drive inverted if srimech breaks and srimech ID's have been set in sweapons
if not self.sweapons and self.maybInvertible == 1:
self.bInvertible = True
# fire srimech if we're stuck on our rear
if list(plus.getDirection(self.GetID(), 0))[1] > 0.9:
for trigger in self.trigger2:
self.Input(trigger, 0, 1)
# Upside-down srimech
if self.RunUpsideDown == 1 and not self.IsUpsideDown():
self.InverterTime -= 1
if self.InverterTime <= 0:
for trigger in self.trigger2:
self.Input(trigger, 0, 1)
self.InverterTime = 4
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# if a component is in the smart zone but not the chassis, wait to find chassis before firing weapons
if self.compinzone == 1 and self.botinzone == 0:
self.comptimer += 1
if self.botinzone == 1:
self.comptimer = 0
if self.weapons and (self.botinzone == 1 or
(self.comptimer >= self.NoChassisTime
and self.compinzone == 1)):
for trigger in self.triggers:
self.Input(trigger, 0, 1)
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# if a component is in the smart zone but not the chassis, wait to find chassis before firing weapons
if self.compinzone == 1 and self.botinzone == 0:
self.comptimer += 1
if self.botinzone == 1:
self.comptimer = 0
if self.weapons and (self.botinzone == 1 or
(self.comptimer >= self.NoChassisTime
and self.compinzone == 1)):
for trigger in self.triggers1:
self.Input(trigger, 0, 1)
if not self.weapons and self.sweapons and (
self.botinzone == 1 or
(self.comptimer >= self.NoChassisTime and self.compinzone == 1)):
for trigger in self.triggers3:
self.Input(trigger, 0, 1)
bReturn = AI.SuperAI.Tick(self)
return bReturn
def Tick(self):
if AI.SuperAI.debugging:
speed = self.GetSpeed()
self.DebugString(4, "Speed = " + str(speed))
turning_speed = self.GetTurning()
self.DebugString(5, "TSpeed = " + str(turning_speed))
# fire weapon
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon if being counted out, attempting to unstuck
if self.bImmobile and self.GetSpeed < 0.5:
self.Input("Fire", 0, 1)
# fire weapon when stuck on rear end...totally not ripped off FB's Seism 13
if list(plus.getDirection(self.GetID(), 0))[1] > 0.9:
self.Input("Fire", 0, 1)
# fire weapon
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
self.DebugString(4, "self.botinzone: "+ str(self.botinzone))
self.DebugString(5, "self.notMoving: "+ str(self.notMoving))
#drive inverted
if not self.sweapons:
self.bInvertible = True
#keep track of when we're not moving
if abs(self.GetSpeed()) < 1:
self.notMoving = 1
else:
self.notMoving = 0
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
if self.sweapons and self.botinzone == 1 and self.notMoving == 1 and self.weapons:
for trigger in self.triggers1: self.Input(trigger, 0, 1)
if self.sweapons and self.botinzone == 1 and not self.weapons:
for trigger in self.triggers1: self.Input(trigger, 0, 1)
bReturn = AI.SuperAI.Tick(self)
return bReturn
def Tick(self):
enemy, range = self.GetNearestEnemy()
# if spinner in range : do spin :
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
self.flipflop = True #: not used indeed
if self.flipflop :
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
if len(targets) > 0 : self.Input("Fire", 0, 1)
if self.ShiftConditionOk() and self.flipflop : #Time to shift ?
# new angle to reach :
self.servoAimAngle = self.servoAimAngle + (math.pi * 2 / self.servoNumberOfPosition)
if (self.servoAimAngle > math.pi) : self.servoAimAngle = self.servoAimAngle - (2 * math.pi)
self.wellPositionned = False
if not self.wellPositionned :
# go to servoAimAngle :
selfangle = self.GetMotorAngle(self.Motor)
Winkel = selfangle - self.servoAimAngle
self.wellPositionned = self.AimTowards(Winkel)
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
if self.weapons:
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
if self.weapons:
# spin up if enemy is in smartzone.
if self.botinzone1 == 1:
self.Input("Spin", 0, 100)
else:
self.Input("Spin", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
enemy, range = self.GetNearestEnemy()
# if spinner in range : do spin :
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
self.counterRecheck -= 1 #we check if we need to open/close arms only from time to time
if self.counterRecheck == 0:
self.haveToOpenArms = True # force to open arms
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
if len(targets) > 0:
self.Input("Fire", 0, 1)
if self.counterRecheck == 0:
self.haveToOpenArms = False # recheck if must close
if self.counterRecheck <= 0: self.counterRecheck = 3
if self.haveToOpenArms:
if self.debug: self.DebugString(8, "must OPEN ARMS")
self.isOpenArms1 = self.openArms(self.MotorOne, "Servo1", 1)
self.isOpenArms2 = self.openArms(self.MotorTwo, "Servo2", -1)
else:
if self.debug: self.DebugString(8, "must CLOSE ARMS")
self.isCloseArms1 = self.closeArms(self.MotorOne, "Servo1", 1)
self.isCloseArms2 = self.closeArms(self.MotorTwo, "Servo2", -1)
if self.isCloseArms1: self.Input("ServoFire1", 0, 1)
if self.isCloseArms2: self.Input("ServoFire2", 0, 1)
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
if len(targets) > 0:
for trigger in self.triggers:
self.Input(trigger, 0, 1)
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
targets = []
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
bReturn = AI.SuperAI.Tick(self)
# call this now so it takes place after other driving commands
if self.whipFunction and self.ThisAI_bImmobile == 0: self.whipFunction(len(targets) > 0)
if self.ThisAI_bImmobile == 1: # If Immobility is on: -------------------------------------
self.ImmobileCounter += 1 # Then start counting....
if self.ImmobileCounter >= self.ReMobilizeRoutineTime*0.2: # go backward for a designated time.
self.Throttle(100)
self.Input("LeftRight", 0, 0)
self.Input("Forward", 0, -100)
if self.ImmobileCounter >= self.ReMobilizeRoutineTime*0.6: # go forward for a designated time.
self.Input("LeftRight", 0, 0)
self.Throttle(100)
self.Input("Forward", 0, 100)
if self.ImmobileCounter >= self.ReMobilizeRoutineTime: # Reset everything:
self.ThisAI_bImmobile = 0 # default Reset (if timer goes too long).
self.ImmobileCounter = 1
else:
self.ThisAI_bImmobile = 0
self.ImmobileCounter = 0
# BackUp Immobile routine (continually running).... calculate difference of position between 2 calls
self.BU_ImmobileTimer_A +=1
if self.BU_ImmobileTimer_A >= 1:
self.ThisAIBot_XFactorA = plus.getLocation(self.GetID())[0] #
self.ThisAIBot_ZFactorA = plus.getLocation(self.GetID())[2]
if self.BU_ImmobileTimer_A == 16:
self.ThisAIBot_XFactorB = plus.getLocation(self.GetID())[0]
self.ThisAIBot_ZFactorB = plus.getLocation(self.GetID())[2]
self.BU_ImmobileTimer_A = 0 # Reset.
if self.ThisAIBot_XFactorA > self.ThisAIBot_XFactorB - .07 and self.ThisAIBot_XFactorA < self.ThisAIBot_XFactorB + .07 and self.ThisAIBot_ZFactorA > self.ThisAIBot_ZFactorB - .07 and self.ThisAIBot_ZFactorA < self.ThisAIBot_ZFactorB + .07:
self.BU_ImmobileTimer_B +=1
if self.BU_ImmobileTimer_B ==50:
self.ThisAI_bImmobile = 1
self.BU_ImmobileTimer_B = 0
else:
self.BU_ImmobileTimer_B = 0 # Reset
return bReturn
def Tick(self):
#self.DebugString(4, str(self.zone2))
# spin weapons briefly at start because for some dumb reason we can't move otherwise.
if plus.getTimeElapsed() <= self.spinup:
self.Input("Spin", 0, 100)
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None:
heading = self.GetHeadingToID(enemy, False)
# spin weapons only when necessary, and don't waste battery on them when we're being counted out!
if enemy is not None and self.weapons and range < self.spin_range and not self.bImmobile and (
self.botinzone2 == 1 or self.usespinzone == 0):
if self.pulsetime > 0 and range > self.pulse_range:
# Pulse spinner
self.pulse -= 1
if self.pulsetime2 < self.pulse < self.pulsetime:
self.Input("Spin", 0, 100)
if 0 < self.pulse < self.pulsetime2:
self.Input("Spin", 0, 0)
if self.pulse <= 0:
self.pulse = self.pulsetime
else:
self.Input("Spin", 0, 100)
else:
if plus.getTimeElapsed() > self.spinup:
self.Input("Spin", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if self.botinzone1 == 1 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
if self.botinzone3 == 1:
self.Input("Fire2", 0, 1)
bReturn = AI.SuperAI.Tick(self)
# call this now so it takes place after other driving commands
if self.goodFunction: self.goodFunction(len(targets) > 0)
return bReturn
def Tick(self):
# fire weapon (but only if the target is not upside down already)
if self.weapons:
targets = [x.robot for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
fire = False
for bot in targets:
if not plus.isUpsideDown(bot) or self.CanDriveUpsideDown(bot):
fire = True
if fire: self.Input(self.trigger, 0, 1)
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
targets = []
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
bReturn = AI.SuperAI.Tick(self)
# call this now so it takes place after other driving commands
if self.whipFunction: self.whipFunction(len(targets) > 0)
return bReturn
def Tick(self):
bReturn = Popup.Tick(self)
if self.weapons:
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
return AI.SuperAI.Tick(self)
def Tick(self):
# drive inverted
if not self.sweapons:
self.bInvertible = True
# fire weapon
if self.weapons:
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range and self.weapons and not self.IsUpsideDown(
):
self.Input("Spin", 0, 100)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
#Self right
if self.IsUpsideDown():
self.cycle += 1
if self.cycle <= self.cycletime / 2:
self.Input("Spin", 0, 100)
if self.cycle > self.cycletime / 2:
self.Input("Spin", 0, -100)
if self.cycle >= self.cycletime:
self.cycle = 0
if not self.IsUpsideDown():
self.cycle = 0
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def CheckSensors(self):
if self.zone:
self.sensors = {}
results = self.GetZoneContents(self.zone)
#print results
for reading in results:
self.SmartZoneEvent(1, 1, reading[0], reading[1])
if self.zone1:
result = self.GetZoneContents(self.zone1)
for readings in result:
if readings[0]> 0: b = readings[0] - 1
if self.reloadTime2 > 0: self.reloadTime2 -= 1
if not plus.isDefeated(b) and self.reloadTime2 <= 0:
self.Input("Fire2", 0, 1)
self.reloadTime2 = self.reloadDelay2
def Tick(self):
#self.DebugString(4, "getContacts: "+ str(len(plus.getContacts(self.GetID()))))
#self.DebugString(5, "self.contact: "+ str(self.contact))
# drive inverted
if not self.sweapons:
self.bInvertible = True
# monitor when our wheels leave the ground
if not 1 in plus.getContacts(self.GetID()):
self.contact += 1
else:
self.contact = 0
# fire weapon
if self.weapons:
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range and self.weapons and self.contact < 20:
self.Input("Spin", 0, 100)
self.Input("Spin2", 0, 0)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
if self.contact >= 20:
self.Input("Spin", 0, 0)
self.Input("Spin2", 0, 100)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
bReturn = AI.SuperAI.Tick(self)
return bReturn
def Tick(self):
#self righteous- fire weapons if balanced on rear end
if list(plus.getDirection(self.GetID(), 0))[1] > 0.9:
self.Input("Fire", 0, 1)
#self.memory = eval(open("adaptiveAI.txt").read())
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
if self.weapons and self.botinzone == 1:
self.Input("Fire", 0, 1)
#if poo:
#a= str([blah])
#output1 = file("adaptiveAI.txt", "w")
#output1.write(a)
#output1.close
#decide how to shift wedges- wide or narrow
if self.randcheck == 0:
if self.memory[0] == 0:
a = 1 - self.memory[1]
if self.undered == 0:
self.memory[1] = a
self.memory[0] = 1
file("adaptiveAI.txt", "w").write(str(self.memory))
else:
a = self.memory[1]
self.worn = a * 14
#self.worn = random.randint(0, 31)
self.snowcount = 0
self.randcheck = 1
if self.snowcount >= 6:
self.Input("Shift", 0, 0)
self.Input("Shift", 1, 0)
if self.snowcount < 6:
if self.worn < 13:
self.Input("Shift", 0, -100)
self.snowcount += 1
if self.worn >= 13:
self.Input("Shift", 1, 100)
self.snowcount += 1
return AI.SuperAI.Tick(self)
def Tick(self):
# spin weapons briefly at start because for some dumb reason we can't move otherwise.
if plus.getTimeElapsed() <= self.spinup:
self.Input("Spin1", 0, 100)
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
# spin weapons only when necessary, and don't waste battery on them when we're being counted out!
if self.weapons:
if enemy is not None and range < self.spin_range and not self.bImmobile:
self.Input("Spin1", 0, 100)
else:
if plus.getTimeElapsed() > self.spinup:
self.Input("Spin1", 0, 0)
if not self.weapons:
self.Input("Spin1", 0, 0)
if enemy is not None and range < self.spin_range and not self.bImmobile:
self.Input("Spin2", 0, 100)
else:
self.Input("Spin2", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
bReturn = AI.SuperAI.Tick(self)
# call this now so it takes place after other driving commands
if self.goodFunction: self.goodFunction()
return bReturn
def Tick(self):
#drive inverted
if not self.weapons:
self.bInvertible = True
#detect when bot is not moving
if abs(self.GetSpeed()) < 0.5:
self.notMoving = 1
else:
self.notMoving = 0
#drive backwards when upside down
if self.weapons and self.IsUpsideDown() and self.notMoving == 0:
self.Input("DriveBack", 0, 100)
if self.weapons and self.IsUpsideDown() and self.notMoving == 1:
self.Input("DriveBack", 0, -100)
if not self.IsUpsideDown():
self.Input("DriveBack", 0, 0)
# fire weapon
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# if a component is in the smart zone but not the chassis, wait to find chassis before firing weapons
if self.compinzone == 1 and self.botinzone == 0:
self.comptimer += 1
if self.botinzone == 1:
self.comptimer = 0
if self.weapons and (self.botinzone == 1 or
(self.comptimer >= self.NoChassisTime
and self.compinzone == 1)):
for trigger in self.triggers1:
self.Input(trigger, 0, 1)
bReturn = AI.SuperAI.Tick(self)
return bReturn
def Tick(self):
#self.tauntbox.get("taunt1").setText(str(list(plus.getDirection(self.GetID(),0))[1]))
# drive inverted
if not self.sweapons:
self.bInvertible = True
else:
if self.IsUpsideDown():
self.Input("Sriturn", 0, 100)
else:
self.Input("Sriturn", 0, 0)
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range and self.weapons and abs(list(plus.getDirection(self.GetID(),0))[1]) < self.troll and not self.IsUpsideDown():
self.Input("Spin", 0, 100)
else:
self.Input("Spin", 0, 0)
# fire weapon
if self.weapons:
if self.IsUpsideDown() or abs(list(plus.getDirection(self.GetID(),0))[1]) > self.troll:
self.Input("Spin", 0, -100)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
#self.tauntbox.get("taunt1").setText("Nose: " + str(self.fNoseOffset))
# Turn around if there are more weapons on the back
if len(self.weapons) < len(self.sweapons) and self.currentTactic == 0:
tactic = [x for x in self.tactics if x.name == "Ram"]
if len(tactic) > 0:
self.tactics.remove(tactic[0])
self.tactics.append(Tactics.ReverseRam(self))
self.currentTactic = 1
# Turn around again if there are more weapons in the front
if len(self.sweapons) < len(self.weapons) and self.currentTactic == 1:
tactic = [x for x in self.tactics if x.name == "ReverseRam"]
if len(tactic) > 0:
self.tactics.remove(tactic[0])
self.tactics.append(Tactics.Ram(self))
self.currentTactic = 0
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range:
self.Input("Spin", 0, 1)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
return AI.SuperAI.Tick(self)
def Tick(self):
# fire weapon
if self.weapons:
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range and not self.IsUpsideDown(
):
self.Input("Spin", 0, 100)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
if self.IsUpsideDown():
self.Input("Spin", 0, -100)
# slight delay between firing
if self.reloadTime > 0: self.reloadTime -= 1
if len(targets) > 0 and self.reloadTime <= 0:
try:
trigger = self.triggerIterator.next()
except StopIteration:
self.triggerIterator = iter(self.triggers)
trigger = self.triggerIterator.next()
self.Input(trigger, 0, 1)
self.reloadTime = self.reloadDelay
bReturn = AI.SuperAI.Tick(self)
# call this now so it takes place after other driving commands
# back up if a bot gets under us
if self.botinzone1 == 1:
self.Throttle(0)
self.Input("Fire1", 0, 100)
else:
self.Input("Fire1", 0, 0)
return bReturn
def Tick(self):
# fire weapon
if self.weapons:
# spin up depending on enemy's range
enemy, range = self.GetNearestEnemy()
if enemy is not None and range < self.spin_range and self.weapons and not self.IsUpsideDown():
self.Input("Spin", 0, 100)
elif self.GetInputStatus("Spin", 0) != 0:
self.Input("Spin", 0, 0)
if self.IsUpsideDown():
self.Input("Spin", 0, -100)
targets = [x for x in self.sensors.itervalues() if x.contacts > 0 \
and not plus.isDefeated(x.robot)]
return AI.SuperAI.Tick(self)
