def defend_weakest_ally(state): success = False my_planets_under_attack = [planet for planet in state.my_planets() if surplus(state, planet) < 0] for planet_under_attack in my_planets_under_attack: enemy_fleets = sorted([fleet for fleet in state.enemy_fleets() if fleet.destination_planet == planet_under_attack.ID], key=lambda f:f.turns_remaining) turns_capped, my_ships, last_arrival = inf, planet_under_attack.num_ships, 0 for fleet in enemy_fleets: my_ships -= (fleet.num_ships - (planet_under_attack.growth_rate * (fleet.turns_remaining - last_arrival))) last_arrival = fleet.turns_remaining if my_ships < 0 and turns_capped == inf: turns_capped = fleet.turns_remaining #check if I have another planet close enough to assist my_other_planets = [planet for planet in state.my_planets() if planet not in my_planets_under_attack] for other_planet in my_other_planets: if state.distance(other_planet.ID, planet_under_attack.ID) < turns_capped and surplus(state, other_planet) > fabs(my_ships): issue_order(state, other_planet.ID, planet_under_attack.ID, fabs(my_ships) + 1) success = True my_planets_under_attack.remove(planet_under_attack) break return success
def production(state): my_planets = iter( sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) target_planets = [ planet for planet in state.not_my_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] target_planets = iter( sorted(target_planets, key=lambda p: p.num_ships, reverse=True)) success = False try: my_planet = next(my_planets) target_planet = next(target_planets) while True: if target_planet.owner == 0: required_ships = target_planet.num_ships + 1 else: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) success = True my_planet = next(my_planets) target_planet = next(target_planets) else: target_planet = next(target_planets) except StopIteration: return success
def do_turn(universe): # (1) If we currently have a fleet in flight, just do nothing. if len(universe.my_fleets()) >= 1: return # (2) Find my strongest planet. source = -1 source_score = -999999.0 source_num_ships = 0 for p in universe.my_planets(): score = float(p.num_ships) if score > source_score: source_score = score source = p._id source_num_ships = p.num_ships # (3) Find the weakest enemy or neutral planet. dest = -1 dest_score = -999999.0 for p in universe.other_planets(): score = 1.0 / (1 + p.num_ships) if score > dest_score: dest_score = score dest = p._id # (4) Send half the ships from my strongest planet to the weakest # planet that I do not own. if source >= 0 and dest >= 0: num_ships = source_num_ships / 2 issue_order(source, dest, num_ships)
def spread_to_weakest_neutral_planet(state): # (1) If we currently have a fleet in flight, just do nothing. # (2) Find my strongest planet. strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) # (3) Find the weakest neutral planet. weakest_planet = min(state.neutral_planets(), key=lambda p: p.num_ships, default=None) dist_check = 9999 dist = 0 # first_planet = state.my_planets()[0] # for planets in state.neutral_planets(): # dist = state.distance(planets.ID, first_planet.ID) # if dist < dist_check: # dist_check = dist # weakest_planet = planets if not strongest_planet or not weakest_planet: # No legal source or destination return False else: # (4) Send half the ships from my strongest planet to the weakest enemy planet. if strongest_planet.num_ships>weakest_planet.num_ships: issue_order(state, strongest_planet.ID, weakest_planet.ID,weakest_planet.num_ships) else: issue_order(state, strongest_planet.ID, weakest_planet.ID,strongest_planet.num_ships-20) return
def retaliate_with_fury(state): # (1) Sort our planets from strongest to weakest. fortresses = iter( sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) # (2) Find the weakest hostile planet. weakest_target = min(state.enemy_planets(), key=lambda t: t.num_ships, default=None) if not fortresses or not weakest_target: return False # (3) Send in joint invasion force from multiple bases. else: try: our_fortress = next(fortresses) #-- determine required force, considering distance to target and its production rate -- legion_size = weakest_target.num_ships + \ state.distance(our_fortress.ID, weakest_target.ID) * weakest_target.growth_rate + 1 while True: #-- if enough available ships on standby, with still enough for defence, deploy -- detachment = int(our_fortress.num_ships * 0.75) if detachment > legion_size: issue_order(state, our_fortress.ID, weakest_target.ID, detachment) break #-- otherwise, send 75% of available ships and check next base -- else: issue_order(state, our_fortress.ID, weakest_target.ID, detachment) legion_size -= detachment our_fortress = next(fortresses) except StopIteration: return
def cheese(state): #sending_planet = find_my_strongest_planet(state) #enemy_planet = find_enemy_weakest_planet(state) #sending_planet = max(state.my_planets(), key=lambda t: t.num_ships, default=None) #enemy_planet = min(state.enemy_planets(), key=lambda t: t.num_ships, default=None) #check = find_available_ships(state, sending_planet) for enemy_planet in state.enemy_planets(): for my_planet in state.my_planets(): fleets_in_progress = 0 for my_fleets in state.my_fleets(): if(my_fleets.destination_planet == enemy_planet.ID): fleets_in_progress = fleets_in_progress + my_fleets.num_ships future_forces = enemy_planet.num_ships + state.distance(enemy_planet.ID, my_planet.ID)*enemy_planet.growth_rate if(future_forces < find_available_ships(state, my_planet) and fleets_in_progress < future_forces): if(find_available_ships(state, my_planet) > enemy_planet.num_ships): issue_order(state, my_planet.ID, enemy_planet.ID, enemy_planet.num_ships) #return issue_order(state, sending_planet.ID, enemy_planet.ID, find_available_ships(state, sending_planet)) return False
def spread_to_weakest_neutral_planet(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) neutral_planets = [ planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) send = 0 try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) send += 1 my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: if send > 0: return True else: return False
def attack(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) enemy_planets = [planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] enemy_planets.sort(key=lambda p: p.num_ships) target_planets = iter(enemy_planets) try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return
def spread(state): # (1) If we currently have a fleet in flight, just do nothing. my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) neutral_planets = [ planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) sent = 0 try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) sent = 1 my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: if sent > 0: return True else: return False """if len(state.my_fleets()) >= 1:
def spread_default(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) neutral_planets = [ planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) distance = 200 try: my_planet = next(my_planets) target_planet = next(target_planets) required_ships = target_planet.num_ships + 1 while True: while my_planet is not None and target_planet is not None: curr_dist = state.distance(my_planet.ID, target_planet.ID) if distance >= curr_dist and my_planet.num_ships > required_ships: distance = curr_dist tmp_my_planet = my_planet tmp_target_planet = target_planet required_ships = tmp_target_planet.num_ships + 1 my_planet = next(my_planets) target_planet = next(target_planets) issue_order(state, tmp_my_planet.ID, tmp_target_planet.ID, required_ships) except StopIteration: return
def snipe(state): targets = sorted(state.neutral_planets(), key = lambda p: p.growth_rate, reverse = True) danger = defaultdict(int) min_turns = defaultdict(lambda: inf) for fleet in state.enemy_fleets(): if fleet.destination_planet in [target.ID for target in targets]: danger[fleet.destination_planet] += fleet.num_ships min_turns[fleet.destination_planet] = min(min_turns[fleet.destination_planet], fleet.turns_remaining) for fleet in state.my_fleets(): if fleet.destination_planet in [target.ID for target in targets]: danger[fleet.destination_planet] -= fleet.num_ships valid_targets = [target for target in targets if under_attack(state, target)] if not valid_targets: logging.log (logging.DEBUG, "Snipe: No valid targets") return False else: logging.log(logging.DEBUG, 'yes valid targets') for target in valid_targets: logging.log(logging.DEBUG, 'target~') danger[target.ID] += target.growth_rate + 1 for planet in smallest_first(state): logging.log(logging.DEBUG, 'planet~ : {} {}'.format(state.distance (planet.ID, target.ID), min_turns[target.ID])) distance = state.distance (planet.ID, target.ID) turns = min_turns[target.ID] if distance == turns + 1: logging.log(logging.DEBUG, 'sending_fleet: {} {}'.format(state.distance(planet.ID, target.ID), min_turns[target.ID])) ships = planet.num_ships danger_level = danger[target.ID] reenforcements = min (ships, danger_level) if reenforcements > 0: issue_order(state, planet.ID, target.ID, reenforcements) danger[target.ID] -= reenforcements return True
def expandToNeutrals(state): enemyTargets = [] #planets that are being targeted by the enemy for fleet in state.enemy_fleets(): enemyTargets.append(fleet.destination_planet) easyPickings = [] # find neutral planets that are not the target of an enemy fleet to expand to for planet in state.neutral_planets(): if planet.ID not in enemyTargets: #This needed to be a tupple or else game would crash easyPickings.append( (planet, state.distance(state.my_planets()[0].ID, planet.ID) + planet.num_ships)) #sort to find the closest and weakest neutral planets easyPickings = sorted(easyPickings, key=lambda x: x[1]) neutralTargets = easyPickings[:4] #ATTACK!!! for target in neutralTargets: issue_order(state, state.my_planets()[0].ID, target[0].ID, (target[0].num_ships + 1) * target[0].growth_rate) return True
def spread_to_weakest_neutral_planet(state): # (1) If we currently have a fleet in flight, just do nothing. if len(state.my_fleets()) >= 1: return False # (2) Find my strongest planet. strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) neutral_planets = [planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] # neutral_planets.sort(key=lambda p: p.num_ships) neutral_planets.sort(key=lambda p: p.num_ships + state.distance(strongest_planet.ID, p.ID)) target_planets = iter(neutral_planets) try: target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if strongest_planet.num_ships > required_ships: issue_order(state, strongest_planet.ID, target_planet.ID, required_ships) target_planet = next(target_planets) else: return False except StopIteration: return
def send_aid_to_invaded_planet(state): strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) try: my_planet = next(my_planets) #target_planet = next(target_planets) while my_planet: if any(fleet.destination_planet == my_planet.ID for fleet in state.enemy_fleets()): if not any(fleet.destination_planet == my_planet.ID for fleet in state.my_fleets()): for fleet in state.enemy_fleets(): if fleet.destination_planet == my_planet.ID: if (my_planet.num_ships + (fleet.turns_remaining * my_planet.growth_rate) + (strongest_planet.num_ships/15+2) + 5 >= fleet.num_ships + (state.distance(strongest_planet.ID, my_planet.ID)-fleet.turns_remaining) * my_planet.growth_rate): issue_order(state, strongest_planet.ID, my_planet.ID, strongest_planet.num_ships / 15 + 2) my_planet = next(my_planets) #target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return
def assult(state): #find strongest planet readyPlanets = max( [planet for planet in state.my_planets() if planet.num_ships >= 100], key=lambda p: p.num_ships) #if we dont have a planet with enough forces we abort if not readyPlanets: return False # find a good weak target planet to attack weakPlanets = [] for planet in state.not_my_planets(): weakPlanets.append( (planet, state.distance(readyPlanets.ID, planet.ID) + planet.num_ships)) #fin the weakest 3 planets to attack weakPlanets = sorted(weakPlanets, key=lambda x: x[1]) weakPlanets = weakPlanets[:3] #ATTACK for target in weakPlanets: issue_order(state, readyPlanets.ID, target[0].ID, (target[0].num_ships + 1) * target[0].growth_rate)
def spread(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) neutral_planets = [ planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) success = False try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if my_planet.num_ships > required_ships: success = True issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return success
def barrage(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships, reverse = True)) enemy_planets = [planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] enemy_planets.sort(key=lambda p: p.num_ships) target_planets = iter(enemy_planets) if len(state.enemy_planets()) > 3: return try: target_planet = next(target_planets) while True: cluster = [] i = 0 my_ships = 0 while i < 9: cluster.append(next(my_planets)) i += 1 for planet in cluster: issue_order(state, planet.ID, target_planet.ID, planet.num_ships/2) target_planet = next(target_planets) except StopIteration: return
def multi_spread(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships, reverse = True)) neutral_planets = [planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) try: neutral_planet = next(target_planets) while True: cluster = [] i = 0 my_ships = 0 while i < 10: cluster.append(next(my_planets)) my_ships += cluster[0].num_ships/8 + 2 i += 1 required_neutral = neutral_planet.num_ships if my_ships > required_neutral: for planet in cluster: issue_order(state, planet.ID, neutral_planet.ID, (planet.num_ships/8 + 2)) return else: return except StopIteration: return
def send_defensive_fleet(state): planets_in_danger = get_planets_in_danger(state) planets_helping = [] for key in planets_in_danger: for planet in state.my_planets(): if state.distance(key,planet.ID) <= planets_in_danger[key][2] and planet not in planets_in_danger and state.distance(key,planet.ID) != 0: planets_helping.append(planet) while True: remove_planets_list = [] for index, planet_helping in enumerate(planets_helping): if planet_helping.num_ships <= math.ceil((planets_in_danger[key][1] + 1)/len(planets_helping)): remove_planets_list.append(index) break if len(remove_planets_list): for id in remove_planets_list: planets_helping.pop(id) elif len(planets_helping): for planet_helping in planets_helping: issue_order(state, planet_helping.ID, key, math.ceil((planets_in_danger[key][1] + 1)/len(planets_helping))) break else: break return False
def attack_weakest_enemy_planet(state): # (1) If we currently have a fleet in flight, abort plan. if len(state.my_fleets()) >= 3: return False # (2) Find my strongest planet. strongest_planet = max(state.my_planets(), key=lambda t: t.num_ships, default=None) # (3) Find the weakest enemy planet. weakest_planet = min(state.enemy_planets(), key=lambda t: t.num_ships, default=None) if not strongest_planet or not weakest_planet: # No legal source or destination return False else: # required ships along with safety net required_ships = weakest_planet.num_ships + state.distance( strongest_planet.ID, strongest_planet.ID) * weakest_planet.growth_rate + 20 if strongest_planet.num_ships < required_ships: weakest_neutral = min(state.neutral_planets(), key=lambda p: p.num_ships, default=None) if not weakest_neutral: return False issue_order(state, strongest_planet.ID, weakest_neutral.ID, weakest_neutral.num_ships + 1) return issue_order(state, strongest_planet.ID, weakest_planet.ID, required_ships)
def take_defenseless_territory(state): # (1) Sort our planets from weakest to strongest. fortresses = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) # (2) Sort neutral planets from weakest to strongest. wishlist = [ planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] wishlist.sort(key=lambda p: p.num_ships) wishlist = iter(wishlist) # (3) Given enough ships for a target, send an invasion force to capture it. try: our_fortress = next(fortresses) target = next(wishlist) while True: legion_size = target.num_ships + 1 if our_fortress.num_ships > legion_size: issue_order(state, our_fortress.ID, target.ID, legion_size) our_fortress = next(fortresses) target = next(wishlist) else: our_fortress = next(fortresses) except StopIteration: return
def attack(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) enemy_planets = [ planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] enemy_planets.sort(key=lambda p: p.num_ships) target_planets = iter(enemy_planets) success = False try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: success = True issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return success
def attack_recent_lost_neutral_planet(state): # (1) If we currently have a fleet in flight, just do nothing. if len(state.my_fleets()) >= 1: return False # (2) Get target enemy planet enemy_planets = [planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] enemy_planets.sort(key=lambda p: p.num_ships) iter_planets = iter(enemy_planets) # (3) Get my planet iter my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) # (4) Calculate the least amount of ships we need to send try: my_planet = next(my_planets) target_planet = next(iter_planets) while True: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships + 20) my_planet = next(my_planets) target_planet = next(iter_planets) else: my_planet = next(my_planets) except StopIteration: return
def do_turn(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) target_planets = [planet for planet in state.not_my_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] target_planets = iter(sorted(target_planets, key=lambda p: p.num_ships, reverse=True)) try: my_planet = next(my_planets) target_planet = next(target_planets) while True: if target_planet.owner == 0: required_ships = target_planet.num_ships + 1 else: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: target_planet = next(target_planets) except StopIteration: return
def attack_plan(state): my_planets = iter( sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) target_planets = [planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] target_planets = iter( sorted(target_planets, key=lambda p: p.num_ships, reverse=True)) sent_ship = False try: # my_planet = next(my_planets) target_planet = next(target_planets) my_planet = closest_ally(target_planet, state) while True: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * \ target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) sent_ship = True my_planet = next(my_planets) target_planet = next(target_planets) else: target_planet = next(target_planets) except StopIteration: return sent_ship
def defend_my_planets(state): my_planets = [planet for planet in state.my_planets()] if not my_planets: return avg = sum(strength(planet) for planet in my_planets) / len(my_planets) weak_planets = [planet for planet in my_planets if strength(planet) < avg] strong_planets = [planet for planet in my_planets if strength(planet) > avg] if (not weak_planets) or (not strong_planets): return weak_planets = iter(sorted(weak_planets, key=strength)) strong_planets = iter(sorted(strong_planets, key=strength, reverse=True)) try: weak_planet = next(weak_planets) strong_planet = next(strong_planets) while True: need = int(avg - strength(weak_planet)) have = int(strength(strong_planet) - avg) if have >= need > 0: issue_order(state, strong_planet.ID, weak_planet.ID, need) weak_planet = next(weak_planets) elif have > 0: issue_order(state, strong_planet.ID, weak_planet.ID, have) strong_planet = next(strong_planets) else: strong_planet = next(strong_planets) except StopIteration: return
def spread_to_weakest_and_closest_planet(state): close_and_weak = None close_and_weak_dst = float("inf") #check how many planets you own first to ensure survival if len(state.my_planets()) >= 1: strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) else: return False # now check planets that are not mine for planets in state.not_my_planets(): # get a combined value that will determine if this planet is weak and has a small fleet dst = planet_distance( strongest_planet, planets) + planets.num_ships / (1 + planets.growth_rate) if dst < close_and_weak_dst: close_and_weak_dst = dst close_and_weak = planets #now that you know the closest and weakest planet we need to see what to do with it if close_and_weak is not None and close_and_weak.num_ships + 10 < strongest_planet.num_ships: required_ships = close_and_weak.num_ships + \ state.distance(strongest_planet.ID, close_and_weak.ID) * close_and_weak.growth_rate + 2 issue_order(state, strongest_planet.ID, close_and_weak.ID, required_ships) return False
def attack_weakest_planet(state): # Sort player and enemy planets my_planets = sort_player_planets(state) enemy_planets = sort_enemy_planets(state) neutral_planets = sort_neutral_planets(state) # Combine neutral and enemy lists neutral_and_enemy = neutral_planets + enemy_planets target_planets = iter(neutral_and_enemy) try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return False
def attack_with_no_mercy(state): # (1) Sort our planets from weakest to strongest. fortresses = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) # (2) Sort enemy planets from weakest to strongest. hostiles = [ planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] hostiles.sort(key=lambda p: p.num_ships) hostiles = iter(hostiles) # (3) Given enough ships for a target, send an invasion force to capture it. try: our_fortress = next(fortresses) marked_for_DDay = next(hostiles) while True: #-- determine required force, considering distance to target and its production rate -- required_ships = marked_for_DDay.num_ships + \ state.distance(our_fortress.ID, marked_for_DDay.ID) * marked_for_DDay.growth_rate + 1 if our_fortress.num_ships > required_ships: issue_order(state, our_fortress.ID, marked_for_DDay.ID, required_ships) our_fortress = next(fortresses) marked_for_DDay = next(hostiles) else: our_fortress = next(fortresses) except StopIteration: return
def spread_to_closest_planet(state): # Sort player and neutral planets my_planets = sort_player_planets(state) neutral_planets = sort_neutral_planets(state) target_planets = iter(neutral_planets) try: my_planet = next(my_planets) if len(neutral_planets) > 0: target_planet = find_closest_planet(state, neutral_planets, my_planet) else: target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) if len(neutral_planets) > 0: target_planet = find_closest_planet(state, neutral_planets, my_planet) else: target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return False
def closest(state): threatenedPlanets = do_not_kill_if_you_are_being_killed(state) planets = settled_predictPop(state) my_planets = state.my_planets() other_planets = state.not_my_planets() my_planets = state.my_planets() my_planets.sort(key=lambda p : p.num_ships) other_planets = [toNametuple(p[1]) for p in planets.items() if p[1]['owner'] != 1] # state.not_my_planets()#state.neutral_planets() my_center = getCenter(my_planets) #sorted distance #neutral_planets.sort(key=lambda p : distance(getCenter(my_planets), (p.x,p.y) )) #sorted lowest pop #other_planets.sort(key=lambda p : p.num_ships ) #combined value other_planets.sort(key=lambda p : popAtArrival(p, distance(getCenter(my_planets), (p.x,p.y))) + 50 * distance(getCenter(my_planets), (p.x,p.y) )) for mp in my_planets: closest = None for op in other_planets: if closest == None or state.distance(mp.ID, closest.ID) > state.distance(mp.ID, op.ID): closest = op if closest != None: pop = popAtArrival(closest, state.distance(mp.ID,closest.ID)) if pop + 1 < mp.num_ships: other_planets.remove(closest) issue_order(state, mp.ID, closest.ID, pop + 1) return True
def defend_friendly_planet(state): fleets_attacking = [] friend_planet = [] for friend in state.my_fleets(): friend_planet.append(friend.destination_planet) for enemy_fleet in state.enemy_fleets(): planet = enemy_fleet.destination_planet for friendly_planet in state.my_planets(): if planet == friendly_planet.ID: size_of_fleet = enemy_fleet.num_ships size_of_planet = friendly_planet.num_ships + (friendly_planet.growth_rate*enemy_fleet.turns_remaining) if size_of_fleet > size_of_planet: if friendly_planet.ID not in friend_planet: fleets_attacking.append(enemy_fleet) for fleet in fleets_attacking: number_of_ships = fleet.num_ships ships_to_send = number_of_ships / (len(state.my_planets())) for planet in state.my_planets(): if planet.ID != fleet.destination_planet: if planet.num_ships > (ships_to_send + 10): number_of_ships = number_of_ships - ships_to_send issue_order(state, planet.ID, fleet.destination_planet, ships_to_send) return
def spread_to_weakest_neutral_planet(state): # (1) If we currently have a fleet in flight, just do nothing. ##if len(state.my_fleets()) > 4: ##return False # (2) Find my strongest planet. strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) # (3) Find the weakest neutral planet. weakest_planet = sorted(state.neutral_planets(), key=lambda p: p.num_ships) weakest_planeta = min(state.neutral_planets(), key=lambda p: p.num_ships, default=None) for neut in weakest_planet: if strongest_planet.num_ships <= neut.num_ships + 1: return False is_attacked = False for fleet in state.fleets: if neut.ID == fleet.destination_planet: is_attacked = True break if not is_attacked: return issue_order(state, strongest_planet.ID, neut.ID, neut.num_ships + 1) if len(state.my_fleets() ) < 1 and strongest_planet.num_ships > weakest_planeta.num_ships: return issue_order(state, strongest_planet.ID, weakest_planeta.ID, weakest_planeta.num_ships + 1) return False
def spread(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) neutral_planets = [ planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets()) ] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return
def deploy_fleet(state, data, parameters): """ Attempts to make a deployment defined in the deployments priority queue Returns True if deployment was successfully made """ ships = data["available_ships"] deployments = data["deployments"] # all deployments processed, return false if deployments.empty(): return False # get next deployment score, target, num_ships = deployments.get() # not enough ships available, return false if num_ships > data["num_available_ships"]: return False # account for fleets already sent for fleet in state.my_fleets(): if fleet.destination_planet == target.ID: num_ships -= fleet.num_ships # account for ships on planet if target in ships: ships_on_planet = min(num_ships, ships[target]) num_ships -= ships_on_planet ships[target] -= ships_on_planet data["num_available_ships"] -= ships_on_planet if ships[target] <= 0: ships.pop(target) # loop until ship requirement met while num_ships > 0: # find closest planet with available ships closest_planet = None closest_planet_distance = inf for planet in ships.keys(): planet_distance = state.distance(planet.ID, target.ID) if planet_distance < closest_planet_distance: closest_planet = planet closest_planet_distance = planet_distance # send ships fleet_size = min(ships[closest_planet], num_ships) issue_order(state, closest_planet.ID, target.ID, fleet_size) # reduce number of available ships num_ships -= fleet_size data["num_available_ships"] -= fleet_size ships[closest_planet] -= fleet_size if ships[closest_planet] <= 0: ships.pop(closest_planet) # deployment return True
def reinforce_friends(state): planets = state.my_planets() if(len(planets)>=2): issue_order(state, planets[0].ID, planets[1].ID, 1) pass
def cluster(state): #threatenedPlanets = do_not_kill_if_you_are_being_killed(state) #planets = settled_predictPop(state) #my_planets = state.my_planets() #other_planets = state.not_my_planets() my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships)) neutral_planets = [planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] neutral_planets.sort(key=lambda p: p.num_ships) target_planets = iter(neutral_planets) try: my_planet = next(my_planets) target_planet = next(target_planets) while True: required_ships = target_planet.num_ships + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: my_planet = next(my_planets) except StopIteration: return '''my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) target_planets = [planet for planet in state.not_my_planets()] target_planets = iter(sorted(target_planets, key=lambda p: p.num_ships, reverse=True)) try: my_planet = next(my_planets) target_planet = next(target_planets) while True: if target_planet.owner == 0: required_ships = target_planet.num_ships + 1 else: required_ships = target_planet.num_ships + \ state.distance(my_planet.ID, target_planet.ID) * target_planet.growth_rate + 1 if my_planet.num_ships > required_ships: issue_order(state, my_planet.ID, target_planet.ID, required_ships) my_planet = next(my_planets) target_planet = next(target_planets) else: target_planet = next(target_planets) except StopIteration: return''' pass
def spread_to_weakest_neutral_planet(state): success = False my_planets = sorted(state.my_planets(), key = lambda p: p.num_ships, reverse = True) neutral_planets = sorted([planet for planet in state.neutral_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())], key = lambda p: p.num_ships) viable_moves = [] for planet in my_planets: l = [] sur = surplus(state, planet) for neutral_planet in neutral_planets: enemy_fleets = sorted([fleet for fleet in state.enemy_fleets() if fleet.destination_planet == neutral_planet.ID], key=lambda f: f.turns_remaining) distance = state.distance(planet.ID, neutral_planet.ID) turns_capped, neutral_ships = inf, neutral_planet.num_ships for fleet in enemy_fleets: neutral_ships -= fleet.num_ships if neutral_ships < 0: turns_capped = distance - fleet.turns_remaining if turns_capped < 1: continue required_ships = fabs(neutral_ships) + (turns_capped * neutral_planet.growth_rate) + 1 \ if enemy_fleets \ else neutral_planet.num_ships + 1 #arbitrary: don't send more ships to take a neutral planet then my planet's growth rate * 10 if sur - required_ships < planet.growth_rate * 10: continue #arbitrary ranking of which planets are best to take planet_ratio = c * sqrt(distance) + sqrt(fabs(neutral_ships)) - neutral_planet.growth_rate l.append((planet_ratio, planet, neutral_planet, required_ships, sur)) viable_moves.append(sorted([att[:-1] for att in l])) #order all moves into dictionary of lists where key is neutral planet and value is moves to that planet d = defaultdict(list) for my_planet in viable_moves: for move in my_planet: d[move[2]].append(move) #find the best available move to each enemy planet and execute it planets_have_spread = set() for neutral_planet, move in d.items(): ratio, my_p, neutral_p, req = sorted(move)[0] if my_p not in planets_have_spread: issue_order(state, my_p.ID, neutral_p.ID, req) planets_have_spread.add(my_p) success = True return success
def defend(state): my_planets = [planet for planet in state.my_planets()] if not my_planets: return def strength(p): return p.num_ships \ + sum(fleet.num_ships for fleet in state.my_fleets() if fleet.destination_planet == p.ID) \ - sum(fleet.num_ships for fleet in state.enemy_fleets() if fleet.destination_planet == p.ID) avg = sum(strength(planet) for planet in my_planets) / len(my_planets) reinforce = [] weak_planets = [planet for planet in my_planets if strength(planet) < avg] incoming = [fleet.destination_planet for fleet in state.enemy_fleets()] for planet in weak_planets: for fleet in incoming: if fleet == planet.ID: reinforce.append(planet) strong_planets = [ planet for planet in my_planets if strength(planet) > avg ] if (not reinforce) or (not strong_planets): return reinforce = sorted(reinforce, key=strength) strong_planets = sorted(strong_planets, key=strength, reverse=True) avg_dist = 0 for planet in strong_planets: for weak in reinforce: avg_dist += state.distance(planet.ID, weak.ID) avg_dist /= int(len(strong_planets) * len(reinforce)) avg_dist = math.ceil(int(avg_dist)) inbound = {} for strong_planet in strong_planets: for weak_planet in reinforce: incoming = 0 if weak_planet.ID in inbound.keys(): incoming += inbound[weak_planet.ID] need = abs(int(strength(weak_planet) + incoming)) have = abs(int(strength(strong_planet))) if have >= need > 0 and state.distance(strong_planet.ID, weak_planet.ID) <= avg_dist: issue_order(state, strong_planet.ID, weak_planet.ID, need) if weak_planet.ID not in inbound.keys(): inbound[weak_planet.ID] = need else: inbound[weak_planet.ID] += need return False
def reinforce_friendly_planet(state): low_planet = [] for planet in state.my_planets(): if planet.num_ships > 40: low_planet.append(planet) for receive in low_planet: for donator in state.my_planets(): if donator.num_ships < 20: issue_order(state, receive.ID, donator.ID, 10) return
def spread_to_best_neutral(state): my_planets = iter( sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) neutral_planets = iter( sorted(state.neutral_planets(), key=lambda p: (p.growth_rate / (p.num_ships + 1)), reverse=True)) try: my_planet = next(my_planets) neutral_planet = next(neutral_planets) #iterate through neutral_planets and assign each neutral_planet a my_planet # attack if possible while True: if any(fleet.destination_planet == neutral_planet.ID for fleet in state.my_fleets()): neutral_planet = next(neutral_planets) continue #check if any enemy fleet trying to get this next neutral_planet for fleet in state.enemy_fleets(): if fleet.destination_planet == neutral_planet.ID: my_distance = state.distance(my_planet.ID, neutral_planet.ID) if my_distance > fleet.turns_remaining: ship_diff_arrived = fleet.num_ships - neutral_planet.num_ships num_ships_to_send = 15 + ship_diff_arrived + ( (my_distance - fleet.turns_remaining + 1) * neutral_planet.growth_rate) elif my_distance == fleet.turns_remaining: num_ships_to_send = fleet.num_ships + 10 else: num_ships_to_send = fleet.num_ships - neutral_planet.num_ships + 5 if my_planet.num_ships - 25 > num_ships_to_send: issue_order(state, my_planet.ID, neutral_planet.ID, num_ships_to_send) my_planet = next(my_planets) break if my_planet.num_ships - 30 < neutral_planet.num_ships: my_planet = next(my_planets) continue else: if state.distance(my_planet.ID, neutral_planet.ID) > 15: neutral_planet = next(neutral_planets) continue issue_order(state, my_planet.ID, neutral_planet.ID, neutral_planet.num_ships + 10) my_planet = next(my_planets) neutral_planet = next(neutral_planets) except StopIteration: return
def spread_to_closest_weak_planets(state): # find the closest planets that the enemy is not spreading to and take them enemy_destination_planets = [f.destination_planet for f in state.enemy_fleets()] closest_neutral_planets = [(p, state.distance(state.my_planets()[0].ID, p.ID) + p.num_ships) for p in state.neutral_planets() if p.ID not in enemy_destination_planets] closest_neutral_planets = sorted(closest_neutral_planets, key=lambda x: x[1]) closest_neutral_planets = closest_neutral_planets[:4] for dest in closest_neutral_planets: issue_order(state, state.my_planets()[0].ID, dest[0].ID, (dest[0].num_ships + 1 * dest[0].growth_rate)) return True
def spread_to_small_close_planets (state): for planet in smallest_first(state): if under_attack (state, planet) or planet.num_ships < 50: continue planet_targets = sorted (state.neutral_planets(), key = lambda p: p.num_ships * 2 + state.distance(planet.ID, p.ID) * 3) for target in planet_targets: closest_enemy = get_closest_enemy(state, target) if not closest_enemy: return False if state.distance (closest_enemy.ID, target.ID) <= state.distance(planet.ID, target.ID): continue ships = planet.num_ships danger_level = target.num_ships + 1 if ships > danger_level and danger_level > 0: issue_order(state, planet.ID, target.ID, danger_level) return True
def pinpoint(state): my_planets = iter(sorted(state.my_planets(), key=lambda p: p.num_ships, reverse = True)) enemy_planets = [planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] enemy_planets.sort(key=lambda p: p.num_ships) target_planets = iter(enemy_planets) if len(state.enemy_fleets()) == 0: return enemy_fleet = state.enemy_fleets() target_planet = None target_size = 0 for fleet in enemy_fleet: if state.planet[fleet.source_planet].num_ships > target_size: target_planet = state.planet[fleet.source_planet] target_size = target_planet.num_ships ID = enemy_fleet[0].source_planet target_planet = state.planets[ID] try: while True: cluster = [] i = 0 my_ships = 0 while i < 6: cluster.append(next(my_planets)) my_ships += cluster[0].num_ships/5 + 2 i += 1 dist = 0 furthest_planet = None for planet in cluster: temp = state.distance(target_planet.ID, planet.ID) if temp > dist: furthest_planet = planet dist = temp required_ships = target_planet.num_ships + \ state.distance(furthest_planet.ID, target_planet.ID) * target_planet.growth_rate + 2 if my_ships > required_ships: for planet in cluster: issue_order(state, planet.ID, target_planet.ID, (planet.num_ships/4 + 2)) return else: return except StopIteration: return
def defense_action(state): my_planets = iter( sorted(state.my_planets(), key=lambda p: p.num_ships, reverse=True)) our_planet = next(my_planets) my_list = state.my_planets() for enemy in state.enemy_fleets(): for my in my_list: if enemy.destination_planet == my.ID: need = enemy.num_ships - my.num_ships if need < our_planet.num_ships and our_planet.num_ships > 3: issue_order(state, our_planet.ID, enemy.destination_planet, 3) return
def spread_to_weakest_closest_neutral_planet(state): if len(state.my_fleets()) >= 1: return False strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) weakest_planet = min(state.neutral_planets(), key=lambda p: p.num_ships, default=None) if not strongest_planet or not weakest_planet: return False main_distance = state.distance(strongest_planet.ID, weakest_planet.ID) new_time = main_distance difference = main_distance for planet in state.neutral_planets(): new_distance = state.distance(strongest_planet.ID, planet.ID) if (planet.num_ships > strongest_planet.num_ships): difference = planet.num_ships - strongest_planet.num_ships + (strongest_planet.num_ships / 2) new_time = difference / strongest_planet.growth_rate new_time += new_distance if (planet.num_ships < (1.5 * strongest_planet.num_ships)): new_time = new_distance if (new_time < main_distance): main_distance = new_time weakest_planet = planet return issue_order(state, strongest_planet.ID, weakest_planet.ID, strongest_planet.num_ships / 2)
def attack_good_enemy_planet(state): def calc_priority(p): if p.num_ships > weak_planet_threshold: return 0 return p.growth_rate / (p.num_ships + 1) best_planet = max(get_unrouted_enemy_planets(state), key=lambda p: calc_priority(p), default=None) if not best_planet: return False def calc_distance(p): if p.num_ships < best_planet.num_ships: return inf distance = state.distance(p.ID, best_planet.ID) enemy_ships = best_planet.num_ships + (distance * best_planet.growth_rate) if p.num_ships - 10 < enemy_ships: return inf return state.distance(p.ID, best_planet.ID) closest_planet = min(state.my_planets(), key=lambda p: calc_distance(p), default=None) if not closest_planet: # No legal source return False else: if closest_planet.num_ships < 15: return False # return issue_order(state, closest_planet.ID, best_planet.ID, closest_planet.num_ships - 10)
def do_turn(state): # (1) If we currently have a fleet in flight, just do nothing. if len(state.my_fleets()) >= 1: return # (2) Find my strongest planet. strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) # (3) Find the weakest enemy or neutral planet. weakest_planet = min(state.not_my_planets(), key=lambda p: p.num_ships, default=None) if not strongest_planet or not weakest_planet: # No legal source or destination return # (4) Send half the ships from my strongest planet to the weakest planet that I do not own. issue_order(state, strongest_planet.ID, weakest_planet.ID, strongest_planet.num_ships/2)
def coordinate_attack_on_enemy(state): my_planets = sorted(state.my_planets(), key=lambda p: p.num_ships) enemy_planets = [planet for planet in state.enemy_planets() if not any(fleet.destination_planet == planet.ID for fleet in state.my_fleets())] enemy_planets.sort(key=lambda p: p.num_ships) target_planets = iter(enemy_planets) '''my_fleet_size = sum(planet.num_ships for planet in state.my_planets()) \ + sum(fleet.num_ships for fleet in state.my_fleets()) local_planets = [] enemy_distances = {} plausible_target = []''' try: target_planet = next(target_planets) while True: closest_enemy_allies = get_neighbors_within(state, target_planet, enemy_planets, inf) radius = inf if len(closest_enemy_allies) != 0: radius = closest_enemy_allies[0][1] logging.error("cea: " + str(closest_enemy_allies)) logging.error("enemy planets: " + str(enemy_planets)) logging.error("target planet: " + str(target_planet)) best_offesive_planets = get_neighbors_within(state, target_planet, my_planets, radius) if len(best_offesive_planets) > 0: required_ships = 0 if radius == inf: required_ships = target_planet.num_ships + \ state.distance(best_offesive_planets[-1][0].ID, target_planet.ID) * target_planet.growth_rate + 1 else: required_ships = target_planet.num_ships + \ state.distance(closest_enemy_allies[0][0].ID, target_planet.ID) * target_planet.growth_rate + 1 offesive_planets_scored = score_planets_contributions(state, best_offesive_planets, required_ships) for offesive_planet in offesive_planets_scored: issue_order(state, offesive_planet[0].ID, target_planet.ID, offesive_planet[1]) target_planet = next(target_planets) except StopIteration: return False '''
def spread_to_weakest_neutral_planet(state): if len(state.my_fleets()) >= 1: return False strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) weakest_planet = min(state.neutral_planets(), key=lambda p: p.num_ships, default=None) if not strongest_planet or not weakest_planet: return False else: return issue_order(state, strongest_planet.ID, weakest_planet.ID, strongest_planet.num_ships / 2)
def abandon_planet(state): fleets_destinations = [fleet.destination_planet for fleet in state.enemy_fleets()] planets_being_attacked = [planet for planet in state.my_planets() if planet.ID in fleets_destinations] for planet in planets_being_attacked: fleets_defending = [fleet.num_ships for fleet in state.my_fleets() if fleet.destination_planet == planet.ID] fleets_defending_total = sum(fleets_defending) fleets_attacking = [fleet for fleet in state.enemy_fleets() if state.planets[fleet.destination_planet].ID == planet.ID] fleets_attacking.sort(key=lambda x: x.turns_remaining) total_defense = fleets_attacking[0].turns_remaining*planet.growth_rate + planet.num_ships + fleets_defending_total - fleets_attacking[0].num_ships message = "Sera que precisa?"+str(fleets_defending) + " " + str(fleets_attacking) + " " + str(total_defense) logging.info(message) if total_defense < 0: logging.info("ALGUM PLANETA DEVERIA SER ABANDONADO") other_planets = [p for p in state.my_planets() if p.ID != planet.ID] if other_planets: closest = min(other_planets,key=lambda x: state.distance(planet.ID, x.ID)) issue_order(state, planet.ID, closest.ID, planet.num_ships) return False
def move_up (state): if not state.enemy_planets(): return False my_planets = state.my_planets() for planet in my_planets: if planet.num_ships < 50 or under_attack(state, planet): continue my_closest_enemy = get_closest_enemy(state, planet) min_dist = inf min_planet = planet for other_planet in my_planets: new_dist = state.distance(other_planet.ID, my_closest_enemy.ID) if new_dist < min_dist: min_planet = other_planet min_dist = new_dist if min_planet.ID != planet.ID: ships = planet.num_ships reenforcements = ships - 50 if reenforcements > 0: issue_order(state, planet.ID, min_planet.ID, reenforcements) return True
def spread_unexplored_planet(state): strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) if not strongest_planet: return False best_planet = max(get_unrouted_neutral_planets(state), key=lambda p: p.growth_rate / (1 + p.num_ships * state.distance(strongest_planet.ID, p.ID)), default=None) if not best_planet: return False else: send_ships = best_planet.num_ships + spread_garrison return issue_order(state, strongest_planet.ID, best_planet.ID, send_ships)
def attack_most_valuable_enemy_planet(state): attackable_planets = get_attackable_planets(state,state.enemy_planets()) if len(attackable_planets): queue = populate_priority_queue(state, attackable_planets) if queue: domination_value, my_planet, enemy_planet, predicted_num_ships = heappop(queue) return issue_order(state, my_planet.ID, enemy_planet.ID, predicted_num_ships + 1) return False
def spread_to_most_valuable_neutral_planet(state): attackable_planets = get_attackable_planets(state,state.neutral_planets()) if len(attackable_planets): queue = populate_priority_queue(state, attackable_planets) if queue: domination_value, my_planet, neutral_planet, num_ships = heappop(queue) return issue_order(state, my_planet.ID, neutral_planet.ID, num_ships + 1) return False
def attack_largest_enemies (state): targets = sorted(state.enemy_planets(), key = lambda p: p.growth_rate, reverse = True) fleet_distribution = defaultdict(lambda: defaultdict(int)) for fleet in state.enemy_fleets(): if fleet.destination_planet in targets: fleet_distribution[fleet.destination_planet]['danger_level'] += fleet.num_ships for fleet in state.my_fleets(): if fleet.destination_planet in targets: fleet_distribution[fleet.destination_planet]['danger_level'] -= fleet.num_ships for target in targets: for planet in smallest_first(state): if not under_attack(state, planet): ships = planet.num_ships if ships < 50: continue danger_level = fleet_distribution[target.ID]['danger_level'] + target.num_ships + target.growth_rate * state.distance(target.ID, planet.ID) + 1 reenforcements = min (ships, danger_level) if reenforcements > 0: issue_order(state, planet.ID, target.ID, reenforcements) fleet_distribution[target.ID]['danger_level'] -= reenforcements return True
def attack_closest_enemy (state): target = closest_enemy(state) danger = target.num_ships for fleet in state.enemy_fleets(): if fleet.destination_planet == target.ID: danger += fleet.num_ships for fleet in state.my_fleets(): if fleet.destination_planet == target.ID: danger -= fleet.num_ships for planet in smallest_first(state): if not under_attack(state, planet): ships = planet.num_ships if ships < 50: continue danger_level = danger + target.growth_rate * 10 reenforcements = min (ships, danger_level) if reenforcements > 0: issue_order(state, planet.ID, target.ID, reenforcements) danger -= reenforcements return True
def defend_planet(state): fleets_attacking = [fleet for fleet in state.enemy_fleets() if state.planets[fleet.destination_planet].owner == 1] fleets_destinations = [fleet.destination_planet for fleet in fleets_attacking] planets_not_being_attacked = [planet for planet in state.my_planets() if planet.ID not in fleets_destinations] for fleet in fleets_attacking: planet_being_attacked = state.planets[fleet.destination_planet] fleets_defending = [fleet.num_ships for fleet in state.my_fleets() if state.planets[fleet.destination_planet].ID == planet_being_attacked.ID] total_fleet_defending = sum(fleets_defending) needed_fleet = fleet.num_ships - planet_being_attacked.num_ships - \ planet_being_attacked.growth_rate * fleet.turns_remaining - total_fleet_defending +1 if needed_fleet > 0: close_planets = [planet for planet in planets_not_being_attacked if state.distance(planet.ID, planet_being_attacked.ID) < fleet.turns_remaining] for close_planet in close_planets: max_can_send = min(close_planet.num_ships/3,needed_fleet) if max_can_send == 0: continue issue_order(state,close_planet.ID,planet_being_attacked.ID,max_can_send) needed_fleet -= max_can_send if needed_fleet < 0: break return True
def d_fence(state): sort_enemy_fleet = sorted(state.enemy_fleets(), key=lambda p: p.num_ships) iter_enemy_fleet = iter(sort_enemy_fleet) sort_my_planets = sorted(state.my_planets(), key=lambda p: p.num_ships) iter_my_planets = iter(sort_my_planets) enemy_fleet = sort_enemy_fleet(state) my_planets = sort_player_planets(state) avg = sum(strength(planet) for planet in sort_my_planets) / len(sort_my_planets) strong_planets = [planet for planet in sort_my_planets if strength(planet) > avg] if not my_planets or not enemy_fleet: return strong_planets = iter(sorted(strong_planets, key=strength, reverse=True)) try: player_planet = next(iter_my_planets) strong_planet = next(strong_planets) enemy_fleet = next(iter_enemy_fleet) while True: if enemy_fleet.destination_planet == player_planet: need = int(avg - strength(enemy_fleet.destination_planet)) have = int(strength(strong_planet) - avg) if have >= need > 0: issue_order(state, strong_planet.ID, enemy_fleet.destination_planet.ID, need) enemy_fleet = next(iter_enemy_fleet) elif have > 0: issue_order(state, strong_planet.ID, enemy_fleet.destination_planet.ID, have) strong_planet = next(strong_planets) else: strong_planet = next(strong_planets) #issue_order(state, strong_planet.ID, enemy_fleet.destination_planet.ID, need) except StopIteration: return False
def attack_weakest_enemy_planet(state): # (2) Find my strongest planet. strongest_planet = max(state.my_planets(), key=lambda p: p.num_ships, default=None) # (3) Find the weakest enemy planet. weakest_planet = min(state.enemy_planets(), key=lambda p: p.num_ships, default=None) if not strongest_planet or not weakest_planet: # No legal source or destination return False else: # (4) Send half the ships from my strongest planet to the weakest enemy planet. return issue_order(state, strongest_planet.ID, weakest_planet.ID, strongest_planet.num_ships / 2)