def AI_loop(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) sendData = getSendData() output = getOutput(sendData, 12, 5, 2, weight) turn, thrust = "N", "N" if output[0] >= .55: ai.turnRight(1) turn = "R" elif output[0] < .45: ai.turnLeft(1) turn = "L" ai.setTurnSpeed(abs(output[0]-.5)*100) if output[1] > random(): ai.thrust(1) thrust = "Y" if ai.selfAlive(): print (turn +" "+ str(round(output[0],3)) +" | "+ thrust +" "+ str(round(output[1],3)))
def act(self): if ai.selfAlive(): self.getInputs() #self.printInputs() steerOutput = self.steeringNet.activate(self.steerInputs)[0] thrustOutput = self.thrustingNet.activate(self.thrustInputs)[0] shootOutput = self.shootingNet.activate(self.shootInputs)[0] print([steerOutput, thrustOutput, shootOutput]) if steerOutput > .5: ai.turnLeft(1) ai.turnRight(0) else: ai.turnRight(1) ai.turnLeft(0) if thrustOutput > .5: ai.thrust(1) else : ai.thrust(0) if shootOutput > .5: ai.fireShot() self.resetInputs() else: self.steeringNet.reset() self.thrustingNet.reset() self.shootingNet.reset()
def register(): """ Register sensor data in a CSV file """ data = get_readings() data["Action"] = ship.current_action() # Check if it's the first iteration by checking if the data file is empty first_time = os.stat(DATA_FILE).st_size == 0 if ai.selfAlive(): with open(DATA_FILE, "a") as f: if first_time: f.write(";".join(data) + "\n") f.write(";".join(str(value) for value in data.values()) + "\n") return first_time
def tick(): # # The API won't print out exceptions, so we have to catch and print them ourselves. # try: # # Declare global variables so we have access to them in the function # global tickCount global mode # # Reset the state machine if we die. # if not ai.selfAlive(): tickCount = 0 mode = "ready" return tickCount += 1 # # Read some "sensors" into local variables, to avoid excessive calls to the API # and improve readability. # selfX = ai.selfX() selfY = ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() selfHeading = ai.selfHeadingRad() # 0-2pi, 0 in x direction, positive toward y # Add more sensors readings here print ("tick count:", tickCount, "mode", mode) if mode == "ready": pass except: print(traceback.print_exc())
def ai_loop(): """ Main loop. Automatically run at each frame. """ try: first_time = register() if first_time: initialise() if ai.selfAlive(): act = actSelector.decide() if action is not None: ship.set_action(act) ship.act() else: ship.you_are_dead() except: print("Unexpected error, %s: %s" % sys.exc_info()[:2]) print(traceback.print_tb(sys.exc_info()[-1]))
def AI_loop(): if ai.selfAlive(): global loopCount, lastLoop con.act() loopCount+=1 con.dummyCode() DataMinerBD.updateInputs() DataMinerBD.updateOutputs() DataMinerBD.savePair() if loopCount % 100 == 0: print(loopCount) if loopCount > 1000: DataMinerBD.writeData() ai.quitAI() lastLoop = 1 else: if lastLoop == 1: DataMinerBD.writeDeath() lastLoop = 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(): 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(): 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 tick(): # # The API won't print out exceptions, so we have to catch and print them ourselves. # try: # # Declare global variables so we're allowed to use them in the function # global tickCount global mode global targetId # # Reset the state machine if we die. # if not ai.selfAlive(): tickCount = 0 mode = "aim" return tickCount += 1 # # Read some "sensors" into local variables to avoid excessive calls to the API # and improve readability. # selfX = ai.selfX() selfY = ai.selfY() selfHeading = ai.selfHeadingRad() # 0-2pi, 0 in x direction, positive toward y targetCount = ai.targetCountServer() targetCountAlive = 0 for i in range(targetCount): if ai.targetAlive(i): targetCountAlive += 1 # Use print statements for debugging, either here or further down in the code. # Useful functions: round(), math.degrees(), math.radians(), etc. # os.system('clear') clears the terminal screen, which can be useful. print("tick count:", tickCount, "mode:", mode, "heading:", round(math.degrees(selfHeading)), "targets alive:", targetCountAlive) if mode == "wait": if targetCountAlive > 0: mode = "aim" elif mode == "aim": if targetCountAlive == 0: mode = "wait" return # Loop through the indexes of targets and find one that is alive, # save that index in targetId. # useful variables: targetCount, targetId # useful functions: ai.targetAlive for i in range(targetCount): if ai.targetAlive(i): targetId = i # Calculate what direction the target is in, save in # the variable targetDirection # useful variables: selfX, selfY # useful functions: math.atan2, ai.targetX, ai.targetY xDiff = ai.targetX(targetId) - ai.selfX() yDiff = ai.targetY(targetId) - ai.selfY() targetDirection = math.atan2(yDiff, xDiff) # Turn to the direction of the target # useful variables: targetDirection # useful functions: ai.turnRad, ai.turnToRa # If the ship keeps oscillating between a few angles # it may be due to latency. Only turning every second # or third tick is a simple solution (use tickCount and %) # Check if you are aiming in the direction of the target, # if so, change mode to shoot. # Note that, due to how the game handles angles, the difference # cannot be 0 for many angles. # useful variables: selfHeading, targetDirection, mode # There is a function defined below called angleDiff that # is very useful as well. if angleDiff(selfHeading, targetDirection) < 0.1 and ai.targetAlive(targetId): mode = "shoot" else: if tickCount % 3 == 0: ai.turnToRad(targetDirection) elif mode == "shoot": # Shoot the target # useful functions: ai.fireShot # if the target is destroyed, change state to aim # useful variables: targetId, mode # useful functions: ai.targetAlive ai.fireShot() if not ai.targetAlive(targetId): mode = "aim" except: # # If tick crashes, print debugging information # print(traceback.print_exc())
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 __init__(self): self.action = None self.target = None self.warned = False self.was_dead = ai.selfAlive() self.was_dead_before = ai.selfAlive()
def tick(): # # The API won't print out exceptions, so we have to catch and print them ourselves. # try: # # Declare global variables so we have access to them in the function # global tickCount global mode # # Reset the state machine if we die. # if not ai.selfAlive(): tickCount = 0 mode = "ready" return tickCount += 1 # # Read some "sensors" into local variables, to avoid excessive calls to the API # and improve readability. # selfX = ai.selfX() selfY = ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() selfHeading = ai.selfHeadingRad() # 0-2pi, 0 in x direction, positive toward y # Add more sensors readings here print("tick count:", tickCount, "mode", mode) if mode == "ready": greetings = [ "Hey. ", "Hello. ", "Yooo. ", "Excuse me, sir? ", "It's yo boy in da house. ", "Goddaaaaag, NOLLA! ", "'Sup. Come here often? " ] questions = [ "What are your coords?", "What is your heading?", "How many items have you seen?", "What ships have you seen?", "What is your tracking?" ] if tickCount % 50 == 0: unansweredQuestions = [] for i in range(ai.getMaxMsgs()): if ":[Pelle]" in ai.scanTalkMsg(i): unansweredQuestions.append(ai.scanTalkMsg(i)) ai.removeTalkMsg(i) if name == "Stub": rand = random.SystemRandom() ai.talk("Pelle:" + rand.choice(greetings) + rand.choice(questions)) for s in unansweredQuestions: if ":[Pelle]" in s: msg = "Stub:Hey" if "coords" in s: msg = "Stub:My coords are (" + str( ai.selfX()) + ", " + str(ai.selfY()) + ")." elif "heading" in s: msg = "Stub:My heading is " + str( ai.selfHeadingRad()) + " radians." elif "tracking" in s: msg = "Stub:My tracking is " + str( ai.selfTrackingRad()) + " radians." elif "items" in s: msg = "Stub:I have seen " + str( ai.itemCountScreen()) + " items." elif "ships" in s: ships = [] if (ai.shipCountScreen() - 1) > 0: for player_id in range(ai.playerCountServer()): if ai.playerName( player_id) != ai.selfName(): ships.append(ai.playerName(player_id)) msg = "I see " + str(ai.shipCountScreen() - 1) + " ship(s). " + str(ships) ai.talk(msg) except: print(traceback.print_exc())
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(): #Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(45) #noshoot simple2 v1 - possibly broken #weight = [[0.7493857316521443, 0.13368056995306654, -0.47767010506248414, 0.36303490376111747, 0.3699402939846066, -0.24513421555956436, 0.6049213422682447, -1.002771350490762, 0.04035249957935825, -0.28434589370049973, 0.06045481719428707, -0.7059773487995405], [0.4597751718875, 0.48527265677711917, 1.1633270644302531, -0.2617787944640836, 0.43969814249154665, 0.39105202732983013, -0.4842763268769806, 0.0139642821717396, 0.6316767202549712, -0.7261062652316246, 0.21262210805420517, 0.5641099350636366], [-0.3874172140692371, 0.7651295146994167, 1.0395098788413182, 1.186226846675026, -0.025235379424306762, 0.2946735626872294, 0.8189904988668917, -0.3112836835374087, 0.4561011502092862, -1.117805735032487, -0.43961810490175446, -0.4119472393430895], [0.22275511634133816, -0.6648437205568158, -0.8414740640064268, 0.8056440111521608, 0.015267716015499746, 0.41334996924272127, 0.4081963555038903, -0.1419511839287509, 0.45361416054410414, -0.8794849582102071, -0.3468746833944422, 0.5401415708615188], [0.5074970117306209, 0.5819675141877677, 0.6517899284876814, 0.46691400605473293, 0.32604510520447944, 0.5968926122763236, 0.5310482664503053, -0.680392116654488, 0.8673231237747582, 0.33285892719317295, 0.8399077545012879, 0.6164215093257798], [-0.372562013299741, -0.19652620269354013, 0.1437357080878078, 0.4658598892474184, 0.2622911587442708, -0.0978653491300881], [-0.8758502232674676, -0.2171515591378693, -2.993752695121232, -0.35299785185297505, 0.23130479682141922, -0.3366867315248932]] #same #weight = [[-0.5615458044552419, 0.18357035281974562, 0.03349259503126993, 0.7384951638825633, -0.30798810007905386, 0.30573186272807085, 0.854959406907431, -0.7415861859492735, -0.7738387875893121, 0.02855354677310282, -0.851478966174285, -0.4098017778685181], [-0.207370684933253, -0.013364767376613134, -0.9163625758710611, 0.7147484720369136, 0.4332939609435104, 0.08179173241171495, -0.7872472562071717, -0.028481692524635203, 0.9018021433254303, 0.44174414866442663, -0.9254417448428363, -0.8782722048252558], [0.33830929947647237, 0.3662059060118147, 0.3811711776833437, 0.24042392561994674, 0.5277499126295441, -0.0004866655690337176, 0.25640579185352463, -0.7633986561071578, -0.612156341670209, 0.8230711072150679, 0.760953671186351, -0.2573796666700781], [-0.504034389497162, -0.5579761993837166, -0.5804468446739354, 0.20559197382639358, 0.2633102441141902, 0.6523171620389138, -0.024442707325193276, 0.20991650483980787, 0.8242995112997102, -0.310268650118638, 0.6134846337134139, -0.1333594123873779], [-0.1482061081648374, -0.8156028525698128, 0.5620698705963493, 0.3369535386843364, 0.4950101349517008, 0.632041030208815, 0.2282786987810209, 0.5886322102158713, 0.1479714498784525, -0.35843514023521145, 0.7822417167093876, -0.6863908492221918], [0.19475966937630487, 0.3329038845401951, -0.4194515125286082, -1.0059783572483236, 0.4401534681618835, -0.14131035905437314], [-0.1489506388852606, -0.7142411448348961, 0.19491176823686687, -0.7258125795197734, -0.5016315182547347, 1.187683861246764]] #noshoot simple2 v1 #weight = [[4.023914862289385, -11.939688383204079, -15.825568188856662, -8.91142185823263, 2.641203914119205, -0.5129014819329881, 0.9220419943089314, 0.3895906088166904, -3.314207628630927, 1.467458787811278, 1.0256723985314264, 6.790853759075572], [0.46927642890835647, 0.4119664313516612, 1.0805195819839035, -22.587191583019706, -2.0569865767257087, 1.0122406403957074, 0.7655020473448081, 0.5363534804959299, -0.09153880599832058, 1.742638802899449, 0.604362216981221, -5.437549122082703], [-7.860553953097792, 8.381751807757572, 16.129268910929408, 0.8192147369369929, 12.621334155351937, 1.1871517887014937, 1.3270695309760896, 1.0735505581082165, -2.1305919492192547, 0.8033262515099523, 3.3317152348735313, -1.1046970930734303], [0.4398449547641411, 1.912802187200376, 1.5190820053279013, 0.05054235950852018, 20.89903152269866, -5.003395008994748, -2.6880139668653324, -7.882075146152547, 7.312459204984362, 0.7725581247271933, -3.2005214579831134, 8.556187322708842], [-1.293677418426306, 1.0762585514923537, 2.9472553959491394, -2.8811018920854745, 20.39410027291124, 3.5575387211971545, -4.928681592073799, 3.91012465174139, -0.6466184042394076, 8.419255646279453, -8.094268776239682, 19.5220882165644], [0.3806641134895386, -0.054247151061047154, 0.35553915476967757, -0.16909223457447353, 0.6749672736601655, -0.19785778477211138], [6.21846263437043, 13.27919055895352, 5.556186398879765, 1.9758063219353386, 3.685290720905768, 11.4029046390971]] #weight = [[0.5903138120766798, 0.3877986755669686, -0.9141386987535192, -0.1976691845132495, 0.20203743452617146, -3.8075577538969068, 13.355367631879064, -4.451492883287705, -4.077459994350015, -2.8670604965816433, -4.7237141988262215, 4.196577955775335], [0.05788957126040142, 0.7553202993193877, -0.41293776536874083, 0.9699420358471046, -0.39940905986885467, -0.7501531314002139, -3.649664715012045, -4.480417131687637, 12.40189634710716, -3.5479446525980323, -5.617634895580113, 4.614443478920718], [-0.44964748196431087, -0.21623652235598786, 0.5866855307562749, 2.6966017037464547, -0.2198767358187771, -15.121568447637916, 5.394174355851121, 3.3357101263144284, 5.142941080162113, 4.396587735322672, 6.27965132359125, -1.7132992179558508], [-0.8420976477874832, 3.6695944609982, 3.985187073998181, 11.839206173737303, -5.338358329529615, 12.584411691032383, -3.6258238911963225, -9.100219517619708, 0.09757837890948427, 0.26347032883307564, -2.317810633312963, 3.488522703736898], [0.7765991306851521, 0.28898396896441564, 0.7418514532805458, 7.79799228304993, -0.19002509820555794, -0.4950254716867189, 1.674108868938578, -2.550479398095525, -0.4777881148214889, -17.68616848936312, 17.798127474785755, 3.564677234214063], [-7.8104601458246075, -2.0636289766378315, -8.171829518484577, -0.3002860633762538, -0.8003364861508999, -8.88545431866241], [-9.931271155016605, -8.304191180682096, -4.721651527085654, -11.413401995134363, -6.807105641677094, -4.2517323859898255]] #take 3 #weight = [[3.2209677211590364, 3.197844521358916, 1.0178700774531555, 2.6850832852265705, -0.1142410857208976, -7.424760693950065, 2.4741068398654735, -2.2455337118424423, 0.7975567187947812, -7.14879174218826, 1.1236926484785208, 1.0893799362829708], [0.8039483127966134, 2.0360025213584287, 0.01727196345640146, 13.743242184336747, -3.1131725731697797, 3.551772323183245, -1.912134715951023, 6.3466547648380365, 2.7583972445682843, -8.543348277242536, 1.0695972197298327, 1.0968548560479523], [-1.9711628616688408, -2.915258703528061, -0.6856763056229077, 5.775022292258987, -0.9242292134264676, -5.2290301586614545, 1.554497111395412, -8.663422012897401, 3.434867742464676, -1.4626063376098368, 3.1916811250980226, -3.1266957996982083], [-2.963581011499582, -1.8333571215071727, 0.19431283257511642, 12.685505979633772, 5.629563357825744, 2.269402859201827, -0.5394798674782302, 0.5415330617135145, -1.3492223641876873, -2.3782036784139104, -1.6868806998589756, -2.566848157895665], [-2.1971772106385568, -3.046613937692231, -1.91992660803775, 6.63802500331367, -13.090973918413972, 2.0019783380453955, 1.5786044885623458, -1.1226639661286304, -0.8816140948702889, -0.6041236731069092, 0.4128577493527515, -9.236718652388456], [-0.37898780078879885, 0.02278416261917311, -0.7370299412447531, 0.4580826382451188, 0.024909816638153417, -0.2986982689652905], [-6.204456817434451, -7.054321617074455, -3.8731103597961956, -7.0447149929917146, -6.223052160580929, -15.546591666508577]] #weight = [[1.1620356523045294, 1.2293119820243932, -1.0680281171990968, -5.292742962549776, 3.004567388617913, 0.1416865776270463, 3.291787739904783, 3.311779449153159, 0.14350525985680226, 1.864065320111765, 0.41531949262324336, -0.7533626568752921], [2.6058003821118527, 0.9844458916296726, -2.031523030007777, -3.4422006288675315, 4.5638626155289055, -2.7046080365173837, 1.5356155037759958, 2.143460607268979, 3.9199241782825687, 0.12721742246873802, -0.8673469875291382, -1.8507505784965346], [-0.6131784294183935, 0.4639547932071712, -0.2666315961058117, 7.5292821094228755, -1.087211170794136, -0.7293843967199962, 0.4755491742014118, 0.4206888297192853, -0.8152826105125003, 1.988359326013337, -5.637090150274117, 0.5993755933965147], [0.27691971567025647, 1.037850843325554, -0.8250576728298599, -2.000417570912899, -0.006391527390813737, 2.0837950209487466, -8.24238052083867, 2.073287983133908, 3.2529633929820907, 2.1453759622986524, 3.7417070714472893, -2.9435663281508724], [-0.5037569895779601, -0.09031006667126633, -0.5311072081881074, 0.9440264182616986, 0.783774066571815, 6.828375559954358, -2.841644500387658, 0.24901014690965492, -4.849174297326825, -1.5945524577293186, -4.823283932380879, 1.1962232130136108], [1.4042452333993327, -0.09263191061453735, 0.8155734671747938, 5.256825832477101, 3.7371321136701705, 6.574206973322576], [13.323880256265307, -2.429025764741311, -10.985707613602697, 5.331771733353978, -0.12615902379461702, 15.191420141027539]] #take 4 #weight = [[0.1906964794417142, -1.3230251087714693, -1.8568527275491726, -10.570510924730712, 0.3754935945207968, -4.767279359714083, 0.11809759894653031, -6.033443845654109, -4.862563766686397, -1.5992520992754746, 7.726616433374799, -3.552685892017083], [0.3653010148791735, 1.6736547762277736, 0.4531478751025384, -16.54229219042565, -3.440356011229119, 1.0104044032989574, -1.5155008934004035, 0.10642496061430406, -0.31316504641192483, 3.6828030284027515, -0.7489883459127186, -1.5244542545724582], [3.764701498917189, 0.4439295275324288, -2.9864503359860985, -3.9316071635513206, 5.798674529890128, -5.74883908980071, 5.398546661400034, -2.51467872126794, 10.108154232633654, -2.18382803218839, 2.5521301844943816, 3.311614056240679], [3.540372052106104, 4.504838909273797, 0.9723232714577832, -8.437301256316747, 14.998025152577217, -0.31994218366769667, -2.907161494453055, 3.893824258473095, -0.7579119727276817, 5.473585535436292, -3.2397908440984766, 15.192742537984023], [-6.248680428157617, -6.451873887564568, 1.6916836827123973, -4.655942296742202, 16.84212812043791, 5.734711342713387, 0.2955864473988734, 1.791898461633518, -3.4668510416701595, -1.358433980522392, -1.1057313703313203, 0.6888252016526282], [-0.43458701659431115, -0.0012780178353029815, -0.3084730481531892, 0.45069433382083834, 0.11685910089310178, -0.38449878977835567], [3.853866205452628, 12.037185197898191, 1.8699413530857774, 5.001790072421261, 4.513316028443307, 9.851232302101327]] #weight = [[1.2911306905979911, -0.24861004977707912, -0.3569265073483646, 6.428936726785303, -1.3066626434454807, 0.25686627368220305, 0.9109367109212936, 0.16801829318526124, -0.20947845384297986, 1.2064241958740287, 0.036856251428802896, -3.359023278463905], [0.8036278040339718, 0.08012145204557049, 0.6845458738830329, 5.665809973883479, -0.9210048722891027, 1.3932208121673026, 1.046083232807299, 0.7941648248360582, 0.9365855847155237, 1.459603497851585, -0.5332056328831426, -2.534773939928277], [0.13301078275476066, 0.3429847838792201, -1.0338159784473917, 4.850766016537791, 0.7802072613774678, 1.2836937010475253, -0.8584360890917163, 1.7672832265369043, 0.10738236989054603, 3.4517636983002387, 0.22658851691351473, -1.0683529525811006], [1.6450210175622832, -0.28557720210974497, -0.2443112896936013, 6.8747070212198045, -0.8271033896420884, 0.2800592224187591, 0.5652744631888489, 0.08792418368229415, 0.9155105124974535, 0.46138821886651926, -0.3837164120204661, -3.494842813175506], [-0.8165377903719206, 1.958062852731677, 2.000566970645578, 5.919031622286524, 0.5506236423988042, 0.5494849931384184, 1.7160531008225108, 0.5260681781001207, 2.06495028663279, -0.07306752095214097, -1.204154609328308, -4.01239045823013], [-0.6146224030404228, 0.3233086944120275, 5.3979041539672545, -4.401300546048576, -0.42678298976091805, 1.0758830778504247], [-5.977941738072086, 0.019369137899827416, -0.5522710341025945, -7.13480943116727, -4.873784872189164, -16.38430927507949]] #over break training weight = [[ 0.3662869049519842, -0.8570465997089849, -1.0415622777532179, 0.4420706041485171, 0.009019607340448946, 10.71120549250932, -12.382299178044326, 10.244684059761504, -4.7714116184482425, 10.703496354982395, -0.8400740885526794, 2.1209753284753745 ], [ 2.5366260663128686, 1.068830514524183, -2.0352964619508715, -0.4999108962144593, 20.533875500405504, -1.301731900907607, 0.3103574877473953, -0.6500134665269202, 0.5084981306498488, -0.8059254394827501, 1.31308616755389, 15.873718577684429 ], [ 0.08005904547677181, -0.007564753721625019, -0.10037179685269433, -30.286524359136706, 1.0348747725041256, -0.9129196441653706, 0.3754957498625551, -1.305163204786704, -0.30909410903499906, 1.3574890310465415, -0.2886464224612783, -5.911566724871949 ], [ 4.655481170315177, -1.2991521769114085, -4.454652256174474, 4.274677448402512, 16.502421922725226, 12.710289689086315, -9.738471684679293, 9.865851212762863, -8.873570414630043, -0.1285739247431209, -14.804016099227272, 10.638993200840254 ], [ -13.975667825847953, 13.618115550695093, 27.871087273931305, 1.7052627216183622, -16.717674225226972, 0.8131962686148689, 0.6430161349620291, -0.6832651795038519, 1.6123037795473343, 3.7701435389411695, -2.729257195826183, -2.0449519807080896 ], [ 0.6784559764050078, -0.30818410563793897, -0.12048266318505906, 0.7386778766766025, 0.18813592750492103, 0.9656707078851317 ], [ 7.248480099597683, 9.862850677133501, 18.95475459828898, 1.981941403265762, 7.509742979506548, 19.364672423856124 ]] sendData = getSendData() output = getOutput(sendData, 11, 5, 2, weight) turn, thrust = "N", "N" if output[0] >= .55: ai.turnRight(1) turn = "R" elif output[0] < .45: ai.turnLeft(1) turn = "L" ai.setTurnSpeed(abs(output[0] - .5) * 100) if output[1] > random(): ai.thrust(1) thrust = "Y" if ai.selfAlive(): print(turn + " " + str(round(output[0], 3)) + " | " + thrust + " " + str(round(output[1], 3)))
def tick(): #NO EXCEPTION HANDLING try: #GLOBAL VARIABLES global tickCount global mode global item global itemId global lastItemCount global latestTask global mapWidth global mapHeight global maplist global finalPath global pathThread # Does not need to be global at the moment global searchForPath, searchQueue global selfVelX, selfVelY global selfSpeed global selfTracking global finalPosition #RESET IF DEAD if not ai.selfAlive(): tickCount = 0 #Create a clear function targetPos = [] finalPath = [] mode = "idle" return tickCount += 1 #SENSORS READINGS selfX = ai.selfX() selfY = (mapHeight * ai.blockSize()) - ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() selfTracking = ai.selfTrackingRad() selfHeading = ai.selfHeadingRad() mass = ai.selfMass() friction = ai.getOption("friction") thrustPower = ai.getPower() mapWidth = ai.getOption("mapwidth") mapHeight = ai.getOption("mapheight") print ("tick count:", tickCount, "mode", mode) #IN THIS MODE WE ARE WAITING FOR THE PLAYER TO GIVE THE BOT INSTRUCTIONS if mode == "idle": mode, value = getMessage() if mode == "move": finalPosition = value elif mode == "collect": item = value #IN THIS MODE WE ARE CALUCLATING PATH USING ASTAR elif mode == "move": #GET PATH searchForPath = True searchQueue.put(searchForPath) try: finalPath = pathQueue.get(timeout=1) except queue.Empty: pass #if not finalPath: #print("CALCULATING PATH") #finalPath = getPath(pixelsToBlockSize(mapWidth, mapHeight), tuple(finalPosition), mapWidth, mapHeight) # else: #SEARCH print("final path", finalPath) if finalPath: print("I HAVE A FINAL PATH!") print("FINAL PATH: ", finalPath) searchForPath = False # We have now found a path searchQueue.put(searchForPath) print("Final Path:", finalPath) print("Player Pos:","(",selfY // ai.blockSize(), selfX // ai.blockSize(),")") targetPosition = finalPath[0] if finalPath[0][1] == selfX // ai.blockSize() and finalPath[0][0] == selfY // ai.blockSize(): if len(finalPath) > 1: finalPath = finalPath[1:] else: print("REACHED TARGETPOS") sendMessage("teacherbot") finalPosition = [] finalPath = [] mode = "idle" #MOVES if finalPath and finalPosition: print("I HAVE A FINAL POSITION!") stoppingDist = stopping_distance(mass, friction, thrustPower, selfSpeed) moveToPos(selfX, selfY, [targetPosition[1]*ai.blockSize(), targetPosition[0]*ai.blockSize()], stoppingDist) else: print("NO FINAL POSITION") #TODO: Search and destroy elif mode == "destroy": pass #TODO: Astar safe path elif mode == "refuel": fuelIndex = random.randint(0, ai.fuelstationCount()) refueling = False #GET FEULSTATION X AND Y POS finalxPosition = ai.fuelstationBlockX(fuelIndex) finalyPosition = mapHeight - ai.fuelstationBlockY(fuelIndex) finalxAndyPosition = [finalyPosition - 1, finalxPosition] targetPos = finalxAndyPosition mode = "move" #TODO: USE WITH ASTAR if refueling: '''Amount of fuel in station''' if ai.fuelstationFuel(fuelIndex) > 0: '''Keep calling to refuel''' ai.refuel() else: mode = "idle" '''Number of fueltanks on server''' #ai.tankCountServer() '''Number of fuelstations on server''' #ai.fuelstationCount() #IN THIS MODE WE ARE COLLECTING ITEMS elif mode == "collect": if ai.itemCountScreen() > 0: itemOnScreen = False for i in range(ai.itemCountScreen()): if ai.itemType(i) == item: itemId = i itemOnScreen = True break if not itemOnScreen: print("No item of type " + str(item) + " on screen") mode = "idle" itemX = ai.itemX(itemId) itemY = ai.itemY(itemId) itemVelX = ai.itemVelX(itemId) itemVelY = ai.itemVelY(itemId) deltaPosX = itemX - selfX deltaPosY = itemY - ai.selfY() deltaVelX = itemVelX - selfVelX deltaVelY = itemVelY - selfVelY time = time_of_impact(deltaPosX, deltaPosY, itemVelX, itemVelY, 10) targetPosition = vector_sum((deltaPosX, deltaPosY), scalar_product((deltaVelX, deltaVelY), time)) ai.turnToRad(math.atan2(targetPosition[1], targetPosition[0])) if selfSpeed < 10: thrust(10) else: brake(2) except: print(traceback.print_exc())
def tick(): # # The API won't print out exceptions, so we have to catch and print them ourselves. # try: # # Declare global variables so we're allowed to use them in the function # global tickCount global mode global targetId # # Reset the state machine if we die. # if not ai.selfAlive(): tickCount = 0 mode = "aim" return tickCount += 1 # # Read some "sensors" into local variables to avoid excessive calls to the API # and improve readability. # selfX = ai.selfX() selfY = ai.selfY() selfHeading = ai.selfHeadingRad() # 0-2pi, 0 in x direction, positive toward y targetCount = ai.targetCountServer() targetCountAlive = 0 for i in range(targetCount): if ai.targetAlive(i): targetCountAlive += 1 # Use print statements for debugging, either here or further down in the code. # Useful functions: round(), math.degrees(), math.radians(), etc. # os.system('clear') clears the terminal screen, which can be useful. print("tick count:", tickCount, "mode:", mode, "heading:", round(ai.radToDeg(selfHeading)), "targets alive:", targetCountAlive) if mode == "wait": if targetCountAlive > 0: mode = "aim" elif mode == "aim": if targetCountAlive == 0: mode = "wait" return # Loop through the indexes of targets and find one that is alive, # save that index in targetId. # useful variables: targetCount, targetId # useful functions: ai.targetAlive """your code here""" # Calculate what direction the target is in, save in # the variable targetDirection # useful variables: selfX, selfY # useful functions: math.atan2, ai.targetX, ai.targetY """your code here""" # Turn to the direction of the target # useful variables: targetDirection # useful functions: turnRad, turnToRad """your code here""" # If the ship keeps oscillating between a few angles # it may be due to latency. Only turning every second # or third tick is a simple solution (use tickCount and %) # Check if you are aiming in the direction of the target, # if so, change mode to shoot. # Note that, due to how the game handles angles, the difference # cannot be 0 for many angles. # useful variables: selfHeading, targetDirection, mode # useful functions: ai.angleDiffRad, ai.radToDeg """your code here""" elif mode == "shoot": # Shoot the target # useful functions: ai.fireShot """your code here""" # if the target is destroyed, change state to aim # useful variables: targetId, mode # useful functions: ai.targetAlive """your code here""" except: # # If tick crashes, print debugging information # print(traceback.print_exc())
def tick(): # # The API won't print out exceptions, so we have to catch and print them ourselves. # try: # # Declare global variables so we have access to them in the function # global tickCount global mode global targetId global lis # # Reset the state machine if we die. # if not ai.selfAlive(): tickCount = 0 mode = "ready" return tickCount += 1 # # Read some "sensors" into local variables, to avoid excessive calls to the API # and improve readability. # selfX = ai.selfX() selfY = ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() selfHeading = ai.selfHeadingRad() selfTracking = ai.selfTrackingRad() # 0-2pi, 0 in x direction, positive toward y # Add more sensors readings here print("tick count:", tickCount, "mode", mode) if mode == "ready": for i in range(4): if ai.targetAlive(i): targetId = i break xDiff = ai.targetX(targetId) - ai.selfX() yDiff = ai.targetY(targetId) - ai.selfY() targetDirection = math.atan2(yDiff, xDiff) ai.turnToRad(targetDirection) ai.setPower(20) if selfSpeed < 20: ai.thrust() if xDiff < 400 and yDiff < 400: mode = "brake" if abs(selfHeading - selfTracking) > 0.1 and selfSpeed > 20: mode = "stab" elif mode == "stab": if selfSpeed < 2: mode = "ready" else: ai.setPower(50) ai.turnToRad(math.pi + ai.selfTrackingRad()) ai.thrust() elif mode == "brake": if selfSpeed < 2: mode = "aim" else: ai.setPower(50) ai.turnToRad(math.pi + ai.selfTrackingRad()) ai.thrust() elif mode == "aim": xDiff = ai.targetX(targetId) - ai.selfX() yDiff = ai.targetY(targetId) - ai.selfY() targetDirection = math.atan2(yDiff, xDiff) ai.turnToRad(targetDirection) angleDiff = abs(targetDirection - selfHeading) if angleDiff < 0.25 or angleDiff > 2 * math.pi - 0.25: mode = "shoot" elif mode == "shoot": ai.fireShot() xDiff = ai.targetX(targetId) - ai.selfX() yDiff = ai.targetY(targetId) - ai.selfY() targetDirection = math.atan2(yDiff, xDiff) ai.turnToRad(targetDirection) if not ai.targetAlive(targetId): mode = "ready" except: print(traceback.print_exc())
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 tick(): try: global tickCount global mode if not ai.selfAlive(): tickCount = 0 mode = "ready" return tickCount += 1 selfX = ai.selfX() selfY = ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() tracking = ai.selfTrackingRad() selfHeading = ai.selfHeadingRad() message = ai.scanTalkMsg(0) mass = ai.selfMass() friction = ai.getOption("friction") thrustPower = ai.getPower() def scalar_product(lis, n): return [x * n for x in lis] def vector_sum(list1, list2): return [sum(x) for x in zip(list1, list2)] def time_of_impact(px, py, vx, vy, s): a = s * s - (vx * vx + vy * vy) b = px * vx + py * vy c = px * px + py * py d = b * b + a * c t = 0 # Time if d >= 0: t = (b + math.sqrt(d)) / a if (t < 0): t = 0 return t def stopping_distance(mass, friction, thrustPower, selfSpeed): fForce = friction * mass tForce = thrustPower accTot = ((fForce / mass) + (tForce / (mass + 5))) return ((selfSpeed * selfSpeed) / (2 * accTot)) stopping_distance = stopping_distance(mass, friction, thrustPower, selfSpeed) print("tick count:", tickCount, "mode", mode) if mode == "ready": print(friction, mass, selfSpeed, thrustPower) print(selfX, selfY) if "move-to" in message: splitmessage = message.split() action = splitmessage[0] if "move-to-stop" in action: mode = "move-to-stop" if "move-to-pass" in action: mode = "move-to-pass" if mode == "move-to-pass": splitmessage = message.split() coordX = float(splitmessage[1]) coordY = float(splitmessage[2]) print(coordX, coordY) distance = math.sqrt( abs(coordX - selfX)**2 + abs(coordY - selfY)**2) time = time_of_impact((coordX - selfX), (coordY - selfY), 0, 0, 10) targetDirection = (math.atan2(coordY - selfY, coordX - selfX)) print(targetDirection) if tracking == targetDirection: ai.thrust() else: ai.turnToRad(targetDirection) ai.thrust() if distance < 10: mode == "klar" if mode == "move-to-stop": splitmessage = message.split() coordX = int(splitmessage[1]) coordY = int(splitmessage[2]) print(coordX, coordY) distance = math.sqrt( abs(coordX - selfX)**2 + abs(coordY - selfY)**2) time = time_of_impact((coordX - selfX), (coordY - selfY), 0, 0, selfSpeed + 0.000001) target_position = vector_sum( (coordX - selfX, coordY - selfY), scalar_product((0 - selfVelX, 0 - selfVelY), time)) targetDirection = (math.atan2(target_position[1], target_position[0])) print(target_position) print(targetDirection) if tickCount % 2 == 0: if abs(tracking - targetDirection) > 0.01: ai.turnToRad(targetDirection) print("vinkel", (tracking - targetDirection), "tid", time) #if abs(targetDirection-tracking) > 0.03: # ai.thrust() #ai.thrust() # if tickCount % 2 == 0: #if selfSpeed < 30: ai.thrust() #if targetDirection-tracking < -0.1: # ai.turnRad(-(tracking-targetDirection)) # ai.thrust() #if targetDirection-tracking < 0.1: # ai.turnRad(-(tracking-targetDirection)) # ai.thrust() #if not tracking == targetDirection: # ai.turnToRad(targetDirection) # ai.thrust() # if distance < 10: # mode == "klar" # print("V", selfSpeed, "tP", thrustPower, "fr", friction, "M", mass) print(stopping_distance, distance) if stopping_distance > distance: mode = "brake" if mode == "brake": ai.turnToRad(tracking + math.pi) ai.thrust() print(selfX, selfY) splitmessage = message.split() coordX = int(splitmessage[1]) coordY = int(splitmessage[2]) distance = math.sqrt( abs(coordX - selfX)**2 + abs(coordY - selfY)**2) print(distance) if selfSpeed < 2: mode = "xD" if mode == "xD": print(selfX, selfY) splitmessage = message.split() coordX = int(splitmessage[1]) coordY = int(splitmessage[2]) distance = math.sqrt( abs(coordX - selfX)**2 + abs(coordY - selfY)**2) print(distance) except: print(traceback.print_exc())
def AI_loop(): #Inserted Code lastLoop = 0 if ai.selfAlive(): lastLoop = 1 DataMinerBD.updateInputs() DataMinerBD.updateOutputs() DataMinerBD.savePair() if DataMinerBD.length() % 100 == 0: print(DataMinerBD.length()) if DataMinerBD.length() > 1000: DataMinerBD.writeData() print("Finished") ai.quitAI() else: if lastLoop == 1: DataMinerBD.writeDeath() global maxSpeed, shotAngle, wallClose, dead, previousScore global turnedLeft, turnedRight, thrusted, shot #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) 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.tturnRight( 1) #If the target is to our right- turn right else: DataMinerBD.tturnLeft( 1) #If the target is to our left - turn left else: if diff > -180: DataMinerBD.tturnRight( 1) #If the target is to our right - turn right else: DataMinerBD.tturnLeft( 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.tturnLeft(1) elif wallNum == 2: # Left Wall is Closest (Turn Away From It) DataMinerBD.tturnRight(1) elif wallNum == 3: #Right Wall is Closest (Turn Away From It) DataMinerBD.tturnLeft(1) else: #Back Wall is closest- turn so that we are facing directly away from it if backLeftWall < backRightWall: DataMinerBD.tturnRight( 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.tturnLeft(1) #Rules for thrusting if speed < maxSpeed and frontWall > 100: #If we are moving slowly and we won't ram into anything, accelerate DataMinerBD.tthrust(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.tthrust(1) elif backWall < 20: #If there is a wall very close behind us, get away from it DataMinerBD.tthrust(1) if abs( calcDir - heading ) < shotAngle and calcDir != -1: #If we are close to the current proper trajectory for a shot then fire DataMinerBD.tshoot() previousScore = ai.selfScore()
def tick(): # # The API won't print out exceptions, so we have to catch and print them ourselves. # try: # # Declare global variables so we have access to them in the function # global tickCount global mode # # Reset the state machine if we die. # if not ai.selfAlive(): tickCount = 0 mode = "ready" return tickCount += 1 # # Read some "sensors" into local variables, to avoid excessive calls to the API # and improve readability. # selfX = ai.selfX() selfY = ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() shotSpeed = ai.getOption("shotSpeed") selfHeading = ai.selfHeadingRad() # 0-2pi, 0 in x direction, positive toward y # Add more sensors readings here print ("tick count:", tickCount, "mode", mode) def scalar_product(lis, n): return [x * n for x in lis] def vector_sum(list1, list2): return [sum(x) for x in zip(list1, list2)] # [a, b, c] [d, e, f] # [a,d] [b, e] [c, f] def time_of_impact(px, py, vx, vy, s): a = s * s - (vx * vx + vy * vy) b = px * vx + py * vy c = px * px + py * py d = b*b + a*c t = 0 # Time if d >= 0: t = (b + math.sqrt(d)) / a if (t < 0): t = 0 return t closest_asteroid_id = 0 if mode == "ready": #print("self vel Y: ", selfVelY) if ai.selfSpeed() > 7: # We're going too fast!!! mode = "brake" # Find closest asteroid if tickCount % 1 == 0: for i in range(ai.asteroidCountScreen()): #if not 130 <= ai.radarType(i) <= 133: # We're only looking for asteroids. # continue radar_dist = ai.asteroidDist(i) if radar_dist < ai.asteroidDist(closest_asteroid_id): closest_asteroid_id = i if ai.asteroidCountScreen() > 0: mode = "aim" if mode == "aim": asteroidX = ai.asteroidX(closest_asteroid_id) asteroidY = ai.asteroidY(closest_asteroid_id) asteroidVelX = ai.asteroidVelX(closest_asteroid_id) asteroidVelY = ai.asteroidVelY(closest_asteroid_id) if asteroidX - selfX > ai.mapWidthPixels()/1.2: print("Target is to the right. Seen to the left") dx = ai.mapWidthPixels() - asteroidX asteroidX = -dx #targetPosition[0] -= ai.mapWidthPixels() if selfX - asteroidX > ai.mapWidthPixels()/1.2: print("Target is to the left. Seen to the right") dx = asteroidX asteroidX = ai.mapWidthPixels() + dx #targetPosition[0] += ai.mapWidthPixels() if asteroidY - selfY > ai.mapHeightPixels()/1.2: print("Target is above. Seen below") dx = ai.mapHeightPixels() - asteroidY asteroidY = -dx #targetPosition[1] -= ai.mapHeightPixels() if selfY - asteroidY > ai.mapHeightPixels()/1.2: print("Target is below. Seen above.") dx = asteroidY asteroidY = ai.mapHeightPixels() + dy #targetPosition[1] += ai.mapHeightPixels() time = time_of_impact(asteroidX - selfX, asteroidY - selfY, asteroidVelX, asteroidVelY, shotSpeed) targetPosition = vector_sum((asteroidX - selfX, asteroidY - selfY), scalar_product((asteroidVelX, asteroidVelY), time*1.1)) print("Map size x: ", ai.mapWidthPixels()) targetAngle = math.atan2(targetPosition[1], targetPosition[0]) ai.turnToRad(targetAngle) if abs(selfHeading - targetAngle) % 2*math.pi < 0.8: print("Firing at", targetPosition[0], ",", targetPosition[1]) ai.fireShot() mode = "ready" if mode == "brake": velocityVector = (selfVelX, selfVelY) targetAngle = math.pi + (math.atan2(velocityVector[1], velocityVector[0])) # Negative velocity vector ai.turnToRad(targetAngle) ai.thrust() selfVel = velocityVector[0] * velocityVector[0] + velocityVector[1] * velocityVector[1] if selfVel < 3: # The bot has come to a stop. mode = "ready" except: print(traceback.print_exc())
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 tick(): #NO EXCEPTION HANDLING try: # #GLOBAL VARIABLES # #XPILOT-SPEC global tickCount global mode global selfVelX, selfVelY global selfX, selfY global selfSpeed global selfTracking #ITEMS global item global itemId global lastItemCount #COMMUNICATION global latestTask #A* global mapWidth global mapHeight global maplist global finalPath global finalPosition #REFUELING global fuelIndex global stationId #MULTITHREADING global maplistQueue global searchForPath global searchQueue global pathQueue #RESET IF DEAD if not ai.selfAlive(): tickCount = 0 #CLEAR A* finalPosition = [] finalPath = [] mode = "idle" return tickCount += 1 # #SENSORS READINGS # #XPILOT-SPEC selfX = ai.selfX() selfY = (mapHeight * ai.blockSize()) - ai.selfY() selfVelX = ai.selfVelX() selfVelY = ai.selfVelY() selfSpeed = ai.selfSpeed() selfTracking = ai.selfTrackingRad() selfHeading = ai.selfHeadingRad() #DOES NOT EXIST FIRST TICKS if tickCount > 6: mass = ai.selfMass() thrustPower = ai.getPower() friction = ai.getOption("friction") mapWidth = ai.getOption("mapwidth") mapHeight = ai.getOption("mapheight") print ("tick count:", tickCount, "mode", mode) #IN THIS MODE WE ARE WAITING FOR THE PLAYER TO GIVE THE BOT INSTRUCTIONS if mode == "idle": mode, value, latestTask = getMessage() if mode == "move": finalPosition = value elif mode == "collect": item = value elif mode == "refuel": fuelIndex = value #IN THIS MODE WE ARE CALUCLATING PATH USING ASTAR elif mode == "move": #MULTITHREADING searchForPath = True searchQueue.put(searchForPath) try: finalPath = pathQueue.get(timeout=1) maplist = maplistQueue.get(timeout=1) except queue.Empty: pass #SEARCH-PATH-PART if not finalPath: print("CALCULATING PATH") maplist, finalPath = getPath(pixelsToBlockSize(mapWidth, mapHeight), tuple(finalPosition), mapWidth, mapHeight) print("CALCULATED MAPLIST LENGTH:", len(maplist)) print("CALCULATED FINAL PATH:", len(finalPath)) else: if maplist: printMap(finalPath, True) #MULTITHREADING searchForPath = False searchQueue.put(searchForPath) print("Final Path:", finalPath) print("Player Pos:","(",selfY // ai.blockSize(), selfX // ai.blockSize(),")") targetPosition = finalPath[0] if finalPath[0][1] == selfX // ai.blockSize() and finalPath[0][0] == selfY // ai.blockSize(): if len(finalPath) > 1: finalPath = finalPath[1:] else: print("REACHED TARGETPOS") sendMessage("teacherbot") finalX = finalPosition[1] finalY = finalPosition[0] finalPosition = [] finalPath = [] print(latestTask) if "refuel" in latestTask: mode = "refueling" elif latestTask == "use-item mine": mode = useMine(finalX, finalY) elif latestTask == "use-item missile": mode = useMissile(finalX, finalY) elif latestTask == "use-item laser": mode = useLaser(finalX, finalY) else: mode = "idle" #MOVE-PART if finalPosition: stoppingDist = stopping_distance(mass, friction, thrustPower, selfSpeed) moveToPos(selfX, selfY, [targetPosition[1]*ai.blockSize(), targetPosition[0]*ai.blockSize()], stoppingDist) #IF OTHER PLAYER IS SHOOTING TOWARDS YOU FLEE elif mode == "flee": if ai.selfItem(18): usePhasing(0, 0) elif ai.selfItem(17): useHyperJump(0, 0) elif ai.selfItem(10): useEcm(0,0) elif ai.selfItem(15): useEmergencyShield(0, 0) else: ai.shield() #IN THIS MODE WE ARE REFUELING elif mode == "refuel": mode, finalPath, finalPosition = moveToFuelStation() elif mode == "refueling": '''Amount of fuel in station''' if ai.fuelstationFuel(fuelIndex) > 0: '''Keep calling to refuel''' ai.refuel() else: mode = "idle" #IN THIS MODE WE ARE COLLECTING ITEMS elif mode == "collect": if ai.itemCountScreen() > 0: itemOnScreen = False for i in range(ai.itemCountScreen()): if ai.itemType(i) == item: itemId = i itemOnScreen = True break if not itemOnScreen: print("No item of type " + str(item) + " on screen") mode = "idle" collectAim(itemId) if selfSpeed < 10: thrust(10) else: brake(2) except: print(traceback.print_exc())
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(): 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(self): # print("AI_LOOP") if ai.selfAlive() == 0: outputFile = open("fitness.txt", "a") # outputFile.write(str((self.totalDists/self.counter))+"\t") outputFile.write(str(int((self.fitness**1.2))) + "\t") [ print(str("%.5f" % g) + "\t", end="", file=outputFile) for g in self.chromosome ] print("\n", end="", file=outputFile) outputFile.close() # Release keys ai.thrust(0) ai.turnLeft(0) ai.turnRight(0) ai.setTurnSpeed(55) # Heuristics frontFeelerOffset = 45 perpFeelerOffset = 90 rearFeelerOffset = 135 # turnSpeedMin = 15 # learn range: 4 - 24 turnSpeedMax = 55 speedLimit = 5 # learn range: 2-6 lowSpeedLimit = 2 targetingAccuracy = 4 # 1/2 tolerance in deg for aiming accuracy shotIsDangerous = 130 # Acquire information heading = int(ai.selfHeadingDeg()) tracking = int(ai.selfTrackingDeg()) ###=== ENEMY FEELERS ===### # gets angle to enemy enemyDeg = self.angleToPointDeg( (ai.selfX(), ai.selfY()), (ai.screenEnemyX(0), ai.screenEnemyY(0))) enemyWallDistances = [] # maxAngleOffset = 90 # learn range: 30 - 120 # resolution = 5 # learn range: 2 - 10 distAngleTuples = [] # creates tuples of degrees and wallFeelers for m in (0, self.maxAngleOffset, self.resolution): distAngleTuples.append( (enemyDeg - m, ai.wallFeeler(500, int(enemyDeg - m)))) distAngleTuples.append( (enemyDeg + m, ai.wallFeeler(500, int(enemyDeg + m)))) # gets furthest feeler maxFeelerAngle = max(distAngleTuples, key=self.returnSecond) angleToOpenSpace = self.headingDiff(ai.selfHeadingDeg(), maxFeelerAngle[0]) ###=== WALL FEELERS ===### frontWall = ai.wallFeeler( self.genericFeelerDist, heading) # wall feeler for wall directly ahead leftFrontWall = ai.wallFeeler( self.genericFeelerDist, heading + frontFeelerOffset) # wall feeler for wall 45 degrees to the left rightFrontWall = ai.wallFeeler( self.genericFeelerDist, heading - frontFeelerOffset) # wall feeler for wall 45 degrees to the right leftWall = ai.wallFeeler( self.genericFeelerDist, heading + perpFeelerOffset) # wall feeler for wall 90 degrees to the left rightWall = ai.wallFeeler( self.genericFeelerDist, heading - perpFeelerOffset) # wall feeler for wall 90 degrees to the right backWall = ai.wallFeeler(self.genericFeelerDist, heading - 180) # wall feeler for wall straight back leftBackWall = ai.wallFeeler( self.genericFeelerDist, heading + rearFeelerOffset) # wall feeler for wall 135 degrees to the left rightBackWall = ai.wallFeeler( self.genericFeelerDist, heading - rearFeelerOffset) # wall feeler for wall 135 degrees to the right trackWall = ai.wallFeeler( self.genericFeelerDist, tracking) # wall in front of where ship is moving # Keep track of all the feeler distances feelers = [ frontWall, leftFrontWall, rightFrontWall, leftWall, rightWall, backWall, leftBackWall, rightBackWall, trackWall ] # Aim assist leftDir = (heading + 90) % 360 # angle 90 degrees to the left of current heading rightDir = (heading - 90 ) % 360 # angle 90 degrees to the right of current heading aimer = ai.aimdir( 0 ) # direction that the ship needs to turn to in order to face the enemy in degrees shot = ai.shotAlert( 0 ) # returns a danger rating of a shot, the smaller the number the more likely the shot is to hit the ship enemyX = ai.screenEnemyX(0) # returns the closest enemy's x-coord enemyY = ai.screenEnemyY(0) # returns the closest enemy's y-coord selfX = ai.selfX() # returns the ship's x-coord selfY = ai.selfY() # returns the ship's x-coord # Fuzzy variable declaration trackRisk = riskEval(trackWall, ai.selfSpeed()) #risk of running into trackWall frontRisk = riskEval(frontWall, ai.selfSpeed()) #risk of running into frontWall leftRisk = riskEval(leftWall, ai.selfSpeed()) #risk of running into leftWall rightRisk = riskEval(rightWall, ai.selfSpeed()) #risk of running into rightWall LFRisk = riskEval(leftFrontWall, ai.selfSpeed()) #risk of running into leftFrontWall RFRisk = riskEval(rightFrontWall, ai.selfSpeed()) #risk of running into rightFrontWall LBRisk = riskEval(leftBackWall, ai.selfSpeed()) #risk of running into leftBackWall RBRisk = riskEval(rightBackWall, ai.selfSpeed()) #risk of running into rightBackWall backRisk = riskEval(backWall, ai.selfSpeed()) #risk of running into backWall # Compress some wall feelers sTrack = self.squisher(trackWall) sLeft = self.squisher(leftFrontWall) sRight = self.squisher(rightFrontWall) sLeftStraight = self.squisher(leftWall) sRightStraight = self.squisher(rightWall) # output from neural network that tells how much to turn and which direction turn = self.trainedNeuralNetwork(sTrack, sLeft, sRight, sLeftStraight, sRightStraight) ###=== THRUST POWER ADJUSTMENT ===# # Power levels mfS = self.mfSpeed(ai.selfSpeed()) mfD = self.mfDanger(ai.shotAlert(0)) # 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 = [55, 45, 55, 36, 36, 28, 24, 30] memberships = [p1, p2, p3, p4, p5, p6, p7, p8] ai.setPower(self.crispify(memberships, consequents)) if ai.enemyDistance(0) > self.lastDist and ai.enemyDistance( 0) < self.enemyClose: ai.thrust(1) elif ai.selfSpeed( ) <= 3 and frontWall >= 200: # if speed is slow and front wall is far away, thrust ai.thrust(1) elif trackWall < 60 and frontWall >= 200: # if the track wall is close, thrust ai.thrust(1) elif backWall < 20: # if the back wall is close, thrust ai.thrust(1) ###=== TURNING RULES ===### # Escape shots if shot > 0 and shot < 70: # if a shot is closeby, turn and thrust to avoid if self.angleDif(rightDir, ai.shotX(0)) < self.angleDif( leftDir, ai.shotX(0) ) or self.angleDif(rightDir, ai.shotY(0)) < self.angleDif( leftDir, ai.shotY(0) ): # if shot is coming from the right, turn away and thrust # print("Turning: avoiding shot")#debug ai.turnLeft(1) ai.thrust(1) elif self.angleDif(leftDir, ai.shotX(0)) < self.angleDif( rightDir, ai.shotX(0) ) or self.angleDif(leftDir, ai.shotY(0)) < self.angleDif( rightDir, ai.shotY(0) ): # if shot is coming from the left, turn away and shoot ------> change this shot is just a number # print("Turning: avoiding shot")#debug ai.turnRight(1) ai.thrust(1) # Turn towards unoccluded enemy elif aimer >= 0 and self.angleDif(rightDir, aimer) < self.angleDif( leftDir, aimer) and not self.enemyBehindWall( 0): # if an enemy to the right, turn and shoot it 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, self.turnSpeedMin, turnSpeedMax)) else: enemyDeg = self.angleToPointDeg( (ai.selfRadarX(), ai.selfRadarY()), (ai.closestRadarX(), ai.closestRadarY())) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, self.turnSpeedMin, turnSpeedMax)) # print("Turning: aiming right")#debug ai.turnRight(1) elif aimer >= 0 and self.angleDif(leftDir, aimer) < self.angleDif( rightDir, aimer) and not self.enemyBehindWall( 0): # if an enemy to the left, turn and shoot it 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, self.turnSpeedMin, turnSpeedMax)) else: enemyDeg = self.angleToPointDeg( (ai.selfRadarX(), ai.selfRadarY()), (ai.closestRadarX(), ai.closestRadarY())) ai.setTurnSpeed( self.rangeMap(abs(enemyDeg), 0, 180, self.turnSpeedMin, turnSpeedMax)) # print("Turning: aiming left")#debug ai.turnLeft(1) #fuzzy avoid walls ahead elif leftRisk > rightRisk and trackRisk > 0.5: # and min(feelers) < self.nearLimit: #if the left wall and track walls are close, turn right #if enemyX >=0 and enemyY >= 0 and ai.wallBetween(selfX, selfY, enemyX, enemyY) == -1: ai.turnRight(1) # print("Turning: fuzzy right")#debug elif rightRisk > leftRisk and trackRisk > 0.5: # and min(feelers) < self.nearLimit: #if the right wall and track walls are close, turn left # if enemyX >=0 and enemyY >= 0 and ai.wallBetween(selfX, selfY, enemyX, enemyY) == -1: ai.turnLeft(1) # print("Turning: fuzzy left")#debug # Turn to open space nearest the angle to the enemy elif self.enemyBehindWall(0) and min(feelers) > self.nearLimit: if angleToOpenSpace < 0: # print("Turning: open space left")#debug ai.turnLeft(1) elif angleToOpenSpace > 0: # print("Turning: open space right")#debug ai.turnRight(1) # if neural net value is not between 0.48 and 0.52 then we have to turn right or left elif not (turn >= 0.43 and turn <= 0.57): if turn < 0.43: # turn right if value is below 0.43 # print("Turning: neural net right")#debug ai.turnRight(1) elif turn > 0.57: # turn left if value is below 0.57 # print("Turning: neural net left")#debug ai.turnLeft(1) ###=== FIRING RULES ===### # Restrict firing to reasonably accurate attempts: # accurate range, enemy not behind wall and enemy close enough if self.headingDiff( heading, ai.aimdir(0)) < targetingAccuracy and not self.enemyBehindWall( 0) and ai.enemyDistance(0) < self.enemyFireDist: ai.fireShot() # print("Shot Fired")#debug # print("Firing Dist: ", self.enemyFireDist)#debug self.counter += 1 ###=== How did we die? and other Fitness Calculations ===### # Fitness function information self.totalDists += ai.enemyDistance(0) if ai.enemyDistance(0) > 0: self.currentDist = ai.enemyDistance(0) if self.currentDist < self.lastDist: self.fitness += 1 self.lastDist = self.currentDist self.fitness += 1 alive = ai.selfAlive() message = ai.scanGameMsg(1) # print(message)#debug if alive == 0: self.framesDead += 1 # print(self.framesDead, message)#debug if self.framesDead == 2: # print("dead now")#debug # Ran into wall if message.find("Beal-Morneault") != -1 and message.find( "wall") != -1: print("End of match: wall collision.") #debug self.fitness -= self.wallPenalty # Crashed into player elif message.find("crashed.") != -1: print("End of match: player collision.") #debug self.fitness -= self.crashPenalty # Killed by bullet elif message.find("Beal-Morneault was") != -1: print("End of match: killed by opponent.") #debug self.fitness -= self.killedPenalty # Killed the opponent elif message.find("by a shot from Beal-Morneault") != -1: print("End of match: killed the opponent!") #debug self.fitness += self.killerBonus else: print("End of match: enemy died.") self.fitness += (ai.selfScore() - ai.enemyScoreId(0) ) * self.scoreDiffBonusFactor ai.quitAI() else: self.framesDead = 0