def generateOrders():
empire = fo.getEmpire()
print "Empire: " + empire.name + " TURN: " + str(fo.currentTurn())
print "Capital: " + str(empire.capitalID)
# turn cleanup
splitFleet()
identifyShipDesigns()
identifyFleetsRoles()
foAIstate.clean(ExplorationAI.getHomeSystemID(), FleetUtilsAI.getEmpireFleetIDs())
# ...missions
# ...demands/priorities
# call AI modules
PriorityAI.calculatePriorities()
ExplorationAI.assignScoutsToExploreSystems()
ColonisationAI.assignColonyFleetsToColonise()
InvasionAI.assignInvasionFleetsToInvade()
FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
ResearchAI.generateResearchOrders()
ProductionAI.generateProductionOrders()
ResourcesAI.generateResourcesOrders()
foAIstate.afterTurnCleanup()
fo.doneTurn()
def generateOrders():
print ("Genearting Orders")
universe = fo.getUniverse()
empire = fo.getEmpire()
planetID = empire.capitalID
planet = universe.getPlanet(planetID)
print "EmpireID: " + str(empire.empireID) + " Name: " + empire.name + " Turn: " + str(fo.currentTurn())
print "CapitalID: " + str(planetID) + " Name: " + planet.name + " Species: " + planet.speciesName
# turn cleanup
splitFleet()
identifyShipDesigns()
identifyFleetsRoles()
foAIstate.clean(ExplorationAI.getHomeSystemID(), FleetUtilsAI.getEmpireFleetIDs())
# ...missions
# ...demands/priorities
print("Calling AI Modules")
# call AI modules
PriorityAI.calculatePriorities()
ExplorationAI.assignScoutsToExploreSystems()
ColonisationAI.assignColonyFleetsToColonise()
InvasionAI.assignInvasionFleetsToInvade()
MilitaryAI.assignMilitaryFleetsToSystems()
FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
ResearchAI.generateResearchOrders()
ProductionAI.generateProductionOrders()
ResourcesAI.generateResourcesOrders()
foAIstate.afterTurnCleanup()
fo.doneTurn()
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 = sum(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 = {}
systems_status = foAI.foAIstate.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 = foAI.foAIstate.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 = foAI.foAIstate.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 = foAI.foAIstate.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 > MIN_INVASION_SCORE] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisableOutpostIDs.items()[:num_targets]
if pscore > MIN_INVASION_SCORE] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisablePlanetIDs.items()[:num_targets]
if pscore > MIN_INVASION_SCORE])
top_target_planets.extend(foAI.foAIstate.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 foAI.foAIstate.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 = foAI.foAIstate.visInteriorSystemIDs | foAI.foAIstate.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 -= 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
base_allocs.add(sid)
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:
new_rating = min(remaining_mil_rating + alloc, max_alloc)
new_allocations.append((sid, new_rating, alloc, rvp, take_any))
remaining_mil_rating -= (new_rating - alloc)
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
def _calculate_planet_colonization_rating(
planet_id: PlanetId,
mission_type: MissionType,
species_name: SpeciesName,
detail: list,
empire_research_list: Sequence,
) -> float:
empire = fo.getEmpire()
retval = 0
character = get_aistate().character
discount_multiplier = character.preferred_discount_multiplier([30.0, 40.0])
species = fo.getSpecies(species_name)
species_foci = [] and species and list(species.foci)
tag_list = list(species.tags) if species else []
pilot_val = pilot_rating = 0
if species and species.canProduceShips:
pilot_val = pilot_rating = rate_piloting_tag(species_name)
if pilot_val > best_pilot_rating():
pilot_val *= 2
if pilot_val > 2:
retval += discount_multiplier * 5 * pilot_val
detail.append("Pilot Val %.1f" %
(discount_multiplier * 5 * pilot_val))
if empire.productionPoints < 100:
backup_factor = 0.0
else:
backup_factor = min(1.0, (empire.productionPoints / 200.0)**2)
universe = fo.getUniverse()
capital_id = PlanetUtilsAI.get_capital()
homeworld = universe.getPlanet(capital_id)
planet = universe.getPlanet(planet_id)
prospective_invasion_targets = [
pid for pid, pscore, trp in
AIstate.invasionTargets[:PriorityAI.allotted_invasion_targets()]
if pscore > InvasionAI.MIN_INVASION_SCORE
]
if species_name != planet.speciesName and planet.speciesName and mission_type != MissionType.INVASION:
return 0
this_sysid = planet.systemID
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = this_sysid
if home_system_id != INVALID_ID and eval_system_id != INVALID_ID:
least_jumps = universe.jumpDistance(home_system_id, eval_system_id)
if least_jumps == -1: # indicates no known path
return 0.0
if planet is None:
vis_map = universe.getVisibilityTurnsMap(planet_id, empire.empireID)
debug("Planet %d object not available; visMap: %s" %
(planet_id, vis_map))
return 0
# only count existing presence if not target planet
# TODO: consider neighboring sytems for smaller contribution, and bigger contributions for
# local colonies versus local outposts
locally_owned_planets = [
lpid for lpid in get_owned_planets_in_system(this_sysid)
if lpid != planet_id
]
planets_with_species = get_inhabited_planets()
locally_owned_pop_ctrs = [
lpid for lpid in locally_owned_planets if lpid in planets_with_species
]
# triple count pop_ctrs
existing_presence = len(
locally_owned_planets) + 2 * len(locally_owned_pop_ctrs)
system = universe.getSystem(this_sysid)
sys_supply = get_system_supply(this_sysid)
planet_supply = AIDependencies.supply_by_size.get(planet.size, 0)
bld_types = set(
universe.getBuilding(bldg).buildingTypeName
for bldg in planet.buildingIDs).intersection(
AIDependencies.building_supply)
planet_supply += sum(
AIDependencies.building_supply[bld_type].get(int(psize), 0)
for psize in [-1, planet.size] for bld_type in bld_types)
supply_specials = set(planet.specials).union(system.specials).intersection(
AIDependencies.SUPPLY_MOD_SPECIALS)
planet_supply += sum(
AIDependencies.SUPPLY_MOD_SPECIALS[_special].get(int(psize), 0)
for _special in supply_specials for psize in [-1, planet.size])
ind_tag_mod = AIDependencies.SPECIES_INDUSTRY_MODIFIER.get(
get_species_tag_grade(species_name, Tags.INDUSTRY), 1.0)
res_tag_mod = AIDependencies.SPECIES_RESEARCH_MODIFIER.get(
get_species_tag_grade(species_name, Tags.RESEARCH), 1.0)
if species:
supply_tag_mod = AIDependencies.SPECIES_SUPPLY_MODIFIER.get(
get_species_tag_grade(species_name, Tags.SUPPLY), 1)
else:
supply_tag_mod = 0
# determine the potential supply provided by owning this planet, and if the planet is currently populated by
# the evaluated species, then save this supply value in a cache.
# The system supply value can be negative (indicates the respective number of starlane jumps to the closest supplied
# system). So if this total planet supply value is non-negative, then the planet would be supply connected (to at
# least a portion of the existing empire) if the planet becomes owned by the AI.
planet_supply += supply_tag_mod
planet_supply = max(planet_supply, 0) # planets can't have negative supply
if planet.speciesName == species_name:
update_planet_supply(planet_id, planet_supply + sys_supply)
threat_factor = _determine_colony_threat_factor(planet_id, species_name,
existing_presence)
sys_partial_vis_turn = get_partial_visibility_turn(this_sysid)
planet_partial_vis_turn = get_partial_visibility_turn(planet_id)
if planet_partial_vis_turn < sys_partial_vis_turn:
# last time we had partial vis of the system, the planet was stealthed to us
# print "Colonization AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
return 0 # TODO: track detection strength, order new scouting when it goes up
star_bonus = 0
colony_star_bonus = 0
research_bonus = 0
growth_val = 0
fixed_ind = 0
fixed_res = 0
if system:
already_got_this_one = this_sysid in get_owned_planets()
# TODO: Should probably consider pilot rating also for Phototropic species
if "PHOTOTROPHIC" not in tag_list and pilot_rating >= best_pilot_rating(
):
if system.starType == fo.starType.red and tech_is_complete(
"LRN_STELLAR_TOMOGRAPHY"):
star_bonus += 40 * discount_multiplier # can be used for artif'l black hole and solar hull
detail.append(
"Red Star for Art Black Hole for solar hull %.1f" %
(40 * discount_multiplier))
elif system.starType == fo.starType.blackHole and tech_is_complete(
"SHP_FRC_ENRG_COMP"):
star_bonus += 100 * discount_multiplier # can be used for solar hull
detail.append("Black Hole for solar hull %.1f" %
(100 * discount_multiplier))
if tech_is_complete("PRO_SOL_ORB_GEN"
) or "PRO_SOL_ORB_GEN" in empire_research_list[:5]:
if system.starType in [fo.starType.blue, fo.starType.white]:
if not has_claimed_star(fo.starType.blue, fo.starType.white):
star_bonus += 20 * discount_multiplier
detail.append("PRO_SOL_ORB_GEN BW %.1f" %
(20 * discount_multiplier))
elif not already_got_this_one:
# still has extra value as an alternate location for solar generators
star_bonus += 10 * discount_multiplier * backup_factor
detail.append("PRO_SOL_ORB_GEN BW Backup Location %.1f" %
(10 * discount_multiplier * backup_factor))
elif fo.currentTurn() > 100: # lock up this whole system
pass
# starBonus += 5 # TODO: how much?
# detail.append("PRO_SOL_ORB_GEN BW LockingDownSystem %.1f"%5)
if system.starType in [fo.starType.yellow, fo.starType.orange]:
if not has_claimed_star(fo.starType.blue, fo.starType.white,
fo.starType.yellow,
fo.starType.orange):
star_bonus += 10 * discount_multiplier
detail.append("PRO_SOL_ORB_GEN YO %.1f" %
(10 * discount_multiplier))
else:
pass
# starBonus +=2 # still has extra value as an alternate location for solar generators
# detail.append("PRO_SOL_ORB_GEN YO Backup %.1f" % 2)
if system.starType in [fo.starType.blackHole
] and fo.currentTurn() > 100:
if not already_got_this_one:
# whether have tech yet or not, assign some base value
star_bonus += 10 * discount_multiplier * backup_factor
detail.append("Black Hole %.1f" %
(10 * discount_multiplier * backup_factor))
else:
star_bonus += 5 * discount_multiplier * backup_factor
detail.append("Black Hole Backup %.1f" %
(5 * discount_multiplier * backup_factor))
if tech_is_complete(AIDependencies.PRO_SOL_ORB_GEN
): # start valuing as soon as PRO_SOL_ORB_GEN done
if system.starType == fo.starType.blackHole:
# pretty rare planets, good for generator
this_val = 0.5 * max(population_with_industry_focus(),
20) * discount_multiplier
if not has_claimed_star(fo.starType.blackHole):
star_bonus += this_val
detail.append("PRO_SINGULAR_GEN %.1f" % this_val)
elif not is_system_star_claimed(system):
# still has extra value as an alternate location for generators & for blocking enemies generators
star_bonus += this_val * backup_factor
detail.append("PRO_SINGULAR_GEN Backup %.1f" %
(this_val * backup_factor))
elif system.starType == fo.starType.red and not has_claimed_star(
fo.starType.blackHole):
rfactor = (1.0 + count_claimed_stars(fo.starType.red))**-2
star_bonus += 40 * discount_multiplier * backup_factor * rfactor # can be used for artif'l black hole
detail.append(
"Red Star for Art Black Hole %.1f" %
(40 * discount_multiplier * backup_factor * rfactor))
if tech_is_complete(
"PRO_NEUTRONIUM_EXTRACTION"
) or "PRO_NEUTRONIUM_EXTRACTION" in empire_research_list[:8]:
if system.starType in [fo.starType.neutron]:
if not has_claimed_star(fo.starType.neutron):
star_bonus += 80 * discount_multiplier # pretty rare planets, good for armor
detail.append("PRO_NEUTRONIUM_EXTRACTION %.1f" %
(80 * discount_multiplier))
else:
# still has extra value as an alternate location for generators & for bnlocking enemies generators
star_bonus += 20 * discount_multiplier * backup_factor
detail.append("PRO_NEUTRONIUM_EXTRACTION Backup %.1f" %
(20 * discount_multiplier * backup_factor))
if tech_is_complete(
"SHP_ENRG_BOUND_MAN"
) or "SHP_ENRG_BOUND_MAN" in empire_research_list[:6]:
# TODO: base this on pilot val, and also consider red stars
if system.starType in [fo.starType.blackHole, fo.starType.blue]:
init_val = 100 * discount_multiplier * (pilot_val or 1)
if not has_claimed_star(fo.starType.blackHole,
fo.starType.blue):
colony_star_bonus += init_val # pretty rare planets, good for energy shipyards
detail.append("SHP_ENRG_BOUND_MAN %.1f" % init_val)
elif not is_system_star_claimed(system):
# still has extra value as an alternate location for energy shipyard
colony_star_bonus += 0.5 * init_val * backup_factor
detail.append("SHP_ENRG_BOUND_MAN Backup %.1f" %
(0.5 * init_val * backup_factor))
retval += star_bonus
planet_specials = list(planet.specials)
if "ECCENTRIC_ORBIT_SPECIAL" in planet.specials:
fixed_res += discount_multiplier * 6
detail.append("ECCENTRIC_ORBIT_SPECIAL %.1f" %
(discount_multiplier * 6))
if mission_type == MissionType.OUTPOST or (
mission_type == MissionType.INVASION and not species_name):
if "ANCIENT_RUINS_SPECIAL" in planet.specials: # TODO: add value for depleted ancient ruins
retval += discount_multiplier * 30
detail.append("Undepleted Ruins %.1f" % discount_multiplier * 30)
for special in planet_specials:
if "_NEST_" in special:
nest_val = get_nest_rating(
special, 5.0
) * discount_multiplier # get an outpost on the nest quick
retval += nest_val
detail.append("%s %.1f" % (special, nest_val))
elif special == "FORTRESS_SPECIAL":
fort_val = 10 * discount_multiplier
retval += fort_val
detail.append("%s %.1f" % (special, fort_val))
elif special == "HONEYCOMB_SPECIAL":
honey_val = 0.3 * (AIDependencies.HONEYCOMB_IND_MULTIPLIER *
AIDependencies.INDUSTRY_PER_POP *
population_with_industry_focus() *
discount_multiplier)
retval += honey_val
detail.append("%s %.1f" % (special, honey_val))
if planet.size == fo.planetSize.asteroids:
ast_val = 0
if system:
for pid in system.planetIDs:
other_planet = universe.getPlanet(pid)
if other_planet.size == fo.planetSize.asteroids:
if pid == planet_id:
continue
elif pid < planet_id and planet.unowned:
ast_val = 0
break
elif other_planet.speciesName:
if other_planet.owner == empire.empireID:
ownership_factor = 1.0
elif pid in prospective_invasion_targets:
ownership_factor = character.secondary_valuation_factor_for_invasion_targets(
)
else:
ownership_factor = 0.0
ast_val += ownership_factor * _base_asteroid_mining_val(
) * discount_multiplier
retval += ast_val
if ast_val > 0:
detail.append("AsteroidMining %.1f" % ast_val)
ast_val = 0
if tech_is_complete("SHP_ASTEROID_HULLS"):
per_ast = 20
elif tech_is_complete("CON_ORBITAL_CON"):
per_ast = 5
else:
per_ast = 0.1
if system:
for pid in system.planetIDs:
other_planet = universe.getPlanet(pid)
if other_planet.size == fo.planetSize.asteroids:
if pid == planet_id:
continue
elif pid < planet_id and planet.unowned:
ast_val = 0
break
elif other_planet.speciesName:
other_species = fo.getSpecies(other_planet.speciesName)
if other_species and other_species.canProduceShips:
if other_planet.owner == empire.empireID:
ownership_factor = 1.0
elif pid in prospective_invasion_targets:
ownership_factor = character.secondary_valuation_factor_for_invasion_targets(
)
else:
ownership_factor = 0.0
ast_val += ownership_factor * per_ast * discount_multiplier
retval += ast_val
if ast_val > 0:
detail.append("AsteroidShipBuilding %.1f" % ast_val)
# We will assume that if any GG in the system is populated, they all will wind up populated; cannot then hope
# to build a GGG on a non-populated GG
populated_gg_factor = 1.0
per_gg = 0
if planet.size == fo.planetSize.gasGiant:
# TODO: Given current industry calc approach, consider bringing this max val down to actual max val of 10
if tech_is_complete("PRO_ORBITAL_GEN"):
per_gg = 20
elif tech_is_complete("CON_ORBITAL_CON"):
per_gg = 10
if species_name:
populated_gg_factor = 0.5
else:
per_gg = 5
if system:
gg_list = []
orb_gen_val = 0
gg_detail = []
for pid in system.planetIDs:
other_planet = universe.getPlanet(pid)
if other_planet.size == fo.planetSize.gasGiant:
gg_list.append(pid)
if other_planet.speciesName:
populated_gg_factor = 0.5
if (pid != planet_id and other_planet.owner == empire.empireID
and FocusType.FOCUS_INDUSTRY
in list(other_planet.availableFoci) +
[other_planet.focus]):
orb_gen_val += per_gg * discount_multiplier
# Note, this reported value may not take into account a later adjustment from a populated gg
gg_detail.append("GGG for %s %.1f" %
(other_planet.name, discount_multiplier *
per_gg * populated_gg_factor))
if planet_id in sorted(gg_list)[:1]:
retval += orb_gen_val * populated_gg_factor
detail.extend(gg_detail)
else:
detail.append("Won't GGG")
if existing_presence:
detail.append("preexisting system colony")
retval = (retval + existing_presence *
_get_defense_value(species_name)) * 1.5
# Fixme - sys_supply is always <= 0 leading to incorrect supply bonus score
supply_val = 0
if sys_supply < 0:
if sys_supply + planet_supply >= 0:
supply_val += 30 * (planet_supply - max(-3, sys_supply))
else:
retval += 30 * (planet_supply + sys_supply) # a penalty
elif planet_supply > sys_supply and (
sys_supply < 2): # TODO: check min neighbor supply
supply_val += 25 * (planet_supply - sys_supply)
detail.append("sys_supply: %d, planet_supply: %d, supply_val: %.0f" %
(sys_supply, planet_supply, supply_val))
retval += supply_val
if threat_factor < 1.0:
threat_factor = _revise_threat_factor(threat_factor, retval,
this_sysid,
MINIMUM_COLONY_SCORE)
retval *= threat_factor
detail.append("threat reducing value by %3d %%" %
(100 * (1 - threat_factor)))
return int(retval)
else: # colonization mission
if not species:
return 0
supply_val = 0
if "ANCIENT_RUINS_SPECIAL" in planet.specials:
retval += discount_multiplier * 50
detail.append("Undepleted Ruins %.1f" % discount_multiplier * 50)
if "HONEYCOMB_SPECIAL" in planet.specials:
honey_val = (AIDependencies.HONEYCOMB_IND_MULTIPLIER *
AIDependencies.INDUSTRY_PER_POP *
population_with_industry_focus() *
discount_multiplier)
if FocusType.FOCUS_INDUSTRY not in species_foci:
honey_val *= -0.3 # discourage settlement by colonizers not able to use Industry Focus
retval += honey_val
detail.append("%s %.1f" % ("HONEYCOMB_SPECIAL", honey_val))
# Fixme - sys_supply is always <= 0 leading to incorrect supply bonus score
if sys_supply <= 0:
if sys_supply + planet_supply >= 0:
supply_val = 40 * (planet_supply - max(-3, sys_supply))
else:
supply_val = 200 * (planet_supply + sys_supply) # a penalty
if species_name == "SP_SLY":
# Sly are essentially stuck with lousy supply, so don't penalize for that
supply_val = 0
elif planet_supply > sys_supply == 1: # TODO: check min neighbor supply
supply_val = 20 * (planet_supply - sys_supply)
detail.append("sys_supply: %d, planet_supply: %d, supply_val: %.0f" %
(sys_supply, planet_supply, supply_val))
# if AITags != "":
# print "Species %s has AITags %s"%(specName, AITags)
retval += fixed_res
retval += colony_star_bonus
asteroid_bonus = 0
gas_giant_bonus = 0
flat_industry = 0
mining_bonus = 0
per_ggg = 10
asteroid_factor = 0.0
gg_factor = 0.0
ast_shipyard_name = ""
if system and FocusType.FOCUS_INDUSTRY in species.foci:
for pid in system.planetIDs:
if pid == planet_id:
continue
p2 = universe.getPlanet(pid)
if p2:
if p2.size == fo.planetSize.asteroids:
this_factor = 0.0
if p2.owner == empire.empireID:
this_factor = 1.0
elif p2.unowned:
this_factor = 0.5
elif pid in prospective_invasion_targets:
this_factor = character.secondary_valuation_factor_for_invasion_targets(
)
if this_factor > asteroid_factor:
asteroid_factor = this_factor
ast_shipyard_name = p2.name
if p2.size == fo.planetSize.gasGiant:
if p2.owner == empire.empireID:
gg_factor = max(gg_factor, 1.0)
elif p2.unowned:
gg_factor = max(gg_factor, 0.5)
elif pid in prospective_invasion_targets:
gg_factor = max(
gg_factor,
character.
secondary_valuation_factor_for_invasion_targets(
))
if asteroid_factor > 0.0:
if tech_is_complete(
"PRO_MICROGRAV_MAN"
) or "PRO_MICROGRAV_MAN" in empire_research_list[:10]:
flat_industry += 2 * asteroid_factor # will go into detailed industry projection
detail.append("Asteroid mining ~ %.1f" %
(5 * asteroid_factor * discount_multiplier))
if tech_is_complete(
"SHP_ASTEROID_HULLS"
) or "SHP_ASTEROID_HULLS" in empire_research_list[:11]:
if species and species.canProduceShips:
asteroid_bonus = 30 * discount_multiplier * pilot_val
detail.append("Asteroid ShipBuilding from %s %.1f" %
(ast_shipyard_name,
discount_multiplier * 30 * pilot_val))
if gg_factor > 0.0:
if tech_is_complete(
"PRO_ORBITAL_GEN"
) or "PRO_ORBITAL_GEN" in empire_research_list[:5]:
flat_industry += per_ggg * gg_factor # will go into detailed industry projection
detail.append("GGG ~ %.1f" %
(per_ggg * gg_factor * discount_multiplier))
# calculate the maximum population of the species on that planet.
if planet.speciesName not in AIDependencies.SPECIES_FIXED_POPULATION:
max_pop_size = calc_max_pop(planet, species, detail)
else:
max_pop_size = AIDependencies.SPECIES_FIXED_POPULATION[
planet.speciesName]
detail.append("Fixed max population of %.2f" % max_pop_size)
if max_pop_size <= 0:
detail.append(
"Non-positive population projection for species '%s', so no colonization value"
% (species and species.name))
return 0
for special in [
"MINERALS_SPECIAL", "CRYSTALS_SPECIAL", "ELERIUM_SPECIAL"
]:
if special in planet_specials:
mining_bonus += 1
has_blackhole = has_claimed_star(fo.starType.blackHole)
ind_tech_map_flat = AIDependencies.INDUSTRY_EFFECTS_FLAT_NOT_MODIFIED_BY_SPECIES
ind_tech_map_before_species_mod = AIDependencies.INDUSTRY_EFFECTS_PER_POP_MODIFIED_BY_SPECIES
ind_tech_map_after_species_mod = AIDependencies.INDUSTRY_EFFECTS_PER_POP_NOT_MODIFIED_BY_SPECIES
ind_mult = 1
for tech in ind_tech_map_before_species_mod:
if tech_is_complete(tech) and (
tech != AIDependencies.PRO_SINGULAR_GEN or has_blackhole):
ind_mult += ind_tech_map_before_species_mod[tech]
ind_mult = ind_mult * max(
ind_tag_mod, 0.5 *
(ind_tag_mod +
res_tag_mod)) # TODO: report an actual calc for research value
for tech in ind_tech_map_after_species_mod:
if tech_is_complete(tech) and (
tech != AIDependencies.PRO_SINGULAR_GEN or has_blackhole):
ind_mult += ind_tech_map_after_species_mod[tech]
max_ind_factor = 0
for tech in ind_tech_map_flat:
if tech_is_complete(tech):
fixed_ind += discount_multiplier * ind_tech_map_flat[tech]
if FocusType.FOCUS_INDUSTRY in species.foci:
if "TIDAL_LOCK_SPECIAL" in planet.specials:
ind_mult += 1
max_ind_factor += AIDependencies.INDUSTRY_PER_POP * mining_bonus
max_ind_factor += AIDependencies.INDUSTRY_PER_POP * ind_mult
cur_pop = 1.0 # assume an initial colonization value
if planet.speciesName != "":
cur_pop = planet.currentMeterValue(fo.meterType.population)
elif tech_is_complete("GRO_LIFECYCLE_MAN"):
cur_pop = 3.0
cur_industry = planet.currentMeterValue(fo.meterType.industry)
ind_val = _project_ind_val(cur_pop, max_pop_size, cur_industry,
max_ind_factor, flat_industry,
discount_multiplier)
detail.append("ind_val %.1f" % ind_val)
# used to give preference to closest worlds
for special in [
spec for spec in planet_specials
if spec in AIDependencies.metabolismBoosts
]:
# TODO: also consider potential future benefit re currently unpopulated planets
gbonus = (discount_multiplier * AIDependencies.INDUSTRY_PER_POP *
ind_mult * empire_metabolisms.get(
AIDependencies.metabolismBoosts[special], 0)
) # due to growth applicability to other planets
growth_val += gbonus
detail.append("Bonus for %s: %.1f" % (special, gbonus))
if FocusType.FOCUS_RESEARCH in species.foci:
research_bonus += discount_multiplier * 2 * AIDependencies.RESEARCH_PER_POP * max_pop_size
if "ANCIENT_RUINS_SPECIAL" in planet.specials or "ANCIENT_RUINS_DEPLETED_SPECIAL" in planet.specials:
research_bonus += discount_multiplier * 2 * AIDependencies.RESEARCH_PER_POP * max_pop_size * 5
detail.append("Ruins Research")
if "TEMPORAL_ANOMALY_SPECIAL" in planet.specials:
research_bonus += discount_multiplier * 2 * AIDependencies.RESEARCH_PER_POP * max_pop_size * 25
detail.append("Temporal Anomaly Research")
if AIDependencies.COMPUTRONIUM_SPECIAL in planet.specials:
comp_bonus = (0.5 * AIDependencies.TECH_COST_MULTIPLIER *
AIDependencies.RESEARCH_PER_POP *
AIDependencies.COMPUTRONIUM_RES_MULTIPLIER *
population_with_research_focus() *
discount_multiplier)
if have_computronium():
comp_bonus *= backup_factor
research_bonus += comp_bonus
detail.append(AIDependencies.COMPUTRONIUM_SPECIAL)
retval += (max(ind_val + asteroid_bonus + gas_giant_bonus,
research_bonus, growth_val) + fixed_ind + fixed_res +
supply_val)
if existing_presence:
detail.append("preexisting system colony")
retval = (retval +
existing_presence * _get_defense_value(species_name)) * 2
if threat_factor < 1.0:
threat_factor = _revise_threat_factor(threat_factor, retval,
this_sysid,
MINIMUM_COLONY_SCORE)
retval *= threat_factor
detail.append("threat reducing value by %3d %%" %
(100 * (1 - threat_factor)))
return retval
def generateOrders():
global lastTurnTimestamp
universe = fo.getUniverse()
turnStartTime=time() #starting AI timer here, to be sure AI doesn't get blame for any lags in server being able to provide the Universe object
empire = fo.getEmpire()
planetID = PlanetUtilsAI.getCapital()
planet=None
if planetID is not None:
planet = universe.getPlanet(planetID)
print "***************************************************************************"
print "***************************************************************************"
print ("Generating Orders")
print "EmpireID: " + str(empire.empireID) + " Name: " + empire.name+ "_"+str(empire.empireID-1) +"_pid:"+str(fo.playerID())+"_"+fo.playerName()+"_"+aggressions.get(foAIstate.aggression, "?") + " Turn: " + str(fo.currentTurn())
empireColor=empire.colour
print "EmpireColors: %d %d %d %d"%(empireColor.r, empireColor.g, empireColor.b, empireColor.a)
if planet:
print "CapitalID: " + str(planetID) + " Name: " + planet.name + " Species: " + planet.speciesName
else:
print "CapitalID: None Currently Name: None Species: None "
print "***************************************************************************"
print "***************************************************************************"
if fo.currentTurn() == 1:
declareWarOnAll()
# turn cleanup !!! this was formerly done at start of every turn -- not sure why
splitNewFleets()
#updateShipDesigns() #should not be needed anymore;
#updateFleetsRoles()
foAIstate.clean() #checks exploration border & clears roles/missions of missing fleets & updates fleet locs
foAIstate.reportSystemThreats()
# ...missions
# ...demands/priorities
print("Calling AI Modules")
# call AI modules
timer=[time()]
try: PriorityAI.calculatePriorities()
except: print "Error: exception triggered and caught: ", traceback.format_exc() # try traceback.print_exc()
timer.append( time() )
try: ExplorationAI.assignScoutsToExploreSystems()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ColonisationAI.assignColonyFleetsToColonise()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: InvasionAI.assignInvasionFleetsToInvade()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: MilitaryAI.assignMilitaryFleetsToSystems()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ResearchAI.generateResearchOrders()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ProductionAI.generateProductionOrders()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ResourcesAI.generateResourcesOrders()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: foAIstate.afterTurnCleanup()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
times = [timer[i] - timer[i-1] for i in range(1, len(timer) ) ]
turnEndTime=time()
timeFmt = "%30s: %8d msec "
print "AI Module Time Requirements:"
for mod, modTime in zip(__timerEntries, times):
print timeFmt%((30*' '+mod)[-30:], int(1000*modTime))
if __timerFile:
__timerFile.write( __timerFileFmt%tuple( [ fo.currentTurn() ]+map(lambda x: int(1000*x), times )) +'\n')
__timerFile.flush()
if __timerBucketFile:
__timerBucketFile.write( __timerBucketFileFmt%tuple( [ fo.currentTurn(), (turnStartTime-lastTurnTimestamp)*1000, (turnEndTime-turnStartTime)*1000 ]) +'\n')
__timerBucketFile.flush()
lastTurnTimestamp = time()
try: fo.doneTurn()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
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))
# Todo: This block had been originally added to address situations where fleet missions were not properly
# terminating, leaving fleets stuck in stale deployments. Assess if this block is still needed at all; delete
# if not, otherwise restructure the following code so that in event a reset is occurring greater priority is given
# to providing military support to locations where a necessary Secure mission might have just been released (i.e.,
# at invasion and colony/outpost targets where the troopships and colony ships are on their way), or else allow
# only a partial reset which does not reset Secure missions.
enable_periodic_mission_reset = False
if enable_periodic_mission_reset and try_reset and (
fo.currentTurn() + empire_id) % 30 == 0 and thisround == "Main":
debug(
"Resetting all Military missions as part of an automatic periodic reset to clear stale missions."
)
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(
get_fleet_rating(x) for x in 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 = get_fleet_rating(fleet_id)
this_rating_vs_planets = get_fleet_rating_against_planets(fleet_id)
already_assigned_rating[last_sys] = combine_ratings(
already_assigned_rating.get(last_sys, 0), this_rating)
already_assigned_rating_vs_planets[last_sys] = 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] = combine_ratings(
my_defense_rating, already_assigned_rating[sys_id])
if _verbose_mil_reporting and already_assigned_rating[sys_id]:
debug(
"\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 = next(iter(
aistate.fleetStatus.items()))[1]["sysID"]
except: # noqa: E722
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 list(aistate.colonisableOutpostIDs.items())
[:num_targets] if pscore > InvasionAI.MIN_INVASION_SCORE
] + [
pid
for pid, (pscore, spec) in list(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()
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(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 systems_connected(sys_id, home_system_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:
debug(
"------------------------------\nFinal %s Round Military Allocations: %s \n-----------------------"
% (thisround,
dict([(sid, alloc)
for sid, alloc, _, _, _ in new_allocations])))
debug("(Apparently) remaining military rating: %.1f" %
remaining_mil_rating)
return new_allocations
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
