def get_fleet_role(self, fleet_id, force_new=False):
"""Returns fleet role by ID."""
if not force_new and fleet_id in self.__fleetRoleByID:
return self.__fleetRoleByID[fleet_id]
else:
role = FleetUtilsAI.assess_fleet_role(fleet_id)
self.__fleetRoleByID[fleet_id] = role
make_aggressive = False
if role in [MissionType.COLONISATION,
MissionType.OUTPOST,
MissionType.ORBITAL_INVASION,
MissionType.ORBITAL_OUTPOST
]:
pass
elif role in [MissionType.EXPLORATION,
MissionType.INVASION
]:
this_rating = self.get_rating(fleet_id) # Done!
n_ships = self.fleetStatus.get(fleet_id, {}).get('nships', 1) # entry sould exist due to above line
if float(this_rating) / n_ships >= 0.5 * MilitaryAI.cur_best_mil_ship_rating():
make_aggressive = True
else:
make_aggressive = True
fo.issueAggressionOrder(fleet_id, make_aggressive)
return role
def get_fleet_role(self, fleet_id, force_new=False):
"""Returns fleet role by ID."""
if not force_new and fleet_id in self.__fleetRoleByID:
return self.__fleetRoleByID[fleet_id]
else:
role = FleetUtilsAI.assess_fleet_role(fleet_id)
self.__fleetRoleByID[fleet_id] = role
make_aggressive = False
if role in [MissionType.COLONISATION,
MissionType.OUTPOST,
MissionType.ORBITAL_INVASION,
MissionType.ORBITAL_OUTPOST
]:
pass
elif role in [MissionType.EXPLORATION,
MissionType.INVASION
]:
this_rating = self.get_rating(fleet_id) # Done!
n_ships = self.fleetStatus.get(fleet_id, {}).get('nships', 1) # entry sould exist due to above line
if float(this_rating) / n_ships >= 0.5 * MilitaryAI.cur_best_mil_ship_rating():
make_aggressive = True
else:
make_aggressive = True
fo.issueAggressionOrder(fleet_id, make_aggressive)
return role
def _determine_colony_threat_factor(planet_id, spec_name, existing_presence):
universe = fo.getUniverse()
planet = universe.getPlanet(planet_id)
if not planet: # should have been checked previously, but belt-and-suspenders
error("Can't retrieve planet ID %d" % planet_id)
return 0
sys_status = get_aistate().systemStatus.get(planet.systemID, {})
cur_best_mil_ship_rating = max(MilitaryAI.cur_best_mil_ship_rating(),
0.001)
local_defenses = sys_status.get("all_local_defenses", 0)
local_threat = sys_status.get("fleetThreat", 0) + sys_status.get(
"monsterThreat", 0)
neighbor_threat = sys_status.get("neighborThreat", 0)
jump2_threat = 0.6 * max(
0,
sys_status.get("jump2_threat", 0) -
sys_status.get("my_neighbor_rating", 0))
area_threat = neighbor_threat + jump2_threat
area_threat *= 2.0 / (
existing_presence + 2
) # once we have a foothold be less scared off by area threats
# TODO: evaluate detectability by specific source of area threat, also consider if the subject AI already has
# researched techs that would grant a stealth bonus
local_enemies = sys_status.get("enemies_nearly_supplied", [])
# could more conservatively base detection on get_aistate().misc.get("observed_empires")
if not EspionageAI.colony_detectable_by_empire(
planet_id, spec_name, empire=local_enemies, default_result=True):
area_threat *= 0.05
net_threat = max(0, local_threat + area_threat - local_defenses)
# even if our military has lost all warships, rate planets as if we have at least one
reference_rating = max(
cur_best_mil_ship_rating,
MilitaryAI.get_preferred_max_military_portion_for_single_battle() *
MilitaryAI.get_concentrated_tot_mil_rating(),
)
threat_factor = min(1.0, reference_rating / (net_threat + 0.001))**2
if threat_factor < 0.5:
mil_ref_string = "Military rating reference: %.1f" % reference_rating
debug(
"Significant threat discounting %2d%% at %s, local defense: %.1f, local threat %.1f, area threat %.1f"
% (100 * (1 - threat_factor), planet.name, local_defenses,
local_threat, area_threat) + mil_ref_string)
return threat_factor
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 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()
for fleet_order in self.orders:
print "Checking order: %s" % fleet_order
if isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)): # TODO: invasion?
if self._check_abort_mission(fleet_order):
print "Aborting fleet order %s" % fleet_order
return
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()
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.order_issued:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.order_issued:
# It's unclear why we'd really get to this spot, but it has been observed to happen, perhaps due to
# game being reloaded after code changes.
# 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, {})
if this_status.get('monsterThreat', 0) > fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating() / 4.0:
if (self.type not in (MissionType.MILITARY,
MissionType.SECURE) or
fleet_order != self.orders[-1] # if this move order is not this mil fleet's final destination, and blocked by Big Monster, release and hope for more effective reassignment
):
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
# moving to another system stops issuing all orders in system where fleet is
# move order is also the last order in system
if isinstance(fleet_order, OrderMove):
fleet = self.fleet.get_object()
if fleet.systemID != fleet_order.target.id:
break
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 = universe.getVisibilityTurnsMap(planet.systemID, fo.empireID()).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet.id, fo.empireID()).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn == sys_partial_vis_turn and not planet.currentMeterValue(fo.meterType.population):
print "Potential Error: 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 = -1
if last_order and isinstance(last_order, OrderMilitary):
last_sys_target = last_order.target.id
# if (MissionType.SECURE == self.type) or # not doing this until decide a way to release from a SECURE mission
secure_targets = set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)
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"
elif last_sys_target in AIstate.blockadeTargetedSystemIDs:
secure_type = "Blockade"
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) != 0) or (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."
new_fleets = FleetUtilsAI.split_fleet(self.fleet.id) # at least first stage of current task is done; release extra ships for potential other deployments
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 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 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 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
system_id_list = universe.systemIDs # will normally look at this, the list of all known systems
# for use in debugging
verbose = False
# assess enemy fleets that may have been momentarily visible
cur_e_fighters = {CombatRatingsAI.default_ship_stats().get_stats(hashable=True): [0]} # start with a dummy entry
old_e_fighters = {CombatRatingsAI.default_ship_stats().get_stats(hashable=True): [0]} # start with a dummy entry
enemy_fleet_ids = []
enemies_by_system = {}
my_fleets_by_system = {}
fleet_spot_position = {}
saw_enemies_at_system = {}
my_milship_rating = MilitaryAI.cur_best_mil_ship_rating()
current_turn = fo.currentTurn()
for fleet_id in universe.fleetIDs:
fleet = universe.getFleet(fleet_id)
if fleet is None:
continue
if not fleet.empty:
# TODO: check if currently in system and blockaded before accepting destination as location
this_system_id = (fleet.nextSystemID != INVALID_ID and fleet.nextSystemID) or fleet.systemID
if fleet.ownedBy(empire_id):
if fleet_id not in destroyed_object_ids:
my_fleets_by_system.setdefault(this_system_id, []).append(fleet_id)
fleet_spot_position.setdefault(fleet.systemID, []).append(fleet_id)
else:
dead_fleet = fleet_id in destroyed_object_ids
if not fleet.ownedBy(-1) and (fleet.hasArmedShips or fleet.hasFighterShips):
ship_stats = CombatRatingsAI.FleetCombatStats(fleet_id).get_ship_stats(hashable=True)
e_f_dict = [cur_e_fighters, old_e_fighters][dead_fleet] # track old/dead enemy fighters for rating assessments in case not enough current info
for stats in ship_stats:
attacks = stats[0]
if attacks:
e_f_dict.setdefault(stats, [0])[0] += 1
partial_vis_turn = universe.getVisibilityTurnsMap(fleet_id, empire_id).get(fo.visibility.partial, -9999)
if not dead_fleet:
# 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.
sys_status = self.systemStatus.setdefault(this_system_id, {})
sys_status['enemy_ship_count'] = sys_status.get('enemy_ship_count', 0) + len(fleet.shipIDs)
if partial_vis_turn >= current_turn - 1: # only interested in immediately recent data
saw_enemies_at_system[fleet.systemID] = True
enemy_fleet_ids.append(fleet_id)
enemies_by_system.setdefault(this_system_id, []).append(fleet_id)
if not fleet.ownedBy(-1):
self.misc.setdefault('enemies_sighted', {}).setdefault(current_turn, []).append(fleet_id)
rating = CombatRatingsAI.get_fleet_rating(fleet_id, enemy_stats=CombatRatingsAI.get_empire_standard_fighter())
if rating > 0.25 * my_milship_rating:
self.misc.setdefault('dangerous_enemies_sighted', {}).setdefault(current_turn, []).append(fleet_id)
e_f_dict = [cur_e_fighters, old_e_fighters][len(cur_e_fighters) == 1]
std_fighter = sorted([(v, k) for k, v in e_f_dict.items()])[-1][1]
self.__empire_standard_enemy = std_fighter
self.empire_standard_enemy_rating = self.get_standard_enemy().get_rating()
# TODO: If no current information available, rate against own fighters
# assess fleet and planet threats & my local fleets
for sys_id in system_id_list:
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
for fid in system.fleetIDs:
if fid in destroyed_object_ids: # TODO: double check are these checks/deletes necessary?
self.delete_fleet_info(fid) # this is safe even if fleet wasn't mine
continue
fleet = universe.getFleet(fid)
if not fleet or fleet.empty:
self.delete_fleet_info(fid) # this is safe even if fleet wasn't mine
continue
# update threats
sys_vis_dict = universe.getVisibilityTurnsMap(sys_id, fo.empireID())
partial_vis_turn = sys_vis_dict.get(fo.visibility.partial, -9999)
mob_ratings = [] # for mobile unowned monster fleets
lost_fleet_rating = 0
enemy_ratings = []
monster_ratings = []
mobile_fleets = []
for fid in local_enemy_fleet_ids:
fleet = universe.getFleet(fid)
if not fleet:
continue
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)
else:
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)
if fleetsLostBySystem.get(sys_id, []):
lost_fleet_rating = CombatRatingsAI.combine_ratings_list(fleetsLostBySystem[sys_id])
if not system or partial_vis_turn == -9999: # under current visibility rules should not be possible to have any losses or other info here, but just in case...
if verbose:
print "Have never had partial vis for system %d ( %s ) -- basing threat assessment on old info and lost ships" % (sys_id, sys_status.get('name', "name unknown"))
sys_status.setdefault('local_fleet_threats', set())
sys_status['planetThreat'] = 0
sys_status['fleetThreat'] = int(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'] = int(max(monster_rating, 0.98 * sys_status.get('monsterThreat', 0), 1.1 * lost_fleet_rating - enemy_rating - mob_rating))
sys_status['enemy_threat'] = int(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 = 0
phealth = 0
mypattack, myphealth = 0, 0
for pid in system.planetIDs:
prating = self.assess_planet_threat(pid, sighting_age=current_turn - partial_vis_turn)
planet = universe.getPlanet(pid)
if not planet:
continue
if planet.owner == self.empireID: # TODO: check for diplomatic status
mypattack += prating['attack']
myphealth += prating['health']
else:
if [special for special in planet.specials if "_NEST_" in special]:
sys_status['nest_threat'] = 100
pattack += prating['attack']
phealth += prating['health']
sys_status['planetThreat'] = pattack * phealth
sys_status['mydefenses'] = {'overall': mypattack * myphealth, 'attack': mypattack, 'health': myphealth}
if max(sys_status.get('totalThreat', 0), pattack * phealth) >= 0.6 * lost_fleet_rating: # previous threat assessment could account for losses, ignore the losses now
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: # (universe.getVisibility(sys_id, self.empire_id) >= fo.visibility.partial):
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'] = int(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'] = int(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'] = int(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 #TODO: reevaluate as visibility rules change
sys_status['currently_visible'] = True
sys_status['local_fleet_threats'] = set(mobile_fleets)
sys_status['fleetThreat'] = int(max(CombatRatingsAI.combine_ratings(enemy_rating, mob_rating), 2 * lost_fleet_rating - monster_rating)) # includes mobile monsters
if verbose:
print "enemy threat calc parts: enemy rating %.1f, lost fleet rating %.1f, monster_rating %.1f" % (enemy_rating, lost_fleet_rating, monster_rating)
sys_status['enemy_threat'] = int(max(enemy_rating, 2 * lost_fleet_rating - monster_rating)) # does NOT include mobile monsters
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))
if partial_vis_turn > 0 and sys_id not in supply_unobstructed_systems: # has been seen with Partial Vis, but is currently supply-blocked
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 system_id_list:
sys_status = self.systemStatus[sys_id]
sys_status['enemies_supplied'] = 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(dict_from_map(universe.getSystemNeighborsMap(sys_id, self.empireID)))
for sys_id in system_id_list:
sys_status = self.systemStatus[sys_id]
neighbors = sys_status.get('neighbors', set())
this_system = fo.getUniverse().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, ref_sys_name="neighbors %s" % this_system) if verbose else 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, ref_sys_name="jump2 %s" % this_system) if verbose else 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
threat_keys = ['fleetThreat', 'neighborThreat', 'jump2_threat'] # for local system includes both enemies and mobs
sys_status['regional_threat'] = CombatRatingsAI.combine_ratings_list(map(lambda x: sys_status.get(x, 0), 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, empire, 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_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 = empire.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 = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet_id, empire_id).get(fo.visibility.partial, -9999)
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: # 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], EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, None, empire, detail)
pop_val = max(0.75*planet_eval.get(planet_id, [0])[0], ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST, None, empire, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, species_name, empire, detail)
bld_tally = 0
for bldType in [universe.getObject(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
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 != -1) and (eval_system_id != -1):
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.target_id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
for ai_target in mission.get_targets(EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE):
target_obj = ai_target.target_obj
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 %d --- maxShields %.1f -- sysFleetThreat %.1f -- sysMonsterThreat %.1f" % (
planet.name, planet_id, 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 ColonisationAI.annexable_ring1:
supply_val = 200
elif p_sys_id in ColonisationAI.annexable_ring2:
supply_val = 300
elif p_sys_id in ColonisationAI.annexable_ring3:
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
threat_factor = min(1, 0.2*MilitaryAI.totMilRating/(sys_total_threat+0.001))**2 # devalue invasions that would require too much military force
build_time = 4
planned_troops = troops if system_secured else min(troops+max_jumps+build_time, max_troops)
if not tech_is_complete("SHP_ORG_HULL"):
troop_cost = math.ceil(planned_troops/6.0) * (40*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
else:
troop_cost = math.ceil(planned_troops/6.0) * (20*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, pop_val+supply_val+bld_tally+enemy_val-0.8*troop_cost)
if clear_path:
planet_score *= 1.5
invasion_score = [planet_score, planned_troops]
print invasion_score, "projected Troop Cost:", troop_cost, ", threatFactor: ", threat_factor, ", planet detail ", detail, "popval, supplyval, bldval, enemyval", pop_val, supply_val, bld_tally, enemy_val
return invasion_score
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 "--------------"
loc = self.get_location_target()
print "Checking orders for fleet %d (on turn %d) at %s, with mission types %s" % (self.target_id, fo.currentTurn(), loc, [AIFleetMissionType.name(mt) for mt in self.get_mission_types()])
print "\t Full Orders are:"
for this_order in self.orders:
print "\t\t| %s" % this_order
print "/t/t------"
if AIFleetMissionType.FLEET_MISSION_INVASION in self.get_mission_types():
self._check_retarget_invasion()
for fleet_order in self.orders:
print "\t| checking Order: %s" % fleet_order
order_type = fleet_order.order_type
if order_type in [AIFleetOrderType.ORDER_COLONISE,
AIFleetOrderType.ORDER_OUTPOST,
AIFleetOrderType.ORDER_INVADE]: # TODO: invasion?
if self._check_abort_mission(fleet_order):
print "\t\t| Aborting fleet order %s" % fleet_order
return
self.check_mergers(context=str(fleet_order))
if fleet_order.can_issue_order(verbose=True):
if order_type == AIFleetOrderType.ORDER_MOVE and order_completed: # only move if all other orders completed
print "\t\t| issuing fleet order %s" % fleet_order
fleet_order.issue_order()
elif order_type not in [AIFleetOrderType.ORDER_MOVE, AIFleetOrderType.ORDER_DEFEND]:
print "\t\t| issuing fleet order %s" % fleet_order
fleet_order.issue_order()
else:
print "\t\t| NOT issuing (even though can_issue) fleet order %s" % fleet_order
print "\t\t| order status-- execution completed: %s" % fleet_order.execution_completed
if not fleet_order.execution_completed:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.execution_completed:
# It's unclear why we'd really get to this spot, but it has been observed to happen, perhaps due to
# game being reloaded after code changes.
# Go on to the next order.
continue
print "\t\t| CAN'T issue fleet order %s" % fleet_order
if order_type == AIFleetOrderType.ORDER_MOVE:
this_system_id = fleet_order.target.target_id
this_status = foAI.foAIstate.systemStatus.setdefault(this_system_id, {})
if this_status.get('monsterThreat', 0) > fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating()/4.0:
first_mission = self.get_mission_types()[0] if self.get_mission_types() else AIFleetMissionType.FLEET_MISSION_INVALID
if (first_mission not in (AIFleetMissionType.FLEET_MISSION_ATTACK,
AIFleetMissionType.FLEET_MISSION_MILITARY,
AIFleetMissionType.FLEET_MISSION_HIT_AND_RUN,
AIFleetMissionType.FLEET_MISSION_SECURE,
) or
fleet_order != self.orders[-1] # if this move order is not this mil fleet's final destination, and blocked by Big Monster, release and hope for more effective reassignment
):
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 "\t\t %s" % this_order
self.clear_fleet_orders()
self.clear_targets(([-1] + self.get_mission_types()[:1])[-1])
return
# moving to another system stops issuing all orders in system where fleet is
# move order is also the last order in system
if order_type == AIFleetOrderType.ORDER_MOVE:
fleet = fo.getUniverse().getFleet(self.target_id)
if fleet.systemID != fleet_order.target.target_id:
break
else: # went through entire order list
if order_completed:
print "\t| Final order is completed"
orders = self.orders
last_order = orders[-1] if orders else None
universe = fo.getUniverse()
if last_order and last_order.order_type == AIFleetOrderType.ORDER_COLONISE:
planet = universe.getPlanet(last_order.target.target_id)
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, fo.empireID()).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet.id, fo.empireID()).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn == sys_partial_vis_turn and not planet.currentMeterValue(fo.meterType.population):
print "Potential Error: Fleet %d has tentatively completed its colonize mission but will wait to confirm population." % self.target_id
print " Order details are %s" % last_order
print " Order is valid: %s ; is Executed : %s; is execution completed: %s " % (last_order.is_valid(), last_order.isExecuted(), last_order.isExecutionCompleted())
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 " % (source_target.valid, target_target.valid)
if EnumsAI.TargetType.TARGET_SHIP == source_target.target_type:
ship_id = source_target.target_id
ship = universe.getShip(ship_id)
if not ship:
print "Ship id %d not a valid ship id" % ship_id
print " source target Ship (%d), species %s, can%s colonize" % (ship_id, ship.speciesName, ["not", ""][ship.canColonize])
return # colonize order must not have completed yet
clearAll = True
last_sys_target = -1
if last_order and last_order.order_type == AIFleetOrderType.ORDER_MILITARY:
last_sys_target = last_order.target.target_id
# if (AIFleetMissionType.FLEET_MISSION_SECURE in self.get_mission_types()) or # not doing this until decide a way to release from a SECURE mission
secure_targets = set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)
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"
elif last_sys_target in AIstate.blockadeTargetedSystemIDs:
secure_type = "Blockade"
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.target_id, last_sys_target, secure_type)
clearAll = False
fleet_id = self.target_id
if clearAll:
if orders:
print "Fleet %d has completed its mission; clearing all orders and targets." % self.target_id
print "Full set of orders were:"
for this_order in orders:
print "\t\t %s" % this_order
self.clear_fleet_orders()
self.clear_targets(([-1] + self.get_mission_types()[:1])[-1])
if foAI.foAIstate.get_fleet_role(fleet_id) in (AIFleetMissionType.FLEET_MISSION_MILITARY,
AIFleetMissionType.FLEET_MISSION_ATTACK,
AIFleetMissionType.FLEET_MISSION_DEFEND,
AIFleetMissionType.FLEET_MISSION_HIT_AND_RUN,
AIFleetMissionType.FLEET_MISSION_SECURE):
allocations = MilitaryAI.get_military_fleets(milFleetIDs=[fleet_id], tryReset=False, thisround="Fleet %d Reassignment" % fleet_id)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(useFleetIDList=[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) != 0) or (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."
new_fleets = FleetUtilsAI.split_fleet(self.target_id) # at least first stage of current task is done; release extra ships for potential other deployments
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(milFleetIDs=new_military_fleets, tryReset=False, thisround="Fleet Reassignment %s" % new_military_fleets)
if allocations:
MilitaryAI.assign_military_fleets_to_systems(useFleetIDList=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
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 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 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 = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet_id, empire_id).get(fo.visibility.partial, -9999)
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 ColonisationAI.annexable_ring1:
supply_val = 200
elif p_sys_id in ColonisationAI.annexable_ring2:
supply_val = 300
elif p_sys_id in ColonisationAI.annexable_ring3:
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
threat_factor = min(1, 0.2*MilitaryAI.get_tot_mil_rating()/(sys_total_threat+0.001))**2 # devalue invasions that would require too much military force
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 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()
for fleet_order in self.orders:
print "Checking order: %s" % fleet_order
if isinstance(
fleet_order,
(OrderColonize, OrderOutpost, OrderInvade)): # TODO: invasion?
if self._check_abort_mission(fleet_order):
print "Aborting fleet order %s" % fleet_order
return
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()
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.order_issued:
order_completed = False
else: # check that we're not held up by a Big Monster
if fleet_order.order_issued:
# It's unclear why we'd really get to this spot, but it has been observed to happen, perhaps due to
# game being reloaded after code changes.
# 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, {})
if this_status.get('monsterThreat', 0) > fo.currentTurn(
) * MilitaryAI.cur_best_mil_ship_rating() / 4.0:
if (self.type not in (
MissionType.MILITARY, MissionType.SECURE
) or fleet_order != self.orders[
-1] # if this move order is not this mil fleet's final destination, and blocked by Big Monster, release and hope for more effective reassignment
):
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
# moving to another system stops issuing all orders in system where fleet is
# move order is also the last order in system
if isinstance(fleet_order, OrderMove):
fleet = self.fleet.get_object()
if fleet.systemID != fleet_order.target.id:
break
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 = universe.getVisibilityTurnsMap(
planet.systemID,
fo.empireID()).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(
planet.id, fo.empireID()).get(fo.visibility.partial,
-9999)
if planet_partial_vis_turn == sys_partial_vis_turn and not planet.currentMeterValue(
fo.meterType.population):
print "Potential Error: 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 = -1
if last_order and isinstance(last_order, OrderMilitary):
last_sys_target = last_order.target.id
# if (MissionType.SECURE == self.type) or # not doing this until decide a way to release from a SECURE mission
secure_targets = set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs +
AIstate.blockadeTargetedSystemIDs)
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"
elif last_sys_target in AIstate.blockadeTargetedSystemIDs:
secure_type = "Blockade"
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) !=
0) or (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."
new_fleets = FleetUtilsAI.split_fleet(
self.fleet.id
) # at least first stage of current task is done; release extra ships for potential other deployments
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 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 evaluate_invasion_planet(planet_id, empire, 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_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 = empire.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 = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet_id, empire_id).get(fo.visibility.partial, -9999)
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: # 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], EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, None, empire, detail)
pop_val = max(0.75*planet_eval.get(planet_id, [0])[0], ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST, None, empire, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, species_name, empire, detail)
bld_tally = 0
for bldType in [universe.getObject(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
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 != -1) and (eval_system_id != -1):
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
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
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.target_id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
for ai_target in mission.get_targets(EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE):
target_obj = ai_target.target_obj
if (target_obj is not None) and target_obj.id in secure_targets:
system_secured = True
break
if verbose:
print "invasion eval of %s %d --- maxShields %.1f -- sysFleetThreat %.1f -- sysMonsterThreat %.1f" % (
planet.name, planet_id, 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 ColonisationAI.annexable_ring1:
supply_val = 200
elif p_sys_id in ColonisationAI.annexable_ring2:
supply_val = 300
elif p_sys_id in ColonisationAI.annexable_ring3:
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
threat_factor = min(1, 0.2*MilitaryAI.totMilRating/(sys_total_threat+0.001))**2 # devalue invasions that would require too much military force
build_time = 4
planned_troops = troops if system_secured else min(troops+max_jumps+build_time, max_troops)
if not tech_is_complete("SHP_ORG_HULL"):
troop_cost = math.ceil(planned_troops/6.0) * (40*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
else:
troop_cost = math.ceil(planned_troops/6.0) * (20*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, pop_val+supply_val+bld_tally+enemy_val-0.8*troop_cost)
if clear_path:
planet_score *= 1.5
invasion_score = [planet_score, planned_troops]
print invasion_score, "projected Troop Cost:", troop_cost, ", threatFactor: ", threat_factor, ", planet detail ", detail, "popval, supplyval, bldval, enemyval", pop_val, supply_val, bld_tally, enemy_val
return invasion_score
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 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
system_id_list = universe.systemIDs # will normally look at this, the list of all known systems
# for use in debugging
verbose = False
# assess enemy fleets that may have been momentarily visible
cur_e_fighters = {
CombatRatingsAI.default_ship_stats().get_stats(hashable=True): [0]
} # start with a dummy entry
old_e_fighters = {
CombatRatingsAI.default_ship_stats().get_stats(hashable=True): [0]
} # start with a dummy entry
enemy_fleet_ids = []
enemies_by_system = {}
my_fleets_by_system = {}
fleet_spot_position = {}
saw_enemies_at_system = {}
my_milship_rating = MilitaryAI.cur_best_mil_ship_rating()
current_turn = fo.currentTurn()
for fleet_id in universe.fleetIDs:
fleet = universe.getFleet(fleet_id)
if fleet is None:
continue
if not fleet.empty:
# TODO: check if currently in system and blockaded before accepting destination as location
this_system_id = (fleet.nextSystemID != INVALID_ID
and fleet.nextSystemID) or fleet.systemID
if fleet.ownedBy(empire_id):
if fleet_id not in destroyed_object_ids:
my_fleets_by_system.setdefault(this_system_id,
[]).append(fleet_id)
fleet_spot_position.setdefault(fleet.systemID,
[]).append(fleet_id)
else:
dead_fleet = fleet_id in destroyed_object_ids
if not fleet.ownedBy(-1) and (fleet.hasArmedShips
or fleet.hasFighterShips):
ship_stats = CombatRatingsAI.FleetCombatStats(
fleet_id).get_ship_stats(hashable=True)
e_f_dict = [
cur_e_fighters, old_e_fighters
][dead_fleet] # track old/dead enemy fighters for rating assessments in case not enough current info
for stats in ship_stats:
attacks = stats[0]
if attacks:
e_f_dict.setdefault(stats, [0])[0] += 1
partial_vis_turn = universe.getVisibilityTurnsMap(
fleet_id, empire_id).get(fo.visibility.partial, -9999)
if not dead_fleet:
# 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.
sys_status = self.systemStatus.setdefault(
this_system_id, {})
sys_status['enemy_ship_count'] = sys_status.get(
'enemy_ship_count', 0) + len(fleet.shipIDs)
if partial_vis_turn >= current_turn - 1: # only interested in immediately recent data
saw_enemies_at_system[fleet.systemID] = True
enemy_fleet_ids.append(fleet_id)
enemies_by_system.setdefault(this_system_id,
[]).append(fleet_id)
if not fleet.ownedBy(-1):
self.misc.setdefault('enemies_sighted',
{}).setdefault(
current_turn,
[]).append(fleet_id)
rating = CombatRatingsAI.get_fleet_rating(
fleet_id,
enemy_stats=CombatRatingsAI.
get_empire_standard_fighter())
if rating > 0.25 * my_milship_rating:
self.misc.setdefault(
'dangerous_enemies_sighted',
{}).setdefault(current_turn,
[]).append(fleet_id)
e_f_dict = [cur_e_fighters, old_e_fighters][len(cur_e_fighters) == 1]
std_fighter = sorted([(v, k) for k, v in e_f_dict.items()])[-1][1]
self.__empire_standard_enemy = std_fighter
self.empire_standard_enemy_rating = self.get_standard_enemy(
).get_rating()
# TODO: If no current information available, rate against own fighters
# assess fleet and planet threats & my local fleets
for sys_id in system_id_list:
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
for fid in system.fleetIDs:
if fid in destroyed_object_ids: # TODO: double check are these checks/deletes necessary?
self.delete_fleet_info(
fid) # this is safe even if fleet wasn't mine
continue
fleet = universe.getFleet(fid)
if not fleet or fleet.empty:
self.delete_fleet_info(
fid) # this is safe even if fleet wasn't mine
continue
# update threats
sys_vis_dict = universe.getVisibilityTurnsMap(
sys_id, fo.empireID())
partial_vis_turn = sys_vis_dict.get(fo.visibility.partial, -9999)
mob_ratings = [] # for mobile unowned monster fleets
lost_fleet_rating = 0
enemy_ratings = []
monster_ratings = []
mobile_fleets = []
for fid in local_enemy_fleet_ids:
fleet = universe.getFleet(fid)
if not fleet:
continue
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)
else:
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)
if fleetsLostBySystem.get(sys_id, []):
lost_fleet_rating = CombatRatingsAI.combine_ratings_list(
fleetsLostBySystem[sys_id])
if not system or partial_vis_turn == -9999: # under current visibility rules should not be possible to have any losses or other info here, but just in case...
if verbose:
print "Have never had partial vis for system %d ( %s ) -- basing threat assessment on old info and lost ships" % (
sys_id, sys_status.get('name', "name unknown"))
sys_status.setdefault('local_fleet_threats', set())
sys_status['planetThreat'] = 0
sys_status['fleetThreat'] = int(
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'] = int(
max(monster_rating,
0.98 * sys_status.get('monsterThreat', 0),
1.1 * lost_fleet_rating - enemy_rating - mob_rating))
sys_status['enemy_threat'] = int(
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 = 0
phealth = 0
mypattack, myphealth = 0, 0
for pid in system.planetIDs:
prating = self.assess_planet_threat(pid,
sighting_age=current_turn -
partial_vis_turn)
planet = universe.getPlanet(pid)
if not planet:
continue
if planet.owner == self.empireID: # TODO: check for diplomatic status
mypattack += prating['attack']
myphealth += prating['health']
else:
if [
special for special in planet.specials
if "_NEST_" in special
]:
sys_status['nest_threat'] = 100
pattack += prating['attack']
phealth += prating['health']
sys_status['planetThreat'] = pattack * phealth
sys_status['mydefenses'] = {
'overall': mypattack * myphealth,
'attack': mypattack,
'health': myphealth
}
if max(
sys_status.get('totalThreat', 0), pattack * phealth
) >= 0.6 * lost_fleet_rating: # previous threat assessment could account for losses, ignore the losses now
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: # (universe.getVisibility(sys_id, self.empire_id) >= fo.visibility.partial):
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'] = int(
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'] = int(
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'] = int(
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 #TODO: reevaluate as visibility rules change
sys_status['currently_visible'] = True
sys_status['local_fleet_threats'] = set(mobile_fleets)
sys_status['fleetThreat'] = int(
max(
CombatRatingsAI.combine_ratings(
enemy_rating, mob_rating), 2 * lost_fleet_rating -
monster_rating)) # includes mobile monsters
if verbose:
print "enemy threat calc parts: enemy rating %.1f, lost fleet rating %.1f, monster_rating %.1f" % (
enemy_rating, lost_fleet_rating, monster_rating)
sys_status['enemy_threat'] = int(
max(enemy_rating, 2 * lost_fleet_rating -
monster_rating)) # does NOT include mobile monsters
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))
if partial_vis_turn > 0 and sys_id not in supply_unobstructed_systems: # has been seen with Partial Vis, but is currently supply-blocked
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 system_id_list:
sys_status = self.systemStatus[sys_id]
sys_status['enemies_supplied'] = 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(
dict_from_map(
universe.getSystemNeighborsMap(sys_id, self.empireID)))
for sys_id in system_id_list:
sys_status = self.systemStatus[sys_id]
neighbors = sys_status.get('neighbors', set())
this_system = fo.getUniverse().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, ref_sys_name="neighbors %s" %
this_system) if verbose else 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, ref_sys_name="jump2 %s" %
this_system) if verbose else 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
threat_keys = ['fleetThreat', 'neighborThreat', 'jump2_threat'
] # for local system includes both enemies and mobs
sys_status[
'regional_threat'] = CombatRatingsAI.combine_ratings_list(
map(lambda x: sys_status.get(x, 0), 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)
