def getSendData(turn, thrust): #Metadata heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) trackHeadRelative = ai.angleDiff(heading, tracking) / 180 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 - 190) backR = ai.wallFeeler(500, heading - 170) 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 angleToPoint(self, x, y, targetX, targetY, heading): differenceX = targetX - x differenceY = targetY - y angleDiffRad = math.atan2(differenceY, differenceX) angleDiffDegrees = math.degrees(angleDiffRad) toTurn = ai.angleDiff(heading, int(angleDiffDegrees)) return toTurn
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 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(): 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(): 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 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 - 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(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) ## 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(): 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(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
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(): #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) 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 getInputs(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 = 0 targetX, targetY = ai.screenEnemyX(0), ai.screenEnemyY(0) if targetX- ai.selfX() != 0: calcDir = int(math.degrees(math.atan2((targetY - ai.selfY()), (targetX- ai.selfX()))) + 360)%360 calcDiff = ai.angleDiff(heading, calcDir) trackDiff = ai.angleDiff(heading, tracking) 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.addTurnInput(1/(frontWall+1)) self.addTurnInput(1/(leftWall+1)) self.addTurnInput(1/(rightWall+1)) self.addTurnInput(1/(backWall+1)) self.addTurnInput(calcDiff/180) self.addTurnInput(trackDiff/180) self.addTurnInput(speed/(trackWall+1)) #self.addTurnInput(heading/360) #self.addTurnInput(calcDir/360) #self.addTurnInput(1/(backLeftWall+1)) #self.addTurnInput(1/(backRightWall+1)) #self.addInput(fFan) #self.addInput(rFan) #self.addInput(lFan) #self.addInput(bFan) #self.addInput(tracking) self.addShootInput(calcDiff/180) self.addThrustInput(trackDiff/180) self.addThrustInput(speed) self.addThrustInput(1/(trackWall+1)) self.addThrustInput(1/(backWall+1))
def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) turn, thrust, shoot = 0.5, 0, 0 maxSpeed = 3 shotAngle = 9 wallClose = 12 #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, 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) calcDir = 0 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 ai.turnRight(1) #Screw aiming and turn right and thrust ai.thrust(1) thrust = 1 #This is arguably a horrible strategy because our sideways profile is much larger, but it's required for the grade elif diff >= 0: if diff >= 180: ai.turnRight(1) #If the target is to our right- turn right turn = 1 else : ai.turnLeft(1) #If the target is to our left - turn left turn = 0 else : if diff > -180: ai.turnRight(1) #If the target is to our right - turn right turn = 1 else : ai.turnLeft(1) #If the target is to our left - turn left turn = 0 #Rules for avoiding death else : # if crashWall/ai.selfSpeed() > ai.closestShot() : 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 if abs(calcDir - heading) < shotAngle : #If we are close to the current proper trajectory for a shot then fire ai.fireShot() shoot = 1 #adjust the the learning NN infile = open("myBotWeights.txt","r") weight = eval(infile.read()) infile.close() sendData = getSendData(turn, thrust, shoot) weight = adjustNN(sendData, 21, 8, 3, weight) outfile = open("myBotWeights.txt","w") outfile.write(str(weight)) outfile.close()