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 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 calculateOutpostPriority():
"""calculates the demand for outpost ships by colonisable planets"""
baseOutpostCost = AIDependencies.OUTPOST_POD_COST
numOutpostPlanetIDs = len(foAI.foAIstate.colonisableOutpostIDs)
numOutpostPlanetIDs = len([
pid
for (pid, (score,
specName)) in foAI.foAIstate.colonisableOutpostIDs.items()
if score > 1.0 * baseOutpostCost / 3.0
][:allottedColonyTargets])
completedTechs = ResearchAI.get_completed_techs()
if numOutpostPlanetIDs == 0 or not AIDependencies.OUTPOSTING_TECH in completedTechs:
return 0
outpostShipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(
EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
numOutpostShips = len(
FleetUtilsAI.extract_fleet_ids_without_mission_types(outpostShipIDs))
outpostPriority = 50 * (numOutpostPlanetIDs -
numOutpostShips) / numOutpostPlanetIDs
# print
# print "Number of Outpost Ships : " + str(numOutpostShips)
# print "Number of Colonisable outposts: " + str(numOutpostPlanetIDs)
print "Priority for outpost ships : " + str(outpostPriority)
if outpostPriority < 1: return 1
return outpostPriority
def calculateResearchPriority():
"calculates the AI empire's demand for research"
universe = fo.getUniverse()
empire = fo.getEmpire()
empireID = empire.empireID
industryPriority = foAI.foAIstate.getPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_PRODUCTION)
gotAlgo = empire.getTechStatus("LRN_ALGO_ELEGANCE") == fo.techStatus.complete
researchQueueList = ResearchAI.getResearchQueueTechs()
orbGenTech = "PRO_ORBITAL_GEN"
totalPP = empire.productionPoints
totalRP = empire.resourceProduction(fo.resourceType.research)
industrySurge= (foAI.foAIstate.aggression > fo.aggression.cautious) and ( totalPP <(30*(foAI.foAIstate.aggression)) ) and (orbGenTech in researchQueueList[:3] or empire.getTechStatus(orbGenTech) == fo.techStatus.complete)
# get current industry production & Target
ownedPlanetIDs = PlanetUtilsAI.getOwnedPlanetsByEmpire(universe.planetIDs, empireID)
planets = map(universe.getPlanet, ownedPlanetIDs)
targetRP = sum( map( lambda x: x.currentMeterValue(fo.meterType.targetResearch), planets) )
styleIndex = empireID%2
cutoffSets = [ [25, 45, 70 ], [35, 50, 70 ] ]
cutoffs = cutoffSets[styleIndex ]
settings = [ [2, .6, .4, .35 ], [1.4, .7, .4, .35 ] ][styleIndex ]
if industrySurge and True:
researchPriority = 0.2 * industryPriority
else:
if (fo.currentTurn() < cutoffs[0]) or not gotAlgo:
researchPriority = settings[0] * industryPriority # high research at beginning of game to get easy gro tech and to get research booster Algotrithmic Elegance
elif fo.currentTurn() < cutoffs[1]:
researchPriority = settings[1] * industryPriority# med-high research
elif fo.currentTurn() < cutoffs[2]:
researchPriority = settings[2] * industryPriority # med-high industry
else:
researchQueue = list(empire.researchQueue)
researchPriority = settings[3] * industryPriority # high industry , low research
if len(researchQueue) == 0 :
researchPriority = 0 # done with research
elif len(researchQueue) <5 and researchQueue[-1].allocation > 0 :
researchPriority = len(researchQueue) # barely not done with research
elif len(researchQueue) <10 and researchQueue[-1].allocation > 0 :
researchPriority = 4+ len(researchQueue) # almost done with research
elif len(researchQueue) <20 and researchQueue[int(len(researchQueue)/2)].allocation > 0 :
researchPriority = 0.5 * researchPriority # closing in on end of research
elif len(researchQueue) <20:
researchPriority = 0.7*researchPriority # high industry , low research
print ""
print "Research Production (current/target) : ( %.1f / %.1f )"%(totalRP, targetRP)
print "Priority for Research: " + str(researchPriority)
return researchPriority
def calculateResearchPriority():
"calculates the AI empire's demand for research"
universe = fo.getUniverse()
empire = fo.getEmpire()
empireID = empire.empireID
gotAlgo = empire.getTechStatus("LRN_ALGO_ELEGANCE") == fo.techStatus.complete
researchQueueList = ResearchAI.getResearchQueueTechs()
orbGenTech = "PRO_ORBITAL_GEN"
totalPP = empire.productionPoints
totalRP = empire.resourceProduction(fo.resourceType.research)
industrySurge= (foAI.foAIstate.aggression > fo.aggression.cautious) and ( totalPP <(30*(foAI.foAIstate.aggression)) ) and (orbGenTech in researchQueueList[:3] or empire.getTechStatus(orbGenTech) == fo.techStatus.complete)
# get current industry production & Target
ownedPlanetIDs = PlanetUtilsAI.getOwnedPlanetsByEmpire(universe.planetIDs, empireID)
planets = map(universe.getPlanet, ownedPlanetIDs)
targetRP = sum( map( lambda x: x.currentMeterValue(fo.meterType.targetResearch), planets) )
styleIndex = empireID%2
styleAdjustmentMap = {0:0, 1:0}#TODO: decide if I want to do anything with this
styleAdjustment = styleAdjustmentMap.get( styleIndex, 0 )
cutoffSets = [ [25, 45, 70 ], [35, 50, 70 ] ]
cutoffs = cutoffSets[styleIndex ]
settings = [ [100, 40, 35, 30 ], [70, 40, 30, 25 ] ][styleIndex ]
if industrySurge and True:
researchPriority = 15+styleAdjustment
else:
if (fo.currentTurn() < cutoffs[0]) or not gotAlgo:
researchPriority = settings[0] # mid industry , high research at beginning of game to get easy gro tech and to get research booster Algotrithmic Elegance
elif fo.currentTurn() < cutoffs[1]:
researchPriority = settings[1] +styleAdjustment# mid industry , mid research
elif fo.currentTurn() < cutoffs[2]:
researchPriority = settings[2]+styleAdjustment # high industry , low research
else:
researchQueue = list(empire.researchQueue)
researchPriority = settings[3]+styleAdjustment # high industry , low research
if len(researchQueue) == 0 :
researchPriority = 0 # done with research
elif len(researchQueue) <5 and researchQueue[-1].allocation > 0 :
researchPriority = len(researchQueue) # barely not done with research
elif len(researchQueue) <10 and researchQueue[-1].allocation > 0 :
researchPriority = 2 # almost done with research
elif len(researchQueue) <20 and researchQueue[int(len(researchQueue)/2)].allocation > 0 :
researchPriority = 5 # closing in on end of research
elif len(researchQueue) <20:
researchPriority = 10 # high industry , low research
print ""
print "Research Production (current/target) : ( %.1f / %.1f )"%(totalRP, targetRP)
print "Priority for Research: " + str(researchPriority)
return researchPriority
def calculateOutpostPriority():
"calculates the demand for outpost ships by colonisable planets"
baseOutpostCost=80
numOutpostPlanetIDs = len(foAI.foAIstate.colonisableOutpostIDs)
numOutpostPlanetIDs = len( [ pid for (pid, (score, specName) ) in foAI.foAIstate.colonisableOutpostIDs if score > 1.0*baseOutpostCost/3.0 ][:allottedColonyTargets] )
completedTechs = ResearchAI.getCompletedTechs()
if numOutpostPlanetIDs == 0 or not 'CON_ENV_ENCAPSUL' in completedTechs:
return 0
outpostShipIDs = FleetUtilsAI.getEmpireFleetIDsByRole(EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
numOutpostShips = len(FleetUtilsAI.extractFleetIDsWithoutMissionTypes(outpostShipIDs))
outpostPriority = 102 * (numOutpostPlanetIDs - numOutpostShips) / numOutpostPlanetIDs
# print ""
# print "Number of Outpost Ships : " + str(numOutpostShips)
# print "Number of Colonisable outposts: " + str(numOutpostPlanetIDs)
print "Priority for outpost ships : " + str(outpostPriority)
if outpostPriority < 1: return 1
return outpostPriority
def calculateOutpostPriority():
"""calculates the demand for outpost ships by colonisable planets"""
baseOutpostCost=80
numOutpostPlanetIDs = len(foAI.foAIstate.colonisableOutpostIDs)
numOutpostPlanetIDs = len( [ pid for (pid, (score, specName) ) in foAI.foAIstate.colonisableOutpostIDs if score > 1.0*baseOutpostCost/3.0 ][:allottedColonyTargets] )
completedTechs = ResearchAI.get_completed_techs()
if numOutpostPlanetIDs == 0 or not AIDependencies.OUTPOSTING_TECH in completedTechs:
return 0
outpostShipIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(EnumsAI.AIFleetMissionType.FLEET_MISSION_OUTPOST)
numOutpostShips = len(FleetUtilsAI.extract_fleet_ids_without_mission_types(outpostShipIDs))
outpostPriority = 50 * (numOutpostPlanetIDs - numOutpostShips) / numOutpostPlanetIDs
# print
# print "Number of Outpost Ships : " + str(numOutpostShips)
# print "Number of Colonisable outposts: " + str(numOutpostPlanetIDs)
print "Priority for outpost ships : " + str(outpostPriority)
if outpostPriority < 1: return 1
return outpostPriority
def generateOrders(): # pylint: disable=invalid-name
"""Called once per turn to tell the Python AI to generate and issue orders to control its empire.
at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
and can be sent to the server for processing."""
try:
rules = fo.getGameRules()
debug("Defined game rules:")
for rule_name, rule_value in rules.getRulesAsStrings().items():
debug("%s: %s", rule_name, rule_value)
debug("Rule RULE_NUM_COMBAT_ROUNDS value: " + str(rules.getInt("RULE_NUM_COMBAT_ROUNDS")))
except Exception as e:
error("Exception %s when trying to get game rules" % e, exc_info=True)
empire = fo.getEmpire()
if empire is None:
fatal("This client has no empire. Doing nothing to generate orders.")
try:
# early abort if no empire. no need to do meter calculations
# on last-seen gamestate if nothing can be ordered anyway...
#
# note that doneTurn() is issued on behalf of the client network
# id, not the empire id, so not having a correct empire id does
# not invalidate doneTurn()
fo.doneTurn()
except Exception as e:
error("Exception %s in doneTurn() on non-existent empire" % e, exc_info=True)
return
if empire.eliminated:
debug("This empire has been eliminated. Aborting order generation")
try:
# early abort if already eliminated. no need to do meter calculations
# on last-seen gamestate if nothing can be ordered anyway...
fo.doneTurn()
except Exception as e:
error("Exception %s while trying doneTurn() on eliminated empire" % e, exc_info=True)
return
# This code block is required for correct AI work.
info("Meter / Resource Pool updating...")
fo.initMeterEstimatesDiscrepancies()
fo.updateMeterEstimates(False)
fo.updateResourcePools()
turn = fo.currentTurn()
aistate = get_aistate()
turn_uid = aistate.set_turn_uid()
debug("\n\n\n" + "=" * 20)
debug("Starting turn %s (%s) of game: %s" % (turn, turn_uid, aistate.uid))
debug("=" * 20 + "\n")
turn_timer.start("AI planning")
# set the random seed (based on galaxy seed, empire name and current turn)
# for game-reload consistency.
random_seed = str(fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
random.seed(random_seed)
universe = fo.getUniverse()
empire = fo.getEmpire()
planet_id = PlanetUtilsAI.get_capital()
planet = None
if planet_id is not None:
planet = universe.getPlanet(planet_id)
aggression_name = get_trait_name_aggression(aistate.character)
debug("***************************************************************************")
debug("******* Log info for AI progress chart script. Do not modify. **********")
debug("Generating Orders")
debug("EmpireID: {empire.empireID}"
" Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
" Turn: {turn}".format(empire=empire, p_id=fo.playerID(), p_name=fo.playerName(),
res_idx=ResearchAI.get_research_index(), turn=turn,
aggression=aggression_name.capitalize()))
debug("EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(empire))
if planet:
debug("CapitalID: " + str(planet_id) + " Name: " + planet.name + " Species: " + planet.speciesName)
else:
debug("CapitalID: None Currently Name: None Species: None ")
debug("***************************************************************************")
debug("***************************************************************************")
# When loading a savegame, the AI will already have issued orders for this turn.
# To avoid duplicate orders, generally try not to replay turns. However, for debugging
# purposes it is often useful to replay the turn and observe varying results after
# code changes. Set the replay_after_load flag in the AI config to let the AI issue
# new orders after a game load. Note that the orders from the original savegame are
# still being issued and the AIstate was saved after those orders were issued.
# TODO: Consider adding an option to clear AI orders after load (must save AIstate at turn start then)
if fo.currentTurn() == aistate.last_turn_played:
info("The AIstate indicates that this turn was already played.")
if not check_bool(get_option_dict().get('replay_turn_after_load', 'False')):
info("Aborting new order generation. Orders from savegame will still be issued.")
try:
fo.doneTurn()
except Exception as e:
error("Exception %s while trying doneTurn()" % e, exc_info=True)
return
else:
info("Issuing new orders anyway.")
if turn == 1:
human_player = fo.empirePlayerID(1)
greet = diplomatic_corp.get_first_turn_greet_message()
fo.sendChatMessage(human_player,
'%s (%s): [[%s]]' % (empire.name, get_trait_name_aggression(aistate.character), greet))
aistate.prepare_for_new_turn()
turn_state.state.update()
debug("Calling AI Modules")
# call AI modules
action_list = [ColonisationAI.survey_universe,
ProductionAI.find_best_designs_this_turn,
PriorityAI.calculate_priorities,
ExplorationAI.assign_scouts_to_explore_systems,
ColonisationAI.assign_colony_fleets_to_colonise,
InvasionAI.assign_invasion_fleets_to_invade,
MilitaryAI.assign_military_fleets_to_systems,
FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
ResearchAI.generate_research_orders,
ProductionAI.generate_production_orders,
ResourcesAI.generate_resources_orders,
]
for action in action_list:
try:
main_timer.start(action.__name__)
action()
main_timer.stop()
except Exception as e:
error("Exception %s while trying to %s" % (e, action.__name__), exc_info=True)
main_timer.stop_print_and_clear()
turn_timer.stop_print_and_clear()
debug('Size of issued orders: ' + str(fo.getOrders().size))
turn_timer.start("Server_Processing")
try:
fo.doneTurn()
except Exception as e:
error("Exception %s while trying doneTurn()" % e, exc_info=True) # TODO move it to cycle above
finally:
aistate.last_turn_played = fo.currentTurn()
if using_statprof:
try:
statprof.stop()
statprof.display()
statprof.start()
except:
pass
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 generateOrders(): # pylint: disable=invalid-name
"""Called once per turn to tell the Python AI to generate and issue orders to control its empire.
at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
and can be sent to the server for processing."""
rules = fo.getGameRules()
print "Defined game rules:"
for rule in rules.getRulesAsStrings:
print "Name: " + rule.name + " value: " + str(rule.value)
print "Rule RULE_NUM_COMBAT_ROUNDS value: " + str(
rules.getInt("RULE_NUM_COMBAT_ROUNDS"))
empire = fo.getEmpire()
if empire is None:
print "This client has no empire. Doing nothing to generate orders."
try:
# early abort if no empire. no need to do meter calculations
# on last-seen gamestate if nothing can be ordered anyway...
#
# note that doneTurn() is issued on behalf of the client network
# id, not the empire id, so not having a correct empire id does
# not invalidate doneTurn()
fo.doneTurn()
except Exception as e:
print_error(e)
return
if empire.eliminated:
print "This empire has been eliminated. Aborting order generation"
try:
# early abort if already eliminated. no need to do meter calculations
# on last-seen gamestate if nothing can be ordered anyway...
fo.doneTurn()
except Exception as e:
print_error(e)
return
# This code block is required for correct AI work.
print "Meter / Resource Pool updating..."
fo.initMeterEstimatesDiscrepancies()
fo.updateMeterEstimates(False)
fo.updateResourcePools()
turn = fo.currentTurn()
turn_uid = foAIstate.set_turn_uid()
print "\n\n\n", "=" * 20,
print "Starting turn %s (%s) of game: %s" % (turn, turn_uid,
foAIstate.uid),
print "=" * 20, "\n"
turn_timer.start("AI planning")
# set the random seed (based on galaxy seed, empire name and current turn)
# for game-reload consistency.
random_seed = str(
fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
random.seed(random_seed)
universe = fo.getUniverse()
empire = fo.getEmpire()
planet_id = PlanetUtilsAI.get_capital()
planet = None
if planet_id is not None:
planet = universe.getPlanet(planet_id)
aggression_name = get_trait_name_aggression(foAIstate.character)
print "***************************************************************************"
print "******* Log info for AI progress chart script. Do not modify. **********"
print("Generating Orders")
print(
"EmpireID: {empire.empireID}"
" Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
" Turn: {turn}").format(empire=empire,
p_id=fo.playerID(),
p_name=fo.playerName(),
res_idx=ResearchAI.get_research_index(),
turn=turn,
aggression=aggression_name.capitalize())
print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(
empire)
if planet:
print "CapitalID: " + str(
planet_id
) + " Name: " + planet.name + " Species: " + planet.speciesName
else:
print "CapitalID: None Currently Name: None Species: None "
print "***************************************************************************"
print "***************************************************************************"
if turn == 1:
declare_war_on_all()
human_player = fo.empirePlayerID(1)
greet = diplomatic_corp.get_first_turn_greet_message()
fo.sendChatMessage(
human_player, '%s (%s): [[%s]]' %
(empire.name, get_trait_name_aggression(
foAIstate.character), greet))
# turn cleanup !!! this was formerly done at start of every turn -- not sure why
foAIstate.split_new_fleets()
foAIstate.refresh(
) # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
foAIstate.report_system_threats()
print("Calling AI Modules")
# call AI modules
action_list = [
ColonisationAI.survey_universe,
ProductionAI.find_best_designs_this_turn,
PriorityAI.calculate_priorities,
ExplorationAI.assign_scouts_to_explore_systems,
ColonisationAI.assign_colony_fleets_to_colonise,
InvasionAI.assign_invasion_fleets_to_invade,
MilitaryAI.assign_military_fleets_to_systems,
FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
ResearchAI.generate_research_orders,
ProductionAI.generate_production_orders,
ResourcesAI.generate_resources_orders,
]
for action in action_list:
try:
main_timer.start(action.__name__)
action()
main_timer.stop()
except Exception as e:
print_error(e, location=action.__name__)
main_timer.stop_print_and_clear()
turn_timer.stop_print_and_clear()
turn_timer.start("Server_Processing")
try:
fo.doneTurn()
except Exception as e:
print_error(e) # TODO move it to cycle above
if using_statprof:
try:
statprof.stop()
statprof.display()
statprof.start()
except:
pass
def generateOrders(): # pylint: disable=invalid-name
"""Called once per turn to tell the Python AI to generate and issue orders to control its empire.
at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
and can be sent to the server for processing."""
turn_timer.start("AI planning")
universe = fo.getUniverse()
empire = fo.getEmpire()
planet_id = PlanetUtilsAI.get_capital()
# set the random seed (based on galaxy seed, empire ID and current turn)
# for game-reload consistency
random_seed = str(fo.getGalaxySetupData().seed) + "%03d%05d" % (
fo.empireID(), fo.currentTurn())
random.seed(random_seed)
planet = None
if planet_id is not None:
planet = universe.getPlanet(planet_id)
aggression_name = fo.aggression.values[foAIstate.aggression].name
print "***************************************************************************"
print "********** String for chart. Do not modify. ***************************"
print("Generating Orders")
print(
"EmpireID: {empire.empireID}"
" Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
" Turn: {turn}").format(empire=empire,
p_id=fo.playerID(),
p_name=fo.playerName(),
res_idx=ResearchAI.get_research_index(),
turn=fo.currentTurn(),
aggression=aggression_name.capitalize())
print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(
empire)
if planet:
print "CapitalID: " + str(
planet_id
) + " Name: " + planet.name + " Species: " + planet.speciesName
else:
print "CapitalID: None Currently Name: None Species: None "
print "***************************************************************************"
print "***************************************************************************"
if fo.currentTurn() == 1:
declare_war_on_all()
human_player = fo.empirePlayerID(1)
fo.sendChatMessage(
human_player,
'%s Empire (%s):\n"Ave, Human, morituri te salutant!"' %
(empire.name, aggression_name))
# turn cleanup !!! this was formerly done at start of every turn -- not sure why
foAIstate.split_new_fleets()
foAIstate.refresh(
) # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
foAIstate.report_system_threats()
# ...missions
# ...demands/priorities
print("Calling AI Modules")
# call AI modules
action_list = [
PriorityAI.calculate_priorities,
ExplorationAI.assign_scouts_to_explore_systems,
ColonisationAI.assign_colony_fleets_to_colonise,
InvasionAI.assign_invasion_fleets_to_invade,
MilitaryAI.assign_military_fleets_to_systems,
FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
ResearchAI.generate_research_orders,
ProductionAI.generateProductionOrders,
ResourcesAI.generate_resources_orders,
foAIstate.after_turn_cleanup,
]
for action in action_list:
try:
main_timer.start(action.__name__)
action()
main_timer.stop()
except Exception as e:
print_error(e, location=action.__name__)
main_timer.end()
turn_timer.end()
turn_timer.start("Server_Processing")
try:
fo.doneTurn()
except Exception as e:
print_error(e) # TODO move it to cycle above
if using_statprof:
try:
statprof.stop()
statprof.display()
statprof.start()
except:
pass
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 generateOrders(): # pylint: disable=invalid-name
"""
Called once per turn to tell the Python AI to generate
and issue orders, i.e. to control its empire.
After leaving this function, the AI's turn will be finished
and its orders will be sent to the server.
"""
try:
rules = fo.getGameRules()
debug("Defined game rules:")
for rule_name, rule_value in rules.getRulesAsStrings().items():
debug("%s: %s", rule_name, rule_value)
debug("Rule RULE_NUM_COMBAT_ROUNDS value: " +
str(rules.getInt("RULE_NUM_COMBAT_ROUNDS")))
except Exception as e:
error("Exception %s when trying to get game rules" % e, exc_info=True)
# If nothing can be ordered anyway, exit early.
# Note that there is no need to update meters etc. in this case.
empire = fo.getEmpire()
if empire is None:
fatal("This client has no empire. Aborting order generation.")
return
if empire.eliminated:
info("This empire has been eliminated. Aborting order generation.")
return
# This code block is required for correct AI work.
info("Meter / Resource Pool updating...")
fo.initMeterEstimatesDiscrepancies()
fo.updateMeterEstimates(False)
fo.updateResourcePools()
turn = fo.currentTurn()
aistate = get_aistate()
debug("\n\n\n" + "=" * 20)
debug(f"Starting turn {turn}")
debug("=" * 20 + "\n")
turn_timer.start("AI planning")
# set the random seed (based on galaxy seed, empire name and current turn)
# for game-reload consistency.
random_seed = str(
fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
random.seed(random_seed)
empire = fo.getEmpire()
aggression_name = get_trait_name_aggression(aistate.character)
debug(
"***************************************************************************"
)
debug(
"******* Log info for AI progress chart script. Do not modify. **********"
)
debug("Generating Orders")
name_parts = (
empire.name,
empire.empireID,
"pid",
fo.playerID(),
fo.playerName(),
"RIdx",
ResearchAI.get_research_index(),
aggression_name.capitalize(),
)
empire_name = "_".join(str(part) for part in name_parts)
debug(f"EmpireID: {empire.empireID} Name: {empire_name} Turn: {turn}")
debug(f"EmpireColors: {empire.colour}")
planet_id = PlanetUtilsAI.get_capital()
if planet_id:
planet = fo.getUniverse().getPlanet(planet_id)
debug("CapitalID: " + str(planet_id) + " Name: " + planet.name +
" Species: " + planet.speciesName)
else:
debug("CapitalID: None Currently Name: None Species: None ")
debug(
"***************************************************************************"
)
debug(
"***************************************************************************"
)
# When loading a savegame, the AI will already have issued orders for this turn.
# To avoid duplicate orders, generally try not to replay turns. However, for debugging
# purposes it is often useful to replay the turn and observe varying results after
# code changes. Set the replay_after_load flag in the AI config to let the AI issue
# new orders after a game load. Note that the orders from the original savegame are
# still being issued and the AIstate was saved after those orders were issued.
# TODO: Consider adding an option to clear AI orders after load (must save AIstate at turn start then)
if fo.currentTurn() == aistate.last_turn_played:
info("The AIstate indicates that this turn was already played.")
if not check_bool(get_option_dict().get("replay_turn_after_load",
"False")):
info(
"Aborting new order generation. Orders from savegame will still be issued."
)
return
info("Issuing new orders anyway.")
if turn == 1:
human_player = fo.empirePlayerID(1)
greet = diplomatic_corp.get_first_turn_greet_message()
fo.sendChatMessage(
human_player, "%s (%s): [[%s]]" %
(empire.name, get_trait_name_aggression(aistate.character), greet))
aistate.prepare_for_new_turn()
debug("Calling AI Modules")
# call AI modules
action_list = [
ColonisationAI.survey_universe,
ShipDesignAI.Cache.update_for_new_turn,
PriorityAI.calculate_priorities,
ExplorationAI.assign_scouts_to_explore_systems,
ColonisationAI.assign_colony_fleets_to_colonise,
InvasionAI.assign_invasion_fleets_to_invade,
MilitaryAI.assign_military_fleets_to_systems,
FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
ResearchAI.generate_research_orders,
ProductionAI.generate_production_orders,
ResourcesAI.generate_resources_orders,
]
for action in action_list:
try:
main_timer.start(action.__name__)
action()
main_timer.stop()
except Exception as e:
error("Exception %s while trying to %s" % (e, action.__name__),
exc_info=True)
main_timer.stop_print_and_clear()
turn_timer.stop_print_and_clear()
turn_timer.start("Server_Processing")
aistate.last_turn_played = fo.currentTurn()
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 generateOrders(): # pylint: disable=invalid-name
"""Called once per turn to tell the Python AI to generate and issue orders to control its empire.
at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
and can be sent to the server for processing."""
turn = fo.currentTurn()
turn_uid = foAIstate.set_turn_uid()
print "Start turn %s (%s) of game: %s" % (turn, turn_uid, foAIstate.uid)
turn_timer.start("AI planning")
universe = fo.getUniverse()
empire = fo.getEmpire()
planet_id = PlanetUtilsAI.get_capital()
# set the random seed (based on galaxy seed, empire ID and current turn)
# for game-reload consistency
random_seed = str(fo.getGalaxySetupData().seed) + "%03d%05d" % (fo.empireID(), turn)
random.seed(random_seed)
planet = None
if planet_id is not None:
planet = universe.getPlanet(planet_id)
aggression_name = fo.aggression.values[foAIstate.aggression].name
print "***************************************************************************"
print "********** String for chart. Do not modify. ***************************"
print ("Generating Orders")
print ("EmpireID: {empire.empireID}"
" Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
" Turn: {turn}").format(empire=empire, p_id=fo.playerID(), p_name=fo.playerName(),
res_idx=ResearchAI.get_research_index(), turn=turn,
aggression=aggression_name.capitalize())
print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(empire)
if planet:
print "CapitalID: " + str(planet_id) + " Name: " + planet.name + " Species: " + planet.speciesName
else:
print "CapitalID: None Currently Name: None Species: None "
print "***************************************************************************"
print "***************************************************************************"
if turn == 1:
declare_war_on_all()
human_player = fo.empirePlayerID(1)
fo.sendChatMessage(human_player, '%s Empire (%s):\n"Ave, Human, morituri te salutant!"' % (empire.name, aggression_name))
# turn cleanup !!! this was formerly done at start of every turn -- not sure why
foAIstate.split_new_fleets()
foAIstate.refresh() # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
foAIstate.report_system_threats()
# ...missions
# ...demands/priorities
print("Calling AI Modules")
# call AI modules
action_list = [ColonisationAI.survey_universe,
ProductionAI.find_best_designs_this_turn,
PriorityAI.calculate_priorities,
ExplorationAI.assign_scouts_to_explore_systems,
ColonisationAI.assign_colony_fleets_to_colonise,
InvasionAI.assign_invasion_fleets_to_invade,
MilitaryAI.assign_military_fleets_to_systems,
FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
ResearchAI.generate_research_orders,
ProductionAI.generateProductionOrders,
ResourcesAI.generate_resources_orders,
foAIstate.after_turn_cleanup,
]
for action in action_list:
try:
main_timer.start(action.__name__)
action()
main_timer.stop()
except Exception as e:
print_error(e, location=action.__name__)
main_timer.end()
turn_timer.end()
turn_timer.start("Server_Processing")
try:
fo.doneTurn()
except Exception as e:
print_error(e) # TODO move it to cycle above
if using_statprof:
try:
statprof.stop()
statprof.display()
statprof.start()
except:
pass
def calculateResearchPriority():
"calculates the AI empire's demand for research"
universe = fo.getUniverse()
empire = fo.getEmpire()
empireID = empire.empireID
industryPriority = foAI.foAIstate.getPriority(EnumsAI.AIPriorityType.PRIORITY_RESOURCE_PRODUCTION)
gotAlgo = empire.getTechStatus("LRN_ALGO_ELEGANCE") == fo.techStatus.complete
got_quant = empire.getTechStatus("LRN_QUANT_NET") == fo.techStatus.complete
researchQueueList = ResearchAI.getResearchQueueTechs()
orbGenTech = "PRO_ORBITAL_GEN"
got_orb_gen = (empire.getTechStatus("PRO_ORBITAL_GEN") == fo.techStatus.complete)
got_solar_gen = (empire.getTechStatus("PRO_SOL_ORB_GEN") == fo.techStatus.complete)
totalPP = empire.productionPoints
totalRP = empire.resourceProduction(fo.resourceType.research)
industrySurge= (foAI.foAIstate.aggression > fo.aggression.cautious) and ( totalPP <(30*(foAI.foAIstate.aggression)) ) and (orbGenTech in researchQueueList[:3] or empire.getTechStatus(orbGenTech) == fo.techStatus.complete)
# get current industry production & Target
ownedPlanetIDs = PlanetUtilsAI.getOwnedPlanetsByEmpire(universe.planetIDs, empireID)
planets = map(universe.getPlanet, ownedPlanetIDs)
targetRP = sum( map( lambda x: x.currentMeterValue(fo.meterType.targetResearch), planets) )
styleIndex = (empireID%3)%2
cutoffSets = [ [25, 45, 70 ], [35, 50, 70 ] ]
cutoffs = cutoffSets[styleIndex ]
settings = [ [1.4, .7, .4, .35 ], [2.0, 1.0, .6, .35 ] ][styleIndex ]
if industrySurge and True:
researchPriority = 0.2 * industryPriority
else:
if (fo.currentTurn() < cutoffs[0]) or (not gotAlgo) or ((styleIndex ==0) and not got_orb_gen):
researchPriority = settings[0] * industryPriority # high research at beginning of game to get easy gro tech and to get research booster Algotrithmic Elegance
elif (not got_orb_gen) or (fo.currentTurn() < cutoffs[1]) :
researchPriority = settings[1] * industryPriority# med-high research
elif (fo.currentTurn() < cutoffs[2]):
researchPriority = settings[2] * industryPriority # med-high industry
else:
researchQueue = list(empire.researchQueue)
researchPriority = settings[3] * industryPriority # high industry , low research
if len(researchQueue) == 0 :
researchPriority = 0 # done with research
elif len(researchQueue) <5 and researchQueue[-1].allocation > 0 :
researchPriority = len(researchQueue) # barely not done with research
elif len(researchQueue) <10 and researchQueue[-1].allocation > 0 :
researchPriority = 4+ len(researchQueue) # almost done with research
elif len(researchQueue) <20 and researchQueue[int(len(researchQueue)/2)].allocation > 0 :
researchPriority = 0.5 * researchPriority # closing in on end of research
elif len(researchQueue) <20:
researchPriority = 0.7*researchPriority # high industry , low research
if ( ((empire.getTechStatus("SHP_WEAPON_2_4") == fo.techStatus.complete) or
(empire.getTechStatus("SHP_WEAPON_4_1") == fo.techStatus.complete)) and
(empire.getTechStatus("PRO_SENTIENT_AUTOMATION") == fo.techStatus.complete) ):
industry_factor = [ [0.25, 0.2], [0.3, 0.25] ][styleIndex ]
researchPriority = min(researchPriority, industry_factor[got_solar_gen]*industryPriority)
if got_quant:
researchPriority = min(researchPriority + 0.1*industryPriority, researchPriority * 1.3)
researchPriority = int(researchPriority)
print ""
print "Research Production (current/target) : ( %.1f / %.1f )"%(totalRP, targetRP)
print "Priority for Research: %d (new target ~ %d RP)"%(researchPriority, totalPP * researchPriority/industryPriority)
return researchPriority
def generateOrders(): # pylint: disable=invalid-name
"""Called once per turn to tell the Python AI to generate and issue orders to control its empire.
at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
and can be sent to the server for processing."""
empire = fo.getEmpire()
if empire is None:
print "This client has no empire. Doing nothing to generate orders."
try:
# early abort if no empire. no need to do meter calculations
# on last-seen gamestate if nothing can be ordered anyway...
#
# note that doneTurn() is issued on behalf of the client network
# id, not the empire id, so not having a correct empire id does
# not invalidate doneTurn()
fo.doneTurn()
except Exception as e:
print_error(e)
return
if empire.eliminated:
print "This empire has been eliminated. Aborting order generation"
try:
# early abort if already eliminated. no need to do meter calculations
# on last-seen gamestate if nothing can be ordered anyway...
fo.doneTurn()
except Exception as e:
print_error(e)
return
# This code block is required for correct AI work.
print "Meter / Resource Pool updating..."
fo.initMeterEstimatesDiscrepancies()
fo.updateMeterEstimates(False)
fo.updateResourcePools()
turn = fo.currentTurn()
turn_uid = foAIstate.set_turn_uid()
print "\n\n\n", "=" * 20,
print "Starting turn %s (%s) of game: %s" % (turn, turn_uid, foAIstate.uid),
print "=" * 20, "\n"
turn_timer.start("AI planning")
# set the random seed (based on galaxy seed, empire name and current turn)
# for game-reload consistency.
random_seed = str(fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
random.seed(random_seed)
universe = fo.getUniverse()
empire = fo.getEmpire()
planet_id = PlanetUtilsAI.get_capital()
planet = None
if planet_id is not None:
planet = universe.getPlanet(planet_id)
aggression_name = get_trait_name_aggression(foAIstate.character)
print "***************************************************************************"
print "******* Log info for AI progress chart script. Do not modify. **********"
print ("Generating Orders")
print ("EmpireID: {empire.empireID}"
" Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
" Turn: {turn}").format(empire=empire, p_id=fo.playerID(), p_name=fo.playerName(),
res_idx=ResearchAI.get_research_index(), turn=turn,
aggression=aggression_name.capitalize())
print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(empire)
if planet:
print "CapitalID: " + str(planet_id) + " Name: " + planet.name + " Species: " + planet.speciesName
else:
print "CapitalID: None Currently Name: None Species: None "
print "***************************************************************************"
print "***************************************************************************"
if turn == 1:
declare_war_on_all()
human_player = fo.empirePlayerID(1)
greet = diplomatic_corp.get_first_turn_greet_message()
fo.sendChatMessage(human_player, '%s (%s): [[%s]]' % (empire.name, get_trait_name_aggression(foAIstate.character), greet))
# turn cleanup !!! this was formerly done at start of every turn -- not sure why
foAIstate.split_new_fleets()
foAIstate.refresh() # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
foAIstate.report_system_threats()
print("Calling AI Modules")
# call AI modules
action_list = [ColonisationAI.survey_universe,
ProductionAI.find_best_designs_this_turn,
PriorityAI.calculate_priorities,
ExplorationAI.assign_scouts_to_explore_systems,
ColonisationAI.assign_colony_fleets_to_colonise,
InvasionAI.assign_invasion_fleets_to_invade,
MilitaryAI.assign_military_fleets_to_systems,
FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
ResearchAI.generate_research_orders,
ProductionAI.generate_production_orders,
ResourcesAI.generate_resources_orders,
]
for action in action_list:
try:
main_timer.start(action.__name__)
action()
main_timer.stop()
except Exception as e:
print_error(e, location=action.__name__)
main_timer.stop_print_and_clear()
turn_timer.stop_print_and_clear()
turn_timer.start("Server_Processing")
try:
fo.doneTurn()
except Exception as e:
print_error(e) # TODO move it to cycle above
if using_statprof:
try:
statprof.stop()
statprof.display()
statprof.start()
except:
pass