def can_travel_to_system(fleet_id, start, target, ensure_return=False):
"""
Return list systems to be visited.
:param fleet_id:
:type fleet_id: int
:param start:
:type start: target.TargetSystem
:param target:
:type target: target.TargetSystem
:param ensure_return:
:type ensure_return: bool
:return:
:rtype: list
"""
if start == target:
return [TargetSystem(start.id)]
debug("Requesting path for fleet %s from %s to %s" % (fo.getUniverse().getFleet(fleet_id), start, target))
target_distance_from_supply = -min(state.get_system_supply(target.id), 0)
# low-aggression AIs may not travel far from supply
if not get_aistate().character.may_travel_beyond_supply(target_distance_from_supply):
debug("May not move %d out of supply" % target_distance_from_supply)
return []
min_fuel_at_target = target_distance_from_supply if ensure_return else 0
path_info = pathfinding.find_path_with_resupply(start.id, target.id, fleet_id,
minimum_fuel_at_target=min_fuel_at_target)
if path_info is None:
debug("Found no valid path.")
return []
debug("Found valid path: %s" % str(path_info))
return [TargetSystem(sys_id) for sys_id in path_info.path]
def can_travel_to_system(fleet_id, start, target, ensure_return=False):
"""
Return list systems to be visited.
:param fleet_id:
:type fleet_id: int
:param start:
:type start: target.TargetSystem
:param target:
:type target: target.TargetSystem
:param ensure_return:
:type ensure_return: bool
:return:
:rtype: list
"""
if start == target:
return [TargetSystem(start.id)]
debug("Requesting path for fleet %s from %s to %s" %
(fo.getUniverse().getFleet(fleet_id), start, target))
target_distance_from_supply = -min(state.get_system_supply(target.id), 0)
# low-aggression AIs may not travel far from supply
if not get_aistate().character.may_travel_beyond_supply(
target_distance_from_supply):
debug("May not move %d out of supply" % target_distance_from_supply)
return []
min_fuel_at_target = target_distance_from_supply if ensure_return else 0
path_info = pathfinding.find_path_with_resupply(
start.id,
target.id,
fleet_id,
minimum_fuel_at_target=min_fuel_at_target)
if path_info is None:
debug("Found no valid path.")
return []
debug("Found valid path: %s" % str(path_info))
return [TargetSystem(sys_id) for sys_id in path_info.path]
def find_path_with_resupply(start,
target,
fleet_id,
minimum_fuel_at_target=0,
mission_type_override=None):
"""
:param start: start system id
:type start: int
:param target: target system id
:type target: int
:param fleet_id: fleet to find the path for
:type fleet_id: int
:param minimum_fuel_at_target: optional - if specified, only accept paths that leave the
fleet with at least this much fuel left at the target system
:type minimum_fuel_at_target: int
:param mission_type_override: optional - use the specified mission type, rather than the fleet's
current mission type, for pathfinding routing choices
:type mission_type_override: MissionType
:return: shortest possible path including resupply-detours in the form of system ids
including both start and target system
:rtype: path_information
"""
universe = fo.getUniverse()
fleet = universe.getFleet(fleet_id)
if not fleet:
return None
empire = fo.getEmpire()
supplied_systems = set(empire.fleetSupplyableSystemIDs)
start_fuel = fleet.maxFuel if start in supplied_systems else fleet.fuel
# We have 1 free jump from supplied system into unsupplied systems.
# Thus, the target system must be at most maxFuel + 1 jumps away
# in order to reach the system under standard conditions.
# In some edge cases, we may have more supply here than what the
# supply graph suggests. For example, we could have recently refueled
# in a system that is now blockaded by an enemy or we have found
# the refuel special.
target_distance_from_supply = -min(state.get_system_supply(target), 0)
if (fleet.maxFuel + 1 <
(target_distance_from_supply + minimum_fuel_at_target)
and universe.jumpDistance(start, target) >
(start_fuel - minimum_fuel_at_target)):
# can't possibly reach this system with the required fuel
return None
mission_type = (mission_type_override if mission_type_override is not None
else foAI.foAIstate.get_fleet_mission(fleet_id))
may_travel_starlane_func = _STARLANE_TRAVEL_FUNC_MAP.get(
mission_type, _more_careful_travel_starlane_func)
path_info = find_path_with_resupply_generic(
start,
target,
start_fuel,
fleet.maxFuel,
lambda s: s in supplied_systems,
minimum_fuel_at_target,
may_travel_starlane_func=may_travel_starlane_func)
if not _DEBUG_CHAT:
return path_info
if may_travel_starlane_func != _may_travel_anywhere:
risky_path = find_path_with_resupply_generic(
start, target, start_fuel, fleet.maxFuel,
lambda s: s in supplied_systems, minimum_fuel_at_target)
if path_info and may_travel_starlane_func == _risky_travel_starlane_func:
safest_path = find_path_with_resupply_generic(
start,
target,
start_fuel,
fleet.maxFuel,
lambda s: s in supplied_systems,
minimum_fuel_at_target,
may_travel_starlane_func=_more_careful_travel_starlane_func)
if safest_path and path_info.distance < safest_path.distance:
message = "(Scout?) Fleet %d chose somewhat risky path %s instead of safe path %s" % (
fleet_id, _info_string(path_info),
_info_string(risky_path))
chat_human(message)
if path_info and risky_path and risky_path.distance < path_info.distance:
message = "Fleet %d chose safer path %s instead of risky path %s" % (
fleet_id, _info_string(path_info), _info_string(risky_path))
chat_human(message)
return path_info
def find_path_with_resupply(start, target, fleet_id, minimum_fuel_at_target=0, mission_type_override=None):
"""
:param start: start system id
:type start: int
:param target: target system id
:type target: int
:param fleet_id: fleet to find the path for
:type fleet_id: int
:param minimum_fuel_at_target: optional - if specified, only accept paths that leave the
fleet with at least this much fuel left at the target system
:type minimum_fuel_at_target: int
:param mission_type_override: optional - use the specified mission type, rather than the fleet's
current mission type, for pathfinding routing choices
:type mission_type_override: MissionType
:return: shortest possible path including resupply-detours in the form of system ids
including both start and target system
:rtype: path_information
"""
universe = fo.getUniverse()
fleet = universe.getFleet(fleet_id)
if not fleet:
return None
empire = fo.getEmpire()
supplied_systems = set(empire.fleetSupplyableSystemIDs)
start_fuel = fleet.maxFuel if start in supplied_systems else fleet.fuel
# We have 1 free jump from supplied system into unsupplied systems.
# Thus, the target system must be at most maxFuel + 1 jumps away
# in order to reach the system under standard conditions.
# In some edge cases, we may have more supply here than what the
# supply graph suggests. For example, we could have recently refueled
# in a system that is now blockaded by an enemy or we have found
# the refuel special.
target_distance_from_supply = -min(state.get_system_supply(target), 0)
if (fleet.maxFuel + 1 < (target_distance_from_supply + minimum_fuel_at_target) and
universe.jumpDistance(start, target) > (start_fuel - minimum_fuel_at_target)):
# can't possibly reach this system with the required fuel
return None
mission_type = (mission_type_override if mission_type_override is not None else
foAI.foAIstate.get_fleet_mission(fleet_id))
may_travel_starlane_func = _STARLANE_TRAVEL_FUNC_MAP.get(mission_type, _more_careful_travel_starlane_func)
path_info = find_path_with_resupply_generic(start, target, start_fuel, fleet.maxFuel,
lambda s: s in supplied_systems,
minimum_fuel_at_target,
may_travel_starlane_func=may_travel_starlane_func)
if not _DEBUG_CHAT:
return path_info
if may_travel_starlane_func != _may_travel_anywhere:
risky_path = find_path_with_resupply_generic(start, target, start_fuel, fleet.maxFuel,
lambda s: s in supplied_systems,
minimum_fuel_at_target)
if path_info and may_travel_starlane_func == _risky_travel_starlane_func:
safest_path = find_path_with_resupply_generic(start, target, start_fuel, fleet.maxFuel,
lambda s: s in supplied_systems,
minimum_fuel_at_target,
may_travel_starlane_func=_more_careful_travel_starlane_func)
if safest_path and path_info.distance < safest_path.distance:
message = "(Scout?) Fleet %d chose somewhat risky path %s instead of safe path %s" % (
fleet_id, _info_string(path_info), _info_string(risky_path))
chat_human(message)
if path_info and risky_path and risky_path.distance < path_info.distance:
message = "Fleet %d chose safer path %s instead of risky path %s" % (
fleet_id, _info_string(path_info), _info_string(risky_path))
chat_human(message)
return path_info
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_system_supply(-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]