def generateOrders():
print ("Genearting Orders")
universe = fo.getUniverse()
empire = fo.getEmpire()
planetID = empire.capitalID
planet = universe.getPlanet(planetID)
print "EmpireID: " + str(empire.empireID) + " Name: " + empire.name + " Turn: " + str(fo.currentTurn())
print "CapitalID: " + str(planetID) + " Name: " + planet.name + " Species: " + planet.speciesName
# turn cleanup
splitFleet()
identifyShipDesigns()
identifyFleetsRoles()
foAIstate.clean(ExplorationAI.getHomeSystemID(), FleetUtilsAI.getEmpireFleetIDs())
# ...missions
# ...demands/priorities
print("Calling AI Modules")
# call AI modules
PriorityAI.calculatePriorities()
ExplorationAI.assignScoutsToExploreSystems()
ColonisationAI.assignColonyFleetsToColonise()
InvasionAI.assignInvasionFleetsToInvade()
MilitaryAI.assignMilitaryFleetsToSystems()
FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
ResearchAI.generateResearchOrders()
ProductionAI.generateProductionOrders()
ResourcesAI.generateResourcesOrders()
foAIstate.afterTurnCleanup()
fo.doneTurn()
def calculatePriorities():
"calculates the priorities of the AI player"
ColonisationAI.getColonyFleets() # sets AIstate.colonisablePlanetIDs and AIstate.outpostPlanetIDs
InvasionAI.getInvasionFleets() # sets AIstate.opponentPlanetIDs
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_EXPLORATION, calculateExplorationPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_OUTPOST, calculateOutpostPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_COLONISATION, calculateColonisationPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_INVASION, calculateInvasionPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_MILITARY, 20)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_FOOD, calculateFoodPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_PRODUCTION, calculateIndustryPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_MINERALS, calculateMineralsPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_RESEARCH, 10)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_TRADE, 0)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_LEARNING, calculateLearningPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_GROWTH, calculateGrowthPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_PRODUCTION, calculateTechsProductionPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_CONSTRUCTION, calculateConstructionPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_ECONOMICS, 0)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_SHIPS, calculateShipsPriority())
def calculatePriorities():
"calculates the priorities of the AI player"
print("calculating priorities")
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_RESEARCH, calculateResearchPriority())
ColonisationAI.getColonyFleets() # sets foAI.foAIstate.colonisablePlanetIDs and foAI.foAIstate.outpostPlanetIDs
InvasionAI.getInvasionFleets() # sets AIstate.invasionFleetIDs, AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
MilitaryAI.getMilitaryFleets() # sets AIstate.militaryFleetIDs and AIstate.militaryTargetedSystemIDs
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_PRODUCTION, calculateIndustryPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_TRADE, 0)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_EXPLORATION, calculateExplorationPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_OUTPOST, calculateOutpostPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_COLONISATION, calculateColonisationPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_INVASION, calculateInvasionPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_MILITARY, calculateMilitaryPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_LEARNING, calculateLearningPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_GROWTH, calculateGrowthPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_PRODUCTION, calculateTechsProductionPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_CONSTRUCTION, calculateConstructionPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_ECONOMICS, 0)
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_SHIPS, calculateShipsPriority())
foAI.foAIstate.setPriority(AIPriorityType.PRIORITY_RESEARCH_DEFENSE, 0)
def calculatePriorities():
"calculates the priorities of the AI player"
print("checking statuses")
# Industry, Research, Colony, Invasion, Military
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_PRODUCTION, 50) # let this one stay fixed & just adjust Research
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_RESEARCH, calculateResearchPriority())
ColonisationAI.getColonyFleets() # sets foAI.foAIstate.colonisablePlanetIDs and foAI.foAIstate.outpostPlanetIDs and many other values used by other modules
InvasionAI.getInvasionFleets() # sets AIstate.invasionFleetIDs, AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
MilitaryAI.getMilitaryFleets() # sets AIstate.militaryFleetIDs and AIstate.militaryTargetedSystemIDs
print("calculating priorities")
calculateIndustryPriority()#purely for reporting purposes
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_TRADE, 0)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_EXPLORATION, calculateExplorationPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_OUTPOST, calculateOutpostPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION, calculateColonisationPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_INVASION, calculateInvasionPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY, calculateMilitaryPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_LEARNING, calculateLearningPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_GROWTH, calculateGrowthPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_PRODUCTION, calculateTechsProductionPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_CONSTRUCTION, calculateConstructionPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_ECONOMICS, 0)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_SHIPS, calculateShipsPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_DEFENSE, 0)
def generateOrders():
empire = fo.getEmpire()
print "Empire: " + empire.name + " TURN: " + str(fo.currentTurn())
print "Capital: " + str(empire.capitalID)
# turn cleanup
splitFleet()
identifyShipDesigns()
identifyFleetsRoles()
foAIstate.clean(ExplorationAI.getHomeSystemID(), FleetUtilsAI.getEmpireFleetIDs())
# ...missions
# ...demands/priorities
# call AI modules
PriorityAI.calculatePriorities()
ExplorationAI.assignScoutsToExploreSystems()
ColonisationAI.assignColonyFleetsToColonise()
InvasionAI.assignInvasionFleetsToInvade()
FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
ResearchAI.generateResearchOrders()
ProductionAI.generateProductionOrders()
ResourcesAI.generateResourcesOrders()
foAIstate.afterTurnCleanup()
fo.doneTurn()
def calculate_priorities():
"""Calculates the priorities of the AI player."""
debug("\n=== Preparing to Calculate Priorities ===")
prioritiees_timer.start("setting Production Priority")
aistate = get_aistate()
# let this one stay fixed & just adjust Research and Influence
aistate.set_priority(PriorityType.RESOURCE_PRODUCTION, 50)
# RESOURCE_INFLUENCE priority is calculated in PolicyAI
debug("\n*** Calculating Research Priority ***\n")
prioritiees_timer.start("setting Research Priority")
aistate.set_priority(
PriorityType.RESOURCE_RESEARCH,
_calculate_research_priority()) # TODO: do univ _survey before this
debug("\n*** Updating Colonization Status ***\n")
prioritiees_timer.start("Evaluating Colonization Status")
ColonisationAI.get_colony_fleets(
) # sets aistate.colonisablePlanetIDs and many other values used by other modules
debug("\n*** Updating Invasion Status ***\n")
prioritiees_timer.start("Evaluating Invasion Status")
InvasionAI.get_invasion_fleets(
) # sets AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
debug("\n*** Updating Military Status ***\n")
prioritiees_timer.start("Evaluating Military Status")
MilitaryAI.get_military_fleets()
debug("\n** Calculating Production Priorities ***\n")
prioritiees_timer.start("reporting Production Priority")
_calculate_industry_priority() # purely for reporting purposes
prioritiees_timer.start("setting Exploration Priority")
aistate.set_priority(PriorityType.RESOURCE_TRADE, 0)
aistate.set_priority(PriorityType.RESOURCE_CONSTRUCTION, 0)
aistate.set_priority(PriorityType.PRODUCTION_EXPLORATION,
_calculate_exploration_priority())
prioritiees_timer.start("setting Colony Priority")
aistate.set_priority(PriorityType.PRODUCTION_COLONISATION,
_calculate_colonisation_priority())
prioritiees_timer.start("setting Outpost Priority")
aistate.set_priority(PriorityType.PRODUCTION_OUTPOST,
_calculate_outpost_priority())
prioritiees_timer.start("setting Invasion Priority")
aistate.set_priority(PriorityType.PRODUCTION_INVASION,
_calculate_invasion_priority())
prioritiees_timer.start("setting Military Priority")
aistate.set_priority(PriorityType.PRODUCTION_MILITARY,
_calculate_military_priority())
prioritiees_timer.start("setting other priorities")
aistate.set_priority(PriorityType.PRODUCTION_BUILDINGS, 25)
prioritiees_timer.stop_print_and_clear()
def calculate_priorities():
"""Calculates the priorities of the AI player."""
print "\n", 10 * "=", "Preparing to Calculate Priorities", 10 * "="
prioritiees_timer.start('setting Production Priority')
foAI.foAIstate.set_priority(PriorityType.RESOURCE_PRODUCTION, 50) # let this one stay fixed & just adjust Research
print "\n*** Calculating Research Priority ***\n"
prioritiees_timer.start('setting Research Priority')
foAI.foAIstate.set_priority(PriorityType.RESOURCE_RESEARCH, _calculate_research_priority()) # TODO: do univ _survey before this
print "\n*** Updating Colonization Status ***\n"
prioritiees_timer.start('Evaluating Colonization Status')
ColonisationAI.get_colony_fleets() # sets foAI.foAIstate.colonisablePlanetIDs and foAI.foAIstate.outpostPlanetIDs and many other values used by other modules
print "\n*** Updating Invasion Status ***\n"
prioritiees_timer.start('Evaluating Invasion Status')
InvasionAI.get_invasion_fleets() # sets AIstate.invasionFleetIDs, AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
print "\n*** Updating Military Status ***\n"
prioritiees_timer.start('Evaluating Military Status')
MilitaryAI.get_military_fleets()
print("\n** Calculating Production Priorities ***\n")
prioritiees_timer.start('reporting Production Priority')
_calculate_industry_priority() # purely for reporting purposes
prioritiees_timer.start('setting Exploration Priority')
foAI.foAIstate.set_priority(PriorityType.RESOURCE_TRADE, 0)
foAI.foAIstate.set_priority(PriorityType.RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_EXPLORATION, _calculate_exploration_priority())
prioritiees_timer.start('setting Colony Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_COLONISATION, _calculate_colonisation_priority())
prioritiees_timer.start('setting Outpost Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_OUTPOST, _calculate_outpost_priority())
prioritiees_timer.start('setting Invasion Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_INVASION, _calculate_invasion_priority())
prioritiees_timer.start('setting Military Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_MILITARY, _calculate_military_priority())
prioritiees_timer.start('setting other priorities')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.set_priority(PriorityType.RESEARCH_LEARNING, _calculate_learning_priority())
foAI.foAIstate.set_priority(PriorityType.RESEARCH_GROWTH, _calculate_growth_priority())
foAI.foAIstate.set_priority(PriorityType.RESEARCH_PRODUCTION, _calculate_techs_production_priority())
foAI.foAIstate.set_priority(PriorityType.RESEARCH_CONSTRUCTION, _calculate_construction_priority())
foAI.foAIstate.set_priority(PriorityType.RESEARCH_ECONOMICS, 0)
foAI.foAIstate.set_priority(PriorityType.RESEARCH_SHIPS, _calculate_ships_priority())
foAI.foAIstate.set_priority(PriorityType.RESEARCH_DEFENSE, 0)
prioritiees_timer.stop_print_and_clear()
def calculate_priorities():
"""calculates the priorities of the AI player"""
print ("checking statuses")
# Industry, Research, Colony, Invasion, Military
prioritiees_timer.start("setting Production Priority")
foAI.foAIstate.set_priority(
EnumsAI.AIPriorityType.PRIORITY_RESOURCE_PRODUCTION, 50
) # let this one stay fixed & just adjust Research
prioritiees_timer.start("setting Research Priority")
foAI.foAIstate.set_priority(
EnumsAI.AIPriorityType.PRIORITY_RESOURCE_RESEARCH, calculateResearchPriority()
) # TODO: do univ _survey before this
prioritiees_timer.start("Evaluating Colonization Status")
ColonisationAI.get_colony_fleets() # sets foAI.foAIstate.colonisablePlanetIDs and foAI.foAIstate.outpostPlanetIDs and many other values used by other modules
prioritiees_timer.start("Evaluating Invasion Status")
InvasionAI.get_invasion_fleets() # sets AIstate.invasionFleetIDs, AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
prioritiees_timer.start("Evaluating Military Status")
MilitaryAI.get_military_fleets() # sets AIstate.militaryFleetIDs and AIstate.militaryTargetedSystemIDs
prioritiees_timer.start("reporting Production Priority")
print ("calculating priorities")
calculateIndustryPriority() # purely for reporting purposes
prioritiees_timer.start("setting Exploration Priority")
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_TRADE, 0)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_EXPLORATION, calculateExplorationPriority())
prioritiees_timer.start("setting Colony Priority")
foAI.foAIstate.set_priority(
EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION, calculateColonisationPriority()
)
prioritiees_timer.start("setting Outpost Priority")
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_OUTPOST, calculateOutpostPriority())
prioritiees_timer.start("setting Invasion Priority")
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_INVASION, calculateInvasionPriority())
prioritiees_timer.start("setting Military Priority")
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY, calculateMilitaryPriority())
prioritiees_timer.start("setting other priorities")
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_LEARNING, calculateLearningPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_GROWTH, calculateGrowthPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_PRODUCTION, calculateTechsProductionPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_CONSTRUCTION, calculateConstructionPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_ECONOMICS, 0)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_SHIPS, calculateShipsPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_DEFENSE, 0)
prioritiees_timer.end()
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 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_priorities():
"""calculates the priorities of the AI player"""
print("checking statuses")
# Industry, Research, Colony, Invasion, Military
prioritiees_timer.start('setting Production Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_PRODUCTION, 50) # let this one stay fixed & just adjust Research
prioritiees_timer.start('setting Research Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_RESEARCH, calculateResearchPriority()) #TODO: do univ _survey before this
prioritiees_timer.start('Evaluating Colonization Status')
ColonisationAI.get_colony_fleets() # sets foAI.foAIstate.colonisablePlanetIDs and foAI.foAIstate.outpostPlanetIDs and many other values used by other modules
prioritiees_timer.start('Evaluating Invasion Status')
InvasionAI.get_invasion_fleets() # sets AIstate.invasionFleetIDs, AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
prioritiees_timer.start('Evaluating Military Status')
MilitaryAI.get_military_fleets() # sets AIstate.militaryFleetIDs and AIstate.militaryTargetedSystemIDs
prioritiees_timer.start('reporting Production Priority')
print("calculating priorities")
calculateIndustryPriority()#purely for reporting purposes
prioritiees_timer.start('setting Exploration Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_TRADE, 0)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_EXPLORATION, calculateExplorationPriority())
prioritiees_timer.start('setting Colony Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION, calculateColonisationPriority())
prioritiees_timer.start('setting Outpost Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_OUTPOST, calculateOutpostPriority())
prioritiees_timer.start('setting Invasion Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_INVASION, calculateInvasionPriority())
prioritiees_timer.start('setting Military Priority')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY, calculateMilitaryPriority())
prioritiees_timer.start('setting other priorities')
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_LEARNING, calculateLearningPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_GROWTH, calculateGrowthPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_PRODUCTION, calculateTechsProductionPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_CONSTRUCTION, calculateConstructionPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_ECONOMICS, 0)
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_SHIPS, calculateShipsPriority())
foAI.foAIstate.set_priority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_DEFENSE, 0)
prioritiees_timer.end()
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 calculate_priorities():
"""Calculates the priorities of the AI player."""
print "\n", 10 * "=", "Preparing to Calculate Priorities", 10 * "="
prioritiees_timer.start('setting Production Priority')
foAI.foAIstate.set_priority(PriorityType.RESOURCE_PRODUCTION, 50) # let this one stay fixed & just adjust Research
print "\n*** Calculating Research Priority ***\n"
prioritiees_timer.start('setting Research Priority')
foAI.foAIstate.set_priority(PriorityType.RESOURCE_RESEARCH, _calculate_research_priority()) # TODO: do univ _survey before this
print "\n*** Updating Colonization Status ***\n"
prioritiees_timer.start('Evaluating Colonization Status')
ColonisationAI.get_colony_fleets() # sets foAI.foAIstate.colonisablePlanetIDs and many other values used by other modules
print "\n*** Updating Invasion Status ***\n"
prioritiees_timer.start('Evaluating Invasion Status')
InvasionAI.get_invasion_fleets() # sets AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
print "\n*** Updating Military Status ***\n"
prioritiees_timer.start('Evaluating Military Status')
MilitaryAI.get_military_fleets()
print("\n** Calculating Production Priorities ***\n")
prioritiees_timer.start('reporting Production Priority')
_calculate_industry_priority() # purely for reporting purposes
prioritiees_timer.start('setting Exploration Priority')
foAI.foAIstate.set_priority(PriorityType.RESOURCE_TRADE, 0)
foAI.foAIstate.set_priority(PriorityType.RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_EXPLORATION, _calculate_exploration_priority())
prioritiees_timer.start('setting Colony Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_COLONISATION, _calculate_colonisation_priority())
prioritiees_timer.start('setting Outpost Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_OUTPOST, _calculate_outpost_priority())
prioritiees_timer.start('setting Invasion Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_INVASION, _calculate_invasion_priority())
prioritiees_timer.start('setting Military Priority')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_MILITARY, _calculate_military_priority())
prioritiees_timer.start('setting other priorities')
foAI.foAIstate.set_priority(PriorityType.PRODUCTION_BUILDINGS, 25)
prioritiees_timer.stop_print_and_clear()
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 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 _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 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 convert_to_version(state, version):
"""Convert a savegame AIstate to the next version.
:param dict state: savegame state, modified in function
:param int version: Version to convert to
"""
debug("Trying to convert savegame state to version %d..." % version)
current_version = state.get("version", -1)
debug(" Current version: %d" % current_version)
if current_version == version:
raise ConversionError("Can't convert AI savegame to the same compatibility version.")
if current_version > version:
raise ConversionError("Can't convert AI savegame to an older compatibility version.")
if version != current_version + 1:
raise ConversionError("Can't skip a compatibility version when converting AI savegame.")
# Starting with version 3, we switched from pickle to json-style encoding
# Do not try to load an older savegame even if it magically passed the encoder.
if version <= 3:
raise ConversionError("The AI savegame version is no longer supported.")
if version == 4:
del state['qualifyingOutpostBaseTargets']
del state['qualifyingColonyBaseTargets']
state['orbital_colonization_manager'] = ColonisationAI.OrbitalColonizationManager()
if version == 5:
state['last_turn_played'] = 0
# state["some_new_member"] = some_default_value
# del state["some_removed_member"]
# state["list_changed_to_set"] = set(state["list_changed_to_set"])
debug(" All updates set. Setting new version number.")
state["version"] = version
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 evaluate_invasion_planet(planet_id, empire, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
detail = []
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
# TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empire_id = empire.empireID
max_jumps = 8
planet = universe.getPlanet(planet_id)
if planet is None: # TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d" % planet_id
return [0, 0]
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet_id, empire_id).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn < sys_partial_vis_turn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
# TODO: track detection strength, order new scouting when it goes up
return [0, 0] # last time we had partial vis of the system, the planet was stealthed to us
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species: # this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, None, empire, detail)
pop_val = max(0.75*planet_eval.get(planet_id, [0])[0], ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST, None, empire, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, species_name, empire, detail)
bld_tally = 0
for bldType in [universe.getObject(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
p_sys_id = planet.systemID
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = planet.systemID
if (home_system_id != -1) and (eval_system_id != -1):
least_jumps_path = list(universe.leastJumpsPath(home_system_id, eval_system_id, empire_id))
max_jumps = len(least_jumps_path)
system_status = foAI.foAIstate.systemStatus.get(p_sys_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
this_system = universe.getSystem(p_sys_id)
secure_targets = [p_sys_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.target_id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
for ai_target in mission.get_targets(EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE):
target_obj = ai_target.target_obj
if (target_obj is not None) and target_obj.id in secure_targets:
system_secured = True
break
if verbose:
print "invasion eval of %s %d --- maxShields %.1f -- sysFleetThreat %.1f -- sysMonsterThreat %.1f" % (
planet.name, planet_id, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat,
system_monster_threat)
supply_val = 0
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) + 2*planet.currentMeterValue(fo.meterType.targetResearch))
if p_sys_id in ColonisationAI.annexable_system_ids: # TODO: extend to rings
supply_val = 100
elif p_sys_id in ColonisationAI.annexable_ring1:
supply_val = 200
elif p_sys_id in ColonisationAI.annexable_ring2:
supply_val = 300
elif p_sys_id in ColonisationAI.annexable_ring3:
supply_val = 400
if max_path_threat > 0.5 * mil_ship_rating:
if max_path_threat < 3 * mil_ship_rating:
supply_val *= 0.5
else:
supply_val *= 0.2
threat_factor = min(1, 0.2*MilitaryAI.totMilRating/(sys_total_threat+0.001))**2 # devalue invasions that would require too much military force
build_time = 4
planned_troops = troops if system_secured else min(troops+max_jumps+build_time, max_troops)
if not tech_is_complete("SHP_ORG_HULL"):
troop_cost = math.ceil(planned_troops/6.0) * (40*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
else:
troop_cost = math.ceil(planned_troops/6.0) * (20*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, pop_val+supply_val+bld_tally+enemy_val-0.8*troop_cost)
if clear_path:
planet_score *= 1.5
invasion_score = [planet_score, planned_troops]
print invasion_score, "projected Troop Cost:", troop_cost, ", threatFactor: ", threat_factor, ", planet detail ", detail, "popval, supplyval, bldval, enemyval", pop_val, supply_val, bld_tally, enemy_val
return invasion_score
def evaluate_invasion_planet(planet_id, empire, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
detail = []
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
# TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empire_id = empire.empireID
max_jumps = 8
planet = universe.getPlanet(planet_id)
if planet is None: # TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d" % planet_id
return [0, 0]
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet_id, empire_id).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn < sys_partial_vis_turn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
# TODO: track detection strength, order new scouting when it goes up
return [0, 0] # last time we had partial vis of the system, the planet was stealthed to us
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species: # this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, None, empire, detail)
pop_val = max(0.75*planet_eval.get(planet_id, [0])[0], ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST, None, empire, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, EnumsAI.AIFleetMissionType.FLEET_MISSION_INVASION, species_name, empire, detail)
bld_tally = 0
for bldType in [universe.getObject(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
p_sys_id = planet.systemID
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = planet.systemID
if (home_system_id != -1) and (eval_system_id != -1):
least_jumps_path = list(universe.leastJumpsPath(home_system_id, eval_system_id, empire_id))
max_jumps = len(least_jumps_path)
system_status = foAI.foAIstate.systemStatus.get(p_sys_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(p_sys_id)
secure_targets = [p_sys_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.target_id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
for ai_target in mission.get_targets(EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE):
target_obj = ai_target.target_obj
if (target_obj is not None) and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating',0)
if verbose:
print "invasion eval of %s %d --- maxShields %.1f -- sysFleetThreat %.1f -- sysMonsterThreat %.1f" % (
planet.name, planet_id, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat,
system_monster_threat)
supply_val = 0
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) + 2*planet.currentMeterValue(fo.meterType.targetResearch))
if p_sys_id in ColonisationAI.annexable_system_ids: # TODO: extend to rings
supply_val = 100
elif p_sys_id in ColonisationAI.annexable_ring1:
supply_val = 200
elif p_sys_id in ColonisationAI.annexable_ring2:
supply_val = 300
elif p_sys_id in ColonisationAI.annexable_ring3:
supply_val = 400
if max_path_threat > 0.5 * mil_ship_rating:
if max_path_threat < 3 * mil_ship_rating:
supply_val *= 0.5
else:
supply_val *= 0.2
threat_factor = min(1, 0.2*MilitaryAI.totMilRating/(sys_total_threat+0.001))**2 # devalue invasions that would require too much military force
build_time = 4
planned_troops = troops if system_secured else min(troops+max_jumps+build_time, max_troops)
if not tech_is_complete("SHP_ORG_HULL"):
troop_cost = math.ceil(planned_troops/6.0) * (40*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
else:
troop_cost = math.ceil(planned_troops/6.0) * (20*(1+foAI.foAIstate.shipCount * AIDependencies.SHIP_UPKEEP))
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, pop_val+supply_val+bld_tally+enemy_val-0.8*troop_cost)
if clear_path:
planet_score *= 1.5
invasion_score = [planet_score, planned_troops]
print invasion_score, "projected Troop Cost:", troop_cost, ", threatFactor: ", threat_factor, ", planet detail ", detail, "popval, supplyval, bldval, enemyval", pop_val, supply_val, bld_tally, enemy_val
return invasion_score
def generateOrders():
global lastTurnTimestamp
universe = fo.getUniverse()
turnStartTime=time() #starting AI timer here, to be sure AI doesn't get blame for any lags in server being able to provide the Universe object
empire = fo.getEmpire()
planetID = PlanetUtilsAI.getCapital()
planet=None
if planetID is not None:
planet = universe.getPlanet(planetID)
print "***************************************************************************"
print "***************************************************************************"
print ("Generating Orders")
print "EmpireID: " + str(empire.empireID) + " Name: " + empire.name+ "_"+str(empire.empireID-1) +"_pid:"+str(fo.playerID())+"_"+fo.playerName()+"_"+aggressions.get(foAIstate.aggression, "?") + " Turn: " + str(fo.currentTurn())
empireColor=empire.colour
print "EmpireColors: %d %d %d %d"%(empireColor.r, empireColor.g, empireColor.b, empireColor.a)
if planet:
print "CapitalID: " + str(planetID) + " Name: " + planet.name + " Species: " + planet.speciesName
else:
print "CapitalID: None Currently Name: None Species: None "
print "***************************************************************************"
print "***************************************************************************"
if fo.currentTurn() == 1:
declareWarOnAll()
# turn cleanup !!! this was formerly done at start of every turn -- not sure why
splitNewFleets()
#updateShipDesigns() #should not be needed anymore;
#updateFleetsRoles()
foAIstate.clean() #checks exploration border & clears roles/missions of missing fleets & updates fleet locs
foAIstate.reportSystemThreats()
# ...missions
# ...demands/priorities
print("Calling AI Modules")
# call AI modules
timer=[time()]
try: PriorityAI.calculatePriorities()
except: print "Error: exception triggered and caught: ", traceback.format_exc() # try traceback.print_exc()
timer.append( time() )
try: ExplorationAI.assignScoutsToExploreSystems()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ColonisationAI.assignColonyFleetsToColonise()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: InvasionAI.assignInvasionFleetsToInvade()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: MilitaryAI.assignMilitaryFleetsToSystems()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ResearchAI.generateResearchOrders()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ProductionAI.generateProductionOrders()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: ResourcesAI.generateResourcesOrders()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
try: foAIstate.afterTurnCleanup()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
timer.append( time() )
times = [timer[i] - timer[i-1] for i in range(1, len(timer) ) ]
turnEndTime=time()
timeFmt = "%30s: %8d msec "
print "AI Module Time Requirements:"
for mod, modTime in zip(__timerEntries, times):
print timeFmt%((30*' '+mod)[-30:], int(1000*modTime))
if __timerFile:
__timerFile.write( __timerFileFmt%tuple( [ fo.currentTurn() ]+map(lambda x: int(1000*x), times )) +'\n')
__timerFile.flush()
if __timerBucketFile:
__timerBucketFile.write( __timerBucketFileFmt%tuple( [ fo.currentTurn(), (turnStartTime-lastTurnTimestamp)*1000, (turnEndTime-turnStartTime)*1000 ]) +'\n')
__timerBucketFile.flush()
lastTurnTimestamp = time()
try: fo.doneTurn()
except: print "Error: exception triggered and caught: ", traceback.format_exc()
def evaluate_invasion_planet(planet_id, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
detail = []
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
# TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empire_id = fo.empireID()
max_jumps = 8
planet = universe.getPlanet(planet_id)
if planet is None: # TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d" % planet_id
return [0, 0]
sys_partial_vis_turn = universe.getVisibilityTurnsMap(planet.systemID, empire_id).get(fo.visibility.partial, -9999)
planet_partial_vis_turn = universe.getVisibilityTurnsMap(planet_id, empire_id).get(fo.visibility.partial, -9999)
if planet_partial_vis_turn < sys_partial_vis_turn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
# TODO: track detection strength, order new scouting when it goes up
return [0, 0] # last time we had partial vis of the system, the planet was stealthed to us
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], MissionType.INVASION, None, detail)
pop_val = max(0.75 * planet_eval.get(planet_id, [0])[0],
ColonisationAI.evaluate_planet(planet_id, MissionType.OUTPOST, None, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, MissionType.INVASION, species_name, detail)
bld_tally = 0
for bldType in [universe.getBuilding(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
tech_tally = 0
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_tally += rp_cost * 4
detail.append("%s: %d" % (unlocked_tech, rp_cost * 4))
p_sys_id = planet.systemID
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = planet.systemID
if (home_system_id != INVALID_ID) and (eval_system_id != INVALID_ID):
least_jumps_path = list(universe.leastJumpsPath(home_system_id, eval_system_id, empire_id))
max_jumps = len(least_jumps_path)
system_status = foAI.foAIstate.systemStatus.get(p_sys_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(p_sys_id)
secure_targets = [p_sys_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
if mission.type == MissionType.SECURE:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating', 0)
if verbose:
print ("Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f") % (
planet, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat,
system_monster_threat)
supply_val = 0
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) + 2*planet.currentMeterValue(fo.meterType.targetResearch))
if p_sys_id in ColonisationAI.annexable_system_ids: # TODO: extend to rings
supply_val = 100
elif p_sys_id in ColonisationAI.annexable_ring1:
supply_val = 200
elif p_sys_id in ColonisationAI.annexable_ring2:
supply_val = 300
elif p_sys_id in ColonisationAI.annexable_ring3:
supply_val = 400
if max_path_threat > 0.5 * mil_ship_rating:
if max_path_threat < 3 * mil_ship_rating:
supply_val *= 0.5
else:
supply_val *= 0.2
threat_factor = min(1, 0.2*MilitaryAI.get_tot_mil_rating()/(sys_total_threat+0.001))**2 # devalue invasions that would require too much military force
design_id, _, locs = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / 6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(design.troopCapacity,
CombatRatingsAI.get_species_troops_grade(species_here))
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
ships_needed = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints, 1)
normalized_cost = max(1, normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = pop_val + supply_val + bld_tally + tech_tally + enemy_val - cost_score
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, base_score)
if clear_path:
planet_score *= 1.5
if verbose:
print (' - planet score: %.2f\n'
' - troop score: %.2f\n'
' - projected troop cost: %.1f\n'
' - threat factor: %s\n'
' - planet detail: %s\n'
' - popval: %.1f\n'
' - supplyval: %.1f\n'
' - bldval: %s\n'
' - enemyval: %s') % (planet_score, planned_troops, troop_cost,
threat_factor, detail, pop_val, supply_val, bld_tally, enemy_val)
return [planet_score, planned_troops]
def calculatePriorities():
"calculates the priorities of the AI player"
print("checking statuses")
# Industry, Research, Colony, Invasion, Military
times=[]
tasks = []
times.append( time() )
tasks.append("init")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_PRODUCTION, 50) # let this one stay fixed & just adjust Research
times.append( time() )
tasks.append( "setting Production Priority" )
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_RESEARCH, calculateResearchPriority())
times.append( time() )
tasks.append( "setting Research Priority")
ColonisationAI.getColonyFleets() # sets foAI.foAIstate.colonisablePlanetIDs and foAI.foAIstate.outpostPlanetIDs and many other values used by other modules
times.append( time() )
tasks.append( "Evaluating Colonization Status")
InvasionAI.getInvasionFleets() # sets AIstate.invasionFleetIDs, AIstate.opponentPlanetIDs, and AIstate.invasionTargetedPlanetIDs
times.append( time() )
tasks.append( "Evaluating Invasion Status")
MilitaryAI.getMilitaryFleets() # sets AIstate.militaryFleetIDs and AIstate.militaryTargetedSystemIDs
times.append( time() )
tasks.append( "Evaluating Military Status")
print("calculating priorities")
calculateIndustryPriority()#purely for reporting purposes
times.append( time() )
tasks.append( "reporting Production Priority")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_TRADE, 0)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_CONSTRUCTION, 0)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_EXPLORATION, calculateExplorationPriority())
times.append( time() )
tasks.append( "setting Exploration Priority")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_OUTPOST, calculateOutpostPriority())
times.append( time() )
tasks.append( "setting Outpost Priority")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_COLONISATION, calculateColonisationPriority())
times.append( time() )
tasks.append( "setting Colony Priority")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_INVASION, calculateInvasionPriority())
times.append( time() )
tasks.append( "setting Invasion Priority")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_MILITARY, calculateMilitaryPriority())
times.append( time() )
tasks.append( "setting Military Priority")
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_PRODUCTION_BUILDINGS, 25)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_LEARNING, calculateLearningPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_GROWTH, calculateGrowthPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_PRODUCTION, calculateTechsProductionPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_CONSTRUCTION, calculateConstructionPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_ECONOMICS, 0)
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_SHIPS, calculateShipsPriority())
foAI.foAIstate.setPriority(EnumsAI.AIPriorityType.PRIORITY_RESEARCH_DEFENSE, 0)
times.append( time() )
tasks.append( "total processing")
for t_index in range(1, len(times)-1):
print "calculatePriorities(): %40s took %d msec"%(tasks[t_index], int(1000*(times[t_index]-times[t_index-1])))
print "calculatePriorities(): %40s took %d msec"%(tasks[-1], int(1000*(times[-1]-times[0])))
def generate_research_orders():
"""generate research orders"""
report_adjustments = False
empire = fo.getEmpire()
empire_id = empire.empireID
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
print "Research Queue Management:"
resource_production = empire.resourceProduction(fo.resourceType.research)
print "\nTotal Current Research Points: %.2f\n" % resource_production
print "Techs researched and available for use:"
completed_techs = sorted(list(get_completed_techs()))
tlist = completed_techs+3*[" "]
tlines = zip(tlist[0::3], tlist[1::3], tlist[2::3])
for tline in tlines:
print "%25s %25s %25s" % tline
print
#
# report techs currently at head of research queue
#
research_queue = empire.researchQueue
research_queue_list = get_research_queue_techs()
inProgressTechs.clear()
tech_turns_left = {}
if research_queue_list:
print "Techs currently at head of Research Queue:"
for element in list(research_queue)[:10]:
tech_turns_left[element.tech] = element.turnsLeft
if element.allocation > 0.0:
inProgressTechs[element.tech] = True
this_tech = fo.getTech(element.tech)
if not this_tech:
print "Error: can't retrieve tech ", element.tech
continue
missing_prereqs = [preReq for preReq in this_tech.recursivePrerequisites(empire_id) if preReq not in completed_techs]
# unlocked_items = [(uli.name, uli.type) for uli in this_tech.unlocked_items]
unlocked_items = [uli.name for uli in this_tech.unlockedItems]
if not missing_prereqs:
print " %25s allocated %6.2f RP -- unlockable items: %s " % (element.tech, element.allocation, unlocked_items)
else:
print " %25s allocated %6.2f RP -- missing preReqs: %s -- unlockable items: %s " % (element.tech, element.allocation, missing_prereqs, unlocked_items)
print
#
# set starting techs, or after turn 100 add any additional default techs
#
if (fo.currentTurn() == 1) or ((fo.currentTurn() < 5) and (len(research_queue_list) == 0)):
research_index = get_research_index()
new_tech = TechsListsAI.sparse_galaxy_techs(research_index) if galaxy_is_sparse else TechsListsAI.primary_meta_techs(research_index)
print "Empire %s (%d) is selecting research index %d" % (empire.name, empire_id, research_index)
# techs_to_enqueue = (set(new_tech)-(set(completed_techs)|set(research_queue_list)))
techs_to_enqueue = new_tech[:]
tech_base = set(completed_techs+research_queue_list)
techs_to_add = []
for tech in techs_to_enqueue:
if tech not in tech_base:
this_tech = fo.getTech(tech)
if this_tech is None:
print "Error: desired tech '%s' appears to not exist" % tech
continue
missing_prereqs = [preReq for preReq in this_tech.recursivePrerequisites(empire_id) if preReq not in tech_base]
techs_to_add.extend(missing_prereqs + [tech])
tech_base.update(missing_prereqs+[tech])
cum_cost = 0
print " Enqueued Tech: %20s \t\t %8s \t %s" % ("Name", "Cost", "CumulativeCost")
for name in techs_to_add:
try:
enqueue_res = fo.issueEnqueueTechOrder(name, -1)
if enqueue_res == 1:
this_tech = fo.getTech(name)
this_cost = 0
if this_tech:
this_cost = this_tech.researchCost(empire_id)
cum_cost += this_cost
print " Enqueued Tech: %20s \t\t %8.0f \t %8.0f" % (name, this_cost, cum_cost)
else:
print " Error: failed attempt to enqueued Tech: " + name
except:
print " Error: failed attempt to enqueued Tech: " + name
print " Error: exception triggered and caught: ", traceback.format_exc()
if foAI.foAIstate.aggression <= fo.aggression.cautious:
research_queue_list = get_research_queue_techs()
def_techs = TechsListsAI.defense_techs_1()
for def_tech in def_techs:
if def_tech not in research_queue_list[:5] and not tech_is_complete(def_tech):
res = fo.issueEnqueueTechOrder(def_tech, min(3, len(research_queue_list)))
print "Empire is very defensive, so attempted to fast-track %s, got result %d" % (def_tech, res)
if False and foAI.foAIstate.aggression >= fo.aggression.aggressive: # with current stats of Conc Camps, disabling this fast-track
research_queue_list = get_research_queue_techs()
if "CON_CONC_CAMP" in research_queue_list:
insert_idx = min(40, research_queue_list.index("CON_CONC_CAMP"))
else:
insert_idx = max(0, min(40, len(research_queue_list)-10))
if "SHP_DEFLECTOR_SHIELD" in research_queue_list:
insert_idx = min(insert_idx, research_queue_list.index("SHP_DEFLECTOR_SHIELD"))
for cc_tech in ["CON_ARCH_PSYCH", "CON_CONC_CAMP"]:
if cc_tech not in research_queue_list[:insert_idx + 1] and not tech_is_complete(cc_tech):
res = fo.issueEnqueueTechOrder(cc_tech, insert_idx)
msg = "Empire is very aggressive, so attempted to fast-track %s, got result %d" % (cc_tech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
print""
generate_default_research_order()
print "\n\nAll techs:"
alltechs = fo.techs() # returns names of all techs
for tname in alltechs:
print tname
print "\n-------------------------------\nAll unqueued techs:"
# coveredTechs = new_tech+completed_techs
for tname in [tn for tn in alltechs if tn not in tech_base]:
print tname
elif fo.currentTurn() > 100:
generate_default_research_order()
research_queue_list = get_research_queue_techs()
num_techs_accelerated = 1 # will ensure leading tech doesn't get dislodged
got_ggg_tech = tech_is_complete("PRO_ORBITAL_GEN")
got_sym_bio = tech_is_complete("GRO_SYMBIOTIC_BIO")
got_xeno_gen = tech_is_complete("GRO_XENO_GENETICS")
#
# Consider accelerating techs; priority is
# Supply/Detect range
# xeno arch
# ast / GG
# gro xeno gen
# distrib thought
# quant net
# pro sing gen
# death ray 1 cleanup
#
# Supply range and detection range
if False: # disabled for now, otherwise just to help with cold-folding / organization
if len(foAI.foAIstate.colonisablePlanetIDs) == 0:
best_colony_site_score = 0
else:
best_colony_site_score = foAI.foAIstate.colonisablePlanetIDs.items()[0][1]
if len(foAI.foAIstate.colonisableOutpostIDs) == 0:
best_outpost_site_score = 0
else:
best_outpost_site_score = foAI.foAIstate.colonisableOutpostIDs.items()[0][1]
need_improved_scouting = (best_colony_site_score < 150 or best_outpost_site_score < 200)
if need_improved_scouting:
if not tech_is_complete("CON_ORBITAL_CON"):
num_techs_accelerated += 1
if ("CON_ORBITAL_CON" not in research_queue_list[:1 + num_techs_accelerated]) and (
tech_is_complete("PRO_FUSION_GEN") or ("PRO_FUSION_GEN" in research_queue_list[:1 + num_techs_accelerated])):
res = fo.issueEnqueueTechOrder("CON_ORBITAL_CON", num_techs_accelerated)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % ("CON_ORBITAL_CON", res)
if report_adjustments:
chat_human(msg)
else:
print msg
elif not tech_is_complete("CON_CONTGRAV_ARCH"):
num_techs_accelerated += 1
if ("CON_CONTGRAV_ARCH" not in research_queue_list[:1+num_techs_accelerated]) and (
tech_is_complete("CON_METRO_INFRA")):
for supply_tech in [_s_tech for _s_tech in ["CON_ARCH_MONOFILS", "CON_CONTGRAV_ARCH"] if not tech_is_complete(_s_tech)]:
res = fo.issueEnqueueTechOrder(supply_tech, num_techs_accelerated)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % (supply_tech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
elif not tech_is_complete("CON_GAL_INFRA"):
num_techs_accelerated += 1
if ("CON_GAL_INFRA" not in research_queue_list[:1+num_techs_accelerated]) and (
tech_is_complete("PRO_SINGULAR_GEN")):
res = fo.issueEnqueueTechOrder("CON_GAL_INFRA", num_techs_accelerated)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % ("CON_GAL_INFRA", res)
if report_adjustments:
chat_human(msg)
else:
print msg
else:
pass
research_queue_list = get_research_queue_techs()
# could add more supply tech
if False and not tech_is_complete("SPY_DETECT_2"): # disabled for now, detect2
num_techs_accelerated += 1
if "SPY_DETECT_2" not in research_queue_list[:2+num_techs_accelerated] and tech_is_complete("PRO_FUSION_GEN"):
if "CON_ORBITAL_CON" not in research_queue_list[:1+num_techs_accelerated]:
res = fo.issueEnqueueTechOrder("SPY_DETECT_2", num_techs_accelerated)
else:
co_idx = research_queue_list.index("CON_ORBITAL_CON")
res = fo.issueEnqueueTechOrder("SPY_DETECT_2", co_idx + 1)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % ("CON_ORBITAL_CON", res)
if report_adjustments:
chat_human(msg)
else:
print msg
research_queue_list = get_research_queue_techs()
#
# check to accelerate xeno_arch
if True: # just to help with cold-folding / organization
if (ColonisationAI.gotRuins and not tech_is_complete("LRN_XENOARCH") and
foAI.foAIstate.aggression >= fo.aggression.typical):
if "LRN_ARTIF_MINDS" in research_queue_list:
insert_idx = 7 + research_queue_list.index("LRN_ARTIF_MINDS")
elif "GRO_SYMBIOTIC_BIO" in research_queue_list:
insert_idx = research_queue_list.index("GRO_SYMBIOTIC_BIO") + 1
else:
insert_idx = num_techs_accelerated
if "LRN_XENOARCH" not in research_queue_list[:insert_idx]:
for xenoTech in ["LRN_XENOARCH", "LRN_TRANSLING_THT", "LRN_PHYS_BRAIN", "LRN_ALGO_ELEGANCE"]:
if not tech_is_complete(xenoTech) and xenoTech not in research_queue_list[:(insert_idx + 4)]:
res = fo.issueEnqueueTechOrder(xenoTech, insert_idx)
num_techs_accelerated += 1
msg = "ANCIENT_RUINS: have an ancient ruins, so attempted to fast-track %s to enable LRN_XENOARCH, got result %d" % (xenoTech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
research_queue_list = get_research_queue_techs()
if False and not enemies_sighted: # curently disabled
# params = [ (tech, gate, target_slot, add_tech_list), ]
params = [("GRO_XENO_GENETICS", "PRO_EXOBOTS", "PRO_EXOBOTS", ["GRO_GENETIC_MED", "GRO_XENO_GENETICS"]),
("PRO_EXOBOTS", "PRO_SENTIENT_AUTOMATION", "PRO_SENTIENT_AUTOMATION", ["PRO_EXOBOTS"]),
("PRO_SENTIENT_AUTOMATION", "PRO_NANOTECH_PROD", "PRO_NANOTECH_PROD", ["PRO_SENTIENT_AUTOMATION"]),
("PRO_INDUSTRY_CENTER_I", "GRO_SYMBIOTIC_BIO", "GRO_SYMBIOTIC_BIO", ["PRO_ROBOTIC_PROD", "PRO_FUSION_GEN", "PRO_INDUSTRY_CENTER_I"]),
("GRO_SYMBIOTIC_BIO", "SHP_ORG_HULL", "SHP_ZORTRIUM_PLATE", ["GRO_SYMBIOTIC_BIO"]),
]
for (tech, gate, target_slot, add_tech_list) in params:
if tech_is_complete(tech):
break
if tech_turns_left.get(gate, 0) not in [0, 1, 2]: # needs to exclude -1, the flag for no predicted completion
continue
if target_slot in research_queue_list:
target_index = 1 + research_queue_list.index(target_slot)
else:
target_index = num_techs_accelerated
for move_tech in add_tech_list:
print "for tech %s, target_slot %s, target_index:%s ; num_techs_accelerated:%s" % (move_tech, target_slot, target_index, num_techs_accelerated)
if tech_is_complete(move_tech):
continue
if target_index <= num_techs_accelerated:
num_techs_accelerated += 1
if move_tech not in research_queue_list[:1 + target_index]:
res = fo.issueEnqueueTechOrder(move_tech, target_index)
msg = "Research: To prioritize %s, have advanced %s to slot %d" % (tech, move_tech, target_index)
if report_adjustments:
chat_human(msg)
else:
print msg
target_index += 1
#
# check to accelerate asteroid or GG tech
if True: # just to help with cold-folding / organization
if ColonisationAI.got_ast:
insert_idx = num_techs_accelerated if "GRO_SYMBIOTIC_BIO" not in research_queue_list else research_queue_list.index("GRO_SYMBIOTIC_BIO")
ast_tech = "PRO_MICROGRAV_MAN"
if not (tech_is_complete(ast_tech) or ast_tech in research_queue_list[:(1 + insert_idx)]):
res = fo.issueEnqueueTechOrder(ast_tech, insert_idx)
num_techs_accelerated += 1
msg = "Asteroids: plan to colonize an asteroid belt, so attempted to fast-track %s , got result %d" % (ast_tech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
research_queue_list = get_research_queue_techs()
elif tech_is_complete("SHP_ZORTRIUM_PLATE"):
insert_idx = (1 + insert_idx) if "LRN_FORCE_FIELD" not in research_queue_list else max(1 + insert_idx, research_queue_list.index("LRN_FORCE_FIELD") - 1)
for ast_tech in ["SHP_ASTEROID_HULLS", "SHP_IMPROVED_ENGINE_COUPLINGS"]:
if not tech_is_complete(ast_tech) and ast_tech not in research_queue_list[:insert_idx + 1]:
res = fo.issueEnqueueTechOrder(ast_tech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
msg = "Asteroids: plan to colonize an asteroid belt, so attempted to fast-track %s , got result %d" % (ast_tech, res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
if ColonisationAI.got_gg and not tech_is_complete("PRO_ORBITAL_GEN"):
fusion_idx = 0 if "PRO_FUSION_GEN" not in research_queue_list else (1 + research_queue_list.index("PRO_FUSION_GEN"))
forcefields_idx = 0 if "LRN_FORCE_FIELD" not in research_queue_list else (1 + research_queue_list.index("LRN_FORCE_FIELD"))
insert_idx = max(fusion_idx, forcefields_idx) if enemies_sighted else fusion_idx
if "PRO_ORBITAL_GEN" not in research_queue_list[:insert_idx+1]:
res = fo.issueEnqueueTechOrder("PRO_ORBITAL_GEN", insert_idx)
num_techs_accelerated += 1
msg = "GasGiant: plan to colonize a gas giant, so attempted to fast-track %s, got result %d" % ("PRO_ORBITAL_GEN", res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# assess if our empire has any non-lousy colonizers, & boost gro_xeno_gen if we don't
if True: # just to help with cold-folding / organization
if got_ggg_tech and got_sym_bio and (not got_xeno_gen) and foAI.foAIstate.aggression >= fo.aggression.cautious:
most_adequate = 0
for specName in ColonisationAI.empire_colonizers:
environs = {}
this_spec = fo.getSpecies(specName)
if not this_spec:
continue
for ptype in [fo.planetType.swamp, fo.planetType.radiated, fo.planetType.toxic, fo.planetType.inferno, fo.planetType.barren, fo.planetType.tundra, fo.planetType.desert, fo.planetType.terran, fo.planetType.ocean, fo.planetType.asteroids]:
environ = this_spec.getPlanetEnvironment(ptype)
environs.setdefault(environ, []).append(ptype)
most_adequate = max(most_adequate, len(environs.get(fo.planetEnvironment.adequate, [])))
if most_adequate == 0:
insert_idx = num_techs_accelerated
for xg_tech in ["GRO_XENO_GENETICS", "GRO_GENETIC_ENG"]:
if xg_tech not in research_queue_list[:1+num_techs_accelerated] and not tech_is_complete(xg_tech):
res = fo.issueEnqueueTechOrder(xg_tech, insert_idx)
num_techs_accelerated += 1
msg = "Empire has poor colonizers, so attempted to fast-track %s, got result %d" % (xg_tech, res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# check to accelerate distrib thought
if True: # just to help with cold-folding / organization
if not tech_is_complete("LRN_DISTRIB_THOUGHT"):
got_telepathy = False
for specName in ColonisationAI.empire_species:
this_spec = fo.getSpecies(specName)
if this_spec and ("TELEPATHIC" in list(this_spec.tags)):
got_telepathy = True
break
if (foAI.foAIstate.aggression > fo.aggression.cautious) and (empire.population() > ([300, 100][got_telepathy])):
insert_idx = num_techs_accelerated
for dt_ech in ["LRN_PHYS_BRAIN", "LRN_TRANSLING_THT", "LRN_PSIONICS", "LRN_DISTRIB_THOUGHT"]:
if dt_ech not in research_queue_list[:insert_idx + 2] and not tech_is_complete(dt_ech):
res = fo.issueEnqueueTechOrder(dt_ech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
fmt_str = "Empire has a telepathic race, so attempted to fast-track %s (got result %d)"
fmt_str += " with current target_RP %.1f and current pop %.1f, on turn %d"
msg = fmt_str % (dt_ech, res, resource_production, empire.population(), fo.currentTurn())
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# check to accelerate quant net
if False: # disabled for now, otherwise just to help with cold-folding / organization
if (foAI.foAIstate.aggression > fo.aggression.cautious) and (ColonisationAI.empire_status.get('researchers', 0) >= 40):
if not tech_is_complete("LRN_QUANT_NET"):
insert_idx = num_techs_accelerated # TODO determine min target slot if reenabling
for qnTech in ["LRN_NDIM_SUBSPACE", "LRN_QUANT_NET"]:
if qnTech not in research_queue_list[:insert_idx + 2] and not tech_is_complete(qnTech):
res = fo.issueEnqueueTechOrder(qnTech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
msg = "Empire has many researchers, so attempted to fast-track %s (got result %d) on turn %d" % (qnTech, res, fo.currentTurn())
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# if we own a blackhole, accelerate sing_gen and conc camp
if True: # just to help with cold-folding / organization
if (fo.currentTurn() > 50 and len(AIstate.empireStars.get(fo.starType.blackHole, [])) != 0 and
foAI.foAIstate.aggression > fo.aggression.cautious and not tech_is_complete(AIDependencies.PRO_SINGULAR_GEN) and
tech_is_complete(AIDependencies.PRO_SOL_ORB_GEN)):
# sing_tech_list = [ "LRN_GRAVITONICS" , "PRO_SINGULAR_GEN"] # formerly also "CON_ARCH_PSYCH", "CON_CONC_CAMP",
sing_gen_tech = fo.getTech(AIDependencies.PRO_SINGULAR_GEN)
sing_tech_list = [pre_req for pre_req in sing_gen_tech.recursivePrerequisites(empire_id) if not tech_is_complete(pre_req)]
sing_tech_list += [AIDependencies.PRO_SINGULAR_GEN]
for singTech in sing_tech_list:
if singTech not in research_queue_list[:num_techs_accelerated+1]:
res = fo.issueEnqueueTechOrder(singTech, num_techs_accelerated)
num_techs_accelerated += 1
msg = "have a black hole star outpost/colony, so attempted to fast-track %s, got result %d" % (singTech, res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# if got deathray from Ruins, remove most prereqs from queue
if True: # just to help with cold-folding / organization
if tech_is_complete("SHP_WEAPON_4_1"):
this_tech = fo.getTech("SHP_WEAPON_4_1")
if this_tech:
missing_prereqs = [preReq for preReq in this_tech.recursivePrerequisites(empire_id) if preReq in research_queue_list]
if len(missing_prereqs) > 2: # leave plasma 4 and 3 if up to them already
for preReq in missing_prereqs: # sorted(missing_prereqs, reverse=True)[2:]
if preReq in research_queue_list:
fo.issueDequeueTechOrder(preReq)
research_queue_list = get_research_queue_techs()
if "SHP_WEAPON_4_2" in research_queue_list: # (should be)
idx = research_queue_list.index("SHP_WEAPON_4_2")
fo.issueEnqueueTechOrder("SHP_WEAPON_4_2", max(0, idx-18))
def generate_research_orders():
"""generate research orders"""
report_adjustments = False
empire = fo.getEmpire()
empire_id = empire.empireID
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
print "Research Queue Management:"
resource_production = empire.resourceProduction(fo.resourceType.research)
print "\nTotal Current Research Points: %.2f\n" % resource_production
print "Techs researched and available for use:"
completed_techs = sorted(list(get_completed_techs()))
tlist = completed_techs + 3 * [" "]
tlines = zip(tlist[0::3], tlist[1::3], tlist[2::3])
for tline in tlines:
print "%25s %25s %25s" % tline
print
#
# report techs currently at head of research queue
#
research_queue = empire.researchQueue
research_queue_list = get_research_queue_techs()
inProgressTechs.clear()
tech_turns_left = {}
if research_queue_list:
print "Techs currently at head of Research Queue:"
for element in list(research_queue)[:10]:
tech_turns_left[element.tech] = element.turnsLeft
if element.allocation > 0.0:
inProgressTechs[element.tech] = True
this_tech = fo.getTech(element.tech)
if not this_tech:
print "Error: can't retrieve tech ", element.tech
continue
missing_prereqs = [
preReq
for preReq in this_tech.recursivePrerequisites(empire_id)
if preReq not in completed_techs
]
# unlocked_items = [(uli.name, uli.type) for uli in this_tech.unlocked_items]
unlocked_items = [uli.name for uli in this_tech.unlockedItems]
if not missing_prereqs:
print " %25s allocated %6.2f RP -- unlockable items: %s " % (
element.tech, element.allocation, unlocked_items)
else:
print " %25s allocated %6.2f RP -- missing preReqs: %s -- unlockable items: %s " % (
element.tech, element.allocation, missing_prereqs,
unlocked_items)
print
#
# set starting techs, or after turn 100 add any additional default techs
#
if (fo.currentTurn() == 1) or ((fo.currentTurn() < 5) and
(len(research_queue_list) == 0)):
research_index = get_research_index()
new_tech = TechsListsAI.sparse_galaxy_techs(
research_index
) if galaxy_is_sparse else TechsListsAI.primary_meta_techs(
research_index)
print "Empire %s (%d) is selecting research index %d" % (
empire.name, empire_id, research_index)
# techs_to_enqueue = (set(new_tech)-(set(completed_techs)|set(research_queue_list)))
techs_to_enqueue = new_tech[:]
tech_base = set(completed_techs + research_queue_list)
techs_to_add = []
for tech in techs_to_enqueue:
if tech not in tech_base:
this_tech = fo.getTech(tech)
if this_tech is None:
print "Error: desired tech '%s' appears to not exist" % tech
continue
missing_prereqs = [
preReq
for preReq in this_tech.recursivePrerequisites(empire_id)
if preReq not in tech_base
]
techs_to_add.extend(missing_prereqs + [tech])
tech_base.update(missing_prereqs + [tech])
cum_cost = 0
print " Enqueued Tech: %20s \t\t %8s \t %s" % ("Name", "Cost",
"CumulativeCost")
for name in techs_to_add:
try:
enqueue_res = fo.issueEnqueueTechOrder(name, -1)
if enqueue_res == 1:
this_tech = fo.getTech(name)
this_cost = 0
if this_tech:
this_cost = this_tech.researchCost(empire_id)
cum_cost += this_cost
print " Enqueued Tech: %20s \t\t %8.0f \t %8.0f" % (
name, this_cost, cum_cost)
else:
print " Error: failed attempt to enqueued Tech: " + name
except:
print " Error: failed attempt to enqueued Tech: " + name
print " Error: exception triggered and caught: ", traceback.format_exc(
)
if foAI.foAIstate.aggression <= fo.aggression.cautious:
research_queue_list = get_research_queue_techs()
def_techs = TechsListsAI.defense_techs_1()
for def_tech in def_techs:
if def_tech not in research_queue_list[:
5] and not tech_is_complete(
def_tech):
res = fo.issueEnqueueTechOrder(
def_tech, min(3, len(research_queue_list)))
print "Empire is very defensive, so attempted to fast-track %s, got result %d" % (
def_tech, res)
if False and foAI.foAIstate.aggression >= fo.aggression.aggressive: # with current stats of Conc Camps, disabling this fast-track
research_queue_list = get_research_queue_techs()
if "CON_CONC_CAMP" in research_queue_list:
insert_idx = min(40,
research_queue_list.index("CON_CONC_CAMP"))
else:
insert_idx = max(0, min(40, len(research_queue_list) - 10))
if "SHP_DEFLECTOR_SHIELD" in research_queue_list:
insert_idx = min(
insert_idx,
research_queue_list.index("SHP_DEFLECTOR_SHIELD"))
for cc_tech in ["CON_ARCH_PSYCH", "CON_CONC_CAMP"]:
if cc_tech not in research_queue_list[:insert_idx +
1] and not tech_is_complete(
cc_tech):
res = fo.issueEnqueueTechOrder(cc_tech, insert_idx)
msg = "Empire is very aggressive, so attempted to fast-track %s, got result %d" % (
cc_tech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
print ""
generate_default_research_order()
print "\n\nAll techs:"
alltechs = fo.techs() # returns names of all techs
for tname in alltechs:
print tname
print "\n-------------------------------\nAll unqueued techs:"
# coveredTechs = new_tech+completed_techs
for tname in [tn for tn in alltechs if tn not in tech_base]:
print tname
elif fo.currentTurn() > 100:
generate_default_research_order()
research_queue_list = get_research_queue_techs()
num_techs_accelerated = 1 # will ensure leading tech doesn't get dislodged
got_ggg_tech = tech_is_complete("PRO_ORBITAL_GEN")
got_sym_bio = tech_is_complete("GRO_SYMBIOTIC_BIO")
got_xeno_gen = tech_is_complete("GRO_XENO_GENETICS")
#
# Consider accelerating techs; priority is
# Supply/Detect range
# xeno arch
# ast / GG
# gro xeno gen
# distrib thought
# quant net
# pro sing gen
# death ray 1 cleanup
#
# Supply range and detection range
if False: # disabled for now, otherwise just to help with cold-folding / organization
if len(foAI.foAIstate.colonisablePlanetIDs) == 0:
best_colony_site_score = 0
else:
best_colony_site_score = foAI.foAIstate.colonisablePlanetIDs.items(
)[0][1]
if len(foAI.foAIstate.colonisableOutpostIDs) == 0:
best_outpost_site_score = 0
else:
best_outpost_site_score = foAI.foAIstate.colonisableOutpostIDs.items(
)[0][1]
need_improved_scouting = (best_colony_site_score < 150
or best_outpost_site_score < 200)
if need_improved_scouting:
if not tech_is_complete("CON_ORBITAL_CON"):
num_techs_accelerated += 1
if ("CON_ORBITAL_CON"
not in research_queue_list[:1 + num_techs_accelerated]
) and (tech_is_complete("PRO_FUSION_GEN") or
("PRO_FUSION_GEN"
in research_queue_list[:1 +
num_techs_accelerated])):
res = fo.issueEnqueueTechOrder("CON_ORBITAL_CON",
num_techs_accelerated)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % (
"CON_ORBITAL_CON", res)
if report_adjustments:
chat_human(msg)
else:
print msg
elif not tech_is_complete("CON_CONTGRAV_ARCH"):
num_techs_accelerated += 1
if ("CON_CONTGRAV_ARCH"
not in research_queue_list[:1 + num_techs_accelerated]
) and (tech_is_complete("CON_METRO_INFRA")):
for supply_tech in [
_s_tech for _s_tech in
["CON_ARCH_MONOFILS", "CON_CONTGRAV_ARCH"]
if not tech_is_complete(_s_tech)
]:
res = fo.issueEnqueueTechOrder(supply_tech,
num_techs_accelerated)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % (
supply_tech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
elif not tech_is_complete("CON_GAL_INFRA"):
num_techs_accelerated += 1
if ("CON_GAL_INFRA"
not in research_queue_list[:1 + num_techs_accelerated]
) and (tech_is_complete("PRO_SINGULAR_GEN")):
res = fo.issueEnqueueTechOrder("CON_GAL_INFRA",
num_techs_accelerated)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % (
"CON_GAL_INFRA", res)
if report_adjustments:
chat_human(msg)
else:
print msg
else:
pass
research_queue_list = get_research_queue_techs()
# could add more supply tech
if False and not tech_is_complete(
"SPY_DETECT_2"): # disabled for now, detect2
num_techs_accelerated += 1
if "SPY_DETECT_2" not in research_queue_list[:2 +
num_techs_accelerated] and tech_is_complete(
"PRO_FUSION_GEN"
):
if "CON_ORBITAL_CON" not in research_queue_list[:1 +
num_techs_accelerated]:
res = fo.issueEnqueueTechOrder("SPY_DETECT_2",
num_techs_accelerated)
else:
co_idx = research_queue_list.index("CON_ORBITAL_CON")
res = fo.issueEnqueueTechOrder("SPY_DETECT_2",
co_idx + 1)
msg = "Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d" % (
"CON_ORBITAL_CON", res)
if report_adjustments:
chat_human(msg)
else:
print msg
research_queue_list = get_research_queue_techs()
#
# check to accelerate xeno_arch
if True: # just to help with cold-folding / organization
if (ColonisationAI.gotRuins and not tech_is_complete("LRN_XENOARCH")
and foAI.foAIstate.aggression >= fo.aggression.typical):
if "LRN_ARTIF_MINDS" in research_queue_list:
insert_idx = 7 + research_queue_list.index("LRN_ARTIF_MINDS")
elif "GRO_SYMBIOTIC_BIO" in research_queue_list:
insert_idx = research_queue_list.index("GRO_SYMBIOTIC_BIO") + 1
else:
insert_idx = num_techs_accelerated
if "LRN_XENOARCH" not in research_queue_list[:insert_idx]:
for xenoTech in [
"LRN_XENOARCH", "LRN_TRANSLING_THT", "LRN_PHYS_BRAIN",
"LRN_ALGO_ELEGANCE"
]:
if not tech_is_complete(
xenoTech
) and xenoTech not in research_queue_list[:(insert_idx +
4)]:
res = fo.issueEnqueueTechOrder(xenoTech, insert_idx)
num_techs_accelerated += 1
msg = "ANCIENT_RUINS: have an ancient ruins, so attempted to fast-track %s to enable LRN_XENOARCH, got result %d" % (
xenoTech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
research_queue_list = get_research_queue_techs()
if False and not enemies_sighted: # curently disabled
# params = [ (tech, gate, target_slot, add_tech_list), ]
params = [
("GRO_XENO_GENETICS", "PRO_EXOBOTS", "PRO_EXOBOTS",
["GRO_GENETIC_MED", "GRO_XENO_GENETICS"]),
("PRO_EXOBOTS", "PRO_SENTIENT_AUTOMATION",
"PRO_SENTIENT_AUTOMATION", ["PRO_EXOBOTS"]),
("PRO_SENTIENT_AUTOMATION", "PRO_NANOTECH_PROD",
"PRO_NANOTECH_PROD", ["PRO_SENTIENT_AUTOMATION"]),
("PRO_INDUSTRY_CENTER_I", "GRO_SYMBIOTIC_BIO", "GRO_SYMBIOTIC_BIO",
["PRO_ROBOTIC_PROD", "PRO_FUSION_GEN", "PRO_INDUSTRY_CENTER_I"]),
("GRO_SYMBIOTIC_BIO", "SHP_ORG_HULL", "SHP_ZORTRIUM_PLATE",
["GRO_SYMBIOTIC_BIO"]),
]
for (tech, gate, target_slot, add_tech_list) in params:
if tech_is_complete(tech):
break
if tech_turns_left.get(gate, 0) not in [
0, 1, 2
]: # needs to exclude -1, the flag for no predicted completion
continue
if target_slot in research_queue_list:
target_index = 1 + research_queue_list.index(target_slot)
else:
target_index = num_techs_accelerated
for move_tech in add_tech_list:
print "for tech %s, target_slot %s, target_index:%s ; num_techs_accelerated:%s" % (
move_tech, target_slot, target_index,
num_techs_accelerated)
if tech_is_complete(move_tech):
continue
if target_index <= num_techs_accelerated:
num_techs_accelerated += 1
if move_tech not in research_queue_list[:1 + target_index]:
res = fo.issueEnqueueTechOrder(move_tech, target_index)
msg = "Research: To prioritize %s, have advanced %s to slot %d" % (
tech, move_tech, target_index)
if report_adjustments:
chat_human(msg)
else:
print msg
target_index += 1
#
# check to accelerate asteroid or GG tech
if True: # just to help with cold-folding / organization
if ColonisationAI.got_ast:
insert_idx = num_techs_accelerated if "GRO_SYMBIOTIC_BIO" not in research_queue_list else research_queue_list.index(
"GRO_SYMBIOTIC_BIO")
ast_tech = "PRO_MICROGRAV_MAN"
if not (tech_is_complete(ast_tech)
or ast_tech in research_queue_list[:(1 + insert_idx)]):
res = fo.issueEnqueueTechOrder(ast_tech, insert_idx)
num_techs_accelerated += 1
msg = "Asteroids: plan to colonize an asteroid belt, so attempted to fast-track %s , got result %d" % (
ast_tech, res)
if report_adjustments:
chat_human(msg)
else:
print msg
research_queue_list = get_research_queue_techs()
elif tech_is_complete("SHP_ZORTRIUM_PLATE"):
insert_idx = (
1 + insert_idx
) if "LRN_FORCE_FIELD" not in research_queue_list else max(
1 + insert_idx,
research_queue_list.index("LRN_FORCE_FIELD") - 1)
for ast_tech in [
"SHP_ASTEROID_HULLS", "SHP_IMPROVED_ENGINE_COUPLINGS"
]:
if not tech_is_complete(
ast_tech
) and ast_tech not in research_queue_list[:insert_idx + 1]:
res = fo.issueEnqueueTechOrder(ast_tech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
msg = "Asteroids: plan to colonize an asteroid belt, so attempted to fast-track %s , got result %d" % (
ast_tech, res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
if ColonisationAI.got_gg and not tech_is_complete("PRO_ORBITAL_GEN"):
fusion_idx = 0 if "PRO_FUSION_GEN" not in research_queue_list else (
1 + research_queue_list.index("PRO_FUSION_GEN"))
forcefields_idx = 0 if "LRN_FORCE_FIELD" not in research_queue_list else (
1 + research_queue_list.index("LRN_FORCE_FIELD"))
insert_idx = max(
fusion_idx, forcefields_idx) if enemies_sighted else fusion_idx
if "PRO_ORBITAL_GEN" not in research_queue_list[:insert_idx + 1]:
res = fo.issueEnqueueTechOrder("PRO_ORBITAL_GEN", insert_idx)
num_techs_accelerated += 1
msg = "GasGiant: plan to colonize a gas giant, so attempted to fast-track %s, got result %d" % (
"PRO_ORBITAL_GEN", res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# assess if our empire has any non-lousy colonizers, & boost gro_xeno_gen if we don't
if True: # just to help with cold-folding / organization
if got_ggg_tech and got_sym_bio and (
not got_xeno_gen
) and foAI.foAIstate.aggression >= fo.aggression.cautious:
most_adequate = 0
for specName in ColonisationAI.empire_colonizers:
environs = {}
this_spec = fo.getSpecies(specName)
if not this_spec:
continue
for ptype in [
fo.planetType.swamp, fo.planetType.radiated,
fo.planetType.toxic, fo.planetType.inferno,
fo.planetType.barren, fo.planetType.tundra,
fo.planetType.desert, fo.planetType.terran,
fo.planetType.ocean, fo.planetType.asteroids
]:
environ = this_spec.getPlanetEnvironment(ptype)
environs.setdefault(environ, []).append(ptype)
most_adequate = max(
most_adequate,
len(environs.get(fo.planetEnvironment.adequate, [])))
if most_adequate == 0:
insert_idx = num_techs_accelerated
for xg_tech in ["GRO_XENO_GENETICS", "GRO_GENETIC_ENG"]:
if xg_tech not in research_queue_list[:1 +
num_techs_accelerated] and not tech_is_complete(
xg_tech):
res = fo.issueEnqueueTechOrder(xg_tech, insert_idx)
num_techs_accelerated += 1
msg = "Empire has poor colonizers, so attempted to fast-track %s, got result %d" % (
xg_tech, res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# check to accelerate distrib thought
if True: # just to help with cold-folding / organization
if not tech_is_complete("LRN_DISTRIB_THOUGHT"):
got_telepathy = False
for specName in ColonisationAI.empire_species:
this_spec = fo.getSpecies(specName)
if this_spec and ("TELEPATHIC" in list(this_spec.tags)):
got_telepathy = True
break
if (foAI.foAIstate.aggression >
fo.aggression.cautious) and (empire.population() >
([300, 100][got_telepathy])):
insert_idx = num_techs_accelerated
for dt_ech in [
"LRN_PHYS_BRAIN", "LRN_TRANSLING_THT", "LRN_PSIONICS",
"LRN_DISTRIB_THOUGHT"
]:
if dt_ech not in research_queue_list[:insert_idx +
2] and not tech_is_complete(
dt_ech):
res = fo.issueEnqueueTechOrder(dt_ech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
fmt_str = "Empire has a telepathic race, so attempted to fast-track %s (got result %d)"
fmt_str += " with current target_RP %.1f and current pop %.1f, on turn %d"
msg = fmt_str % (dt_ech, res, resource_production,
empire.population(), fo.currentTurn())
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# check to accelerate quant net
if False: # disabled for now, otherwise just to help with cold-folding / organization
if (foAI.foAIstate.aggression > fo.aggression.cautious) and (
ColonisationAI.empire_status.get('researchers', 0) >= 40):
if not tech_is_complete("LRN_QUANT_NET"):
insert_idx = num_techs_accelerated # TODO determine min target slot if reenabling
for qnTech in ["LRN_NDIM_SUBSPACE", "LRN_QUANT_NET"]:
if qnTech not in research_queue_list[:insert_idx +
2] and not tech_is_complete(
qnTech):
res = fo.issueEnqueueTechOrder(qnTech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
msg = "Empire has many researchers, so attempted to fast-track %s (got result %d) on turn %d" % (
qnTech, res, fo.currentTurn())
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# if we own a blackhole, accelerate sing_gen and conc camp
if True: # just to help with cold-folding / organization
if (fo.currentTurn() > 50 and
len(AIstate.empireStars.get(fo.starType.blackHole, [])) != 0
and foAI.foAIstate.aggression > fo.aggression.cautious
and not tech_is_complete(AIDependencies.PRO_SINGULAR_GEN)
and tech_is_complete(AIDependencies.PRO_SOL_ORB_GEN)):
# sing_tech_list = [ "LRN_GRAVITONICS" , "PRO_SINGULAR_GEN"] # formerly also "CON_ARCH_PSYCH", "CON_CONC_CAMP",
sing_gen_tech = fo.getTech(AIDependencies.PRO_SINGULAR_GEN)
sing_tech_list = [
pre_req
for pre_req in sing_gen_tech.recursivePrerequisites(empire_id)
if not tech_is_complete(pre_req)
]
sing_tech_list += [AIDependencies.PRO_SINGULAR_GEN]
for singTech in sing_tech_list:
if singTech not in research_queue_list[:num_techs_accelerated +
1]:
res = fo.issueEnqueueTechOrder(singTech,
num_techs_accelerated)
num_techs_accelerated += 1
msg = "have a black hole star outpost/colony, so attempted to fast-track %s, got result %d" % (
singTech, res)
print msg
if report_adjustments:
chat_human(msg)
research_queue_list = get_research_queue_techs()
#
# if got deathray from Ruins, remove most prereqs from queue
if True: # just to help with cold-folding / organization
if tech_is_complete("SHP_WEAPON_4_1"):
this_tech = fo.getTech("SHP_WEAPON_4_1")
if this_tech:
missing_prereqs = [
preReq
for preReq in this_tech.recursivePrerequisites(empire_id)
if preReq in research_queue_list
]
if len(missing_prereqs
) > 2: # leave plasma 4 and 3 if up to them already
for preReq in missing_prereqs: # sorted(missing_prereqs, reverse=True)[2:]
if preReq in research_queue_list:
fo.issueDequeueTechOrder(preReq)
research_queue_list = get_research_queue_techs()
if "SHP_WEAPON_4_2" in research_queue_list: # (should be)
idx = research_queue_list.index("SHP_WEAPON_4_2")
fo.issueEnqueueTechOrder("SHP_WEAPON_4_2",
max(0, idx - 18))
def generate_classic_research_orders():
"""generate research orders"""
empire = fo.getEmpire()
empire_id = empire.empireID
aistate = get_aistate()
enemies_sighted = aistate.misc.get("enemies_sighted", {})
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
resource_production = empire.resourceProduction(fo.resourceType.research)
completed_techs = sorted(list(get_completed_techs()))
_print_reserch_order_header(resource_production, completed_techs)
#
# report techs currently at head of research queue
#
research_queue = empire.researchQueue
research_queue_list = get_research_queue_techs()
total_rp = empire.resourceProduction(fo.resourceType.research)
tech_turns_left = {}
if research_queue_list:
debug("Techs currently at head of Research Queue:")
for element in list(research_queue)[:10]:
tech_turns_left[element.tech] = element.turnsLeft
this_tech = fo.getTech(element.tech)
if not this_tech:
warning("Can't retrieve tech ", element.tech)
continue
missing_prereqs = [
preReq
for preReq in this_tech.recursivePrerequisites(empire_id)
if preReq not in completed_techs
]
# unlocked_items = [(uli.name, uli.type) for uli in this_tech.unlocked_items]
unlocked_items = [uli.name for uli in this_tech.unlockedItems]
if not missing_prereqs:
debug(
" %25s allocated %6.2f RP (%d turns left)-- unlockable items: %s ",
element.tech,
element.allocation,
tech_turns_left[element.tech],
unlocked_items,
)
else:
debug(
" %25s allocated %6.2f RP -- missing preReqs: %s -- unlockable items: %s ",
element.tech,
element.allocation,
missing_prereqs,
unlocked_items,
)
debug("")
#
# set starting techs, or after turn 100 add any additional default techs
#
if (fo.currentTurn() <= 2) or ((total_rp - research_queue.totalSpent) > 0):
research_index = get_research_index()
if fo.currentTurn() == 1:
# do only this one on first turn, to facilitate use of a turn-1 savegame for testing of alternate
# research strategies
new_tech = ["LRN_PHYS_BRAIN", "GRO_PLANET_ECOL"]
else:
new_tech = (TechsListsAI.sparse_galaxy_techs(research_index)
if galaxy_is_sparse else
TechsListsAI.primary_meta_techs(research_index))
debug("Empire %s (%d) is selecting research index %d", empire.name,
empire_id, research_index)
# techs_to_enqueue = (set(new_tech)-(set(completed_techs)|set(research_queue_list)))
techs_to_enqueue = new_tech[:]
tech_base = set(completed_techs + research_queue_list)
techs_to_add = []
for tech in techs_to_enqueue:
if tech not in tech_base:
this_tech = fo.getTech(tech)
if this_tech is None:
error("Desired tech '%s' appears to not exist" % tech)
continue
missing_prereqs = [
preReq
for preReq in this_tech.recursivePrerequisites(empire_id)
if preReq not in tech_base
]
techs_to_add.extend(missing_prereqs + [tech])
tech_base.update(missing_prereqs + [tech])
cum_cost = 0
debug(" Enqueued Tech: %20s \t\t %8s \t %s", "Name", "Cost",
"CumulativeCost")
for name in techs_to_add:
try:
enqueue_res = fo.issueEnqueueTechOrder(name, -1)
if enqueue_res == 1:
this_tech = fo.getTech(name)
this_cost = 0
if this_tech:
this_cost = this_tech.researchCost(empire_id)
cum_cost += this_cost
debug(" Enqueued Tech: %20s \t\t %8.0f \t %8.0f", name,
this_cost, cum_cost)
else:
warning(" Failed attempt to enqueued Tech: " + name)
except: # noqa: E722
warning(" Failed attempt to enqueued Tech: " + name,
exc_info=True)
debug("\n\nAll techs:")
debug("=" * 20)
alltechs = fo.techs()
print_in_columns(sorted(fo.techs()), columns=3)
debug("\n\nAll unqueued techs:")
debug("=" * 20)
# coveredTechs = new_tech+completed_techs
print_in_columns([tn for tn in alltechs if tn not in tech_base],
columns=3)
debug("")
if fo.currentTurn() == 1:
return
if True:
research_queue_list = get_research_queue_techs()
def_techs = TechsListsAI.defense_techs_1()
for def_tech in def_techs:
if (aistate.character.may_research_tech_classic(def_tech)
and def_tech not in research_queue_list[:5]
and not tech_is_complete(def_tech)):
res = fo.issueEnqueueTechOrder(
def_tech, min(3, len(research_queue_list)))
debug(
"Empire is very defensive, so attempted to fast-track %s, got result %d",
def_tech, res)
if False: # with current stats of Conc Camps, disabling this fast-track
research_queue_list = get_research_queue_techs()
if "CON_CONC_CAMP" in research_queue_list and aistate.character.may_research_tech_classic(
"CON_CONC_CAMP"):
insert_idx = min(40,
research_queue_list.index("CON_CONC_CAMP"))
else:
insert_idx = max(0, min(40, len(research_queue_list) - 10))
if "SHP_DEFLECTOR_SHIELD" in research_queue_list and aistate.character.may_research_tech_classic(
"SHP_DEFLECTOR_SHIELD"):
insert_idx = min(
insert_idx,
research_queue_list.index("SHP_DEFLECTOR_SHIELD"))
for cc_tech in ["CON_ARCH_PSYCH", "CON_CONC_CAMP"]:
if (cc_tech not in research_queue_list[:insert_idx + 1]
and not tech_is_complete(cc_tech) and
aistate.character.may_research_tech_classic(cc_tech)):
res = fo.issueEnqueueTechOrder(cc_tech, insert_idx)
debug(
"Empire is very aggressive, so attempted to fast-track %s, got result %d",
cc_tech, res)
elif fo.currentTurn() > 100:
generate_default_research_order()
research_queue_list = get_research_queue_techs()
num_techs_accelerated = 1 # will ensure leading tech doesn't get dislodged
got_ggg_tech = tech_is_complete("PRO_ORBITAL_GEN")
got_sym_bio = tech_is_complete("GRO_SYMBIOTIC_BIO")
got_xeno_gen = tech_is_complete("GRO_XENO_GENETICS")
#
# Consider accelerating techs; priority is
# Supply/Detect range
# xeno arch
# ast / GG
# gro xeno gen
# distrib thought
# quant net
# pro sing gen
# death ray 1 cleanup
nest_tech = Dep.NEST_DOMESTICATION_TECH
artif_minds = Dep.LRN_ARTIF_MINDS_1
if have_nest() and not tech_is_complete(nest_tech):
if artif_minds in research_queue_list:
insert_idx = 1 + research_queue_list.index(artif_minds)
else:
insert_idx = 1
res = fo.issueEnqueueTechOrder(nest_tech, insert_idx)
num_techs_accelerated += 1
debug(
"Have a monster nest, so attempted to fast-track %s, got result %d",
nest_tech, res)
research_queue_list = get_research_queue_techs()
#
# Supply range and detection range
if False: # disabled for now, otherwise just to help with cold-folding / organization
if len(aistate.colonisablePlanetIDs) == 0:
best_colony_site_score = 0
else:
best_colony_site_score = next(
iter(aistate.colonisablePlanetIDs.items()))[1]
if len(aistate.colonisableOutpostIDs) == 0:
best_outpost_site_score = 0
else:
best_outpost_site_score = next(
iter(aistate.colonisableOutpostIDs.items()))[1]
need_improved_scouting = best_colony_site_score < 150 or best_outpost_site_score < 200
if need_improved_scouting:
if not tech_is_complete("CON_ORBITAL_CON"):
num_techs_accelerated += 1
if ("CON_ORBITAL_CON"
not in research_queue_list[:1 + num_techs_accelerated]
) and (tech_is_complete("PRO_FUSION_GEN") or
("PRO_FUSION_GEN"
in research_queue_list[:1 +
num_techs_accelerated])):
res = fo.issueEnqueueTechOrder("CON_ORBITAL_CON",
num_techs_accelerated)
debug(
"Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d",
"CON_ORBITAL_CON",
res,
)
elif not tech_is_complete("CON_CONTGRAV_ARCH"):
num_techs_accelerated += 1
if ("CON_CONTGRAV_ARCH"
not in research_queue_list[:1 + num_techs_accelerated]
) and (tech_is_complete("CON_METRO_INFRA")):
for supply_tech in [
_s_tech for _s_tech in
["CON_ARCH_MONOFILS", "CON_CONTGRAV_ARCH"]
if not tech_is_complete(_s_tech)
]:
res = fo.issueEnqueueTechOrder(supply_tech,
num_techs_accelerated)
debug(
"Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d",
supply_tech,
res,
)
else:
pass
research_queue_list = get_research_queue_techs()
# could add more supply tech
if False and not tech_is_complete(
"SPY_DETECT_2"): # disabled for now, detect2
num_techs_accelerated += 1
if "SPY_DETECT_2" not in research_queue_list[:2 +
num_techs_accelerated] and tech_is_complete(
"PRO_FUSION_GEN"
):
if "CON_ORBITAL_CON" not in research_queue_list[:1 +
num_techs_accelerated]:
res = fo.issueEnqueueTechOrder("SPY_DETECT_2",
num_techs_accelerated)
else:
co_idx = research_queue_list.index("CON_ORBITAL_CON")
res = fo.issueEnqueueTechOrder("SPY_DETECT_2",
co_idx + 1)
debug(
"Empire has poor colony/outpost prospects, so attempted to fast-track %s, got result %d"
"CON_ORBITAL_CON",
res,
)
research_queue_list = get_research_queue_techs()
#
# check to accelerate xeno_arch
if True: # just to help with cold-folding / organization
if (have_ruins() and not tech_is_complete("LRN_XENOARCH") and
aistate.character.may_research_tech_classic("LRN_XENOARCH")):
if artif_minds in research_queue_list:
insert_idx = 7 + research_queue_list.index(artif_minds)
elif "GRO_SYMBIOTIC_BIO" in research_queue_list:
insert_idx = research_queue_list.index("GRO_SYMBIOTIC_BIO") + 1
else:
insert_idx = num_techs_accelerated
if "LRN_XENOARCH" not in research_queue_list[:insert_idx]:
for xenoTech in [
"LRN_XENOARCH", "LRN_TRANSLING_THT", "LRN_PHYS_BRAIN",
"LRN_ALGO_ELEGANCE"
]:
if not tech_is_complete(
xenoTech
) and xenoTech not in research_queue_list[:(insert_idx +
4)]:
res = fo.issueEnqueueTechOrder(xenoTech, insert_idx)
num_techs_accelerated += 1
debug(
"ANCIENT_RUINS: have an ancient ruins, so attempted to fast-track %s to enable LRN_XENOARCH, got result %d",
xenoTech,
res,
)
research_queue_list = get_research_queue_techs()
if False and not enemies_sighted: # curently disabled
# params = [ (tech, gate, target_slot, add_tech_list), ]
params = [
("GRO_XENO_GENETICS", "PRO_EXOBOTS", "PRO_EXOBOTS",
["GRO_GENETIC_MED", "GRO_XENO_GENETICS"]),
("PRO_EXOBOTS", "PRO_ADAPTIVE_AUTOMATION",
"PRO_ADAPTIVE_AUTOMATION", ["PRO_EXOBOTS"]),
("PRO_ADAPTIVE_AUTOMATION", "PRO_NANOTECH_PROD",
"PRO_NANOTECH_PROD", ["PRO_ADAPTIVE_AUTOMATION"]),
(
"PRO_INDUSTRY_CENTER_I",
"GRO_SYMBIOTIC_BIO",
"GRO_SYMBIOTIC_BIO",
[
"PRO_ROBOTIC_PROD", "PRO_FUSION_GEN",
"PRO_INDUSTRY_CENTER_I"
],
),
("GRO_SYMBIOTIC_BIO", "SHP_ORG_HULL", "SHP_ZORTRIUM_PLATE",
["GRO_SYMBIOTIC_BIO"]),
]
for (tech, gate, target_slot, add_tech_list) in params:
if tech_is_complete(tech):
break
if tech_turns_left.get(gate, 0) not in [
0,
1,
2,
]: # needs to exclude -1, the flag for no predicted completion
continue
if target_slot in research_queue_list:
target_index = 1 + research_queue_list.index(target_slot)
else:
target_index = num_techs_accelerated
for move_tech in add_tech_list:
debug(
"for tech %s, target_slot %s, target_index:%s ; num_techs_accelerated:%s",
move_tech,
target_slot,
target_index,
num_techs_accelerated,
)
if tech_is_complete(move_tech):
continue
if target_index <= num_techs_accelerated:
num_techs_accelerated += 1
if move_tech not in research_queue_list[:1 + target_index]:
fo.issueEnqueueTechOrder(move_tech, target_index)
debug(
"Research: To prioritize %s, have advanced %s to slot %d",
tech, move_tech, target_index)
target_index += 1
#
# check to accelerate asteroid or GG tech
if True: # just to help with cold-folding / organization
if have_asteroids():
insert_idx = (num_techs_accelerated
if "GRO_SYMBIOTIC_BIO" not in research_queue_list
else research_queue_list.index("GRO_SYMBIOTIC_BIO"))
ast_tech = "PRO_MICROGRAV_MAN"
if not (tech_is_complete(ast_tech)
or ast_tech in research_queue_list[:(1 + insert_idx)]):
res = fo.issueEnqueueTechOrder(ast_tech, insert_idx)
num_techs_accelerated += 1
debug(
"Asteroids: plan to colonize an asteroid belt, so attempted to fast-track %s , got result %d",
ast_tech,
res,
)
research_queue_list = get_research_queue_techs()
elif tech_is_complete("SHP_ZORTRIUM_PLATE"):
insert_idx = (
(1 + insert_idx)
if "LRN_FORCE_FIELD" not in research_queue_list else max(
1 + insert_idx,
research_queue_list.index("LRN_FORCE_FIELD") - 1))
for ast_tech in [
"SHP_ASTEROID_HULLS", "SHP_IMPROVED_ENGINE_COUPLINGS"
]:
if not tech_is_complete(
ast_tech
) and ast_tech not in research_queue_list[:insert_idx + 1]:
res = fo.issueEnqueueTechOrder(ast_tech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
debug(
"Asteroids: plan to colonize an asteroid belt, so attempted to fast-track %s , got result %d",
ast_tech,
res,
)
research_queue_list = get_research_queue_techs()
if have_gas_giant() and not tech_is_complete("PRO_ORBITAL_GEN"):
fusion_idx = (0 if "PRO_FUSION_GEN" not in research_queue_list else
(1 + research_queue_list.index("PRO_FUSION_GEN")))
forcefields_idx = (0 if "LRN_FORCE_FIELD"
not in research_queue_list else
(1 +
research_queue_list.index("LRN_FORCE_FIELD")))
insert_idx = max(
fusion_idx, forcefields_idx) if enemies_sighted else fusion_idx
if "PRO_ORBITAL_GEN" not in research_queue_list[:insert_idx + 1]:
res = fo.issueEnqueueTechOrder("PRO_ORBITAL_GEN", insert_idx)
num_techs_accelerated += 1
debug(
"GasGiant: plan to colonize a gas giant, so attempted to fast-track %s, got result %d",
"PRO_ORBITAL_GEN",
res,
)
research_queue_list = get_research_queue_techs()
#
# assess if our empire has any non-lousy colonizers, & boost gro_xeno_gen if we don't
if True: # just to help with cold-folding / organization
if got_ggg_tech and got_sym_bio and (not got_xeno_gen):
most_adequate = 0
for specName in get_colony_builders():
environs = {}
this_spec = fo.getSpecies(specName)
if not this_spec:
continue
for ptype in [
fo.planetType.swamp,
fo.planetType.radiated,
fo.planetType.toxic,
fo.planetType.inferno,
fo.planetType.barren,
fo.planetType.tundra,
fo.planetType.desert,
fo.planetType.terran,
fo.planetType.ocean,
fo.planetType.asteroids,
]:
environ = this_spec.getPlanetEnvironment(ptype)
environs.setdefault(environ, []).append(ptype)
most_adequate = max(
most_adequate,
len(environs.get(fo.planetEnvironment.adequate, [])))
if most_adequate == 0:
insert_idx = num_techs_accelerated
for xg_tech in ["GRO_XENO_GENETICS", "GRO_GENETIC_ENG"]:
if (xg_tech
not in research_queue_list[:1 +
num_techs_accelerated]
and not tech_is_complete(xg_tech)
and aistate.character.may_research_tech_classic(
xg_tech)):
res = fo.issueEnqueueTechOrder(xg_tech, insert_idx)
num_techs_accelerated += 1
debug(
"Empire has poor colonizers, so attempted to fast-track %s, got result %d",
xg_tech,
res,
)
research_queue_list = get_research_queue_techs()
#
# check to accelerate translinguistics
if True: # just to help with cold-folding / organization
# planet is needed to determine the cost. Without a capital we have bigger problems anyway...
if not tech_is_complete("LRN_TRANSLING_THT") and translators_wanted():
insert_idx = num_techs_accelerated
for dt_ech in [
"LRN_TRANSLING_THT", "LRN_PHYS_BRAIN", "LRN_ALGO_ELEGANCE"
]:
if (dt_ech not in research_queue_list[:insert_idx + 2]
and not tech_is_complete(dt_ech) and
aistate.character.may_research_tech_classic(dt_ech)):
res = fo.issueEnqueueTechOrder(dt_ech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
fmt_str = "Empire wants to build translators, so attempted to fast-track %s (got result %d)"
fmt_str += " with current target_RP %.1f and current pop %.1f, on turn %d"
debug(fmt_str, dt_ech, res, resource_production,
empire.population(), fo.currentTurn())
research_queue_list = get_research_queue_techs()
#
# check to accelerate distrib thought
if True: # just to help with cold-folding / organization
if not tech_is_complete("LRN_DISTRIB_THOUGHT"):
got_telepathy = False
for specName in get_empire_planets_by_species():
this_spec = fo.getSpecies(specName)
if this_spec and ("TELEPATHIC" in list(this_spec.tags)):
got_telepathy = True
break
pop_threshold = 100 if got_telepathy else 300
if empire.population() > pop_threshold:
insert_idx = num_techs_accelerated
for dt_ech in [
"LRN_PHYS_BRAIN", "LRN_TRANSLING_THT", "LRN_PSIONICS",
"LRN_DISTRIB_THOUGHT"
]:
if (dt_ech not in research_queue_list[:insert_idx + 2]
and not tech_is_complete(dt_ech)
and aistate.character.may_research_tech_classic(
dt_ech)):
res = fo.issueEnqueueTechOrder(dt_ech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
fmt_str = "Empire has a telepathic race, so attempted to fast-track %s (got result %d)"
fmt_str += " with current target_RP %.1f and current pop %.1f, on turn %d"
debug(fmt_str, dt_ech, res, resource_production,
empire.population(), fo.currentTurn())
research_queue_list = get_research_queue_techs()
#
# check to accelerate quant net
if False: # disabled for now, otherwise just to help with cold-folding / organization
if aistate.character.may_research_tech_classic("LRN_QUANT_NET") and (
population_with_research_focus() >= 40):
if not tech_is_complete("LRN_QUANT_NET"):
insert_idx = num_techs_accelerated # TODO determine min target slot if reenabling
for qnTech in ["LRN_NDIM_SUBSPACE", "LRN_QUANT_NET"]:
if qnTech not in research_queue_list[:insert_idx +
2] and not tech_is_complete(
qnTech):
res = fo.issueEnqueueTechOrder(qnTech, insert_idx)
num_techs_accelerated += 1
insert_idx += 1
debug(
"Empire has many researchers, so attempted to fast-track %s (got result %d) on turn %d",
qnTech,
res,
fo.currentTurn(),
)
research_queue_list = get_research_queue_techs()
#
# if we own a blackhole, accelerate sing_gen and conc camp
if True: # just to help with cold-folding / organization
if (fo.currentTurn() > 50 and
len(AIstate.empireStars.get(fo.starType.blackHole, [])) != 0
and
aistate.character.may_research_tech_classic("PRO_SINGULAR_GEN")
and not tech_is_complete(Dep.PRO_SINGULAR_GEN)
and tech_is_complete("LRN_EVERYTHING")):
# sing_tech_list = [ "LRN_GRAVITONICS" , "PRO_SINGULAR_GEN"] # formerly also "CON_ARCH_PSYCH", "CON_CONC_CAMP",
sing_gen_tech = fo.getTech(Dep.PRO_SINGULAR_GEN)
sing_tech_list = [
pre_req
for pre_req in sing_gen_tech.recursivePrerequisites(empire_id)
if not tech_is_complete(pre_req)
]
sing_tech_list += [Dep.PRO_SINGULAR_GEN]
for singTech in sing_tech_list:
if singTech not in research_queue_list[:num_techs_accelerated +
1]:
res = fo.issueEnqueueTechOrder(singTech,
num_techs_accelerated)
num_techs_accelerated += 1
debug(
"have a black hole star outpost/colony, so attempted to fast-track %s, got result %d",
singTech,
res,
)
research_queue_list = get_research_queue_techs()
#
# if got deathray from Ruins, remove most prereqs from queue
if True: # just to help with cold-folding / organization
if tech_is_complete("SHP_WEAPON_4_1"):
this_tech = fo.getTech("SHP_WEAPON_4_1")
if this_tech:
missing_prereqs = [
preReq
for preReq in this_tech.recursivePrerequisites(empire_id)
if preReq in research_queue_list
]
if len(missing_prereqs
) > 2: # leave plasma 4 and 3 if up to them already
for preReq in missing_prereqs: # sorted(missing_prereqs, reverse=True)[2:]
if preReq in research_queue_list:
fo.issueDequeueTechOrder(preReq)
research_queue_list = get_research_queue_techs()
if "SHP_WEAPON_4_2" in research_queue_list: # (should be)
idx = research_queue_list.index("SHP_WEAPON_4_2")
fo.issueEnqueueTechOrder("SHP_WEAPON_4_2",
max(0, idx - 18))
# TODO: Remove the following example code
# Example/Test code for the new ShipDesigner functionality
techs = [
"SHP_WEAPON_4_2", "SHP_TRANSSPACE_DRIVE", "SHP_INTSTEL_LOG",
"SHP_ASTEROID_HULLS", ""
]
for tech in techs:
this_tech = fo.getTech(tech)
if not this_tech:
debug("Invalid Tech specified")
continue
unlocked_items = this_tech.unlockedItems
unlocked_hulls = []
unlocked_parts = []
for item in unlocked_items:
if item.type == fo.unlockableItemType.shipPart:
debug("Tech %s unlocks a ShipPart: %s", tech, item.name)
unlocked_parts.append(item.name)
elif item.type == fo.unlockableItemType.shipHull:
debug("Tech %s unlocks a ShipHull: %s", tech, item.name)
unlocked_hulls.append(item.name)
if not (unlocked_parts or unlocked_hulls):
debug("No new ship parts/hulls unlocked by tech %s", tech)
continue
old_designs = ShipDesignAI.WarShipDesigner().optimize_design(
consider_fleet_count=False)
new_designs = ShipDesignAI.WarShipDesigner().optimize_design(
additional_hulls=unlocked_hulls,
additional_parts=unlocked_parts,
consider_fleet_count=False)
if not (old_designs and new_designs):
# AI is likely defeated; don't bother with logging error message
continue
old_rating, old_pid, old_design_id, old_cost, old_stats = old_designs[
0]
old_design = fo.getShipDesign(old_design_id)
new_rating, new_pid, new_design_id, new_cost, new_stats = new_designs[
0]
new_design = fo.getShipDesign(new_design_id)
if new_rating > old_rating:
debug("Tech %s gives access to a better design!", tech)
debug("old best design: Rating %.5f", old_rating)
debug("old design specs: %s - %s", old_design.hull,
list(old_design.parts))
debug("new best design: Rating %.5f", new_rating)
debug("new design specs: %s - %s", new_design.hull,
list(new_design.parts))
else:
debug(
"Tech %s gives access to new parts or hulls but there seems to be no military advantage.",
tech)
def evaluate_invasion_planet(planet_id, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
detail = []
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
# TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empire_id = fo.empireID()
max_jumps = 8
planet = universe.getPlanet(planet_id)
if planet is None: # TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d" % planet_id
return [0, 0]
sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID)
planet_partial_vis_turn = get_partial_visibility_turn(planet_id)
if planet_partial_vis_turn < sys_partial_vis_turn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)" % planet_id
# TODO: track detection strength, order new scouting when it goes up
return [0, 0] # last time we had partial vis of the system, the planet was stealthed to us
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], MissionType.INVASION, None, detail)
pop_val = max(0.75 * planet_eval.get(planet_id, [0])[0],
ColonisationAI.evaluate_planet(planet_id, MissionType.OUTPOST, None, detail))
else:
pop_val = ColonisationAI.evaluate_planet(planet_id, MissionType.INVASION, species_name, detail)
bld_tally = 0
for bldType in [universe.getBuilding(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
tech_tally = 0
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_tally += rp_cost * 4
detail.append("%s: %d" % (unlocked_tech, rp_cost * 4))
p_sys_id = planet.systemID
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld:
home_system_id = homeworld.systemID
eval_system_id = planet.systemID
if (home_system_id != INVALID_ID) and (eval_system_id != INVALID_ID):
least_jumps_path = list(universe.leastJumpsPath(home_system_id, eval_system_id, empire_id))
max_jumps = len(least_jumps_path)
system_status = foAI.foAIstate.systemStatus.get(p_sys_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(p_sys_id)
secure_targets = [p_sys_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != p_sys_id:
continue
if mission.type == MissionType.SECURE:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating', 0)
if verbose:
print ("Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f") % (
planet, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat,
system_monster_threat)
supply_val = 0
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) +
2*planet.currentMeterValue(fo.meterType.targetResearch))
if p_sys_id in ColonisationAI.annexable_system_ids: # TODO: extend to rings
supply_val = 100
elif p_sys_id in state.get_systems_by_supply_tier(-1):
supply_val = 200
elif p_sys_id in state.get_systems_by_supply_tier(-2):
supply_val = 300
elif p_sys_id in state.get_systems_by_supply_tier(-3):
supply_val = 400
if max_path_threat > 0.5 * mil_ship_rating:
if max_path_threat < 3 * mil_ship_rating:
supply_val *= 0.5
else:
supply_val *= 0.2
# devalue invasions that would require too much military force
threat_factor = min(1, 0.2*MilitaryAI.get_tot_mil_rating()/(sys_total_threat+0.001))**2
design_id, _, locs = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / 6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(design.troopCapacity,
CombatRatingsAI.get_species_troops_grade(species_here))
planned_troops = troops if system_secured else min(troops + max_jumps + build_time, max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
ships_needed = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints, 1)
normalized_cost = max(1., normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = pop_val + supply_val + bld_tally + tech_tally + enemy_val - cost_score
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, base_score)
if clear_path:
planet_score *= 1.5
if verbose:
print (' - planet score: %.2f\n'
' - troop score: %.2f\n'
' - projected troop cost: %.1f\n'
' - threat factor: %s\n'
' - planet detail: %s\n'
' - popval: %.1f\n'
' - supplyval: %.1f\n'
' - bldval: %s\n'
' - enemyval: %s') % (planet_score, planned_troops, troop_cost,
threat_factor, detail, pop_val, supply_val, bld_tally, enemy_val)
return [planet_score, planned_troops]
def _calculate_research_priority():
"""Calculates the AI empire's demand for research."""
universe = fo.getUniverse()
empire = fo.getEmpire()
empire_id = empire.empireID
current_turn = fo.currentTurn()
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
recent_enemies = [x for x in enemies_sighted if x > current_turn - 8]
industry_priority = foAI.foAIstate.get_priority(PriorityType.RESOURCE_PRODUCTION)
got_algo = tech_is_complete(AIDependencies.LRN_ALGO_ELEGANCE)
got_quant = tech_is_complete(AIDependencies.LRN_QUANT_NET)
research_queue_list = ResearchAI.get_research_queue_techs()
orb_gen_tech = AIDependencies.PRO_ORBITAL_GEN
got_orb_gen = tech_is_complete(orb_gen_tech)
mgrav_prod_tech = AIDependencies.PRO_MICROGRAV_MAN
got_mgrav_prod = tech_is_complete(mgrav_prod_tech)
# got_solar_gen = tech_is_complete(AIDependencies.PRO_SOL_ORB_GEN)
milestone_techs = ["PRO_SENTIENT_AUTOMATION", "LRN_DISTRIB_THOUGHT", "LRN_QUANT_NET", "SHP_WEAPON_2_4", "SHP_WEAPON_3_2", "SHP_WEAPON_4_2"]
milestones_done = [mstone for mstone in milestone_techs if tech_is_complete(mstone)]
print "Research Milestones accomplished at turn %d: %s" % (current_turn, milestones_done)
total_pp = empire.productionPoints
total_rp = empire.resourceProduction(fo.resourceType.research)
industry_surge = (foAI.foAIstate.character.may_surge_industry(total_pp, total_rp) and
(((orb_gen_tech in research_queue_list[:2] or got_orb_gen) and state.have_gas_giant) or
((mgrav_prod_tech in research_queue_list[:2] or got_mgrav_prod) and state.have_asteroids)) and
(not (len(AIstate.popCtrIDs) >= 12)))
# get current industry production & Target
owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
planets = map(universe.getPlanet, owned_planet_ids)
target_rp = sum(map(lambda x: x.currentMeterValue(fo.meterType.targetResearch), planets))
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
style_index = foAI.foAIstate.character.preferred_research_cutoff([0, 1])
if foAI.foAIstate.character.may_maximize_research():
style_index += 1
cutoff_sets = [[25, 45, 70, 110], [30, 45, 70, 150], [25, 40, 80, 160]]
cutoffs = cutoff_sets[style_index]
settings = [[1.3, .7, .5, .4, .35], [1.4, 0.8, 0.6, 0.5, 0.35], [1.4, 0.8, 0.6, 0.5, 0.4]][style_index]
if (current_turn < cutoffs[0]) or (not got_algo) or ((style_index == 0) and not got_orb_gen and (current_turn < cutoffs[1])):
research_priority = settings[0] * industry_priority # high research at beginning of game to get easy gro tech and to get research booster Algotrithmic Elegance
elif (not got_orb_gen) or (current_turn < cutoffs[1]):
research_priority = settings[1] * industry_priority # med-high research
elif current_turn < cutoffs[2]:
research_priority = settings[2] * industry_priority # med-high industry
elif current_turn < cutoffs[3]:
research_priority = settings[3] * industry_priority # med-high industry
else:
research_queue = list(empire.researchQueue)
research_priority = settings[4] * industry_priority # high industry , low research
if len(research_queue) == 0:
research_priority = 0 # done with research
elif len(research_queue) < 5 and research_queue[-1].allocation > 0:
research_priority = len(research_queue) * 0.01 * industry_priority # barely not done with research
elif len(research_queue) < 10 and research_queue[-1].allocation > 0:
research_priority = (4 + 2 * len(research_queue)) * 0.01 * industry_priority # almost done with research
elif len(research_queue) < 20 and research_queue[int(len(research_queue) / 2)].allocation > 0:
research_priority *= 0.7 # closing in on end of research
if industry_surge:
if galaxy_is_sparse and not any(enemies_sighted):
research_priority *= 0.5
else:
research_priority *= 0.8
if ((tech_is_complete("SHP_WEAPON_2_4") or
tech_is_complete("SHP_WEAPON_4_1")) and
tech_is_complete(AIDependencies.PROD_AUTO_NAME)):
# industry_factor = [ [0.25, 0.2], [0.3, 0.25], [0.3, 0.25] ][style_index ]
# researchPriority = min(researchPriority, industry_factor[got_solar_gen]*industryPriority)
research_priority *= 0.9
if got_quant:
research_priority = min(research_priority + 0.1 * industry_priority, research_priority * 1.3)
research_priority = int(research_priority)
print "Research Production (current/target) : ( %.1f / %.1f )" % (total_rp, target_rp)
print "Priority for Research: %d (new target ~ %d RP)" % (research_priority, total_pp * research_priority / industry_priority)
if len(enemies_sighted) < (2 + current_turn/20.0): # TODO: adjust for colonisation priority
research_priority *= 1.2
if (current_turn > 20) and (len(recent_enemies) > 3):
research_priority *= 0.8
return research_priority
def evaluateInvasionPlanet(planetID, missionType, fleetSupplyablePlanetIDs, empire):
"return the invasion value of a planet"
detail = []
buildingValues = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 150,
"BLD_SHIPYARD_AST_REF": 500,
"BLD_SHIPYARD_ENRG_COMP": 500,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
#TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empireID = empire.empireID
maxJumps=8
planet = universe.getPlanet(planetID)
if (planet == None) : #TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't get current info on planet %d"%planetID
return 0, 0
specName=planet.speciesName
species=fo.getSpecies(specName)
if not species:#TODO: probably stealth makes planet inacccesible & should abort
return 0, 0
else:
popVal = ColonisationAI.evaluatePlanet(planetID, EnumsAI.AIFleetMissionType.FLEET_MISSION_COLONISATION, [planetID], species, empire, detail) #evaluatePlanet is imported from ColonisationAI
bldTally=0
for bldType in [universe.getObject(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = buildingValues.get(bldType, 50)
bldTally += bval
detail.append("%s: %d"%(bldType, bval))
capitolID = PlanetUtilsAI.getCapital()
if capitolID:
homeworld = universe.getPlanet(capitolID)
if homeworld:
homeSystemID = homeworld.systemID
evalSystemID = planet.systemID
leastJumpsPath = len(universe.leastJumpsPath(homeSystemID, evalSystemID, empireID))
maxJumps = leastJumpsPath
troops = planet.currentMeterValue(fo.meterType.troops)
maxTroops = planet.currentMeterValue(fo.meterType.maxTroops)
popTSize = planet.currentMeterValue(fo.meterType.targetPopulation)#TODO: adjust for empire tech
planetSpecials = list(planet.specials)
pSysID = planet.systemID#TODO: check star value
pmaxShield = planet.currentMeterValue(fo.meterType.maxShield)
sysFThrt = foAI.foAIstate.systemStatus.get(pSysID, {}).get('fleetThreat', 1000 )
sysMThrt = foAI.foAIstate.systemStatus.get(pSysID, {}).get('monsterThreat', 0 )
print "invasion eval of %s %d --- maxShields %.1f -- sysFleetThreat %.1f -- sysMonsterThreat %.1f"%(planet.name, planetID, pmaxShield, sysFThrt, sysMThrt)
supplyVal=0
enemyVal=0
if planet.owner!=-1 : #value in taking this away from an enemy
enemyVal= 20* (planet.currentMeterValue(fo.meterType.targetIndustry) + 2*planet.currentMeterValue(fo.meterType.targetResearch))
if planetID in fleetSupplyablePlanetIDs: #TODO: extend to rings
supplyVal = 100
if planet.owner== -1:
#if (pmaxShield <10):
if ( sysFThrt < 0.5*ProductionAI.curBestMilShipRating() ):
if ( sysMThrt < 3*ProductionAI.curBestMilShipRating()):
supplyVal = 50
else:
supplyVal = 20
else:
supplyVal *= int( min(1, ProductionAI.curBestMilShipRating() / sysFThrt ) )
buildTime=4
plannedTroops = min(troops+maxJumps+buildTime, maxTroops)
if ( empire.getTechStatus("SHP_ORG_HULL") != fo.techStatus.complete ):
troopCost = math.ceil( plannedTroops/6.0) * ( 40*( 1+foAI.foAIstate.shipCount * AIDependencies.shipUpkeep ) )
else:
troopCost = math.ceil( plannedTroops/6.0) * ( 20*( 1+foAI.foAIstate.shipCount * AIDependencies.shipUpkeep ) )
invscore = max(0, popVal+supplyVal+bldTally+enemyVal-0.8*troopCost), plannedTroops
print invscore, "projected Troop Cost:", troopCost, "planet detail ", detail, popVal, supplyVal, bldTally, enemyVal
return invscore
def _calculate_research_priority():
"""Calculates the AI empire's demand for research."""
universe = fo.getUniverse()
empire = fo.getEmpire()
current_turn = fo.currentTurn()
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
recent_enemies = [x for x in enemies_sighted if x > current_turn - 8]
industry_priority = foAI.foAIstate.get_priority(PriorityType.RESOURCE_PRODUCTION)
got_algo = tech_is_complete(AIDependencies.LRN_ALGO_ELEGANCE)
got_quant = tech_is_complete(AIDependencies.LRN_QUANT_NET)
research_queue_list = ResearchAI.get_research_queue_techs()
orb_gen_tech = AIDependencies.PRO_ORBITAL_GEN
got_orb_gen = tech_is_complete(orb_gen_tech)
mgrav_prod_tech = AIDependencies.PRO_MICROGRAV_MAN
got_mgrav_prod = tech_is_complete(mgrav_prod_tech)
# got_solar_gen = tech_is_complete(AIDependencies.PRO_SOL_ORB_GEN)
milestone_techs = ["PRO_SENTIENT_AUTOMATION", "LRN_DISTRIB_THOUGHT", "LRN_QUANT_NET", "SHP_WEAPON_2_4", "SHP_WEAPON_3_2", "SHP_WEAPON_4_2"]
milestones_done = [mstone for mstone in milestone_techs if tech_is_complete(mstone)]
print "Research Milestones accomplished at turn %d: %s" % (current_turn, milestones_done)
total_pp = empire.productionPoints
total_rp = empire.resourceProduction(fo.resourceType.research)
industry_surge = (foAI.foAIstate.character.may_surge_industry(total_pp, total_rp) and
(((orb_gen_tech in research_queue_list[:2] or got_orb_gen) and state.have_gas_giant) or
((mgrav_prod_tech in research_queue_list[:2] or got_mgrav_prod) and state.have_asteroids)) and
(state.get_number_of_colonies() < 12))
# get current industry production & Target
owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire(universe.planetIDs)
planets = map(universe.getPlanet, owned_planet_ids)
target_rp = sum(map(lambda x: x.currentMeterValue(fo.meterType.targetResearch), planets))
galaxy_is_sparse = ColonisationAI.galaxy_is_sparse()
enemies_sighted = foAI.foAIstate.misc.get('enemies_sighted', {})
style_index = foAI.foAIstate.character.preferred_research_cutoff([0, 1])
if foAI.foAIstate.character.may_maximize_research():
style_index += 1
cutoff_sets = [[25, 45, 70, 110], [30, 45, 70, 150], [25, 40, 80, 160]]
cutoffs = cutoff_sets[style_index]
settings = [[1.3, .7, .5, .4, .35], [1.4, 0.8, 0.6, 0.5, 0.35], [1.4, 0.8, 0.6, 0.5, 0.4]][style_index]
if (current_turn < cutoffs[0]) or (not got_algo) or ((style_index == 0) and not got_orb_gen and (current_turn < cutoffs[1])):
research_priority = settings[0] * industry_priority # high research at beginning of game to get easy gro tech and to get research booster Algotrithmic Elegance
elif (not got_orb_gen) or (current_turn < cutoffs[1]):
research_priority = settings[1] * industry_priority # med-high research
elif current_turn < cutoffs[2]:
research_priority = settings[2] * industry_priority # med-high industry
elif current_turn < cutoffs[3]:
research_priority = settings[3] * industry_priority # med-high industry
else:
research_queue = list(empire.researchQueue)
research_priority = settings[4] * industry_priority # high industry , low research
if len(research_queue) == 0:
research_priority = 0 # done with research
elif len(research_queue) < 5 and research_queue[-1].allocation > 0:
research_priority = len(research_queue) * 0.01 * industry_priority # barely not done with research
elif len(research_queue) < 10 and research_queue[-1].allocation > 0:
research_priority = (4 + 2 * len(research_queue)) * 0.01 * industry_priority # almost done with research
elif len(research_queue) < 20 and research_queue[int(len(research_queue) / 2)].allocation > 0:
research_priority *= 0.7 # closing in on end of research
if industry_surge:
if galaxy_is_sparse and not any(enemies_sighted):
research_priority *= 0.5
else:
research_priority *= 0.8
if ((tech_is_complete("SHP_WEAPON_2_4") or
tech_is_complete("SHP_WEAPON_4_1")) and
tech_is_complete(AIDependencies.PROD_AUTO_NAME)):
# industry_factor = [ [0.25, 0.2], [0.3, 0.25], [0.3, 0.25] ][style_index ]
# researchPriority = min(researchPriority, industry_factor[got_solar_gen]*industryPriority)
research_priority *= 0.9
if got_quant:
research_priority = min(research_priority + 0.1 * industry_priority, research_priority * 1.3)
research_priority = int(research_priority)
print "Research Production (current/target) : ( %.1f / %.1f )" % (total_rp, target_rp)
print "Priority for Research: %d (new target ~ %d RP)" % (research_priority, total_pp * research_priority / industry_priority)
if len(enemies_sighted) < (2 + current_turn/20.0): # TODO: adjust for colonisation priority
research_priority *= 1.2
if (current_turn > 20) and (len(recent_enemies) > 3):
research_priority *= 0.8
return research_priority
def evaluate_invasion_planet(planet_id, secure_fleet_missions, verbose=True):
"""Return the invasion value (score, troops) of a planet."""
universe = fo.getUniverse()
empire_id = fo.empireID()
detail = []
planet = universe.getPlanet(planet_id)
if planet is None:
debug("Invasion AI couldn't access any info for planet id %d" % planet_id)
return [0, 0]
system_id = planet.systemID
# by using the following instead of simply relying on stealth meter reading, can (sometimes) plan ahead even if
# planet is temporarily shrouded by an ion storm
predicted_detectable = EspionageAI.colony_detectable_by_empire(planet_id, empire=fo.empireID(),
default_result=False)
if not predicted_detectable:
if get_partial_visibility_turn(planet_id) < fo.currentTurn():
debug("InvasionAI predicts planet id %d to be stealthed" % planet_id)
return [0, 0]
else:
debug("InvasionAI predicts planet id %d to be stealthed" % planet_id +
", but somehow have current visibity anyway, will still consider as target")
# Check if the target planet was extra-stealthed somehow its system was last viewed
# this test below may augment the tests above, but can be thrown off by temporary combat-related sighting
system_last_seen = get_partial_visibility_turn(planet_id)
planet_last_seen = get_partial_visibility_turn(system_id)
if planet_last_seen < system_last_seen:
# TODO: track detection strength, order new scouting when it goes up
debug("Invasion AI considering planet id %d (stealthed at last view), still proceeding." % planet_id)
# get a baseline evaluation of the planet as determined by ColonisationAI
species_name = planet.speciesName
species = fo.getSpecies(species_name)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values([planet_id], MissionType.INVASION, None, detail)
colony_base_value = max(0.75 * planet_eval.get(planet_id, [0])[0],
ColonisationAI.evaluate_planet(planet_id, MissionType.OUTPOST, None, detail))
else:
colony_base_value = ColonisationAI.evaluate_planet(planet_id, MissionType.INVASION, species_name, detail)
# Add extra score for all buildings on the planet
building_values = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
bld_tally = 0
for bldType in [universe.getBuilding(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
# Add extra score for unlocked techs when we conquer the species
tech_tally = 0
value_per_pp = 4
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_value = value_per_pp * rp_cost
tech_tally += tech_value
detail.append("%s: %d" % (unlocked_tech, tech_value))
max_jumps = 8
capitol_id = PlanetUtilsAI.get_capital()
least_jumps_path = []
clear_path = True
if capitol_id:
homeworld = universe.getPlanet(capitol_id)
if homeworld and homeworld.systemID != INVALID_ID and system_id != INVALID_ID:
least_jumps_path = list(universe.leastJumpsPath(homeworld.systemID, system_id, empire_id))
max_jumps = len(least_jumps_path)
aistate = get_aistate()
system_status = aistate.systemStatus.get(system_id, {})
system_fleet_treat = system_status.get('fleetThreat', 1000)
system_monster_threat = system_status.get('monsterThreat', 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get('planetThreat', 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = aistate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000) + path_leg_status.get('monsterThreat', 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
troop_regen = planet.currentMeterValue(fo.meterType.troops) - planet.initialMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(system_id)
secure_targets = [system_id] + list(this_system.planetIDs)
system_secured = False
for mission in secure_fleet_missions:
if system_secured:
break
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != system_id:
continue
if mission.type in [MissionType.SECURE, MissionType.MILITARY]:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get('myFleetRating', 0)
if verbose:
debug("Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f",
planet, planet.currentMeterValue(fo.meterType.maxShield), system_fleet_treat, system_monster_threat)
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (planet.currentMeterValue(fo.meterType.targetIndustry) +
2*planet.currentMeterValue(fo.meterType.targetResearch))
# devalue invasions that would require too much military force
preferred_max_portion = MilitaryAI.get_preferred_max_military_portion_for_single_battle()
total_max_mil_rating = MilitaryAI.get_concentrated_tot_mil_rating()
threat_exponent = 2 # TODO: make this a character trait; higher aggression with a lower exponent
threat_factor = min(1, preferred_max_portion * total_max_mil_rating/(sys_total_threat+0.001))**threat_exponent
design_id, _, locs = ProductionAI.get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(troops + troop_regen*(max_jumps + build_time), max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / 6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(design.troopCapacity,
CombatRatingsAI.get_species_troops_grade(species_here))
planned_troops = troops if system_secured else min(troops + troop_regen*(max_jumps + build_time), max_troops)
planned_troops += .01 # we must attack with more troops than there are defenders
ships_needed = math.ceil((planned_troops+_TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints, 1)
normalized_cost = max(1., normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = colony_base_value + bld_tally + tech_tally + enemy_val - cost_score
# If the AI does have enough total miltary to attack this target, and the target is more than minimally valuable,
# don't let the threat_factor discount the adjusted value below MIN_INVASION_SCORE +1, so that if there are no
# other targets the AI could still pursue this one. Otherwise, scoring pressure from
# MilitaryAI.get_preferred_max_military_portion_for_single_battle might prevent the AI from attacking heavily
# defended but still defeatable targets even if it has no softer targets available.
if total_max_mil_rating > sys_total_threat and base_score > 2 * MIN_INVASION_SCORE:
threat_factor = max(threat_factor, (MIN_INVASION_SCORE + 1)/base_score)
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(0, base_score)
if clear_path:
planet_score *= 1.5
if verbose:
debug(' - planet score: %.2f\n'
' - planned troops: %.2f\n'
' - projected troop cost: %.1f\n'
' - threat factor: %s\n'
' - planet detail: %s\n'
' - popval: %.1f\n'
' - bldval: %s\n'
' - enemyval: %s',
planet_score, planned_troops, troop_cost, threat_factor, detail, colony_base_value, bld_tally, enemy_val)
debug(' - system secured: %s' % system_secured)
return [planet_score, planned_troops]
def evaluateInvasionPlanet(planetID, missionType, fleetSupplyablePlanetIDs, empire, secureAIFleetMissions, verbose=True):
"return the invasion value (score, troops) of a planet"
detail = []
buildingValues = {"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
#TODO: add more factors, as used for colonization
universe = fo.getUniverse()
empireID = empire.empireID
maxJumps=8
planet = universe.getPlanet(planetID)
if (planet == None) : #TODO: exclude planets with stealth higher than empireDetection
print "invasion AI couldn't access any info for planet id %d"%planetID
return [0, 0]
sysPartialVisTurn = dictFromMap(universe.getVisibilityTurnsMap(planet.systemID, empireID)).get(fo.visibility.partial, -9999)
planetPartialVisTurn = dictFromMap(universe.getVisibilityTurnsMap(planetID, empireID)).get(fo.visibility.partial, -9999)
if planetPartialVisTurn < sysPartialVisTurn:
print "invasion AI couldn't get current info on planet id %d (was stealthed at last sighting)"%planetID
return [0, 0] #last time we had partial vis of the system, the planet was stealthed to us #TODO: track detection strength, order new scouting when it goes up
specName=planet.speciesName
species=fo.getSpecies(specName)
if not species: #this call iterates over this Empire's available species with which it could colonize after an invasion
planetEval = ColonisationAI.assignColonisationValues([planetID], EnumsAI.AIFleetMissionType.FLEET_MISSION_COLONISATION, [planetID], None, empire, detail) #evaluatePlanet is imported from ColonisationAI
popVal = max( 0.75*planetEval.get(planetID, [0])[0], ColonisationAI.evaluatePlanet(planetID, EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST, [planetID], None, empire, detail) )
else:
popVal = ColonisationAI.evaluatePlanet(planetID, EnumsAI.AIFleetMissionType.FLEET_MISSION_COLONISATION, [planetID], specName, empire, detail) #evaluatePlanet is imported from ColonisationAI
bldTally=0
for bldType in [universe.getObject(bldg).buildingTypeName for bldg in planet.buildingIDs]:
bval = buildingValues.get(bldType, 50)
bldTally += bval
detail.append("%s: %d"%(bldType, bval))
pSysID = planet.systemID
capitolID = PlanetUtilsAI.getCapital()
leastJumpsPath = []
clear_path = True
if capitolID:
homeworld = universe.getPlanet(capitolID)
if homeworld:
homeSystemID = homeworld.systemID
evalSystemID = planet.systemID
if (homeSystemID != -1) and (evalSystemID != -1):
leastJumpsPath = list(universe.leastJumpsPath(homeSystemID, evalSystemID, empireID))
maxJumps = len(leastJumpsPath)
system_status = foAI.foAIstate.systemStatus.get(pSysID, {})
sysFThrt = system_status.get('fleetThreat', 1000 )
sysMThrt = foAI.foAIstate.systemStatus.get(pSysID, {}).get('monsterThreat', 0 )
sysPThrt = foAI.foAIstate.systemStatus.get(pSysID, {}).get('planetThreat', 0 )
sysTotThrt = sysFThrt + sysMThrt + sysPThrt
max_path_threat = sysFThrt
mil_ship_rating = ProductionAI.curBestMilShipRating()
for path_sys_id in leastJumpsPath:
path_leg_status = foAI.foAIstate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get('fleetThreat', 1000 ) + path_leg_status.get('monsterThreat', 0 )
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
troops = planet.currentMeterValue(fo.meterType.troops)
maxTroops = planet.currentMeterValue(fo.meterType.maxTroops)
this_system = universe.getSystem(pSysID)
secure_targets = [pSysID] + list(this_system.planetIDs)
system_secured = False
for mission in secureAIFleetMissions:
if system_secured:
break
secure_fleet_id = mission.target_id
s_fleet = universe.getFleet(secure_fleet_id)
if (not s_fleet) or (s_fleet.systemID != pSysID):
continue
for ai_target in mission.getAITargets(EnumsAI.AIFleetMissionType.FLEET_MISSION_SECURE):
target_obj = ai_target.target_obj
if (target_obj is not None) and target_obj.id in secure_targets:
system_secured = True
break
pmaxShield = planet.currentMeterValue(fo.meterType.maxShield)
if verbose:
print "invasion eval of %s %d --- maxShields %.1f -- sysFleetThreat %.1f -- sysMonsterThreat %.1f"%(planet.name, planetID, pmaxShield, sysFThrt, sysMThrt)
supplyVal=0
enemyVal=0
if planet.owner!=-1 : #value in taking this away from an enemy
enemyVal= 20* (planet.currentMeterValue(fo.meterType.targetIndustry) + 2*planet.currentMeterValue(fo.meterType.targetResearch))
if pSysID in ColonisationAI.annexableSystemIDs: #TODO: extend to rings
supplyVal = 100
elif pSysID in ColonisationAI.annexableRing1:
supplyVal = 200
elif pSysID in ColonisationAI.annexableRing2:
supplyVal = 300
elif pSysID in ColonisationAI.annexableRing2:
supplyVal = 400
if ( max_path_threat > 0.5 * mil_ship_rating ):
if ( max_path_threat < 3 * mil_ship_rating ):
supplyVal *= 0.5
else:
supplyVal *= 0.2
threatFactor = min(1, 0.2*MilitaryAI.totMilRating/(sysTotThrt+0.001))**2 #devalue invasions that would require too much military force
buildTime=4
if system_secured:
plannedTroops = troops
else:
plannedTroops = min(troops+maxJumps+buildTime, maxTroops)
if ( empire.getTechStatus("SHP_ORG_HULL") != fo.techStatus.complete ):
troopCost = math.ceil( plannedTroops/6.0) * ( 40*( 1+foAI.foAIstate.shipCount * AIDependencies.shipUpkeep ) )
else:
troopCost = math.ceil( plannedTroops/6.0) * ( 20*( 1+foAI.foAIstate.shipCount * AIDependencies.shipUpkeep ) )
planet_score = threatFactor*max(0, popVal+supplyVal+bldTally+enemyVal-0.8*troopCost)
if clear_path:
planet_score *= 1.5
invscore = [ planet_score, plannedTroops ]
print invscore, "projected Troop Cost:", troopCost, ", threatFactor: ", threatFactor, ", planet detail ", detail, "popval, supplyval, bldval, enemyval", popVal, supplyVal, bldTally, enemyVal
return invscore
def __init__(self, aggression):
# Do not allow to create AIstate instances with an invalid version number.
if not hasattr(AIstate, 'version'):
raise ConversionError("AIstate must have an integer version attribute for savegame compatibility")
if not isinstance(AIstate.version, int):
raise ConversionError("Version attribute of AIstate must be an integer!")
if AIstate.version < 0:
raise ConversionError("AIstate savegame compatibility version must be a positive integer!")
# need to store the version explicitly as the class variable "version" is only stored in the
# self.__class__.__dict__ while we only pickle the object (i.e. self.__dict__ )
self.version = AIstate.version
# Debug info
# unique id for game
self.uid = self.generate_uid(first=True)
# unique ids for turns. {turn: uid}
self.turn_uids = {}
# see AIstate docstring re importance of int cast for aggression
self._aggression = int(aggression)
# 'global' (?) variables
self.colonisablePlanetIDs = odict()
self.colonisableOutpostIDs = odict() #
self.__aiMissionsByFleetID = {}
self.__shipRoleByDesignID = {}
self.__fleetRoleByID = {}
self.diplomatic_logs = {}
self.__priorityByType = {}
# initialize home system knowledge
universe = fo.getUniverse()
empire = fo.getEmpire()
self.empireID = empire.empireID
homeworld = universe.getPlanet(empire.capitalID)
self.__origin_home_system_id = homeworld.systemID if homeworld else INVALID_ID
self.visBorderSystemIDs = {self.__origin_home_system_id}
self.visInteriorSystemIDs = set()
self.exploredSystemIDs = set()
self.unexploredSystemIDs = {self.__origin_home_system_id}
self.fleetStatus = {} # keys: 'sysID', 'nships', 'rating'
# systemStatus keys:
# 'name', 'neighbors' (sysIDs), '2jump_ring' (sysIDs), '3jump_ring', '4jump_ring', 'enemy_ship_count',
# 'fleetThreat', 'planetThreat', 'monsterThreat' (specifically, immobile nonplanet threat), 'totalThreat',
# 'localEnemyFleetIDs', 'neighborThreat', 'max_neighbor_threat', 'jump2_threat' (up to 2 jumps away),
# 'jump3_threat', 'jump4_threat', 'regional_threat', 'myDefenses' (planet rating), 'myfleets',
# 'myFleetsAccessible'(not just next desitination), 'myFleetRating', 'my_neighbor_rating' (up to 1 jump away),
# 'my_jump2_rating', 'my_jump3_rating', my_jump4_rating', 'local_fleet_threats',
# 'regional_fleet_threats' <== these are only for mobile fleet threats
self.systemStatus = {}
self.needsEmergencyExploration = []
self.newlySplitFleets = {}
self.militaryRating = 0
self.shipCount = 4
self.misc = {} # Keys: "enemies_sighted" (dict[turn: list[fleetIDs]]),
# "observed_empires" (set[enemy empire IDs]),
# "ReassignedFleetMissions" (list[FleetMissions])
self.orbital_colonization_manager = ColonisationAI.OrbitalColonizationManager()
self.qualifyingTroopBaseTargets = {}
# TODO: track on a per-empire basis
self.__empire_standard_enemy = CombatRatingsAI.default_ship_stats().get_stats(hashable=True)
self.empire_standard_enemy_rating = 0 # TODO: track on a per-empire basis
self.character = create_character(aggression, self.empireID)
self.last_turn_played = 0
def evaluate_invasion_planet(planet_id):
"""Return the invasion value (score, troops) of a planet."""
universe = fo.getUniverse()
empire_id = fo.empireID()
detail = []
planet = universe.getPlanet(planet_id)
if planet is None:
debug("Invasion AI couldn't access any info for planet id %d" %
planet_id)
return [0, 0]
system_id = planet.systemID
# by using the following instead of simply relying on stealth meter reading,
# can (sometimes) plan ahead even if planet is temporarily shrouded by an ion storm
predicted_detectable = EspionageAI.colony_detectable_by_empire(
planet_id, empire=fo.empireID(), default_result=False)
if not predicted_detectable:
if get_partial_visibility_turn(planet_id) < fo.currentTurn():
debug("InvasionAI predicts planet id %d to be stealthed" %
planet_id)
return [0, 0]
else:
debug(
"InvasionAI predicts planet id %d to be stealthed" %
planet_id +
", but somehow have current visibility anyway, will still consider as target"
)
# Check if the target planet was extra-stealthed somehow its system was last viewed
# this test below may augment the tests above,
# but can be thrown off by temporary combat-related sighting
system_last_seen = get_partial_visibility_turn(planet_id)
planet_last_seen = get_partial_visibility_turn(system_id)
if planet_last_seen < system_last_seen:
# TODO: track detection strength, order new scouting when it goes up
debug(
"Invasion AI considering planet id %d (stealthed at last view), still proceeding."
% planet_id)
# get a baseline evaluation of the planet as determined by ColonisationAI
species_name = planet.speciesName
species = fo.getSpecies(species_name)
empire_research_list = tuple(element.tech
for element in fo.getEmpire().researchQueue)
if not species or AIDependencies.TAG_DESTROYED_ON_CONQUEST in species.tags:
# this call iterates over this Empire's available species with which it could colonize after an invasion
planet_eval = ColonisationAI.assign_colonisation_values(
[planet_id], MissionType.INVASION, None, detail)
colony_base_value = max(
0.75 * planet_eval.get(planet_id, [0])[0],
calculate_planet_colonization_rating.
calculate_planet_colonization_rating(
planet_id=planet_id,
mission_type=MissionType.OUTPOST,
spec_name=None,
detail=detail,
empire_research_list=empire_research_list,
),
)
else:
colony_base_value = calculate_planet_colonization_rating.calculate_planet_colonization_rating(
planet_id=planet_id,
mission_type=MissionType.INVASION,
spec_name=species_name,
detail=detail,
empire_research_list=empire_research_list,
)
# Add extra score for all buildings on the planet
building_values = {
"BLD_IMPERIAL_PALACE": 1000,
"BLD_CULTURE_ARCHIVES": 1000,
"BLD_AUTO_HISTORY_ANALYSER": 100,
"BLD_SHIPYARD_BASE": 100,
"BLD_SHIPYARD_ORG_ORB_INC": 200,
"BLD_SHIPYARD_ORG_XENO_FAC": 200,
"BLD_SHIPYARD_ORG_CELL_GRO_CHAMB": 200,
"BLD_SHIPYARD_CON_NANOROBO": 300,
"BLD_SHIPYARD_CON_GEOINT": 400,
"BLD_SHIPYARD_CON_ADV_ENGINE": 1000,
"BLD_SHIPYARD_AST": 300,
"BLD_SHIPYARD_AST_REF": 1000,
"BLD_SHIPYARD_ENRG_SOLAR": 1500,
"BLD_INDUSTRY_CENTER": 500,
"BLD_GAS_GIANT_GEN": 200,
"BLD_SOL_ORB_GEN": 800,
"BLD_BLACK_HOLE_POW_GEN": 2000,
"BLD_ENCLAVE_VOID": 500,
"BLD_NEUTRONIUM_EXTRACTOR": 2000,
"BLD_NEUTRONIUM_SYNTH": 2000,
"BLD_NEUTRONIUM_FORGE": 1000,
"BLD_CONC_CAMP": 100,
"BLD_BIOTERROR_PROJECTOR": 1000,
"BLD_SHIPYARD_ENRG_COMP": 3000,
}
bld_tally = 0
for bldType in [
universe.getBuilding(bldg).buildingTypeName
for bldg in planet.buildingIDs
]:
bval = building_values.get(bldType, 50)
bld_tally += bval
detail.append("%s: %d" % (bldType, bval))
# Add extra score for unlocked techs when we conquer the species
tech_tally = 0
value_per_pp = 4
for unlocked_tech in AIDependencies.SPECIES_TECH_UNLOCKS.get(
species_name, []):
if not tech_is_complete(unlocked_tech):
rp_cost = fo.getTech(unlocked_tech).researchCost(empire_id)
tech_value = value_per_pp * rp_cost
tech_tally += tech_value
detail.append("%s: %d" % (unlocked_tech, tech_value))
least_jumps_path, max_jumps = _get_path_from_capital(planet)
clear_path = True
aistate = get_aistate()
system_status = aistate.systemStatus.get(system_id, {})
system_fleet_treat = system_status.get("fleetThreat", 1000)
system_monster_threat = system_status.get("monsterThreat", 0)
sys_total_threat = system_fleet_treat + system_monster_threat + system_status.get(
"planetThreat", 0)
max_path_threat = system_fleet_treat
mil_ship_rating = MilitaryAI.cur_best_mil_ship_rating()
for path_sys_id in least_jumps_path:
path_leg_status = aistate.systemStatus.get(path_sys_id, {})
path_leg_threat = path_leg_status.get(
"fleetThreat", 1000) + path_leg_status.get("monsterThreat", 0)
if path_leg_threat > 0.5 * mil_ship_rating:
clear_path = False
if path_leg_threat > max_path_threat:
max_path_threat = path_leg_threat
pop = planet.currentMeterValue(fo.meterType.population)
target_pop = planet.currentMeterValue(fo.meterType.targetPopulation)
troops = planet.currentMeterValue(fo.meterType.troops)
troop_regen = planet.currentMeterValue(
fo.meterType.troops) - planet.initialMeterValue(fo.meterType.troops)
max_troops = planet.currentMeterValue(fo.meterType.maxTroops)
# TODO: refactor troop determination into function for use in mid-mission updates and also consider defender techs
max_troops += AIDependencies.TROOPS_PER_POP * (target_pop - pop)
this_system = universe.getSystem(system_id)
secure_targets = [system_id] + list(this_system.planetIDs)
system_secured = False
secure_fleets = get_aistate().get_fleet_missions_with_any_mission_types(
[MissionType.SECURE, MissionType.MILITARY])
for mission in secure_fleets:
secure_fleet_id = mission.fleet.id
s_fleet = universe.getFleet(secure_fleet_id)
if not s_fleet or s_fleet.systemID != system_id:
continue
if mission.type in [MissionType.SECURE, MissionType.MILITARY]:
target_obj = mission.target.get_object()
if target_obj is not None and target_obj.id in secure_targets:
system_secured = True
break
system_secured = system_secured and system_status.get("myFleetRating", 0)
debug(
"Invasion eval of %s\n"
" - maxShields: %.1f\n"
" - sysFleetThreat: %.1f\n"
" - sysMonsterThreat: %.1f",
planet,
planet.currentMeterValue(fo.meterType.maxShield),
system_fleet_treat,
system_monster_threat,
)
enemy_val = 0
if planet.owner != -1: # value in taking this away from an enemy
enemy_val = 20 * (
planet.currentMeterValue(fo.meterType.targetIndustry) +
2 * planet.currentMeterValue(fo.meterType.targetResearch))
# devalue invasions that would require too much military force
preferred_max_portion = MilitaryAI.get_preferred_max_military_portion_for_single_battle(
)
total_max_mil_rating = MilitaryAI.get_concentrated_tot_mil_rating()
threat_exponent = 2 # TODO: make this a character trait; higher aggression with a lower exponent
threat_factor = min(
1, preferred_max_portion * total_max_mil_rating /
(sys_total_threat + 0.001))**threat_exponent
design_id, _, locs = get_best_ship_info(PriorityType.PRODUCTION_INVASION)
if not locs or not universe.getPlanet(locs[0]):
# We are in trouble anyway, so just calculate whatever approximation...
build_time = 4
planned_troops = troops if system_secured else min(
troops + troop_regen * (max_jumps + build_time), max_troops)
planned_troops += 0.01 # we must attack with more troops than there are defenders
troop_cost = math.ceil((planned_troops + _TROOPS_SAFETY_MARGIN) /
6.0) * 20 * FleetUtilsAI.get_fleet_upkeep()
else:
loc = locs[0]
species_here = universe.getPlanet(loc).speciesName
design = fo.getShipDesign(design_id)
cost_per_ship = design.productionCost(empire_id, loc)
build_time = design.productionTime(empire_id, loc)
troops_per_ship = CombatRatingsAI.weight_attack_troops(
design.troopCapacity,
get_species_tag_grade(species_here, Tags.ATTACKTROOPS))
planned_troops = troops if system_secured else min(
troops + troop_regen * (max_jumps + build_time), max_troops)
planned_troops += 0.01 # we must attack with more troops than there are defenders
ships_needed = math.ceil(
(planned_troops + _TROOPS_SAFETY_MARGIN) / float(troops_per_ship))
troop_cost = ships_needed * cost_per_ship # fleet upkeep is already included in query from server
# apply some bias to expensive operations
normalized_cost = float(troop_cost) / max(fo.getEmpire().productionPoints,
1)
normalized_cost = max(1.0, normalized_cost)
cost_score = (normalized_cost**2 / 50.0) * troop_cost
base_score = colony_base_value + bld_tally + tech_tally + enemy_val - cost_score
# If the AI does have enough total military to attack this target, and the target is more than minimally valuable,
# don't let the threat_factor discount the adjusted value below MIN_INVASION_SCORE +1, so that if there are no
# other targets the AI could still pursue this one. Otherwise, scoring pressure from
# MilitaryAI.get_preferred_max_military_portion_for_single_battle might prevent the AI from attacking heavily
# defended but still defeatable targets even if it has no softer targets available.
if total_max_mil_rating > sys_total_threat and base_score > 2 * MIN_INVASION_SCORE:
threat_factor = max(threat_factor,
(MIN_INVASION_SCORE + 1) / base_score)
planet_score = retaliation_risk_factor(planet.owner) * threat_factor * max(
0, base_score)
if clear_path:
planet_score *= 1.5
debug(
" - planet score: %.2f\n"
" - planned troops: %.2f\n"
" - projected troop cost: %.1f\n"
" - threat factor: %s\n"
" - planet detail: %s\n"
" - popval: %.1f\n"
" - bldval: %s\n"
" - enemyval: %s",
planet_score,
planned_troops,
troop_cost,
threat_factor,
detail,
colony_base_value,
bld_tally,
enemy_val,
)
debug(" - system secured: %s" % system_secured)
return [planet_score, planned_troops]
def _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 = state.get_number_of_colonies()
colony_growth_barrier = foAI.foAIstate.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 = 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 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 foAI.foAIstate.colonisablePlanetIDs.items()
if min_score < score <= minimal_top]
decent_opportunities = [species_name for (_, (score, species_name)) in foAI.foAIstate.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
