def assign_invasion_fleets_to_invade():
"""Assign fleet targets to invadable planets."""
assign_invasion_bases()
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
invasion_fleet_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids)
send_invasion_fleets(invasion_fleet_ids, AIstate.invasionTargets, MissionType.INVASION)
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids):
this_mission = foAI.foAIstate.get_fleet_mission(fid)
this_mission.check_mergers(context="Post-send consolidation of unassigned troops")
def assign_invasion_fleets_to_invade():
"""Assign fleet targets to invadable planets."""
assign_invasion_bases()
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
invasion_fleet_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids)
send_invasion_fleets(invasion_fleet_ids, AIstate.invasionTargets, MissionType.INVASION)
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids):
this_mission = foAI.foAIstate.get_fleet_mission(fid)
this_mission.check_mergers(context="Post-send consolidation of unassigned troops")
def calculateOutpostPriority():
"""calculates the demand for outpost ships by colonisable planets"""
baseOutpostCost = AIDependencies.OUTPOST_POD_COST
numOutpostPlanetIDs = len(foAI.foAIstate.colonisableOutpostIDs)
numOutpostPlanetIDs = len([
pid
for (pid, (score,
specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > 1.0 * baseOutpostCost / 3.0
][:allottedColonyTargets])
completedTechs = ResearchAI.get_completed_techs()
if numOutpostPlanetIDs == 0 or not AIDependencies.OUTPOSTING_TECH in completedTechs:
return 0
outpostShipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(
EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
numOutpostShips = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(outpostShipIDs))
outpostPriority = 50 * (numOutpostPlanetIDs -
numOutpostShips) / numOutpostPlanetIDs
# print
# print "Number of Outpost Ships : " + str(numOutpostShips)
# print "Number of Colonisable outposts: " + str(numOutpostPlanetIDs)
print "Priority for outpost ships : " + str(outpostPriority)
if outpostPriority < 1: return 1
return outpostPriority
def cur_best_mil_ship_rating(include_designs=False):
"""Find the best military ship we have available in this turn and return its rating.
:param include_designs: toggles if available designs are considered or only existing ships
:return: float: rating of the best ship
"""
current_turn = fo.currentTurn()
if current_turn in _best_ship_rating_cache:
best_rating = _best_ship_rating_cache[current_turn]
if include_designs:
best_design_rating = ProductionAI.cur_best_military_design_rating()
best_rating = max(best_rating, best_design_rating)
return best_rating
best_rating = 0.001
universe = fo.getUniverse()
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY):
fleet = universe.getFleet(fleet_id)
for ship_id in fleet.shipIDs:
ship_rating = CombatRatingsAI.ShipCombatStats(ship_id).get_rating(enemy_stats=foAI.foAIstate.get_standard_enemy())
best_rating = max(best_rating, ship_rating)
_best_ship_rating_cache[current_turn] = best_rating
if include_designs:
best_design_rating = ProductionAI.cur_best_military_design_rating()
best_rating = max(best_rating, best_design_rating)
return max(best_rating, 0.001)
def cur_best_mil_ship_rating(include_designs=False):
"""Find the best military ship we have available in this turn and return its rating.
:param include_designs: toggles if available designs are considered or only existing ships
:return: float: rating of the best ship
"""
current_turn = fo.currentTurn()
if current_turn in _best_ship_rating_cache:
best_rating = _best_ship_rating_cache[current_turn]
if include_designs:
best_design_rating = ProductionAI.cur_best_military_design_rating()
best_rating = max(best_rating, best_design_rating)
return best_rating
best_rating = 0.001
universe = fo.getUniverse()
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY):
fleet = universe.getFleet(fleet_id)
for ship_id in fleet.shipIDs:
ship_rating = CombatRatingsAI.ShipCombatStats(ship_id).get_rating(enemy_stats=foAI.foAIstate.get_standard_enemy())
best_rating = max(best_rating, ship_rating)
_best_ship_rating_cache[current_turn] = best_rating
if include_designs:
best_design_rating = ProductionAI.cur_best_military_design_rating()
best_rating = max(best_rating, best_design_rating)
return max(best_rating, 0.001)
def _calculate_colonisation_priority():
"""Calculates the demand for colony ships by colonisable planets."""
global allottedColonyTargets
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
colony_cost = AIDependencies.COLONY_POD_COST * (
1 + AIDependencies.COLONY_POD_UPKEEP * num_colonies)
turns_to_build = 8 # TODO: check for susp anim pods, build time 10
mil_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_MILITARY)
allotted_portion = ([[[0.6, 0.8], [0.3, 0.4]],
[[0.8, 0.9],
[0.4, 0.6]]][galaxy_is_sparse][any(enemies_sighted)])
allotted_portion = foAI.foAIstate.character.preferred_colonization_portion(
allotted_portion)
# if ( foAI.foAIstate.get_priority(AIPriorityType.PRIORITY_PRODUCTION_COLONISATION)
# > 2 * foAI.foAIstate.get_priority(AIPriorityType.PRIORITY_PRODUCTION_MILITARY)):
# allotted_portion *= 1.5
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
elif fo.currentTurn() > 100:
allotted_portion *= 0.75**(num_colonies / 10.0)
# allottedColonyTargets = 1+ int(fo.currentTurn()/50)
allottedColonyTargets = 1 + int(
total_pp * turns_to_build * allotted_portion / colony_cost)
outpost_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_OUTPOST)
# if have any outposts to build, don't build colony ships TODO: make more complex assessment
if outpost_prio > 0 or num_colonies > colony_growth_barrier:
return 0.0
if num_colonies > colony_growth_barrier:
return 0.0
num_colonisable_planet_ids = len([
pid
for (pid, (score, _)) in foAI.foAIstate.colonisablePlanetIDs.items()
if score > 60
][:allottedColonyTargets + 2])
if num_colonisable_planet_ids == 0:
return 1
colony_ship_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
MissionType.COLONISATION)
num_colony_ships = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(colony_ship_ids))
colonisation_priority = 60 * (1.0 + num_colonisable_planet_ids -
num_colony_ships) / (
num_colonisable_planet_ids + 1)
# print
# print "Number of Colony Ships : " + str(num_colony_ships)
# print "Number of Colonisable planets : " + str(num_colonisable_planet_ids)
# print "Priority for colony ships : " + str(colonisation_priority)
if colonisation_priority < 1:
return 0
return colonisation_priority
def cur_best_mil_ship_rating(include_designs=False):
"""Find the best military ship we have available in this turn and return its rating.
:param include_designs: toggles if available designs are considered or only existing ships
:return: float: rating of the best ship
"""
current_turn = fo.currentTurn()
if current_turn in best_ship_rating_cache:
best_rating = best_ship_rating_cache[current_turn]
if include_designs:
best_design_rating = ProductionAI.cur_best_military_design_rating()
best_rating = max(best_rating, best_design_rating)
return best_rating
best_rating = 0.001
universe = fo.getUniverse()
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY):
fleet = universe.getFleet(fleet_id)
for ship_id in fleet.shipIDs:
ship = universe.getShip(ship_id)
if ship:
ship_info = [(ship.id, ship.designID, ship.speciesName)]
ship_rating = foAI.foAIstate.rate_psuedo_fleet(ship_info=ship_info)['overall']
best_rating = max(best_rating, ship_rating)
best_ship_rating_cache[current_turn] = best_rating
if include_designs:
best_design_rating = ProductionAI.cur_best_military_design_rating()
best_rating = max(best_rating, best_design_rating)
return max(best_rating, 0.001)
def calculateColonisationPriority():
"""calculates the demand for colony ships by colonisable planets"""
global allottedColonyTargets, colony_growth_barrier
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
# significant growth barrier for low aggression, negligible for high aggression
colony_growth_barrier = 2 + (
(0.5 + foAI.foAIstate.aggression)**2) * fo.currentTurn() / 50.0
colonyCost = AIDependencies.COLONY_POD_COST * (
1 + AIDependencies.COLONY_POD_UPKEEP * num_colonies)
turnsToBuild = 8 # TODO: check for susp anim pods, build time 10
mil_prio = foAI.foAIstate.get_priority(
EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)
allottedPortion = ([[[0.6, 0.8], [0.3, 0.4]], [[0.8, 0.9], [
0.3, 0.4
]]][galaxy_is_sparse][any(enemies_sighted)][fo.empireID() % 2])
#if ( foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION)
# > 2 * foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)):
# allottedPortion *= 1.5
if mil_prio < 100:
allottedPortion *= 2
elif mil_prio < 200:
allottedPortion *= 1.5
elif fo.currentTurn() > 100:
allottedPortion *= 0.75**(num_colonies / 10.0)
#allottedColonyTargets = 1+ int(fo.currentTurn()/50)
allottedColonyTargets = 1 + int(
total_pp * turnsToBuild * allottedPortion / colonyCost)
outpost_prio = foAI.foAIstate.get_priority(
EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_OUTPOST)
# if have any outposts to build, don't build colony ships TODO: make more complex assessment
if outpost_prio > 0 or num_colonies > colony_growth_barrier:
return 0.0
if num_colonies > colony_growth_barrier:
return 0.0
numColonisablePlanetIDs = len([
pid
for (pid, (score, _)) in foAI.foAIstate.colonisablePlanetIDs.items()
if score > 60
][:allottedColonyTargets + 2])
if numColonisablePlanetIDs == 0: return 1
colonyshipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(
EnumsAI.AIFleetMissionType.FLEET_MISSION_COLONISATION)
numColonyships = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(colonyshipIDs))
colonisationPriority = 60 * (1 + numColonisablePlanetIDs - numColonyships
) / (numColonisablePlanetIDs + 1)
# print
# print "Number of Colony Ships : " + str(numColonyships)
# print "Number of Colonisable planets : " + str(numColonisablePlanetIDs)
# print "Priority for colony ships : " + str(colonisationPriority)
if colonisationPriority < 1: return 0
return colonisationPriority
def get_concentrated_tot_mil_rating():
"""
Give an assessment of total miltary rating as if all fleets were merged into a single mega-fleet.
:return: a military rating value
:rtype: float
"""
return CombatRatingsAI.combine_ratings_list([CombatRatingsAI.get_fleet_rating(fleet_id) for fleet_id in
FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)])
def get_concentrated_tot_mil_rating():
"""
Give an assessment of total miltary rating as if all fleets were merged into a single mega-fleet.
:return: a military rating value
:rtype: float
"""
return CombatRatingsAI.combine_ratings_list([CombatRatingsAI.get_fleet_rating(fleet_id) for fleet_id in
FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)])
def get_tot_mil_rating():
"""
Give an assessment of total miltary rating considering all fleets as if distributed to separate systems.
:return: a military rating value
:rtype: float
"""
return sum(CombatRatingsAI.get_fleet_rating(fleet_id)
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
def get_tot_mil_rating():
"""
Give an assessment of total miltary rating considering all fleets as if distributed to separate systems.
:return: a military rating value
:rtype: float
"""
return sum(CombatRatingsAI.get_fleet_rating(fleet_id)
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
def get_concentrated_tot_mil_rating() -> float:
"""
Give an assessment of total military rating as if all fleets were merged into a single mega-fleet.
:return: a military rating value
"""
return combine_ratings(
get_fleet_rating(fleet_id) for fleet_id in
FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
def _calculate_outpost_priority():
"""Calculates the demand for outpost ships by colonisable planets."""
global allotted_outpost_targets
base_outpost_cost = AIDependencies.OUTPOST_POD_COST
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
if num_colonies > colony_growth_barrier:
return 0.0
mil_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_MILITARY)
not_sparse, enemy_unseen = 0, 0
is_sparse, enemy_seen = 1, 1
allotted_portion = {
(not_sparse, enemy_unseen): (0.6, 0.8),
(not_sparse, enemy_seen): (0.3, 0.4),
(is_sparse, enemy_unseen): (0.8, 0.9),
(is_sparse, enemy_seen): (0.3, 0.4),
}[(galaxy_is_sparse, any(enemies_sighted))]
allotted_portion = foAI.foAIstate.character.preferred_outpost_portion(
allotted_portion)
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
allotted_outpost_targets = 1 + int(
total_pp * 3 * allotted_portion / base_outpost_cost)
num_outpost_targets = len([
pid
for (pid, (score,
specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > 1.0 * base_outpost_cost / 3.0
][:allotted_outpost_targets])
if num_outpost_targets == 0 or not tech_is_complete(
AIDependencies.OUTPOSTING_TECH):
return 0
outpost_ship_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
MissionType.OUTPOST)
num_outpost_ships = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(outpost_ship_ids))
outpost_priority = (
50.0 * (num_outpost_targets - num_outpost_ships)) / num_outpost_targets
# print
# print "Number of Outpost Ships : " + str(num_outpost_ships)
# print "Number of Colonisable outposts: " + str(num_outpost_planet_ids)
print "Priority for outpost ships: " + str(outpost_priority)
if outpost_priority < 1:
return 0
return outpost_priority
def calculateOutpostPriority():
"""calculates the demand for outpost ships by colonisable planets"""
global allotted_outpost_targets
base_outpost_cost = AIDependencies.OUTPOST_POD_COST
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
# significant growth barrier for low aggression, negligible for high aggression
if num_colonies > colony_growth_barrier:
return 0.0
mil_prio = foAI.foAIstate.get_priority(
EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)
NOT_SPARCE, ENEMY_UNSEEN = 0, 0
IS_SPARCE, ENEMY_SEEN = 1, 1
allotted_portion = {
(NOT_SPARCE, ENEMY_UNSEEN): (0.6, 0.8),
(NOT_SPARCE, ENEMY_SEEN): (0.3, 0.4),
(IS_SPARCE, ENEMY_UNSEEN): (0.8, 0.9),
(IS_SPARCE, ENEMY_SEEN): (0.3, 0.4),
}[(galaxy_is_sparse, any(enemies_sighted))][fo.empireID() % 2]
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
allotted_outpost_targets = 1 + int(
total_pp * 3 * allotted_portion / base_outpost_cost)
num_outpost_targets = len([
pid
for (pid, (score,
specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > 1.0 * base_outpost_cost / 3.0
][:allotted_outpost_targets])
if num_outpost_targets == 0 or not tech_is_complete(
AIDependencies.OUTPOSTING_TECH):
return 0
outpostShipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(
EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
num_outpost_ships = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(outpostShipIDs))
outpost_priority = 50 * (num_outpost_targets -
num_outpost_ships) / num_outpost_targets
# print
# print "Number of Outpost Ships : " + str(num_outpost_ships)
# print "Number of Colonisable outposts: " + str(num_outpost_planet_ids)
print "Priority for outpost ships : " + str(outpost_priority)
if outpost_priority < 1: return 0
return outpost_priority
def assign_colony_fleets_to_colonise():
aistate = get_aistate()
aistate.orbital_colonization_manager.assign_bases_to_colonize()
# assign fleet targets to colonisable planets
all_colony_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.COLONISATION)
send_colony_ships(
FleetUtilsAI.extract_fleet_ids_without_mission_types(all_colony_fleet_ids),
list(aistate.colonisablePlanetIDs.items()),
MissionType.COLONISATION,
)
# assign fleet targets to colonisable outposts
all_outpost_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.OUTPOST)
send_colony_ships(
FleetUtilsAI.extract_fleet_ids_without_mission_types(all_outpost_fleet_ids),
list(aistate.colonisableOutpostIDs.items()),
MissionType.OUTPOST,
)
def assign_invasion_bases():
"""Assign our troop bases to invasion targets."""
universe = fo.getUniverse()
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
aistate = get_aistate()
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # entry may have been discarded in previous loop iterations
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(aistate.qualifyingTroopBaseTargets.keys()))
debug("Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, aistate.qualifyingTroopBaseTargets[pid]) for pid in available_planets]))
targets = [pid for pid in available_planets if aistate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
debug("Failure: found no valid target for troop base in system %s" % system)
continue
status = aistate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
target_id = INVALID_ID
best_score = -1
target_troops = 0
for pid, (p_score, p_troops) in assign_invasion_values(targets).items():
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == INVALID_ID:
continue
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed + _TROOPS_SAFETY_MARGIN}
FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=local_base_troops,
fleet_list=found_fleets)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
aistate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = TargetPlanet(target_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.set_target(MissionType.ORBITAL_INVASION, target)
def assign_invasion_bases():
"""Assign our troop bases to invasion targets."""
universe = fo.getUniverse()
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
aistate = get_aistate()
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # entry may have been discarded in previous loop iterations
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(aistate.qualifyingTroopBaseTargets.keys()))
debug("Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, aistate.qualifyingTroopBaseTargets[pid]) for pid in available_planets]))
targets = [pid for pid in available_planets if aistate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
debug("Failure: found no valid target for troop base in system %s" % system)
continue
status = aistate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
target_id = INVALID_ID
best_score = -1
target_troops = 0
for pid, (p_score, p_troops) in assign_invasion_values(targets).items():
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id == INVALID_ID:
continue
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed + _TROOPS_SAFETY_MARGIN}
FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, found_stats,
starting_system=sys_id, fleet_pool_set=local_base_troops,
fleet_list=found_fleets)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
aistate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = TargetPlanet(target_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.set_target(MissionType.ORBITAL_INVASION, target)
def calculateColonisationPriority():
"""calculates the demand for colony ships by colonisable planets"""
global allottedColonyTargets, colony_growth_barrier
enemies_sighted = foAI.foAIstate.misc.get("enemies_sighted", {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
# significant growth barrier for low aggression, negligible for high aggression
colony_growth_barrier = 2 + ((0.5 + foAI.foAIstate.aggression) ** 2) * fo.currentTurn() / 50.0
colonyCost = AIDependencies.COLONY_POD_COST * (1 + AIDependencies.COLONY_POD_UPKEEP * num_colonies)
turnsToBuild = 8 # TODO: check for susp anim pods, build time 10
mil_prio = foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)
allottedPortion = [[[0.6, 0.8], [0.3, 0.4]], [[0.8, 0.9], [0.3, 0.4]]][galaxy_is_sparse][any(enemies_sighted)][
fo.empireID() % 2
]
# if ( foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION)
# > 2 * foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)):
# allottedPortion *= 1.5
if mil_prio < 100:
allottedPortion *= 2
elif mil_prio < 200:
allottedPortion *= 1.5
elif fo.currentTurn() > 100:
allottedPortion *= 0.75 ** (num_colonies / 10.0)
# allottedColonyTargets = 1+ int(fo.currentTurn()/50)
allottedColonyTargets = 1 + int(total_pp * turnsToBuild * allottedPortion / colonyCost)
outpost_prio = foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_OUTPOST)
# if have any outposts to build, don't build colony ships TODO: make more complex assessment
if outpost_prio > 0 or num_colonies > colony_growth_barrier:
return 0.0
if num_colonies > colony_growth_barrier:
return 0.0
numColonisablePlanetIDs = len(
[pid for (pid, (score, _)) in foAI.foAIstate.colonisablePlanetIDs.items() if score > 60][
: allottedColonyTargets + 2
]
)
if numColonisablePlanetIDs == 0:
return 1
colonyshipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_COLONISATION)
numColonyships = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(colonyshipIDs))
colonisationPriority = 60 * (1 + numColonisablePlanetIDs - numColonyships) / (numColonisablePlanetIDs + 1)
# print
# print "Number of Colony Ships : " + str(numColonyships)
# print "Number of Colonisable planets : " + str(numColonisablePlanetIDs)
# print "Priority for colony ships : " + str(colonisationPriority)
if colonisationPriority < 1:
return 0
return colonisationPriority
def _calculate_outpost_priority():
"""Calculates the demand for outpost ships by colonisable planets."""
global allotted_outpost_targets
base_outpost_cost = AIDependencies.OUTPOST_POD_COST
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
if state.get_number_of_colonies() > colony_growth_barrier:
return 0.0
mil_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_MILITARY)
not_sparse, enemy_unseen = 0, 0
is_sparse, enemy_seen = 1, 1
allotted_portion = {
(not_sparse, enemy_unseen): (0.6, 0.8),
(not_sparse, enemy_seen): (0.3, 0.4),
(is_sparse, enemy_unseen): (0.8, 0.9),
(is_sparse, enemy_seen): (0.3, 0.4),
}[(galaxy_is_sparse, any(enemies_sighted))]
allotted_portion = foAI.foAIstate.character.preferred_outpost_portion(allotted_portion)
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
allotted_outpost_targets = 1 + int(total_pp * 3 * allotted_portion / base_outpost_cost)
num_outpost_targets = len([pid for (pid, (score, specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > max(1.0 * base_outpost_cost / 3.0, ColonisationAI.MINIMUM_COLONY_SCORE)]
[:allotted_outpost_targets])
if num_outpost_targets == 0 or not tech_is_complete(AIDependencies.OUTPOSTING_TECH):
return 0
outpost_ship_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.OUTPOST)
num_outpost_ships = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(outpost_ship_ids))
outpost_priority = (50.0 * (num_outpost_targets - num_outpost_ships)) / num_outpost_targets
# discourage early outposting for SP_SLY, due to supply and stealth considerations they are best off
# using colony ships until they have other colonizers (and more established military)
if list(ColonisationAI.empire_colonizers) == ["SP_SLY"]:
outpost_priority /= 3.0
# print
# print "Number of Outpost Ships : " + str(num_outpost_ships)
# print "Number of Colonisable outposts: " + str(num_outpost_planet_ids)
print "Priority for outpost ships: " + str(outpost_priority)
if outpost_priority < 1:
return 0
return outpost_priority
def calculateOutpostPriority():
"""calculates the demand for outpost ships by colonisable planets"""
global allotted_outpost_targets
base_outpost_cost = AIDependencies.OUTPOST_POD_COST
enemies_sighted = foAI.foAIstate.misc.get("enemies_sighted", {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
# significant growth barrier for low aggression, negligible for high aggression
if num_colonies > colony_growth_barrier:
return 0.0
mil_prio = foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)
NOT_SPARCE, ENEMY_UNSEEN = 0, 0
IS_SPARCE, ENEMY_SEEN = 1, 1
allotted_portion = {
(NOT_SPARCE, ENEMY_UNSEEN): (0.6, 0.8),
(NOT_SPARCE, ENEMY_SEEN): (0.3, 0.4),
(IS_SPARCE, ENEMY_UNSEEN): (0.8, 0.9),
(IS_SPARCE, ENEMY_SEEN): (0.3, 0.4),
}[(galaxy_is_sparse, any(enemies_sighted))][fo.empireID() % 2]
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
allotted_outpost_targets = 1 + int(total_pp * 3 * allotted_portion / base_outpost_cost)
num_outpost_targets = len(
[
pid
for (pid, (score, specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > 1.0 * base_outpost_cost / 3.0
][:allotted_outpost_targets]
)
if num_outpost_targets == 0 or not tech_is_complete(AIDependencies.OUTPOSTING_TECH):
return 0
outpostShipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
num_outpost_ships = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(outpostShipIDs))
outpost_priority = 50 * (num_outpost_targets - num_outpost_ships) / num_outpost_targets
# print
# print "Number of Outpost Ships : " + str(num_outpost_ships)
# print "Number of Colonisable outposts: " + str(num_outpost_planet_ids)
print "Priority for outpost ships : " + str(outpost_priority)
if outpost_priority < 1:
return 0
return outpost_priority
def _calculate_colonisation_priority():
"""Calculates the demand for colony ships by colonisable planets."""
global allottedColonyTargets
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
colony_cost = AIDependencies.COLONY_POD_COST * (1 + AIDependencies.COLONY_POD_UPKEEP * num_colonies)
turns_to_build = 8 # TODO: check for susp anim pods, build time 10
mil_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_MILITARY)
allotted_portion = ([[[0.6, 0.8], [0.3, 0.4]], [[0.8, 0.9], [0.4, 0.6]]][galaxy_is_sparse]
[any(enemies_sighted)])
allotted_portion = foAI.foAIstate.character.preferred_colonization_portion(allotted_portion)
# if ( foAI.foAIstate.get_priority(AIPriorityType.PRIORITY_PRODUCTION_COLONISATION)
# > 2 * foAI.foAIstate.get_priority(AIPriorityType.PRIORITY_PRODUCTION_MILITARY)):
# allotted_portion *= 1.5
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
elif fo.currentTurn() > 100:
allotted_portion *= 0.75 ** (num_colonies / 10.0)
# allottedColonyTargets = 1+ int(fo.currentTurn()/50)
allottedColonyTargets = 1 + int(total_pp * turns_to_build * allotted_portion / colony_cost)
outpost_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_OUTPOST)
# if have any outposts to build, don't build colony ships TODO: make more complex assessment
if outpost_prio > 0 or num_colonies > colony_growth_barrier:
return 0.0
if num_colonies > colony_growth_barrier:
return 0.0
num_colonisable_planet_ids = len([pid for (pid, (score, _)) in foAI.foAIstate.colonisablePlanetIDs.items()
if score > 60][:allottedColonyTargets + 2])
if num_colonisable_planet_ids == 0:
return 1
colony_ship_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.COLONISATION)
num_colony_ships = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(colony_ship_ids))
colonisation_priority = 60 * (1 + num_colonisable_planet_ids - num_colony_ships) / (num_colonisable_planet_ids + 1)
# print
# print "Number of Colony Ships : " + str(num_colony_ships)
# print "Number of Colonisable planets : " + str(num_colonisable_planet_ids)
# print "Priority for colony ships : " + str(colonisation_priority)
if colonisation_priority < 1:
return 0
return colonisation_priority
def get_empire_standard_fighter():
"""Get the current empire standard fighter stats, i.e. the most common shiptype within the empire.
:return: Stats of most common fighter in the empire
:rtype: ShipCombatStats
"""
stats_dict = Counter()
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY):
ship_stats = FleetCombatStats(fleet_id, consider_refuel=True).get_ship_combat_stats()
stats_dict.update(ship_stats)
most_commons = stats_dict.most_common(1)
if most_commons:
return most_commons[0][0]
else:
return default_ship_stats()
def get_empire_standard_fighter():
"""Get the current empire standard fighter stats, i.e. the most common shiptype within the empire.
:return: Stats of most common fighter in the empire
:rtype: ShipCombatStats
"""
stats_dict = Counter()
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY):
ship_stats = FleetCombatStats(fleet_id, consider_refuel=True).get_ship_combat_stats()
stats_dict.update(ship_stats)
most_commons = stats_dict.most_common(1)
if most_commons:
return most_commons[0][0]
else:
return default_ship_stats()
def calculateExplorationPriority():
"""calculates the demand for scouts by unexplored systems"""
global scoutsNeeded
universe = fo.getUniverse()
empire = fo.getEmpire()
numUnexploredSystems = len(
ExplorationAI.borderUnexploredSystemIDs
) #len(foAI.foAIstate.get_explorable_systems(AIExplorableSystemType.EXPLORABLE_SYSTEM_UNEXPLORED))
numScouts = sum(
[
foAI.foAIstate.fleetStatus.get(fid, {}).get('nships', 0)
for fid in FleetUtilsAI.get_empire_fleet_ids_by_role(
EnumsAI.AIFleetMissionType.FLEET_MISSION_EXPLORATION)
]
) # FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_EXPLORATION)
productionQueue = empire.productionQueue
queuedScoutShips = 0
for queue_index in range(0, len(productionQueue)):
element = productionQueue[queue_index]
if element.buildType == EnumsAI.AIEmpireProductionTypes.BT_SHIP:
if foAI.foAIstate.get_ship_role(
element.designID
) == EnumsAI.AIShipRoleType.SHIP_ROLE_CIVILIAN_EXPLORATION:
queuedScoutShips += element.remaining * element.blocksize
milShips = MilitaryAI.num_milships
# intent of the following calc is essentially
# new_scouts_needed = min(need_cap_A, need_cap_B, base_need) - already_got_or_queued
# where need_cap_A is to help prevent scouting needs from swamping military needs, and
# need_cap_B is to help regulate investment into scouting while the empire is small.
# These caps could perhaps instead be tied more directly to military priority and
# total empire production.
scoutsNeeded = max(
0,
min(4 + int(milShips / 5), 4 + int(fo.currentTurn() / 50),
2 + numUnexploredSystems**0.5) - numScouts - queuedScoutShips)
explorationPriority = int(40 * scoutsNeeded)
print
print "Number of Scouts : " + str(numScouts)
print "Number of Unexplored systems: " + str(numUnexploredSystems)
print "military size: ", milShips
print "Priority for scouts : " + str(explorationPriority)
return explorationPriority
def _calculate_outpost_priority():
"""Calculates the demand for outpost ships by colonisable planets."""
global allotted_outpost_targets
base_outpost_cost = AIDependencies.OUTPOST_POD_COST
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = len(list(AIstate.popCtrIDs))
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
if num_colonies > colony_growth_barrier:
return 0.0
mil_prio = foAI.foAIstate.get_priority(PriorityType.PRODUCTION_MILITARY)
not_sparse, enemy_unseen = 0, 0
is_sparse, enemy_seen = 1, 1
allotted_portion = {
(not_sparse, enemy_unseen): (0.6, 0.8),
(not_sparse, enemy_seen): (0.3, 0.4),
(is_sparse, enemy_unseen): (0.8, 0.9),
(is_sparse, enemy_seen): (0.3, 0.4),
}[(galaxy_is_sparse, any(enemies_sighted))]
allotted_portion = foAI.foAIstate.character.preferred_outpost_portion(allotted_portion)
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
allotted_outpost_targets = 1 + int(total_pp * 3 * allotted_portion / base_outpost_cost)
num_outpost_targets = len([pid for (pid, (score, specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > 1.0 * base_outpost_cost / 3.0][:allotted_outpost_targets])
if num_outpost_targets == 0 or not tech_is_complete(AIDependencies.OUTPOSTING_TECH):
return 0
outpost_ship_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.OUTPOST)
num_outpost_ships = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(outpost_ship_ids))
outpost_priority = 50 * (num_outpost_targets - num_outpost_ships) / num_outpost_targets
# print
# print "Number of Outpost Ships : " + str(num_outpost_ships)
# print "Number of Colonisable outposts: " + str(num_outpost_planet_ids)
print "Priority for outpost ships: " + str(outpost_priority)
if outpost_priority < 1:
return 0
return outpost_priority
def get_current_exploration_info():
"""Returns ([current target list], [available scout list])."""
fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.EXPLORATION)
available_scouts = []
already_covered = set()
for fleet_id in fleet_ids:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
if not fleet_mission.type:
available_scouts.append(fleet_id)
else:
if fleet_mission.type == MissionType.EXPLORATION:
already_covered.add(fleet_mission.target)
if not fleet_mission.target:
print "problem determining existing exploration target systems"
else:
print "found existing exploration target: %s" % fleet_mission.target
return list(already_covered), available_scouts
def calculateExplorationPriority():
"""calculates the demand for scouts by unexplored systems"""
global scoutsNeeded
universe = fo.getUniverse()
empire = fo.getEmpire()
numUnexploredSystems = len(
ExplorationAI.borderUnexploredSystemIDs
) # len(foAI.foAIstate.get_explorable_systems(AIExplorableSystemType.EXPLORABLE_SYSTEM_UNEXPLORED))
numScouts = sum(
[
foAI.foAIstate.fleetStatus.get(fid, {}).get("nships", 0)
for fid in FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_EXPLORATION)
]
) # FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_EXPLORATION)
productionQueue = empire.productionQueue
queuedScoutShips = 0
for queue_index in range(0, len(productionQueue)):
element = productionQueue[queue_index]
if element.buildType == EnumsAI.AIEmpireProductionTypes.BT_SHIP:
if foAI.foAIstate.get_ship_role(element.designID) == EnumsAI.AIShipRoleType.SHIP_ROLE_CIVILIAN_EXPLORATION:
queuedScoutShips += element.remaining * element.blocksize
milShips = MilitaryAI.num_milships
# intent of the following calc is essentially
# new_scouts_needed = min(need_cap_A, need_cap_B, base_need) - already_got_or_queued
# where need_cap_A is to help prevent scouting needs from swamping military needs, and
# need_cap_B is to help regulate investment into scouting while the empire is small.
# These caps could perhaps instead be tied more directly to military priority and
# total empire production.
scoutsNeeded = max(
0,
min(4 + int(milShips / 5), 4 + int(fo.currentTurn() / 50), 2 + numUnexploredSystems ** 0.5)
- numScouts
- queuedScoutShips,
)
explorationPriority = int(40 * scoutsNeeded)
print
print "Number of Scouts : " + str(numScouts)
print "Number of Unexplored systems: " + str(numUnexploredSystems)
print "military size: ", milShips
print "Priority for scouts : " + str(explorationPriority)
return explorationPriority
def get_current_exploration_info(verbose=True):
"""returns ( [current target list] , [available scout list] ) """
fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_EXPLORATION)
available_scouts = []
already_covered = set()
for fleet_id in fleet_ids:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
if len(fleet_mission.get_mission_types()) == 0:
available_scouts.append(fleet_id)
else:
targets = [targ.target_id for targ in fleet_mission.get_targets(AIFleetMissionType.FLEET_MISSION_EXPLORATION)]
if verbose:
if len(targets) == 0:
print "problem determining existing exploration target systems from targets:\n%s" % (fleet_mission.get_targets(AIFleetMissionType.FLEET_MISSION_EXPLORATION))
else:
print "found existing exploration targets: %s" % targets
already_covered.update(targets)
return list(already_covered), available_scouts
def get_current_exploration_info(verbose=True):
"""returns ( [current target list] , [available scout list] ) """
fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_EXPLORATION)
available_scouts = []
already_covered = set()
for fleet_id in fleet_ids:
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
if len(fleet_mission.get_mission_types()) == 0:
available_scouts.append(fleet_id)
else:
targets = [targ.target_id for targ in fleet_mission.get_targets(AIFleetMissionType.FLEET_MISSION_EXPLORATION)]
if verbose:
if len(targets) == 0:
print "problem determining existing exploration target systems from targets:\n%s" % (fleet_mission.get_targets(AIFleetMissionType.FLEET_MISSION_EXPLORATION))
else:
print "found existing exploration targets: %s" % targets
already_covered.update(targets)
return list(already_covered), available_scouts
def assign_bases_to_colonize(self):
universe = fo.getUniverse()
all_outpost_base_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_OUTPOST)
avail_outpost_base_fleet_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(all_outpost_base_fleet_ids)
for fid in avail_outpost_base_fleet_ids:
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
avail_plans = [
plan
for plan in self._colonization_plans.values()
if plan.target in system.planetIDs and not plan.base_assigned
]
avail_plans.sort(key=lambda x: x.score, reverse=True)
for plan in avail_plans:
success = plan.assign_base(fid)
if success:
break
def calculateColonisationPriority():
"""calculates the demand for colony ships by colonisable planets"""
global allottedColonyTargets, colonyGrowthBarrier
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted',{})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
totalPP=fo.getEmpire().productionPoints
num_colonies = len( list(AIstate.popCtrIDs) )
colonyGrowthBarrier = 2 + ((0.5+foAI.foAIstate.aggression)**2)*fo.currentTurn()/50.0 #significant for low aggression, negligible for high aggression
if num_colonies > colonyGrowthBarrier:
return 0.0
colonyCost=120*(1+ 0.06*num_colonies)
turnsToBuild=8#TODO: check for susp anim pods, build time 10
mil_prio = foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)
allottedPortion = [[[0.6, 0.8],[0.3, 0.4]],[[0.8, 0.9],[0.3, 0.4]]][galaxy_is_sparse][any(enemies_sighted)][fo.empireID() % 2] #
#if ( foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION)
# > 2 * foAI.foAIstate.get_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY)):
# allottedPortion *= 1.5
if mil_prio < 100:
allottedPortion *= 2
elif mil_prio < 200:
allottedPortion *= 1.5
elif fo.currentTurn() > 100:
allottedPortion *= 0.75**(num_colonies/10.0)
#allottedColonyTargets = 1+ int(fo.currentTurn()/50)
allottedColonyTargets = 1 + int( totalPP*turnsToBuild*allottedPortion/colonyCost)
numColonisablePlanetIDs = len( [ pid for (pid, (score, specName) ) in foAI.foAIstate.colonisablePlanetIDs if score > 60 ][:allottedColonyTargets+2] )
if numColonisablePlanetIDs == 0: return 1
colonyshipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_COLONISATION)
numColonyships = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(colonyshipIDs))
colonisationPriority = 60 * (1+numColonisablePlanetIDs - numColonyships) / (numColonisablePlanetIDs+1)
# print
# print "Number of Colony Ships : " + str(numColonyships)
# print "Number of Colonisable planets : " + str(numColonisablePlanetIDs)
# print "Priority for colony ships : " + str(colonisationPriority)
if colonisationPriority < 1: return 1
return colonisationPriority
def _calculate_exploration_priority():
"""Calculates the demand for scouts by unexplored systems."""
empire = fo.getEmpire()
num_unexplored_systems = len(ExplorationAI.border_unexplored_system_ids)
aistate = get_aistate()
num_scouts = sum([
aistate.fleetStatus.get(fid, {}).get('nships', 0) for fid in
FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.EXPLORATION)
])
production_queue = empire.productionQueue
queued_scout_ships = 0
for queue_index in range(0, len(production_queue)):
element = production_queue[queue_index]
if element.buildType == EmpireProductionTypes.BT_SHIP:
if aistate.get_ship_role(
element.designID) == ShipRoleType.CIVILIAN_EXPLORATION:
queued_scout_ships += element.remaining * element.blocksize
mil_ships = MilitaryAI.get_num_military_ships()
# intent of the following calc is essentially
# new_scouts_needed = min(need_cap_A, need_cap_B, base_need) - already_got_or_queued
# where need_cap_A is to help prevent scouting needs from swamping military needs, and
# need_cap_B is to help regulate investment into scouting while the empire is small.
# These caps could perhaps instead be tied more directly to military priority and
# total empire production.
desired_number_of_scouts = int(
min(4 + mil_ships / 5, 4 + fo.currentTurn() / 50.0,
2 + num_unexplored_systems**0.5))
scouts_needed = max(
0, desired_number_of_scouts - (num_scouts + queued_scout_ships))
exploration_priority = int(40 * scouts_needed)
debug('')
debug("Number of Scouts: %s" % num_scouts)
debug("Number of Unexplored systems: %s" % num_unexplored_systems)
debug("Military size: %s" % mil_ships)
debug("Priority for scouts: %s" % exploration_priority)
return exploration_priority
def calculateOutpostPriority():
"""calculates the demand for outpost ships by colonisable planets"""
baseOutpostCost=80
numOutpostPlanetIDs = len(foAI.foAIstate.colonisableOutpostIDs)
numOutpostPlanetIDs = len( [ pid for (pid, (score, specName) ) in foAI.foAIstate.colonisableOutpostIDs if score > 1.0*baseOutpostCost/3.0 ][:allottedColonyTargets] )
completedTechs = ResearchAI.get_completed_techs()
if numOutpostPlanetIDs == 0 or not AIDependencies.OUTPOSTING_TECH in completedTechs:
return 0
outpostShipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
numOutpostShips = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(outpostShipIDs))
outpostPriority = 50 * (numOutpostPlanetIDs - numOutpostShips) / numOutpostPlanetIDs
# print
# print "Number of Outpost Ships : " + str(numOutpostShips)
# print "Number of Colonisable outposts: " + str(numOutpostPlanetIDs)
print "Priority for outpost ships : " + str(outpostPriority)
if outpostPriority < 1: return 1
return outpostPriority
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global _military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
aistate = get_aistate()
if doing_main:
aistate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = TargetSystem(sys_id)
fleet_mission = aistate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.set_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
_military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = _military_allocations
debug("==================================================")
debug("Assigning military fleets")
debug("---------------------------------")
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, rvp, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
debug("Allocating for: %s", TargetSystem(sys_id))
found_fleets = []
found_stats = {}
ensure_return = sys_id not in set(AIstate.colonyTargetedSystemIDs
+ AIstate.outpostTargetedSystemIDs
+ AIstate.invasionTargetedSystemIDs)
these_fleets = FleetUtilsAI.get_fleets_for_mission(
target_stats={'rating': alloc, 'ratingVsPlanets': rvp, 'target_system': TargetSystem(sys_id)},
min_stats={'rating': minalloc, 'ratingVsPlanets': rvp, 'target_system': TargetSystem(sys_id)},
cur_stats=found_stats, starting_system=sys_id, fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets, ensure_return=ensure_return)
if not these_fleets:
debug("Could not allocate any fleets.")
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if _verbose_mil_reporting:
debug("NO available/suitable military allocation for system %d ( %s ) "
"-- requested allocation %8d, found available rating %8d in fleets %s"
% (sys_id, universe.getSystem(sys_id).name, minalloc,
found_stats.get('rating', 0), found_fleets))
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
else:
debug("Assigning fleets %s to target %s", these_fleets, TargetSystem(sys_id))
if doing_main and _verbose_mil_reporting:
debug("FULL+ military allocation for system %d ( %s )"
" -- requested allocation %8d, got %8d with fleets %s"
% (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets))
target = TargetSystem(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = aistate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs):
mission_type = MissionType.SECURE
elif state.get_empire_planets_by_system(sys_id):
mission_type = MissionType.PROTECT_REGION
else:
mission_type = MissionType.MILITARY
fleet_mission.set_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
aistate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
debug("---------------------------------")
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
debug("Round %s - still have available military fleets: %s", thisround, avail_mil_fleet_ids)
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
else:
# assign remaining fleets to nearest systems to protect.
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
def system_score(_fid, _sys_id):
"""Helper function to rank systems by priority"""
jump_distance = universe.jumpDistance(_fid, _sys_id)
if get_system_local_threat(_sys_id):
weight = 10
elif get_system_neighbor_threat(_sys_id):
weight = 3
elif get_system_jump2_threat(_sys_id):
weight = 1
else:
weight = 1 / max(.5, float(state.get_distance_to_enemy_supply(_sys_id)))**1.25
return float(weight) / (jump_distance+1)
for fid in avail_mil_fleet_ids:
fleet = universe.getFleet(fid)
FleetUtilsAI.get_fleet_system(fleet)
systems = state.get_empire_planets_by_system().keys()
if not systems:
continue
sys_id = max(systems, key=lambda x: system_score(fid, x))
debug("Assigning leftover %s to system %d "
"- nothing better to do.", fleet, sys_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.clear_fleet_orders()
target_system = TargetSystem(sys_id)
fleet_mission.set_target(MissionType.PROTECT_REGION, target_system)
fleet_mission.generate_fleet_orders()
def get_num_military_ships():
return sum(foAI.foAIstate.fleetStatus.get(fid, {}).get('nships', 0)
for fid in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
aistate = get_aistate()
visible_system_ids = list(aistate.visInteriorSystemIDs) + list(
aistate.visBorderSystemIDs)
if home_system_id != INVALID_ID:
accessible_system_ids = [
sys_id for sys_id in visible_system_ids
if systems_connected(sys_id, home_system_id)
]
else:
debug(
"Empire has no identifiable homeworld; will treat all visible planets as accessible."
)
# TODO: check if any troop ships owned, use their system as home system
accessible_system_ids = visible_system_ids
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(
accessible_system_ids)
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(
acessible_planet_ids) # includes unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(
acessible_planet_ids) # includes unowned natives
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(
universe.planetIDs)
invadable_planet_ids = set(all_owned_planet_ids).union(
all_populated_planets) - set(empire_owned_planet_ids)
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(
universe.planetIDs, MissionType.INVASION)
invasion_targeted_planet_ids.extend(
get_invasion_targeted_planet_ids(universe.planetIDs,
MissionType.ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(
PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
MissionType.INVASION)
num_invasion_fleets = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(
invasion_fleet_ids))
debug("Current Invasion Targeted SystemIDs: %s" %
PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs))
debug("Current Invasion Targeted PlanetIDs: %s" %
PlanetUtilsAI.planet_string(invasion_targeted_planet_ids))
debug(invasion_fleet_ids and "Invasion Fleet IDs: %s" % invasion_fleet_ids
or "Available Invasion Fleets: 0")
debug("Invasion Fleets Without Missions: %s" % num_invasion_fleets)
invasion_timer.start("planning troop base production")
reserved_troop_base_targets = []
if aistate.character.may_invade_with_bases():
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
# For planning base trooper invasion targets we have a two-pass system. (1) In the first pass we consider all
# the invasion targets and figure out which ones appear to be suitable for using base troopers against (i.e., we
# already have a populated planet in the same system that could build base troopers) and we have at least a
# minimal amount of PP available, and (2) in the second pass we go through the reserved base trooper target list
# and check to make sure that there does not appear to be too much military action still needed before the
# target is ready to be invaded, we double check that not too many base troopers would be needed, and if things
# look clear then we queue up the base troopers on the Production Queue and keep track of where we are building
# them, and how many; we may also disqualify and remove previously qualified targets (in case, for example,
# we lost our base trooper source planet since it was first added to list).
#
# For planning and tracking base troopers under construction, we use a dictionary store in
# get_aistate().qualifyingTroopBaseTargets, keyed by the invasion target planet ID. We only store values
# for invasion targets that appear likely to be suitable for base trooper use, and store a 2-item list.
# The first item in this list is the ID of the planet where we expect to build the base troopers, and the second
# entry initially is set to INVALID_ID (-1). The presence of this entry in qualifyingTroopBaseTargets
# flags this target as being reserved as a base-trooper invasion target.
# In the second pass, if/when we actually start construction, then we modify the record, replacing that second
# value with the ID of the planet where the troopers are actually being built. (Right now that is always the
# same as the source planet originally identified, but we could consider reevaluating that, or use that second
# value to instead record how many base troopers have been queued, so that on later turns we can assess if the
# process got delayed & perhaps more troopers need to be queued).
# Pass 1: identify qualifying base troop invasion targets
for pid in invadable_planet_ids: # TODO: reorganize
if pid in aistate.qualifyingTroopBaseTargets:
continue
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = get_partial_visibility_turn(sys_id)
planet_partial_vis_turn = get_partial_visibility_turn(pid)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
best_base_planet = INVALID_ID
best_trooper_count = 0
for pid2 in get_colonized_planets_in_system(sys_id):
if available_pp.get(
pid2, 0
) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2 or not can_build_ship_for_species(
planet2.speciesName):
continue
best_base_trooper_here = get_best_ship_info(
PriorityType.PRODUCTION_ORBITAL_INVASION, pid2)[1]
if not best_base_trooper_here:
continue
troops_per_ship = best_base_trooper_here.troopCapacity
if not troops_per_ship:
continue
species_troop_grade = get_species_tag_grade(
planet2.speciesName, Tags.ATTACKTROOPS)
troops_per_ship = CombatRatingsAI.weight_attack_troops(
troops_per_ship, species_troop_grade)
if troops_per_ship > best_trooper_count:
best_base_planet = pid2
best_trooper_count = troops_per_ship
if best_base_planet != INVALID_ID:
aistate.qualifyingTroopBaseTargets.setdefault(
pid, [best_base_planet, INVALID_ID])
# Pass 2: for each target previously identified for base troopers, check that still qualifies and
# check how many base troopers would be needed; if reasonable then queue up the troops and record this in
# get_aistate().qualifyingTroopBaseTargets
for pid in list(aistate.qualifyingTroopBaseTargets.keys()):
planet = universe.getPlanet(pid)
if planet and planet.owner == empire_id:
del aistate.qualifyingTroopBaseTargets[pid]
continue
if pid in invasion_targeted_planet_ids: # TODO: consider overriding standard invasion mission
continue
if aistate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
# TODO: evaluate changes to situation, any more troops needed, etc.
continue # already building for here
_, planet_troops = evaluate_invasion_planet(pid)
sys_id = planet.systemID
this_sys_status = aistate.systemStatus.get(sys_id, {})
troop_tally = 0
for _fid in this_sys_status.get("myfleets", []):
troop_tally += FleetUtilsAI.count_troops_in_fleet(_fid)
if troop_tally > planet_troops: # base troopers appear unneeded
del aistate.qualifyingTroopBaseTargets[pid]
continue
if planet.currentMeterValue(fo.meterType.shield) > 0 and (
this_sys_status.get("myFleetRating", 0) <
0.8 * this_sys_status.get("totalThreat", 0)
or this_sys_status.get("myFleetRatingVsPlanets", 0) <
this_sys_status.get("planetThreat", 0)):
# this system not secured, so ruling out invasion base troops for now
# don't immediately delete from qualifyingTroopBaseTargets or it will be opened up for regular troops
continue
loc = aistate.qualifyingTroopBaseTargets[pid][0]
best_base_trooper_here = get_best_ship_info(
PriorityType.PRODUCTION_ORBITAL_INVASION, loc)[1]
loc_planet = universe.getPlanet(loc)
if best_base_trooper_here is None: # shouldn't be possible at this point, but just to be safe
warning(
"Could not find a suitable orbital invasion design at %s" %
loc_planet)
continue
# TODO: have TroopShipDesigner give the expected number of troops including species effects directly
troops_per_ship = best_base_trooper_here.troopCapacity
species_troop_grade = get_species_tag_grade(
loc_planet.speciesName, Tags.ATTACKTROOPS)
troops_per_ship = CombatRatingsAI.weight_attack_troops(
troops_per_ship, species_troop_grade)
if not troops_per_ship:
warning(
"The best orbital invasion design at %s seems not to have any troop capacity."
% loc_planet)
continue
_, col_design, build_choices = get_best_ship_info(
PriorityType.PRODUCTION_ORBITAL_INVASION, loc)
if not col_design:
continue
if loc not in build_choices:
warning(
"Best troop design %s can not be produced at planet with id: %s"
% (col_design, build_choices))
continue
n_bases = math.ceil(
(planet_troops + 1) /
troops_per_ship) # TODO: reconsider this +1 safety factor
# TODO: evaluate cost and time-to-build of best base trooper here versus cost and time-to-build-and-travel
# for best regular trooper elsewhere
# For now, we assume what building base troopers is best so long as either (1) we would need no more than
# MAX_BASE_TROOPERS_POOR_INVADERS base troop ships, or (2) our base troopers have more than 1 trooper per
# ship and we would need no more than MAX_BASE_TROOPERS_GOOD_INVADERS base troop ships
if n_bases > MAX_BASE_TROOPERS_POOR_INVADERS or (
troops_per_ship > 1
and n_bases > MAX_BASE_TROOPERS_GOOD_INVADERS):
debug(
"ruling out base invasion troopers for %s due to high number (%d) required."
% (planet, n_bases))
del aistate.qualifyingTroopBaseTargets[pid]
continue
debug(
"Invasion base planning, need %d troops at %d per ship, will build %d ships."
% ((planet_troops + 1), troops_per_ship, n_bases))
retval = fo.issueEnqueueShipProductionOrder(col_design.id, loc)
debug("Enqueueing %d Troop Bases at %s for %s" %
(n_bases, PlanetUtilsAI.planet_string(loc),
PlanetUtilsAI.planet_string(pid)))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
aistate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(
empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1,
0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(
set(invadable_planet_ids) - set(invasion_targeted_planet_ids) -
set(reserved_troop_base_targets))
evaluated_planets = assign_invasion_values(evaluated_planet_ids)
sorted_planets = [(pid, pscore % 10000, ptroops)
for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops)
for pid, pscore, ptroops in sorted_planets]
invasion_table = Table(
Text("Planet"),
Number("Score"),
Text("Species"),
Number("Troops"),
table_name="Potential Targets for Invasion Turn %d" % fo.currentTurn(),
)
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
invasion_table.add_row(planet, pscore, planet and planet.speciesName
or "unknown", ptroops)
invasion_table.print_table(info)
sorted_planets = [x for x in sorted_planets if x[1] > 0]
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, __, __ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" %
(len(evaluated_planet_ids)))
invasion_timer.stop_print_and_clear()
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global _military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
if doing_main:
foAI.foAIstate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = universe_object.System(sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.set_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
_military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = _military_allocations
print "=================================================="
print "Assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, rvp, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
these_fleets = FleetUtilsAI.get_fleets_for_mission({'rating': alloc, 'ratingVsPlanets': rvp},
{'rating': minalloc, 'ratingVsPlanets': rvp}, found_stats,
starting_system=sys_id, fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets)
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if _verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
elif doing_main and _verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets)
target = universe_object.System(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs):
mission_type = MissionType.SECURE
else:
mission_type = MissionType.MILITARY
fleet_mission.set_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
print "---------------------------------"
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
print "Still have available military fleets: %s" % avail_mil_fleet_ids
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
def get_tot_mil_rating():
return sum(
CombatRatingsAI.get_fleet_rating(fleet_id) for fleet_id in
FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = empire.empireID
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
AIstate.invasionFleetIDs = FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids)
home_system_id = PlanetUtilsAI.get_capital_sys_id()
visible_system_ids = foAI.foAIstate.visInteriorSystemIDs.keys() + foAI.foAIstate. visBorderSystemIDs.keys()
if home_system_id != -1:
accessible_system_ids = [sys_id for sys_id in visible_system_ids
if (sys_id != -1) and universe.systemsConnected(sys_id, home_system_id, empire_id)]
else:
print "Warning: Empire has no identifiable homeworld; will treat all visible planets as accessible."
accessible_system_ids = visible_system_ids # TODO: check if any troop ships owned, use their system as home system
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(accessible_system_ids)
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(acessible_planet_ids) # includes unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(acessible_planet_ids) # includes unowned natives
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
invadable_planet_ids = set(all_owned_planet_ids).union(all_populated_planets) - set(empire_owned_planet_ids)
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.INVASION)
invasion_targeted_planet_ids.extend(get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
num_invasion_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(invasion_fleet_ids))
print "Current Invasion Targeted SystemIDs: ", PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs)
print "Current Invasion Targeted PlanetIDs: ", PlanetUtilsAI.planet_name_ids(invasion_targeted_planet_ids)
print invasion_fleet_ids and "Invasion Fleet IDs: %s" % invasion_fleet_ids or "Available Invasion Fleets: 0"
print "Invasion Fleets Without Missions: %s" % num_invasion_fleets
invasion_timer.start("planning troop base production")
# only do base invasions if aggression is typical or above
reserved_troop_base_targets = []
if foAI.foAIstate.aggression > fo.aggression.typical:
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
for pid in invadable_planet_ids: # TODO: reorganize
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(pid, empire_id).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
for pid2 in state.get_empire_inhabited_planets_by_system().get(sys_id, []):
if available_pp.get(pid2, 0) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2:
continue
if pid not in foAI.foAIstate.qualifyingTroopBaseTargets and planet2.speciesName in ColonisationAI.empire_ship_builders:
foAI.foAIstate.qualifyingTroopBaseTargets.setdefault(pid, [pid2, -1])
break
for pid in list(foAI.foAIstate.qualifyingTroopBaseTargets):
planet = universe.getPlanet(pid) # TODO: also check that still have a colony in this system that can make troops
if planet and planet.owner == empire_id:
del foAI.foAIstate.qualifyingTroopBaseTargets[pid]
secure_ai_fleet_missions = foAI.foAIstate.get_fleet_missions_with_any_mission_types([MissionType.SECURE])
for pid in (set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()) - set(invasion_targeted_planet_ids)): # TODO: consider overriding standard invasion mission
planet = universe.getPlanet(pid)
if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
continue # already building for here
sys_id = planet.systemID
this_sys_status = foAI.foAIstate.systemStatus.get(sys_id, {})
if (planet.currentMeterValue(fo.meterType.shield) > 0 and
this_sys_status.get('myFleetRating', 0) < 0.8 * this_sys_status.get('totalThreat', 0)):
continue
loc = foAI.foAIstate.qualifyingTroopBaseTargets[pid][0]
best_base_trooper_here = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION, loc)[1]
loc_planet = universe.getPlanet(loc)
if best_base_trooper_here is None: # shouldn't be possible at this point, but just to be safe
print "Could not find a suitable orbital invasion design at %s" % loc_planet
continue
# TODO: have TroopShipDesigner give the expected number of troops including species effects directly
troops_per_ship = best_base_trooper_here.troopCapacity
species_troop_grade = CombatRatingsAI.get_species_troops_grade(loc_planet.speciesName)
troops_per_ship = CombatRatingsAI.weight_attack_troops(troops_per_ship, species_troop_grade)
if not troops_per_ship:
print "The best orbital invasion design at %s seems not to have any troop capacity." % loc_planet
continue
this_score, p_troops = evaluate_invasion_planet(pid, empire, secure_ai_fleet_missions, False)
_, col_design, build_choices = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION, loc)
if not col_design:
continue
if loc not in build_choices:
sys.stderr.write(
'Best troop design %s can not be produces in at planet with id: %s\d' % (col_design, build_choices)
)
n_bases = math.ceil((p_troops + 1) / troops_per_ship) # TODO: reconsider this +1 safety factor
print "Invasion base planning, need %d troops at %d pership, will build %d ships." % ((p_troops + 1), troops_per_ship, n_bases)
retval = fo.issueEnqueueShipProductionOrder(col_design.id, loc)
print "Enqueueing %d Troop Bases at %s for %s" % (n_bases, PlanetUtilsAI.planet_name_ids([loc]), PlanetUtilsAI.planet_name_ids([pid]))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1, 0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(set(invadable_planet_ids) - set(invasion_targeted_planet_ids) - set(reserved_troop_base_targets))
evaluated_planets = assign_invasion_values(evaluated_planet_ids, empire)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, pscore, ptroops in sorted_planets]
invasion_table = Table([Text('Planet'), Float('Score'), Text('Species'), Float('Troops')],
table_name="Potential Targets for Invasion Turn %d" % fo.currentTurn())
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
invasion_table.add_row([
planet,
pscore,
planet and planet.speciesName or "unknown",
ptroops
])
print
invasion_table.print_table()
sorted_planets = filter(lambda x: x[1] > 0, sorted_planets)
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, _, _ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" % (len(evaluated_planet_ids)))
invasion_timer.end()
def _calculate_exploration_priority():
"""Calculates the demand for scouts by unexplored systems."""
empire = fo.getEmpire()
num_unexplored_systems = len(ExplorationAI.borderUnexploredSystemIDs)
num_scouts = sum([foAI.foAIstate.fleetStatus.get(fid, {}).get('nships', 0) for fid in FleetUtilsAI.get_empire_fleet_ids_by_role(
MissionType.EXPLORATION)])
production_queue = empire.productionQueue
queued_scout_ships = 0
for queue_index in range(0, len(production_queue)):
element = production_queue[queue_index]
if element.buildType == EmpireProductionTypes.BT_SHIP:
if foAI.foAIstate.get_ship_role(element.designID) == ShipRoleType.CIVILIAN_EXPLORATION:
queued_scout_ships += element.remaining * element.blocksize
mil_ships = MilitaryAI.get_num_military_ships()
# intent of the following calc is essentially
# new_scouts_needed = min(need_cap_A, need_cap_B, base_need) - already_got_or_queued
# where need_cap_A is to help prevent scouting needs from swamping military needs, and
# need_cap_B is to help regulate investment into scouting while the empire is small.
# These caps could perhaps instead be tied more directly to military priority and
# total empire production.
desired_number_of_scouts = int(min(4 + mil_ships/5, 4 + fo.currentTurn()/50.0, 2 + num_unexplored_systems**0.5))
scouts_needed = max(0, desired_number_of_scouts - (num_scouts + queued_scout_ships))
exploration_priority = int(40 * scouts_needed)
print
print "Number of Scouts: %s" % num_scouts
print "Number of Unexplored systems: %s" % num_unexplored_systems
print "Military size: %s" % mil_ships
print "Priority for scouts: %s" % exploration_priority
return exploration_priority
def assign_invasion_fleets_to_invade():
"""Assign fleet targets to invadable planets."""
universe = fo.getUniverse()
empire = fo.getEmpire()
fleet_suppliable_system_ids = empire.fleetSupplyableSystemIDs
fleet_suppliable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(fleet_suppliable_system_ids)
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.
FLEET_MISSION_ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # TODO: I do not see how this check makes sense, maybe remove?
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()))
print "Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, foAI.foAIstate.qualifyingTroopBaseTargets[pid]) for pid in available_planets])
targets = [pid for pid in available_planets if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
print "Error: found no valid target for troop base in system %s (%d)" % (system.name, sys_id)
continue
status = foAI.foAIstate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
troop_capacity_tally = 0
for fid2 in local_base_troops:
troop_capacity_tally += FleetUtilsAI.count_troops_in_fleet(fid2)
target_id = -1
best_score = -1
target_troops = 0
for pid, rating in assign_invasion_values(targets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION,
fleet_suppliable_planet_ids, empire).items():
p_score, p_troops = rating
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id != -1:
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=local_base_troops, fleet_list=found_fleets,
verbose=False)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
foAI.foAIstate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, target_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fid)
fleet_mission.add_target(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION, target)
invasion_fleet_ids = AIstate.invasionFleetIDs
send_invasion_fleets(invasion_fleet_ids, AIstate.invasionTargets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids):
this_mission = foAI.foAIstate.get_fleet_mission(fid)
this_mission.check_mergers(context="Post-send consolidation of unassigned troops")
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
AIstate.invasionFleetIDs = FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids)
# get suppliable planets
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = empire.empireID
capital_id = PlanetUtilsAI.get_capital()
homeworld=None
if capital_id:
homeworld = universe.getPlanet(capital_id)
if homeworld:
home_system_id = homeworld.systemID
else:
home_system_id = -1
fleet_suppliable_system_ids = empire.fleetSupplyableSystemIDs
fleet_suppliable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(fleet_suppliable_system_ids)
prime_invadable_system_ids = set(ColonisationAI.annexable_system_ids)
prime_invadable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(prime_invadable_system_ids)
visible_system_ids = foAI.foAIstate.visInteriorSystemIDs.keys() + foAI.foAIstate. visBorderSystemIDs.keys()
if home_system_id != -1:
accessible_system_ids = [sys_id for sys_id in visible_system_ids if (sys_id != -1) and universe.systemsConnected(sys_id, home_system_id, empire_id)]
else:
print "Invasion Warning: this empire has no identifiable homeworld, will therefor treat all visible planets as accessible."
accessible_system_ids = visible_system_ids # TODO: check if any troop ships still owned, use their system as home system
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(accessible_system_ids)
print "Accessible Systems: ", ", ".join(PlanetUtilsAI.sys_name_ids(accessible_system_ids))
print
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(acessible_planet_ids) # need these for unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(acessible_planet_ids) # need this for natives
print "All Visible and accessible Populated PlanetIDs (including this empire's): ", ", ".join(PlanetUtilsAI.planet_name_ids(all_populated_planets))
print
print "Prime Invadable Target Systems: ", ", ".join(PlanetUtilsAI.sys_name_ids(prime_invadable_system_ids))
print
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
invadable_planet_ids = set(prime_invadable_planet_ids).intersection(set(all_owned_planet_ids).union(all_populated_planets) - set(empire_owned_planet_ids))
print "Prime Invadable PlanetIDs: ", ", ".join(PlanetUtilsAI.planet_name_ids(invadable_planet_ids))
print
print "Current Invasion Targeted SystemIDs: ", ", ".join(PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs))
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(universe.planetIDs, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
invasion_targeted_planet_ids.extend(get_invasion_targeted_planet_ids(universe.planetIDs, EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
print "Current Invasion Targeted PlanetIDs: ", ", ".join(PlanetUtilsAI.planet_name_ids(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
if not invasion_fleet_ids:
print "Available Invasion Fleets: 0"
else:
print "Invasion FleetIDs: %s" % FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
num_invasion_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(invasion_fleet_ids))
print "Invasion Fleets Without Missions: %s" % num_invasion_fleets
invasion_timer.start("planning troop base production")
# only do base invasions if aggression is typical or above
reserved_troop_base_targets = []
if foAI.foAIstate.aggression > fo.aggression.typical:
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
for pid in invadable_planet_ids: # TODO: reorganize
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(pid, empire_id).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
for pid2 in ColonisationAI.empire_species_systems.get(sys_id, {}).get('pids', []):
if available_pp.get(pid2, 0) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2:
continue
if pid not in foAI.foAIstate.qualifyingTroopBaseTargets and planet2.speciesName in ColonisationAI.empire_ship_builders:
foAI.foAIstate.qualifyingTroopBaseTargets.setdefault(pid, [pid2, -1])
break
for pid in list(foAI.foAIstate.qualifyingTroopBaseTargets):
planet = universe.getPlanet(pid) # TODO: also check that still have a colony in this system that can make troops
if planet and planet.owner == empire_id:
del foAI.foAIstate.qualifyingTroopBaseTargets[pid]
secure_ai_fleet_missions = foAI.foAIstate.get_fleet_missions_with_any_mission_types([EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE])
for pid in (set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()) - set(invasion_targeted_planet_ids)): # TODO: consider overriding standard invasion mission
planet = universe.getPlanet(pid)
if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
continue # already building for here
sys_id = planet.systemID
this_sys_status = foAI.foAIstate.systemStatus.get(sys_id, {})
if (planet.currentMeterValue(fo.meterType.shield) > 0 and
this_sys_status.get('myFleetRating', 0) < 0.8 * this_sys_status.get('totalThreat', 0)):
continue
loc = foAI.foAIstate.qualifyingTroopBaseTargets[pid][0]
this_score, p_troops = evaluate_invasion_planet(pid, empire, secure_ai_fleet_missions, False)
best_ship, col_design, build_choices = ProductionAI.getBestShipInfo(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_ORBITAL_INVASION, loc)
if not best_ship:
continue
n_bases = math.ceil((p_troops+1) / 2) # TODO: reconsider this +1 safety factor
retval = fo.issueEnqueueShipProductionOrder(best_ship, loc)
print "Enqueueing %d Troop Bases at %s for %s" % (n_bases, PlanetUtilsAI.planet_name_ids([loc]), PlanetUtilsAI.planet_name_ids([pid]))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1, 0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(set(invadable_planet_ids) - set(invasion_targeted_planet_ids) - set(reserved_troop_base_targets))
print "Evaluating potential invasions, PlanetIDs: %s" % evaluated_planet_ids
evaluated_planets = assign_invasion_values(evaluated_planet_ids, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, fleet_suppliable_planet_ids, empire)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, pscore, ptroops in sorted_planets]
print
if sorted_planets:
print "Invadable planets:\n%-6s | %-6s | %-16s | %-16s | Troops" % ('ID', 'Score', 'Name', 'Race')
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
if planet:
print "%6d | %6d | %16s | %16s | %d" % (pid, pscore, planet.name, planet.speciesName, ptroops)
else:
print "%6d | %6d | Error: invalid planet ID" % (pid, pscore)
else:
print "No Invadable planets identified"
sorted_planets = filter(lambda x: x[1] > 0, sorted_planets)
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, _, _ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" % (len(evaluated_planet_ids)))
invasion_timer.end()
def assign_invasion_fleets_to_invade():
"""Assign fleet targets to invadable planets."""
universe = fo.getUniverse()
empire = fo.getEmpire()
fleet_suppliable_system_ids = empire.fleetSupplyableSystemIDs
fleet_suppliable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(fleet_suppliable_system_ids)
all_troopbase_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.
FLEET_MISSION_ORBITAL_INVASION)
available_troopbase_fleet_ids = set(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_troopbase_fleet_ids))
for fid in list(available_troopbase_fleet_ids):
if fid not in available_troopbase_fleet_ids: # TODO: I do not see how this check makes sense, maybe remove?
continue
fleet = universe.getFleet(fid)
if not fleet:
continue
sys_id = fleet.systemID
system = universe.getSystem(sys_id)
available_planets = set(system.planetIDs).intersection(set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()))
print "Considering Base Troopers in %s, found planets %s and registered targets %s with status %s" % (
system.name, list(system.planetIDs), available_planets,
[(pid, foAI.foAIstate.qualifyingTroopBaseTargets[pid]) for pid in available_planets])
targets = [pid for pid in available_planets if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1]
if not targets:
print "Error: found no valid target for troop base in system %s (%d)" % (system.name, sys_id)
continue
status = foAI.foAIstate.systemStatus.get(sys_id, {})
local_base_troops = set(status.get('myfleets', [])).intersection(available_troopbase_fleet_ids)
troop_capacity_tally = 0
for fid2 in local_base_troops:
troop_capacity_tally += FleetUtilsAI.count_troops_in_fleet(fid2)
target_id = -1
best_score = -1
target_troops = 0
for pid, rating in assign_invasion_values(targets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION,
fleet_suppliable_planet_ids, empire).items():
p_score, p_troops = rating
if p_score > best_score:
best_score = p_score
target_id = pid
target_troops = p_troops
if target_id != -1:
local_base_troops.discard(fid)
found_fleets = []
troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fid))
found_stats = {}
min_stats = {'rating': 0, 'troopCapacity': troops_needed}
target_stats = {'rating': 10, 'troopCapacity': troops_needed}
FleetUtilsAI.get_fleets_for_mission(1, target_stats, min_stats, found_stats, "",
systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=local_base_troops, fleet_list=found_fleets,
verbose=False)
for fid2 in found_fleets:
FleetUtilsAI.merge_fleet_a_into_b(fid2, fid)
available_troopbase_fleet_ids.discard(fid2)
available_troopbase_fleet_ids.discard(fid)
foAI.foAIstate.qualifyingTroopBaseTargets[target_id][1] = -1 # TODO: should probably delete
target = AITarget.AITarget(EnumsAI.TargetType.TARGET_PLANET, target_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fid)
fleet_mission.add_target(EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION, target)
invasion_fleet_ids = AIstate.invasionFleetIDs
send_invasion_fleets(invasion_fleet_ids, AIstate.invasionTargets, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
for fid in FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids):
this_mission = foAI.foAIstate.get_fleet_mission(fid)
this_mission.check_mergers(context="Post-send consolidation of unassigned troops")
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
all_invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
AIstate.invasionFleetIDs = FleetUtilsAI.extract_fleet_ids_without_mission_types(all_invasion_fleet_ids)
# get suppliable planets
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = empire.empireID
capital_id = PlanetUtilsAI.get_capital()
homeworld=None
if capital_id:
homeworld = universe.getPlanet(capital_id)
if homeworld:
home_system_id = homeworld.systemID
else:
home_system_id = -1
fleet_suppliable_system_ids = empire.fleetSupplyableSystemIDs
fleet_suppliable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(fleet_suppliable_system_ids)
prime_invadable_system_ids = set(ColonisationAI.annexable_system_ids)
prime_invadable_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(prime_invadable_system_ids)
visible_system_ids = foAI.foAIstate.visInteriorSystemIDs.keys() + foAI.foAIstate. visBorderSystemIDs.keys()
if home_system_id != -1:
accessible_system_ids = [sys_id for sys_id in visible_system_ids if (sys_id != -1) and universe.systemsConnected(sys_id, home_system_id, empire_id)]
else:
print "Invasion Warning: this empire has no identifiable homeworld, will therefor treat all visible planets as accessible."
accessible_system_ids = visible_system_ids # TODO: check if any troop ships still owned, use their system as home system
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(accessible_system_ids)
print "Accessible Systems: ", ", ".join(PlanetUtilsAI.sys_name_ids(accessible_system_ids))
print
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(acessible_planet_ids) # need these for unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(acessible_planet_ids) # need this for natives
print "All Visible and accessible Populated PlanetIDs (including this empire's): ", ", ".join(PlanetUtilsAI.planet_name_ids(all_populated_planets))
print
print "Prime Invadable Target Systems: ", ", ".join(PlanetUtilsAI.sys_name_ids(prime_invadable_system_ids))
print
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
invadable_planet_ids = set(prime_invadable_planet_ids).intersection(set(all_owned_planet_ids).union(all_populated_planets) - set(empire_owned_planet_ids))
print "Prime Invadable PlanetIDs: ", ", ".join(PlanetUtilsAI.planet_name_ids(invadable_planet_ids))
print
print "Current Invasion Targeted SystemIDs: ", ", ".join(PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs))
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(universe.planetIDs, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
invasion_targeted_planet_ids.extend(get_invasion_targeted_planet_ids(universe.planetIDs, EnumsAI.AIFleetMissionType.FLEET_MISSION_ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
print "Current Invasion Targeted PlanetIDs: ", ", ".join(PlanetUtilsAI.planet_name_ids(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
if not invasion_fleet_ids:
print "Available Invasion Fleets: 0"
else:
print "Invasion FleetIDs: %s" % FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION)
num_invasion_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(invasion_fleet_ids))
print "Invasion Fleets Without Missions: %s" % num_invasion_fleets
invasion_timer.start("planning troop base production")
# only do base invasions if aggression is typical or above
reserved_troop_base_targets = []
if foAI.foAIstate.aggression > fo.aggression.typical:
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
for pid in invadable_planet_ids: # TODO: reorganize
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(pid, empire_id).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
for pid2 in ColonisationAI.empire_species_systems.get(sys_id, {}).get('pids', []):
if available_pp.get(pid2, 0) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2:
continue
if pid not in foAI.foAIstate.qualifyingTroopBaseTargets and planet2.speciesName in ColonisationAI.empire_ship_builders:
foAI.foAIstate.qualifyingTroopBaseTargets.setdefault(pid, [pid2, -1])
break
for pid in list(foAI.foAIstate.qualifyingTroopBaseTargets):
planet = universe.getPlanet(pid) # TODO: also check that still have a colony in this system that can make troops
if planet and planet.owner == empire_id:
del foAI.foAIstate.qualifyingTroopBaseTargets[pid]
secure_ai_fleet_missions = foAI.foAIstate.get_fleet_missions_with_any_mission_types([EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE])
for pid in (set(foAI.foAIstate.qualifyingTroopBaseTargets.keys()) - set(invasion_targeted_planet_ids)): # TODO: consider overriding standard invasion mission
planet = universe.getPlanet(pid)
if foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
continue # already building for here
sys_id = planet.systemID
this_sys_status = foAI.foAIstate.systemStatus.get(sys_id, {})
if (planet.currentMeterValue(fo.meterType.shield) > 0 and
this_sys_status.get('myFleetRating', 0) < 0.8 * this_sys_status.get('totalThreat', 0)):
continue
loc = foAI.foAIstate.qualifyingTroopBaseTargets[pid][0]
best_base_trooper_here = ProductionAI.getBestShipInfo(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_ORBITAL_INVASION, loc)[1]
if best_base_trooper_here == None: # shouldn't be possible at this point, but just to be safe
continue
# TODO: have TroopShipDesigner give the expected number of troops including species effects
troops_per_ship = best_base_trooper_here.troopCapacity
if not troops_per_ship:
continue
this_score, p_troops = evaluate_invasion_planet(pid, empire, secure_ai_fleet_missions, False)
best_ship, col_design, build_choices = ProductionAI.getBestShipInfo(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_ORBITAL_INVASION, loc)
if not best_ship:
continue
n_bases = math.ceil((p_troops+1) / troops_per_ship) # TODO: reconsider this +1 safety factor
print "Invasion base planning, need %d troops at %d pership, will build %d ships." % ((p_troops+1), troops_per_ship, n_bases)
retval = fo.issueEnqueueShipProductionOrder(best_ship, loc)
print "Enqueueing %d Troop Bases at %s for %s" % (n_bases, PlanetUtilsAI.planet_name_ids([loc]), PlanetUtilsAI.planet_name_ids([pid]))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
foAI.foAIstate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1, 0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(set(invadable_planet_ids) - set(invasion_targeted_planet_ids) - set(reserved_troop_base_targets))
print "Evaluating potential invasions, PlanetIDs: %s" % evaluated_planet_ids
evaluated_planets = assign_invasion_values(evaluated_planet_ids, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, fleet_suppliable_planet_ids, empire)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, pscore, ptroops in sorted_planets]
print
if sorted_planets:
print "Invadable planets:\n%-6s | %-6s | %-16s | %-16s | Troops" % ('ID', 'Score', 'Name', 'Race')
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
if planet:
print "%6d | %6d | %16s | %16s | %d" % (pid, pscore, planet.name, planet.speciesName, ptroops)
else:
print "%6d | %6d | Error: invalid planet ID" % (pid, pscore)
else:
print "No Invadable planets identified"
sorted_planets = filter(lambda x: x[1] > 0, sorted_planets)
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, _, _ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" % (len(evaluated_planet_ids)))
invasion_timer.end()
def get_colony_fleets():
"""examines known planets, collects various colonization data, to be later used to send colony fleets"""
universe = fo.getUniverse()
empire = fo.getEmpire()
colonization_timer.start("Identify Existing colony/outpost targets")
colony_targeted_planet_ids = FleetUtilsAI.get_targeted_planet_ids(universe.planetIDs, MissionType.COLONISATION)
all_colony_targeted_system_ids = PlanetUtilsAI.get_systems(colony_targeted_planet_ids)
colony_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.COLONISATION)
num_colony_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(colony_fleet_ids))
outpost_targeted_planet_ids = FleetUtilsAI.get_targeted_planet_ids(universe.planetIDs, MissionType.OUTPOST)
outpost_targeted_planet_ids.extend(
FleetUtilsAI.get_targeted_planet_ids(universe.planetIDs, MissionType.ORBITAL_OUTPOST)
)
all_outpost_targeted_system_ids = PlanetUtilsAI.get_systems(outpost_targeted_planet_ids)
outpost_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.OUTPOST)
num_outpost_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(outpost_fleet_ids))
debug("Colony Targeted SystemIDs: %s" % all_colony_targeted_system_ids)
debug("Colony Targeted PlanetIDs: %s" % colony_targeted_planet_ids)
debug(colony_fleet_ids and "Colony Fleet IDs: %s" % colony_fleet_ids or "Available Colony Fleets: 0")
debug("Colony Fleets Without Missions: %s" % num_colony_fleets)
debug("")
debug("Outpost Targeted SystemIDs: %s" % all_outpost_targeted_system_ids)
debug("Outpost Targeted PlanetIDs: %s" % outpost_targeted_planet_ids)
debug(outpost_fleet_ids and "Outpost Fleet IDs: %s" % outpost_fleet_ids or "Available Outpost Fleets: 0")
debug("Outpost Fleets Without Missions: %s" % num_outpost_fleets)
debug("")
# export targeted systems for other AI modules
AIstate.colonyTargetedSystemIDs = all_colony_targeted_system_ids
AIstate.outpostTargetedSystemIDs = all_outpost_targeted_system_ids
colonization_timer.start("Identify colony base targets")
# keys are sets of ints; data is doubles
available_pp = {tuple(el.key()): el.data() for el in empire.planetsWithAvailablePP}
avail_pp_by_sys = {}
for p_set in available_pp:
avail_pp_by_sys.update([(sys_id, available_pp[p_set]) for sys_id in set(PlanetUtilsAI.get_systems(p_set))])
evaluated_colony_planet_ids = list(
get_unowned_empty_planets().union(get_empire_outposts()) - set(colony_targeted_planet_ids)
) # places for possible colonyBase
aistate = get_aistate()
outpost_base_manager = aistate.orbital_colonization_manager
for pid in evaluated_colony_planet_ids: # TODO: reorganize
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
for pid2 in get_colonized_planets_in_system(sys_id):
planet2 = universe.getPlanet(pid2)
if not (planet2 and can_build_colony_for_species(planet2.speciesName)):
continue
if planet.unowned:
outpost_base_manager.create_new_plan(pid, pid2)
colonization_timer.start("Initiate outpost base construction")
reserved_outpost_base_targets = outpost_base_manager.get_targets()
debug("Current qualifyingOutpostBaseTargets: %s" % reserved_outpost_base_targets)
outpost_base_manager.build_bases()
colonization_timer.start("Evaluate Primary Colony Opportunities")
evaluated_outpost_planet_ids = list(
get_unowned_empty_planets()
- set(outpost_targeted_planet_ids)
- set(colony_targeted_planet_ids)
- set(reserved_outpost_base_targets)
)
evaluated_colony_planets = assign_colonisation_values(evaluated_colony_planet_ids, MissionType.COLONISATION, None)
colonization_timer.stop("Evaluate %d Primary Colony Opportunities" % (len(evaluated_colony_planet_ids)))
colonization_timer.start("Evaluate All Colony Opportunities")
_all_colony_opportunities.clear()
_all_colony_opportunities.update(
assign_colonisation_values(evaluated_colony_planet_ids, MissionType.COLONISATION, None, [], True)
)
colonization_timer.start("Evaluate Outpost Opportunities")
sorted_planets = list(evaluated_colony_planets.items())
sorted_planets.sort(key=itemgetter(1), reverse=True)
_print_colony_candidate_table(sorted_planets, show_detail=False)
sorted_planets = [(planet_id, score[:2]) for planet_id, score in sorted_planets if score[0] > 0]
# export planets for other AI modules
aistate.colonisablePlanetIDs.clear()
aistate.colonisablePlanetIDs.update(sorted_planets)
evaluated_outpost_planets = assign_colonisation_values(evaluated_outpost_planet_ids, MissionType.OUTPOST, None)
# if outposted planet would be in supply range, let outpost value be best of outpost value or colonization value
for pid in set(evaluated_outpost_planets).intersection(evaluated_colony_planets):
if get_planet_supply(pid, -99) >= 0:
evaluated_outpost_planets[pid] = (
max(evaluated_colony_planets[pid][0], evaluated_outpost_planets[pid][0]),
"",
)
colonization_timer.stop()
sorted_outposts = list(evaluated_outpost_planets.items())
sorted_outposts.sort(key=itemgetter(1), reverse=True)
_print_outpost_candidate_table(sorted_outposts)
sorted_outposts = [(planet_id, score[:2]) for planet_id, score in sorted_outposts if score[0] > 0]
# export outposts for other AI modules
aistate.colonisableOutpostIDs.clear()
aistate.colonisableOutpostIDs.update(sorted_outposts)
colonization_timer.stop_print_and_clear()
def _calculate_colonisation_priority():
"""Calculates the demand for colony ships by colonisable planets."""
global allottedColonyTargets
aistate = get_aistate()
enemies_sighted = aistate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
total_pp = fo.getEmpire().productionPoints
num_colonies = state.get_number_of_colonies()
colony_growth_barrier = aistate.character.max_number_colonies()
if num_colonies > colony_growth_barrier:
return 0.0
colony_cost = AIDependencies.COLONY_POD_COST * (
1 + AIDependencies.COLONY_POD_UPKEEP * num_colonies)
turns_to_build = 8 # TODO: check for susp anim pods, build time 10
mil_prio = aistate.get_priority(PriorityType.PRODUCTION_MILITARY)
allotted_portion = ([[[0.6, 0.8], [0.3, 0.4]],
[[0.8, 0.9],
[0.4, 0.6]]][galaxy_is_sparse][any(enemies_sighted)])
allotted_portion = aistate.character.preferred_colonization_portion(
allotted_portion)
# if ( get_aistate().get_priority(AIPriorityType.PRIORITY_PRODUCTION_COLONISATION)
# > 2 * get_aistate().get_priority(AIPriorityType.PRIORITY_PRODUCTION_MILITARY)):
# allotted_portion *= 1.5
if mil_prio < 100:
allotted_portion *= 2
elif mil_prio < 200:
allotted_portion *= 1.5
elif fo.currentTurn() > 100:
allotted_portion *= 0.75**(num_colonies / 10.0)
# allottedColonyTargets = 1+ int(fo.currentTurn()/50)
allottedColonyTargets = 1 + int(
total_pp * turns_to_build * allotted_portion / colony_cost)
outpost_prio = aistate.get_priority(PriorityType.PRODUCTION_OUTPOST)
# if have no SP_SLY, and have any outposts to build, don't build colony ships TODO: make more complex assessment
colonizers = list(ColonisationAI.empire_colonizers)
if "SP_SLY" not in colonizers and outpost_prio > 0:
return 0.0
min_score = ColonisationAI.MINIMUM_COLONY_SCORE
minimal_top = min_score + 2 # one more than the conditional floor set by ColonisationAI.revise_threat_factor()
minimal_opportunities = [
species_name
for (_, (score, species_name)) in aistate.colonisablePlanetIDs.items()
if min_score < score <= minimal_top
]
decent_opportunities = [
species_name
for (_, (score, species_name)) in aistate.colonisablePlanetIDs.items()
if score > minimal_top
]
minimal_planet_factor = 0.2 # count them for something, but not much
num_colonisable_planet_ids = len(
decent_opportunities
) + minimal_planet_factor * len(minimal_opportunities)
if num_colonisable_planet_ids == 0:
return 1
colony_ship_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
MissionType.COLONISATION)
num_colony_ships = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(colony_ship_ids))
colonisation_priority = 60 * (1.0 + num_colonisable_planet_ids -
num_colony_ships) / (
num_colonisable_planet_ids + 1)
if colonizers == ["SP_SLY"]:
colonisation_priority *= 2
elif "SP_SLY" in colonizers:
colony_opportunities = minimal_opportunities + decent_opportunities
colonisation_priority *= (1.0 + colony_opportunities.count("SP_SLY")
) / len(colony_opportunities)
# print
# print "Number of Colony Ships : " + str(num_colony_ships)
# print "Number of Colonisable planets : " + str(num_colonisable_planet_ids)
# print "Priority for colony ships : " + str(colonisation_priority)
if colonisation_priority < 1:
return 0
return colonisation_priority
def _calculate_invasion_priority():
"""Calculates the demand for troop ships by opponent planets."""
global allottedInvasionTargets
if not foAI.foAIstate.character.may_invade():
return 0
empire = fo.getEmpire()
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
multiplier = 1
num_colonies = len(list(AIstate.popCtrIDs))
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
if num_colonies > colony_growth_barrier:
return 0.0
if len(foAI.foAIstate.colonisablePlanetIDs) > 0:
best_colony_score = max(2, foAI.foAIstate.colonisablePlanetIDs.items()[0][1][0])
else:
best_colony_score = 2
allottedInvasionTargets = 1 + int(fo.currentTurn() / 25)
total_val = 0
troops_needed = 0
for pid, pscore, trp in AIstate.invasionTargets[:allottedInvasionTargets]:
if pscore > best_colony_score:
multiplier += 1
total_val += 2 * pscore
else:
total_val += pscore
troops_needed += trp + 4 # ToDo: This seems like it could be improved by some dynamic calculation of buffer
if total_val == 0:
return 0
production_queue = empire.productionQueue
queued_troop_capacity = 0
for queue_index in range(0, len(production_queue)):
element = production_queue[queue_index]
if element.buildType == EmpireProductionTypes.BT_SHIP:
if foAI.foAIstate.get_ship_role(element.designID) in [ShipRoleType.MILITARY_INVASION,
ShipRoleType.BASE_INVASION]:
design = fo.getShipDesign(element.designID)
queued_troop_capacity += element.remaining * element.blocksize * design.troopCapacity
_, best_design, _ = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if best_design:
troops_per_best_ship = best_design.troopCapacity
else:
return 1e-6 # if we can not build troop ships, we don't want to build (non-existing) invasion ships
# don't count troop bases here as these cannot be redeployed after misplaning
# troopFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)\
# + FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_INVASION)
troop_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
total_troop_capacity = sum([FleetUtilsAI.count_troops_in_fleet(fid) for fid in troop_fleet_ids])
troop_ships_needed = \
math.ceil((troops_needed - (total_troop_capacity + queued_troop_capacity)) / troops_per_best_ship)
# invasion_priority = max( 10+ 200*max(0, troop_ships_needed ) , int(0.1* total_val) )
invasion_priority = multiplier * (30 + 150*max(0, troop_ships_needed))
if not ColonisationAI.colony_status.get('colonies_under_attack', []):
if not ColonisationAI.colony_status.get('colonies_under_threat', []):
invasion_priority *= 2.0
else:
invasion_priority *= 1.5
if not enemies_sighted:
invasion_priority *= 1.5
if invasion_priority < 0:
return 0
return invasion_priority * foAI.foAIstate.character.invasion_priority_scaling()
def update_scout_fleets():
currentScoutFleetIDs[:] = []
currentScoutFleetIDs.extend( FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_EXPLORATION) )
def get_invasion_fleets():
invasion_timer.start("gathering initial info")
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
aistate = get_aistate()
visible_system_ids = list(aistate.visInteriorSystemIDs) + list(aistate.visBorderSystemIDs)
if home_system_id != INVALID_ID:
accessible_system_ids = [sys_id for sys_id in visible_system_ids if
(sys_id != INVALID_ID) and universe.systemsConnected(sys_id, home_system_id,
empire_id)]
else:
debug("Empire has no identifiable homeworld; will treat all visible planets as accessible.")
# TODO: check if any troop ships owned, use their system as home system
accessible_system_ids = visible_system_ids
acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids(accessible_system_ids)
all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids(acessible_planet_ids) # includes unpopulated outposts
all_populated_planets = PlanetUtilsAI.get_populated_planet_ids(acessible_planet_ids) # includes unowned natives
empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
invadable_planet_ids = set(all_owned_planet_ids).union(all_populated_planets) - set(empire_owned_planet_ids)
invasion_targeted_planet_ids = get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.INVASION)
invasion_targeted_planet_ids.extend(
get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.ORBITAL_INVASION))
all_invasion_targeted_system_ids = set(PlanetUtilsAI.get_systems(invasion_targeted_planet_ids))
invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
num_invasion_fleets = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(invasion_fleet_ids))
debug("Current Invasion Targeted SystemIDs: %s" % PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs))
debug("Current Invasion Targeted PlanetIDs: %s" % PlanetUtilsAI.planet_string(invasion_targeted_planet_ids))
debug(invasion_fleet_ids and "Invasion Fleet IDs: %s" % invasion_fleet_ids or "Available Invasion Fleets: 0")
debug("Invasion Fleets Without Missions: %s" % num_invasion_fleets)
invasion_timer.start("planning troop base production")
reserved_troop_base_targets = []
if aistate.character.may_invade_with_bases():
available_pp = {}
for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles
avail_pp = el.data()
for pid in el.key():
available_pp[pid] = avail_pp
# For planning base trooper invasion targets we have a two-pass system. (1) In the first pass we consider all
# the invasion targets and figure out which ones appear to be suitable for using base troopers against (i.e., we
# already have a populated planet in the same system that could build base troopers) and we have at least a
# minimal amount of PP available, and (2) in the second pass we go through the reserved base trooper target list
# and check to make sure that there does not appear to be too much military action still needed before the
# target is ready to be invaded, we double check that not too many base troopers would be needed, and if things
# look clear then we queue up the base troopers on the Production Queue and keep track of where we are building
# them, and how many; we may also disqualify and remove previously qualified targets (in case, for example,
# we lost our base trooper source planet since it was first added to list).
#
# For planning and tracking base troopers under construction, we use a dictionary store in
# get_aistate().qualifyingTroopBaseTargets, keyed by the invasion target planet ID. We only store values
# for invasion targets that appear likely to be suitable for base trooper use, and store a 2-item list.
# The first item in this list is the ID of the planet where we expect to build the base troopers, and the second
# entry initially is set to INVALID_ID (-1). The presence of this entry in qualifyingTroopBaseTargets
# flags this target as being reserved as a base-trooper invasion target.
# In the second pass, if/when we actually start construction, then we modify the record, replacing that second
# value with the ID of the planet where the troopers are actually being built. (Right now that is always the
# same as the source planet originally identified, but we could consider reevaluating that, or use that second
# value to instead record how many base troopers have been queued, so that on later turns we can assess if the
# process got delayed & perhaps more troopers need to be queued).
secure_ai_fleet_missions = aistate.get_fleet_missions_with_any_mission_types([MissionType.SECURE,
MissionType.MILITARY])
# Pass 1: identify qualifying base troop invasion targets
for pid in invadable_planet_ids: # TODO: reorganize
if pid in aistate.qualifyingTroopBaseTargets:
continue
planet = universe.getPlanet(pid)
if not planet:
continue
sys_id = planet.systemID
sys_partial_vis_turn = get_partial_visibility_turn(sys_id)
planet_partial_vis_turn = get_partial_visibility_turn(pid)
if planet_partial_vis_turn < sys_partial_vis_turn:
continue
best_base_planet = INVALID_ID
best_trooper_count = 0
for pid2 in state.get_empire_planets_by_system(sys_id, include_outposts=False):
if available_pp.get(pid2, 0) < 2: # TODO: improve troop base PP sufficiency determination
break
planet2 = universe.getPlanet(pid2)
if not planet2 or planet2.speciesName not in ColonisationAI.empire_ship_builders:
continue
best_base_trooper_here = \
ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION, pid2)[1]
if not best_base_trooper_here:
continue
troops_per_ship = best_base_trooper_here.troopCapacity
if not troops_per_ship:
continue
species_troop_grade = CombatRatingsAI.get_species_troops_grade(planet2.speciesName)
troops_per_ship = CombatRatingsAI.weight_attack_troops(troops_per_ship, species_troop_grade)
if troops_per_ship > best_trooper_count:
best_base_planet = pid2
best_trooper_count = troops_per_ship
if best_base_planet != INVALID_ID:
aistate.qualifyingTroopBaseTargets.setdefault(pid, [best_base_planet, INVALID_ID])
# Pass 2: for each target previously identified for base troopers, check that still qualifies and
# check how many base troopers would be needed; if reasonable then queue up the troops and record this in
# get_aistate().qualifyingTroopBaseTargets
for pid in aistate.qualifyingTroopBaseTargets.keys():
planet = universe.getPlanet(pid)
if planet and planet.owner == empire_id:
del aistate.qualifyingTroopBaseTargets[pid]
continue
if pid in invasion_targeted_planet_ids: # TODO: consider overriding standard invasion mission
continue
if aistate.qualifyingTroopBaseTargets[pid][1] != -1:
reserved_troop_base_targets.append(pid)
if planet:
all_invasion_targeted_system_ids.add(planet.systemID)
# TODO: evaluate changes to situation, any more troops needed, etc.
continue # already building for here
_, planet_troops = evaluate_invasion_planet(pid, secure_ai_fleet_missions, True)
sys_id = planet.systemID
this_sys_status = aistate.systemStatus.get(sys_id, {})
troop_tally = 0
for _fid in this_sys_status.get('myfleets', []):
troop_tally += FleetUtilsAI.count_troops_in_fleet(_fid)
if troop_tally > planet_troops: # base troopers appear unneeded
del aistate.qualifyingTroopBaseTargets[pid]
continue
if (planet.currentMeterValue(fo.meterType.shield) > 0 and
(this_sys_status.get('myFleetRating', 0) < 0.8 * this_sys_status.get('totalThreat', 0) or
this_sys_status.get('myFleetRatingVsPlanets', 0) < this_sys_status.get('planetThreat', 0))):
# this system not secured, so ruling out invasion base troops for now
# don't immediately delete from qualifyingTroopBaseTargets or it will be opened up for regular troops
continue
loc = aistate.qualifyingTroopBaseTargets[pid][0]
best_base_trooper_here = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION, loc)[1]
loc_planet = universe.getPlanet(loc)
if best_base_trooper_here is None: # shouldn't be possible at this point, but just to be safe
warn("Could not find a suitable orbital invasion design at %s" % loc_planet)
continue
# TODO: have TroopShipDesigner give the expected number of troops including species effects directly
troops_per_ship = best_base_trooper_here.troopCapacity
species_troop_grade = CombatRatingsAI.get_species_troops_grade(loc_planet.speciesName)
troops_per_ship = CombatRatingsAI.weight_attack_troops(troops_per_ship, species_troop_grade)
if not troops_per_ship:
warn("The best orbital invasion design at %s seems not to have any troop capacity." % loc_planet)
continue
_, col_design, build_choices = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_ORBITAL_INVASION,
loc)
if not col_design:
continue
if loc not in build_choices:
warn('Best troop design %s can not be produced at planet with id: %s\d' % (col_design, build_choices))
continue
n_bases = math.ceil((planet_troops + 1) / troops_per_ship) # TODO: reconsider this +1 safety factor
# TODO: evaluate cost and time-to-build of best base trooper here versus cost and time-to-build-and-travel
# for best regular trooper elsewhere
# For now, we assume what building base troopers is best so long as either (1) we would need no more than
# MAX_BASE_TROOPERS_POOR_INVADERS base troop ships, or (2) our base troopers have more than 1 trooper per
# ship and we would need no more than MAX_BASE_TROOPERS_GOOD_INVADERS base troop ships
if (n_bases > MAX_BASE_TROOPERS_POOR_INVADERS or
(troops_per_ship > 1 and n_bases > MAX_BASE_TROOPERS_GOOD_INVADERS)):
debug("ruling out base invasion troopers for %s due to high number (%d) required." % (planet, n_bases))
del aistate.qualifyingTroopBaseTargets[pid]
continue
debug("Invasion base planning, need %d troops at %d per ship, will build %d ships." % (
(planet_troops + 1), troops_per_ship, n_bases))
retval = fo.issueEnqueueShipProductionOrder(col_design.id, loc)
debug("Enqueueing %d Troop Bases at %s for %s" % (n_bases, PlanetUtilsAI.planet_string(loc),
PlanetUtilsAI.planet_string(pid)))
if retval != 0:
all_invasion_targeted_system_ids.add(planet.systemID)
reserved_troop_base_targets.append(pid)
aistate.qualifyingTroopBaseTargets[pid][1] = loc
fo.issueChangeProductionQuantityOrder(empire.productionQueue.size - 1, 1, int(n_bases))
fo.issueRequeueProductionOrder(empire.productionQueue.size - 1, 0)
invasion_timer.start("evaluating target planets")
# TODO: check if any invasion_targeted_planet_ids need more troops assigned
evaluated_planet_ids = list(
set(invadable_planet_ids) - set(invasion_targeted_planet_ids) - set(reserved_troop_base_targets))
evaluated_planets = assign_invasion_values(evaluated_planet_ids)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, (pscore, ptroops) in evaluated_planets.items()]
sorted_planets.sort(key=lambda x: x[1], reverse=True)
sorted_planets = [(pid, pscore % 10000, ptroops) for pid, pscore, ptroops in sorted_planets]
invasion_table = Table([Text('Planet'), Float('Score'), Text('Species'), Float('Troops')],
table_name="Potential Targets for Invasion Turn %d" % fo.currentTurn())
for pid, pscore, ptroops in sorted_planets:
planet = universe.getPlanet(pid)
invasion_table.add_row([
planet,
pscore,
planet and planet.speciesName or "unknown",
ptroops
])
info(invasion_table)
sorted_planets = filter(lambda x: x[1] > 0, sorted_planets)
# export opponent planets for other AI modules
AIstate.opponentPlanetIDs = [pid for pid, __, __ in sorted_planets]
AIstate.invasionTargets = sorted_planets
# export invasion targeted systems for other AI modules
AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids)
invasion_timer.stop(section_name="evaluating %d target planets" % (len(evaluated_planet_ids)))
invasion_timer.stop_print_and_clear()
def get_military_fleets(mil_fleets_ids=None, try_reset=True, thisround="Main"):
"""Get armed military fleets."""
global _military_allocations
universe = fo.getUniverse()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
all_military_fleet_ids = (mil_fleets_ids if mil_fleets_ids is not None
else FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
if try_reset and (fo.currentTurn() + empire_id) % 30 == 0 and thisround == "Main":
try_again(all_military_fleet_ids, try_reset=False, thisround=thisround + " Reset")
return
mil_fleets_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, mil_fleets_ids = avail_mil_needing_repair(mil_fleets_ids, split_ships=True)
avail_mil_rating = sum(map(CombatRatingsAI.get_fleet_rating, mil_fleets_ids))
if not mil_fleets_ids:
if "Main" in thisround:
_military_allocations = []
return []
# for each system, get total rating of fleets assigned to it
already_assigned_rating = {}
already_assigned_rating_vs_planets = {}
systems_status = foAI.foAIstate.systemStatus
enemy_sup_factor = {} # enemy supply
for sys_id in universe.systemIDs:
already_assigned_rating[sys_id] = 0
already_assigned_rating_vs_planets[sys_id] = 0
enemy_sup_factor[sys_id] = min(2, len(systems_status.get(sys_id, {}).get('enemies_nearly_supplied', [])))
for fleet_id in [fid for fid in all_military_fleet_ids if fid not in mil_fleets_ids]:
ai_fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
if not ai_fleet_mission.target: # shouldn't really be possible
continue
last_sys = ai_fleet_mission.target.get_system().id # will count this fleet as assigned to last system in target list # TODO last_sys or target sys?
this_rating = CombatRatingsAI.get_fleet_rating(fleet_id)
this_rating_vs_planets = CombatRatingsAI.get_fleet_rating_against_planets(fleet_id)
already_assigned_rating[last_sys] = CombatRatingsAI.combine_ratings(
already_assigned_rating.get(last_sys, 0), this_rating)
already_assigned_rating_vs_planets[last_sys] = CombatRatingsAI.combine_ratings(
already_assigned_rating_vs_planets.get(last_sys, 0), this_rating_vs_planets)
for sys_id in universe.systemIDs:
my_defense_rating = systems_status.get(sys_id, {}).get('mydefenses', {}).get('overall', 0)
already_assigned_rating[sys_id] = CombatRatingsAI.combine_ratings(my_defense_rating, already_assigned_rating[sys_id])
if _verbose_mil_reporting and already_assigned_rating[sys_id]:
print "\t System %s already assigned rating %.1f" % (
universe.getSystem(sys_id), already_assigned_rating[sys_id])
# get systems to defend
capital_id = PlanetUtilsAI.get_capital()
if capital_id is not None:
capital_planet = universe.getPlanet(capital_id)
else:
capital_planet = None
# TODO: if no owned planets try to capture one!
if capital_planet:
capital_sys_id = capital_planet.systemID
else: # should be rare, but so as to not break code below, pick a randomish mil-centroid system
capital_sys_id = None # unless we can find one to use
system_dict = {}
for fleet_id in all_military_fleet_ids:
status = foAI.foAIstate.fleetStatus.get(fleet_id, None)
if status is not None:
system_id = status['sysID']
if not list(universe.getSystem(system_id).planetIDs):
continue
system_dict[system_id] = system_dict.get(system_id, 0) + status.get('rating', 0)
ranked_systems = sorted([(val, sys_id) for sys_id, val in system_dict.items()])
if ranked_systems:
capital_sys_id = ranked_systems[-1][-1]
else:
try:
capital_sys_id = foAI.foAIstate.fleetStatus.items()[0][1]['sysID']
except:
pass
num_targets = max(10, PriorityAI.allotted_outpost_targets)
top_target_planets = ([pid for pid, pscore, trp in AIstate.invasionTargets[:PriorityAI.allotted_invasion_targets()]
if pscore > MIN_INVASION_SCORE] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisableOutpostIDs.items()[:num_targets]
if pscore > MIN_INVASION_SCORE] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisablePlanetIDs.items()[:num_targets]
if pscore > MIN_INVASION_SCORE])
top_target_planets.extend(foAI.foAIstate.qualifyingTroopBaseTargets.keys())
base_col_target_systems = PlanetUtilsAI.get_systems(top_target_planets)
top_target_systems = []
for sys_id in AIstate.invasionTargetedSystemIDs + base_col_target_systems:
if sys_id not in top_target_systems:
if foAI.foAIstate.systemStatus[sys_id]['totalThreat'] > get_tot_mil_rating():
continue
top_target_systems.append(sys_id) # doing this rather than set, to preserve order
try:
# capital defense
allocation_helper = AllocationHelper(already_assigned_rating, already_assigned_rating_vs_planets, avail_mil_rating, try_reset)
if capital_sys_id is not None:
CapitalDefenseAllocator(capital_sys_id, allocation_helper).allocate()
# defend other planets
empire_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
empire_occupied_system_ids = list(set(PlanetUtilsAI.get_systems(empire_planet_ids)) - {capital_sys_id})
for sys_id in empire_occupied_system_ids:
PlanetDefenseAllocator(sys_id, allocation_helper).allocate()
# attack / protect high priority targets
for sys_id in top_target_systems:
TopTargetAllocator(sys_id, allocation_helper).allocate()
# enemy planets
other_targeted_system_ids = [sys_id for sys_id in set(PlanetUtilsAI.get_systems(AIstate.opponentPlanetIDs)) if
sys_id not in top_target_systems]
for sys_id in other_targeted_system_ids:
TargetAllocator(sys_id, allocation_helper).allocate()
# colony / outpost targets
other_targeted_system_ids = [sys_id for sys_id in
list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs)) if
sys_id not in top_target_systems]
for sys_id in other_targeted_system_ids:
OutpostTargetAllocator(sys_id, allocation_helper).allocate()
# TODO blockade enemy systems
# interior systems
targetable_ids = set(state.get_systems_by_supply_tier(0))
current_mil_systems = [sid for sid, _, _, _, _ in allocation_helper.allocations]
interior_targets1 = targetable_ids.difference(current_mil_systems)
interior_targets = [sid for sid in interior_targets1 if (
allocation_helper.threat_bias + systems_status.get(sid, {}).get('totalThreat', 0) > 0.8 * allocation_helper.already_assigned_rating[sid])]
for sys_id in interior_targets:
InteriorTargetsAllocator(sys_id, allocation_helper).allocate()
# TODO Exploration targets
# border protections
visible_system_ids = foAI.foAIstate.visInteriorSystemIDs | foAI.foAIstate.visBorderSystemIDs
accessible_system_ids = ([sys_id for sys_id in visible_system_ids if
universe.systemsConnected(sys_id, home_system_id, empire_id)]
if home_system_id != INVALID_ID else [])
current_mil_systems = [sid for sid, alloc, rvp, take_any, _ in allocation_helper.allocations if alloc > 0]
border_targets1 = [sid for sid in accessible_system_ids if sid not in current_mil_systems]
border_targets = [sid for sid in border_targets1 if (
allocation_helper.threat_bias + systems_status.get(sid, {}).get('fleetThreat', 0) + systems_status.get(sid, {}).get(
'planetThreat', 0) > 0.8 * allocation_helper.already_assigned_rating[sid])]
for sys_id in border_targets:
BorderSecurityAllocator(sys_id, allocation_helper).allocate()
except ReleaseMilitaryException:
try_again(all_military_fleet_ids)
return
new_allocations = []
remaining_mil_rating = avail_mil_rating
# for top categories assign max_alloc right away as available
for cat in ['capitol', 'occupied', 'topTargets']:
for sid, alloc, rvp, take_any, max_alloc in allocation_helper.allocation_by_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
this_alloc = min(remaining_mil_rating, max_alloc)
new_allocations.append((sid, this_alloc, alloc, rvp, take_any))
remaining_mil_rating -= this_alloc
base_allocs = set()
# for lower priority categories, first assign base_alloc around to all, then top up as available
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, rvp, take_any, max_alloc in allocation_helper.allocation_by_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
base_allocs.add(sid)
remaining_mil_rating -= alloc
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, rvp, take_any, max_alloc in allocation_helper.allocation_by_groups.get(cat, []):
if sid not in base_allocs:
break
if remaining_mil_rating <= 0:
new_allocations.append((sid, alloc, alloc, rvp, take_any))
else:
new_rating = min(remaining_mil_rating + alloc, max_alloc)
new_allocations.append((sid, new_rating, alloc, rvp, take_any))
remaining_mil_rating -= (new_rating - alloc)
if "Main" in thisround:
_military_allocations = new_allocations
if _verbose_mil_reporting or "Main" in thisround:
print "------------------------------\nFinal %s Round Military Allocations: %s \n-----------------------" % (thisround, dict([(sid, alloc) for sid, alloc, _, _, _ in new_allocations]))
print "(Apparently) remaining military rating: %.1f" % remaining_mil_rating
return new_allocations
def get_military_fleets(mil_fleets_ids=None, try_reset=True, thisround="Main"):
"""Get armed military fleets."""
global military_allocations, totMilRating, num_milships
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = empire.empireID
capital_id = PlanetUtilsAI.get_capital()
if capital_id is None:
homeworld = None
else:
homeworld = universe.getPlanet(capital_id)
if homeworld:
home_system_id = homeworld.systemID
else:
home_system_id = -1
if mil_fleets_ids is not None:
all_military_fleet_ids = mil_fleets_ids
else:
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if try_reset and (fo.currentTurn() + empire_id) % 30 == 0 and thisround == "Main":
try_again(all_military_fleet_ids, try_reset=False, thisround=thisround + " Reset")
num_milships = 0
for fid in all_military_fleet_ids:
num_milships += foAI.foAIstate.fleetStatus.get(fid, {}).get('nships', 0)
enemy_rating = foAI.foAIstate.empire_standard_enemy_rating
mil_fleets_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, mil_fleets_ids = avail_mil_needing_repair(mil_fleets_ids, split_ships=True)
avail_mil_rating = sum(map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), mil_fleets_ids))
if "Main" in thisround:
print "=================================================="
print "%s Round Available Military Rating: %d" % (thisround, avail_mil_rating)
print "---------------------------------"
remaining_mil_rating = avail_mil_rating
allocations = []
allocation_groups = {}
if not mil_fleets_ids:
if "Main" in thisround:
military_allocations = []
return []
# for each system, get total rating of fleets assigned to it
already_assigned_rating = {}
assigned_attack = {}
assigned_hp = {}
systems_status = foAI.foAIstate.systemStatus
enemy_sup_factor = {} # enemy supply
for sys_id in universe.systemIDs:
assigned_attack[sys_id] = 0
assigned_hp[sys_id] = 0
enemy_sup_factor[sys_id] = min(2, len(systems_status.get(sys_id, {}).get('enemies_nearly_supplied', [])))
for fleet_id in [fid for fid in all_military_fleet_ids if fid not in mil_fleets_ids]:
ai_fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
if not ai_fleet_mission.target: # shouldn't really be possible
continue
last_sys = ai_fleet_mission.target.get_system().id # will count this fleet as assigned to last system in target list
assigned_attack[last_sys] += foAI.foAIstate.get_rating(fleet_id).get('attack', 0)
assigned_hp[last_sys] += foAI.foAIstate.get_rating(fleet_id).get('health', 0)
for sys_id in universe.systemIDs:
mydefenses = systems_status.get(sys_id, {}).get('mydefenses', {})
mypattack = mydefenses.get('attack', 0)
myphealth = mydefenses.get('health', 0)
already_assigned_rating[sys_id] = (assigned_attack[sys_id] + mypattack) * (assigned_hp[sys_id] + myphealth)
if verbose_mil_reporting and already_assigned_rating[sys_id]:
print "\t System %s already assigned rating %.1f" % (
universe.getSystem(sys_id), already_assigned_rating[sys_id])
# get systems to defend
capital_id = PlanetUtilsAI.get_capital()
if capital_id is not None:
capital_planet = universe.getPlanet(capital_id)
else:
capital_planet = None
# TODO: if no owned planets try to capture one!
if capital_planet:
capital_sys_id = capital_planet.systemID
else: # should be rare, but so as to not break code below, pick a randomish mil-centroid system
capital_sys_id = None # unless we can find one to use
system_dict = {}
for fleet_id in all_military_fleet_ids:
status = foAI.foAIstate.fleetStatus.get(fleet_id, None)
if status is not None:
sys_id = status['sysID']
if not list(universe.getSystem(sys_id).planetIDs):
continue
system_dict[sys_id] = system_dict.get(sys_id, 0) + status.get('rating', {}).get('overall', 0)
ranked_systems = sorted([(val, sys_id) for sys_id, val in system_dict.items()])
if ranked_systems:
capital_sys_id = ranked_systems[-1][-1]
else:
try:
capital_sys_id = foAI.foAIstate.fleetStatus.items()[0][1]['sysID']
except:
pass
if False:
if fo.currentTurn() < 20:
threat_bias = 0
elif fo.currentTurn() < 40:
threat_bias = 10
elif fo.currentTurn() < 60:
threat_bias = 80
elif fo.currentTurn() < 80:
threat_bias = 200
else:
threat_bias = 400
else:
threat_bias = 0
safety_factor = get_safety_factor()
num_targets = max(10, PriorityAI.allotted_outpost_targets)
top_target_planets = ([pid for pid, pscore, trp in AIstate.invasionTargets[:PriorityAI.allottedInvasionTargets] if pscore > 20] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisableOutpostIDs.items()[:num_targets] if pscore > 20] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisablePlanetIDs.items()[:num_targets] if pscore > 20])
top_target_planets.extend(foAI.foAIstate.qualifyingTroopBaseTargets.keys())
base_col_target_systems = PlanetUtilsAI.get_systems(top_target_planets)
top_target_systems = []
for sys_id in AIstate.invasionTargetedSystemIDs + base_col_target_systems:
if sys_id not in top_target_systems:
if foAI.foAIstate.systemStatus[sys_id]['totalThreat'] > totMilRating:
continue
top_target_systems.append(sys_id) # doing this rather than set, to preserve order
if verbose_mil_reporting:
print "----------------------------"
# allocation format: ( sysID, newAllocation, takeAny, maxMultiplier )
# ================================
# --------Capital Threat ----------
if capital_sys_id is not None:
capital_sys_status = systems_status[capital_sys_id]
capital_threat = safety_factor*(2 * threat_bias + combine_ratings_list([capital_sys_status[thrt_key] for thrt_key in ['totalThreat', 'neighborThreat']]))
capital_threat += max(0, enemy_sup_factor[sys_id]*enemy_rating - capital_sys_status.get('my_neighbor_rating', 0))
local_support = combine_ratings(already_assigned_rating[capital_sys_id], capital_sys_status['my_neighbor_rating'])
base_needed_rating = rating_needed(capital_sys_status['regional_threat'], local_support)
needed_rating = max(base_needed_rating, rating_needed(1.4 * capital_threat, already_assigned_rating[capital_sys_id]))
max_alloc = max(rating_needed(1.5 * capital_sys_status['regional_threat'], already_assigned_rating[capital_sys_id]),
rating_needed(2 * capital_threat, already_assigned_rating[capital_sys_id]))
new_alloc = 0
if try_reset:
if needed_rating > 0.5*avail_mil_rating:
try_again(all_military_fleet_ids)
return
if needed_rating > 0:
new_alloc = min(remaining_mil_rating, needed_rating)
allocations.append((capital_sys_id, new_alloc, True, max_alloc))
allocation_groups.setdefault('capitol', []).append((capital_sys_id, new_alloc, True, max_alloc))
if verbose_mil_reporting:
report_format = ("\tAt Capital system %s, local threat %.1f, regional threat %.1f, local support %.1f, "
"base_needed_rating %.1f, needed_rating %.1f, new allocation %.1f")
print report_format % (universe.getSystem(capital_sys_id), capital_threat,
capital_sys_status['regional_threat'], local_support,
base_needed_rating, needed_rating, new_alloc)
remaining_mil_rating -= new_alloc
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "Empire Capital System: (%d) %s -- threat : %d, military allocation: existing: %d ; new: %d" % (capital_sys_id, universe.getSystem(capital_sys_id).name, capital_threat, already_assigned_rating[capital_sys_id], new_alloc)
print "-----------------"
# ================================
# --------Empire Occupied Systems ----------
empire_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
empire_occupied_system_ids = list(set(PlanetUtilsAI.get_systems(empire_planet_ids)) - {capital_sys_id})
if "Main" in thisround:
if verbose_mil_reporting:
print "Empire-Occupied Systems: %s" % (["| %d %s |" % (eo_sys_id, universe.getSystem(eo_sys_id).name) for eo_sys_id in empire_occupied_system_ids])
print "-----------------"
new_alloc = 0
if empire_occupied_system_ids:
oc_sys_tot_threat_v1 = [(o_s_id, threat_bias + safety_factor*combine_ratings_list(
[systems_status.get(o_s_id, {}).get(thrt_key, 0) for thrt_key in ['totalThreat', 'neighborThreat']]))
for o_s_id in empire_occupied_system_ids]
tot_oc_sys_threat = sum([thrt for _, thrt in oc_sys_tot_threat_v1])
tot_cur_alloc = sum([already_assigned_rating[sid] for sid, _ in oc_sys_tot_threat_v1])
# intentionally after tallies, but perhaps should be before
oc_sys_tot_threat = []
threat_details = {}
for sys_id, sys_threat in oc_sys_tot_threat_v1:
j2_threat = systems_status.get(sys_id, {}).get('jump2_threat', 0)
local_defenses = combine_ratings_list([systems_status.get(sys_id, {}).get('my_neighbor_rating', 0),
already_assigned_rating[sys_id]])
threat_details[sys_id] = (sys_threat, enemy_sup_factor[sys_id] * 0.5 * enemy_rating,
j2_threat, local_defenses)
oc_sys_tot_threat.append((sys_id, sys_threat + max(0,
enemy_sup_factor[sys_id] * 0.5 * enemy_rating +
j2_threat - local_defenses
)))
oc_sys_alloc = 0
for sid, thrt in oc_sys_tot_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.3 * thrt, cur_alloc)
max_alloc = rating_needed(2*thrt, cur_alloc)
if (needed_rating > 0.8 * remaining_mil_rating) and try_reset:
try_again(all_military_fleet_ids)
return
this_alloc = 0
if needed_rating > 0 and remaining_mil_rating > 0:
this_alloc = max(0, min(needed_rating, 0.5 * avail_mil_rating, remaining_mil_rating))
new_alloc += this_alloc
allocations.append((sid, this_alloc, True, max_alloc))
allocation_groups.setdefault('occupied', []).append((sid, this_alloc, True, max_alloc))
remaining_mil_rating -= this_alloc
oc_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Provincial Occupied system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
print "\t base threat was %.1f, supply_threat %.1f, jump2_threat %.1f, and local defenses %.1f" % (
threat_details[sid])
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "Provincial Empire-Occupied Sytems under total threat: %d -- total mil allocation: existing %d ; new: %d" % (tot_oc_sys_threat, tot_cur_alloc, oc_sys_alloc)
print "-----------------"
# ================================
# --------Top Targeted Systems ----------
# TODO: do native invasions highest priority
other_targeted_system_ids = top_target_systems
if "Main" in thisround:
if verbose_mil_reporting:
print "Top Colony and Invasion Targeted Systems : %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in other_targeted_system_ids])
print "-----------------"
new_alloc = 0
if other_targeted_system_ids:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, threat_bias + safety_factor * combine_ratings_list([
systems_status.get(o_s_id, {}).get('totalThreat', 0),
0.75 * systems_status.get(o_s_id, {}).get('neighborThreat', 0),
0.5 * systems_status.get(o_s_id, {}).get('jump2_threat', 0)]))
for o_s_id in other_targeted_system_ids]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
tot_cur_alloc = sum([already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
# intentionally after tallies, but perhaps should be before
ot_sys_threat = [(sys_id, sys_threat + enemy_sup_factor[sys_id] * 0.5 * enemy_rating) for sys_id, sys_threat in ot_sys_threat]
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.4*thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = already_assigned_rating[sid] > 0
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
max_alloc = rating_needed(3 * thrt, cur_alloc)
new_alloc += this_alloc
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('topTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Top Colony and Invasion Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
# ================================
# --------Targeted Systems ----------
# TODO: do native invasions highest priority
other_targeted_system_ids = [sys_id for sys_id in set(PlanetUtilsAI.get_systems(AIstate.opponentPlanetIDs)) if sys_id not in top_target_systems]
if "Main" in thisround:
if verbose_mil_reporting:
print "Other Invasion Targeted Systems : %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in other_targeted_system_ids])
print "-----------------"
# for these, calc local threat only, no neighbor threat, but use a multiplier for fleet safety
new_alloc = 0
if other_targeted_system_ids:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, threat_bias + safety_factor*combine_ratings_list([
systems_status.get(o_s_id, {}).get('totalThreat', 0),
0.75*systems_status.get(o_s_id, {}).get('neighborThreat', 0),
0.5*systems_status.get(o_s_id, {}).get('jump2_threat', 0)]))
for o_s_id in other_targeted_system_ids]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
tot_cur_alloc = sum([already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
# intentionally after tallies, but perhaps should be before
ot_sys_threat = [(sys_id, sys_threat + enemy_sup_factor[sys_id] * 0.5 * enemy_rating) for sys_id, sys_threat in ot_sys_threat]
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.4 * thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = already_assigned_rating[sid] > 0
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
new_alloc += this_alloc
max_alloc = rating_needed(2 * thrt, cur_alloc)
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('otherTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Invasion Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
other_targeted_system_ids = [sys_id for sys_id in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs)) if sys_id not in top_target_systems]
if "Main" in thisround:
if verbose_mil_reporting:
print "Other Targeted Systems : %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in other_targeted_system_ids])
print "-----------------"
if other_targeted_system_ids:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, threat_bias + safety_factor*combine_ratings_list([
systems_status.get(o_s_id, {}).get('totalThreat', 0),
0.75*systems_status.get(o_s_id, {}).get('neighborThreat', 0),
0.5*systems_status.get(o_s_id, {}).get('jump2_threat', 0)]))
for o_s_id in other_targeted_system_ids]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
# intentionally after tallies, but perhaps should be before
ot_sys_threat = [(sys_id, sys_threat + enemy_sup_factor[sys_id] * 0.5 * enemy_rating) for sys_id, sys_threat in ot_sys_threat]
tot_cur_alloc = sum([already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
new_alloc = 0
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.4 * thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = already_assigned_rating[sid] > 0
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
new_alloc += this_alloc
max_alloc = rating_needed(3*thrt, cur_alloc)
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('otherTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Other Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
other_targeted_system_ids = []
# targetable_ids = ColonisationAI.annexableSystemIDs.union(empire.fleetSupplyableSystemIDs)
targetable_ids = set(ColonisationAI.systems_by_supply_tier.get(0, []) + ColonisationAI.systems_by_supply_tier.get(1, []))
for sys_id in AIstate.opponentSystemIDs:
if sys_id in targetable_ids:
other_targeted_system_ids.append(sys_id)
else:
for nID in universe.getImmediateNeighbors(sys_id, empire_id):
if nID in targetable_ids:
other_targeted_system_ids.append(sys_id)
break
if "Main" in thisround:
if verbose_mil_reporting:
print "Blockade Targeted Systems : %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in other_targeted_system_ids])
print "-----------------"
if other_targeted_system_ids:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, threat_bias + safety_factor*combine_ratings_list([
systems_status.get(o_s_id, {}).get('totalThreat', 0),
0.75*systems_status.get(o_s_id, {}).get('neighborThreat', 0),
0.5*systems_status.get(o_s_id, {}).get('jump2_threat', 0)]))
for o_s_id in other_targeted_system_ids]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
tot_cur_alloc = sum([already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
# intentionally after tallies, but perhaps should be before
# this supply threat calc intentionally uses a lower multiplier 0.25
ot_sys_threat = [(sys_id, sys_threat + enemy_sup_factor[sys_id] * 0.25 * enemy_rating) for sys_id, sys_threat in ot_sys_threat]
new_alloc = 0
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.4*thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = already_assigned_rating[sid] > 0
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
new_alloc += this_alloc
max_alloc = 1.5 * this_alloc
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('otherTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Blockade Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Blockade Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
current_mil_systems = [sid for sid, alloc, take_any, mm in allocations]
interior_targets1 = targetable_ids.difference(current_mil_systems)
interior_targets = [sid for sid in interior_targets1 if (
threat_bias + systems_status.get(sid, {}).get('totalThreat', 0) > 0.8 * already_assigned_rating[sid])]
if "Main" in thisround:
if verbose_mil_reporting:
print
print "Other Empire-Proximal Systems : %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in interior_targets1])
print "-----------------"
# for these, calc local threat only, no neighbor threat, but use a multiplier for fleet safety
new_alloc = 0
if interior_targets:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, threat_bias + safety_factor*(systems_status.get(o_s_id, {}).get('totalThreat', 0))) for o_s_id in interior_targets]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
tot_cur_alloc = sum([already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
# do not add enemy supply threat here
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.5 * thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = already_assigned_rating[sid] > 0
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
new_alloc += this_alloc
max_alloc = 3 * this_alloc
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('otherTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Other interior system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Other Interior Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
elif "Main" in thisround:
if verbose_mil_reporting:
print "-----------------"
print "No Other Interior Systems with fleet threat "
print "-----------------"
monster_dens = []
# explo_target_ids, _ = ExplorationAI.get_current_exploration_info(verbose=False)
explo_target_ids = []
if "Main" in thisround:
if verbose_mil_reporting:
print
print "Exploration-targeted Systems: %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in explo_target_ids])
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
new_alloc = 0
if explo_target_ids:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, safety_factor*combine_ratings(systems_status.get(o_s_id, {}).get('fleetThreat', 0), systems_status.get(o_s_id, {}).get('monsterThreat', 0) + systems_status.get(o_s_id, {}).get('planetThreat', 0))) for o_s_id in explo_target_ids]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
tot_cur_alloc = sum([0.8*already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
# intentionally after tallies, but perhaps should be before
# this supply threat calc intentionally uses a lower multiplier 0.25
ot_sys_threat = [(sys_id, sys_threat + enemy_sup_factor[sys_id] * 0.25 * enemy_rating) for sys_id, sys_threat in ot_sys_threat]
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.4 * thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = False
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
new_alloc += this_alloc
max_alloc = 2 * this_alloc
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('exploreTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Exploration-targeted %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Exploration-targeted s under total threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
visible_system_ids = foAI.foAIstate.visInteriorSystemIDs.keys() + foAI.foAIstate. visBorderSystemIDs.keys()
accessible_system_ids = [sys_id for sys_id in visible_system_ids if universe.systemsConnected(sys_id, home_system_id, empire_id)]
current_mil_systems = [sid for sid, alloc, take_any, multiplier in allocations if alloc > 0]
border_targets1 = [sid for sid in accessible_system_ids if sid not in current_mil_systems]
border_targets = [sid for sid in border_targets1 if (threat_bias + systems_status.get(sid, {}).get('fleetThreat', 0) + systems_status.get(sid, {}).get('planetThreat', 0) > 0.8*already_assigned_rating[sid])]
if "Main" in thisround:
if verbose_mil_reporting:
print
print "Empire-Accessible Systems not yet allocated military: %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id) and universe.getSystem(sys_id).name) for sys_id in border_targets1])
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
new_alloc = 0
if border_targets:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, threat_bias + safety_factor*combine_ratings(systems_status.get(o_s_id, {}).get('fleetThreat', 0), systems_status.get(o_s_id, {}).get('monsterThreat', 0) + systems_status.get(o_s_id, {}).get('planetThreat', 0))) for o_s_id in border_targets]
totot_sys_threat = sum([thrt for sid, thrt in ot_sys_threat])
tot_cur_alloc = sum([0.8*already_assigned_rating[sid] for sid, thrt in ot_sys_threat])
# do not add enemy supply threat here
for sid, thrt in ot_sys_threat:
cur_alloc = already_assigned_rating[sid]
needed_rating = rating_needed(1.2 * thrt, cur_alloc)
this_alloc = 0
# only record more allocation for this invasion if we already started or have enough rating available
take_any = False
if needed_rating > 0 and (remaining_mil_rating > needed_rating or take_any):
this_alloc = max(0, min(needed_rating, remaining_mil_rating))
new_alloc += this_alloc
max_alloc = safety_factor*2*max(systems_status.get(sid, {}).get('totalThreat', 0), systems_status.get(sid, {}).get('neighborThreat', 0))
allocations.append((sid, this_alloc, take_any, max_alloc))
allocation_groups.setdefault('accessibleTargets', []).append((sid, this_alloc, take_any, max_alloc))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Other Empire-Accessible system %4d ( %10s ) has local biased threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
print "Other Empire-Accessible Systems under total biased threat: %d -- total mil allocation-- existing: %d ; new: %d" % (totot_sys_threat, tot_cur_alloc, ot_sys_alloc)
print "-----------------"
elif "Main" in thisround:
if verbose_mil_reporting:
print "-----------------"
print "No Other Empire-Accessible Systems with biased local threat "
print "-----------------"
# monster den treatment probably unnecessary now
if "Main" in thisround:
if verbose_mil_reporting:
print
print "Big-Monster Dens: %s" % (["| %d %s |" % (sys_id, universe.getSystem(sys_id).name) for sys_id in monster_dens])
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
new_alloc = 0
if monster_dens:
ot_sys_alloc = 0
ot_sys_threat = [(o_s_id, safety_factor * combine_ratings_list([systems_status.get(o_s_id, {}).get('fleetThreat', 0), systems_status.get(o_s_id, {}).get('monsterThreat', 0), systems_status.get(o_s_id, {}).get('planetThreat', 0)])) for o_s_id in monster_dens]
for sid, thrt in ot_sys_threat:
cur_alloc = 0.8 * already_assigned_rating[sid]
this_alloc = 0
if (thrt > cur_alloc) and remaining_mil_rating > 2 * thrt:
this_alloc = int(0.99999 + (thrt - cur_alloc) * 1.5)
new_alloc += this_alloc
allocations.append((sid, this_alloc, False, 5))
remaining_mil_rating -= this_alloc
ot_sys_alloc += this_alloc
if "Main" in thisround or this_alloc > 0:
if verbose_mil_reporting:
print "Monster Den %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d" % (sid, universe.getSystem(sid).name, thrt, cur_alloc, this_alloc)
if "Main" in thisround or new_alloc > 0:
if verbose_mil_reporting:
print "-----------------"
new_allocations = []
remaining_mil_rating = avail_mil_rating
# for top categories assign max_alloc right away as available
for cat in ['capitol', 'occupied', 'topTargets']:
for sid, alloc, take_any, max_alloc in allocation_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
this_alloc = min(remaining_mil_rating, max_alloc)
new_allocations.append((sid, this_alloc, alloc, take_any))
remaining_mil_rating -= this_alloc
base_allocs = set()
# for lower priority categories, first assign base_alloc around to all, then top up as available
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, take_any, max_alloc in allocation_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
base_allocs.add(sid)
remaining_mil_rating -= alloc
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, take_any, max_alloc in allocation_groups.get(cat, []):
if sid not in base_allocs:
break
if remaining_mil_rating <= 0:
new_allocations.append((sid, alloc, alloc, take_any))
else:
new_rating = min(remaining_mil_rating + alloc, max_alloc)
new_allocations.append((sid, new_rating, alloc, take_any))
remaining_mil_rating -= (new_rating - alloc)
if "Main" in thisround:
military_allocations = new_allocations
minMilAllocations.clear()
minMilAllocations.update([(sid, alloc) for sid, alloc, take_any, mm in allocations])
if verbose_mil_reporting or "Main" in thisround:
print "------------------------------\nFinal %s Round Military Allocations: %s \n-----------------------" % (thisround, dict([(sid, alloc) for sid, alloc, minalloc, take_any in new_allocations]))
print "(Apparently) remaining military rating: %.1f" % remaining_mil_rating
# export military systems for other AI modules
if "Main" in thisround:
AIstate.militarySystemIDs = list(set([sid for sid, alloc, minalloc, take_any in new_allocations]).union([sid for sid in already_assigned_rating if already_assigned_rating[sid] > 0]))
else:
AIstate.militarySystemIDs = list(set([sid for sid, alloc, minalloc, take_any in new_allocations]).union(AIstate.militarySystemIDs))
return new_allocations
def get_military_fleets(milFleetIDs=None, tryReset=True, thisround="Main"):
"""get armed military fleets"""
global MilitaryAllocations, totMilRating, num_milships
universe = fo.getUniverse()
empire = fo.getEmpire()
empireID = empire.empireID
capitalID = PlanetUtilsAI.get_capital()
if capitalID is None:
homeworld=None
else:
homeworld = universe.getPlanet(capitalID)
if homeworld:
homeSystemID = homeworld.systemID
else:
homeSystemID=-1
if milFleetIDs is not None:
allMilitaryFleetIDs = milFleetIDs
else:
allMilitaryFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_MILITARY )
if tryReset and ((fo.currentTurn()+empireID) % 30 ==0) and thisround=="Main":
try_again(allMilitaryFleetIDs, try_reset=False, thisround = thisround+" Reset")
num_milships = 0
for fid in allMilitaryFleetIDs:
num_milships += foAI.foAIstate.fleetStatus.get(fid, {}).get('nships', 0)
thisTotMilRating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), allMilitaryFleetIDs ) )
if "Main" in thisround:
totMilRating = thisTotMilRating
print "=================================================="
print "%s Round Total Military Rating: %d"%(thisround, totMilRating)
print "---------------------------------"
foAI.foAIstate.militaryRating=totMilRating
milFleetIDs = list( FleetUtilsAI.extract_fleet_ids_without_mission_types(allMilitaryFleetIDs))
mil_needing_repair_ids, milFleetIDs = avail_mil_needing_repair(milFleetIDs, split_ships=True)
availMilRating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), milFleetIDs ) )
if "Main" in thisround:
print "=================================================="
print "%s Round Available Military Rating: %d"%(thisround, availMilRating)
print "---------------------------------"
remainingMilRating = availMilRating
allocations = []
allocationGroups={}
if not milFleetIDs:
if "Main" in thisround:
MilitaryAllocations = []
return []
#for each system, get total rating of fleets assigned to it
alreadyAssignedRating={}
assignedAttack={}
assignedHP={}
for sysID in universe.systemIDs:
assignedAttack[sysID]=0
assignedHP[sysID]=0
for fleetID in [fid for fid in allMilitaryFleetIDs if fid not in milFleetIDs]:
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
sysTargets= []
for aiFleetMissionType in aiFleetMission.get_mission_types():
aiTargets = aiFleetMission.get_targets(aiFleetMissionType)
for aiTarget in aiTargets:
sysTargets.extend(aiTarget.get_required_system_ai_targets())
if not sysTargets: #shouldn't really be possible
continue
lastSys = sysTargets[-1].target_id # will count this fleet as assigned to last system in target list
assignedAttack[lastSys] += foAI.foAIstate.get_rating(fleetID).get('attack', 0)
assignedHP[lastSys] += foAI.foAIstate.get_rating(fleetID).get('health', 0)
for sysID in universe.systemIDs:
mydefenses = foAI.foAIstate.systemStatus.get(sysID, {}).get( 'mydefenses', {} )
mypattack = mydefenses.get('attack', 0)
myphealth = mydefenses.get('health', 0)
alreadyAssignedRating[sysID] = ( assignedAttack[sysID] + mypattack ) * ( assignedHP[sysID] + myphealth )
# get systems to defend
capitalID = PlanetUtilsAI.get_capital()
if capitalID is not None:
capitalPlanet = universe.getPlanet(capitalID)
else:
capitalPlanet=None
#TODO: if no owned planets try to capture one!
if capitalPlanet:
capitalSysID = capitalPlanet.systemID
else: # should be rare, but so as to not break code below, pick a randomish mil-centroid system
capitalSysID=None #unless we can find one to use
systemDict = {}
for fleetID in allMilitaryFleetIDs:
status = foAI.foAIstate.fleetStatus.get(fleetID, None)
if status is not None:
sysID = status['sysID']
if len( list( universe.getSystem(sysID).planetIDs ) ) ==0:
continue
systemDict[sysID] = systemDict.get( sysID, 0) + status.get('rating', {}).get('overall', 0)
rankedSystems = sorted( [(val, sysID) for sysID, val in systemDict.items() ] )
if rankedSystems:
capitalSysID = rankedSystems[-1][-1]
else:
try:
capitalSysID = foAI.foAIstate.fleetStatus.items()[0][1]['sysID']
except:
pass
if False:
if fo.currentTurn() < 20:
threatBias = 0
elif fo.currentTurn() < 40:
threatBias = 10
elif fo.currentTurn() < 60:
threatBias = 80
elif fo.currentTurn() < 80:
threatBias = 200
else:
threatBias = 400
else:
threatBias = 0
safetyFactor = [ 4.0, 3.0, 2.0, 1.5, 1.2, 1.0 ][foAI.foAIstate.aggression]
topTargetPlanets = [pid for pid, pscore, trp in AIstate.invasionTargets[:PriorityAI.allottedInvasionTargets] if pscore > 20] + [pid for pid, pscore in foAI.foAIstate.colonisablePlanetIDs[:10] if pscore > 20]
topTargetPlanets.extend( foAI.foAIstate.qualifyingTroopBaseTargets.keys() )
topTargetSystems = []
for sysID in AIstate.invasionTargetedSystemIDs + PlanetUtilsAI.get_systems( topTargetPlanets ):
if sysID not in topTargetSystems:
topTargetSystems.append(sysID) #doing this rather than set, to preserve order
# allocation format: ( sysID, newAllocation, takeAny, maxMultiplier )
#================================
#--------Capital Threat ----------
capitalThreat = safetyFactor*(2* threatBias +sum( [ foAI.foAIstate.systemStatus[capitalSysID][thrtKey] for thrtKey in ['totalThreat', 'neighborThreat']] ))
neededRating = rating_needed(1.4*capitalThreat, alreadyAssignedRating[capitalSysID])
newAlloc=0
if tryReset:
if neededRating > 0.5*availMilRating:
try_again(allMilitaryFleetIDs)
return
if neededRating > 0:
newAlloc = min(remainingMilRating, neededRating )
allocations.append( ( capitalSysID, newAlloc, True, 1.6*capitalThreat) )
allocationGroups.setdefault('capitol', []).append( ( capitalSysID, newAlloc, True, 2*capitalThreat) )
remainingMilRating -= newAlloc
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "Empire Capital System: (%d) %s -- threat : %d, military allocation: existing: %d ; new: %d"%(capitalSysID, universe.getSystem(capitalSysID).name , capitalThreat, alreadyAssignedRating[capitalSysID], newAlloc)
print "-----------------"
#================================
#--------Empire Occupied Systems ----------
empirePlanetIDs = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
empireOccupiedSystemIDs = list(set(PlanetUtilsAI.get_systems(empirePlanetIDs)) - {capitalSysID})
if "Main" in thisround:
if verboseMilReporting:
print "Empire-Occupied Systems: %s"%( [ "| %d %s |"%(eoSysID, universe.getSystem(eoSysID).name) for eoSysID in empireOccupiedSystemIDs ] )
print "-----------------"
newAlloc=0
if len( empireOccupiedSystemIDs ) > 0:
ocSysTotThreat = [ ( oSID, threatBias +safetyFactor*sum( [ foAI.foAIstate.systemStatus.get(oSID, {}).get(thrtKey, 0) for thrtKey in ['totalThreat', 'neighborThreat']] ))
for oSID in empireOccupiedSystemIDs ]
totocSysThreat = sum( [thrt for sid, thrt in ocSysTotThreat] )
totCurAlloc = sum( [alreadyAssignedRating[sid] for sid, thrt in ocSysTotThreat] )
allocationFactor = min( 1.5, remainingMilRating /max(0.01, ( totocSysThreat -totCurAlloc) ))
ocSysAlloc = 0
for sid, thrt in ocSysTotThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.3*thrt, curAlloc)
if (neededRating > 0.8* remainingMilRating) and tryReset:
try_again(allMilitaryFleetIDs)
return
thisAlloc=0
if ( neededRating>0 ) and remainingMilRating > 0:
thisAlloc = max(0, min( neededRating, 0.5*availMilRating, remainingMilRating))
newAlloc+=thisAlloc
allocations.append( (sid, thisAlloc, True, 1.6*thrt) )
allocationGroups.setdefault('occupied', []).append( (sid, thisAlloc, True, 2*thrt) )
remainingMilRating -= thisAlloc
ocSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Provincial Occupied system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "Provincial Empire-Occupied Sytems under total threat: %d -- total mil allocation: existing %d ; new: %d"%(totocSysThreat, totCurAlloc, ocSysAlloc )
print "-----------------"
#================================
#--------Top Targeted Systems ----------
#TODO: do native invasions highest priority
otherTargetedSystemIDs = topTargetSystems
if "Main" in thisround:
if verboseMilReporting:
print "Top Colony and Invasion Targeted Systems : %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in otherTargetedSystemIDs ] )
print "-----------------"
# for these, calc local threat only, no neighbor threat, but use a multiplier for fleet safety
newAlloc=0
if len( otherTargetedSystemIDs ) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, threatBias +safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('totalThreat', 0)+0.5*foAI.foAIstate.systemStatus.get(oSID, {}).get('neightborThreat', 0) ) ) for oSID in otherTargetedSystemIDs ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.4*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= alreadyAssignedRating[sid] > 0
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
maxAlloc = safetyFactor*3*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
newAlloc+=thisAlloc
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('topTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Top Colony and Invasion Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
#================================
#--------Targeted Systems ----------
#TODO: do native invasions highest priority
otherTargetedSystemIDs = [sysID for sysID in set( PlanetUtilsAI.get_systems(AIstate.opponentPlanetIDs)) if sysID not in topTargetSystems]
if "Main" in thisround:
if verboseMilReporting:
print "Other Invasion Targeted Systems : %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in otherTargetedSystemIDs ] )
print "-----------------"
# for these, calc local threat only, no neighbor threat, but use a multiplier for fleet safety
newAlloc=0
if len( otherTargetedSystemIDs ) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, threatBias +safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('totalThreat', 0)+0.5*foAI.foAIstate.systemStatus.get(oSID, {}).get('neighborThreat', 0) ) ) for oSID in otherTargetedSystemIDs ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.4*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= alreadyAssignedRating[sid] > 0
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
newAlloc+=thisAlloc
maxAlloc = safetyFactor*3*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('otherTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Invasion Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
otherTargetedSystemIDs = [sysID for sysID in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs)) if sysID not in topTargetSystems]
if "Main" in thisround:
if verboseMilReporting:
print "Other Targeted Systems : %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in otherTargetedSystemIDs ] )
print "-----------------"
if len( otherTargetedSystemIDs ) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, safetyFactor*(threatBias +foAI.foAIstate.systemStatus.get(oSID, {}).get('totalThreat', 0)+0.5*foAI.foAIstate.systemStatus.get(oSID, {}).get('neighborThreat', 0) ) ) for oSID in otherTargetedSystemIDs ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
newAlloc=0
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.2*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= alreadyAssignedRating[sid] > 0
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
newAlloc+=thisAlloc
maxAlloc = safetyFactor*3*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('otherTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Other Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
otherTargetedSystemIDs = []
#targetableIDs = ColonisationAI.annexableSystemIDs.union( empire.fleetSupplyableSystemIDs )
targetableIDs = set(ColonisationAI.systems_by_supply_tier.get(0, []) + ColonisationAI.systems_by_supply_tier.get(1, []))
for sysID in AIstate.opponentSystemIDs:
if sysID in targetableIDs:
otherTargetedSystemIDs.append(sysID)
else:
for nID in universe.getImmediateNeighbors(sysID, empireID):
if nID in targetableIDs:
otherTargetedSystemIDs.append(sysID)
break
if "Main" in thisround:
if verboseMilReporting:
print "Blockade Targeted Systems : %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in otherTargetedSystemIDs ] )
print "-----------------"
if len( otherTargetedSystemIDs ) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, threatBias +safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('totalThreat', 0)+ 0.5*foAI.foAIstate.systemStatus.get(oSID, {}).get('neighborThreat', 0) ) ) for oSID in otherTargetedSystemIDs ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
newAlloc=0
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.2*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= alreadyAssignedRating[sid] > 0
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
newAlloc+=thisAlloc
maxAlloc = safetyFactor*2*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('otherTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Blockade Targeted system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Blockade Targeted Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
currentMilSystems = [sid for sid, alloc, takeAny, mm in allocations ]
interiorIDs = list( foAI.foAIstate.expInteriorSystemIDs)
interiorTargets1 = (targetableIDs.union(interiorIDs)).difference( currentMilSystems )
interiorTargets = [sid for sid in interiorTargets1 if (
threatBias + foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0) >0.8*alreadyAssignedRating[sid] ) ]
if "Main" in thisround:
if verboseMilReporting:
print
print "Other Empire-Proximal Systems : %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in interiorTargets1 ] )
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
newAlloc=0
if len(interiorTargets) >0:
otSysAlloc = 0
otSysThreat = [ ( oSID, threatBias +safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('totalThreat', 0)) ) for oSID in interiorTargets ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.2*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= alreadyAssignedRating[sid] > 0
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
newAlloc+=thisAlloc
maxAlloc = safetyFactor*2*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('otherTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Other interior system %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Other Interior Systems under total threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
elif "Main" in thisround:
if verboseMilReporting:
print "-----------------"
print "No Other Interior Systems with fleet threat "
print "-----------------"
monsterDens=[]
#exploTargetIDs, _ = ExplorationAI.get_current_exploration_info(verbose=False)
exploTargetIDs=[]
if "Main" in thisround:
if verboseMilReporting:
print
print "Exploration-targeted Systems: %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in exploTargetIDs ] )
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
newAlloc=0
if len(exploTargetIDs) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('fleetThreat', 0) + foAI.foAIstate.systemStatus.get(oSID, {}).get('monsterThreat', 0)+ foAI.foAIstate.systemStatus.get(oSID, {}).get('planetThreat', 0) )) for oSID in exploTargetIDs ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [0.8*alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
if availMilRating <1125:
maxMilRating = availMilRating
else:
maxMilRating = 0.5*availMilRating
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.2*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= False
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
newAlloc+=thisAlloc
maxAlloc = safetyFactor*2*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('exploreTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Exploration-targeted %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Exploration-targeted s under total threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
visibleSystemIDs = foAI.foAIstate.visInteriorSystemIDs.keys() + foAI.foAIstate. visBorderSystemIDs.keys()
accessibleSystemIDs = [sysID for sysID in visibleSystemIDs if universe.systemsConnected(sysID, homeSystemID, empireID) ]
currentMilSystems = [sid for sid, alloc, takeAny, multiplier in allocations if alloc > 0 ]
borderTargets1 = [sid for sid in accessibleSystemIDs if ( sid not in currentMilSystems) ]
borderTargets = [sid for sid in borderTargets1 if (threatBias +foAI.foAIstate.systemStatus.get(sid, {}).get('fleetThreat', 0) + foAI.foAIstate.systemStatus.get(sid, {}).get('planetThreat', 0) > 0.8*alreadyAssignedRating[sid]) ]
if "Main" in thisround:
if verboseMilReporting:
print
print "Empire-Accessible Systems not yet allocated military: %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID) and universe.getSystem(sysID).name) for sysID in borderTargets1 ] )
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
newAlloc=0
if len(borderTargets) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, threatBias +safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('fleetThreat', 0) + foAI.foAIstate.systemStatus.get(oSID, {}).get('monsterThreat', 0)+ foAI.foAIstate.systemStatus.get(oSID, {}).get('planetThreat', 0)) ) for oSID in borderTargets ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [0.8*alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
for sid, thrt in otSysThreat:
curAlloc=alreadyAssignedRating[sid]
neededRating = rating_needed( 1.2*thrt, curAlloc)
thisAlloc=0
#only record more allocation for this invasion if we already started or have enough rating available
takeAny= False
if ( neededRating>0 ) and (remainingMilRating > neededRating or takeAny):
thisAlloc = max(0, min( neededRating, remainingMilRating))
newAlloc+=thisAlloc
maxAlloc = safetyFactor*2*max( foAI.foAIstate.systemStatus.get(sid, {}).get('totalThreat', 0), foAI.foAIstate.systemStatus.get(sid, {}).get('neightborThreat', 0))
allocations.append( (sid, thisAlloc, takeAny , maxAlloc) )
allocationGroups.setdefault('accessibleTargets', []).append( (sid, thisAlloc, takeAny , maxAlloc) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Other Empire-Accessible system %4d ( %10s ) has local biased threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
print "Other Empire-Accessible Systems under total biased threat: %d -- total mil allocation-- existing: %d ; new: %d"%(tototSysThreat, totCurAlloc, otSysAlloc )
print "-----------------"
elif "Main" in thisround:
if verboseMilReporting:
print "-----------------"
print "No Other Empire-Accessible Systems with biased local threat "
print "-----------------"
#monster den treatment probably unnecessary now
if "Main" in thisround:
if verboseMilReporting:
print
print "Big-Monster Dens: %s"%( [ "| %d %s |"%(sysID, universe.getSystem(sysID).name) for sysID in monsterDens ] )
print "-----------------"
# for these, calc fleet threat only, no neighbor threat, but use a multiplier for fleet safety
newAlloc=0
if len(monsterDens) > 0:
otSysAlloc = 0
otSysThreat = [ ( oSID, safetyFactor*(foAI.foAIstate.systemStatus.get(oSID, {}).get('fleetThreat', 0)+foAI.foAIstate.systemStatus.get(oSID, {}).get('monsterThreat', 0) + foAI.foAIstate.systemStatus.get(oSID, {}).get('planetThreat', 0) ) ) for oSID in monsterDens ]
tototSysThreat = sum( [thrt for sid, thrt in otSysThreat] )
totCurAlloc = sum( [0.8*alreadyAssignedRating[sid] for sid, thrt in otSysThreat] )
for sid, thrt in otSysThreat:
curAlloc=0.8*alreadyAssignedRating[sid]
thisAlloc=0
if (thrt > curAlloc) and remainingMilRating > 2* thrt:
thisAlloc = int(0.99999 + (thrt-curAlloc)*1.5)
newAlloc+=thisAlloc
allocations.append( (sid, thisAlloc, False, 5) )
remainingMilRating -= thisAlloc
otSysAlloc += thisAlloc
if "Main" in thisround or thisAlloc >0:
if verboseMilReporting:
print "Monster Den %4d ( %10s ) has local threat %8d ; existing military allocation %d and new allocation %8d"%(sid, universe.getSystem(sid).name, thrt, curAlloc, thisAlloc)
if "Main" in thisround or newAlloc >0:
if verboseMilReporting:
print "-----------------"
if remainingMilRating <=6:
newAllocations = [ (sid, alc, alc, ta) for (sid, alc, ta, mm) in allocations ]
else:
#oldAllocations = dict( [ (entry[0], entry ) for entry in allocations ] )
try:
totAlloc = sum( [alloc for sid, alloc, takeAny, maxAlloc in allocations ] )
except:
print "error unpacking sid, alloc, takeAny, maxAlloc from ", allocations
factor =(2.0* remainingMilRating ) / ( totAlloc + 0.1)
#print "Remaining military strength allocation %d will be allocated as %.1f %% surplus allocation to top current priorities"%(remainingMilRating, 100*factor)
print "%s Round Remaining military strength allocation %d will be allocated as surplus allocation to top current priorities"%(thisround, remainingMilRating)
newAllocations = []
for cat in ['capitol', 'topTargets', 'otherTargets', 'accessibleTargets', 'occupied', 'exploreTargets']:
for sid, alloc, takeAny, maxAlloc in allocationGroups.get(cat, []):
if remainingMilRating <= 0 :
newAllocations.append( ( sid, alloc, alloc, takeAny ) )
else:
newRating = min(remainingMilRating+alloc, max(alloc, rating_needed( maxAlloc, alreadyAssignedRating[sid]) ) )
newAllocations.append( ( sid, newRating, alloc, takeAny ) )
remainingMilRating -= ( newRating - alloc )
if "Main" in thisround:
MilitaryAllocations = newAllocations
minMilAllocations.clear()
minMilAllocations.update( [ (sid, alloc) for sid, alloc, takeAny, mm in allocations ] )
if verboseMilReporting or "Main" in thisround:
print "------------------------------\nFinal %s Round Military Allocations: %s \n-----------------------"%(thisround, dict( [ (sid, alloc) for sid, alloc, minalloc, takeAny in newAllocations ] ) )
# export military systems for other AI modules
if "Main" in thisround:
AIstate.militarySystemIDs = list( set([sid for sid, alloc, minalloc, takeAny in newAllocations]).union( [sid for sid in alreadyAssignedRating if alreadyAssignedRating[sid]>0 ] ))
else:
AIstate.militarySystemIDs = list( set([sid for sid, alloc, minalloc, takeAny in newAllocations]).union( AIstate.militarySystemIDs) )
return newAllocations
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
if doing_main:
foAI.foAIstate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = universe_object.System(sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.add_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = military_allocations
print "=================================================="
print "Assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
try:
these_fleets = FleetUtilsAI.get_fleets_for_mission(1, {'rating': alloc}, {'rating': minalloc}, found_stats, "", systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=avail_mil_fleet_ids, fleet_list=found_fleets, verbose=False)
except:
continue
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
# rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, found_fleets)
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum([fr.get('health', 0) for fr in ratings])
if doing_main and verbose_mil_reporting:
if rating < minMilAllocations.get(sys_id, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, rating, these_fleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, minMilAllocations.get(sys_id, 0), rating, these_fleets)
elif doing_main and verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets)
target = universe_object.System(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)):
mission_type = MissionType.SECURE
else:
mission_type = MissionType.MILITARY
fleet_mission.add_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
print "---------------------------------"
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
print "Still have available military fleets: %s" % avail_mil_fleet_ids
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
def get_num_military_ships():
return sum(foAI.foAIstate.fleetStatus.get(fid, {}).get('nships', 0)
for fid in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
def _calculate_invasion_priority():
"""Calculates the demand for troop ships by opponent planets."""
if not foAI.foAIstate.character.may_invade():
return 0
empire = fo.getEmpire()
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
multiplier = 1
colony_growth_barrier = foAI.foAIstate.character.max_number_colonies()
if state.get_number_of_colonies() > colony_growth_barrier:
return 0.0
if len(foAI.foAIstate.colonisablePlanetIDs) > 0:
best_colony_score = max(2, foAI.foAIstate.colonisablePlanetIDs.items()[0][1][0])
else:
best_colony_score = 2
total_val = 0
troops_needed = 0
for pid, pscore, trp in AIstate.invasionTargets[:allotted_invasion_targets()]:
if pscore > best_colony_score:
multiplier += 1
total_val += 2 * pscore
else:
total_val += pscore
troops_needed += trp + 4 # ToDo: This seems like it could be improved by some dynamic calculation of buffer
if total_val == 0:
return 0
production_queue = empire.productionQueue
queued_troop_capacity = 0
for queue_index in range(0, len(production_queue)):
element = production_queue[queue_index]
if element.buildType == EmpireProductionTypes.BT_SHIP:
if foAI.foAIstate.get_ship_role(element.designID) in [ShipRoleType.MILITARY_INVASION,
ShipRoleType.BASE_INVASION]:
design = fo.getShipDesign(element.designID)
queued_troop_capacity += element.remaining * element.blocksize * design.troopCapacity
_, best_design, _ = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if best_design:
troops_per_best_ship = best_design.troopCapacity
else:
return 1e-6 # if we can not build troop ships, we don't want to build (non-existing) invasion ships
# don't count troop bases here as these cannot be redeployed after misplaning
# troopFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)\
# + FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_INVASION)
troop_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.INVASION)
total_troop_capacity = sum([FleetUtilsAI.count_troops_in_fleet(fid) for fid in troop_fleet_ids])
troop_ships_needed = \
math.ceil((troops_needed - (total_troop_capacity + queued_troop_capacity)) / troops_per_best_ship)
# invasion_priority = max( 10+ 200*max(0, troop_ships_needed ) , int(0.1* total_val) )
invasion_priority = multiplier * (30 + 150*max(0, troop_ships_needed))
if not ColonisationAI.colony_status.get('colonies_under_attack', []):
if not ColonisationAI.colony_status.get('colonies_under_threat', []):
invasion_priority *= 2.0
else:
invasion_priority *= 1.5
if not enemies_sighted:
invasion_priority *= 1.5
if invasion_priority < 0:
return 0
return invasion_priority * foAI.foAIstate.character.invasion_priority_scaling()
def get_military_fleets(mil_fleets_ids=None, try_reset=True, thisround="Main"):
"""Get armed military fleets."""
global _military_allocations
universe = fo.getUniverse()
empire_id = fo.empireID()
home_system_id = PlanetUtilsAI.get_capital_sys_id()
all_military_fleet_ids = (mil_fleets_ids if mil_fleets_ids is not None
else FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
if try_reset and (fo.currentTurn() + empire_id) % 30 == 0 and thisround == "Main":
try_again(all_military_fleet_ids, try_reset=False, thisround=thisround + " Reset")
return
mil_fleets_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, mil_fleets_ids = avail_mil_needing_repair(mil_fleets_ids, split_ships=True)
avail_mil_rating = sum(map(CombatRatingsAI.get_fleet_rating, mil_fleets_ids))
if not mil_fleets_ids:
if "Main" in thisround:
_military_allocations = []
return []
# for each system, get total rating of fleets assigned to it
already_assigned_rating = {}
systems_status = foAI.foAIstate.systemStatus
enemy_sup_factor = {} # enemy supply
for sys_id in universe.systemIDs:
already_assigned_rating[sys_id] = 0
enemy_sup_factor[sys_id] = min(2, len(systems_status.get(sys_id, {}).get('enemies_nearly_supplied', [])))
for fleet_id in [fid for fid in all_military_fleet_ids if fid not in mil_fleets_ids]:
ai_fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
if not ai_fleet_mission.target: # shouldn't really be possible
continue
last_sys = ai_fleet_mission.target.get_system().id # will count this fleet as assigned to last system in target list # TODO last_sys or target sys?
this_rating = CombatRatingsAI.get_fleet_rating(fleet_id)
already_assigned_rating[last_sys] = CombatRatingsAI.combine_ratings(already_assigned_rating.get(last_sys, 0), this_rating)
for sys_id in universe.systemIDs:
my_defense_rating = systems_status.get(sys_id, {}).get('mydefenses', {}).get('overall', 0)
already_assigned_rating[sys_id] = CombatRatingsAI.combine_ratings(my_defense_rating, already_assigned_rating[sys_id])
if _verbose_mil_reporting and already_assigned_rating[sys_id]:
print "\t System %s already assigned rating %.1f" % (
universe.getSystem(sys_id), already_assigned_rating[sys_id])
# get systems to defend
capital_id = PlanetUtilsAI.get_capital()
if capital_id is not None:
capital_planet = universe.getPlanet(capital_id)
else:
capital_planet = None
# TODO: if no owned planets try to capture one!
if capital_planet:
capital_sys_id = capital_planet.systemID
else: # should be rare, but so as to not break code below, pick a randomish mil-centroid system
capital_sys_id = None # unless we can find one to use
system_dict = {}
for fleet_id in all_military_fleet_ids:
status = foAI.foAIstate.fleetStatus.get(fleet_id, None)
if status is not None:
sys_id = status['sysID']
if not list(universe.getSystem(sys_id).planetIDs):
continue
system_dict[sys_id] = system_dict.get(sys_id, 0) + status.get('rating', 0)
ranked_systems = sorted([(val, sys_id) for sys_id, val in system_dict.items()])
if ranked_systems:
capital_sys_id = ranked_systems[-1][-1]
else:
try:
capital_sys_id = foAI.foAIstate.fleetStatus.items()[0][1]['sysID']
except:
pass
num_targets = max(10, PriorityAI.allotted_outpost_targets)
top_target_planets = ([pid for pid, pscore, trp in AIstate.invasionTargets[:PriorityAI.allottedInvasionTargets] if pscore > 20] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisableOutpostIDs.items()[:num_targets] if pscore > 20] +
[pid for pid, (pscore, spec) in foAI.foAIstate.colonisablePlanetIDs.items()[:num_targets] if pscore > 20])
top_target_planets.extend(foAI.foAIstate.qualifyingTroopBaseTargets.keys())
base_col_target_systems = PlanetUtilsAI.get_systems(top_target_planets)
top_target_systems = []
for sys_id in AIstate.invasionTargetedSystemIDs + base_col_target_systems:
if sys_id not in top_target_systems:
if foAI.foAIstate.systemStatus[sys_id]['totalThreat'] > get_tot_mil_rating():
continue
top_target_systems.append(sys_id) # doing this rather than set, to preserve order
try:
# capital defense
allocation_helper = AllocationHelper(already_assigned_rating, avail_mil_rating, try_reset)
if capital_sys_id is not None:
CapitalDefenseAllocator(capital_sys_id, allocation_helper).allocate()
# defend other planets
empire_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
empire_occupied_system_ids = list(set(PlanetUtilsAI.get_systems(empire_planet_ids)) - {capital_sys_id})
for sys_id in empire_occupied_system_ids:
PlanetDefenseAllocator(sys_id, allocation_helper).allocate()
# attack / protect high priority targets
for sys_id in top_target_systems:
TopTargetAllocator(sys_id, allocation_helper).allocate()
# enemy planets
other_targeted_system_ids = [sys_id for sys_id in set(PlanetUtilsAI.get_systems(AIstate.opponentPlanetIDs)) if
sys_id not in top_target_systems]
for sys_id in other_targeted_system_ids:
TargetAllocator(sys_id, allocation_helper).allocate()
# colony / outpost targets
other_targeted_system_ids = [sys_id for sys_id in
list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs)) if
sys_id not in top_target_systems]
for sys_id in other_targeted_system_ids:
OutpostTargetAllocator(sys_id, allocation_helper).allocate()
# TODO blockade enemy systems
# interior systems
targetable_ids = set(ColonisationAI.systems_by_supply_tier.get(0, []) +
ColonisationAI.systems_by_supply_tier.get(1, []))
current_mil_systems = [sid for sid, _, _, _ in allocation_helper.allocations]
interior_targets1 = targetable_ids.difference(current_mil_systems)
interior_targets = [sid for sid in interior_targets1 if (
allocation_helper.threat_bias + systems_status.get(sid, {}).get('totalThreat', 0) > 0.8 * allocation_helper.already_assigned_rating[sid])]
for sys_id in interior_targets:
InteriorTargetsAllocator(sys_id, allocation_helper).allocate()
# TODO Exploration targets
# border protections
visible_system_ids = foAI.foAIstate.visInteriorSystemIDs.keys() + foAI.foAIstate.visBorderSystemIDs.keys()
accessible_system_ids = [sys_id for sys_id in visible_system_ids if
universe.systemsConnected(sys_id, home_system_id, empire_id)]
current_mil_systems = [sid for sid, alloc, take_any, _ in allocation_helper.allocations if alloc > 0]
border_targets1 = [sid for sid in accessible_system_ids if sid not in current_mil_systems]
border_targets = [sid for sid in border_targets1 if (
allocation_helper.threat_bias + systems_status.get(sid, {}).get('fleetThreat', 0) + systems_status.get(sid, {}).get(
'planetThreat', 0) > 0.8 * allocation_helper.already_assigned_rating[sid])]
for sys_id in border_targets:
BorderSecurityAllocator(sys_id, allocation_helper).allocate()
except ReleaseMilitaryException:
try_again(all_military_fleet_ids)
return
allocation_groups = allocation_helper.allocation_by_groups
allocations = allocation_helper.allocations
new_allocations = []
remaining_mil_rating = avail_mil_rating
# for top categories assign max_alloc right away as available
for cat in ['capitol', 'occupied', 'topTargets']:
for sid, alloc, take_any, max_alloc in allocation_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
this_alloc = min(remaining_mil_rating, max_alloc)
new_allocations.append((sid, this_alloc, alloc, take_any))
remaining_mil_rating -= this_alloc
base_allocs = set()
# for lower priority categories, first assign base_alloc around to all, then top up as available
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, take_any, max_alloc in allocation_groups.get(cat, []):
if remaining_mil_rating <= 0:
break
base_allocs.add(sid)
remaining_mil_rating -= alloc
for cat in ['otherTargets', 'accessibleTargets', 'exploreTargets']:
for sid, alloc, take_any, max_alloc in allocation_groups.get(cat, []):
if sid not in base_allocs:
break
if remaining_mil_rating <= 0:
new_allocations.append((sid, alloc, alloc, take_any))
else:
new_rating = min(remaining_mil_rating + alloc, max_alloc)
new_allocations.append((sid, new_rating, alloc, take_any))
remaining_mil_rating -= (new_rating - alloc)
if "Main" in thisround:
_military_allocations = new_allocations
_min_mil_allocations.clear()
_min_mil_allocations.update([(sid, alloc) for sid, alloc, take_any, _ in allocations])
if _verbose_mil_reporting or "Main" in thisround:
print "------------------------------\nFinal %s Round Military Allocations: %s \n-----------------------" % (thisround, dict([(sid, alloc) for sid, alloc, minalloc, take_any in new_allocations]))
print "(Apparently) remaining military rating: %.1f" % remaining_mil_rating
# export military systems for other AI modules
if "Main" in thisround:
AIstate.militarySystemIDs = list(set([sid for sid, alloc, minalloc, take_any in new_allocations]).union(
[sid for sid in allocation_helper.already_assigned_rating
if allocation_helper.already_assigned_rating[sid] > 0]))
else:
AIstate.militarySystemIDs = list(set([sid for sid, alloc, minalloc, take_any in new_allocations]).union(AIstate.militarySystemIDs))
return new_allocations
def get_tot_mil_rating():
return sum(CombatRatingsAI.get_fleet_rating(fleet_id)
for fleet_id in FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY))
