def assign_invasion_bases():
"""Assign our troop bases to invasion targets."""
universe = fo.getUniverse()
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
aistate = get_aistate()
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # entry may have been discarded in previous loop iterations
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(aistate.qualifyingTroopBaseTargets.keys()))
debug("Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, aistate.qualifyingTroopBaseTargets[pid]) for pid in available_planets]))
targets = [pid for pid in available_planets if aistate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
debug("Failure: found no valid target for troop base in system %s" % system)
continue
status = aistate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
target_id = INVALID_ID
best_score = -1
target_troops = 0
for pid, (p_score, p_troops) in assign_invasion_values(targets).items():
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == INVALID_ID:
continue
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed + _TROOPS_SAFETY_MARGIN}
FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=local_base_troops,
fleet_list=found_fleets)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
aistate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = TargetPlanet(target_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.set_target(MissionType.ORBITAL_INVASION, target)
def assign_invasion_bases():
"""Assign our troop bases to invasion targets."""
universe = fo.getUniverse()
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
aistate = get_aistate()
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # entry may have been discarded in previous loop iterations
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(aistate.qualifyingTroopBaseTargets.keys()))
debug("Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, aistate.qualifyingTroopBaseTargets[pid]) for pid in available_planets]))
targets = [pid for pid in available_planets if aistate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
debug("Failure: found no valid target for troop base in system %s" % system)
continue
status = aistate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
target_id = INVALID_ID
best_score = -1
target_troops = 0
for pid, (p_score, p_troops) in assign_invasion_values(targets).items():
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == INVALID_ID:
continue
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed + _TROOPS_SAFETY_MARGIN}
FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=local_base_troops,
fleet_list=found_fleets)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
aistate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = TargetPlanet(target_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.set_target(MissionType.ORBITAL_INVASION, target)
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
if not invasion_fleet_pool:
return
for planet_id, pscore, ptroops in evaluated_planets:
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': ptroops}
target_stats = {'rating': 10, 'troopCapacity': ptroops+1}
these_fleets = FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=invasion_fleet_pool, fleet_list=found_fleets,
verbose=False)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
print "Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s" % (
sys_id, universe.getSystem(sys_id).name, min_stats, found_stats)
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, planet_id)
print "assigning invasion fleets %s to target %s" % (these_fleets, target)
for fleetID in these_fleets:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_targets((fleet_mission.get_mission_types() + [-1])[0])
fleet_mission.add_target(mission_type, target)
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
if not fleet_ids:
return
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
for planet_id, pscore, ptroops in evaluated_planets:
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': ptroops}
target_stats = {'rating': 10, 'troopCapacity': ptroops + _TROOPS_SAFETY_MARGIN}
these_fleets = FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=invasion_fleet_pool,
fleet_list=found_fleets)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
print "Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s" % (
sys_id, universe.getSystem(sys_id).name, min_stats, found_stats)
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = universe_object.Planet(planet_id)
print "assigning invasion fleets %s to target %s" % (these_fleets, target)
for fleetID in these_fleets:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
fleet_mission.set_target(mission_type, target)
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
if not invasion_fleet_pool:
return
for planet_id, pscore, ptroops in evaluated_planets:
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': ptroops}
target_stats = {'rating': 10, 'troopCapacity': ptroops+1}
these_fleets = FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=invasion_fleet_pool,
fleet_list=found_fleets)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
print "Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s" % (
sys_id, universe.getSystem(sys_id).name, min_stats, found_stats)
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = universe_object.Planet(planet_id)
print "assigning invasion fleets %s to target %s" % (these_fleets, target)
for fleetID in these_fleets:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
fleet_mission.set_target(mission_type, target)
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
if not invasion_fleet_pool:
return
for planet_id, pscore, ptroops in evaluated_planets:
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': ptroops}
target_stats = {'rating': 10, 'troopCapacity': ptroops+1}
these_fleets = FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=invasion_fleet_pool, fleet_list=found_fleets,
verbose=False)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
print "Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s" % (
sys_id, universe.getSystem(sys_id).name, min_stats, found_stats)
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, planet_id)
print "assigning invasion fleets %s to target %s" % (these_fleets, target)
for fleetID in these_fleets:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_targets((fleet_mission.get_mission_types() + [-1])[0])
fleet_mission.add_target(mission_type, target)
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
if not fleet_ids:
return
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
for planet_id, pscore, ptroops in evaluated_planets:
if pscore < MIN_INVASION_SCORE:
continue
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {"troopCapacity": ptroops}
target_stats = {
"troopCapacity": ptroops + _TROOPS_SAFETY_MARGIN,
"target_system": TargetSystem(sys_id),
}
these_fleets = FleetUtilsAI.get_fleets_for_mission(
target_stats,
min_stats,
found_stats,
starting_system=sys_id,
fleet_pool_set=invasion_fleet_pool,
fleet_list=found_fleets,
)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
debug(
"Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s"
% (sys_id, universe.getSystem(sys_id).name, min_stats,
found_stats))
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = TargetPlanet(planet_id)
debug("assigning invasion fleets %s to target %s" %
(these_fleets, target))
if target.get_object().currentMeterValue(
fo.meterType.maxShield) > 0.0 and not secure_system(
sys_id, True):
continue
aistate = get_aistate()
for fleetID in these_fleets:
fleet_mission = aistate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
fleet_mission.set_target(mission_type, target)
# cannot wait for next turn, else the secure mission may be abandoned
if these_fleets and sys_id not in AIstate.invasionTargetedSystemIDs:
AIstate.invasionTargetedSystemIDs.append(sys_id)
def assign_scouts_to_explore_systems():
# TODO: use Graph Theory to explore closest systems
universe = fo.getUniverse()
capital_sys_id = PlanetUtilsAI.get_capital_sys_id()
# order fleets to explore
#explorable_system_ids = foAI.foAIstate.get_explorable_systems(AIExplorableSystemType.EXPLORABLE_SYSTEM_UNEXPLORED)
explorable_system_ids = list(borderUnexploredSystemIDs)
if not explorable_system_ids or (capital_sys_id == -1):
return
exp_systems_by_dist = sorted(map(lambda x: (universe.linearDistance(capital_sys_id, x), x), explorable_system_ids))
print "Exploration system considering following system-distance pairs:\n %s"%("[ "+ ", ".join(["%3d : %5.1f"%(sys, dist) for dist, sys in exp_systems_by_dist]) +" ]")
explore_list = [sys_id for dist, sys_id in exp_systems_by_dist ]
already_covered, available_scouts = get_current_exploration_info()
print "explorable sys IDs: %s"%explore_list
print "already targeted: %s"%already_covered
if 'needsEmergencyExploration' not in dir(foAI.foAIstate):
foAI.foAIstate.needsEmergencyExploration = []
needs_coverage = foAI.foAIstate.needsEmergencyExploration + [sys_id for sys_id in explore_list if sys_id not in already_covered ] # emergency coverage cane be due to invasion detection trouble, etc.
print "needs coverage: %s"%needs_coverage
print "available scouts & AIstate locs: %s" % (map(lambda x: (x, foAI.foAIstate.fleetStatus.get(x, {}).get('sysID', -1)), available_scouts) )
print "available scouts & universe locs: %s" % (map(lambda x: (x, universe.getFleet(x).systemID), available_scouts))
if not needs_coverage or not available_scouts:
return
available_scouts = set(available_scouts)
sent_list = []
while (len(available_scouts) > 0 ) and ( len(needs_coverage) > 0):
this_sys_id = needs_coverage.pop(0)
if (foAI.foAIstate.systemStatus.setdefault(this_sys_id, {}).setdefault('monsterThreat', 0) > 2000* foAI.foAIstate.aggression ) or (fo.currentTurn() <20 and foAI.foAIstate.systemStatus[this_sys_id]['monsterThreat'] > 200):
print "Skipping exploration of system %d due to Big Monster, threat %d"%(this_sys_id, foAI.foAIstate.systemStatus[this_sys_id]['monsterThreat'])
continue
found_fleets=[]
this_fleet_list = FleetUtilsAI.get_fleets_for_mission(nships=1, target_stats={}, min_stats={}, cur_stats={}, species="", systems_to_check=[this_sys_id], systems_checked=[],
fleet_pool_set= available_scouts, fleet_list=found_fleets, verbose=False)
if not this_fleet_list:
print "seem to have run out of scouts while trying to cover sys_id %d"%this_sys_id
break #must have ran out of scouts
fleet_id = this_fleet_list[0]
fleet_mission = foAI.foAIstate.get_fleet_mission( fleet_id )
target = AITarget.AITarget(AITargetType.TARGET_SYSTEM, this_sys_id )
if len(MoveUtilsAI.can_travel_to_system_and_return_to_resupply(fleet_id, fleet_mission.get_location_target(), target)) > 0:
fleet_mission.add_target(AIFleetMissionType.FLEET_MISSION_EXPLORATION, target)
sent_list.append(this_sys_id)
else: #system too far out, skip it, but can add scout back to available pool
print "sys_id %d too far out for fleet ( ID %d ) to readch"%(this_sys_id, fleet_id)
available_scouts.update(this_fleet_list)
print "sent scouting fleets to sysIDs : %s"%sent_list
return
# pylint: disable=pointless-string-statement
"""
def assign_scouts_to_explore_systems():
# TODO: use Graph Theory to explore closest systems
universe = fo.getUniverse()
capital_sys_id = PlanetUtilsAI.get_capital_sys_id()
# order fleets to explore
#explorable_system_ids = foAI.foAIstate.get_explorable_systems(AIExplorableSystemType.EXPLORABLE_SYSTEM_UNEXPLORED)
explorable_system_ids = list(borderUnexploredSystemIDs)
if not explorable_system_ids or (capital_sys_id == -1):
return
exp_systems_by_dist = sorted(map(lambda x: (universe.linearDistance(capital_sys_id, x), x), explorable_system_ids))
print "Exploration system considering following system-distance pairs:\n %s" % ("[ " + ", ".join(["%3d : %5.1f" % (sys, dist) for dist, sys in exp_systems_by_dist]) + " ]")
explore_list = [sys_id for dist, sys_id in exp_systems_by_dist]
already_covered, available_scouts = get_current_exploration_info()
print "explorable sys IDs: %s" % explore_list
print "already targeted: %s" % already_covered
if 'needsEmergencyExploration' not in dir(foAI.foAIstate):
foAI.foAIstate.needsEmergencyExploration = []
needs_coverage = foAI.foAIstate.needsEmergencyExploration + [sys_id for sys_id in explore_list if sys_id not in already_covered] # emergency coverage cane be due to invasion detection trouble, etc.
print "needs coverage: %s" % needs_coverage
print "available scouts & AIstate locs: %s" % (map(lambda x: (x, foAI.foAIstate.fleetStatus.get(x, {}).get('sysID', -1)), available_scouts))
print "available scouts & universe locs: %s" % (map(lambda x: (x, universe.getFleet(x).systemID), available_scouts))
if not needs_coverage or not available_scouts:
return
available_scouts = set(available_scouts)
sent_list = []
while (len(available_scouts) > 0) and (len(needs_coverage) > 0):
this_sys_id = needs_coverage.pop(0)
if (foAI.foAIstate.systemStatus.setdefault(this_sys_id, {}).setdefault('monsterThreat', 0) > 2000 * foAI.foAIstate.aggression) or (fo.currentTurn() < 20 and foAI.foAIstate.systemStatus[this_sys_id]['monsterThreat'] > 200):
print "Skipping exploration of system %d due to Big Monster, threat %d" % (this_sys_id, foAI.foAIstate.systemStatus[this_sys_id]['monsterThreat'])
continue
found_fleets = []
this_fleet_list = FleetUtilsAI.get_fleets_for_mission(nships=1, target_stats={}, min_stats={}, cur_stats={}, species="", systems_to_check=[this_sys_id], systems_checked=[],
fleet_pool_set=available_scouts, fleet_list=found_fleets, verbose=False)
if not this_fleet_list:
print "seem to have run out of scouts while trying to cover sys_id %d" % this_sys_id
break # must have ran out of scouts
fleet_id = this_fleet_list[0]
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
target = AITarget.AITarget(TargetType.TARGET_SYSTEM, this_sys_id)
if len(MoveUtilsAI.can_travel_to_system_and_return_to_resupply(fleet_id, fleet_mission.get_location_target(), target)) > 0:
fleet_mission.add_target(AIFleetMissionType.FLEET_MISSION_EXPLORATION, target)
sent_list.append(this_sys_id)
else: # system too far out, skip it, but can add scout back to available pool
print "sys_id %d too far out for fleet ( ID %d ) to reach" % (this_sys_id, fleet_id)
available_scouts.update(this_fleet_list)
print "sent scouting fleets to sysIDs : %s" % sent_list
return
# pylint: disable=pointless-string-statement
"""
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
if not fleet_ids:
return
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
for planet_id, pscore, ptroops in evaluated_planets:
if pscore < MIN_INVASION_SCORE:
continue
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {"rating": 0, "troopCapacity": ptroops}
target_stats = {
"rating": 10,
"troopCapacity": ptroops + _TROOPS_SAFETY_MARGIN,
"target_system": TargetSystem(sys_id),
}
these_fleets = FleetUtilsAI.get_fleets_for_mission(
target_stats,
min_stats,
found_stats,
starting_system=sys_id,
fleet_pool_set=invasion_fleet_pool,
fleet_list=found_fleets,
)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
debug(
"Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s"
% (sys_id, universe.getSystem(sys_id).name, min_stats,
found_stats))
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = TargetPlanet(planet_id)
debug("assigning invasion fleets %s to target %s" %
(these_fleets, target))
aistate = get_aistate()
for fleetID in these_fleets:
fleet_mission = aistate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
fleet_mission.set_target(mission_type, target)
def send_invasion_fleets(fleet_ids, evaluated_planets, mission_type):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
if not fleet_ids:
return
universe = fo.getUniverse()
invasion_fleet_pool = set(fleet_ids)
for planet_id, pscore, ptroops in evaluated_planets:
if pscore < MIN_INVASION_SCORE:
continue
planet = universe.getPlanet(planet_id)
if not planet:
continue
sys_id = planet.systemID
found_fleets = []
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': ptroops}
target_stats = {'rating': 10,
'troopCapacity': ptroops + _TROOPS_SAFETY_MARGIN,
'target_system': TargetSystem(sys_id)}
these_fleets = FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=invasion_fleet_pool,
fleet_list=found_fleets)
if not these_fleets:
if not FleetUtilsAI.stats_meet_reqs(found_stats, min_stats):
debug("Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s" % (
sys_id, universe.getSystem(sys_id).name, min_stats, found_stats))
invasion_fleet_pool.update(found_fleets)
continue
else:
these_fleets = found_fleets
target = TargetPlanet(planet_id)
debug("assigning invasion fleets %s to target %s" % (these_fleets, target))
aistate = get_aistate()
for fleetID in these_fleets:
fleet_mission = aistate.get_fleet_mission(fleetID)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
fleet_mission.set_target(mission_type, target)
def send_invasion_fleets(invasionFleetIDs, evaluatedPlanets, missionType):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
universe=fo.getUniverse()
invasionPool = invasionFleetIDs[:] #need to make a copy
bestShip, bestDesign, buildChoices = ProductionAI.getBestShipInfo( EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_INVASION)
if bestDesign:
troopsPerBestShip = 2*( list(bestDesign.parts).count("GT_TROOP_POD") )
else:
troopsPerBestShip=5 #may actually not have any troopers available, but this num will do for now
#sortedTargets=sorted( [ ( pscore-ptroops/2 , pID, pscore, ptroops) for pID, pscore, ptroops in evaluatedPlanets ] , reverse=True)
invasionPool=set(invasionPool)
for pID, pscore, ptroops in evaluatedPlanets: #
if not invasionPool: return
planet=universe.getPlanet(pID)
if not planet: continue
sysID = planet.systemID
foundFleets = []
podsNeeded= math.ceil( (ptroops+0.05)/2.0)
foundStats={}
minStats= {'rating':0, 'troopPods':podsNeeded}
targetStats={'rating':10,'troopPods':podsNeeded+1}
theseFleets = FleetUtilsAI.get_fleets_for_mission(1, targetStats , minStats, foundStats, "", systems_to_check=[sysID], systems_checked=[], fleet_pool_set=invasionPool, fleet_list=foundFleets, verbose=False)
if not theseFleets:
if not FleetUtilsAI.stats_meet_reqs(foundStats, minStats):
print "Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s"%(sysID, universe.getSystem(sysID).name, minStats, foundStats)
invasionPool.update( foundFleets )
continue
else:
theseFleets = foundFleets
aiTarget = AITarget.AITarget(EnumsAI.AITargetType.TARGET_PLANET, pID)
print "assigning invasion fleets %s to target %s"%(theseFleets, aiTarget)
for fleetID in theseFleets:
fleet=universe.getFleet(fleetID)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
aiFleetMission.clear_fleet_orders()
aiFleetMission.clear_targets( (aiFleetMission.get_mission_types() + [-1])[0] )
aiFleetMission.add_target(missionType, aiTarget)
def send_invasion_fleets(invasionFleetIDs, evaluatedPlanets, missionType):
"""sends a list of invasion fleets to a list of planet_value_pairs"""
universe=fo.getUniverse()
invasionPool = invasionFleetIDs[:] #need to make a copy
bestShip, bestDesign, buildChoices = ProductionAI.getBestShipInfo( EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_INVASION)
if bestDesign:
troopsPerBestShip = 2*( list(bestDesign.parts).count("GT_TROOP_POD") )
else:
troopsPerBestShip=5 #may actually not have any troopers available, but this num will do for now
#sortedTargets=sorted( [ ( pscore-ptroops/2 , pID, pscore, ptroops) for pID, pscore, ptroops in evaluatedPlanets ] , reverse=True)
invasionPool=set(invasionPool)
for pID, pscore, ptroops in evaluatedPlanets: #
if not invasionPool: return
planet=universe.getPlanet(pID)
if not planet: continue
sysID = planet.systemID
foundFleets = []
podsNeeded= math.ceil( (ptroops+0.05)/2.0)
foundStats={}
minStats= {'rating':0, 'troopPods':podsNeeded}
targetStats={'rating':10,'troopPods':podsNeeded+1}
theseFleets = FleetUtilsAI.get_fleets_for_mission(1, targetStats , minStats, foundStats, "", systems_to_check=[sysID], systems_checked=[], fleet_pool_set=invasionPool, fleet_list=foundFleets, verbose=False)
if not theseFleets:
if not FleetUtilsAI.stats_meet_reqs(foundStats, minStats):
print "Insufficient invasion troop allocation for system %d ( %s ) -- requested %s , found %s"%(sysID, universe.getSystem(sysID).name, minStats, foundStats)
invasionPool.update( foundFleets )
continue
else:
theseFleets = foundFleets
aiTarget = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, pID)
print "assigning invasion fleets %s to target %s"%(theseFleets, aiTarget)
for fleetID in theseFleets:
fleet=universe.getFleet(fleetID)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
aiFleetMission.clear_fleet_orders()
aiFleetMission.clear_targets( (aiFleetMission.get_mission_types() + [-1])[0] )
aiFleetMission.add_target(missionType, aiTarget)
def _check_retarget_invasion(self):
"""checks if an invasion mission should be retargeted"""
universe = fo.getUniverse()
empire_id = fo.empireID()
fleet_id = self.fleet.id
fleet = universe.getFleet(fleet_id)
if fleet.systemID == INVALID_ID:
# next_loc = fleet.nextSystemID
return # TODO: still check
system = universe.getSystem(fleet.systemID)
if not system:
return
orders = self.orders
last_sys_target = INVALID_ID
if orders:
last_sys_target = orders[-1].target.id
if last_sys_target == fleet.systemID:
return # TODO: check for best local target
open_targets = []
already_targeted = InvasionAI.get_invasion_targeted_planet_ids(
system.planetIDs, MissionType.INVASION)
aistate = get_aistate()
for pid in system.planetIDs:
if pid in already_targeted or (
pid in aistate.qualifyingTroopBaseTargets):
continue
planet = universe.getPlanet(pid)
if planet.unowned or (planet.owner == empire_id):
continue
if (planet.initialMeterValue(fo.meterType.shield)) <= 0:
open_targets.append(pid)
if not open_targets:
return
troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id)
target_id = INVALID_ID
best_score = -1
target_troops = 0
#
for pid, rating in InvasionAI.assign_invasion_values(
open_targets).items():
p_score, p_troops = rating
if p_score > best_score:
if p_troops >= troops_in_fleet:
continue
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == INVALID_ID:
return
debug("\t Splitting and retargetting fleet %d" % fleet_id)
new_fleets = FleetUtilsAI.split_fleet(fleet_id)
self.clear_target() # TODO: clear from foAIstate
self.clear_fleet_orders()
troops_needed = max(
0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id))
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
found_fleets = []
# TODO check if next statement does not mutate any global states and can be removed
_ = FleetUtilsAI.get_fleets_for_mission(
target_stats,
min_stats,
{},
starting_system=fleet.systemID, # noqa: F841
fleet_pool_set=set(new_fleets),
fleet_list=found_fleets)
for fid in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id)
target = TargetPlanet(target_id)
self.set_target(MissionType.INVASION, target)
self.generate_fleet_orders()
def _check_retarget_invasion(self):
"""checks if an invasion mission should be retargeted"""
universe = fo.getUniverse()
empire_id = fo.empireID()
fleet_id = self.fleet.id
fleet = universe.getFleet(fleet_id)
if fleet.systemID == INVALID_ID:
# next_loc = fleet.nextSystemID
return # TODO: still check
system = universe.getSystem(fleet.systemID)
if not system:
return
orders = self.orders
last_sys_target = INVALID_ID
if orders:
last_sys_target = orders[-1].target.id
if last_sys_target == fleet.systemID:
return # TODO: check for best local target
open_targets = []
already_targeted = InvasionAI.get_invasion_targeted_planet_ids(system.planetIDs, MissionType.INVASION)
aistate = get_aistate()
for pid in system.planetIDs:
if pid in already_targeted or (pid in aistate.qualifyingTroopBaseTargets):
continue
planet = universe.getPlanet(pid)
if planet.unowned or (planet.owner == empire_id):
continue
if (planet.initialMeterValue(fo.meterType.shield)) <= 0:
open_targets.append(pid)
if not open_targets:
return
troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id)
target_id = INVALID_ID
best_score = -1
target_troops = 0
#
for pid, rating in InvasionAI.assign_invasion_values(open_targets).items():
p_score, p_troops = rating
if p_score > best_score:
if p_troops >= troops_in_fleet:
continue
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == INVALID_ID:
return
debug("\t Splitting and retargetting fleet %d" % fleet_id)
new_fleets = FleetUtilsAI.split_fleet(fleet_id)
self.clear_target() # TODO: clear from foAIstate
self.clear_fleet_orders()
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id))
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
found_fleets = []
# TODO check if next statement does not mutate any global states and can be removed
_ = FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, {}, starting_system=fleet.systemID, # noqa: F841
fleet_pool_set=set(new_fleets), fleet_list=found_fleets)
for fid in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id)
target = TargetPlanet(target_id)
self.set_target(MissionType.INVASION, target)
self.generate_fleet_orders()
def assign_military_fleets_to_systems(useFleetIDList=None, allocations=None):
# assign military fleets to military theater systems
global military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (useFleetIDList is None)
if doing_main:
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(
base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = AITarget.AITarget(TargetType.TARGET_SYSTEM, sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_targets(
(fleet_mission.get_mission_types() + [-1])[0])
mission_type = AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE
fleet_mission.add_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
AIFleetMissionType.FLEET_MISSION_MILITARY)
AIstate.militaryFleetIDs = all_military_fleet_ids
if not all_military_fleet_ids:
military_allocations = []
return
avail_mil_fleet_ids = list(
FleetUtilsAI.extract_fleet_ids_without_mission_types(
all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(
avail_mil_fleet_ids)
these_allocations = military_allocations
print "=================================================="
print "assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(useFleetIDList)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(
avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
try:
these_fleets = FleetUtilsAI.get_fleets_for_mission(
1, {'rating': alloc}, {'rating': minalloc},
found_stats,
"",
systems_to_check=[sys_id],
systems_checked=[],
fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets,
verbose=False)
except:
continue
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(
found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (
sys_id, universe.getSystem(sys_id).name, minalloc,
found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
# rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, found_fleets)
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum(
[fr.get('health', 0) for fr in ratings])
if doing_main and verbose_mil_reporting:
if rating < minMilAllocations.get(sys_id, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (
sys_id, universe.getSystem(sys_id).name, minalloc,
rating, these_fleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (
sys_id, universe.getSystem(sys_id).name,
minMilAllocations.get(sys_id,
0), rating, these_fleets)
elif doing_main and verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (
sys_id, universe.getSystem(sys_id).name, alloc,
found_stats.get('rating', 0), these_fleets)
target = AITarget.AITarget(TargetType.TARGET_SYSTEM, sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_targets(
(fleet_mission.get_mission_types() + [-1])[0])
if sys_id in list(
set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs +
AIstate.blockadeTargetedSystemIDs)):
mission_type = AIFleetMissionType.FLEET_MISSION_SECURE
else:
mission_type = AIFleetMissionType.FLEET_MISSION_MILITARY
fleet_mission.add_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions',
[]).append(fleet_mission)
if doing_main:
print "---------------------------------"
def _check_retarget_invasion(self):
"""checks if an invasion mission should be retargeted"""
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
fleet_id = self.fleet.id
fleet = universe.getFleet(fleet_id)
if fleet.systemID == -1:
# next_loc = fleet.nextSystemID
return # TODO: still check
system = universe.getSystem(fleet.systemID)
if not system:
return
orders = self.orders
last_sys_target = -1
if orders:
last_sys_target = orders[-1].target.id
if last_sys_target == fleet.systemID:
return # TODO: check for best local target
open_targets = []
already_targeted = InvasionAI.get_invasion_targeted_planet_ids(system.planetIDs, MissionType.INVASION)
for pid in system.planetIDs:
if pid in already_targeted or (pid in foAI.foAIstate.qualifyingTroopBaseTargets):
continue
planet = universe.getPlanet(pid)
if planet.unowned or (planet.owner == empire_id):
continue
if (planet.currentMeterValue(fo.meterType.shield)) <= 0:
open_targets.append(pid)
if not open_targets:
return
troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id)
target_id = -1
best_score = -1
target_troops = 0
#
for pid, rating in InvasionAI.assign_invasion_values(open_targets, empire).items():
p_score, p_troops = rating
if p_score > best_score:
if p_troops >= troops_in_fleet:
continue
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == -1:
return
print "\t AIFleetMission._check_retarget_invasion: splitting and retargetting fleet %d" % fleet_id
new_fleets = FleetUtilsAI.split_fleet(fleet_id)
self.clear_target() # TODO: clear from foAIstate
self.clear_fleet_orders()
# pods_needed = max(0, math.ceil((target_troops - 2 * (FleetUtilsAI.count_parts_fleetwide(fleet_id, ["GT_TROOP_POD"])) + 0.05) / 2.0))
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
found_fleets = []
# TODO check if next statement does not mutate any global states and can be removed
_ = FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[fleet.systemID], systems_checked=[],
fleet_pool_set=set(new_fleets), fleet_list=found_fleets,
verbose=False)
for fid in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id)
target = Planet(target_id)
self.add_target(MissionType.INVASION, target)
self.generate_fleet_orders()
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global _military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
if doing_main:
foAI.foAIstate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = universe_object.System(sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.set_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
_military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = _military_allocations
print "=================================================="
print "Assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, rvp, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
these_fleets = FleetUtilsAI.get_fleets_for_mission({'rating': alloc, 'ratingVsPlanets': rvp},
{'rating': minalloc, 'ratingVsPlanets': rvp}, found_stats,
starting_system=sys_id, fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets)
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if _verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
elif doing_main and _verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets)
target = universe_object.System(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs):
mission_type = MissionType.SECURE
else:
mission_type = MissionType.MILITARY
fleet_mission.set_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
print "---------------------------------"
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
print "Still have available military fleets: %s" % avail_mil_fleet_ids
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
def send_colony_ships(colony_fleet_ids, evaluated_planets, mission_type):
"""sends a list of colony ships to a list of planet_value_pairs"""
fleet_pool = colony_fleet_ids[:]
try_all = False
if mission_type == MissionType.OUTPOST:
cost = 20 + outpod_pod_cost()
else:
try_all = True
cost = 20 + colony_pod_cost_turns()[1]
if fo.currentTurn() < 50:
cost *= 0.4 # will be making fast tech progress so value is underestimated
elif fo.currentTurn() < 80:
cost *= 0.8 # will be making fast-ish tech progress so value is underestimated
potential_targets = [
(pid, (score, specName))
for (pid, (score, specName)) in evaluated_planets
if score > (0.8 * cost) and score > MINIMUM_COLONY_SCORE
]
debug("Colony/outpost ship matching: fleets %s to planets %s" % (fleet_pool, evaluated_planets))
if try_all:
debug("Trying best matches to current colony ships")
best_scores = dict(evaluated_planets)
potential_targets = []
for pid, ratings in _all_colony_opportunities.items():
for rating in ratings:
if rating[0] >= 0.75 * best_scores.get(pid, [9999])[0]:
potential_targets.append((pid, rating))
potential_targets.sort(key=itemgetter(1), reverse=True)
# added a lot of checking because have been getting mysterious exception, after too many recursions to get info
fleet_pool = set(fleet_pool)
universe = fo.getUniverse()
for fid in fleet_pool:
fleet = universe.getFleet(fid)
if not fleet or fleet.empty:
warning("Bad fleet ( ID %d ) given to colonization routine; will be skipped" % fid)
fleet_pool.remove(fid)
continue
report_str = "Fleet ID (%d): %d ships; species: " % (fid, fleet.numShips)
for sid in fleet.shipIDs:
ship = universe.getShip(sid)
if not ship:
report_str += "NoShip, "
else:
report_str += "%s, " % ship.speciesName
debug(report_str)
debug("")
already_targeted = []
# for planetID_value_pair in evaluatedPlanets:
aistate = get_aistate()
while fleet_pool and potential_targets:
target = potential_targets.pop(0)
if target in already_targeted:
continue
planet_id = target[0]
if planet_id in already_targeted:
continue
planet = universe.getPlanet(planet_id)
sys_id = planet.systemID
if (
aistate.systemStatus.setdefault(sys_id, {}).setdefault("monsterThreat", 0) > 2000
or fo.currentTurn() < 20
and aistate.systemStatus[sys_id]["monsterThreat"] > 200
):
debug(
"Skipping colonization of system %s due to Big Monster, threat %d"
% (universe.getSystem(sys_id), aistate.systemStatus[sys_id]["monsterThreat"])
)
already_targeted.append(planet_id)
continue
# make sure not to run into stationary guards
if ExplorationAI.system_could_have_unknown_stationary_guard(sys_id):
ExplorationAI.request_emergency_exploration(sys_id)
continue
this_spec = target[1][1]
found_fleets = []
try:
this_fleet_list = FleetUtilsAI.get_fleets_for_mission(
target_stats={},
min_stats={},
cur_stats={},
starting_system=sys_id,
species=this_spec,
fleet_pool_set=fleet_pool,
fleet_list=found_fleets,
)
except Exception as e:
error(e, exc_info=True)
continue
if not this_fleet_list:
fleet_pool.update(found_fleets) # just to be safe
continue # must have no compatible colony/outpost ships
fleet_id = this_fleet_list[0]
already_targeted.append(planet_id)
ai_target = TargetPlanet(planet_id)
aistate.get_fleet_mission(fleet_id).set_target(mission_type, ai_target)
def _check_retarget_invasion(self):
"""checks if an invasion mission should be retargeted"""
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
fleet_id = self.fleet.id
fleet = universe.getFleet(fleet_id)
if fleet.systemID == -1:
# next_loc = fleet.nextSystemID
return # TODO: still check
system = universe.getSystem(fleet.systemID)
if not system:
return
orders = self.orders
last_sys_target = -1
if orders:
last_sys_target = orders[-1].target.id
if last_sys_target == fleet.systemID:
return # TODO: check for best local target
open_targets = []
already_targeted = InvasionAI.get_invasion_targeted_planet_ids(
system.planetIDs, MissionType.INVASION)
for pid in system.planetIDs:
if pid in already_targeted or (
pid in foAI.foAIstate.qualifyingTroopBaseTargets):
continue
planet = universe.getPlanet(pid)
if planet.unowned or (planet.owner == empire_id):
continue
if (planet.currentMeterValue(fo.meterType.shield)) <= 0:
open_targets.append(pid)
if not open_targets:
return
troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id)
target_id = -1
best_score = -1
target_troops = 0
#
for pid, rating in InvasionAI.assign_invasion_values(
open_targets, empire).items():
p_score, p_troops = rating
if p_score > best_score:
if p_troops >= troops_in_fleet:
continue
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == -1:
return
print "\t AIFleetMission._check_retarget_invasion: splitting and retargetting fleet %d" % fleet_id
new_fleets = FleetUtilsAI.split_fleet(fleet_id)
self.clear_target() # TODO: clear from foAIstate
self.clear_fleet_orders()
# pods_needed = max(0, math.ceil((target_troops - 2 * (FleetUtilsAI.count_parts_fleetwide(fleet_id, ["GT_TROOP_POD"])) + 0.05) / 2.0))
troops_needed = max(
0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
found_fleets = []
# TODO check if next statement does not mutate any global states and can be removed
_ = FleetUtilsAI.get_fleets_for_mission(
1,
target_stats,
min_stats,
found_stats,
"",
systems_to_check=[fleet.systemID],
systems_checked=[],
fleet_pool_set=set(new_fleets),
fleet_list=found_fleets,
verbose=False)
for fid in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id)
target = Planet(target_id)
self.add_target(MissionType.INVASION, target)
self.generate_fleet_orders()
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global _military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
aistate = get_aistate()
if doing_main:
aistate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = TargetSystem(sys_id)
fleet_mission = aistate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.set_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
_military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = _military_allocations
debug("==================================================")
debug("Assigning military fleets")
debug("---------------------------------")
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, rvp, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
debug("Allocating for: %s", TargetSystem(sys_id))
found_fleets = []
found_stats = {}
ensure_return = sys_id not in set(AIstate.colonyTargetedSystemIDs
+ AIstate.outpostTargetedSystemIDs
+ AIstate.invasionTargetedSystemIDs)
these_fleets = FleetUtilsAI.get_fleets_for_mission(
target_stats={'rating': alloc, 'ratingVsPlanets': rvp, 'target_system': TargetSystem(sys_id)},
min_stats={'rating': minalloc, 'ratingVsPlanets': rvp, 'target_system': TargetSystem(sys_id)},
cur_stats=found_stats, starting_system=sys_id, fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets, ensure_return=ensure_return)
if not these_fleets:
debug("Could not allocate any fleets.")
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if _verbose_mil_reporting:
debug("NO available/suitable military allocation for system %d ( %s ) "
"-- requested allocation %8d, found available rating %8d in fleets %s"
% (sys_id, universe.getSystem(sys_id).name, minalloc,
found_stats.get('rating', 0), found_fleets))
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
else:
debug("Assigning fleets %s to target %s", these_fleets, TargetSystem(sys_id))
if doing_main and _verbose_mil_reporting:
debug("FULL+ military allocation for system %d ( %s )"
" -- requested allocation %8d, got %8d with fleets %s"
% (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets))
target = TargetSystem(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = aistate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs):
mission_type = MissionType.SECURE
elif state.get_empire_planets_by_system(sys_id):
mission_type = MissionType.PROTECT_REGION
else:
mission_type = MissionType.MILITARY
fleet_mission.set_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
aistate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
debug("---------------------------------")
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
debug("Round %s - still have available military fleets: %s", thisround, avail_mil_fleet_ids)
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
else:
# assign remaining fleets to nearest systems to protect.
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
def system_score(_fid, _sys_id):
"""Helper function to rank systems by priority"""
jump_distance = universe.jumpDistance(_fid, _sys_id)
if get_system_local_threat(_sys_id):
weight = 10
elif get_system_neighbor_threat(_sys_id):
weight = 3
elif get_system_jump2_threat(_sys_id):
weight = 1
else:
weight = 1 / max(.5, float(state.get_distance_to_enemy_supply(_sys_id)))**1.25
return float(weight) / (jump_distance+1)
for fid in avail_mil_fleet_ids:
fleet = universe.getFleet(fid)
FleetUtilsAI.get_fleet_system(fleet)
systems = state.get_empire_planets_by_system().keys()
if not systems:
continue
sys_id = max(systems, key=lambda x: system_score(fid, x))
debug("Assigning leftover %s to system %d "
"- nothing better to do.", fleet, sys_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.clear_fleet_orders()
target_system = TargetSystem(sys_id)
fleet_mission.set_target(MissionType.PROTECT_REGION, target_system)
fleet_mission.generate_fleet_orders()
def assign_invasion_fleets_to_invade():
# assign fleet targets to invadable planets
universe = fo.getUniverse()
empire = fo.getEmpire()
empireID = empire.empireID
fleetSupplyableSystemIDs = empire.fleetSupplyableSystemIDs
fleetSupplyablePlanetIDs = PlanetUtilsAI.get_planets_in__systems_ids(fleetSupplyableSystemIDs)
allTroopBaseFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION)
availTroopBaseFleetIDs = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(allTroopBaseFleetIDs))
for fid in list(availTroopBaseFleetIDs):
if fid not in availTroopBaseFleetIDs:
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sysID = fleet.systemID
system = universe.getSystem(sysID)
availPlanets = set(system.planetIDs).intersection(set( foAI.foAIstate.qualifyingTroopBaseTargets.keys()))
print "Considering Base Troopers in %s, found planets %s and regtistered targets %s with status %s"%(system.name, list(system.planetIDs), availPlanets,
[(pid, foAI.foAIstate.qualifyingTroopBaseTargets[pid]) for pid in availPlanets])
targets = [pid for pid in availPlanets if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1 ]
if not targets:
print "Error found no valid target for troop base in system %s (%d)"%(system.name, sysID)
continue
status=foAI.foAIstate.systemStatus.get( sysID, {} )
local_base_troops = set(status.get('myfleets', [])).intersection(availTroopBaseFleetIDs)
troop_pod_tally = 0
for fid2 in local_base_troops:
troop_pod_tally += FleetUtilsAI.count_parts_fleetwide(fid2, ["GT_TROOP_POD"])
targetID=-1
bestScore=-1
target_troops = 0
#
for pid, rating in assign_invasion_values(targets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, fleetSupplyablePlanetIDs, empire).items():
p_score, p_troops = rating
if p_score>bestScore:
if p_troops >= 2*troop_pod_tally:
pass
#continue
bestScore = p_score
targetID = pid
target_troops = p_troops
if targetID != -1:
local_base_troops.discard(fid)
foundFleets = []
podsNeeded= math.ceil( (target_troops - 2*(FleetUtilsAI.count_parts_fleetwide(fid, ["GT_TROOP_POD"]))+0.05)/2.0)
foundStats={}
minStats= {'rating':0, 'troopPods':podsNeeded}
targetStats={'rating':10,'troopPods':podsNeeded}
theseFleets = FleetUtilsAI.get_fleets_for_mission(1, targetStats , minStats, foundStats, "", systems_to_check=[sysID], systems_checked=[], fleet_pool_set=local_base_troops, fleet_list=foundFleets, verbose=False)
for fid2 in foundFleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
availTroopBaseFleetIDs.discard(fid2)
availTroopBaseFleetIDs.discard(fid)
foAI.foAIstate.qualifyingTroopBaseTargets[targetID][1] = -1 #TODO: should probably delete
aiTarget = AITarget.AITarget(EnumsAI.AITargetType.TARGET_PLANET, targetID)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fid)
aiFleetMission.add_target(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION, aiTarget)
invasionFleetIDs = AIstate.invasionFleetIDs
send_invasion_fleets(invasionFleetIDs, AIstate.invasionTargets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
allInvasionFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(allInvasionFleetIDs):
thisMission = foAI.foAIstate.get_fleet_mission(fid)
thisMission.check_mergers(context="Post-send consolidation of unassigned troops")
def assign_scouts_to_explore_systems():
# TODO: use Graph Theory to explore closest systems
universe = fo.getUniverse()
capital_sys_id = PlanetUtilsAI.get_capital_sys_id()
# order fleets to explore
if not border_unexplored_system_ids or (capital_sys_id == INVALID_ID):
return
exp_systems_by_dist = sorted((universe.linearDistance(capital_sys_id, x), x) for x in border_unexplored_system_ids)
print "Exploration system considering following system-distance pairs:\n %s" % ("\n ".join("%3d: %5.1f" % info for info in exp_systems_by_dist))
explore_list = [sys_id for dist, sys_id in exp_systems_by_dist]
already_covered, available_scouts = get_current_exploration_info()
print "Explorable system IDs: %s" % explore_list
print "Already targeted: %s" % already_covered
needs_vis = foAI.foAIstate.misc.setdefault('needs_vis', [])
check_list = foAI.foAIstate.needsEmergencyExploration + needs_vis + explore_list
if INVALID_ID in check_list: # shouldn't normally happen, unless due to bug elsewhere
for sys_list, name in [(foAI.foAIstate.needsEmergencyExploration, "foAI.foAIstate.needsEmergencyExploration"), (needs_vis, "needs_vis"), (explore_list, "explore_list")]:
if INVALID_ID in sys_list:
print_error("INVALID_ID found in " + name)
needs_coverage = [sys_id for sys_id in check_list if sys_id not in already_covered and sys_id != INVALID_ID] # emergency coverage can be due to invasion detection trouble, etc.
print "Needs coverage: %s" % needs_coverage
print "Available scouts & AIstate locs: %s" % [(x, foAI.foAIstate.fleetStatus.get(x, {}).get('sysID', INVALID_ID)) for x in available_scouts]
print "Available scouts & universe locs: %s" % [(x, universe.getFleet(x).systemID) for x in available_scouts]
if not needs_coverage or not available_scouts:
return
available_scouts = set(available_scouts)
sent_list = []
while available_scouts and needs_coverage:
this_sys_id = needs_coverage.pop(0)
sys_status = foAI.foAIstate.systemStatus.setdefault(this_sys_id, {})
if this_sys_id not in explore_list: # doesn't necessarily need direct visit
if universe.getVisibility(this_sys_id, fo.empireID()) >= fo.visibility.partial:
# already got visibility; remove from visit lists and skip
if this_sys_id in needs_vis:
del needs_vis[needs_vis.index(this_sys_id)]
if this_sys_id in foAI.foAIstate.needsEmergencyExploration:
del foAI.foAIstate.needsEmergencyExploration[
foAI.foAIstate.needsEmergencyExploration.index(this_sys_id)]
print "system id %d already currently visible; skipping exploration" % this_sys_id
continue
# TODO: if blocked byu monster, try to find nearby system from which to see this system
if not foAI.foAIstate.character.may_explore_system(sys_status.setdefault('monsterThreat', 0)) or (fo.currentTurn() < 20 and foAI.foAIstate.systemStatus[this_sys_id]['monsterThreat'] > 200):
print "Skipping exploration of system %d due to Big Monster, threat %d" % (this_sys_id, foAI.foAIstate.systemStatus[this_sys_id]['monsterThreat'])
continue
this_fleet_list = FleetUtilsAI.get_fleets_for_mission(target_stats={}, min_stats={}, cur_stats={},
starting_system=this_sys_id, fleet_pool_set=available_scouts,
fleet_list=[])
if not this_fleet_list:
print "Seem to have run out of scouts while trying to cover sys_id %d" % this_sys_id
break # must have ran out of scouts
fleet_id = this_fleet_list[0]
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
target = universe_object.System(this_sys_id)
if len(MoveUtilsAI.can_travel_to_system_and_return_to_resupply(fleet_id, fleet_mission.get_location_target(), target)) > 0:
fleet_mission.set_target(MissionType.EXPLORATION, target)
sent_list.append(this_sys_id)
else: # system too far out, skip it, but can add scout back to available pool
print "sys_id %d too far out for fleet ( ID %d ) to reach" % (this_sys_id, fleet_id)
available_scouts.update(this_fleet_list)
print "Sent scouting fleets to sysIDs : %s" % sent_list
return
# pylint: disable=pointless-string-statement
"""
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
if doing_main:
foAI.foAIstate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = universe_object.System(sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.add_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = military_allocations
print "=================================================="
print "Assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
try:
these_fleets = FleetUtilsAI.get_fleets_for_mission(1, {'rating': alloc}, {'rating': minalloc}, found_stats, "", systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=avail_mil_fleet_ids, fleet_list=found_fleets, verbose=False)
except:
continue
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
# rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, found_fleets)
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum([fr.get('health', 0) for fr in ratings])
if doing_main and verbose_mil_reporting:
if rating < minMilAllocations.get(sys_id, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, rating, these_fleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, minMilAllocations.get(sys_id, 0), rating, these_fleets)
elif doing_main and verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets)
target = universe_object.System(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)):
mission_type = MissionType.SECURE
else:
mission_type = MissionType.MILITARY
fleet_mission.add_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
print "---------------------------------"
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
print "Still have available military fleets: %s" % avail_mil_fleet_ids
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
def assign_invasion_fleets_to_invade():
"""Assign fleet targets to invadable planets."""
universe = fo.getUniverse()
empire = fo.getEmpire()
fleet_suppliable_system_ids = empire.fleetSupplyableSystemIDs
fleet_suppliable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(fleet_suppliable_system_ids)
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.
FLEET_MISSION_ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # TODO: I do not see how this check makes sense, maybe remove?
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()))
print "Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, foAI.foAIstate.qualifyingTroopBaseTargets[pid]) for pid in available_planets])
targets = [pid for pid in available_planets if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
print "Error: found no valid target for troop base in system %s (%d)" % (system.name, sys_id)
continue
status = foAI.foAIstate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
troop_capacity_tally = 0
for fid2 in local_base_troops:
troop_capacity_tally += FleetUtilsAI.count_troops_in_fleet(fid2)
target_id = -1
best_score = -1
target_troops = 0
for pid, rating in assign_invasion_values(targets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION,
fleet_suppliable_planet_ids, empire).items():
p_score, p_troops = rating
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id != -1:
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=local_base_troops, fleet_list=found_fleets,
verbose=False)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
foAI.foAIstate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, target_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fid)
fleet_mission.add_target(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION, target)
invasion_fleet_ids = AIstate.invasionFleetIDs
send_invasion_fleets(invasion_fleet_ids, AIstate.invasionTargets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids):
this_mission = foAI.foAIstate.get_fleet_mission(fid)
this_mission.check_mergers(context="Post-send consolidation of unassigned troops")
def assign_military_fleets_to_systems(useFleetIDList=None, allocations=None):
# assign military fleets to military theater systems
global MilitaryAllocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doingMain = (useFleetIDList is None)
if doingMain:
baseDefenseIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE)
unassignedBaseDefenseIDs = FleetUtilsAI.extract_fleet_ids_without_mission_types(baseDefenseIDs)
for fleetID in unassignedBaseDefenseIDs:
fleet = universe.getFleet(fleetID)
if not fleet:
continue
sysID = fleet.systemID
aiTarget = AITarget.AITarget(AITargetType.TARGET_SYSTEM, sysID)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
aiFleetMission.clear_fleet_orders()
aiFleetMission.clear_targets( (aiFleetMission.get_mission_types() + [-1])[0] )
missionType = AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE
aiFleetMission.add_target( missionType , aiTarget)
allMilitaryFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_MILITARY)
AIstate.militaryFleetIDs = allMilitaryFleetIDs
if not allMilitaryFleetIDs:
MilitaryAllocations = []
return
availMilFleetIDs = list( FleetUtilsAI.extract_fleet_ids_without_mission_types(allMilitaryFleetIDs) )
mil_needing_repair_ids, availMilFleetIDs = avail_mil_needing_repair(availMilFleetIDs)
availMilRating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), availMilFleetIDs ) )
under_repair_mil_rating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), mil_needing_repair_ids ) )
theseAllocations = MilitaryAllocations
print "=================================================="
print "assigning military fleets"
print "---------------------------------"
else:
availMilFleetIDs = list( useFleetIDList )
mil_needing_repair_ids, availMilFleetIDs = avail_mil_needing_repair(availMilFleetIDs)
availMilRating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), availMilFleetIDs ) )
theseAllocations = allocations
remainingMilRating = availMilRating
#send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
availMilFleetIDs = set(availMilFleetIDs)
for sysID, alloc, minalloc, takeAny in theseAllocations:
if not doingMain and len(availMilFleetIDs)==0:
break
foundFleets = []
foundStats={}
try:
theseFleets = FleetUtilsAI.get_fleets_for_mission(1, {'rating':alloc}, {'rating':minalloc}, foundStats, "", systems_to_check=[sysID], systems_checked=[],
fleet_pool_set=availMilFleetIDs, fleet_list=foundFleets, verbose=False)
except:
continue
if not theseFleets:
if foundFleets==[] or not ( FleetUtilsAI.stats_meet_reqs( foundStats, {'rating':minalloc}) or takeAny):
if doingMain:
if verboseMilReporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s"%(sysID, universe.getSystem(sysID).name, minalloc, foundStats.get('rating', 0), foundFleets)
availMilFleetIDs.update(foundFleets)
continue
else:
theseFleets = foundFleets
#rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, foundFleets )
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum([fr.get('health', 0) for fr in ratings])
if doingMain and verboseMilReporting:
if rating < minMilAllocations.get(sysID, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s"%(sysID, universe.getSystem(sysID).name, minalloc, rating, theseFleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s "%(sysID, universe.getSystem(sysID).name, minMilAllocations.get(sysID, 0) , rating, theseFleets)
elif doingMain and verboseMilReporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s"%(sysID, universe.getSystem(sysID).name, alloc, foundStats.get('rating', 0), theseFleets)
aiTarget = AITarget.AITarget(AITargetType.TARGET_SYSTEM, sysID)
for fleetID in theseFleets:
fleet=universe.getFleet(fleetID)
fo.issueAggressionOrder(fleetID, True)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
aiFleetMission.clear_fleet_orders()
aiFleetMission.clear_targets( (aiFleetMission.get_mission_types() + [-1])[0] )
if sysID in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)):
missionType = AIFleetMissionType.FLEET_MISSION_SECURE
else:
missionType = AIFleetMissionType.FLEET_MISSION_MILITARY
aiFleetMission.add_target( missionType , aiTarget)
aiFleetMission.generate_fleet_orders()
if not doingMain:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(aiFleetMission)
if doingMain:
print "---------------------------------"
def assign_invasion_fleets_to_invade():
"""Assign fleet targets to invadable planets."""
universe = fo.getUniverse()
empire = fo.getEmpire()
fleet_suppliable_system_ids = empire.fleetSupplyableSystemIDs
fleet_suppliable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(fleet_suppliable_system_ids)
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.
FLEET_MISSION_ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # TODO: I do not see how this check makes sense, maybe remove?
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()))
print "Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, foAI.foAIstate.qualifyingTroopBaseTargets[pid]) for pid in available_planets])
targets = [pid for pid in available_planets if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
print "Error: found no valid target for troop base in system %s (%d)" % (system.name, sys_id)
continue
status = foAI.foAIstate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
troop_capacity_tally = 0
for fid2 in local_base_troops:
troop_capacity_tally += FleetUtilsAI.count_troops_in_fleet(fid2)
target_id = -1
best_score = -1
target_troops = 0
for pid, rating in assign_invasion_values(targets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION,
fleet_suppliable_planet_ids, empire).items():
p_score, p_troops = rating
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id != -1:
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=local_base_troops, fleet_list=found_fleets,
verbose=False)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
foAI.foAIstate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, target_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fid)
fleet_mission.add_target(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION, target)
invasion_fleet_ids = AIstate.invasionFleetIDs
send_invasion_fleets(invasion_fleet_ids, AIstate.invasionTargets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids):
this_mission = foAI.foAIstate.get_fleet_mission(fid)
this_mission.check_mergers(context="Post-send consolidation of unassigned troops")
def assign_invasion_fleets_to_invade():
# assign fleet targets to invadable planets
universe = fo.getUniverse()
empire = fo.getEmpire()
empireID = empire.empireID
fleetSupplyableSystemIDs = empire.fleetSupplyableSystemIDs
fleetSupplyablePlanetIDs = PlanetUtilsAI.get_planets_in__systems_ids(fleetSupplyableSystemIDs)
allTroopBaseFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION)
availTroopBaseFleetIDs = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(allTroopBaseFleetIDs))
for fid in list(availTroopBaseFleetIDs):
if fid not in availTroopBaseFleetIDs:
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sysID = fleet.systemID
system = universe.getSystem(sysID)
availPlanets = set(system.planetIDs).intersection(set( foAI.foAIstate.qualifyingTroopBaseTargets.keys()))
print "Considering Base Troopers in %s, found planets %s and regtistered targets %s with status %s"%(system.name, list(system.planetIDs), availPlanets,
[(pid, foAI.foAIstate.qualifyingTroopBaseTargets[pid]) for pid in availPlanets])
targets = [pid for pid in availPlanets if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1 ]
if not targets:
print "Error found no valid target for troop base in system %s (%d)"%(system.name, sysID)
continue
status=foAI.foAIstate.systemStatus.get( sysID, {} )
local_base_troops = set(status.get('myfleets', [])).intersection(availTroopBaseFleetIDs)
troop_pod_tally = 0
for fid2 in local_base_troops:
troop_pod_tally += FleetUtilsAI.count_parts_fleetwide(fid2, ["GT_TROOP_POD"])
targetID=-1
bestScore=-1
target_troops = 0
#
for pid, rating in assign_invasion_values(targets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, fleetSupplyablePlanetIDs, empire).items():
p_score, p_troops = rating
if p_score>bestScore:
if p_troops >= 2*troop_pod_tally:
pass
#continue
bestScore = p_score
targetID = pid
target_troops = p_troops
if targetID != -1:
local_base_troops.discard(fid)
foundFleets = []
podsNeeded= math.ceil( (target_troops - 2*(FleetUtilsAI.count_parts_fleetwide(fid, ["GT_TROOP_POD"]))+0.05)/2.0)
foundStats={}
minStats= {'rating':0, 'troopPods':podsNeeded}
targetStats={'rating':10,'troopPods':podsNeeded}
theseFleets = FleetUtilsAI.get_fleets_for_mission(1, targetStats , minStats, foundStats, "", systems_to_check=[sysID], systems_checked=[], fleet_pool_set=local_base_troops, fleet_list=foundFleets, verbose=False)
for fid2 in foundFleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
availTroopBaseFleetIDs.discard(fid2)
availTroopBaseFleetIDs.discard(fid)
foAI.foAIstate.qualifyingTroopBaseTargets[targetID][1] = -1 #TODO: should probably delete
aiTarget = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, targetID)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fid)
aiFleetMission.add_target(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION, aiTarget)
invasionFleetIDs = AIstate.invasionFleetIDs
send_invasion_fleets(invasionFleetIDs, AIstate.invasionTargets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
allInvasionFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(allInvasionFleetIDs):
thisMission = foAI.foAIstate.get_fleet_mission(fid)
thisMission.check_mergers(context="Post-send consolidation of unassigned troops")
def assign_scouts_to_explore_systems():
# TODO: use Graph Theory to explore closest systems
universe = fo.getUniverse()
capital_sys_id = PlanetUtilsAI.get_capital_sys_id()
# order fleets to explore
# explorable_system_ids = foAI.foAIstate.get_explorable_systems(AIExplorableSystemType.EXPLORABLE_SYSTEM_UNEXPLORED)
explorable_system_ids = list(borderUnexploredSystemIDs)
if not explorable_system_ids or (capital_sys_id == -1):
return
exp_systems_by_dist = sorted(map(lambda x: (universe.linearDistance(capital_sys_id, x), x), explorable_system_ids))
print "Exploration system considering following system-distance pairs:\n %s" % (
"[ " + ", ".join(["%3d : %5.1f" % (sys, dist) for dist, sys in exp_systems_by_dist]) + " ]"
)
explore_list = [sys_id for dist, sys_id in exp_systems_by_dist]
already_covered, available_scouts = get_current_exploration_info()
print "explorable sys IDs: %s" % explore_list
print "already targeted: %s" % already_covered
if "needsEmergencyExploration" not in dir(foAI.foAIstate):
foAI.foAIstate.needsEmergencyExploration = []
needs_vis = foAI.foAIstate.misc.setdefault("needs_vis", [])
check_list = foAI.foAIstate.needsEmergencyExploration + needs_vis + explore_list
needs_coverage = [
sys_id for sys_id in check_list if sys_id not in already_covered
] # emergency coverage cane be due to invasion detection trouble, etc.
print "needs coverage: %s" % needs_coverage
print "available scouts & AIstate locs: %s" % (
map(lambda x: (x, foAI.foAIstate.fleetStatus.get(x, {}).get("sysID", -1)), available_scouts)
)
print "available scouts & universe locs: %s" % (map(lambda x: (x, universe.getFleet(x).systemID), available_scouts))
if not needs_coverage or not available_scouts:
return
available_scouts = set(available_scouts)
sent_list = []
while (len(available_scouts) > 0) and (len(needs_coverage) > 0):
this_sys_id = needs_coverage.pop(0)
sys_status = foAI.foAIstate.systemStatus.setdefault(this_sys_id, {})
if this_sys_id not in explore_list: # doesn't necessarily need direct visit
if universe.getVisibility(this_sys_id, fo.empireID()) >= fo.visibility.partial:
# already got visibility; remove from visit lists and skip
if this_sys_id in needs_vis:
del needs_vis[needs_vis.index(this_sys_id)]
if this_sys_id in foAI.foAIstate.needsEmergencyExploration:
del foAI.foAIstate.needsEmergencyExploration[
foAI.foAIstate.needsEmergencyExploration.index(this_sys_id)
]
print "sys id %d already currently visible; skipping exploration" % this_sys_id
continue
# TODO: if blocked byu monster, try to find nearby sys from which to see this sys
if (sys_status.setdefault("monsterThreat", 0) > 2000 * foAI.foAIstate.aggression) or (
fo.currentTurn() < 20 and foAI.foAIstate.systemStatus[this_sys_id]["monsterThreat"] > 200
):
print "Skipping exploration of system %d due to Big Monster, threat %d" % (
this_sys_id,
foAI.foAIstate.systemStatus[this_sys_id]["monsterThreat"],
)
continue
found_fleets = []
this_fleet_list = FleetUtilsAI.get_fleets_for_mission(
nships=1,
target_stats={},
min_stats={},
cur_stats={},
species="",
systems_to_check=[this_sys_id],
systems_checked=[],
fleet_pool_set=available_scouts,
fleet_list=found_fleets,
verbose=False,
)
if not this_fleet_list:
print "seem to have run out of scouts while trying to cover sys_id %d" % this_sys_id
break # must have ran out of scouts
fleet_id = this_fleet_list[0]
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
target = universe_object.System(this_sys_id)
if (
len(
MoveUtilsAI.can_travel_to_system_and_return_to_resupply(
fleet_id, fleet_mission.get_location_target(), target
)
)
> 0
):
fleet_mission.add_target(AIFleetMissionType.FLEET_MISSION_EXPLORATION, target)
sent_list.append(this_sys_id)
else: # system too far out, skip it, but can add scout back to available pool
print "sys_id %d too far out for fleet ( ID %d ) to reach" % (this_sys_id, fleet_id)
available_scouts.update(this_fleet_list)
print "sent scouting fleets to sysIDs : %s" % sent_list
return
# pylint: disable=pointless-string-statement
"""
