def clean(self):
global invasionTargets
"turn start AIstate cleanup"
fleetsLostBySystem.clear()
fleetsLostByID.clear()
invasionTargets=[]
ExplorationAI.graphFlags.clear()
print "-------------------------------------------------"
print "Border Exploration Update"
print "-------------------------------------------------"
for sysID in list(self.visBorderSystemIDs):
ExplorationAI.followVisSystemConnections(sysID, self.origHomeSystemID)
newlyExplored = ExplorationAI.updateExploredSystems()
nametags=[]
universe = fo.getUniverse()
for sysID in newlyExplored:
newsys = universe.getSystem(sysID)
nametags.append( "ID:%4d -- %20s"%(sysID, (newsys and newsys.name) or"name unknown" ) )# an explored system *should* always be able to be gotten
if newlyExplored:
print "-------------------------------------------------"
print "newly explored systems: \n"+"\n".join(nametags)
print "-------------------------------------------------"
# cleanup fleet roles
#self.updateFleetLocs()
self.__cleanFleetRoles()
self.__cleanAIFleetMissions(FleetUtilsAI.getEmpireFleetIDs())
print "Fleets lost by system: %s"%fleetsLostBySystem
self.updateSystemStatus()
ExplorationAI.updateScoutFleets() #should do this after clearing dead fleets, currently should be already done here
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 splitNewFleets():
"split any fleets (at creation, can have unplanned mix of ship roles)"
print "Review of current Fleet Role/Mission records:"
print "--------------------"
print "Map of Roles keyed by Fleet ID: %s"%foAIstate.getFleetRolesMap()
print "--------------------"
print "Map of Missions keyed by ID:"
for item in foAIstate.getFleetMissionsMap().items():
print " %4d : %s "%item
print "--------------------"
# TODO: check length of fleets for losses or do in AIstat.__cleanRoles
knownFleets= foAIstate.getFleetRolesMap().keys()
foAIstate.newlySplitFleets.clear()
splitableFleets=[]
for fleetID in FleetUtilsAI.getEmpireFleetIDs():
if fleetID in knownFleets: #not a new fleet
continue
else:
splitableFleets.append(fleetID)
if splitableFleets:
universe=fo.getUniverse()
print ("splitting new fleets")
for fleetID in splitableFleets:
fleet = universe.getFleet(fleetID)
if not fleet:
print "Error splittting new fleets; resulting fleet ID %d appears to not exist"%fleetID
continue
fleetLen = len(list(fleet.shipIDs))
if fleetLen ==1:
continue
newFleets = FleetUtilsAI.splitFleet(fleetID) # try splitting fleet
print "\t from splitting fleet ID %4d with %d ships, got %d new fleets:"%(fleetID, fleetLen, len(newFleets))
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 sessionStartCleanup(self):
ResourcesAI.newTargets.clear()
self.newlySplitFleets={}
for fleetID in FleetUtilsAI.getEmpireFleetIDs():
self.getFleetRole(fleetID) #
self.getRating(fleetID) #
self.ensureHaveFleetMissions([fleetID])
self.__cleanFleetRoles(justResumed=True)
fleetsLostBySystem.clear()
fleetsLostByID.clear()
popCtrSystemIDs[:] = []#resets without detroying existing references
colonizedSystems.clear()
empireStars.clear()
popCtrIDs[:] = []
outpostIDs[:] = []
outpostSystemIDs[:] = []
def clean(self):
"turn start AIstate cleanup"
fleetsLostBySystem.clear()
fleetsLostByID.clear()
invasionTargets[:]=[]
exploration_center = PlanetUtilsAI.getCapitalSysID()
if exploration_center == -1: #a bad state probably from an old savegame
exploration_center = self.origHomeSystemID
ExplorationAI.graphFlags.clear()
if fo.currentTurn() < 50:
print "-------------------------------------------------"
print "Border Exploration Update (relative to %s"%(PlanetUtilsAI.sysNameIDs([exploration_center, -1])[0])
print "-------------------------------------------------"
if self.visBorderSystemIDs.keys() == [-1]:
self.visBorderSystemIDs.clear()
self.visBorderSystemIDs[exploration_center] = 1
for sysID in list(self.visBorderSystemIDs):
if fo.currentTurn() < 50:
print "Considering border system %s"%(PlanetUtilsAI.sysNameIDs([sysID, -1])[0])
ExplorationAI.followVisSystemConnections(sysID, exploration_center)
newlyExplored = ExplorationAI.updateExploredSystems()
nametags=[]
universe = fo.getUniverse()
for sysID in newlyExplored:
newsys = universe.getSystem(sysID)
nametags.append( "ID:%4d -- %20s"%(sysID, (newsys and newsys.name) or"name unknown" ) )# an explored system *should* always be able to be gotten
if newlyExplored:
print "-------------------------------------------------"
print "newly explored systems: \n"+"\n".join(nametags)
print "-------------------------------------------------"
# cleanup fleet roles
#self.updateFleetLocs()
self.__cleanFleetRoles()
self.__cleanAIFleetMissions(FleetUtilsAI.getEmpireFleetIDs())
print "Fleets lost by system: %s"%fleetsLostBySystem
self.updateSystemStatus()
ExplorationAI.updateScoutFleets() #should do this after clearing dead fleets, currently should be already done here
def __cleanFleetRoles(self, justResumed=False):
"removes fleetRoles if a fleet has been lost, and update fleet Ratings"
for sysID in self.systemStatus:
self.systemStatus[sysID]['myFleetRating']=0
#deleteRoles = []
universe = fo.getUniverse()
okFleets=FleetUtilsAI.getEmpireFleetIDs()
fleetList = sorted( list( self.__fleetRoleByID ))
unaccountedFleets = set( okFleets ) - set( fleetList )
shipCount=0
print "----------------------------------------------------------------------------------"
print "in CleanFleetRoles"
print "fleetList : %s"%fleetList
print "-----------"
print "FleetUtils empire-owned fleetList : %s"%okFleets
print "-----------"
if unaccountedFleets:
print "Fleets unaccounted for in Empire Records: ", unaccountedFleets
print "-----------"
#print "statusList %s"%[self.fleetStatus[fid] for fid in sorted( self.fleetStatus.keys() ) ]
print "-----------"
minThreatRating = {'overall':MinThreat, 'attack':MinThreat**0.5, 'health':MinThreat**0.5}
fighters = { (0, ((0, 0),), 0.0, 5.0):[0] } # start with a dummy entry
for fleetID in fleetList:
status=self.fleetStatus.setdefault(fleetID, {} )
rating = status.get('rating', {'overall':0, 'attack':0, 'health':0} )
newRating = self.rateFleet(fleetID, self.fleet_summary_to_estats([(1, self.empire_standard_enemy)]))
oldSysID = status.get('sysID', -2)
fleet = universe.getFleet(fleetID)
#if fleet and not fleet.aggressive:
# fleet.setAggressive(True)
if fleet:
sysID = fleet.systemID
if oldSysID in [-2, -1]:
oldSysID = sysID
status['nships']=len(fleet.shipIDs)
shipCount += status['nships']
else:
sysID = oldSysID #can still retrieve a fleet object even if fleet was just destroyed, so shouldn't get here
if (fleetID not in okFleets):# or fleet.empty:
if not ( (self.__fleetRoleByID.get(fleetID, -1) ==-1) ):
if not justResumed:
if rating.get('overall', 0) > MinThreat:
fleetsLostBySystem.setdefault(oldSysID, []).append( rating )
else:
fleetsLostBySystem.setdefault(oldSysID, []).append( minThreatRating )
sys=universe.getSystem(sysID)
sysName=(sys and sys.name) or "unknown"
#print "Fleet %d with role %s was used up, lost or destroyed at sys (%d) %s"%(fleetID, self.__fleetRoleByID[fleetID], sysID, sysName) #perhaps diff message for successful colony fleets
if fleetID in self.__fleetRoleByID:
del self.__fleetRoleByID[fleetID]
if fleetID in self.__aiMissionsByFleetID:
del self.__aiMissionsByFleetID[fleetID]
if fleetID in self.fleetStatus:
del self.fleetStatus[fleetID]
continue
else:#fleet in ok fleets
sys1 = universe.getSystem(sysID)
if sysID==-1:
sys1Name = 'starlane'
else:
sys1Name = (sys1 and sys1.name ) or "unknown"
nextSysID = fleet.nextSystemID
sys2 = universe.getSystem(nextSysID)
if nextSysID==-1:
sys2Name= 'starlane'
else:
sys2Name = (sys2 and sys2.name ) or "unknown"
print "Fleet %d (%s) oldRating: %6d | newRating %6d | at system %d (%s) | next system %d (%s)"%(fleetID, fleet.name, rating.get('overall', 0), newRating.get('overall', 0),
fleet.systemID, sys1Name, fleet.nextSystemID, sys2Name)
print "Fleet %d (%s) summary: %s"%(fleetID, fleet.name, rating.get('summary', None) )
status['rating'] = newRating
for count, sum_stats in newRating['summary']:
if sum_stats[0] > 0:
fighters.setdefault( sum_stats, [0])[0] += count
if nextSysID !=-1:
status['sysID'] = nextSysID
elif sysID !=-1:
status['sysID'] = sysID
else:
mainFleetMission=self.getAIFleetMission(fleetID)
mainMissionType = (mainFleetMission.getAIMissionTypes() + [-1])[0]
if mainMissionType != -1:
mainMissionTargets = mainFleetMission.getAITargets(mainMissionType)
if mainMissionTargets:
mMT0=mainMissionTargets[0]
if mMT0.target_type == AITargetType.TARGET_SYSTEM:
status['sysID'] = mMT0.target_id #hmm, but might still be a fair ways from here
self.shipCount = shipCount
std_fighter = sorted( [ (v, k) for k, v in fighters.items()] )[-1][1]
self.empire_standard_fighter = std_fighter
print "------------------------"
print "Empire Ship Count: ", shipCount
print "Empire standard fighter summary: ", std_fighter
print "------------------------"
def __cleanFleetRoles(self, justResumed=False):
"removes fleetRoles if a fleet has been lost, and update fleet Ratings"
global fleetsLostBySystem
for sysID in self.systemStatus:
self.systemStatus[sysID]['myFleetRating']=0
#deleteRoles = []
universe = fo.getUniverse()
okFleets=FleetUtilsAI.getEmpireFleetIDs()
fleetList = sorted( list( self.__fleetRoleByID ))
print "----------------------------------------------------------------------------------"
print "in CleanFleetRoles"
print "fleetList : %s"%fleetList
print "-----------"
print "FleetUtils empire-owned fleetList : %s"%okFleets
print "-----------"
print "statusList %s"%[self.fleetStatus[fid] for fid in sorted( self.fleetStatus.keys() ) ]
print "-----------"
for fleetID in fleetList:
status=self.fleetStatus.get(fleetID, {} )
rating = status.get('rating', {})
newRating = self.rateFleet(fleetID)
oldSysID = status.get('sysID', -2)
fleet = universe.getFleet(fleetID)
#if fleet and not fleet.aggressive:
# fleet.setAggressive(True)
if fleet:
sysID = fleet.systemID
else:
sysID = oldSysID #can still retrieve a fleet object even if fleet was just destroyed
if (fleetID not in okFleets):# or fleet.empty:
if not ( (self.__fleetRoleByID.get(fleetID, -1) ==-1) ):
if not justResumed:
fleetsLostBySystem.setdefault(sysID, []).append( max(rating.get('overall', 0), MinThreat) )
sys=universe.getSystem(sysID)
sysName=(sys and sys.name) or "unknown"
print "Fleet %d with role %s was used up, lost or destroyed at sys (%d) %s"%(fleetID, self.__fleetRoleByID[fleetID], sysID, sysName) #perhaps diff message for successful colony fleets
if fleetID in self.__fleetRoleByID:
del self.__fleetRoleByID[fleetID]
if fleetID in self.__aiMissionsByFleetID:
del self.__aiMissionsByFleetID[fleetID]
if fleetID in self.fleetStatus:
del self.fleetStatus[fleetID]
continue
else:#fleet not in ok fleets
sys1 = universe.getSystem(sysID)
sys1Name = (sys1 and sys1.name ) or "unknown"
sys2 = universe.getSystem(fleet.nextSystemID)
sys2Name = (sys2 and sys2.name ) or "unknown"
print "Fleet %d (%s) oldRating: %6d | newRating %6d | at system %d (%s) | next system %d (%s)"%(fleetID, fleet.name, rating.get('overall', 0), newRating.get('overall', 0),
fleet.systemID, sys1Name, fleet.nextSystemID, sys2Name)
status['rating'] = newRating
if sysID !=-1:
status['sysID'] = sysID
elif fleet.nextSystemID !=-1:
status['sysID'] = fleet.nextSystemID
else:
mainFleetMission=self.getAIFleetMission(fleetID)
mainMissionType = (mainFleetMission.getAIMissionTypes() + [-1])[0]
if mainMissionType != -1:
mainMissionTargets = mainFleetMission.getAITargets(mainMissionType)
if mainMissionTargets:
mMT0=mainMissionTargets[0]
if mMT0.getAITargetType()==AITargetType.TARGET_SYSTEM:
status['sysID'] = mMT0.getTargetID() #hmm, but might still be a fair ways from here
#status['sysID'] = (fleet.systemID != -1 and fleet.systemID ) or fleet.nextSystemID #universe should still give fleet & fleet.systemID even if just destroyed
self.fleetStatus[fleetID] = status
def updateFleetsRoles():
"updating fleet role records"
print ("Updating fleet role records")
# assign roles to fleets
for fleetID in FleetUtilsAI.getEmpireFleetIDs():
foAIstate.getFleetRole(fleetID) #force assessment if not previously known
