def is_valid(self):
if not super(OrderOutpost, self).is_valid():
return False
planet = self.target.get_object()
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet.id)
if not (planet_partial_vis_turn == sys_partial_vis_turn and planet.unowned):
self.executed = True
self.order_issued = True
return False
else:
return self.fleet.get_object().hasOutpostShips
def is_valid(self):
if not super(OrderColonize, self).is_valid():
return False
planet = self.target.get_object()
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet.id)
if (planet_partial_vis_turn == sys_partial_vis_turn and planet.unowned or
(planet.ownedBy(fo.empireID()) and not planet.currentMeterValue(fo.meterType.population))):
return self.fleet.get_object().hasColonyShips
self.executed = True
self.order_issued = True
return False
def follow_vis_system_connections(start_system_id, home_system_id):
universe = fo.getUniverse()
empire_id = fo.empireID()
exploration_list = [start_system_id]
aistate = get_aistate()
while exploration_list:
cur_system_id = exploration_list.pop()
if cur_system_id in graph_flags:
continue
graph_flags.add(cur_system_id)
system = universe.getSystem(cur_system_id)
if cur_system_id in aistate.visBorderSystemIDs:
pre_vis = "a border system"
elif cur_system_id in aistate.visInteriorSystemIDs:
pre_vis = "an interior system"
else:
pre_vis = "an unknown system"
system_header = "*** system %s;" % system
if fo.currentTurn() < 50:
visibility_turn_list = sorted(universe.getVisibilityTurnsMap(cur_system_id, empire_id).items(),
key=lambda x: x[0].numerator)
visibility_info = ', '.join('%s: %s' % (vis.name, turn) for vis, turn in visibility_turn_list)
debug("%s previously %s. Visibility per turn: %s " % (system_header, pre_vis, visibility_info))
status_info = []
else:
status_info = [system_header]
has_been_visible = get_partial_visibility_turn(cur_system_id) > 0
is_connected = universe.systemsConnected(cur_system_id, home_system_id, -1) # self.empire_id)
status_info.append(" -- is%s partially visible" % ("" if has_been_visible else " not"))
status_info.append(" -- is%s visibly connected to homesystem" % ("" if is_connected else " not"))
if has_been_visible:
sys_status = aistate.systemStatus.setdefault(cur_system_id, {})
aistate.visInteriorSystemIDs.add(cur_system_id)
aistate.visBorderSystemIDs.discard(cur_system_id)
neighbors = set(universe.getImmediateNeighbors(cur_system_id, empire_id))
sys_status.setdefault('neighbors', set()).update(neighbors)
if neighbors:
status_info.append(" -- has neighbors %s" % sorted(neighbors))
for sys_id in neighbors:
if sys_id not in aistate.exploredSystemIDs:
aistate.unexploredSystemIDs.add(sys_id)
if (sys_id not in graph_flags) and (sys_id not in aistate.visInteriorSystemIDs):
aistate.visBorderSystemIDs.add(sys_id)
exploration_list.append(sys_id)
if fo.currentTurn() < 50:
debug('\n'.join(status_info))
debug("----------------------------------------------------------")
def _check_abort_mission(self, fleet_order: AIFleetOrder):
"""checks if current mission (targeting a planet) should be aborted"""
planet_stealthed = False
target_is_planet = fleet_order.target and isinstance(
fleet_order.target, TargetPlanet)
planet = None
if target_is_planet:
planet = fleet_order.target.get_object()
# Check visibility prediction, but if somehow still have current visibility, don't
# abort the mission yet
if not EspionageAI.colony_detectable_by_empire(
planet.id, empire=fo.empireID()):
if get_partial_visibility_turn(planet.id) == fo.currentTurn():
debug(
"EspionageAI predicts planet id %d to be stealthed" %
planet.id +
", but somehow have current visibity anyway, so won't trigger mission abort"
)
else:
debug(
"EspionageAI predicts we can no longer detect %s, will abort mission"
% fleet_order.target)
planet_stealthed = True
if target_is_planet and not planet_stealthed:
if isinstance(fleet_order, OrderColonize):
if planet.initialMeterValue(fo.meterType.population) == 0 and (
planet.ownedBy(fo.empireID()) or planet.unowned):
return False
elif isinstance(fleet_order, OrderOutpost):
if planet.unowned:
return False
elif isinstance(fleet_order,
OrderInvade): # TODO add substantive abort check
return False
else:
return False
# canceling fleet orders
debug(" %s" % fleet_order)
debug(
"Fleet %d had a target planet that is no longer valid for this mission; aborting."
% self.fleet.id)
self.clear_fleet_orders()
self.clear_target()
FleetUtilsAI.split_fleet(self.fleet.id)
return True
def _check_abort_mission(self, fleet_order):
""" checks if current mission (targeting a planet) should be aborted"""
planet_stealthed = False
target_is_planet = fleet_order.target and isinstance(fleet_order.target, TargetPlanet)
planet = None
if target_is_planet:
planet = fleet_order.target.get_object()
# Check visibility prediction, but if somehow still have current visibility, don't
# abort the mission yet
if not EspionageAI.colony_detectable_by_empire(planet.id, empire=fo.empireID()):
if get_partial_visibility_turn(planet.id) == fo.currentTurn():
debug("EspionageAI predicts planet id %d to be stealthed" % planet.id +
", but somehow have current visibity anyway, so won't trigger mission abort")
else:
debug("EspionageAI predicts we can no longer detect %s, will abort mission" % fleet_order.target)
planet_stealthed = True
if target_is_planet and not planet_stealthed:
if isinstance(fleet_order, OrderColonize):
if (planet.initialMeterValue(fo.meterType.population) == 0 and
(planet.ownedBy(fo.empireID()) or planet.unowned)):
return False
elif isinstance(fleet_order, OrderOutpost):
if planet.unowned:
return False
elif isinstance(fleet_order, OrderInvade): # TODO add substantive abort check
return False
else:
return False
# canceling fleet orders
debug(" %s" % fleet_order)
debug("Fleet %d had a target planet that is no longer valid for this mission; aborting." % self.fleet.id)
self.clear_fleet_orders()
self.clear_target()
FleetUtilsAI.split_fleet(self.fleet.id)
return True
def evaluate_invasion_planet(planet_id, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
detail = []
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
# TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empire_id = fo.empireID()
max_jumps = 8
planet = universe.getPlanet(planet_id)
if planet is None: # TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d" % planet_id
return [0, 0]
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet_id)
if planet_partial_vis_turn < sys_partial_vis_turn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
# TODO: track detection strength, order new scouting when it goes up
return [0, 0] # last time we had partial vis of the system, the planet was stealthed to us
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], MissionType.INVASION, None, detail)
pop_val = max(0.75 * planet_eval.get(planet_id, [0])[0],
ColonisationAI.evaluate_planet(planet_id, MissionType.OUTPOST, None, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, MissionType.INVASION, species_name, detail)
bld_tally = 0
for bldType in [universe.getBuilding(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
tech_tally = 0
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_tally += rp_cost * 4
detail.append("%s: %d" % (unlocked_tech, rp_cost * 4))
p_sys_id = planet.systemID
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = planet.systemID
if (home_system_id != INVALID_ID) and (eval_system_id != INVALID_ID):
least_jumps_path = list(universe.leastJumpsPath(home_system_id, eval_system_id, empire_id))
max_jumps = len(least_jumps_path)
system_status = foAI.foAIstate.systemStatus.get(p_sys_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(p_sys_id)
secure_targets = [p_sys_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
if mission.type == MissionType.SECURE:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating', 0)
if verbose:
print ("Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f") % (
planet, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat,
system_monster_threat)
supply_val = 0
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) +
2*planet.currentMeterValue(fo.meterType.targetResearch))
if p_sys_id in ColonisationAI.annexable_system_ids: # TODO: extend to rings
supply_val = 100
elif p_sys_id in state.get_systems_by_supply_tier(-1):
supply_val = 200
elif p_sys_id in state.get_systems_by_supply_tier(-2):
supply_val = 300
elif p_sys_id in state.get_systems_by_supply_tier(-3):
supply_val = 400
if max_path_threat > 0.5 * mil_ship_rating:
if max_path_threat < 3 * mil_ship_rating:
supply_val *= 0.5
else:
supply_val *= 0.2
# devalue invasions that would require too much military force
threat_factor = min(1, 0.2*MilitaryAI.get_tot_mil_rating()/(sys_total_threat+0.001))**2
design_id, _, locs = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / 6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(design.troopCapacity,
CombatRatingsAI.get_species_troops_grade(species_here))
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
ships_needed = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints, 1)
normalized_cost = max(1., normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = pop_val + supply_val + bld_tally + tech_tally + enemy_val - cost_score
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, base_score)
if clear_path:
planet_score *= 1.5
if verbose:
print (' - planet score: %.2f\n'
' - troop score: %.2f\n'
' - projected troop cost: %.1f\n'
' - threat factor: %s\n'
' - planet detail: %s\n'
' - popval: %.1f\n'
' - supplyval: %.1f\n'
' - bldval: %s\n'
' - enemyval: %s') % (planet_score, planned_troops, troop_cost,
threat_factor, detail, pop_val, supply_val, bld_tally, enemy_val)
return [planet_score, planned_troops]
def __update_system_status(self):
print 10 * "=", "Updating System Threats", 10 * "="
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
destroyed_object_ids = universe.destroyedObjectIDs(empire_id)
supply_unobstructed_systems = set(empire.supplyUnobstructedSystems)
min_hidden_attack = 4
min_hidden_health = 8
observed_empires = self.misc.setdefault("observed_empires", set())
# TODO: Variables that are recalculated each turn from scratch should not be stored in AIstate
# clear previous game state
for sys_id in self.systemStatus:
self.systemStatus[sys_id]['enemy_ship_count'] = 0
self.systemStatus[sys_id]['myFleetRating'] = 0
self.systemStatus[sys_id]['myFleetRatingVsPlanets'] = 0
# for use in debugging
verbose = False
# assess enemy fleets that may have been momentarily visible
enemies_by_system = {}
my_fleets_by_system = {}
fleet_spot_position = {}
current_turn = fo.currentTurn()
for fleet_id in universe.fleetIDs:
fleet = universe.getFleet(fleet_id)
if not fleet or fleet.empty:
self.delete_fleet_info(fleet_id) # this is safe even if fleet wasn't mine
continue
# TODO: check if currently in system and blockaded before accepting destination as location
this_system_id = fleet.nextSystemID if fleet.nextSystemID != INVALID_ID else fleet.systemID
dead_fleet = fleet_id in destroyed_object_ids
if dead_fleet:
self.delete_fleet_info(fleet_id)
if fleet.ownedBy(empire_id):
if not dead_fleet:
my_fleets_by_system.setdefault(this_system_id, []).append(fleet_id)
fleet_spot_position.setdefault(fleet.systemID, []).append(fleet_id)
continue
# TODO: consider checking death of individual ships. If ships had been moved from this fleet
# into another fleet, we might have witnessed their death in that other fleet but if this fleet
# had not been seen since before that transfer then the ships might also still be listed here.
if dead_fleet:
continue
# we are only interested in immediately recent data
if get_partial_visibility_turn(fleet_id) < (current_turn - 1):
continue
sys_status = self.systemStatus.setdefault(this_system_id, {})
sys_status['enemy_ship_count'] = sys_status.get('enemy_ship_count', 0) + len(fleet.shipIDs)
enemies_by_system.setdefault(this_system_id, []).append(fleet_id)
if not fleet.unowned:
self.misc.setdefault('enemies_sighted', {}).setdefault(current_turn, []).append(fleet_id)
observed_empires.add(fleet.owner)
# assess fleet and planet threats & my local fleets
for sys_id in universe.systemIDs:
sys_status = self.systemStatus.setdefault(sys_id, {})
system = universe.getSystem(sys_id)
if verbose:
print "AIState threat evaluation for %s" % system
# update fleets
sys_status['myfleets'] = my_fleets_by_system.get(sys_id, [])
sys_status['myFleetsAccessible'] = fleet_spot_position.get(sys_id, [])
local_enemy_fleet_ids = enemies_by_system.get(sys_id, [])
sys_status['localEnemyFleetIDs'] = local_enemy_fleet_ids
if system:
sys_status['name'] = system.name
# update threats
monster_ratings = [] # immobile
enemy_ratings = [] # owned & mobile
mob_ratings = [] # mobile & unowned
mobile_fleets = [] # mobile and either owned or unowned
for fid in local_enemy_fleet_ids:
fleet = universe.getFleet(fid) # ensured to exist
fleet_rating = CombatRatingsAI.get_fleet_rating(
fid, enemy_stats=CombatRatingsAI.get_empire_standard_fighter())
if fleet.speed == 0:
monster_ratings.append(fleet_rating)
if verbose:
print "\t immobile enemy fleet %s has rating %.1f" % (fleet, fleet_rating)
continue
if verbose:
print "\t mobile enemy fleet %s has rating %.1f" % (fleet, fleet_rating)
mobile_fleets.append(fid)
if fleet.unowned:
mob_ratings.append(fleet_rating)
else:
enemy_ratings.append(fleet_rating)
enemy_rating = CombatRatingsAI.combine_ratings_list(enemy_ratings)
monster_rating = CombatRatingsAI.combine_ratings_list(monster_ratings)
mob_rating = CombatRatingsAI.combine_ratings_list(mob_ratings)
lost_fleets = fleetsLostBySystem.get(sys_id, [])
lost_fleet_rating = CombatRatingsAI.combine_ratings_list(lost_fleets)
# under current visibility rules should not be possible to have any losses or other info here,
# but just in case...
partial_vis_turn = get_partial_visibility_turn(sys_id)
if not system or partial_vis_turn < 0:
if verbose:
print "Never had partial vis for %s - basing threat assessment on old info and lost ships" % system
sys_status.setdefault('local_fleet_threats', set())
sys_status['planetThreat'] = 0
sys_status['fleetThreat'] = max(
CombatRatingsAI.combine_ratings(enemy_rating, mob_rating),
0.98 * sys_status.get('fleetThreat', 0),
1.1*lost_fleet_rating - monster_rating)
sys_status['monsterThreat'] = max(
monster_rating,
0.98 * sys_status.get('monsterThreat', 0),
1.1*lost_fleet_rating - enemy_rating - mob_rating)
sys_status['enemy_threat'] = max(
enemy_rating,
0.98 * sys_status.get('enemy_threat', 0),
1.1*lost_fleet_rating - monster_rating - mob_rating)
sys_status['mydefenses'] = {'overall': 0, 'attack': 0, 'health': 0}
sys_status['totalThreat'] = sys_status['fleetThreat']
sys_status['regional_fleet_threats'] = sys_status['local_fleet_threats'].copy()
continue
# have either stale or current info
pattack = phealth = 0
mypattack = myphealth = 0
for pid in system.planetIDs:
planet = universe.getPlanet(pid)
if not planet:
continue
prating = self.assess_planet_threat(pid, sighting_age=current_turn - partial_vis_turn)
if planet.ownedBy(empire_id): # TODO: check for diplomatic status
mypattack += prating['attack']
myphealth += prating['health']
else:
pattack += prating['attack']
phealth += prating['health']
if any("_NEST_" in special for special in planet.specials):
sys_status['nest_threat'] = 100
sys_status['planetThreat'] = pattack * phealth
sys_status['mydefenses'] = {'overall': mypattack * myphealth, 'attack': mypattack, 'health': myphealth}
# previous threat assessment could account for losses, ignore the losses now
if max(sys_status.get('totalThreat', 0), pattack * phealth) >= 0.6 * lost_fleet_rating:
lost_fleet_rating = 0
# TODO use sitrep combat info rather than estimating stealthed enemies by fleets lost to them
# TODO also only consider past stealthed fleet threat to still be present if the system is still obstructed
# TODO: track visibility across turns in order to distinguish the blip of visibility in (losing) combat,
# which FO currently treats as being for the previous turn,
# partially superseding the previous visibility for that turn
if not partial_vis_turn == current_turn:
sys_status.setdefault('local_fleet_threats', set())
sys_status['currently_visible'] = False
# print ("Stale visibility for system %d ( %s ) -- last seen %d, "
# "current Turn %d -- basing threat assessment on old info and lost ships") % (
# sys_id, sys_status.get('name', "name unknown"), partial_vis_turn, currentTurn)
sys_status['fleetThreat'] = max(
CombatRatingsAI.combine_ratings(enemy_rating, mob_rating),
0.98 * sys_status.get('fleetThreat', 0),
2.0 * lost_fleet_rating - max(sys_status.get('monsterThreat', 0), monster_rating))
sys_status['enemy_threat'] = max(
enemy_rating,
0.98 * sys_status.get('enemy_threat', 0),
1.1*lost_fleet_rating - max(sys_status.get('monsterThreat', 0), monster_rating))
sys_status['monsterThreat'] = max(monster_rating, 0.98 * sys_status.get('monsterThreat', 0))
# sys_status['totalThreat'] = ((pattack + enemy_attack + monster_attack) ** 0.8)\
# * ((phealth + enemy_health + monster_health)** 0.6) # reevaluate this
sys_status['totalThreat'] = max(
CombatRatingsAI.combine_ratings_list([enemy_rating, mob_rating, monster_rating, pattack * phealth]),
2 * lost_fleet_rating,
0.98 * sys_status.get('totalThreat', 0))
else: # system considered visible
sys_status['currently_visible'] = True
sys_status['local_fleet_threats'] = set(mobile_fleets)
# includes mobile monsters
sys_status['fleetThreat'] = max(
CombatRatingsAI.combine_ratings(enemy_rating, mob_rating), 2*lost_fleet_rating - monster_rating)
if verbose:
print "enemy threat calc parts: enemy rating %.1f, lost fleet rating %.1f, monster_rating %.1f" % (
enemy_rating, lost_fleet_rating, monster_rating)
# does NOT include mobile monsters
sys_status['enemy_threat'] = max(enemy_rating, 2*lost_fleet_rating - monster_rating)
sys_status['monsterThreat'] = monster_rating
sys_status['totalThreat'] = CombatRatingsAI.combine_ratings_list(
[enemy_rating, mob_rating, monster_rating, pattack * phealth])
sys_status['regional_fleet_threats'] = sys_status['local_fleet_threats'].copy()
sys_status['fleetThreat'] = max(sys_status['fleetThreat'], sys_status.get('nest_threat', 0))
sys_status['totalThreat'] = max(sys_status['totalThreat'], sys_status.get('nest_threat', 0))
# has been seen with Partial Vis, but is currently supply-blocked
if partial_vis_turn > 0 and sys_id not in supply_unobstructed_systems:
sys_status['fleetThreat'] = max(sys_status['fleetThreat'], min_hidden_attack * min_hidden_health)
sys_status['totalThreat'] = max(
sys_status['totalThreat'],
((pattack + min_hidden_attack) ** 0.8) * ((phealth + min_hidden_health) ** 0.6))
if verbose and sys_status['fleetThreat'] > 0:
print "%s intermediate status: %s" % (system, sys_status)
enemy_supply, enemy_near_supply = self.assess_enemy_supply() # TODO: assess change in enemy supply over time
# assess secondary threats (threats of surrounding systems) and update my fleet rating
for sys_id in universe.systemIDs:
sys_status = self.systemStatus[sys_id]
sys_status['enemies_supplied'] = enemy_supply.get(sys_id, [])
observed_empires.update(enemy_supply.get(sys_id, []))
sys_status['enemies_nearly_supplied'] = enemy_near_supply.get(sys_id, [])
my_ratings_list = []
my_ratings_against_planets_list = []
for fid in sys_status['myfleets']:
this_rating = self.get_rating(fid, True, self.get_standard_enemy())
my_ratings_list.append(this_rating)
my_ratings_against_planets_list.append(self.get_rating(fid, against_planets=True))
if sys_id != INVALID_ID:
sys_status['myFleetRating'] = CombatRatingsAI.combine_ratings_list(my_ratings_list)
sys_status['myFleetRatingVsPlanets'] = CombatRatingsAI.combine_ratings_list(
my_ratings_against_planets_list)
sys_status['all_local_defenses'] = CombatRatingsAI.combine_ratings(
sys_status['myFleetRating'], sys_status['mydefenses']['overall'])
sys_status['neighbors'] = set(universe.getImmediateNeighbors(sys_id, self.empireID))
for sys_id in universe.systemIDs:
sys_status = self.systemStatus[sys_id]
neighbors = sys_status.get('neighbors', set())
this_system = universe.getSystem(sys_id)
if verbose:
print "Regional Assessment for %s with local fleet threat %.1f" % (
this_system, sys_status.get('fleetThreat', 0))
jumps2 = set()
jumps3 = set()
jumps4 = set()
for seta, setb in [(neighbors, jumps2), (jumps2, jumps3), (jumps3, jumps4)]:
for sys2id in seta:
setb.update(self.systemStatus.get(sys2id, {}).get('neighbors', set()))
jump2ring = jumps2 - neighbors - {sys_id}
jump3ring = jumps3 - jumps2 - neighbors - {sys_id}
jump4ring = jumps4 - jumps3 - jumps2 - neighbors - {sys_id}
sys_status['2jump_ring'] = jump2ring
sys_status['3jump_ring'] = jump3ring
sys_status['4jump_ring'] = jump4ring
threat, max_threat, myrating, j1_threats = self.area_ratings(neighbors)
sys_status['neighborThreat'] = threat
sys_status['max_neighbor_threat'] = max_threat
sys_status['my_neighbor_rating'] = myrating
threat, max_threat, myrating, j2_threats = self.area_ratings(jump2ring)
sys_status['jump2_threat'] = threat
sys_status['my_jump2_rating'] = myrating
threat, max_threat, myrating, j3_threats = self.area_ratings(jump3ring)
sys_status['jump3_threat'] = threat
sys_status['my_jump3_rating'] = myrating
# for local system includes both enemies and mobs
threat_keys = ['fleetThreat', 'neighborThreat', 'jump2_threat']
sys_status['regional_threat'] = CombatRatingsAI.combine_ratings_list(
[sys_status.get(x, 0) for x in threat_keys])
# TODO: investigate cases where regional_threat has been nonzero but no regional_threat_fleets
# (probably due to attenuating history of past threats)
sys_status.setdefault('regional_fleet_threats', set()).update(j1_threats, j2_threats)
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
aistate = get_aistate()
visible_system_ids = list(aistate.visInteriorSystemIDs) + list(
aistate.visBorderSystemIDs)
if home_system_id != INVALID_ID:
accessible_system_ids = [
sys_id for sys_id in visible_system_ids
if systems_connected(sys_id, home_system_id)
]
else:
debug(
"Empire has no identifiable homeworld; will treat all visible planets as accessible."
)
# TODO: check if any troop ships owned, use their system as home system
accessible_system_ids = visible_system_ids
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(
accessible_system_ids)
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(
acessible_planet_ids) # includes unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(
acessible_planet_ids) # includes unowned natives
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(
universe.planetIDs)
invadable_planet_ids = set(all_owned_planet_ids).union(
all_populated_planets) - set(empire_owned_planet_ids)
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(
universe.planetIDs, MissionType.INVASION)
invasion_targeted_planet_ids.extend(
get_invasion_targeted_planet_ids(universe.planetIDs,
MissionType.ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(
PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
MissionType.INVASION)
num_invasion_fleets = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(
invasion_fleet_ids))
debug("Current Invasion Targeted SystemIDs: %s" %
PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs))
debug("Current Invasion Targeted PlanetIDs: %s" %
PlanetUtilsAI.planet_string(invasion_targeted_planet_ids))
debug(invasion_fleet_ids and "Invasion Fleet IDs: %s" % invasion_fleet_ids
or "Available Invasion Fleets: 0")
debug("Invasion Fleets Without Missions: %s" % num_invasion_fleets)
invasion_timer.start("planning troop base production")
reserved_troop_base_targets = []
if aistate.character.may_invade_with_bases():
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
# For planning base trooper invasion targets we have a two-pass system. (1) In the first pass we consider all
# the invasion targets and figure out which ones appear to be suitable for using base troopers against (i.e., we
# already have a populated planet in the same system that could build base troopers) and we have at least a
# minimal amount of PP available, and (2) in the second pass we go through the reserved base trooper target list
# and check to make sure that there does not appear to be too much military action still needed before the
# target is ready to be invaded, we double check that not too many base troopers would be needed, and if things
# look clear then we queue up the base troopers on the Production Queue and keep track of where we are building
# them, and how many; we may also disqualify and remove previously qualified targets (in case, for example,
# we lost our base trooper source planet since it was first added to list).
#
# For planning and tracking base troopers under construction, we use a dictionary store in
# get_aistate().qualifyingTroopBaseTargets, keyed by the invasion target planet ID. We only store values
# for invasion targets that appear likely to be suitable for base trooper use, and store a 2-item list.
# The first item in this list is the ID of the planet where we expect to build the base troopers, and the second
# entry initially is set to INVALID_ID (-1). The presence of this entry in qualifyingTroopBaseTargets
# flags this target as being reserved as a base-trooper invasion target.
# In the second pass, if/when we actually start construction, then we modify the record, replacing that second
# value with the ID of the planet where the troopers are actually being built. (Right now that is always the
# same as the source planet originally identified, but we could consider reevaluating that, or use that second
# value to instead record how many base troopers have been queued, so that on later turns we can assess if the
# process got delayed & perhaps more troopers need to be queued).
# Pass 1: identify qualifying base troop invasion targets
for pid in invadable_planet_ids: # TODO: reorganize
if pid in aistate.qualifyingTroopBaseTargets:
continue
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = get_partial_visibility_turn(sys_id)
planet_partial_vis_turn = get_partial_visibility_turn(pid)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
best_base_planet = INVALID_ID
best_trooper_count = 0
for pid2 in get_colonized_planets_in_system(sys_id):
if available_pp.get(
pid2, 0
) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2 or not can_build_ship_for_species(
planet2.speciesName):
continue
best_base_trooper_here = get_best_ship_info(
PriorityType.PRODUCTION_ORBITAL_INVASION, pid2)[1]
if not best_base_trooper_here:
continue
troops_per_ship = best_base_trooper_here.troopCapacity
if not troops_per_ship:
continue
species_troop_grade = get_species_tag_grade(
planet2.speciesName, Tags.ATTACKTROOPS)
troops_per_ship = CombatRatingsAI.weight_attack_troops(
troops_per_ship, species_troop_grade)
if troops_per_ship > best_trooper_count:
best_base_planet = pid2
best_trooper_count = troops_per_ship
if best_base_planet != INVALID_ID:
aistate.qualifyingTroopBaseTargets.setdefault(
pid, [best_base_planet, INVALID_ID])
# Pass 2: for each target previously identified for base troopers, check that still qualifies and
# check how many base troopers would be needed; if reasonable then queue up the troops and record this in
# get_aistate().qualifyingTroopBaseTargets
for pid in list(aistate.qualifyingTroopBaseTargets.keys()):
planet = universe.getPlanet(pid)
if planet and planet.owner == empire_id:
del aistate.qualifyingTroopBaseTargets[pid]
continue
if pid in invasion_targeted_planet_ids: # TODO: consider overriding standard invasion mission
continue
if aistate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
# TODO: evaluate changes to situation, any more troops needed, etc.
continue # already building for here
_, planet_troops = evaluate_invasion_planet(pid)
sys_id = planet.systemID
this_sys_status = aistate.systemStatus.get(sys_id, {})
troop_tally = 0
for _fid in this_sys_status.get("myfleets", []):
troop_tally += FleetUtilsAI.count_troops_in_fleet(_fid)
if troop_tally > planet_troops: # base troopers appear unneeded
del aistate.qualifyingTroopBaseTargets[pid]
continue
if planet.currentMeterValue(fo.meterType.shield) > 0 and (
this_sys_status.get("myFleetRating", 0) <
0.8 * this_sys_status.get("totalThreat", 0)
or this_sys_status.get("myFleetRatingVsPlanets", 0) <
this_sys_status.get("planetThreat", 0)):
# this system not secured, so ruling out invasion base troops for now
# don't immediately delete from qualifyingTroopBaseTargets or it will be opened up for regular troops
continue
loc = aistate.qualifyingTroopBaseTargets[pid][0]
best_base_trooper_here = get_best_ship_info(
PriorityType.PRODUCTION_ORBITAL_INVASION, loc)[1]
loc_planet = universe.getPlanet(loc)
if best_base_trooper_here is None: # shouldn't be possible at this point, but just to be safe
warning(
"Could not find a suitable orbital invasion design at %s" %
loc_planet)
continue
# TODO: have TroopShipDesigner give the expected number of troops including species effects directly
troops_per_ship = best_base_trooper_here.troopCapacity
species_troop_grade = get_species_tag_grade(
loc_planet.speciesName, Tags.ATTACKTROOPS)
troops_per_ship = CombatRatingsAI.weight_attack_troops(
troops_per_ship, species_troop_grade)
if not troops_per_ship:
warning(
"The best orbital invasion design at %s seems not to have any troop capacity."
% loc_planet)
continue
_, col_design, build_choices = get_best_ship_info(
PriorityType.PRODUCTION_ORBITAL_INVASION, loc)
if not col_design:
continue
if loc not in build_choices:
warning(
"Best troop design %s can not be produced at planet with id: %s"
% (col_design, build_choices))
continue
n_bases = math.ceil(
(planet_troops + 1) /
troops_per_ship) # TODO: reconsider this +1 safety factor
# TODO: evaluate cost and time-to-build of best base trooper here versus cost and time-to-build-and-travel
# for best regular trooper elsewhere
# For now, we assume what building base troopers is best so long as either (1) we would need no more than
# MAX_BASE_TROOPERS_POOR_INVADERS base troop ships, or (2) our base troopers have more than 1 trooper per
# ship and we would need no more than MAX_BASE_TROOPERS_GOOD_INVADERS base troop ships
if n_bases > MAX_BASE_TROOPERS_POOR_INVADERS or (
troops_per_ship > 1
and n_bases > MAX_BASE_TROOPERS_GOOD_INVADERS):
debug(
"ruling out base invasion troopers for %s due to high number (%d) required."
% (planet, n_bases))
del aistate.qualifyingTroopBaseTargets[pid]
continue
debug(
"Invasion base planning, need %d troops at %d per ship, will build %d ships."
% ((planet_troops + 1), troops_per_ship, n_bases))
retval = fo.issueEnqueueShipProductionOrder(col_design.id, loc)
debug("Enqueueing %d Troop Bases at %s for %s" %
(n_bases, PlanetUtilsAI.planet_string(loc),
PlanetUtilsAI.planet_string(pid)))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
aistate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(
empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1,
0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(
set(invadable_planet_ids) - set(invasion_targeted_planet_ids) -
set(reserved_troop_base_targets))
evaluated_planets = assign_invasion_values(evaluated_planet_ids)
sorted_planets = [(pid, pscore % 10000, ptroops)
for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops)
for pid, pscore, ptroops in sorted_planets]
invasion_table = Table(
Text("Planet"),
Number("Score"),
Text("Species"),
Number("Troops"),
table_name="Potential Targets for Invasion Turn %d" % fo.currentTurn(),
)
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
invasion_table.add_row(planet, pscore, planet and planet.speciesName
or "unknown", ptroops)
invasion_table.print_table(info)
sorted_planets = [x for x in sorted_planets if x[1] > 0]
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, __, __ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" %
(len(evaluated_planet_ids)))
invasion_timer.stop_print_and_clear()
def issue_fleet_orders(self):
"""issues AIFleetOrders which can be issued in system and moves to next one if is possible"""
# TODO: priority
order_completed = True
debug("\nChecking orders for fleet %s (on turn %d), with mission type %s and target %s",
self.fleet.get_object(), fo.currentTurn(), self.type or 'No mission', self.target or 'No Target')
if MissionType.INVASION == self.type:
self._check_retarget_invasion()
just_issued_move_order = False
last_move_target_id = INVALID_ID
# Note: the following abort check somewhat assumes only one major mission type
for fleet_order in self.orders:
if (isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)) and
self._check_abort_mission(fleet_order)):
return
aistate = get_aistate()
for fleet_order in self.orders:
if just_issued_move_order and self.fleet.get_object().systemID != last_move_target_id:
# having just issued a move order, we will normally stop issuing orders this turn, except that if there
# are consecutive move orders we will consider moving through the first destination rather than stopping
# Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test
# noinspection PyTypeChecker
if (not isinstance(fleet_order, OrderMove) or
self.need_to_pause_movement(last_move_target_id, fleet_order)):
break
debug("Checking order: %s" % fleet_order)
self.check_mergers(context=str(fleet_order))
if fleet_order.can_issue_order(verbose=False):
# only move if all other orders completed
if isinstance(fleet_order, OrderMove) and order_completed:
debug("Issuing fleet order %s" % fleet_order)
fleet_order.issue_order()
just_issued_move_order = True
last_move_target_id = fleet_order.target.id
elif not isinstance(fleet_order, OrderMove):
debug("Issuing fleet order %s" % fleet_order)
fleet_order.issue_order()
else:
debug("NOT issuing (even though can_issue) fleet order %s" % fleet_order)
status_words = tuple(["not", ""][_s] for _s in [fleet_order.order_issued, fleet_order.executed])
debug("Order %s issued and %s fully executed." % status_words)
if not fleet_order.executed:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.order_issued:
# A previously issued order that wasn't instantly executed must have had cirumstances change so that
# the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same
# turn the order was issued).
if not fleet_order.executed:
order_completed = False
# Go on to the next order.
continue
debug("CAN'T issue fleet order %s because:" % fleet_order)
fleet_order.can_issue_order(verbose=True)
if isinstance(fleet_order, OrderMove):
this_system_id = fleet_order.target.id
this_status = aistate.systemStatus.setdefault(this_system_id, {})
threat_threshold = fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating() / 4.0
if this_status.get('monsterThreat', 0) > threat_threshold:
# if this move order is not this mil fleet's final destination, and blocked by Big Monster,
# release and hope for more effective reassignment
if (self.type not in (MissionType.MILITARY, MissionType.SECURE) or
fleet_order != self.orders[-1]):
debug("Aborting mission due to being blocked by Big Monster at system %d, threat %d" % (
this_system_id, aistate.systemStatus[this_system_id]['monsterThreat']))
debug("Full set of orders were:")
for this_order in self.orders:
debug(" - %s" % this_order)
self.clear_fleet_orders()
self.clear_target()
return
break # do not order the next order until this one is finished.
else: # went through entire order list
if order_completed:
debug("Final order is completed")
orders = self.orders
last_order = orders[-1] if orders else None
universe = fo.getUniverse()
if last_order and isinstance(last_order, OrderColonize):
planet = universe.getPlanet(last_order.target.id)
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet.id)
if (planet_partial_vis_turn == sys_partial_vis_turn and
not planet.initialMeterValue(fo.meterType.population)):
warn("Fleet %d has tentatively completed its "
"colonize mission but will wait to confirm population." % self.fleet.id)
debug(" Order details are %s" % last_order)
debug(" Order is valid: %s; issued: %s; executed: %s" % (
last_order.is_valid(), last_order.order_issued, last_order.executed))
if not last_order.is_valid():
source_target = last_order.fleet
target_target = last_order.target
debug(" source target validity: %s; target target validity: %s " % (
bool(source_target), bool(target_target)))
return # colonize order must not have completed yet
clear_all = True
last_sys_target = INVALID_ID
if last_order and isinstance(last_order, OrderMilitary):
last_sys_target = last_order.target.id
# not doing this until decide a way to release from a SECURE mission
# if (MissionType.SECURE == self.type) or
secure_targets = set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs)
if last_sys_target in secure_targets: # consider a secure mission
if last_sys_target in AIstate.colonyTargetedSystemIDs:
secure_type = "Colony"
elif last_sys_target in AIstate.outpostTargetedSystemIDs:
secure_type = "Outpost"
elif last_sys_target in AIstate.invasionTargetedSystemIDs:
secure_type = "Invasion"
else:
secure_type = "Unidentified"
debug("Fleet %d has completed initial stage of its mission "
"to secure system %d (targeted for %s), "
"may release a portion of ships" % (self.fleet.id, last_sys_target, secure_type))
clear_all = False
# for PROTECT_REGION missions, only release fleet if no more threat
if self.type == MissionType.PROTECT_REGION:
# use military logic code below to determine if can release
# any or even all of the ships.
clear_all = False
last_sys_target = self.target.id
debug("Check if PROTECT_REGION mission with target %d is finished.", last_sys_target)
fleet_id = self.fleet.id
if clear_all:
if orders:
debug("Fleet %d has completed its mission; clearing all orders and targets." % self.fleet.id)
debug("Full set of orders were:")
for this_order in orders:
debug("\t\t %s" % this_order)
self.clear_fleet_orders()
self.clear_target()
if aistate.get_fleet_role(fleet_id) in (MissionType.MILITARY, MissionType.SECURE):
allocations = MilitaryAI.get_military_fleets(mil_fleets_ids=[fleet_id],
try_reset=False,
thisround="Fleet %d Reassignment" % fleet_id)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=[fleet_id],
allocations=allocations)
else: # no orders
debug("No Current Orders")
else:
potential_threat = CombatRatingsAI.combine_ratings(
MilitaryAI.get_system_local_threat(last_sys_target),
MilitaryAI.get_system_neighbor_threat(last_sys_target)
)
threat_present = potential_threat > 0
debug("Fleet threat present? %s", threat_present)
target_system = universe.getSystem(last_sys_target)
if not threat_present and target_system:
for pid in target_system.planetIDs:
planet = universe.getPlanet(pid)
if (planet and
planet.owner != fo.empireID() and
planet.currentMeterValue(fo.meterType.maxDefense) > 0):
debug("Found local planetary threat: %s", planet)
threat_present = True
break
if not threat_present:
debug("No current threat in target system; releasing a portion of ships.")
# at least first stage of current task is done;
# release extra ships for potential other deployments
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id)
if self.type == MissionType.PROTECT_REGION:
self.clear_fleet_orders()
self.clear_target()
new_fleets.append(self.fleet.id)
else:
debug("Threat remains in target system; Considering to release some ships.")
new_fleets = []
fleet_portion_to_remain = self._portion_of_fleet_needed_here()
if fleet_portion_to_remain > 1:
debug("Can not release fleet yet due to large threat.")
elif fleet_portion_to_remain > 0:
debug("Not all ships are needed here - considering releasing a few")
fleet_remaining_rating = CombatRatingsAI.get_fleet_rating(fleet_id)
fleet_min_rating = fleet_portion_to_remain * fleet_remaining_rating
debug("Starting rating: %.1f, Target rating: %.1f",
fleet_remaining_rating, fleet_min_rating)
allowance = CombatRatingsAI.rating_needed(fleet_remaining_rating, fleet_min_rating)
debug("May release ships with total rating of %.1f", allowance)
ship_ids = list(self.fleet.get_object().shipIDs)
for ship_id in ship_ids:
ship_rating = CombatRatingsAI.get_ship_rating(ship_id)
debug("Considering to release ship %d with rating %.1f", ship_id, ship_rating)
if ship_rating > allowance:
debug("Remaining rating insufficient. Not released.")
continue
debug("Splitting from fleet.")
new_fleet_id = FleetUtilsAI.split_ship_from_fleet(fleet_id, ship_id)
if assertion_fails(new_fleet_id and new_fleet_id != INVALID_ID):
break
new_fleets.append(new_fleet_id)
fleet_remaining_rating = CombatRatingsAI.rating_difference(
fleet_remaining_rating, ship_rating)
allowance = CombatRatingsAI.rating_difference(
fleet_remaining_rating, fleet_min_rating)
debug("Remaining fleet rating: %.1f - Allowance: %.1f",
fleet_remaining_rating, allowance)
if new_fleets:
aistate.get_fleet_role(fleet_id, force_new=True)
aistate.update_fleet_rating(fleet_id)
aistate.ensure_have_fleet_missions(new_fleets)
else:
debug("Planetary defenses are deemed sufficient. Release fleet.")
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id)
new_military_fleets = []
for fleet_id in new_fleets:
if aistate.get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES:
new_military_fleets.append(fleet_id)
allocations = []
if new_military_fleets:
allocations = MilitaryAI.get_military_fleets(
mil_fleets_ids=new_military_fleets,
try_reset=False,
thisround="Fleet Reassignment %s" % new_military_fleets
)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=new_military_fleets,
allocations=allocations)
def _risky_travel_starlane_func(c, d):
return any((_somewhat_careful_travel_starlane_func(c, d),
get_partial_visibility_turn(c) <= 0))
def __update_system_status(self):
debug('{0} Updating System Threats {0}'.format(10 * "="))
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
destroyed_object_ids = universe.destroyedObjectIDs(empire_id)
supply_unobstructed_systems = set(empire.supplyUnobstructedSystems)
min_hidden_attack = 4
min_hidden_health = 8
observed_empires = self.misc.setdefault("observed_empires", set())
# TODO: Variables that are recalculated each turn from scratch should not be stored in AIstate
# clear previous game state
for sys_id in self.systemStatus:
self.systemStatus[sys_id]['enemy_ship_count'] = 0
self.systemStatus[sys_id]['myFleetRating'] = 0
self.systemStatus[sys_id]['myFleetRatingVsPlanets'] = 0
# for use in debugging
verbose = False
# assess enemy fleets that may have been momentarily visible
enemies_by_system = {}
my_fleets_by_system = {}
fleet_spot_position = {}
current_turn = fo.currentTurn()
for fleet_id in universe.fleetIDs:
fleet = universe.getFleet(fleet_id)
if not fleet or fleet.empty:
self.delete_fleet_info(fleet_id) # this is safe even if fleet wasn't mine
continue
# TODO: check if currently in system and blockaded before accepting destination as location
this_system_id = fleet.nextSystemID if fleet.nextSystemID != INVALID_ID else fleet.systemID
dead_fleet = fleet_id in destroyed_object_ids
if dead_fleet:
self.delete_fleet_info(fleet_id)
if fleet.ownedBy(empire_id):
if not dead_fleet:
my_fleets_by_system.setdefault(this_system_id, []).append(fleet_id)
fleet_spot_position.setdefault(fleet.systemID, []).append(fleet_id)
continue
# TODO: consider checking death of individual ships. If ships had been moved from this fleet
# into another fleet, we might have witnessed their death in that other fleet but if this fleet
# had not been seen since before that transfer then the ships might also still be listed here.
if dead_fleet:
continue
# we are only interested in immediately recent data
if get_partial_visibility_turn(fleet_id) < (current_turn - 1):
continue
sys_status = self.systemStatus.setdefault(this_system_id, {})
sys_status['enemy_ship_count'] = sys_status.get('enemy_ship_count', 0) + len(fleet.shipIDs)
enemies_by_system.setdefault(this_system_id, []).append(fleet_id)
if not fleet.unowned:
self.misc.setdefault('enemies_sighted', {}).setdefault(current_turn, []).append(fleet_id)
observed_empires.add(fleet.owner)
# assess fleet and planet threats & my local fleets
for sys_id in universe.systemIDs:
sys_status = self.systemStatus.setdefault(sys_id, {})
system = universe.getSystem(sys_id)
if verbose:
debug("AIState threat evaluation for %s" % system)
# update fleets
sys_status['myfleets'] = my_fleets_by_system.get(sys_id, [])
sys_status['myFleetsAccessible'] = fleet_spot_position.get(sys_id, [])
local_enemy_fleet_ids = enemies_by_system.get(sys_id, [])
sys_status['localEnemyFleetIDs'] = local_enemy_fleet_ids
if system:
sys_status['name'] = system.name
# update threats
monster_ratings = [] # immobile
enemy_ratings = [] # owned & mobile
mob_ratings = [] # mobile & unowned
mobile_fleets = [] # mobile and either owned or unowned
for fid in local_enemy_fleet_ids:
fleet = universe.getFleet(fid) # ensured to exist
fleet_rating = CombatRatingsAI.get_fleet_rating(
fid, enemy_stats=CombatRatingsAI.get_empire_standard_fighter())
if fleet.speed == 0:
monster_ratings.append(fleet_rating)
if verbose:
debug("\t immobile enemy fleet %s has rating %.1f" % (fleet, fleet_rating))
continue
if verbose:
debug("\t mobile enemy fleet %s has rating %.1f" % (fleet, fleet_rating))
mobile_fleets.append(fid)
if fleet.unowned:
mob_ratings.append(fleet_rating)
else:
enemy_ratings.append(fleet_rating)
enemy_rating = CombatRatingsAI.combine_ratings_list(enemy_ratings)
monster_rating = CombatRatingsAI.combine_ratings_list(monster_ratings)
mob_rating = CombatRatingsAI.combine_ratings_list(mob_ratings)
lost_fleets = fleetsLostBySystem.get(sys_id, [])
lost_fleet_rating = CombatRatingsAI.combine_ratings_list(lost_fleets)
# under current visibility rules should not be possible to have any losses or other info here,
# but just in case...
partial_vis_turn = get_partial_visibility_turn(sys_id)
if not system or partial_vis_turn < 0:
if verbose:
debug("Never had partial vis for %s - basing threat assessment on old info and lost ships" % system)
sys_status.setdefault('local_fleet_threats', set())
sys_status['planetThreat'] = 0
sys_status['fleetThreat'] = max(
CombatRatingsAI.combine_ratings(enemy_rating, mob_rating),
0.98 * sys_status.get('fleetThreat', 0),
1.1*lost_fleet_rating - monster_rating)
sys_status['monsterThreat'] = max(
monster_rating,
0.98 * sys_status.get('monsterThreat', 0),
1.1*lost_fleet_rating - enemy_rating - mob_rating)
sys_status['enemy_threat'] = max(
enemy_rating,
0.98 * sys_status.get('enemy_threat', 0),
1.1*lost_fleet_rating - monster_rating - mob_rating)
sys_status['mydefenses'] = {'overall': 0, 'attack': 0, 'health': 0}
sys_status['totalThreat'] = sys_status['fleetThreat']
sys_status['regional_fleet_threats'] = sys_status['local_fleet_threats'].copy()
continue
# have either stale or current info
pattack = phealth = 0
mypattack = myphealth = 0
for pid in system.planetIDs:
planet = universe.getPlanet(pid)
if not planet:
continue
prating = self.assess_planet_threat(pid, sighting_age=current_turn - partial_vis_turn)
if planet.ownedBy(empire_id): # TODO: check for diplomatic status
mypattack += prating['attack']
myphealth += prating['health']
else:
pattack += prating['attack']
phealth += prating['health']
if any("_NEST_" in special for special in planet.specials):
sys_status['nest_threat'] = 100
sys_status['planetThreat'] = pattack * phealth
sys_status['mydefenses'] = {'overall': mypattack * myphealth, 'attack': mypattack, 'health': myphealth}
# previous threat assessment could account for losses, ignore the losses now
if max(sys_status.get('totalThreat', 0), pattack * phealth) >= 0.6 * lost_fleet_rating:
lost_fleet_rating = 0
# TODO use sitrep combat info rather than estimating stealthed enemies by fleets lost to them
# TODO also only consider past stealthed fleet threat to still be present if the system is still obstructed
# TODO: track visibility across turns in order to distinguish the blip of visibility in (losing) combat,
# which FO currently treats as being for the previous turn,
# partially superseding the previous visibility for that turn
if not partial_vis_turn == current_turn:
sys_status.setdefault('local_fleet_threats', set())
sys_status['currently_visible'] = False
# print ("Stale visibility for system %d ( %s ) -- last seen %d, "
# "current Turn %d -- basing threat assessment on old info and lost ships") % (
# sys_id, sys_status.get('name', "name unknown"), partial_vis_turn, currentTurn)
sys_status['fleetThreat'] = max(
CombatRatingsAI.combine_ratings(enemy_rating, mob_rating),
0.98 * sys_status.get('fleetThreat', 0),
2.0 * lost_fleet_rating - max(sys_status.get('monsterThreat', 0), monster_rating))
sys_status['enemy_threat'] = max(
enemy_rating,
0.98 * sys_status.get('enemy_threat', 0),
1.1*lost_fleet_rating - max(sys_status.get('monsterThreat', 0), monster_rating))
sys_status['monsterThreat'] = max(monster_rating, 0.98 * sys_status.get('monsterThreat', 0))
# sys_status['totalThreat'] = ((pattack + enemy_attack + monster_attack) ** 0.8)\
# * ((phealth + enemy_health + monster_health)** 0.6) # reevaluate this
sys_status['totalThreat'] = max(
CombatRatingsAI.combine_ratings_list([enemy_rating, mob_rating, monster_rating, pattack * phealth]),
2 * lost_fleet_rating,
0.98 * sys_status.get('totalThreat', 0))
else: # system considered visible
sys_status['currently_visible'] = True
sys_status['local_fleet_threats'] = set(mobile_fleets)
# includes mobile monsters
sys_status['fleetThreat'] = max(
CombatRatingsAI.combine_ratings(enemy_rating, mob_rating), 2*lost_fleet_rating - monster_rating)
if verbose:
debug("enemy threat calc parts: enemy rating %.1f, lost fleet rating %.1f, monster_rating %.1f" % (
enemy_rating, lost_fleet_rating, monster_rating))
# does NOT include mobile monsters
sys_status['enemy_threat'] = max(enemy_rating, 2*lost_fleet_rating - monster_rating)
sys_status['monsterThreat'] = monster_rating
sys_status['totalThreat'] = CombatRatingsAI.combine_ratings_list(
[enemy_rating, mob_rating, monster_rating, pattack * phealth])
sys_status['regional_fleet_threats'] = sys_status['local_fleet_threats'].copy()
sys_status['fleetThreat'] = max(sys_status['fleetThreat'], sys_status.get('nest_threat', 0))
sys_status['totalThreat'] = max(sys_status['totalThreat'], sys_status.get('nest_threat', 0))
# has been seen with Partial Vis, but is currently supply-blocked
if partial_vis_turn > 0 and sys_id not in supply_unobstructed_systems:
sys_status['fleetThreat'] = max(sys_status['fleetThreat'], min_hidden_attack * min_hidden_health)
sys_status['totalThreat'] = max(
sys_status['totalThreat'],
((pattack + min_hidden_attack) ** 0.8) * ((phealth + min_hidden_health) ** 0.6))
if verbose and sys_status['fleetThreat'] > 0:
debug("%s intermediate status: %s" % (system, sys_status))
enemy_supply, enemy_near_supply = self.assess_enemy_supply() # TODO: assess change in enemy supply over time
# assess secondary threats (threats of surrounding systems) and update my fleet rating
for sys_id in universe.systemIDs:
sys_status = self.systemStatus[sys_id]
sys_status['enemies_supplied'] = enemy_supply.get(sys_id, [])
observed_empires.update(enemy_supply.get(sys_id, []))
sys_status['enemies_nearly_supplied'] = enemy_near_supply.get(sys_id, [])
my_ratings_list = []
my_ratings_against_planets_list = []
for fid in sys_status['myfleets']:
this_rating = self.get_rating(fid, True, self.get_standard_enemy())
my_ratings_list.append(this_rating)
my_ratings_against_planets_list.append(self.get_rating(fid, against_planets=True))
if sys_id != INVALID_ID:
sys_status['myFleetRating'] = CombatRatingsAI.combine_ratings_list(my_ratings_list)
sys_status['myFleetRatingVsPlanets'] = CombatRatingsAI.combine_ratings_list(
my_ratings_against_planets_list)
sys_status['all_local_defenses'] = CombatRatingsAI.combine_ratings(
sys_status['myFleetRating'], sys_status['mydefenses']['overall'])
sys_status['neighbors'] = set(universe.getImmediateNeighbors(sys_id, self.empireID))
for sys_id in universe.systemIDs:
sys_status = self.systemStatus[sys_id]
neighbors = sys_status.get('neighbors', set())
this_system = universe.getSystem(sys_id)
if verbose:
debug("Regional Assessment for %s with local fleet threat %.1f" % (
this_system, sys_status.get('fleetThreat', 0)))
jumps2 = set()
jumps3 = set()
jumps4 = set()
for seta, setb in [(neighbors, jumps2), (jumps2, jumps3), (jumps3, jumps4)]:
for sys2id in seta:
setb.update(self.systemStatus.get(sys2id, {}).get('neighbors', set()))
jump2ring = jumps2 - neighbors - {sys_id}
jump3ring = jumps3 - jumps2 - neighbors - {sys_id}
jump4ring = jumps4 - jumps3 - jumps2 - neighbors - {sys_id}
sys_status['2jump_ring'] = jump2ring
sys_status['3jump_ring'] = jump3ring
sys_status['4jump_ring'] = jump4ring
threat, max_threat, myrating, j1_threats = self.area_ratings(neighbors)
sys_status['neighborThreat'] = threat
sys_status['max_neighbor_threat'] = max_threat
sys_status['my_neighbor_rating'] = myrating
threat, max_threat, myrating, j2_threats = self.area_ratings(jump2ring)
sys_status['jump2_threat'] = threat
sys_status['my_jump2_rating'] = myrating
threat, max_threat, myrating, j3_threats = self.area_ratings(jump3ring)
sys_status['jump3_threat'] = threat
sys_status['my_jump3_rating'] = myrating
# for local system includes both enemies and mobs
threat_keys = ['fleetThreat', 'neighborThreat', 'jump2_threat']
sys_status['regional_threat'] = CombatRatingsAI.combine_ratings_list(
[sys_status.get(x, 0) for x in threat_keys])
# TODO: investigate cases where regional_threat has been nonzero but no regional_threat_fleets
# (probably due to attenuating history of past threats)
sys_status.setdefault('regional_fleet_threats', set()).update(j1_threats, j2_threats)
def evaluate_invasion_planet(planet_id, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
universe = fo.getUniverse()
empire_id = fo.empireID()
detail = []
planet = universe.getPlanet(planet_id)
if planet is None:
debug("Invasion AI couldn't access any info for planet id %d" % planet_id)
return [0, 0]
system_id = planet.systemID
# by using the following instead of simply relying on stealth meter reading, can (sometimes) plan ahead even if
# planet is temporarily shrouded by an ion storm
predicted_detectable = EspionageAI.colony_detectable_by_empire(planet_id, empire=fo.empireID(),
default_result=False)
if not predicted_detectable:
if get_partial_visibility_turn(planet_id) < fo.currentTurn():
debug("InvasionAI predicts planet id %d to be stealthed" % planet_id)
return [0, 0]
else:
debug("InvasionAI predicts planet id %d to be stealthed" % planet_id +
", but somehow have current visibity anyway, will still consider as target")
# Check if the target planet was extra-stealthed somehow its system was last viewed
# this test below may augment the tests above, but can be thrown off by temporary combat-related sighting
system_last_seen = get_partial_visibility_turn(planet_id)
planet_last_seen = get_partial_visibility_turn(system_id)
if planet_last_seen < system_last_seen:
# TODO: track detection strength, order new scouting when it goes up
debug("Invasion AI considering planet id %d (stealthed at last view), still proceeding." % planet_id)
# get a baseline evaluation of the planet as determined by ColonisationAI
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], MissionType.INVASION, None, detail)
colony_base_value = max(0.75 * planet_eval.get(planet_id, [0])[0],
ColonisationAI.evaluate_planet(planet_id, MissionType.OUTPOST, None, detail))
else:
colony_base_value = ColonisationAI.evaluate_planet(planet_id, MissionType.INVASION, species_name, detail)
# Add extra score for all buildings on the planet
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
bld_tally = 0
for bldType in [universe.getBuilding(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
# Add extra score for unlocked techs when we conquer the species
tech_tally = 0
value_per_pp = 4
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_value = value_per_pp * rp_cost
tech_tally += tech_value
detail.append("%s: %d" % (unlocked_tech, tech_value))
max_jumps = 8
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld and homeworld.systemID != INVALID_ID and system_id != INVALID_ID:
least_jumps_path = list(universe.leastJumpsPath(homeworld.systemID, system_id, empire_id))
max_jumps = len(least_jumps_path)
aistate = get_aistate()
system_status = aistate.systemStatus.get(system_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = aistate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
troop_regen = planet.currentMeterValue(fo.meterType.troops) - planet.initialMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(system_id)
secure_targets = [system_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != system_id:
continue
if mission.type in [MissionType.SECURE, MissionType.MILITARY]:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating', 0)
if verbose:
debug("Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f",
planet, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat, system_monster_threat)
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) +
2*planet.currentMeterValue(fo.meterType.targetResearch))
# devalue invasions that would require too much military force
preferred_max_portion = MilitaryAI.get_preferred_max_military_portion_for_single_battle()
total_max_mil_rating = MilitaryAI.get_concentrated_tot_mil_rating()
threat_exponent = 2 # TODO: make this a character trait; higher aggression with a lower exponent
threat_factor = min(1, preferred_max_portion * total_max_mil_rating/(sys_total_threat+0.001))**threat_exponent
design_id, _, locs = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(troops + troop_regen*(max_jumps + build_time), max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / 6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(design.troopCapacity,
CombatRatingsAI.get_species_troops_grade(species_here))
planned_troops = troops if system_secured else min(troops + troop_regen*(max_jumps + build_time), max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
ships_needed = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints, 1)
normalized_cost = max(1., normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = colony_base_value + bld_tally + tech_tally + enemy_val - cost_score
# If the AI does have enough total miltary to attack this target, and the target is more than minimally valuable,
# don't let the threat_factor discount the adjusted value below MIN_INVASION_SCORE +1, so that if there are no
# other targets the AI could still pursue this one. Otherwise, scoring pressure from
# MilitaryAI.get_preferred_max_military_portion_for_single_battle might prevent the AI from attacking heavily
# defended but still defeatable targets even if it has no softer targets available.
if total_max_mil_rating > sys_total_threat and base_score > 2 * MIN_INVASION_SCORE:
threat_factor = max(threat_factor, (MIN_INVASION_SCORE + 1)/base_score)
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, base_score)
if clear_path:
planet_score *= 1.5
if verbose:
debug(' - planet score: %.2f\n'
' - planned troops: %.2f\n'
' - projected troop cost: %.1f\n'
' - threat factor: %s\n'
' - planet detail: %s\n'
' - popval: %.1f\n'
' - bldval: %s\n'
' - enemyval: %s',
planet_score, planned_troops, troop_cost, threat_factor, detail, colony_base_value, bld_tally, enemy_val)
debug(' - system secured: %s' % system_secured)
return [planet_score, planned_troops]
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
aistate = get_aistate()
visible_system_ids = list(aistate.visInteriorSystemIDs) + list(aistate.visBorderSystemIDs)
if home_system_id != INVALID_ID:
accessible_system_ids = [sys_id for sys_id in visible_system_ids if
(sys_id != INVALID_ID) and universe.systemsConnected(sys_id, home_system_id,
empire_id)]
else:
debug("Empire has no identifiable homeworld; will treat all visible planets as accessible.")
# TODO: check if any troop ships owned, use their system as home system
accessible_system_ids = visible_system_ids
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(accessible_system_ids)
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(acessible_planet_ids) # includes unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(acessible_planet_ids) # includes unowned natives
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
invadable_planet_ids = set(all_owned_planet_ids).union(all_populated_planets) - set(empire_owned_planet_ids)
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.INVASION)
invasion_targeted_planet_ids.extend(
get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
num_invasion_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(invasion_fleet_ids))
debug("Current Invasion Targeted SystemIDs: %s" % PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs))
debug("Current Invasion Targeted PlanetIDs: %s" % PlanetUtilsAI.planet_string(invasion_targeted_planet_ids))
debug(invasion_fleet_ids and "Invasion Fleet IDs: %s" % invasion_fleet_ids or "Available Invasion Fleets: 0")
debug("Invasion Fleets Without Missions: %s" % num_invasion_fleets)
invasion_timer.start("planning troop base production")
reserved_troop_base_targets = []
if aistate.character.may_invade_with_bases():
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
# For planning base trooper invasion targets we have a two-pass system. (1) In the first pass we consider all
# the invasion targets and figure out which ones appear to be suitable for using base troopers against (i.e., we
# already have a populated planet in the same system that could build base troopers) and we have at least a
# minimal amount of PP available, and (2) in the second pass we go through the reserved base trooper target list
# and check to make sure that there does not appear to be too much military action still needed before the
# target is ready to be invaded, we double check that not too many base troopers would be needed, and if things
# look clear then we queue up the base troopers on the Production Queue and keep track of where we are building
# them, and how many; we may also disqualify and remove previously qualified targets (in case, for example,
# we lost our base trooper source planet since it was first added to list).
#
# For planning and tracking base troopers under construction, we use a dictionary store in
# get_aistate().qualifyingTroopBaseTargets, keyed by the invasion target planet ID. We only store values
# for invasion targets that appear likely to be suitable for base trooper use, and store a 2-item list.
# The first item in this list is the ID of the planet where we expect to build the base troopers, and the second
# entry initially is set to INVALID_ID (-1). The presence of this entry in qualifyingTroopBaseTargets
# flags this target as being reserved as a base-trooper invasion target.
# In the second pass, if/when we actually start construction, then we modify the record, replacing that second
# value with the ID of the planet where the troopers are actually being built. (Right now that is always the
# same as the source planet originally identified, but we could consider reevaluating that, or use that second
# value to instead record how many base troopers have been queued, so that on later turns we can assess if the
# process got delayed & perhaps more troopers need to be queued).
secure_ai_fleet_missions = aistate.get_fleet_missions_with_any_mission_types([MissionType.SECURE,
MissionType.MILITARY])
# Pass 1: identify qualifying base troop invasion targets
for pid in invadable_planet_ids: # TODO: reorganize
if pid in aistate.qualifyingTroopBaseTargets:
continue
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = get_partial_visibility_turn(sys_id)
planet_partial_vis_turn = get_partial_visibility_turn(pid)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
best_base_planet = INVALID_ID
best_trooper_count = 0
for pid2 in state.get_empire_planets_by_system(sys_id, include_outposts=False):
if available_pp.get(pid2, 0) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2 or planet2.speciesName not in ColonisationAI.empire_ship_builders:
continue
best_base_trooper_here = \
ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION, pid2)[1]
if not best_base_trooper_here:
continue
troops_per_ship = best_base_trooper_here.troopCapacity
if not troops_per_ship:
continue
species_troop_grade = CombatRatingsAI.get_species_troops_grade(planet2.speciesName)
troops_per_ship = CombatRatingsAI.weight_attack_troops(troops_per_ship, species_troop_grade)
if troops_per_ship > best_trooper_count:
best_base_planet = pid2
best_trooper_count = troops_per_ship
if best_base_planet != INVALID_ID:
aistate.qualifyingTroopBaseTargets.setdefault(pid, [best_base_planet, INVALID_ID])
# Pass 2: for each target previously identified for base troopers, check that still qualifies and
# check how many base troopers would be needed; if reasonable then queue up the troops and record this in
# get_aistate().qualifyingTroopBaseTargets
for pid in aistate.qualifyingTroopBaseTargets.keys():
planet = universe.getPlanet(pid)
if planet and planet.owner == empire_id:
del aistate.qualifyingTroopBaseTargets[pid]
continue
if pid in invasion_targeted_planet_ids: # TODO: consider overriding standard invasion mission
continue
if aistate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
# TODO: evaluate changes to situation, any more troops needed, etc.
continue # already building for here
_, planet_troops = evaluate_invasion_planet(pid, secure_ai_fleet_missions, True)
sys_id = planet.systemID
this_sys_status = aistate.systemStatus.get(sys_id, {})
troop_tally = 0
for _fid in this_sys_status.get('myfleets', []):
troop_tally += FleetUtilsAI.count_troops_in_fleet(_fid)
if troop_tally > planet_troops: # base troopers appear unneeded
del aistate.qualifyingTroopBaseTargets[pid]
continue
if (planet.currentMeterValue(fo.meterType.shield) > 0 and
(this_sys_status.get('myFleetRating', 0) < 0.8 * this_sys_status.get('totalThreat', 0) or
this_sys_status.get('myFleetRatingVsPlanets', 0) < this_sys_status.get('planetThreat', 0))):
# this system not secured, so ruling out invasion base troops for now
# don't immediately delete from qualifyingTroopBaseTargets or it will be opened up for regular troops
continue
loc = aistate.qualifyingTroopBaseTargets[pid][0]
best_base_trooper_here = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION, loc)[1]
loc_planet = universe.getPlanet(loc)
if best_base_trooper_here is None: # shouldn't be possible at this point, but just to be safe
warn("Could not find a suitable orbital invasion design at %s" % loc_planet)
continue
# TODO: have TroopShipDesigner give the expected number of troops including species effects directly
troops_per_ship = best_base_trooper_here.troopCapacity
species_troop_grade = CombatRatingsAI.get_species_troops_grade(loc_planet.speciesName)
troops_per_ship = CombatRatingsAI.weight_attack_troops(troops_per_ship, species_troop_grade)
if not troops_per_ship:
warn("The best orbital invasion design at %s seems not to have any troop capacity." % loc_planet)
continue
_, col_design, build_choices = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION,
loc)
if not col_design:
continue
if loc not in build_choices:
warn('Best troop design %s can not be produced at planet with id: %s\d' % (col_design, build_choices))
continue
n_bases = math.ceil((planet_troops + 1) / troops_per_ship) # TODO: reconsider this +1 safety factor
# TODO: evaluate cost and time-to-build of best base trooper here versus cost and time-to-build-and-travel
# for best regular trooper elsewhere
# For now, we assume what building base troopers is best so long as either (1) we would need no more than
# MAX_BASE_TROOPERS_POOR_INVADERS base troop ships, or (2) our base troopers have more than 1 trooper per
# ship and we would need no more than MAX_BASE_TROOPERS_GOOD_INVADERS base troop ships
if (n_bases > MAX_BASE_TROOPERS_POOR_INVADERS or
(troops_per_ship > 1 and n_bases > MAX_BASE_TROOPERS_GOOD_INVADERS)):
debug("ruling out base invasion troopers for %s due to high number (%d) required." % (planet, n_bases))
del aistate.qualifyingTroopBaseTargets[pid]
continue
debug("Invasion base planning, need %d troops at %d per ship, will build %d ships." % (
(planet_troops + 1), troops_per_ship, n_bases))
retval = fo.issueEnqueueShipProductionOrder(col_design.id, loc)
debug("Enqueueing %d Troop Bases at %s for %s" % (n_bases, PlanetUtilsAI.planet_string(loc),
PlanetUtilsAI.planet_string(pid)))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
aistate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1, 0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(
set(invadable_planet_ids) - set(invasion_targeted_planet_ids) - set(reserved_troop_base_targets))
evaluated_planets = assign_invasion_values(evaluated_planet_ids)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, pscore, ptroops in sorted_planets]
invasion_table = Table([Text('Planet'), Float('Score'), Text('Species'), Float('Troops')],
table_name="Potential Targets for Invasion Turn %d" % fo.currentTurn())
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
invasion_table.add_row([
planet,
pscore,
planet and planet.speciesName or "unknown",
ptroops
])
info(invasion_table)
sorted_planets = filter(lambda x: x[1] > 0, sorted_planets)
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, __, __ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" % (len(evaluated_planet_ids)))
invasion_timer.stop_print_and_clear()
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 survey_universe():
survey_timer.start("Categorizing Visible Planets")
universe = fo.getUniverse()
empire_id = fo.empireID()
current_turn = fo.currentTurn()
# set up / reset various variables; the 'if' is purely for code folding convenience
if True:
AIstate.empireStars.clear()
empire_metabolisms.clear()
active_growth_specials.clear()
# var setup done
aistate = get_aistate()
for sys_id in universe.systemIDs:
system = universe.getSystem(sys_id)
if not system:
continue
local_ast = False
local_gg = False
empire_has_qualifying_planet = False
if sys_id in AIstate.colonyTargetedSystemIDs:
empire_has_qualifying_planet = True
for pid in system.planetIDs:
planet = universe.getPlanet(pid)
if not planet:
continue
if pid in aistate.colonisablePlanetIDs:
empire_has_qualifying_planet = True
if planet.size == fo.planetSize.asteroids:
local_ast = True
elif planet.size == fo.planetSize.gasGiant:
local_gg = True
spec_name = planet.speciesName
this_spec = fo.getSpecies(spec_name)
owner_id = planet.owner
planet_population = planet.currentMeterValue(
fo.meterType.population)
buildings_here = [
universe.getBuilding(bldg).buildingTypeName
for bldg in planet.buildingIDs
]
weapons_grade = "WEAPONS_0.0"
if owner_id == empire_id:
if planet_population > 0.0 and this_spec:
empire_has_qualifying_planet = True
for metab in [
tag for tag in this_spec.tags
if tag in AIDependencies.metabolismBoostMap
]:
empire_metabolisms[metab] = empire_metabolisms.get(
metab, 0.0) + planet.habitableSize
if this_spec.canProduceShips:
pilot_val = rate_piloting_tag(spec_name)
if spec_name == "SP_ACIREMA":
pilot_val += 1
weapons_grade = "WEAPONS_%.1f" % pilot_val
set_pilot_rating_for_planet(pid, pilot_val)
yard_here = []
if "BLD_SHIPYARD_BASE" in buildings_here:
set_ship_builders(spec_name, pid)
yard_here = [pid]
if this_spec.canColonize and planet.currentMeterValue(
fo.meterType.targetPopulation) >= 3:
set_colony_builders(spec_name, yard_here)
set_building_locations(weapons_grade, buildings_here, pid)
for special in planet.specials:
if special_is_nest(special):
set_have_nest()
if special in AIDependencies.metabolismBoosts:
set_growth_special(special, pid)
if planet.focus == FocusType.FOCUS_GROWTH:
active_growth_specials.setdefault(special,
[]).append(pid)
elif owner_id != -1:
if get_partial_visibility_turn(
pid
) >= current_turn - 1: # only interested in immediately recent data
aistate.misc.setdefault("enemies_sighted",
{}).setdefault(current_turn,
[]).append(pid)
if empire_has_qualifying_planet:
if local_ast:
set_have_asteroids()
elif local_gg:
set_have_gas_giant()
if sys_id in get_owned_planets():
AIstate.empireStars.setdefault(system.starType, []).append(sys_id)
sys_status = aistate.systemStatus.setdefault(sys_id, {})
if sys_status.get("fleetThreat", 0) > 0:
set_colonies_is_under_attack()
if sys_status.get("neighborThreat", 0) > 0:
set_colonies_is_under_treat()
survey_universe_lock.unlock()
survey_timer.stop()
# lock must be released before this, since it uses the locked functions
_print_empire_species_roster()
def issue_fleet_orders(self):
"""issues AIFleetOrders which can be issued in system and moves to next one if is possible"""
# TODO: priority
order_completed = True
print
print "Checking orders for fleet %s (on turn %d), with mission type %s" % (
self.fleet.get_object(), fo.currentTurn(), self.type or 'No mission')
if MissionType.INVASION == self.type:
self._check_retarget_invasion()
just_issued_move_order = False
last_move_target_id = INVALID_ID
# Note: the following abort check somewhat assumes only one major mission type
for fleet_order in self.orders:
if (isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)) and
self._check_abort_mission(fleet_order)):
return
for fleet_order in self.orders:
if just_issued_move_order and self.fleet.get_object().systemID != last_move_target_id:
# having just issued a move order, we will normally stop issuing orders this turn, except that if there
# are consecutive move orders we will consider moving through the first destination rather than stopping
# Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test
# noinspection PyTypeChecker
if (not isinstance(fleet_order, OrderMove) or
self.need_to_pause_movement(last_move_target_id, fleet_order)):
break
print "Checking order: %s" % fleet_order
self.check_mergers(context=str(fleet_order))
if fleet_order.can_issue_order(verbose=False):
if isinstance(fleet_order, OrderMove) and order_completed: # only move if all other orders completed
print "Issuing fleet order %s" % fleet_order
fleet_order.issue_order()
just_issued_move_order = True
last_move_target_id = fleet_order.target.id
elif not isinstance(fleet_order, OrderMove):
print "Issuing fleet order %s" % fleet_order
fleet_order.issue_order()
else:
print "NOT issuing (even though can_issue) fleet order %s" % fleet_order
print "Order issued: %s" % fleet_order.order_issued
if not fleet_order.executed:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.order_issued:
# A previously issued order that wasn't instantly executed must have had cirumstances change so that
# the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same
# turn the order was issued).
if not fleet_order.executed:
order_completed = False
# Go on to the next order.
continue
print "CAN'T issue fleet order %s" % fleet_order
if isinstance(fleet_order, OrderMove):
this_system_id = fleet_order.target.id
this_status = foAI.foAIstate.systemStatus.setdefault(this_system_id, {})
threat_threshold = fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating() / 4.0
if this_status.get('monsterThreat', 0) > threat_threshold:
# if this move order is not this mil fleet's final destination, and blocked by Big Monster,
# release and hope for more effective reassignment
if (self.type not in (MissionType.MILITARY, MissionType.SECURE) or
fleet_order != self.orders[-1]):
print "Aborting mission due to being blocked by Big Monster at system %d, threat %d" % (
this_system_id, foAI.foAIstate.systemStatus[this_system_id]['monsterThreat'])
print "Full set of orders were:"
for this_order in self.orders:
print " - %s" % this_order
self.clear_fleet_orders()
self.clear_target()
return
break # do not order the next order until this one is finished.
else: # went through entire order list
if order_completed:
print "Final order is completed"
orders = self.orders
last_order = orders[-1] if orders else None
universe = fo.getUniverse()
if last_order and isinstance(last_order, OrderColonize):
planet = universe.getPlanet(last_order.target.id)
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet.id)
if (planet_partial_vis_turn == sys_partial_vis_turn and
not planet.initialMeterValue(fo.meterType.population)):
warn("Fleet %d has tentatively completed its "
"colonize mission but will wait to confirm population." % self.fleet.id)
print " Order details are %s" % last_order
print " Order is valid: %s; issued: %s; executed: %s" % (
last_order.is_valid(), last_order.order_issued, last_order.executed)
if not last_order.is_valid():
source_target = last_order.fleet
target_target = last_order.target
print " source target validity: %s; target target validity: %s " % (
bool(source_target), bool(target_target))
return # colonize order must not have completed yet
clear_all = True
last_sys_target = INVALID_ID
if last_order and isinstance(last_order, OrderMilitary):
last_sys_target = last_order.target.id
# not doing this until decide a way to release from a SECURE mission
# if (MissionType.SECURE == self.type) or
secure_targets = set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs)
if last_sys_target in secure_targets: # consider a secure mission
if last_sys_target in AIstate.colonyTargetedSystemIDs:
secure_type = "Colony"
elif last_sys_target in AIstate.outpostTargetedSystemIDs:
secure_type = "Outpost"
elif last_sys_target in AIstate.invasionTargetedSystemIDs:
secure_type = "Invasion"
else:
secure_type = "Unidentified"
print ("Fleet %d has completed initial stage of its mission "
"to secure system %d (targeted for %s), "
"may release a portion of ships" % (self.fleet.id, last_sys_target, secure_type))
clear_all = False
fleet_id = self.fleet.id
if clear_all:
if orders:
print "Fleet %d has completed its mission; clearing all orders and targets." % self.fleet.id
print "Full set of orders were:"
for this_order in orders:
print "\t\t %s" % this_order
self.clear_fleet_orders()
self.clear_target()
if foAI.foAIstate.get_fleet_role(fleet_id) in (MissionType.MILITARY,
MissionType.SECURE):
allocations = MilitaryAI.get_military_fleets(mil_fleets_ids=[fleet_id],
try_reset=False,
thisround="Fleet %d Reassignment" % fleet_id)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=[fleet_id],
allocations=allocations)
else: # no orders
print "No Current Orders"
else:
# TODO: evaluate releasing a smaller portion or none of the ships
system_status = foAI.foAIstate.systemStatus.setdefault(last_sys_target, {})
new_fleets = []
threat_present = system_status.get('totalThreat', 0) + system_status.get('neighborThreat', 0) > 0
target_system = universe.getSystem(last_sys_target)
if not threat_present and target_system:
for pid in target_system.planetIDs:
planet = universe.getPlanet(pid)
if (planet and
planet.owner != fo.empireID() and
planet.currentMeterValue(fo.meterType.maxDefense) > 0):
threat_present = True
break
if not threat_present:
print "No current threat in target system; releasing a portion of ships."
# at least first stage of current task is done;
# release extra ships for potential other deployments
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id)
else:
print "Threat remains in target system; NOT releasing any ships."
new_military_fleets = []
for fleet_id in new_fleets:
if foAI.foAIstate.get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES:
new_military_fleets.append(fleet_id)
allocations = []
if new_military_fleets:
allocations = MilitaryAI.get_military_fleets(
mil_fleets_ids=new_military_fleets,
try_reset=False,
thisround="Fleet Reassignment %s" % new_military_fleets
)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=new_military_fleets,
allocations=allocations)
def _risky_travel_starlane_func(c, d):
return any((_somewhat_careful_travel_starlane_func(c, d),
get_partial_visibility_turn(c) <= 0))
def evaluate_invasion_planet(planet_id):
"""Return the invasion value (score, troops) of a planet."""
universe = fo.getUniverse()
empire_id = fo.empireID()
detail = []
planet = universe.getPlanet(planet_id)
if planet is None:
debug("Invasion AI couldn't access any info for planet id %d" %
planet_id)
return [0, 0]
system_id = planet.systemID
# by using the following instead of simply relying on stealth meter reading,
# can (sometimes) plan ahead even if planet is temporarily shrouded by an ion storm
predicted_detectable = EspionageAI.colony_detectable_by_empire(
planet_id, empire=fo.empireID(), default_result=False)
if not predicted_detectable:
if get_partial_visibility_turn(planet_id) < fo.currentTurn():
debug("InvasionAI predicts planet id %d to be stealthed" %
planet_id)
return [0, 0]
else:
debug(
"InvasionAI predicts planet id %d to be stealthed" %
planet_id +
", but somehow have current visibility anyway, will still consider as target"
)
# Check if the target planet was extra-stealthed somehow its system was last viewed
# this test below may augment the tests above,
# but can be thrown off by temporary combat-related sighting
system_last_seen = get_partial_visibility_turn(planet_id)
planet_last_seen = get_partial_visibility_turn(system_id)
if planet_last_seen < system_last_seen:
# TODO: track detection strength, order new scouting when it goes up
debug(
"Invasion AI considering planet id %d (stealthed at last view), still proceeding."
% planet_id)
# get a baseline evaluation of the planet as determined by ColonisationAI
species_name = planet.speciesName
species = fo.getSpecies(species_name)
empire_research_list = tuple(element.tech
for element in fo.getEmpire().researchQueue)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values(
[planet_id], MissionType.INVASION, None, detail)
colony_base_value = max(
0.75 * planet_eval.get(planet_id, [0])[0],
calculate_planet_colonization_rating.
calculate_planet_colonization_rating(
planet_id=planet_id,
mission_type=MissionType.OUTPOST,
spec_name=None,
detail=detail,
empire_research_list=empire_research_list,
),
)
else:
colony_base_value = calculate_planet_colonization_rating.calculate_planet_colonization_rating(
planet_id=planet_id,
mission_type=MissionType.INVASION,
spec_name=species_name,
detail=detail,
empire_research_list=empire_research_list,
)
# Add extra score for all buildings on the planet
building_values = {
"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
bld_tally = 0
for bldType in [
universe.getBuilding(bldg).buildingTypeName
for bldg in planet.buildingIDs
]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
# Add extra score for unlocked techs when we conquer the species
tech_tally = 0
value_per_pp = 4
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(
species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_value = value_per_pp * rp_cost
tech_tally += tech_value
detail.append("%s: %d" % (unlocked_tech, tech_value))
least_jumps_path, max_jumps = _get_path_from_capital(planet)
clear_path = True
aistate = get_aistate()
system_status = aistate.systemStatus.get(system_id, {})
system_fleet_treat = system_status.get("fleetThreat", 1000)
system_monster_threat = system_status.get("monsterThreat", 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get(
"planetThreat", 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = aistate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get(
"fleetThreat", 1000) + path_leg_status.get("monsterThreat", 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
troop_regen = planet.currentMeterValue(
fo.meterType.troops) - planet.initialMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(system_id)
secure_targets = [system_id] + list(this_system.planetIDs)
system_secured = False
secure_fleets = get_aistate().get_fleet_missions_with_any_mission_types(
[MissionType.SECURE, MissionType.MILITARY])
for mission in secure_fleets:
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != system_id:
continue
if mission.type in [MissionType.SECURE, MissionType.MILITARY]:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get("myFleetRating", 0)
debug(
"Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f",
planet,
planet.currentMeterValue(fo.meterType.maxShield),
system_fleet_treat,
system_monster_threat,
)
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (
planet.currentMeterValue(fo.meterType.targetIndustry) +
2 * planet.currentMeterValue(fo.meterType.targetResearch))
# devalue invasions that would require too much military force
preferred_max_portion = MilitaryAI.get_preferred_max_military_portion_for_single_battle(
)
total_max_mil_rating = MilitaryAI.get_concentrated_tot_mil_rating()
threat_exponent = 2 # TODO: make this a character trait; higher aggression with a lower exponent
threat_factor = min(
1, preferred_max_portion * total_max_mil_rating /
(sys_total_threat + 0.001))**threat_exponent
design_id, _, locs = get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(
troops + troop_regen * (max_jumps + build_time), max_troops)
planned_troops += 0.01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops + _TROOPS_SAFETY_MARGIN) /
6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(
design.troopCapacity,
get_species_tag_grade(species_here, Tags.ATTACKTROOPS))
planned_troops = troops if system_secured else min(
troops + troop_regen * (max_jumps + build_time), max_troops)
planned_troops += 0.01 # we must attack with more troops than there are defenders
ships_needed = math.ceil(
(planned_troops + _TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints,
1)
normalized_cost = max(1.0, normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = colony_base_value + bld_tally + tech_tally + enemy_val - cost_score
# If the AI does have enough total military to attack this target, and the target is more than minimally valuable,
# don't let the threat_factor discount the adjusted value below MIN_INVASION_SCORE +1, so that if there are no
# other targets the AI could still pursue this one. Otherwise, scoring pressure from
# MilitaryAI.get_preferred_max_military_portion_for_single_battle might prevent the AI from attacking heavily
# defended but still defeatable targets even if it has no softer targets available.
if total_max_mil_rating > sys_total_threat and base_score > 2 * MIN_INVASION_SCORE:
threat_factor = max(threat_factor,
(MIN_INVASION_SCORE + 1) / base_score)
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(
0, base_score)
if clear_path:
planet_score *= 1.5
debug(
" - planet score: %.2f\n"
" - planned troops: %.2f\n"
" - projected troop cost: %.1f\n"
" - threat factor: %s\n"
" - planet detail: %s\n"
" - popval: %.1f\n"
" - bldval: %s\n"
" - enemyval: %s",
planet_score,
planned_troops,
troop_cost,
threat_factor,
detail,
colony_base_value,
bld_tally,
enemy_val,
)
debug(" - system secured: %s" % system_secured)
return [planet_score, planned_troops]
def issue_fleet_orders(self):
"""issues AIFleetOrders which can be issued in system and moves to next one if is possible"""
# TODO: priority
order_completed = True
debug("\nChecking orders for fleet %s (on turn %d), with mission type %s and target %s",
self.fleet.get_object(), fo.currentTurn(), self.type or 'No mission', self.target or 'No Target')
if MissionType.INVASION == self.type:
self._check_retarget_invasion()
just_issued_move_order = False
last_move_target_id = INVALID_ID
# Note: the following abort check somewhat assumes only one major mission type
for fleet_order in self.orders:
if (isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)) and
self._check_abort_mission(fleet_order)):
return
aistate = get_aistate()
for fleet_order in self.orders:
if just_issued_move_order and self.fleet.get_object().systemID != last_move_target_id:
# having just issued a move order, we will normally stop issuing orders this turn, except that if there
# are consecutive move orders we will consider moving through the first destination rather than stopping
# Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test
# noinspection PyTypeChecker
if (not isinstance(fleet_order, OrderMove) or
self.need_to_pause_movement(last_move_target_id, fleet_order)):
break
debug("Checking order: %s" % fleet_order)
self.check_mergers(context=str(fleet_order))
if fleet_order.can_issue_order(verbose=False):
# only move if all other orders completed
if isinstance(fleet_order, OrderMove) and order_completed:
debug("Issuing fleet order %s" % fleet_order)
fleet_order.issue_order()
just_issued_move_order = True
last_move_target_id = fleet_order.target.id
elif not isinstance(fleet_order, OrderMove):
debug("Issuing fleet order %s" % fleet_order)
fleet_order.issue_order()
else:
debug("NOT issuing (even though can_issue) fleet order %s" % fleet_order)
status_words = tuple(["not", ""][_s] for _s in [fleet_order.order_issued, fleet_order.executed])
debug("Order %s issued and %s fully executed." % status_words)
if not fleet_order.executed:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.order_issued:
# A previously issued order that wasn't instantly executed must have had cirumstances change so that
# the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same
# turn the order was issued).
if not fleet_order.executed:
order_completed = False
# Go on to the next order.
continue
debug("CAN'T issue fleet order %s because:" % fleet_order)
fleet_order.can_issue_order(verbose=True)
if isinstance(fleet_order, OrderMove):
this_system_id = fleet_order.target.id
this_status = aistate.systemStatus.setdefault(this_system_id, {})
threat_threshold = fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating() / 4.0
if this_status.get('monsterThreat', 0) > threat_threshold:
# if this move order is not this mil fleet's final destination, and blocked by Big Monster,
# release and hope for more effective reassignment
if (self.type not in (MissionType.MILITARY, MissionType.SECURE) or
fleet_order != self.orders[-1]):
debug("Aborting mission due to being blocked by Big Monster at system %d, threat %d" % (
this_system_id, aistate.systemStatus[this_system_id]['monsterThreat']))
debug("Full set of orders were:")
for this_order in self.orders:
debug(" - %s" % this_order)
self.clear_fleet_orders()
self.clear_target()
return
break # do not order the next order until this one is finished.
else: # went through entire order list
if order_completed:
debug("Final order is completed")
orders = self.orders
last_order = orders[-1] if orders else None
universe = fo.getUniverse()
if last_order and isinstance(last_order, OrderColonize):
planet = universe.getPlanet(last_order.target.id)
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet.id)
if (planet_partial_vis_turn == sys_partial_vis_turn and
not planet.initialMeterValue(fo.meterType.population)):
warning("Fleet %s has tentatively completed its "
"colonize mission but will wait to confirm population.", self.fleet)
debug(" Order details are %s" % last_order)
debug(" Order is valid: %s; issued: %s; executed: %s" % (
last_order.is_valid(), last_order.order_issued, last_order.executed))
if not last_order.is_valid():
source_target = last_order.fleet
target_target = last_order.target
debug(" source target validity: %s; target target validity: %s " % (
bool(source_target), bool(target_target)))
return # colonize order must not have completed yet
clear_all = True
last_sys_target = INVALID_ID
if last_order and isinstance(last_order, OrderMilitary):
last_sys_target = last_order.target.id
# not doing this until decide a way to release from a SECURE mission
# if (MissionType.SECURE == self.type) or
secure_targets = set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs)
if last_sys_target in secure_targets: # consider a secure mission
if last_sys_target in AIstate.colonyTargetedSystemIDs:
secure_type = "Colony"
elif last_sys_target in AIstate.outpostTargetedSystemIDs:
secure_type = "Outpost"
elif last_sys_target in AIstate.invasionTargetedSystemIDs:
secure_type = "Invasion"
else:
secure_type = "Unidentified"
debug("Fleet %d has completed initial stage of its mission "
"to secure system %d (targeted for %s), "
"may release a portion of ships" % (self.fleet.id, last_sys_target, secure_type))
clear_all = False
# for PROTECT_REGION missions, only release fleet if no more threat
if self.type == MissionType.PROTECT_REGION:
# use military logic code below to determine if can release
# any or even all of the ships.
clear_all = False
last_sys_target = self.target.id
debug("Check if PROTECT_REGION mission with target %d is finished.", last_sys_target)
fleet_id = self.fleet.id
if clear_all:
if orders:
debug("Fleet %d has completed its mission; clearing all orders and targets." % self.fleet.id)
debug("Full set of orders were:")
for this_order in orders:
debug("\t\t %s" % this_order)
self.clear_fleet_orders()
self.clear_target()
if aistate.get_fleet_role(fleet_id) in (MissionType.MILITARY, MissionType.SECURE):
allocations = MilitaryAI.get_military_fleets(mil_fleets_ids=[fleet_id],
try_reset=False,
thisround="Fleet %d Reassignment" % fleet_id)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=[fleet_id],
allocations=allocations)
else: # no orders
debug("No Current Orders")
else:
potential_threat = combine_ratings(
MilitaryAI.get_system_local_threat(last_sys_target),
MilitaryAI.get_system_neighbor_threat(last_sys_target)
)
threat_present = potential_threat > 0
debug("Fleet threat present? %s", threat_present)
target_system = universe.getSystem(last_sys_target)
if not threat_present and target_system:
for pid in target_system.planetIDs:
planet = universe.getPlanet(pid)
if (planet and
planet.owner != fo.empireID() and
planet.currentMeterValue(fo.meterType.maxDefense) > 0):
debug("Found local planetary threat: %s", planet)
threat_present = True
break
if not threat_present:
debug("No current threat in target system; releasing a portion of ships.")
# at least first stage of current task is done;
# release extra ships for potential other deployments
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id)
if self.type == MissionType.PROTECT_REGION:
self.clear_fleet_orders()
self.clear_target()
new_fleets.append(self.fleet.id)
else:
debug("Threat remains in target system; Considering to release some ships.")
new_fleets = []
fleet_portion_to_remain = self._portion_of_fleet_needed_here()
if fleet_portion_to_remain >= 1:
debug("Can not release fleet yet due to large threat.")
elif fleet_portion_to_remain > 0:
debug("Not all ships are needed here - considering releasing a few")
# TODO: Rate against specific enemy threat cause
fleet_remaining_rating = CombatRatingsAI.get_fleet_rating(fleet_id)
fleet_min_rating = fleet_portion_to_remain * fleet_remaining_rating
debug("Starting rating: %.1f, Target rating: %.1f",
fleet_remaining_rating, fleet_min_rating)
allowance = CombatRatingsAI.rating_needed(fleet_remaining_rating, fleet_min_rating)
debug("May release ships with total rating of %.1f", allowance)
ship_ids = list(self.fleet.get_object().shipIDs)
for ship_id in ship_ids:
ship_rating = CombatRatingsAI.get_ship_rating(ship_id)
debug("Considering to release ship %d with rating %.1f", ship_id, ship_rating)
if ship_rating > allowance:
debug("Remaining rating insufficient. Not released.")
continue
debug("Splitting from fleet.")
new_fleet_id = FleetUtilsAI.split_ship_from_fleet(fleet_id, ship_id)
if assertion_fails(new_fleet_id and new_fleet_id != INVALID_ID):
break
new_fleets.append(new_fleet_id)
fleet_remaining_rating = CombatRatingsAI.rating_difference(
fleet_remaining_rating, ship_rating)
allowance = CombatRatingsAI.rating_difference(
fleet_remaining_rating, fleet_min_rating)
debug("Remaining fleet rating: %.1f - Allowance: %.1f",
fleet_remaining_rating, allowance)
if new_fleets:
aistate.get_fleet_role(fleet_id, force_new=True)
aistate.update_fleet_rating(fleet_id)
aistate.ensure_have_fleet_missions(new_fleets)
else:
debug("Planetary defenses are deemed sufficient. Release fleet.")
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id)
new_military_fleets = []
for fleet_id in new_fleets:
if aistate.get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES:
new_military_fleets.append(fleet_id)
allocations = []
if new_military_fleets:
allocations = MilitaryAI.get_military_fleets(
mil_fleets_ids=new_military_fleets,
try_reset=False,
thisround="Fleet Reassignment %s" % new_military_fleets
)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=new_military_fleets,
allocations=allocations)
def issue_fleet_orders(self):
"""issues AIFleetOrders which can be issued in system and moves to next one if is possible"""
# TODO: priority
order_completed = True
debug(
"\nChecking orders for fleet %s (on turn %d), with mission type %s"
% (self.fleet.get_object(), fo.currentTurn(), self.type
or 'No mission'))
if MissionType.INVASION == self.type:
self._check_retarget_invasion()
just_issued_move_order = False
last_move_target_id = INVALID_ID
# Note: the following abort check somewhat assumes only one major mission type
for fleet_order in self.orders:
if (isinstance(fleet_order,
(OrderColonize, OrderOutpost, OrderInvade))
and self._check_abort_mission(fleet_order)):
return
aistate = get_aistate()
for fleet_order in self.orders:
if just_issued_move_order and self.fleet.get_object(
).systemID != last_move_target_id:
# having just issued a move order, we will normally stop issuing orders this turn, except that if there
# are consecutive move orders we will consider moving through the first destination rather than stopping
# Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test
# noinspection PyTypeChecker
if (not isinstance(fleet_order, OrderMove)
or self.need_to_pause_movement(last_move_target_id,
fleet_order)):
break
debug("Checking order: %s" % fleet_order)
self.check_mergers(context=str(fleet_order))
if fleet_order.can_issue_order(verbose=False):
if isinstance(
fleet_order, OrderMove
) and order_completed: # only move if all other orders completed
debug("Issuing fleet order %s" % fleet_order)
fleet_order.issue_order()
just_issued_move_order = True
last_move_target_id = fleet_order.target.id
elif not isinstance(fleet_order, OrderMove):
debug("Issuing fleet order %s" % fleet_order)
fleet_order.issue_order()
else:
debug(
"NOT issuing (even though can_issue) fleet order %s" %
fleet_order)
debug("Order issued: %s" % fleet_order.order_issued)
if not fleet_order.executed:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.order_issued:
# A previously issued order that wasn't instantly executed must have had cirumstances change so that
# the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same
# turn the order was issued).
if not fleet_order.executed:
order_completed = False
# Go on to the next order.
continue
debug("CAN'T issue fleet order %s" % fleet_order)
if isinstance(fleet_order, OrderMove):
this_system_id = fleet_order.target.id
this_status = aistate.systemStatus.setdefault(
this_system_id, {})
threat_threshold = fo.currentTurn(
) * MilitaryAI.cur_best_mil_ship_rating() / 4.0
if this_status.get('monsterThreat', 0) > threat_threshold:
# if this move order is not this mil fleet's final destination, and blocked by Big Monster,
# release and hope for more effective reassignment
if (self.type not in (MissionType.MILITARY,
MissionType.SECURE)
or fleet_order != self.orders[-1]):
debug(
"Aborting mission due to being blocked by Big Monster at system %d, threat %d"
% (this_system_id,
aistate.systemStatus[this_system_id]
['monsterThreat']))
debug("Full set of orders were:")
for this_order in self.orders:
debug(" - %s" % this_order)
self.clear_fleet_orders()
self.clear_target()
return
break # do not order the next order until this one is finished.
else: # went through entire order list
if order_completed:
debug("Final order is completed")
orders = self.orders
last_order = orders[-1] if orders else None
universe = fo.getUniverse()
if last_order and isinstance(last_order, OrderColonize):
planet = universe.getPlanet(last_order.target.id)
sys_partial_vis_turn = get_partial_visibility_turn(
planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(
planet.id)
if (planet_partial_vis_turn == sys_partial_vis_turn
and not planet.initialMeterValue(
fo.meterType.population)):
warn(
"Fleet %d has tentatively completed its "
"colonize mission but will wait to confirm population."
% self.fleet.id)
debug(" Order details are %s" % last_order)
debug(
" Order is valid: %s; issued: %s; executed: %s"
% (last_order.is_valid(), last_order.order_issued,
last_order.executed))
if not last_order.is_valid():
source_target = last_order.fleet
target_target = last_order.target
debug(
" source target validity: %s; target target validity: %s "
% (bool(source_target), bool(target_target)))
return # colonize order must not have completed yet
clear_all = True
last_sys_target = INVALID_ID
if last_order and isinstance(last_order, OrderMilitary):
last_sys_target = last_order.target.id
# not doing this until decide a way to release from a SECURE mission
# if (MissionType.SECURE == self.type) or
secure_targets = set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs)
if last_sys_target in secure_targets: # consider a secure mission
if last_sys_target in AIstate.colonyTargetedSystemIDs:
secure_type = "Colony"
elif last_sys_target in AIstate.outpostTargetedSystemIDs:
secure_type = "Outpost"
elif last_sys_target in AIstate.invasionTargetedSystemIDs:
secure_type = "Invasion"
else:
secure_type = "Unidentified"
debug(
"Fleet %d has completed initial stage of its mission "
"to secure system %d (targeted for %s), "
"may release a portion of ships" %
(self.fleet.id, last_sys_target, secure_type))
clear_all = False
fleet_id = self.fleet.id
if clear_all:
if orders:
debug(
"Fleet %d has completed its mission; clearing all orders and targets."
% self.fleet.id)
debug("Full set of orders were:")
for this_order in orders:
debug("\t\t %s" % this_order)
self.clear_fleet_orders()
self.clear_target()
if aistate.get_fleet_role(fleet_id) in (
MissionType.MILITARY, MissionType.SECURE):
allocations = MilitaryAI.get_military_fleets(
mil_fleets_ids=[fleet_id],
try_reset=False,
thisround="Fleet %d Reassignment" % fleet_id)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(
use_fleet_id_list=[fleet_id],
allocations=allocations)
else: # no orders
debug("No Current Orders")
else:
# TODO: evaluate releasing a smaller portion or none of the ships
system_status = aistate.systemStatus.setdefault(
last_sys_target, {})
new_fleets = []
threat_present = system_status.get(
'totalThreat', 0) + system_status.get(
'neighborThreat', 0) > 0
target_system = universe.getSystem(last_sys_target)
if not threat_present and target_system:
for pid in target_system.planetIDs:
planet = universe.getPlanet(pid)
if (planet and planet.owner != fo.empireID()
and planet.currentMeterValue(
fo.meterType.maxDefense) > 0):
threat_present = True
break
if not threat_present:
debug(
"No current threat in target system; releasing a portion of ships."
)
# at least first stage of current task is done;
# release extra ships for potential other deployments
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id)
else:
debug(
"Threat remains in target system; NOT releasing any ships."
)
new_military_fleets = []
for fleet_id in new_fleets:
if aistate.get_fleet_role(
fleet_id) in COMBAT_MISSION_TYPES:
new_military_fleets.append(fleet_id)
allocations = []
if new_military_fleets:
allocations = MilitaryAI.get_military_fleets(
mil_fleets_ids=new_military_fleets,
try_reset=False,
thisround="Fleet Reassignment %s" %
new_military_fleets)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(
use_fleet_id_list=new_military_fleets,
allocations=allocations)
def evaluate_invasion_planet(planet_id, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
detail = []
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
# TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empire_id = fo.empireID()
max_jumps = 8
planet = universe.getPlanet(planet_id)
if planet is None: # TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d" % planet_id
return [0, 0]
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet_id)
if planet_partial_vis_turn < sys_partial_vis_turn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
# TODO: track detection strength, order new scouting when it goes up
return [0, 0] # last time we had partial vis of the system, the planet was stealthed to us
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], MissionType.INVASION, None, detail)
pop_val = max(0.75 * planet_eval.get(planet_id, [0])[0],
ColonisationAI.evaluate_planet(planet_id, MissionType.OUTPOST, None, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, MissionType.INVASION, species_name, detail)
bld_tally = 0
for bldType in [universe.getBuilding(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
tech_tally = 0
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_tally += rp_cost * 4
detail.append("%s: %d" % (unlocked_tech, rp_cost * 4))
p_sys_id = planet.systemID
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = planet.systemID
if (home_system_id != INVALID_ID) and (eval_system_id != INVALID_ID):
least_jumps_path = list(universe.leastJumpsPath(home_system_id, eval_system_id, empire_id))
max_jumps = len(least_jumps_path)
system_status = foAI.foAIstate.systemStatus.get(p_sys_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(p_sys_id)
secure_targets = [p_sys_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
if mission.type == MissionType.SECURE:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating', 0)
if verbose:
print ("Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f") % (
planet, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat,
system_monster_threat)
supply_val = 0
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) +
2*planet.currentMeterValue(fo.meterType.targetResearch))
if p_sys_id in ColonisationAI.annexable_system_ids: # TODO: extend to rings
supply_val = 100
elif p_sys_id in state.get_systems_by_supply_tier(-1):
supply_val = 200
elif p_sys_id in state.get_systems_by_supply_tier(-2):
supply_val = 300
elif p_sys_id in state.get_systems_by_supply_tier(-3):
supply_val = 400
if max_path_threat > 0.5 * mil_ship_rating:
if max_path_threat < 3 * mil_ship_rating:
supply_val *= 0.5
else:
supply_val *= 0.2
# devalue invasions that would require too much military force
threat_factor = min(1, 0.2*MilitaryAI.get_tot_mil_rating()/(sys_total_threat+0.001))**2
design_id, _, locs = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / 6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(design.troopCapacity,
CombatRatingsAI.get_species_troops_grade(species_here))
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
ships_needed = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints, 1)
normalized_cost = max(1, normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = pop_val + supply_val + bld_tally + tech_tally + enemy_val - cost_score
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, base_score)
if clear_path:
planet_score *= 1.5
if verbose:
print (' - planet score: %.2f\n'
' - troop score: %.2f\n'
' - projected troop cost: %.1f\n'
' - threat factor: %s\n'
' - planet detail: %s\n'
' - popval: %.1f\n'
' - supplyval: %.1f\n'
' - bldval: %s\n'
' - enemyval: %s') % (planet_score, planned_troops, troop_cost,
threat_factor, detail, pop_val, supply_val, bld_tally, enemy_val)
return [planet_score, planned_troops]