def getSendData(turn, thrust):
#Metadata
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackHeadRelative = (tracking - heading) / 360
speed = ai.selfSpeed() / 10
#Wall Feelers
trackWall = ai.wallFeeler(500, tracking)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
leftF = ai.wallFeeler(500, heading + 70)
leftB = ai.wallFeeler(500, heading + 110)
rightF = ai.wallFeeler(500, heading - 70)
rightB = ai.wallFeeler(500, heading - 110)
backL = ai.wallFeeler(500, heading - 200)
backR = ai.wallFeeler(500, heading - 160)
data = [trackHeadRelative, speed]
for i in [
trackWall, frontL, frontR, leftF, leftB, rightF, rightB, backL,
backR
]:
if i == -1:
data.append(0)
else:
data.append(1 - i / 500)
for j in [turn, thrust]:
data.append(j)
return data
def getSendData(turn, thrust):
#Metadata
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackHeadRelative = (tracking - heading) / 360
speed = ai.selfSpeed() / 10
#Wall Feelers
trackWall = ai.wallFeeler(500, tracking)
trackL3 = ai.wallFeeler(500, tracking + 3)
trackL10 = ai.wallFeeler(500, tracking + 10)
trackR3 = ai.wallFeeler(500, tracking - 3)
trackR10 = ai.wallFeeler(500, tracking - 10)
frontWall = ai.wallFeeler(500, heading)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500, heading + 90)
rightWall = ai.wallFeeler(500, heading - 90)
backWall = ai.wallFeeler(500, heading - 180)
backL = ai.wallFeeler(500, heading - 185)
backR = ai.wallFeeler(500, heading - 175)
data = [heading / 360, tracking / 360, trackHeadRelative, speed]
for i in [
trackWall, trackL3, trackL10, trackR3, trackR10, frontWall, frontL,
frontR, leftWall, rightWall, backWall, backL, backR
]:
if i == -1:
data.append(0)
else:
data.append(1 - i / 500)
for j in [turn, thrust]:
data.append(j)
return data
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + 90)
rightWall = ai.wallFeeler(500, heading - 90)
trackWall = ai.wallFeeler(500, tracking)
#Thrust rules
if ai.selfSpeed() <= 1 and frontWall >= 20:
ai.thrust(1)
elif trackWall < 40:
ai.thrust(1)
#Turn rules
if leftWall < rightWall:
ai.turnRight(1)
else:
ai.turnLeft(1)
#Just keep shooting
ai.fireShot()
def getSendData(turn,thrust,shoot):
#make all the feelers/get current sichuation data
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackHeadRelative = (tracking-heading)/360
trackWall = ai.wallFeeler(500, tracking)
trackL3 = ai.wallFeeler(500, tracking + 3)
trackL10 = ai.wallFeeler(500, tracking + 10)
trackR3 = ai.wallFeeler(500, tracking - 3)
trackR10 = ai.wallFeeler(500, tracking - 10)
frontWall = ai.wallFeeler(500, heading)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500, heading+90)
rightWall = ai.wallFeeler(500,heading-90)
backWall = ai.wallFeeler(500, heading - 180)
backL = ai.wallFeeler(500, heading - 185)
backR = ai.wallFeeler(500, heading - 175)
speed = ai.selfSpeed()/10
#get position to enemy
enemyX = ai.screenEnemyX(0)
enemyY = ai.screenEnemyY(0)
selfX = ai.selfX()
selfY = ai.selfY()
enemyDegrees = (heading - (math.degrees(math.atan2(enemyY-selfY,enemyX-selfX))+360)%360)/360
#enemyDegrees = heading - math.degrees(math.atan2(enemyY-selfY,enemyX-selfX))-360
enemySpeed = ai.enemySpeed(0)/10
enemyMoveDirection = ai.enemyTrackingDeg(0)
distanceToEnemy = 1 - math.sqrt((selfX-enemyX)**2 + (selfY-enemyY)**2)/500
relativeTracking = (tracking-180)/360-(enemyMoveDirection-180)/360
#get shots at us
data = [heading/360,tracking/360,trackHeadRelative,speed]
for i in [trackWall,trackL3,trackL10,trackR3,trackR10,frontWall,frontL,frontR,leftWall,rightWall,backWall,backL,backR]:
if i == -1:
data.append(0)
else:
data.append(1 - i/500)
for j in [enemySpeed,enemyDegrees,relativeTracking,distanceToEnemy]:
if not math.isnan(j):
if enemyX == -1:
data.append(0)
else:
data.append(j)
else:
data.append(0)
for k in [turn,thrust,shoot]:
data.append(k)
#print("distToEnemy",data[20]*500,"relTrack",data[19]*360)
return data
def updateInputs(self):
#The code in config is inserted into the updateInputs function so you can pull any data you want using ai.(some xpilot-ai function) and adding it with self.addInput("Some Float")
#You can technically also add outputs with self.addOutput if you want your neural network to predict or control something beyond normal but this might not work nicely with the autogenerated controller
#The trainer checks the size of both the input and output datasets and will build a network to accomodate these sizes automatically
#Until the next comment is code for pulling relevant data from the game
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
backWall = ai.wallFeeler(500, heading - 180)
backLeftWall = ai.wallFeeler(500, heading - 190)
backRightWall = ai.wallFeeler(500, heading - 170)
frontWall = ai.wallFeeler(500,heading)
flWall = ai.wallFeeler(500, heading + 10)
frWall = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500,heading+90)
llWall = ai.wallFeeler(500, heading + 100)
rlWall = ai.wallFeeler(500, heading + 80)
rightWall = ai.wallFeeler(500,heading-90)
lrWall = ai.wallFeeler(500, heading - 80)
rrWall = ai.wallFeeler(500, heading - 100)
calcDir = -1
targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0)
if targetX- ai.selfX() != 0:
calcDir = (math.degrees(math.atan2((targetY - ai.selfY()), (targetX- ai.selfX()))) + 360)%360
speed = ai.selfSpeed()
fFan = min(frontWall, flWall, frWall)
lFan = min(leftWall, llWall, rlWall)
rFan = min(rightWall, rrWall, lrWall)
bFan = min(backWall, backLeftWall, backRightWall)
trackWall = ai.wallFeeler(500, tracking)
#Everything below here is just selecting inputs for training - play around by commenting and uncommenting different inputs, or try adding your own!
self.addInput(frontWall)
self.addInput(leftWall)
self.addInput(rightWall)
self.addInput(backWall)
self.addInput(trackWall)
self.addInput(backLeftWall)
self.addInput(backRightWall)
#self.addInput(fFan)
#self.addInput(rFan)
#self.addInput(lFan)
#self.addInput(bFan)
#self.addInput(tracking)
self.addInput(heading)
self.addInput(calcDir)
self.addInput(speed)
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + 90)
rightWall = ai.wallFeeler(500, heading - 90)
trackWall = ai.wallFeeler(500, tracking)
#Thrust rules
print("i am heading")
print(heading)
print(frontWall)
print(leftWall)
print(rightWall)
print("front left right")
if ai.selfSpeed() <= 5 and frontWall >= 20:
ai.thrust(1)
elif trackWall < 20:
ai.thrust(1)
#Turn rules
# if leftWall < rightWall:
# ai.turnRight(1)
# else:
# ai.turnLeft(1)
#------------------------
degList = []
deg = 0
for i in range(9):
degree = heading + deg
degList.append(ai.wallFeeler(500, degree))
deg = deg + 45
highestDist = 0
print(degList)
for element in degList:
if element >= highestDist:
highestDist = element
print("highestDist")
print(highestDist)
print("index of highestdist")
print(degList.index(highestDist))
ai.turn(heading + ((degList.index(highestDist)) * 45))
print("the way to turn")
print(heading + ((degList.index(highestDist)) * 45))
#-------------------------------
#Just keep shooting
ai.fireShot()
def AI_loop(self):
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#-------------------- Set variables --------------------#
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + 45)
rightWall = ai.wallFeeler(500, heading - 45)
leftWallStraight = ai.wallFeeler(500, heading + 90)
rightWallStraight = ai.wallFeeler(500, heading - 90)
leftBack = ai.wallFeeler(500, heading + 135)
rightBack = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
R = (heading - 90) % 360
L = (heading + 90) % 360
aim = ai.aimdir(0)
bullet = ai.shotAlert(0)
speed = ai.selfSpeed()
message = ai.scanMsg(0)
x = ai.selfX()
y = ai.selfY()
if "***" in message:
coordMessage = message.split("***")[1]
coordinatesString = coordMessage.strip().split(" [")[0]
coordinates = eval(coordinatesString)
closestEnemyX = coordinates[0]
closestEnemyY = coordinates[1]
toTurn = self.angleToPoint(x, y, closestEnemyX, closestEnemyY,
heading)
distance = self.distance(x, closestEnemyX, y, closestEnemyY)
#-------------------- Move to target point --------------------#
if toTurn > 0 and toTurn < 20 and distance > 300:
ai.thrust(1)
ai.turnLeft(0)
ai.turnRight(0)
elif toTurn >= 20:
ai.turnRight(1)
elif toTurn <= 0:
ai.turnLeft(1)
if self.counter % 300 == 0:
self.foundPrey((900, 400))
self.counter = self.counter + 1
def getSendDataV1():
#make all the feelers/get current sichuation data
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
trackL3 = ai.wallFeeler(500, tracking + 3)
trackL10 = ai.wallFeeler(500, tracking + 10)
trackR3 = ai.wallFeeler(500, tracking - 3)
trackR10 = ai.wallFeeler(500, tracking - 10)
frontWall = ai.wallFeeler(500, heading)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500, heading + 90)
rightWall = ai.wallFeeler(500, heading - 90)
backWall = ai.wallFeeler(500, heading - 180)
backL = ai.wallFeeler(500, heading - 185)
backR = ai.wallFeeler(500, heading - 175)
speed = ai.selfSpeed()
#get position to enemy
enemyX = ai.screenEnemyX(0)
enemyY = ai.screenEnemyY(0)
selfX = ai.selfX()
selfY = ai.selfY()
enemyDegrees = (math.degrees(math.atan2(enemyY - selfY, enemyX - selfX)) +
360) % 360
enemySpeed = ai.enemySpeed(0)
enemyMoveDirection = ai.enemyTrackingDeg(0)
#get shots at us
data = [heading / 360, tracking / 360]
for i in [
trackWall, trackL3, trackL10, trackR3, trackR10, frontWall, frontL,
frontR, leftWall, rightWall, backWall, backL, backR
]:
if i == -1:
data.append(1)
else:
data.append(i / 500)
for j in [speed, enemyDegrees / 360, enemySpeed, enemyMoveDirection / 360]:
if not math.isnan(j):
data.append(j)
else:
data.append(1)
return data
def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) #Set variables heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) frontWall = ai.wallFeeler(500,heading) left45Wall = ai.wallFeeler(500,heading+45) right45Wall = ai.wallFeeler(500,heading-45) left90Wall = ai.wallFeeler(500,heading+90) right90Wall = ai.wallFeeler(500,heading-90) left135Wall = ai.wallFeeler(500,heading+135) right135Wall = ai.wallFeeler(500,heading-135) backWall = ai.wallFeeler(500,heading-180) trackWall = ai.wallFeeler(500,tracking)
def getSendData():
#Metadata
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackHeadRelative = (tracking - heading) / 360
speed = ai.selfSpeed() / 10
#Wall Feelers
trackWall = ai.wallFeeler(500, tracking)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
left = ai.wallFeeler(500, heading + 90)
right = ai.wallFeeler(500, heading - 90)
backL = ai.wallFeeler(500, heading - 200)
backR = ai.wallFeeler(500, heading - 160)
data = [heading / 360, tracking / 360, trackHeadRelative, speed]
for i in [trackWall, frontL, frontR, left, right, backL, backR]:
if i == -1:
data.append(0)
else:
data.append(1 - i / 500)
return data
def AI_loop():
chrom = [
0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1,
1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0
]
when_to_thrust_speed = convert(chrom[0:4])
front_wall_distance_thrust = convert(chrom[4:8]) * 4
back_wall_distance_thrust = convert(chrom[8:12]) * 2
track_wall_distance_thrust = convert(chrom[12:16]) * 4
left_wall_angle = convert(chrom[16:20]) * 3
right_wall_angle = convert(chrom[20:24]) * 3
back_wall_angle = convert(chrom[24:28]) * 10
left_90_wall_angle = convert(chrom[28:32]) * 6
right_90_wall_angle = convert(chrom[32:36]) * 6
left_back_wall_angle = convert(chrom[36:40]) * 9
right_back_wall_angle = convert(chrom[44:48]) * 9
fuzzy_rate = convert(chrom[48:52])
fuzzy_rate_1 = convert(chrom[52:56])
angle_diff_shoot = convert(chrom[56:60])
shot_alert_distance = convert(chrom[60:64]) * 6
rate = fuzzy_rate
rate1 = fuzzy_rate_1
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + left_wall_angle)
rightWall = ai.wallFeeler(500, heading - right_wall_angle)
left90Wall = ai.wallFeeler(500, heading + left_90_wall_angle)
right90Wall = ai.wallFeeler(500, heading - right_90_wall_angle)
leftbackWall = ai.wallFeeler(500, heading + left_back_wall_angle)
rightbackWall = ai.wallFeeler(500, heading - right_back_wall_angle)
trackWall = ai.wallFeeler(500, tracking)
backWall = ai.wallFeeler(500, heading - back_wall_angle)
#Shooting rule - checks whether theres an enemy to aim at using aimdir,
#and then if we're pointing at them within 10 degrees
#check whether theres a wall between us and the enemy; if there is not then we shoot
if ai.aimdir(0) >= 0 and -angle_diff_shoot <= ai.angleDiff(
heading, ai.aimdir(0)) <= angle_diff_shoot and ai.screenEnemyX(
0) >= 0 and ai.screenEnemyY(0) >= 0 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.screenEnemyX(0),
ai.screenEnemyY(0)) == -1:
ai.fireShot()
#Turn rules
#standard check for enemy proximity and wall between us,
#and if we're not aiming at them the angle is corrected
if ai.aimdir(0) >= 0 and ai.angleDiff(
heading, ai.aimdir(0)) > 0 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.screenEnemyX(0),
ai.screenEnemyY(0)) == -1:
ai.turnLeft(1)
print("aim turn left")
elif ai.aimdir(0) >= 0 and ai.angleDiff(
heading, ai.aimdir(0)) < 0 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.screenEnemyX(0),
ai.screenEnemyY(0)) == -1:
ai.turnRight(1)
print("aim turn right")
#misc turn rules with fuzzy logic
elif left90Wall < right90Wall and minmax(10, (rate * ai.selfSpeed()), 100):
ai.turnRight(1)
print("left90wall")
elif right90Wall < left90Wall and minmax(10, (rate * ai.selfSpeed()), 100):
ai.turnLeft(1)
print("right90wall")
elif leftbackWall < minmax(5, (rate1 * ai.selfSpeed()), 50):
ai.turnRight(1)
print("leftbackwall")
elif rightbackWall < minmax(5, (rate1 * ai.selfSpeed()), 50):
ai.turnLeft(1)
print("rightbackwall")
#default/base case turn rules
elif leftWall < rightWall:
ai.turnRight(1)
else:
ai.turnLeft(1)
#Thrust rules
#rule for speeding up when no wall in front of us
if ai.selfSpeed(
) <= when_to_thrust_speed and frontWall >= front_wall_distance_thrust:
ai.thrust(1)
print("thrust 1")
#dynamic thrust away from walls
elif trackWall < track_wall_distance_thrust:
ai.thrust(1)
print("thrust 2")
#thrust away from back wall
elif backWall < back_wall_distance_thrust:
ai.thrust(1)
print("thrust 3")
#this block handles dodging enemy bullets
elif ai.shotAlert(0) >= 0 and ai.shotAlert(
0) <= shot_alert_distance and ai.shotVelDir(
0) != -1 and ai.angleDiff(heading, ai.shotVelDir(0)) > 0:
print("shotveldir turn left")
ai.turnLeft(1)
ai.thrust(1)
elif ai.shotAlert(0) >= 0 and ai.shotAlert(
0) <= shot_alert_distance and ai.shotVelDir(
0) != -1 and ai.angleDiff(heading, ai.shotVelDir(0)) < 0:
print("shotveldir turn right")
ai.turnRight(1)
ai.thrust(1)
def AI_loop(self):
# print("AI_LOOP")
if ai.selfAlive() == 0:
print("selfAlive is 0")
# if ai.selfAlive() == 0 and time2quit:
outputFile = open("output.txt", "w")
outputFile.write(str(self.counter))
outputFile.close()
# ai.quitAI()
# print(countFrames)
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
ai.setTurnSpeed(55)
turnSpeedMin = 15
turnSpeedMax = 64
# Heuristics
#frontFeelerOffset = 35
ffo = self.frontFeelerOffset
rfo = self.rearFeelerOffset
perpFeelerOffset = 90
#rearFeelerOffset = 135
# speedLimit = 5
lowSpeedLimit = 2
targetingAccuracy = 4 # 1/2 tolerance in deg for aiming accuracy
shotIsDangerous = 130
# Acquire information
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
# Wall feeling
feelers = []
frontWall = ai.wallFeeler(750, heading)
leftWall = ai.wallFeeler(500, heading + perpFeelerOffset)
rightWall = ai.wallFeeler(500, heading - perpFeelerOffset)
trackWall = ai.wallFeeler(750, tracking)
rearWall = ai.wallFeeler(250, heading - 180)
backLeftWall = ai.wallFeeler(500, heading + round(rfo))
backRightWall = ai.wallFeeler(500, heading - round(rfo))
frontLeftWall = ai.wallFeeler(500, heading + round(ffo))
frontRightWall = ai.wallFeeler(500, heading - round(ffo))
feelers.append(frontWall)
feelers.append(leftWall)
feelers.append(rightWall)
feelers.append(trackWall)
feelers.append(rearWall)
feelers.append(backLeftWall)
feelers.append(backRightWall)
feelers.append(frontLeftWall)
feelers.append(frontRightWall)
if min(feelers) < self.veryNearLimit:
self.speedLimit = lowSpeedLimit
# Movement controls
# Compute angles to the nearest things
m = self.angleToPointDeg((ai.selfX(), ai.selfY()),
(ai.shotX(0), ai.shotY(0)))
n = self.angleToPointDeg((ai.selfX(), ai.selfY()),
(ai.shotX(0), ai.shotY(0)))
# Sets turn speed and degree to the enemy
if ai.screenEnemyX(0) >= 0:
enemyDeg = self.angleToPointDeg(
(ai.selfX(), ai.selfY()),
(ai.screenEnemyX(0), ai.screenEnemyY(0)))
ai.setTurnSpeed(
self.rangeMap(abs(enemyDeg), 0, 180, turnSpeedMin,
turnSpeedMax))
else:
enemyDeg = self.angleToPointDeg(
(ai.selfRadarX(), ai.selfRadarY()),
(ai.closestRadarX(), ai.closestRadarY()))
ai.setTurnSpeed(
self.rangeMap(abs(enemyDeg), 0, 180, turnSpeedMin,
turnSpeedMax))
# Turn towards unoccluded enemies while in open space
if ai.aimdir(0) >= 0 and self.headingDiff(
heading, ai.aimdir(0)) > 0 and not self.enemyBehindWall(0):
ai.turnRight(1)
elif ai.aimdir(0) >= 0 and self.headingDiff(
heading, ai.aimdir(0)) < 0 and not self.enemyBehindWall(0):
ai.turnLeft(1)
# Turn away from nearby walls
elif min(feelers) < ai.enemyDistance(
0
) and trackWall < self.nearLimit and leftWall < rightWall: #DONE
ai.turnRight(1)
elif min(feelers) < ai.enemyDistance(
0
) and trackWall < self.nearLimit and rightWall < leftWall: #DONE
ai.turnLeft(1)
elif min(feelers) < ai.enemyDistance(
0
) and backLeftWall < self.nearLimit and rightWall > self.nearLimit:
ai.turnRight(1)
elif min(feelers) < ai.enemyDistance(
0
) and backRightWall < self.nearLimit and leftWall > self.nearLimit:
ai.turnLeft(1)
elif min(feelers) < ai.enemyDistance(
0) and frontRightWall < self.nearLimit:
ai.turnLeft(1)
elif min(feelers) < ai.enemyDistance(
0) and frontLeftWall < self.nearLimit:
ai.turnRight(1)
# TODO: NEED RULES FOR WHEN ENEMY IS OCCLUDED
elif self.enemyBehindWall and enemyDeg < 0:
ai.turnRight(1)
elif self.enemyBehindWall and enemyDeg >= 0:
ai.turnLeft(1)
# Turn away from shots
elif m > 0:
ai.turnRight(1)
elif m < 0:
ai.turnLeft(1)
# THRUST (includes fuzzy controller)
# Power levels
power1 = 55
power2 = 45
power3 = 55
power4 = 36
power5 = 36
power6 = 28
power7 = 24
power8 = 30
mfS = self.mfSpeed(ai.selfSpeed())
mfD = self.mfDanger(ai.shotAlert(0))
# Aggregation
# if S is high and D is moderate or high:
p1 = max(mfS[2], min(mfD[1], mfD[2]))
# if S is moderate and D is moderate:
p2 = max(mfS[1], mfD[1])
# if S is low and D is high:
p3 = max(mfS[0], mfD[2])
# if S is moderate and D is moderate:
p4 = max(mfS[1], mfD[1])
# if S is low and D is moderate:
p5 = max(mfS[0], mfD[1])
# if S is high and D is low:
p6 = max(mfS[2], mfD[0])
# if S is moderate and D is low:
p7 = max(mfS[1], mfD[0])
# if S is low and D is low:
p8 = max(mfS[0], mfD[0])
consequents = [
power1, power2, power3, power4, power5, power6, power7, power8
]
memberships = [p1, p2, p3, p4, p5, p6, p7, p8]
# Defuzzification
ai.setPower(self.crispify(memberships, consequents))
# Further thrusting rules
if ai.shotAlert(0) < 130 and ai.shotAlert(0) != -1 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.shotX(0), ai.shotY(0)) == -1:
ai.thrust(1)
elif ai.selfSpeed() <= self.speedLimit:
ai.thrust(1)
elif trackWall < self.nearLimit and self.angleDiff(heading,
tracking) > 75:
ai.thrust(1)
elif rearWall < self.nearLimit and self.angleDiff(heading,
tracking) > 90:
ai.thrust(1)
# FIRE
# Restrict firing to reasonably accurate attempts
if self.headingDiff(heading, ai.aimdir(
0)) < targetingAccuracy and not self.enemyBehindWall(0):
ai.fireShot()
self.counter += 1
def AI_loop():
global count_frame, loop, boolean, score, population_size, chromosome_size, population, mutation_prob, crossover_prob, fitness_list, generation, generation_size, first_time, done_learning
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
## Get A Chromosome in the Population -- Eventually Will go through each individual in the population ##
current_chromosome = population[loop]
## Transform Each Gene insisde A Single Selected Chromosome. 0s & 1s Are Turned Into Intergers For Fuzzy Sets to understand ##
## Each Value obtained is used to calculate the risk of each 45 degree around the agent ##
## Each value has its own "jump" variable which refers to the distance from each possible points/values ##
## The start and end represents the possible start point and end point for each variable and they depend on
## what the variiable is. It is to ensure a viable fuzzy set and fuzzy functions that these restrictions are applied. ##
frontAlert = current_chromosome[0:5]
frontAlertValue = transform(frontAlert, 25)
backAlert = current_chromosome[5:9]
backAlertValue = transform(backAlert, 25)
speedAlert = current_chromosome[9:13] #4 bits
speedAlertValue = transform(speedAlert, 1) #1 jumps per value
EnemyAlert = current_chromosome[13:18] #5 bits
EnemyAlertValue = transform(EnemyAlert, 50) #50 jumps per value
TrackSlowAlert = current_chromosome[18:22] #4 bits
TrackSlowAlertValue = transform(TrackSlowAlert, 25) #25 jumps per value
TrackFastAlert = current_chromosome[22:26] #4 bits
TrackFastAlertValue = transform(TrackFastAlert, 25) #25 jumps per value
BulletAlert = current_chromosome[26:32] #4 bits
BulletAlertValue = transform(BulletAlert, 15) #15 jumps per value
## Get values of variables for Wall Feelers, Head & Tracking ##
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500,heading)
left45Wall = ai.wallFeeler(500,heading+45)
right45Wall = ai.wallFeeler(500,heading-45)
left90Wall = ai.wallFeeler(500,heading+90)
right90Wall = ai.wallFeeler(500,heading-90)
left135Wall = ai.wallFeeler(500,heading+135)
right135Wall = ai.wallFeeler(500,heading-135)
backWall = ai.wallFeeler(500,heading-180)
trackWall = ai.wallFeeler(500,tracking)
####### Getters Variable Regarding Important Information About Enemies ########
##Find the closest ennemy##
enemy = ai.lockClose()
## Get the lockheadingdeg of enemy ##
head = ai.lockHeadingDeg()
## Get the dstance from enemy ##
enemyDist = ai.selfLockDist()
## If the Enemy is Dead ##
if(ai.selfAlive() == 0 and boolean == False):
## Calculate Fitness Current Population ##
score_previous = score
score_current = ai.selfScore()
fitness_value = fitness(population, count_frame, score_previous, score_current)
fitness_list.append(fitness_value)
## If it went through the whole population and ready to move to next generation ##
if((loop+1) == population_size):
## Output the fitness of population to allow user to see if learning is happening ##
print("Generation:", generation)
print("Agent Fitness:")
print(fitness_list)
print("Average Fitness:", statistics.mean(fitness_list))
print("Best Fitness:", max(fitness_list))
## Finding the optimal chromosome to output it in data file ##
string_maxChromosome = ""
for chrom_max in range(chromosome_size):
string_maxChromosome = string_maxChromosome + str(population[fitness_list.index(max(fitness_list))][chrom_max])
## Formatting entire population in a big string to register it in excel file##
string_population = ""
for pop in range(population_size):
for pop_chrom in range(chromosome_size):
string_population = string_population + str(population[pop][pop_chrom])
if(pop != (population_size-1)):
string_population = string_population + ","
## Formatting entire population's fitness in a big string to register it in excel file##
string_fitness = ""
for fit in range(len(fitness_list)):
string_fitness = string_fitness + str(fitness_list[fit])
if(fit != (len(fitness_list)-1)):
string_fitness = string_fitness + ","
## Output Data into Excel File ##
titles = ["Generation", "Average Fitness", "Best Fitness","Population Size", "Chromosome Size", "Crossover Probability", "Mutation Probability", "Best Chromosome", "Entire Population Chromosome", "Entire Population Fitness"]
data = [generation, statistics.mean(fitness_list), max(fitness_list), population_size, chromosome_size, crossover_prob, mutation_prob, string_maxChromosome, string_population, string_fitness]
first_time = Save_Data("Tiger_Training_Data.xls", 0, titles, data, first_time)
## Select Next Generation -- Apply Crossover & Mutation ##
new_population = select(population, fitness_list)
new_population = crossover(new_population, chromosome_size, population_size, crossover_prob)
new_population = mutate(new_population, chromosome_size, mutation_prob)
population = new_population
loop = 0
count_frame = 0
generation += 1
fitness_list.clear()
### DONE -- QUIT ###
if (generation == generation_size):
quitAI()
## Move to the next individual in population ##
else:
loop += 1
count_frame = 0
boolean = True
else:
## The agent is Alive ##
if(ai.selfAlive() == 1):
### Turning Rules ###
if frontWall <= frontAlertValue and (left45Wall < right45Wall) and ai.selfSpeed() > speedAlertValue:
ai.turnRight(1)
elif frontWall <= frontAlertValue and (left45Wall > right45Wall) and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
elif left90Wall <= frontAlertValue and ai.selfSpeed() > speedAlertValue:
ai.turnRight(1)
elif right90Wall <= frontAlertValue and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
### Thrust commands ####
elif ai.selfSpeed() <= speedAlertValue and (frontWall >= frontAlertValue) and (left45Wall >= frontAlertValue) and (right45Wall >= frontAlertValue) and (right90Wall >= frontAlertValue) and (left90Wall >= frontAlertValue) and (left135Wall >= backAlertValue) and (right135Wall >= backAlertValue) and (backWall >= backAlertValue):
ai.thrust(1)
elif trackWall <= TrackFastAlertValue and ai.selfSpeed() >= speedAlertValue:
ai.thrust(1)
elif trackWall <= TrackSlowAlertValue and ai.selfSpeed() <= speedAlertValue:
ai.thrust(1)
elif backWall <= TrackFastAlertValue and ai.selfSpeed() >= speedAlertValue:
ai.thrust(1)
elif backWall <= TrackSlowAlertValue and ai.selfSpeed() <= speedAlertValue:
ai.thrust(1)
elif left135Wall <= TrackFastAlertValue and ai.selfSpeed() >= speedAlertValue:
ai.thrust(1)
elif left135Wall <= TrackSlowAlertValue and ai.selfSpeed() <= speedAlertValue:
ai.thrust(1)
elif right135Wall <= TrackFastAlertValue and ai.selfSpeed() >= speedAlertValue:
ai.thrust(1)
elif right135Wall <= TrackSlowAlertValue and ai.selfSpeed() <= speedAlertValue:
ai.thrust(1)
##### Bullet Avoidance Commands #####
elif ai.shotAlert(0) >= 0 and ai.shotAlert(0) <= BulletAlertValue:
if ai.angleDiff(heading, ai.shotVelDir(0)) > 0 and ai.selfSpeed() <= speedAlertValue:
ai.turnLeft(1)
ai.thrust(1)
elif ai.angleDiff(heading, ai.shotVelDir(0)) < 0 and ai.selfSpeed() <= speedAlertValue:
ai.turnRight(1)
ai.thrust(1)
elif ai.angleDiff(heading, ai.shotVelDir(0)) > 0 and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
else:
ai.turnRight(1)
##### Shooting Ennemy Commands #####
elif enemyDist <= EnemyAlertValue and heading > (head) and ai.selfSpeed() > speedAlertValue:
ai.turnRight(1)
ai.fireShot()
elif enemyDist <= EnemyAlertValue and heading < (head) and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
ai.fireShot()
elif ai.selfSpeed() < speedAlertValue:
ai.thrust(1)
else:
ai.thrust(0)
count_frame += 3
boolean = False
def AI_loop(self):
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
if self.quitFlag == True:
with open('fitness.txt', 'a') as inFile:
outString = str(self.fitness) + "\n"
inFile.write(outString)
ai.quitAI()
if ai.selfAlive() == 0 or self.frames > 3000:
self.foundPreyFlag = False
self.parterFoundPreyFlag = False
self.checking = False
if self.foundPreyFlag == True and self.parterFoundPreyFlag == True:
self.fitness = self.fitness + 2
#-------------------- Set variables --------------------#
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + 45)
rightWall = ai.wallFeeler(500, heading - 45)
leftWallStraight = ai.wallFeeler(500, heading + 90)
rightWallStraight = ai.wallFeeler(500, heading - 90)
leftBack = ai.wallFeeler(500, heading + 135)
rightBack = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
R = (heading - 90) % 360
L = (heading + 90) % 360
aim = ai.aimdir(0)
bullet = ai.shotAlert(0)
speed = ai.selfSpeed()
x = ai.selfX()
y = ai.selfY()
enemyX = -1
enemyY = -1
enemyTeam = -1
if self.preyID != -1:
enemyX = ai.screenEnemyXId(self.preyID)
enemyY = ai.screenEnemyYId(self.preyID)
enemyTeam = ai.enemyTeamId(self.preyID)
else:
enemyX = ai.screenEnemyXId(ai.closestShipId())
enemyY = ai.screenEnemyYId(ai.closestShipId())
enemyTeam = ai.enemyTeamId(ai.closestShipId())
myTeam = ai.selfTeam()
coordinate = self.grid[self.counter][1]
message = ai.scanMsg(0)
# Continually check messages
if message != self.MessageBuffer[-1]:
self.checkMessage(message)
# Check if enemy is on screen
# If it is: broadcast location of enemy
if enemyX != -1 and enemyY != -1 and enemyTeam != 2:
coordinate = (enemyX, enemyY)
self.foundPreyFlag = True
self.foundPrey(coordinate)
self.fitness += 1
elif self.foundPreyFlag == True:
self.foundPreyFlag = False
ai.talk("--- " + "Lost prey!")
if self.parterFoundPreyFlag == True:
coordinate = self.preyLocation
# Calculate most efficient way to turn to get where we want to
targetX = coordinate[0]
targetY = coordinate[1]
toTurn = self.angleToPoint(x, y, targetX, targetY, heading)
distance = self.distance(x, targetX, y, targetY)
if self.checking == False and self.foundPreyFlag == False:
ai.talk("checking! " + str(coordinate))
self.checking = True
# If speed is too fast, turn around and thrust to negate velocity
if speed > self.gene0:
turning = ai.angleDiff(heading, tracking)
if abs(turning) > self.gene1 and abs(turning) <= self.gene2:
ai.turnLeft(0)
ai.turnRight(0)
if self.frames % self.gene3 == 0:
ai.thrust(1)
elif turning <= self.gene4 and turning > self.gene5:
ai.turnRight(1)
else:
ai.turnLeft(1)
if self.foundPreyFlag == True and distance <= 150:
self.caughtPrey(coordinate, distance)
else:
#-------------------- Go to coordinate / enemy --------------------#
if abs(toTurn) < self.gene6 and distance > self.gene7:
ai.turnLeft(0)
ai.turnRight(0)
if self.frames % self.gene8 == 0:
ai.thrust(1)
elif toTurn >= self.gene9:
ai.turnLeft(1)
elif toTurn <= -self.gene10:
ai.turnRight(1)
if self.foundPreyFlag == True and distance <= 150:
self.caughtPrey(coordinate, distance)
elif self.foundPreyFlag == True and distance > 150:
self.foundPrey(coordinate)
elif distance < 150:
self.markSpotChecked(coordinate, "me")
#-------------------- Old turn and thrust rules --------------------#
if speed <= self.gene14 and frontWall >= self.gene15:
ai.thrust(1)
elif trackWall < self.gene16:
ai.thrust(1)
elif backWall < self.gene17:
ai.thrust(1)
if (backWall < self.gene18) and (rightWallStraight < self.gene19):
ai.turnLeft(1)
elif backWall < self.gene20 and (leftWallStraight < self.gene21):
ai.turnRight(1)
elif leftWallStraight < rightWallStraight and trackWall < self.gene22:
ai.turnRight(1)
elif leftWallStraight > rightWallStraight and trackWall < self.gene23:
ai.turnLeft(1)
self.frames = self.frames + 1
if self.caughtPreyFlag == True and self.quitFlag == False:
ai.talk("quit!")
self.quitFlag = True
if ai.selfAlive() == 0 or self.frames > 1800:
self.quitFlag = True
def AI_loop():
global frames, frameHistory, generation, current_chrom, population, scores, current_score
print("frame", frames)
#rules
chrom = population[current_chrom][0]
when_to_thrust_speed = convert(chrom[0:4])
front_wall_distance_thrust = convert(chrom[4:8]) * 4
back_wall_distance_thrust = convert(chrom[8:12]) * 2
track_wall_distance_thrust = convert(chrom[12:16]) * 4
left_wall_angle = convert(chrom[16:20]) * 3
right_wall_angle = convert(chrom[20:24]) * 3
back_wall_angle = convert(chrom[24:28]) * 10
left_90_wall_angle = convert(chrom[28:32]) * 6
right_90_wall_angle = convert(chrom[32:36]) * 6
left_back_wall_angle = convert(chrom[36:40]) * 9
right_back_wall_angle = convert(chrom[44:48]) * 9
fuzzy_rate = convert(chrom[48:52])
fuzzy_rate_1 = convert(chrom[52:56])
angle_diff_shoot = convert(chrom[56:60])
shot_alert_distance = convert(chrom[60:64]) * 6
rate = fuzzy_rate
rate1 = fuzzy_rate_1
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + left_wall_angle)
rightWall = ai.wallFeeler(500, heading - right_wall_angle)
left90Wall = ai.wallFeeler(500, heading + left_90_wall_angle)
right90Wall = ai.wallFeeler(500, heading - right_90_wall_angle)
leftbackWall = ai.wallFeeler(500, heading + left_back_wall_angle)
rightbackWall = ai.wallFeeler(500, heading - right_back_wall_angle)
trackWall = ai.wallFeeler(500, tracking)
backWall = ai.wallFeeler(500, heading - back_wall_angle)
#Shooting rules
if ai.aimdir(0) >= 0 and -angle_diff_shoot <= ai.angleDiff(
heading, ai.aimdir(0)) <= angle_diff_shoot and ai.screenEnemyX(
0) >= 0 and ai.screenEnemyY(0) >= 0 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.screenEnemyX(0),
ai.screenEnemyY(0)) == -1:
ai.fireShot()
#Turn rules
if ai.aimdir(0) >= 0 and ai.angleDiff(
heading, ai.aimdir(0)) > 0 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.screenEnemyX(0),
ai.screenEnemyY(0)) == -1:
ai.turnLeft(1)
#print("aim turn left")
elif ai.aimdir(0) >= 0 and ai.angleDiff(
heading, ai.aimdir(0)) < 0 and ai.wallBetween(
ai.selfX(), ai.selfY(), ai.screenEnemyX(0),
ai.screenEnemyY(0)) == -1:
ai.turnRight(1)
#print("aim turn right")
elif left90Wall < right90Wall and minmax(10, (rate * ai.selfSpeed()), 100):
ai.turnRight(1)
#print("left90wall")
elif right90Wall < left90Wall and minmax(10, (rate * ai.selfSpeed()), 100):
ai.turnLeft(1)
#print("right90wall")
elif leftbackWall < minmax(5, (rate1 * ai.selfSpeed()), 50):
ai.turnRight(1)
#print("leftbackwall")
elif rightbackWall < minmax(5, (rate1 * ai.selfSpeed()), 50):
ai.turnLeft(1)
#print("rightbackwall")
#base case turn rules
elif leftWall < rightWall:
ai.turnRight(1)
else:
ai.turnLeft(1)
#Thrust rules
if ai.selfSpeed(
) <= when_to_thrust_speed and frontWall >= front_wall_distance_thrust:
ai.thrust(1)
#print("thrust 1")
#dynamic thrust away from walls
elif trackWall < track_wall_distance_thrust:
ai.thrust(1)
#print("thrust 2")
#thrust away from back wall
elif backWall < back_wall_distance_thrust:
ai.thrust(1)
#print("thrust 3")
#Shot avoidance
elif ai.shotAlert(0) >= 0 and ai.shotAlert(
0) <= shot_alert_distance and ai.shotVelDir(
0) != -1 and ai.angleDiff(heading, ai.shotVelDir(0)) > 0:
#print("shotveldir turn left")
ai.turnLeft(1)
ai.thrust(1)
elif ai.shotAlert(0) >= 0 and ai.shotAlert(
0) <= shot_alert_distance and ai.shotVelDir(
0) != -1 and ai.angleDiff(heading, ai.shotVelDir(0)) < 0:
#print("shotveldir turn right")
ai.turnRight(1)
ai.thrust(1)
#tracks frames alive
if ai.selfAlive() == 1:
frames += 1
elif ai.selfAlive() == 0 and frames == 0:
pass
else:
#adds every fitness to a list to avoid the issue of xpilot score never resetting
scores.append(ai.selfScore())
#base case
if len(scores) < 2:
current_score = scores[-1]
else:
current_score = scores[-1] - scores[-2]
if current_score <= 0:
current_score = 2
population[current_chrom][1] = (frames**2) * current_score
print("fitness: ", population[current_chrom][1])
current_chrom += 1
print("current_chrom is: ", current_chrom)
if current_chrom >= len(population):
current_chrom = 0
print("current_chrom is: ", current_chrom)
generation += 1
fitness_scores = fitness(population)
#writes highest fitness agent to file
if generation % 5 == 0:
print("first write")
current_fitness = max(fitness_scores)
best_individual_index = fitness_scores.index(current_fitness)
best_individual = population[best_individual_index][0]
newfile = open("GA_output.txt", "a+")
newfile.write("Generation: ")
newfile.write("\n")
newfile.write(str(generation))
newfile.write("\n")
newfile.write("Best individual: ")
newfile.write("\n")
newfile.write(str(best_individual))
newfile.write("\n")
newfile.write("Best fitness: ")
newfile.write("\n")
newfile.write(str(current_fitness))
newfile.write("\n")
newfile.close()
chrom_pair = top_individuals(population, fitness_scores)
new_pop = []
new_pop += crossover(chrom_pair)
while (len(new_pop) < population_size):
new_pop += crossover(chrom_pair)
population = []
population = new_pop
#writes population to file
if generation % 10 == 0:
print("second write")
popfile = open("GA_pop.txt", "a+")
popfile.write("Generation: ")
popfile.write("\n")
popfile.write(str(generation))
popfile.write("\n")
for i in population:
popfile.write(str(i))
popfile.write("\n")
popfile.write("\n")
popfile.close()
frames = 0
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
ai.setTurnSpeed(45)
turn, thrust = 0.5, 0
maxSpeed = 3
shotAngle = 9
wallClose = 12
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
trackLWall = ai.wallFeeler(500, tracking + 3)
trackRWall = ai.wallFeeler(500, tracking - 3)
frontWall = ai.wallFeeler(500, heading)
flWall = ai.wallFeeler(500, heading + 10)
frWall = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500, heading + 90)
rightWall = ai.wallFeeler(500, heading - 90)
trackWall = ai.wallFeeler(500, tracking)
backWall = ai.wallFeeler(500, heading - 180)
backLeftWall = ai.wallFeeler(500, heading - 185)
backRightWall = ai.wallFeeler(500, heading - 175)
speed = ai.selfSpeed()
closest = min(frontWall, leftWall, rightWall, backWall, flWall, frWall)
def closestWall(x): #Find the closest Wall
return {
frontWall: 1,
leftWall: 2,
rightWall: 3,
backWall: 4,
flWall: 5,
frWall: 6,
}[x]
wallNum = closestWall(closest)
crashWall = min(
trackWall, trackLWall, trackRWall
) #The wall we are likely to crash into if we continue on our current course
#Rules for turning
if wallNum == 1 or wallNum == 5 or wallNum == 6: #Front Wall is Closest (Turn Away From It)
ai.turnLeft(1)
turn = 0
elif wallNum == 2: # Left Wall is Closest (Turn Away From It)
ai.turnRight(1)
turn = 1
elif wallNum == 3: #Right Wall is Closest (Turn Away From It)
ai.turnLeft(1)
turn = 0
else: #Back Wall is closest- turn so that we are facing directly away from it
if backLeftWall < backRightWall:
ai.turnRight(
1) #We need to turn right to face more directly away from it
turn = 1
if backLeftWall > backRightWall: # We need to turn left to face more directly away from it
ai.turnLeft(1)
turn = 0
#Rules for thrusting
if speed < maxSpeed and frontWall > 100: #If we are moving slowly and we won't ram into anything, accelerate
ai.thrust(1)
thrust = 1
elif trackWall < 250 and (
ai.angleDiff(heading, tracking) > 120
): #If we are getting close to a wall, and we can thrust away from it, do so
ai.thrust(1)
thrust = 1
elif backWall < 20: #If there is a wall very close behind us, get away from it
ai.thrust(1)
thrust = 1
def AI_loop():
turn, thrust = .5, 0
ai.turnLeft(0)
ai.turnRight(0)
ai.thrust(0)
ai.setTurnSpeed(64)
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
trackL3 = ai.wallFeeler(500, tracking + 3)
trackL10 = ai.wallFeeler(500, tracking + 10)
trackR3 = ai.wallFeeler(500, tracking - 3)
trackR10 = ai.wallFeeler(500, tracking - 10)
frontWall = ai.wallFeeler(500, heading)
frontL = ai.wallFeeler(500, heading + 15)
frontR = ai.wallFeeler(500, heading - 15)
leftWall = ai.wallFeeler(500, heading + 90)
leftF = ai.wallFeeler(500, heading + 65)
leftB = ai.wallFeeler(500, heading + 115)
rightWall = ai.wallFeeler(500, heading - 90)
rightF = ai.wallFeeler(500, heading - 65)
rightB = ai.wallFeeler(500, heading - 115)
backWall = ai.wallFeeler(500, heading - 180)
backL = ai.wallFeeler(500, heading - 195)
backR = ai.wallFeeler(500, heading - 165)
trackHeadRelative = (tracking - heading)
speed = ai.selfSpeed()
def findClosestArea(x):
return {
frontWall: 1,
frontL: 2,
leftF: 3,
leftWall: 4,
leftB: 5,
backL: 6,
backWall: 7,
backR: 8,
rightB: 9,
rightWall: 10,
rightF: 11,
frontR: 12
}[x]
closestVal = min(frontWall, frontL, leftF, leftWall, leftB, backL,
backWall, backR, rightB, rightWall, rightF, frontR)
#Find the closest Wall to our ship
closestWall = findClosestArea(closestVal)
#The wall we are likely to crash into if we continue on our current course
crashWall = min(trackWall, trackL3, trackL10, trackR3, trackR10)
#Rules for turning
if closestWall == 1:
ai.setTurnSpeed(64)
ai.turnLeft(1)
turn = 0
elif closestWall == 2:
ai.setTurnSpeed(64)
ai.turnRight(1)
turn = 1
elif closestWall == 3:
ai.setTurnSpeed(52)
ai.turnRight(1)
turn = .9
elif closestWall == 4:
ai.setTurnSpeed(40)
ai.turnRight(1)
turn = .8
elif closestWall == 5:
ai.setTurnSpeed(28)
ai.turnRight(1)
turn = .7
elif closestWall == 6:
ai.setTurnSpeed(16)
ai.turnRight(1)
turn = .6
elif closestWall == 7:
pass
elif closestWall == 8:
ai.setTurnSpeed(16)
ai.turnLeft(1)
turn = .4
elif closestWall == 9:
ai.setTurnSpeed(28)
ai.turnLeft(1)
turn = .3
elif closestWall == 10:
ai.setTurnSpeed(40)
ai.turnLeft(1)
turn = .2
elif closestWall == 11:
ai.setTurnSpeed(52)
ai.turnLeft(1)
turn = .1
elif closestWall == 12:
ai.setTurnSpeed(64)
ai.turnLeft(1)
turn = 0
#Rules for thrusting
#if we are going slow and there isn't a wall in front of us
if min(frontWall, frontL, frontR) > 100 and speed < 4:
ai.thrust(1)
thrust = 1
#if we are heading toward a wall and we are not facing it
elif crashWall < 150 and (ai.angleDiff(heading, tracking) > 90):
ai.thrust(1)
thrust = 1
#If there is a wall very close behind us, get away from it
elif backWall < 20 or backL < 20 or backR < 20:
ai.thrust(1)
thrust = 1
doBackPropigation = False
if ai.selfAlive() and doBackPropigation:
#adjust the the learning NN
infile = open("Sem2W_2.txt", "r")
weight = eval(infile.read())
infile.close()
sendData = getSendData(turn, thrust)
weight = adjustNN(sendData, 17, 7, 2, weight)
outfile = open("Sem2W_2.txt", "w")
outfile.write(str(weight))
outfile.close()
def AI_loop():
#Inserted Code
if ai.selfAlive():
DataMinerBD.updateInputs()
DataMinerBD.updateOutputs()
DataMinerBD.savePair()
print(DataMinerBD.length())
if DataMinerBD.length() > 10000:
DataMinerBD.writeData()
print("Finished")
ai.quitAI()
global lastTurn
#Release keys
DataMinerBD.tthrust(0)
DataMinerBD.tturnLeft(0)
DataMinerBD.tturnRight(0)
ai.setTurnSpeed(45)
#Set variables"""
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
trackLWall = ai.wallFeeler(500, tracking+3)
trackRWall = ai.wallFeeler(500, tracking - 3)
frontWall = ai.wallFeeler(500,heading)
flWall = ai.wallFeeler(500, heading + 10)
frWall = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500,heading+90)
rightWall = ai.wallFeeler(500,heading-90)
trackWall = ai.wallFeeler(500,tracking)
backWall = ai.wallFeeler(500, heading - 180)
backLeftWall = ai.wallFeeler(500, heading - 185)
backRightWall = ai.wallFeeler(500, heading - 175)
speed = ai.selfSpeed()
closest = min(frontWall, leftWall, rightWall, backWall)
def closestWall(x): #Find the closest Wall
return {
frontWall : 1,
leftWall : 2,
rightWall : 3,
backWall : 4,
flWall : 5,
frWall : 6,
}[x]
wallNum = closestWall(closest)
#Code for finding the angle to the closest ship
target = ai.closestShipId()
targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0)
calcDir = 0
if targetX- ai.selfX() != 0:
calcDir = (math.degrees(math.atan2((targetY - ai.selfY()), (targetX- ai.selfX()))) + 360)%360
targetDir = calcDir
crashWall = min(trackWall, trackLWall, trackRWall) #The wall we are likely to crash into if we continue on our current course
#Rules for turning
if crashWall > 25*speed and closest > 30 and targetX != -1: #If we are far enough away from a predicted crash and no closer than 25 pixels to a wall, and there isn't a wall between us and the closest enemy
#print("Aiming", targetDir, " Current", heading)
diff = (calcDir - heading)
if ai.shotAlert(0) > -1 and ai.shotAlert(0) < 35:
DataMinerBD.tturnRight(1)
DataMinerBD.tthrust(1)
elif diff >= 0:
if diff >= 180:
a = 0
DataMinerBD.tturnRight(1) #If the target is to our right- turn right
elif diff != 0 :
a = 0
DataMinerBD.tturnLeft(1) #If the target is to our left - turn left
else :
if diff > -180:
a = 0
DataMinerBD.tturnRight(1) #If the target is to our right - turn right
else :
a = 0
DataMinerBD.tturnLeft(1) #If the target is to our left - turn left
else : #Rules for avoiding death
# if crashWall/ai.selfSpeed() > ai.closestShot() :
#We find a target heading using our current trajectory and the closest wall then turn in it's direction
targetHeading = heading
print(heading)
if wallNum == 1or wallNum == 6 or wallNum == 5: #Front Wall is Closest
if lastTurn == 1:
targetHeading += 270
targetHeading = (targetHeading)%360
else :
targetHeading +=90
targetHeading = targetHeading%360
print("front")
elif wallNum == 2 : # Left Wall is Closest
targetHeading += 270
targetHeading = (targetHeading)%360
lastTurn = 1
print("leftwall")
elif wallNum == 3 :
targetHeading = targetHeading + 90
targetHeading = (targetHeading)%360
lastTurn = 2
print("rightWall")
else :
if backLeftWall < backRightWall:
lastTurn = 2
targetHeading += 5
targetHeading = (targetHeading)%360
if backLeftWall > backRightWall:
lastTurn = 1
targetHeading -= 5
targetHeading = (targetHeading)%360
speedConcern = ai.selfSpeed() - 4
if speedConcern < 0:
speedConcern = 0
elif speedConcern > 5:
speedConcern = 5
#targetHeading = (targetHeading*(1-(speedConcern/5))) + (((tracking+170)%360)*(speedConcern/5))
if speedConcern > 2:
targetHeading = (tracking + 180)%360
diff = (targetHeading - heading)
print("targetHEading : ", targetHeading, " heading : ", heading)
if diff >= 0:
if diff >= 180:
DataMinerBD.tturnRight(1) #If the targetHEading is to our right- turn right
print("right")
elif diff != 0 :
DataMinerBD.tturnLeft(1) #If the targeHeadingt is to our left - turn left
print("left")
else :
if diff > -180:
print("right")
DataMinerBD.tturnRight(1) #If the targetHeading is to our right - turn right
#print("right")
else :
print("left")
DataMinerBD.tturnLeft(1) #If the targetHeading is to our left - turn left
#print("nice")
#Rules for thrusting
if speed < 5 and frontWall > 200: #If we are moving slowly and we won't ram into anything, accelerate
DataMinerBD.tthrust(1)
elif crashWall < 25*speed and (abs(tracking - heading) > 120): #If we are getting close to a wall, and we can thrust away from it, do so
DataMinerBD.tthrust(1)
elif backWall < 30: #If there is a wall very close behind us, get away from it
DataMinerBD.tthrust(1)
if abs(calcDir - heading) < 15 : #If we are close to the current proper trajectory for a shot then fire
DataMinerBD.tshoot()
def AI_loop():
""" The main loop for this agent!
Prod.py is a rule-based expert system.
"""
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
# Heuristics
sideFeelerOffset = 65 # Offsets from heading for wall feelers (degrees)
perpFeelerOffset = 90 # (degrees)
trackFeelerOffset = 45 # (degrees)
nearLimit = 150 # Threshold for a relatively "close" object (xp distance units)
nearLimitThreat = 300 # Threshold for a "very close" object (xp distance units)
shotDanger = 130 # Threshold for relatively "close" bullets (xp distance units)
speedLimit = 5 # (xp speed units)
powerHigh = 45 # (xp thrust power units)
powerLow = 20 # (xp thrust power units)
targetingAccuracy = 5 # Tolerance from heading within which firing is OK (degrees)
# Reset everything else
ai.setTurnSpeedDeg(20) # Artificial handicap!
ai.setPower(powerLow)
# Acquire information
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
feelers = []
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + perpFeelerOffset)
rightWall = ai.wallFeeler(500, heading - perpFeelerOffset)
trackWall = ai.wallFeeler(500, tracking)
rearWall = ai.wallFeeler(500, heading - 180)
backLeftWall = ai.wallFeeler(500, heading + 135)
backRightWall = ai.wallFeeler(500, heading - 135)
frontLeftWall = ai.wallFeeler(500, heading + 45)
frontRightWall = ai.wallFeeler(500, heading - 45)
feelers.append(frontWall)
feelers.append(leftWall)
feelers.append(rightWall)
feelers.append(trackWall)
feelers.append(rearWall)
feelers.append(backLeftWall)
feelers.append(backRightWall)
feelers.append(frontLeftWall)
feelers.append(frontRightWall)
# Collect distances
if ai.enemyDistanceId(ai.closestShipId()) > 0:
closestPlayerDistance = ai.enemyDistanceId(ai.closestShipId())
else:
closestPlayerDistance = math.inf
if ai.shotDist(0) > 0:
closestBulletDistance = ai.shotDist(0)
else:
closestBulletDistance = math.inf
dcw = min(feelers)
distToNearestThreat = min(closestPlayerDistance, closestBulletDistance)
# Assign priority to nearest threat
if closestBulletDistance <= dcw and closestBulletDistance <= closestPlayerDistance: # if closest threat is a bullet
priority = 1
elif dcw <= closestPlayerDistance and dcw <= closestBulletDistance: # if closest threat is a wall
priority = 2
else: # closest threat is a player
priority = 3
if distToNearestThreat < nearLimitThreat:
ai.setPower(powerHigh)
# If the closest threat is a bullet
if priority == 1:
m = angleToPointDeg((ai.selfX(), ai.selfY()),
(ai.shotX(0), ai.shotY(0)))
if m >= 0:
ai.turnRight(1)
else:
ai.turnLeft(1)
if ai.shotAlert(0) < shotDanger:
ai.thrust(1)
# If the closest threat is a wall
elif priority == 2:
# Thrust
if ai.selfSpeed() <= speedLimit:
ai.thrust(1)
elif trackWall < nearLimit and angleDiff(heading, tracking) > 90:
ai.thrust(1)
elif rearWall < nearLimit and angleDiff(heading, tracking) > 90:
ai.thrust(1)
# Turn
if trackWall < nearLimit and leftWall < rightWall:
ai.turnRight(1)
elif trackWall < nearLimit and rightWall < leftWall:
ai.turnLeft(1)
elif backLeftWall < nearLimit and rightWall > 50:
ai.turnRight(1)
elif backRightWall < nearLimit and leftWall > 50:
ai.turnLeft(1)
elif frontRightWall < nearLimit:
ai.turnLeft(1)
elif frontLeftWall < nearLimit:
ai.turnRight(1)
# If the closest threat is a player
elif priority == 3:
m = angleToPointDeg((ai.selfX(), ai.selfY()),
(ai.shotX(0), ai.shotY(0)))
if m <= 0:
ai.turnRight(1)
else:
ai.turnLeft(1)
if ai.selfHeadingDeg() <= (targetingAccuracy + angleToPointDeg(
(ai.selfX(), ai.selfY()),
(ai.screenEnemyX(0), ai.screenEnemyY(0)))) and ai.selfHeadingDeg(
) >= (targetingAccuracy - angleToPointDeg(
(ai.selfX(), ai.selfY()),
(ai.screenEnemyX(0), ai.screenEnemyY(0)))):
ai.fireShot()
def AI_loop():
turn, thrust = .5, 0
ai.turnLeft(0)
ai.turnRight(0)
ai.thrust(0)
ai.setTurnSpeed(64)
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
leftF = ai.wallFeeler(500, heading + 70)
leftB = ai.wallFeeler(500, heading + 110)
rightF = ai.wallFeeler(500, heading - 70)
rightB = ai.wallFeeler(500, heading - 110)
backL = ai.wallFeeler(500, heading - 190)
backR = ai.wallFeeler(500, heading - 170)
speed = ai.selfSpeed()
def findClosestArea(x):
return {
frontL: 1,
leftF: 2,
leftB: 3,
backL: 4,
backR: 5,
rightF: 6,
rightB: 7,
frontR: 8
}[x]
closestVal = min(frontL, leftF, leftB, backL, backR, rightF, rightB,
frontR)
#Find the closest Wall to our ship
closestWall = findClosestArea(closestVal)
#Rules for turning
#if we are heading for a wall, turn away from it
if trackWall < 100:
#round(abs(ai.angleDiff(heading, tracking))/3)
ai.setTurnSpeed(15 + round(abs(ai.angleDiff(heading, tracking)) / 4))
if ai.angleDiff(heading, tracking) > 0:
ai.turnRight(1)
turn = .9
else:
ai.turnLeft(1)
turn = .1
#otherwise turn away from the closest wall
elif closestWall == 1:
ai.setTurnSpeed(64)
ai.turnRight(1)
turn = 1
elif closestWall == 2:
ai.setTurnSpeed(46)
ai.turnRight(1)
turn = .9
elif closestWall == 3:
ai.setTurnSpeed(28)
ai.turnRight(1)
turn = .8
elif closestWall == 4:
ai.setTurnSpeed(10)
ai.turnRight(1)
turn = .6
elif closestWall == 5:
ai.setTurnSpeed(10)
ai.turnLeft(1)
turn = .4
elif closestWall == 6:
ai.setTurnSpeed(28)
ai.turnLeft(1)
turn = .2
elif closestWall == 7:
ai.setTurnSpeed(26)
ai.turnLeft(1)
turn = .1
elif closestWall == 8:
ai.setTurnSpeed(64)
ai.turnLeft(1)
turn = 0
#if we are going too fast and are not in danger turn around
# if speed > 2.5 and closestVal > 100:
# ai.setTurnSpeed(64)
# if ai.angleDiff(heading, tracking) > 0:
# ai.turnRight(1)
# turn = 1
# #print("R",random())
# else:
# ai.turnLeft(1)
# turn = 0
#print("L",random())
#Rules for thrusting
#if we are going slow and there isn't a wall in front of us
if min(frontL, frontR) > 100 and speed < 2.5:
ai.thrust(1)
thrust = 1
#if we are going too fast and are facing away from the direction we are heading
elif abs(ai.angleDiff(heading, tracking)) > 135 and speed > 2.5:
ai.thrust(1)
thrust = 1
#if we are heading toward a wall and we are not facing it
elif trackWall < 150 and (abs(ai.angleDiff(heading, tracking)) > 120):
ai.thrust(1)
thrust = 1
#If there is a wall very close behind us, get away from it
elif backL < 25 or backR < 25:
ai.thrust(1)
thrust = 1
doBackPropigation = False
if ai.selfAlive() and doBackPropigation:
#adjust the the learning NN
infile = open("Sem2W_1.txt", "r")
weight = eval(infile.read())
infile.close()
sendData = getSendData(turn, thrust)
weight = adjustNN(sendData, 12, 5, 2, weight)
outfile = open("Sem2W_1.txt", "w")
outfile.write(str(weight))
outfile.close()
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
left45Wall = ai.wallFeeler(500, heading + 45)
right45Wall = ai.wallFeeler(500, heading - 45)
left90Wall = ai.wallFeeler(500, heading + 90)
right90Wall = ai.wallFeeler(500, heading - 90)
left135Wall = ai.wallFeeler(500, heading + 135)
right135Wall = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
####### Shooting Ennemies ########
##Find the closest ennemy##
ClosestID = ai.closestShipId()
#print(ClosestID)
##Get the closest ennemy direction and speed##
ClosestSpeed = ai.enemySpeedId(ClosestID)
#print(ClosestSpeed)
ClosestDir = ai.enemyTrackingDegId(ClosestID)
#print(ClosestDir)
## Get the lockheadingdeg ##
enemy = ai.lockNext()
print(enemy)
head = ai.lockHeadingDeg()
print(head)
enemyDist = ai.selfLockDist()
print(enemyDist)
### Turning Rules ###
if frontWall <= 200 and (left45Wall < right45Wall):
print("turning right")
ai.turnRight(1)
elif frontWall <= 200 and (left45Wall > right45Wall):
ai.turnLeft(1)
elif left90Wall <= 200:
print("turning right")
ai.turnRight(1)
elif right90Wall <= 200:
print("turning left")
ai.turnLeft(1)
### Thrust commands ####
elif ai.selfSpeed() <= 10 and (frontWall >= 200) and (
left45Wall >= 200) and (right45Wall >= 200) and (
right90Wall >= 200) and (left90Wall >= 200) and (
left135Wall >= 50) and (right135Wall >= 50) and (backWall
>= 50):
print("go forward")
ai.thrust(1)
elif trackWall < 75 and ai.selfSpeed() >= 10:
ai.thrust(1)
elif trackWall < 50 and ai.selfSpeed() <= 10:
ai.thrust(1)
elif backWall <= 75:
ai.thrust(1)
elif left135Wall <= 75:
ai.thrust(1)
elif right135Wall <= 75:
ai.thrust(1)
##### Shooting Ennemy Commands #####
elif enemyDist <= 500 and heading > (head):
ai.turnRight(1)
ai.fireShot()
elif enemyDist <= 500 and heading < (head):
ai.turnLeft(1)
ai.fireShot()
else:
print("chilling")
ai.thrust(0)
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
## Get values of variables for Wall Feelers, Head & Tracking ##
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
left45Wall = ai.wallFeeler(500, heading + 45)
right45Wall = ai.wallFeeler(500, heading - 45)
left90Wall = ai.wallFeeler(500, heading + 90)
right90Wall = ai.wallFeeler(500, heading - 90)
left135Wall = ai.wallFeeler(500, heading + 135)
right135Wall = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
####### Getters Variable Regarding Important Information About Enemies ########
##Find the closest ennemy##
enemy = ai.lockClose()
## Get the lockheadingdeg of enemy ##
head = ai.lockHeadingDeg()
## Get the dstance from enemy ##
enemyDist = ai.selfLockDist()
##### Production System Rules ######
### Turning Rules ###
if frontWall <= frontAlertValue and (
left45Wall < right45Wall) and ai.selfSpeed() > speedAlertValue:
ai.turnRight(1)
elif frontWall <= frontAlertValue and (
left45Wall > right45Wall) and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
elif left90Wall <= frontAlertValue and ai.selfSpeed() > speedAlertValue:
ai.turnRight(1)
elif right90Wall <= frontAlertValue and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
### Thrust commands ####
elif ai.selfSpeed() <= speedAlertValue and (
frontWall >=
frontAlertValue) and (left45Wall >= frontAlertValue) and (
right45Wall >=
frontAlertValue) and (right90Wall >= frontAlertValue) and (
left90Wall >=
frontAlertValue) and (left135Wall >= backAlertValue) and (
right135Wall >= backAlertValue) and (backWall >=
backAlertValue):
ai.thrust(1)
elif trackWall <= TrackFastAlertValue and ai.selfSpeed(
) >= speedAlertValue:
ai.thrust(1)
elif trackWall <= TrackSlowAlertValue and ai.selfSpeed(
) <= speedAlertValue:
ai.thrust(1)
elif backWall <= TrackFastAlertValue and ai.selfSpeed() >= speedAlertValue:
ai.thrust(1)
elif backWall <= TrackSlowAlertValue and ai.selfSpeed() <= speedAlertValue:
ai.thrust(1)
elif left135Wall <= TrackFastAlertValue and ai.selfSpeed(
) >= speedAlertValue:
ai.thrust(1)
elif left135Wall <= TrackSlowAlertValue and ai.selfSpeed(
) <= speedAlertValue:
ai.thrust(1)
elif right135Wall <= TrackFastAlertValue and ai.selfSpeed(
) >= speedAlertValue:
ai.thrust(1)
elif right135Wall <= TrackSlowAlertValue and ai.selfSpeed(
) <= speedAlertValue:
ai.thrust(1)
##### Bullet Avoidance Commands #####
elif ai.shotAlert(0) >= 0 and ai.shotAlert(0) <= BulletAlertValue:
if ai.angleDiff(
heading,
ai.shotVelDir(0)) > 0 and ai.selfSpeed() <= speedAlertValue:
ai.turnLeft(1)
ai.thrust(1)
elif ai.angleDiff(
heading,
ai.shotVelDir(0)) < 0 and ai.selfSpeed() <= speedAlertValue:
ai.turnRight(1)
ai.thrust(1)
elif ai.angleDiff(
heading,
ai.shotVelDir(0)) > 0 and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
else:
ai.turnRight(1)
##### Shooting Ennemy Commands #####
elif enemyDist <= EnemyAlertValue and heading > (
head) and ai.selfSpeed() > speedAlertValue:
ai.turnRight(1)
ai.fireShot()
elif enemyDist <= EnemyAlertValue and heading < (
head) and ai.selfSpeed() > speedAlertValue:
ai.turnLeft(1)
ai.fireShot()
elif ai.selfSpeed() < speedAlertValue:
ai.thrust(1)
else:
ai.thrust(0)
def AI_loop(self):
if self.team == False:
ai.talk("/team 2")
self.team = True
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#-------------------- Set variables --------------------#
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + 45)
rightWall = ai.wallFeeler(500, heading - 45)
leftWallStraight = ai.wallFeeler(500, heading + 90)
rightWallStraight = ai.wallFeeler(500, heading - 90)
leftBack = ai.wallFeeler(500, heading + 135)
rightBack = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
R = (heading - 90) % 360
L = (heading + 90) % 360
aim = ai.aimdir(0)
bullet = ai.shotAlert(0)
speed = ai.selfSpeed()
x = ai.selfX()
y = ai.selfY()
enemyX1 = ai.screenEnemyXId(0)
enemyY1 = ai.screenEnemyYId(0)
enemyX2 = ai.screenEnemyXId(1)
enemyY2 = ai.screenEnemyYId(1)
enemyTeam1 = ai.enemyTeamId(0)
enemyTeam2 = ai.enemyTeamId(1)
myTeam = ai.selfTeam()
coordinate = self.grid[self.counter][1]
message = ai.scanMsg(0)
# print(enemyX1, enemyY1, enemyX2, enemyY2)
# print(myTeam, enemyTeam1, enemyTeam2)
# Continually check messages
if message != self.MessageBuffer[-1]:
self.checkMessage(message)
# Check if enemy is on screen
# If it is: broadcast location of enemy
# If it is not: send message that we lost enemy
if enemyX1 != -1 and enemyY1 != -1:
print("enemy 1")
enemyCoordinate = (enemyX1, enemyY1)
self.foundPrey(enemyCoordinate)
coordinate = enemyCoordinate
elif enemyX2 != -1 and enemyY2 != -1:
print("enemy 2")
enemyCoordinate = (enemyX2, enemyY2)
self.foundPrey(enemyCoordinate)
coordinate = enemyCoordinate
elif self.foundPreyFlag == True:
print("lost prey")
self.lostPrey()
targetX = coordinate[0]
targetY = coordinate[1]
toTurn = self.angleToPoint(x, y, targetX, targetY, heading)
distance = self.distance(x, targetX, y, targetY)
if self.foundPreyFlag == False and self.checking == False:
ai.talk("checking! " + str(coordinate))
self.checking = True
# If speed is too fast, turn around and thrust to negate velocity
if speed > 5:
turning = ai.angleDiff(heading, tracking)
if abs(turning) > 165 and abs(turning) <= 180:
ai.turnLeft(0)
ai.turnRight(0)
if self.frames % 10 == 0:
ai.thrust(1)
elif turning <= 165 and turning > 0:
ai.turnRight(1)
else:
ai.turnLeft(1)
else:
#-------------------- Go to coordinate / enemy --------------------#
if abs(toTurn) < 10 and distance > 100:
ai.turnLeft(0)
ai.turnRight(0)
if self.frames % 3 == 0:
ai.thrust(1)
elif toTurn >= 10:
ai.turnLeft(1)
elif toTurn <= -10:
ai.turnRight(1)
if self.foundPreyFlag == True and distance < 150:
print("Caught enemy!")
ai.quitAI()
elif distance < 150:
self.markSpotChecked(coordinate, "me")
#-------------------- Old turn and thrust rules --------------------#
if speed <= 3 and frontWall >= 200:
ai.thrust(1)
elif trackWall < 50:
ai.thrust(1)
elif backWall < 40:
ai.thrust(1)
# Figures out what corner we are in and turns the right directon
if (backWall < 30) and (rightWallStraight < 200):
ai.turnLeft(1)
elif backWall < 30 and (leftWallStraight < 200):
ai.turnRight(1)
# Walls along our periphery (90 degree feelers)
elif leftWallStraight < rightWallStraight and trackWall < 75:
ai.turnRight(1)
elif leftWallStraight > rightWallStraight and trackWall < 75:
ai.turnLeft(1)
self.frames = self.frames + 1
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500,heading)
left45Wall = ai.wallFeeler(500,heading+45)
right45Wall = ai.wallFeeler(500,heading-45)
left90Wall = ai.wallFeeler(500,heading+90)
right90Wall = ai.wallFeeler(500,heading-90)
left135Wall = ai.wallFeeler(500,heading+135)
right135Wall = ai.wallFeeler(500,heading-135)
backWall = ai.wallFeeler(500,heading-180)
trackWall = ai.wallFeeler(500,tracking)
result_list = []
risk_list = []
for i in range(8):
Degree = tracking+(45*i)
Speed = ai.selfSpeed()
Distance = ai.wallFeeler(10000,tracking+(45*i))
result = Closing_Rate(Degree, tracking, Speed, Distance)
result_list.append(result)
### Fuzzy membership ###
closing_rate, distance = Closing_Rate(Degree, tracking, Speed, Distance)
low, medium, fast = Fuzzy_Speed(closing_rate)
close, far = Fuzzy_Distance(distance)
risk = Fuzzy_Risk(low, medium, fast, close, far)
risk_list.append(risk)
## Get the direction in deg that is most risky for the robot ##
max_risk = max(risk_list)
track_risk = (tracking + (risk_list.index(max_risk)*45) % 360)
min_risk = min(risk_list)
####### Shooting Ennemies ########
##Find the closest ennemy##
ClosestID = ai.closestShipId()
#print(ClosestID)
##Get the closest ennemy direction and speed##
ClosestSpeed = ai.enemySpeedId(ClosestID)
ClosestDir = ai.enemyTrackingDegId(ClosestID)
## Get the lockheadingdeg ##
enemy = ai.lockClose()
#print(enemy)
head = ai.lockHeadingDeg()
#print(head)
enemyDist = ai.selfLockDist()
#print(enemyDist, ClosestSpeed, ClosestDir, head)
int1, int2, int3, int4, int5 = Data(enemyDist, ClosestSpeed, ClosestDir, head, heading, tracking)
output = Out(int1, int2, int3, int4, int5)
#print(output)
if(output > 0.5):
addDeg = output * 20
else:
addDeg = (output -0.5) * 20 * -1
## Get the angles on both side between tracking and heading ##
dist = (heading - track_risk) % 360
dist2 = (360 - dist) % 360
## Production system rules based off fuzzy output ##
if(dist <= 130 and dist >= 0 and ai.selfSpeed() > 0 and max_risk >= 75):
ai.turnLeft(1)
#print("turning left")
elif(dist2 <= 130 and dist2 >= 0 and ai.selfSpeed() > 0 and max_risk >= 75):
ai.turnRight(1)
#print("turning right")
elif(ai.selfSpeed() <= 10):
ai.thrust(1)
#print("thrust")
elif(trackWall <= 150):
ai.thrust(1)
#print("thrust")
elif(enemyDist <= 400 and heading > (head) and enemyDist != 0):
ai.turnRight(1)
ai.fireShot()
elif(enemyDist <= 400 and heading < (head) and enemyDist != 0):
ai.turnLeft(1)
ai.fireShot()
elif(enemyDist > 400 and heading > (head + addDeg) and enemyDist != 0):
ai.turnRight(1)
ai.fireShot()
elif(enemyDist > 400 and heading < (head + addDeg) and enemyDist != 0):
ai.turnLeft(1)
ai.fireShot()
else:
#print("chilling")
ai.thrust(0)
ai.fireShot()
def dummyLoop():
global maxSpeed, shotAngle, wallClose, dead, previousScore
global turnedLeft, turnedRight, thrusted, shot
#Release keys
DataMinerBD.tthrustDummy(0)
DataMinerBD.tturnLeftDummy(0)
DataMinerBD.tturnRightDummy(0)
ai.setTurnSpeed(45)
#Set variables"""
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
trackLWall = ai.wallFeeler(500, tracking + 3)
trackRWall = ai.wallFeeler(500, tracking - 3)
frontWall = ai.wallFeeler(500, heading)
flWall = ai.wallFeeler(500, heading + 10)
frWall = ai.wallFeeler(500, heading - 10)
leftWall = ai.wallFeeler(500, heading + 90)
llWall = ai.wallFeeler(500, heading + 100)
rlWall = ai.wallFeeler(500, heading + 80)
rightWall = ai.wallFeeler(500, heading - 90)
lrWall = ai.wallFeeler(500, heading - 80)
rrWall = ai.wallFeeler(500, heading - 100)
trackWall = ai.wallFeeler(500, tracking)
backWall = ai.wallFeeler(500, heading - 180)
backLeftWall = ai.wallFeeler(500, heading - 190)
backRightWall = ai.wallFeeler(500, heading - 170)
speed = ai.selfSpeed()
closest = min(frontWall, leftWall, rightWall, backWall, flWall,
frWall)
def closestWall(x): #Find the closest Wall
return {
frontWall: 1,
leftWall: 2,
rightWall: 3,
backWall: 4,
flWall: 5,
frWall: 6,
}[x]
wallNum = closestWall(closest)
#Code for finding the angle to the closest ship
targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0)
#baseString = "["+str(flWall/500)+","+str(frontWall/500)+","+str(frWall/500) + "," + str(backLeftWall/500) + "," + str(backWall/500) + "," + str(backRightWall/500) + ","+str(leftWall/500)+","+str(rightWall/500)+","+str(trackLWall/500) + "," + str(trackWall/500) + ","+str(trackRWall/500) + "," + str(speed/10)
calcDir = -1
if targetX - ai.selfX() != 0:
calcDir = (math.degrees(
math.atan2((targetY - ai.selfY()),
(targetX - ai.selfX()))) + 360) % 360
crashWall = min(
trackWall, trackLWall, trackRWall
) #The wall we are likely to crash into if we continue on our current course
#Rules for turning
if crashWall > wallClose * speed and closest > 25 and targetX != -1: #If we are far enough away from a predicted crash and no closer than 25 pixels to a wall we can try and aim and kill them
diff = (calcDir - heading)
#if ai.shotAlert(0) > -1 and ai.shotAlert(0) < 35: #If we are about to get shot
# tturnRight(1) #Screw aiming and turn right and thrust
# tthrust(1) #This is arguably a horrible strategy because our sideways profile is much larger, but it's required for the grade
if diff >= 0:
if diff >= 180:
DataMinerBD.tturnRightDummy(
1) #If the target is to our right- turn right
else:
DataMinerBD.tturnLeftDummy(
1) #If the target is to our left - turn left
else:
if diff > -180:
DataMinerBD.tturnRightDummy(
1) #If the target is to our right - turn right
else:
DataMinerBD.tturnLeftDummy(
1) #If the target is to our left - turn left
else: #Rules for avoiding death
# if crashWall/ai.selfSpeed() > ai.closestShot() :
if wallNum == 1 or wallNum == 5 or wallNum == 6: #Front Wall is Closest (Turn Away From It)
DataMinerBD.tturnLeftDummy(1)
elif wallNum == 2: # Left Wall is Closest (Turn Away From It)
DataMinerBD.tturnRightDummy(1)
elif wallNum == 3: #Right Wall is Closest (Turn Away From It)
DataMinerBD.tturnLeftDummy(1)
else: #Back Wall is closest- turn so that we are facing directly away from it
if backLeftWall < backRightWall:
DataMinerBD.tturnRightDummy(
1
) #We need to turn right to face more directly away from it
if backLeftWall > backRightWall: # We need to turn left to face more directly away from it
DataMinerBD.tturnLeftDummy(1)
#Rules for thrusting
if speed < maxSpeed and frontWall > 100: #If we are moving slowly and we won't ram into anything, accelerate
DataMinerBD.tthrustDummy(1)
elif trackWall < 200 and (
ai.angleDiff(heading, tracking) > 120
): #If we are getting close to a wall, and we can thrust away from it, do so
DataMinerBD.tthrustDummy(1)
elif backWall < 20: #If there is a wall very close behind us, get away from it
DataMinerBD.tthrustDummy(1)
if abs(
calcDir - heading
) < shotAngle and calcDir != -1: #If we are close to the current proper trajectory for a shot then fire
DataMinerBD.tshootDummy()
previousScore = ai.selfScore()
def AI_loop():
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#Set variables for Wall feelers, heading and tracking of the agent ##
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
left45Wall = ai.wallFeeler(500, heading + 45)
right45Wall = ai.wallFeeler(500, heading - 45)
left90Wall = ai.wallFeeler(500, heading + 90)
right90Wall = ai.wallFeeler(500, heading - 90)
left135Wall = ai.wallFeeler(500, heading + 135)
right135Wall = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
## Create an array that represents the closing rate of each 45 degree of the full 360 degrees surrounding the agent ##
result_list = []
## Array of the same size, but contains the risk of each direction ##
risk_list = []
for i in range(8):
Degree = tracking + (45 * i)
Speed = ai.selfSpeed()
Distance = ai.wallFeeler(10000, tracking + (45 * i))
result = Closing_Rate(Degree, tracking, Speed, Distance)
result_list.append(result)
### Calculate the Fuzzy membership ###
### 1. Fuzzy Membership For Closing Rate (Speed + Tracking Involved) ###
### 2. Fuzzy Membership For Distance From Walls ###
closing_rate, distance = Closing_Rate(Degree, tracking, Speed,
Distance)
low, medium, fast = Fuzzy_Speed(
closing_rate, closingRate_SlowTopAlertValue,
closingRate_SlowBottomAlertValue,
closingRate_MediumBottomLeftAlertValue,
closingRate_MediumTopLeftAlertValue,
closingRate_MediumTopRightAlertValue,
closingRate_MediumBottomRightAlertValue,
closingRate_FastBottomAlertValue, closingRate_FastTopAlertValue)
close, far = Fuzzy_Distance(distance, Distance_CloseTopAlertValue,
Distance_CloseBottomAlertValue,
Distance_FarBottomAlertValue,
Distance_FarTopAlertValue)
#print("close-far", close, far)
risk = Fuzzy_Risk(low, medium, fast, close, far)
risk_list.append(risk)
## Get the direction in deg that is most risky for the robot as well as the least risky direction ##
max_risk = max(risk_list)
track_risk = (tracking + (risk_list.index(max_risk) * 45) % 360)
min_risk = min(
risk_list
) ## Note: Biase Towards Left Side since min get the first min when risk might be equal ##
####### Getters Variable Regarding Important Information About Enemies ########
##Find the closest ennemy##
enemy = ai.lockClose()
## Get the lockheadingdeg of enemy ##
head = ai.lockHeadingDeg()
## Get the dstance from enemy ##
enemyDist = ai.selfLockDist()
## Get the angles on both side between tracking and heading to decide which way to turn ##
dist = (heading - track_risk) % 360
dist2 = (360 - dist) % 360
###### Production System Rules ######
## Turning Rules ##
if (dist <= 130 and dist >= 0 and ai.selfSpeed() > 0 and max_risk >= 75):
ai.turnLeft(1)
elif (dist2 <= 130 and dist2 >= 0 and ai.selfSpeed() > 0
and max_risk >= 75):
ai.turnRight(1)
elif (trackWall <= 150):
ai.thrust(1)
##### Bullet Avoidance Commands #####
elif (ai.shotAlert(0) >= 0 and ai.shotAlert(0) <= 50):
if (ai.shotVelDir(0) != -1
and ai.angleDiff(heading, ai.shotVelDir(0)) > 0
and ai.selfSpeed() <= 5):
ai.turnLeft(1)
ai.thrust(1)
elif (ai.shotVelDir(0) != -1
and ai.angleDiff(heading, ai.shotVelDir(0)) < 0
and ai.selfSpeed() <= 5):
ai.turnRight(1)
ai.thrust(1)
elif (ai.shotVelDir(0) != -1
and ai.angleDiff(heading, ai.shotVelDir(0)) > 0
and ai.selfSpeed() > 5):
ai.turnLeft(1)
else:
ai.turnRight(1)
##### Shooting Ennemy Commands #####
elif (enemyDist <= 3000 and heading > (head) and enemyDist != 0
and ai.selfSpeed() > 2):
ai.turnRight(1)
ai.fireShot()
elif (enemyDist <= 3000 and heading < (head) and enemyDist != 0
and ai.selfSpeed() > 2):
ai.turnLeft(1)
ai.fireShot()
## Rules if nothing is happening ##
elif (ai.selfSpeed() < 5):
ai.thrust(1)
else:
ai.thrust(0)
def AI_loop():
global count_frame, loop, boolean, score, population_size, chromosome_size, population, mutation_prob, crossover_prob, fitness_list, generation, generation_size, first_time, done_learning
#Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
## Get A Chromosome in the Population -- Eventually Will go through each individual in the population ##
current_chromosome = population[loop]
## Transform Each Gene insisde A Single Selected Chromosome. 0s & 1s Are Turned Into Intergers For Fuzzy Sets to understand ##
## Each Value obtained is used to calculate the risk of each 45 degree around the agent ##
## Each value has its own "jump" variable which refers to the distance from each possible points/values ##
## The start and end represents the possible start point and end point for each variable and they depend on
## what the variiable is. It is to ensure a viable fuzzy set and fuzzy functions that these restrictions are applied. ##
closingRate_SlowTopAlert = current_chromosome[0:4]
closingRate_SlowTopAlertValue = transform_fuzzy(closingRate_SlowTopAlert,
1, 0, 16)
closingRate_MediumTopLeftAlert = current_chromosome[4:8]
closingRate_MediumTopLeftAlertValue = transform_fuzzy(
closingRate_MediumTopLeftAlert, 1, (closingRate_SlowTopAlertValue + 1),
(closingRate_SlowTopAlertValue + 1) + 16)
closingRate_MediumTopRightAlert = current_chromosome[8:12]
closingRate_MediumTopRightAlertValue = transform_fuzzy(
closingRate_MediumTopRightAlert, 1,
(closingRate_MediumTopLeftAlertValue + 1),
(closingRate_MediumTopLeftAlertValue + 1) + 16)
closingRate_FastTopAlert = current_chromosome[12:16]
closingRate_FastTopAlertValue = transform_fuzzy(
closingRate_FastTopAlert, 1,
(closingRate_MediumTopRightAlertValue + 1),
(closingRate_MediumTopRightAlertValue + 1) + 16)
closingRate_SlowBottomAlert = current_chromosome[16:20]
start = (closingRate_SlowTopAlertValue +
(((closingRate_MediumTopLeftAlertValue -
closingRate_SlowTopAlertValue) // 2) + 1))
end = (start + (1 * (2**(len(closingRate_SlowBottomAlert)))))
closingRate_SlowBottomAlertValue = transform_fuzzy(
closingRate_SlowBottomAlert, 1, start, end)
closingRate_MediumBottomLeftAlert = current_chromosome[20:24]
end = (closingRate_MediumTopLeftAlertValue -
(((closingRate_MediumTopLeftAlertValue -
closingRate_SlowTopAlertValue) // 2) + 1))
start = end - (1 * (2**(len(closingRate_MediumBottomLeftAlert))))
if (end < 0):
end = 0
if (start < 0):
start = 0
jump = (end - start) // (2**(len(closingRate_MediumBottomLeftAlert)))
closingRate_MediumBottomLeftAlertValue = transform_fuzzy(
closingRate_MediumBottomLeftAlert, jump, start, end)
closingRate_MediumBottomRightAlert = current_chromosome[24:28]
start = (closingRate_MediumTopRightAlertValue +
(((closingRate_FastTopAlertValue -
closingRate_MediumTopRightAlertValue) // 2) + 1))
end = start + (1 * (2**(len(closingRate_MediumBottomRightAlert))))
closingRate_MediumBottomRightAlertValue = transform_fuzzy(
closingRate_MediumBottomRightAlert, 1, start, end)
closingRate_FastBottomAlert = current_chromosome[28:32]
end = (closingRate_FastTopAlertValue -
(((closingRate_FastTopAlertValue -
closingRate_MediumTopRightAlertValue) // 2) + 1))
start = end - (1 * (2**(len(closingRate_FastBottomAlert))))
if (end < 0):
end = 0
if (start < 0):
start = 0
jump = (end - start) // (2**(len(closingRate_FastBottomAlert)))
closingRate_FastBottomAlertValue = transform_fuzzy(
closingRate_FastBottomAlert, jump, start, end)
Distance_CloseTopAlert = current_chromosome[32:37]
Distance_CloseTopAlertValue = transform_fuzzy(
Distance_CloseTopAlert, 50, 0, (50 * (2**len(Distance_CloseTopAlert))))
Distance_FarTopAlert = current_chromosome[37:42]
Distance_FarTopAlertValue = transform_fuzzy(
Distance_CloseTopAlert, 50, (Distance_CloseTopAlertValue + 50),
(Distance_CloseTopAlertValue + 50) +
(50 * (2**len(Distance_CloseTopAlert))))
Distance_CloseBottomAlert = current_chromosome[42:47]
start = (Distance_CloseTopAlertValue + ((
(Distance_FarTopAlertValue - Distance_CloseTopAlertValue) // 2) + 1))
end = Distance_FarTopAlertValue
jump = (end - start) // (2**(len(Distance_CloseBottomAlert)))
Distance_CloseBottomAlertValue = transform_fuzzy(Distance_CloseBottomAlert,
jump, start, end)
Distance_FarBottomAlert = current_chromosome[47:52]
end = (Distance_FarTopAlertValue - ((
(Distance_FarTopAlertValue - Distance_CloseTopAlertValue) // 2) + 1))
start = Distance_CloseTopAlertValue
jump = (end - start) // (2**(len(Distance_FarBottomAlert)))
Distance_FarBottomAlertValue = transform_fuzzy(Distance_FarBottomAlert,
jump, start, end)
#Set variables for Wall feelers, heading and tracking of the agent ##
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
left45Wall = ai.wallFeeler(500, heading + 45)
right45Wall = ai.wallFeeler(500, heading - 45)
left90Wall = ai.wallFeeler(500, heading + 90)
right90Wall = ai.wallFeeler(500, heading - 90)
left135Wall = ai.wallFeeler(500, heading + 135)
right135Wall = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
## Create an array that represents the closing rate of each 45 degree of the full 360 degrees surrounding the agent ##
result_list = []
## Array of the same size, but contains the risk of each direction ##
risk_list = []
for i in range(8):
Degree = tracking + (45 * i)
Speed = ai.selfSpeed()
Distance = ai.wallFeeler(10000, tracking + (45 * i))
result = Closing_Rate(Degree, tracking, Speed, Distance)
result_list.append(result)
### Calculate the Fuzzy membership ###
### 1. Fuzzy Membership For Closing Rate (Speed + Tracking Involved) ###
### 2. Fuzzy Membership For Distance From Walls ###
closing_rate, distance = Closing_Rate(Degree, tracking, Speed,
Distance)
low, medium, fast = Fuzzy_Speed(
closing_rate, closingRate_SlowTopAlertValue,
closingRate_SlowBottomAlertValue,
closingRate_MediumBottomLeftAlertValue,
closingRate_MediumTopLeftAlertValue,
closingRate_MediumTopRightAlertValue,
closingRate_MediumBottomRightAlertValue,
closingRate_FastBottomAlertValue, closingRate_FastTopAlertValue)
close, far = Fuzzy_Distance(distance, Distance_CloseTopAlertValue,
Distance_CloseBottomAlertValue,
Distance_FarBottomAlertValue,
Distance_FarTopAlertValue)
#print("close-far", close, far)
risk = Fuzzy_Risk(low, medium, fast, close, far)
risk_list.append(risk)
## Get the direction in deg that is most risky for the robot as well as the least risky direction ##
max_risk = max(risk_list)
track_risk = (tracking + (risk_list.index(max_risk) * 45) % 360)
min_risk = min(
risk_list
) ## Note: Biase Towards Left Side since min get the first min when risk might be equal ##
####### Getters Variable Regarding Important Information About Enemies ########
##Find the closest ennemy##
enemy = ai.lockClose()
## Get the lockheadingdeg of enemy ##
head = ai.lockHeadingDeg()
## Get the dstance from enemy ##
enemyDist = ai.selfLockDist()
## If the Enemy is Dead ##
if (ai.selfAlive() == 0 and boolean == False):
## Calculate Fitness Current Individual ##
score_previous = score
score_current = ai.selfScore()
fitness_value = fitness(population, count_frame, score_previous,
score_current)
fitness_list.append(fitness_value)
## If it went through the whole population and ready to move to next generation ##
if ((loop + 1) == population_size):
## Output the fitness of population to allow user to see if learning is happening ##
print("Generation:", generation)
print("Agent Fitness:")
print(fitness_list)
print("Average Fitness:", statistics.mean(fitness_list))
print("Best Fitness:", max(fitness_list))
## Finding the optimal chromosome to output it in data file ##
string_maxChromosome = ""
for chrom_max in range(chromosome_size):
string_maxChromosome = string_maxChromosome + str(
population[fitness_list.index(
max(fitness_list))][chrom_max])
## Formatting entire population in a big string to register it in excel file##
string_population = ""
for pop in range(population_size):
for pop_chrom in range(chromosome_size):
string_population = string_population + str(
population[pop][pop_chrom])
if (pop != (population_size - 1)):
string_population = string_population + ","
## Formatting entire population's fitness in a big string to register it in excel file##
string_fitness = ""
for fit in range(len(fitness_list)):
string_fitness = string_fitness + str(fitness_list[fit])
if (fit != (len(fitness_list) - 1)):
string_fitness = string_fitness + ","
## Output Data into Excel File ##
titles = [
"Generation", "Average Fitness", "Best Fitness",
"Population Size", "Chromosome Size", "Crossover Probability",
"Mutation Probability", "Best Chromosome",
"Entire Population Chromosome", "Entire Population Fitness"
]
data = [
generation,
statistics.mean(fitness_list),
max(fitness_list), population_size, chromosome_size,
crossover_prob, mutation_prob, string_maxChromosome,
string_population, string_fitness
]
first_time = Save_Data("Dumpster_Training_Data.xls", 0, titles,
data, first_time)
## Select Population For Next Generation -- Apply Crossover & Mutation ##
new_population = select(population, fitness_list)
new_population = crossover(new_population, chromosome_size,
population_size, crossover_prob)
new_population = mutate(new_population, chromosome_size,
mutation_prob)
population = new_population
loop = 0
count_frame = 0
generation += 1
fitness_list.clear()
### DONE -- QUIT ###
if (generation == generation_size):
quitAI()
## Move to the next individual in population ##
else:
loop += 1
count_frame = 0
boolean = True
else:
## The agent is Alive ##
if (ai.selfAlive() == 1):
## Get the angles on both side between tracking and heading to decide which way to turn ##
dist = (heading - track_risk) % 360
dist2 = (360 - dist) % 360
###### Production System Rules ######
## Turning Rules ##
if (dist <= 130 and dist >= 0 and ai.selfSpeed() > 0
and max_risk >= 75):
ai.turnLeft(1)
elif (dist2 <= 130 and dist2 >= 0 and ai.selfSpeed() > 0
and max_risk >= 75):
ai.turnRight(1)
elif (ai.selfSpeed() <= 10):
ai.thrust(1)
elif (trackWall <= 150):
ai.thrust(1)
##### Bullet Avoidance Commands #####
elif (ai.shotAlert(0) >= 0 and ai.shotAlert(0) <= 50):
if (ai.shotVelDir(0) != -1
and ai.angleDiff(heading, ai.shotVelDir(0)) > 0
and ai.selfSpeed() <= 5):
ai.turnLeft(1)
ai.thrust(1)
elif (ai.shotVelDir(0) != -1
and ai.angleDiff(heading, ai.shotVelDir(0)) < 0
and ai.selfSpeed() <= 5):
ai.turnRight(1)
ai.thrust(1)
elif (ai.shotVelDir(0) != -1
and ai.angleDiff(heading, ai.shotVelDir(0)) > 0
and ai.selfSpeed() > 5):
ai.turnLeft(1)
else:
ai.turnRight(1)
##### Shooting Ennemy Commands #####
elif (enemyDist <= 3000 and heading > (head) and enemyDist != 0
and ai.selfSpeed() > 5):
ai.turnRight(1)
ai.fireShot()
elif (enemyDist <= 3000 and heading < (head) and enemyDist != 0
and ai.selfSpeed() > 5):
ai.turnLeft(1)
ai.fireShot()
## Rules if nothing is happening ##
elif (ai.selfSpeed() < 5):
ai.thrust(1)
else:
ai.thrust(0)
count_frame += 3
boolean = False
def AI_loop():
turn, thrust = .5, 0
ai.turnLeft(0)
ai.turnRight(0)
ai.thrust(0)
ai.setTurnSpeed(64)
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
trackWall = ai.wallFeeler(500, tracking)
frontL = ai.wallFeeler(500, heading + 10)
frontR = ai.wallFeeler(500, heading - 10)
leftF = ai.wallFeeler(500, heading + 70)
leftB = ai.wallFeeler(500, heading + 110)
rightF = ai.wallFeeler(500, heading - 70)
rightB = ai.wallFeeler(500, heading - 110)
backL = ai.wallFeeler(500, heading - 200)
backR = ai.wallFeeler(500, heading - 160)
trackHeadRelative = (tracking - heading)
speed = ai.selfSpeed()
def findClosestArea(x):
return {
frontL: 1,
leftF: 2,
leftB: 3,
backL: 4,
backR: 5,
rightF: 6,
rightB: 7,
frontR: 8
}[x]
closestVal = min(frontL, leftF, leftB, backL, backR, rightF, rightB,
frontR)
#Find the closest Wall to our ship
closestWall = findClosestArea(closestVal)
#Rules for turning
if closestWall == 1:
ai.setTurnSpeed(64)
ai.turnRight(1)
turn = 1
elif closestWall == 2:
ai.setTurnSpeed(46)
ai.turnRight(1)
turn = .9
elif closestWall == 3:
ai.setTurnSpeed(28)
ai.turnRight(1)
turn = .8
elif closestWall == 4:
ai.setTurnSpeed(10)
ai.turnRight(1)
turn = .6
elif closestWall == 5:
ai.setTurnSpeed(10)
ai.turnLeft(1)
turn = .4
elif closestWall == 6:
ai.setTurnSpeed(28)
ai.turnLeft(1)
turn = .2
elif closestWall == 7:
ai.setTurnSpeed(26)
ai.turnLeft(1)
turn = .1
elif closestWall == 8:
ai.setTurnSpeed(64)
ai.turnLeft(1)
turn = 0
#Rules for thrusting
#if we are going slow and there isn't a wall in front of us
if min(frontL, frontR) > 100 and speed < 3:
ai.thrust(1)
thrust = 1
#if we are heading toward a wall and we are not facing it
elif trackWall < 150 and (ai.angleDiff(heading, tracking) > 90):
ai.thrust(1)
thrust = 1
#If there is a wall very close behind us, get away from it
elif backL < 20 or backR < 20:
ai.thrust(1)
thrust = 1
doBackPropigation = True
if ai.selfAlive() and doBackPropigation:
#adjust the the learning NN
infile = open("Sem2W_1.txt", "r")
weight = eval(infile.read())
infile.close()
sendData = getSendData(turn, thrust)
weight = adjustNN(sendData, 12, 5, 2, weight)
outfile = open("Sem2W_1.txt", "w")
outfile.write(str(weight))
outfile.close()
def AI_loop():
""" The main loop for this agent!
Greenock is a rule-based expert system.
"""
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
# Heuristics
sideFeelerOffset = 15 # Offsets from heading for wall feelers (degrees)
nearLimit = 20 * ai.selfSpeed(
) # Threshold for close objects (xp distance units)
shotDanger = 80 # Threshold for close bullets (xp distance units)
# Reset everything else
ai.setTurnSpeedDeg(20) # Artificial handicap!
# Acquire information
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontLeftWall = ai.wallFeeler(500, heading + sideFeelerOffset)
frontRightWall = ai.wallFeeler(500, heading - sideFeelerOffset)
rshipnum = ai.closestShipId()
# Combat decisions
if (ai.shotAlert(0) > -1) and (ai.shotAlert(0) < shotDanger):
ai.turnToDeg(angleDiff(heading, ai.angleAdd(ai.shot_idir(0), 90)))
ai.thrust(1)
elif (ai.closestShipId() > -1):
ai.turnToDeg(angleDiff(heading, ai.aimdir(ai.closestShipId())))
ai.fireShot()
elif (rshipnum > -1):
ai.turnToDeg(angleDiff(heading, ai.aimdir(ai.closestShipId)))
if (ai.selfSpeed() < 10):
ai.thrust(1)
else:
ai.fireShot()
# Navigation decisions
if ((frontRightWall == frontLeftWall) and (frontRightWall < nearLimit)
and (ai.selfSpeed() > 1)):
ai.turnToDeg(angleDiff(heading, ai.angleAdd(180,
ai.selfTrackingDeg())))
ai.thrust(1)
elif ((frontRightWall < frontLeftWall) and (frontRightWall < nearLimit)
and (ai.selfSpeed() > 1)):
ai.turnToDeg(
angleDiff(heading,
ai.angleAdd(180, ai.angleAdd(-15,
ai.selfTrackingDeg()))))
ai.thrust(1)
elif ((frontRightWall > frontLeftWall) and (frontRightWall < nearLimit)
and (ai.selfSpeed() > 1)):
ai.turnToDeg(
angleDiff(heading,
ai.angleAdd(180, ai.angleAdd(15, ai.selfTrackingDeg()))))
ai.thrust(1)
def AI_loop(self):
# Release keys
ai.thrust(0)
ai.turnLeft(0)
ai.turnRight(0)
#-------------------- Set variables --------------------#
heading = int(ai.selfHeadingDeg())
tracking = int(ai.selfTrackingDeg())
frontWall = ai.wallFeeler(500, heading)
leftWall = ai.wallFeeler(500, heading + 45)
rightWall = ai.wallFeeler(500, heading - 45)
leftWallStraight = ai.wallFeeler(500, heading + 90)
rightWallStraight = ai.wallFeeler(500, heading - 90)
leftBack = ai.wallFeeler(500, heading + 135)
rightBack = ai.wallFeeler(500, heading - 135)
backWall = ai.wallFeeler(500, heading - 180)
trackWall = ai.wallFeeler(500, tracking)
R = (heading - 90) % 360
L = (heading + 90) % 360
aim = ai.aimdir(0)
bullet = ai.shotAlert(0)
speed = ai.selfSpeed()
x = ai.selfX()
y = ai.selfY()
coordinate = self.grid[self.counter][1]
targetX = coordinate[0]
targetY = coordinate[1]
toTurn = self.angleToPoint(x, y, targetX, targetY, heading)
distance = self.distance(x, targetX, y, targetY)
if speed > 5:
turning = ai.angleDiff(heading, tracking)
if abs(turning) > 165 and abs(turning) <= 180:
ai.turnLeft(0)
ai.turnRight(0)
if self.frames % 10 == 0:
ai.thrust(1)
elif abs(turning) <= 165:
ai.turnRight(1)
elif negateAngle >= 10:
ai.turnLeft(1)
else:
#-------------------- Print statements --------------------#
# print("(x, y): (",x,",",y,")")
print("destination: ", self.grid[self.counter % self.gridLength])
# print("distance: ", distance)
# print("closestEnemyX: ", targetX)
# print("closestEnemyY: ", targetY)
# print("screen enemy? ", ai.screenEnemyXId(ai.closestShipId()))
# print("toTurn: ", toTurn)
print("speed: ", speed)
print("")
#-------------------- Move to target point --------------------#
if abs(toTurn) < 10 and distance > 100:
print("Lock!")
ai.turnLeft(0)
ai.turnRight(0)
if self.frames % 3 == 0:
ai.thrust(1)
elif toTurn >= 10:
ai.turnLeft(1)
elif toTurn <= -10:
ai.turnRight(1)
if distance < 200:
self.markSpotChecked(coordinate)
self.checkSearchComplete()
#-------------------- Thrust rules --------------------#
if speed <= 3 and frontWall >= 200:
ai.thrust(1)
elif trackWall < 50:
ai.thrust(1)
elif backWall < 40:
ai.thrust(1)
#---------------- Turn rules ----------------#
# Figures out what corner we are in and turns the right directon
if (backWall < 30) and (rightWallStraight < 200):
ai.turnLeft(1)
elif backWall < 30 and (leftWallStraight < 200):
ai.turnRight(1)
# Walls along our periphery (90 degree feelers)
elif leftWallStraight < rightWallStraight and trackWall < 75:
ai.turnRight(1)
elif leftWallStraight > rightWallStraight and trackWall < 75:
ai.turnLeft(1)
self.frames = self.frames + 1