def allocate(self, group, sys_id, min_rating, min_rating_vs_planets, take_any, max_rating):
tup = (sys_id, min_rating, min_rating_vs_planets, take_any, max_rating)
self.allocations.append(tup)
self.allocation_by_groups.setdefault(group, []).append(tup)
if self._remaining_rating <= min_rating:
self._remaining_rating = 0
else:
self._remaining_rating = rating_difference(self._remaining_rating, min_rating)
def get_military_fleets(mil_fleets_ids=None, try_reset=True, thisround="Main"):
"""Get armed military fleets."""
global _military_allocations
universe = fo.getUniverse()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
all_military_fleet_ids = (mil_fleets_ids if mil_fleets_ids is not None
else FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
if try_reset and (fo.currentTurn() + empire_id) % 30 == 0 and thisround == "Main":
try_again(all_military_fleet_ids, try_reset=False, thisround=thisround + " Reset")
return
mil_fleets_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, mil_fleets_ids = avail_mil_needing_repair(mil_fleets_ids, split_ships=True)
avail_mil_rating = combine_ratings_list(map(CombatRatingsAI.get_fleet_rating, mil_fleets_ids))
if not mil_fleets_ids:
if "Main" in thisround:
_military_allocations = []
return []
# for each system, get total rating of fleets assigned to it
already_assigned_rating = {}
already_assigned_rating_vs_planets = {}
aistate = get_aistate()
systems_status = aistate.systemStatus
enemy_sup_factor = {} # enemy supply
for sys_id in universe.systemIDs:
already_assigned_rating[sys_id] = 0
already_assigned_rating_vs_planets[sys_id] = 0
enemy_sup_factor[sys_id] = min(2, len(systems_status.get(sys_id, {}).get('enemies_nearly_supplied', [])))
for fleet_id in [fid for fid in all_military_fleet_ids if fid not in mil_fleets_ids]:
ai_fleet_mission = aistate.get_fleet_mission(fleet_id)
if not ai_fleet_mission.target: # shouldn't really be possible
continue
last_sys = ai_fleet_mission.target.get_system().id # will count this fleet as assigned to last system in target list # TODO last_sys or target sys?
this_rating = CombatRatingsAI.get_fleet_rating(fleet_id)
this_rating_vs_planets = CombatRatingsAI.get_fleet_rating_against_planets(fleet_id)
already_assigned_rating[last_sys] = CombatRatingsAI.combine_ratings(
already_assigned_rating.get(last_sys, 0), this_rating)
already_assigned_rating_vs_planets[last_sys] = CombatRatingsAI.combine_ratings(
already_assigned_rating_vs_planets.get(last_sys, 0), this_rating_vs_planets)
for sys_id in universe.systemIDs:
my_defense_rating = systems_status.get(sys_id, {}).get('mydefenses', {}).get('overall', 0)
already_assigned_rating[sys_id] = CombatRatingsAI.combine_ratings(my_defense_rating, already_assigned_rating[sys_id])
if _verbose_mil_reporting and already_assigned_rating[sys_id]:
print "\t System %s already assigned rating %.1f" % (
universe.getSystem(sys_id), already_assigned_rating[sys_id])
# get systems to defend
capital_id = PlanetUtilsAI.get_capital()
if capital_id is not None:
capital_planet = universe.getPlanet(capital_id)
else:
capital_planet = None
# TODO: if no owned planets try to capture one!
if capital_planet:
capital_sys_id = capital_planet.systemID
else: # should be rare, but so as to not break code below, pick a randomish mil-centroid system
capital_sys_id = None # unless we can find one to use
system_dict = {}
for fleet_id in all_military_fleet_ids:
status = aistate.fleetStatus.get(fleet_id, None)
if status is not None:
system_id = status['sysID']
if not list(universe.getSystem(system_id).planetIDs):
continue
system_dict[system_id] = system_dict.get(system_id, 0) + status.get('rating', 0)
ranked_systems = sorted([(val, sys_id) for sys_id, val in system_dict.items()])
if ranked_systems:
capital_sys_id = ranked_systems[-1][-1]
else:
try:
capital_sys_id = aistate.fleetStatus.items()[0][1]['sysID']
except:
pass
num_targets = max(10, PriorityAI.allotted_outpost_targets)
top_target_planets = ([pid for pid, pscore, trp in AIstate.invasionTargets[:PriorityAI.allotted_invasion_targets()]
if pscore > InvasionAI.MIN_INVASION_SCORE] +
[pid for pid, (pscore, spec) in aistate.colonisableOutpostIDs.items()[:num_targets]
if pscore > InvasionAI.MIN_INVASION_SCORE] +
[pid for pid, (pscore, spec) in aistate.colonisablePlanetIDs.items()[:num_targets]
if pscore > InvasionAI.MIN_INVASION_SCORE])
top_target_planets.extend(aistate.qualifyingTroopBaseTargets.keys())
base_col_target_systems = PlanetUtilsAI.get_systems(top_target_planets)
top_target_systems = []
for sys_id in AIstate.invasionTargetedSystemIDs + base_col_target_systems:
if sys_id not in top_target_systems:
if aistate.systemStatus[sys_id]['totalThreat'] > get_tot_mil_rating():
continue
top_target_systems.append(sys_id) # doing this rather than set, to preserve order
try:
# capital defense
allocation_helper = AllocationHelper(already_assigned_rating, already_assigned_rating_vs_planets, avail_mil_rating, try_reset)
if capital_sys_id is not None:
CapitalDefenseAllocator(capital_sys_id, allocation_helper).allocate()
# defend other planets
empire_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
empire_occupied_system_ids = list(set(PlanetUtilsAI.get_systems(empire_planet_ids)) - {capital_sys_id})
for sys_id in empire_occupied_system_ids:
PlanetDefenseAllocator(sys_id, allocation_helper).allocate()
# attack / protect high priority targets
for sys_id in top_target_systems:
TopTargetAllocator(sys_id, allocation_helper).allocate()
# enemy planets
other_targeted_system_ids = [sys_id for sys_id in set(PlanetUtilsAI.get_systems(AIstate.opponentPlanetIDs)) if
sys_id not in top_target_systems]
for sys_id in other_targeted_system_ids:
TargetAllocator(sys_id, allocation_helper).allocate()
# colony / outpost targets
other_targeted_system_ids = [sys_id for sys_id in
list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs)) if
sys_id not in top_target_systems]
for sys_id in other_targeted_system_ids:
OutpostTargetAllocator(sys_id, allocation_helper).allocate()
# TODO blockade enemy systems
# interior systems
targetable_ids = set(state.get_systems_by_supply_tier(0))
current_mil_systems = [sid for sid, _, _, _, _ in allocation_helper.allocations]
interior_targets1 = targetable_ids.difference(current_mil_systems)
interior_targets = [sid for sid in interior_targets1 if (
allocation_helper.threat_bias + systems_status.get(sid, {}).get('totalThreat', 0) > 0.8 * allocation_helper.already_assigned_rating[sid])]
for sys_id in interior_targets:
InteriorTargetsAllocator(sys_id, allocation_helper).allocate()
# TODO Exploration targets
# border protections
visible_system_ids = aistate.visInteriorSystemIDs | aistate.visBorderSystemIDs
accessible_system_ids = ([sys_id for sys_id in visible_system_ids if
universe.systemsConnected(sys_id, home_system_id, empire_id)]
if home_system_id != INVALID_ID else [])
current_mil_systems = [sid for sid, alloc, rvp, take_any, _ in allocation_helper.allocations if alloc > 0]
border_targets1 = [sid for sid in accessible_system_ids if sid not in current_mil_systems]
border_targets = [sid for sid in border_targets1 if (
allocation_helper.threat_bias + systems_status.get(sid, {}).get('fleetThreat', 0) + systems_status.get(sid, {}).get(
'planetThreat', 0) > 0.8 * allocation_helper.already_assigned_rating[sid])]
for sys_id in border_targets:
BorderSecurityAllocator(sys_id, allocation_helper).allocate()
except ReleaseMilitaryException:
try_again(all_military_fleet_ids)
return
new_allocations = []
remaining_mil_rating = avail_mil_rating
# for top categories assign max_alloc right away as available
for cat in ['capitol', 'occupied', 'topTargets']:
for sid, alloc, rvp, take_any, max_alloc in allocation_helper.allocation_by_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
this_alloc = min(remaining_mil_rating, max_alloc)
new_allocations.append((sid, this_alloc, alloc, rvp, take_any))
remaining_mil_rating = rating_difference(remaining_mil_rating, this_alloc)
base_allocs = set()
# for lower priority categories, first assign base_alloc around to all, then top up as available
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, rvp, take_any, max_alloc in allocation_helper.allocation_by_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
alloc = min(remaining_mil_rating, alloc)
base_allocs.add(sid)
remaining_mil_rating = rating_difference(remaining_mil_rating, alloc)
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, rvp, take_any, max_alloc in allocation_helper.allocation_by_groups.get(cat, []):
if sid not in base_allocs:
break
if remaining_mil_rating <= 0:
new_allocations.append((sid, alloc, alloc, rvp, take_any))
else:
local_max_avail = combine_ratings(remaining_mil_rating, alloc)
new_rating = min(local_max_avail, max_alloc)
new_allocations.append((sid, new_rating, alloc, rvp, take_any))
remaining_mil_rating = rating_difference(local_max_avail, new_rating)
if "Main" in thisround:
_military_allocations = new_allocations
if _verbose_mil_reporting or "Main" in thisround:
print "------------------------------\nFinal %s Round Military Allocations: %s \n-----------------------" % (thisround, dict([(sid, alloc) for sid, alloc, _, _, _ in new_allocations]))
print "(Apparently) remaining military rating: %.1f" % remaining_mil_rating
return new_allocations
