def splitFleet(fleetID):
"splits a fleet into its ships"
universe = fo.getUniverse()
empireID = fo.empireID()
fleet = universe.getFleet(fleetID)
newfleets = []
if fleet == None: return []
if not fleet.ownedBy(empireID): return []
if len(list(fleet.shipIDs)) <= 1: # fleet with only one ship cannot be split
return [fleetID]
shipIDs = list( fleet.shipIDs )
for shipID in shipIDs[1:]:
newFleetID = fo.issueNewFleetOrder("Fleet %d"%(shipID), shipID)
if newFleetID:
newFleet=universe.getFleet(newFleetID)
if not newFleet:
print "Error: newly split fleet %d not available from universe"%newFleetID
fo.issueRenameOrder(newFleetID, "Fleet %5d"%newFleetID) #to ease review of debugging logs
fo.issueAggressionOrder(newFleetID, True)
role = foAI.foAIstate.getFleetRole(newFleetID) #and mission?
foAI.foAIstate.getRating(newFleetID) #
newfleets.append(newFleetID)
foAI.foAIstate.newlySplitFleets[newFleetID]=True
else:
print "Error - got no fleet ID back after trying to split a ship from fleet %d"%fleetID
foAI.foAIstate.getFleetRole(fleetID, forceNew=True) #
foAI.foAIstate.updateFleetRating(fleetID) #
foAI.foAIstate.ensureHaveFleetMissions(newfleets)
return newfleets
def issue_order(self):
if not super(OrderRepair, self).issue_order():
return False
fleet_id = self.fleet.id
system_id = self.target.get_system().id
fleet = self.fleet.get_object() # type: fo.fleet
if system_id == fleet.systemID:
aistate = get_aistate()
if aistate.get_fleet_role(fleet_id) == MissionType.EXPLORATION:
if system_id in aistate.needsEmergencyExploration:
aistate.needsEmergencyExploration.remove(system_id)
elif system_id != fleet.nextSystemID:
fo.issueAggressionOrder(fleet_id, False)
start_id = FleetUtilsAI.get_fleet_system(fleet)
dest_id = MoveUtilsAI.get_safe_path_leg_to_dest(
fleet_id, start_id, system_id)
universe = fo.getUniverse()
debug(
"fleet %d with order type(%s) sent to safe leg dest %s and ultimate dest %s"
% (fleet_id, self.ORDER_NAME, universe.getSystem(dest_id),
universe.getSystem(system_id)))
fo.issueFleetMoveOrder(fleet_id, dest_id)
debug("Order issued: %s fleet: %s target: %s" %
(self.ORDER_NAME, self.fleet, self.target))
ships_cur_health, ships_max_health = FleetUtilsAI.get_current_and_max_structure(
fleet_id)
self.executed = (ships_cur_health == ships_max_health)
return True
def issue_order(self):
if not super(OrderRepair, self).issue_order():
return
fleet_id = self.fleet.id
system_id = self.target.get_system().id
fleet = self.fleet.get_object()
if system_id not in [fleet.systemID, fleet.nextSystemID]:
fo.issueAggressionOrder(fleet_id, False)
start_id = [fleet.systemID,
fleet.nextSystemID][fleet.systemID == -1]
dest_id = MoveUtilsAI.get_safe_path_leg_to_dest(
fleet_id, start_id, system_id)
print "fleet %d with order type(%s) sent to safe leg dest %s and ultimate dest %s" % (
fleet_id, self.ORDER_NAME, PlanetUtilsAI.sys_name_ids(
[dest_id]), PlanetUtilsAI.sys_name_ids([system_id]))
fo.issueFleetMoveOrder(fleet_id, dest_id)
print "Order issued: %s fleet: %s target: %s" % (
self.ORDER_NAME, self.fleet, self.target)
if system_id == fleet.systemID:
if foAI.foAIstate.get_fleet_role(
fleet_id) == MissionType.EXPLORATION:
if system_id in foAI.foAIstate.needsEmergencyExploration:
del foAI.foAIstate.needsEmergencyExploration[
foAI.foAIstate.needsEmergencyExploration.index(
system_id)]
self.order_issued = True
def get_fleet_role(self, fleet_id, force_new=False):
"""Returns fleet role by ID."""
if not force_new and fleet_id in self.__fleetRoleByID:
return self.__fleetRoleByID[fleet_id]
else:
role = FleetUtilsAI.assess_fleet_role(fleet_id)
self.__fleetRoleByID[fleet_id] = role
make_aggressive = False
if role in [MissionType.COLONISATION,
MissionType.OUTPOST,
MissionType.ORBITAL_INVASION,
MissionType.ORBITAL_OUTPOST
]:
pass
elif role in [MissionType.EXPLORATION,
MissionType.INVASION
]:
this_rating = self.get_rating(fleet_id) # Done!
n_ships = self.fleetStatus.get(fleet_id, {}).get('nships', 1) # entry sould exist due to above line
if float(this_rating) / n_ships >= 0.5 * MilitaryAI.cur_best_mil_ship_rating():
make_aggressive = True
else:
make_aggressive = True
fo.issueAggressionOrder(fleet_id, make_aggressive)
return role
def get_fleet_role(self, fleet_id, force_new=False):
"""Returns fleet role by ID."""
if not force_new and fleet_id in self.__fleetRoleByID:
return self.__fleetRoleByID[fleet_id]
else:
role = FleetUtilsAI.assess_fleet_role(fleet_id)
self.__fleetRoleByID[fleet_id] = role
make_aggressive = False
if role in [MissionType.COLONISATION,
MissionType.OUTPOST,
MissionType.ORBITAL_INVASION,
MissionType.ORBITAL_OUTPOST
]:
pass
elif role in [MissionType.EXPLORATION,
MissionType.INVASION
]:
this_rating = self.get_rating(fleet_id) # Done!
n_ships = self.fleetStatus.get(fleet_id, {}).get('nships', 1) # entry sould exist due to above line
if float(this_rating) / n_ships >= 0.5 * MilitaryAI.cur_best_mil_ship_rating():
make_aggressive = True
else:
make_aggressive = True
fo.issueAggressionOrder(fleet_id, make_aggressive)
return role
def split_fleet(fleet_id):
"""Split a fleet into its ships.
:param fleet_id: fleet to be split.
:type fleet_id: int
:return: New fleets. Empty if couldn't split.
:rtype: list[int]
"""
universe = fo.getUniverse()
empire_id = fo.empireID()
fleet = universe.getFleet(fleet_id)
newfleets = []
if fleet is None:
return []
if not fleet.ownedBy(empire_id):
return []
if len(list(
fleet.shipIDs)) <= 1: # fleet with only one ship cannot be split
return []
ship_ids = list(fleet.shipIDs)
aistate = get_aistate()
for ship_id in ship_ids[1:]:
new_fleet_id = fo.issueNewFleetOrder("Fleet %4d" % ship_id, ship_id)
if new_fleet_id:
new_fleet = universe.getFleet(new_fleet_id)
if not new_fleet:
warn("Newly split fleet %d not available from universe" %
new_fleet_id)
fo.issueRenameOrder(
new_fleet_id,
"Fleet %4d" % new_fleet_id) # to ease review of debugging logs
fo.issueAggressionOrder(new_fleet_id, True)
aistate.update_fleet_rating(new_fleet_id)
newfleets.append(new_fleet_id)
aistate.newlySplitFleets[new_fleet_id] = True
else:
if fleet.systemID == INVALID_ID:
warn(
"Tried to split ship id (%d) from fleet %d when fleet is in starlane"
% (ship_id, fleet_id))
else:
warn(
"Got no fleet ID back after trying to split ship id (%d) from fleet %d"
% (ship_id, fleet_id))
aistate.get_fleet_role(fleet_id, force_new=True)
aistate.update_fleet_rating(fleet_id)
if newfleets:
aistate.ensure_have_fleet_missions(newfleets)
return newfleets
def split_fleet(fleet_id):
"""Split a fleet into its ships.
:param fleet_id: fleet to be split.
:type fleet_id: int
:return: New fleets. Empty if couldn't split.
:rtype: list[int]
"""
universe = fo.getUniverse()
empire_id = fo.empireID()
fleet = universe.getFleet(fleet_id)
newfleets = []
if fleet is None:
return []
if not fleet.ownedBy(empire_id):
return []
if len(list(fleet.shipIDs)) <= 1: # fleet with only one ship cannot be split
return []
ship_ids = list(fleet.shipIDs)
aistate = get_aistate()
for ship_id in ship_ids[1:]:
new_fleet_id = fo.issueNewFleetOrder("Fleet %4d" % ship_id, ship_id)
if new_fleet_id:
new_fleet = universe.getFleet(new_fleet_id)
if not new_fleet:
warn("Newly split fleet %d not available from universe" % new_fleet_id)
fo.issueRenameOrder(new_fleet_id, "Fleet %4d" % new_fleet_id) # to ease review of debugging logs
fo.issueAggressionOrder(new_fleet_id, True)
aistate.update_fleet_rating(new_fleet_id)
newfleets.append(new_fleet_id)
aistate.newlySplitFleets[new_fleet_id] = True
else:
if fleet.systemID == INVALID_ID:
warn("Tried to split ship id (%d) from fleet %d when fleet is in starlane" % (
ship_id, fleet_id))
else:
warn("Got no fleet ID back after trying to split ship id (%d) from fleet %d" % (
ship_id, fleet_id))
aistate.get_fleet_role(fleet_id, force_new=True)
aistate.update_fleet_rating(fleet_id)
if newfleets:
aistate.ensure_have_fleet_missions(newfleets)
return newfleets
def split_ship_from_fleet(fleet_id, ship_id) -> int:
"""Try to split a ship from the fleet, creating a new fleet.
:return: ID of the newly created fleet or INVALID_ID if failed
"""
universe = fo.getUniverse()
fleet = universe.getFleet(fleet_id)
if assertion_fails(fleet is not None):
return INVALID_ID
if assertion_fails(ship_id in fleet.shipIDs):
return INVALID_ID
if assertion_fails(fleet.numShips > 1, "Can't split last ship from fleet"):
return INVALID_ID
new_fleet_id = fo.issueNewFleetOrder("Fleet %4d" % ship_id, ship_id)
if new_fleet_id != INVALID_ID:
aistate = get_aistate()
new_fleet = universe.getFleet(new_fleet_id)
if not new_fleet:
warning("Newly split fleet %d not available from universe" %
new_fleet_id)
debug("Successfully split ship %d from fleet %d into new fleet %d",
ship_id, fleet_id, new_fleet_id)
fo.issueRenameOrder(new_fleet_id, "Fleet %4d" %
new_fleet_id) # to ease review of debugging logs
fo.issueAggressionOrder(new_fleet_id, True)
aistate.update_fleet_rating(new_fleet_id)
aistate.newlySplitFleets[new_fleet_id] = True
# register the new fleets so AI logic is aware of them
sys_status = aistate.systemStatus.setdefault(fleet.systemID, {})
sys_status["myfleets"].append(new_fleet_id)
sys_status["myFleetsAccessible"].append(new_fleet_id)
else:
if fleet.systemID == INVALID_ID:
warning(
"Tried to split ship id (%d) from fleet %d when fleet is in starlane"
% (ship_id, fleet_id))
else:
warning(
"Got no fleet ID back after trying to split ship id (%d) from fleet %d"
% (ship_id, fleet_id))
return new_fleet_id
def getFleetRole(self, fleetID, forceNew=False):
"returns fleet role by ID"
if (not forceNew) and fleetID in self.__fleetRoleByID:
return self.__fleetRoleByID[fleetID]
else:
role=FleetUtilsAI.assessFleetRole(fleetID)
self.__fleetRoleByID[fleetID] = role
makeAggressive=False
if role in [AIFleetMissionType.FLEET_MISSION_COLONISATION, AIFleetMissionType.FLEET_MISSION_OUTPOST]:
pass
if role in [AIFleetMissionType.FLEET_MISSION_EXPLORATION]:
thisRating=self.getRating(fleetID)
if float(thisRating.get('overall', 0))/thisRating.get('nships', 1) >= 0.5 * ProductionAI.curBestMilShipRating():
makeAggressive=True
else:
makeAggressive=True
fo.issueAggressionOrder(fleetID, makeAggressive)
return role
def split_fleet(fleet_id):
"""Splits a fleet into its ships."""
universe = fo.getUniverse()
empire_id = fo.empireID()
fleet = universe.getFleet(fleet_id)
newfleets = []
if fleet is None:
return []
if not fleet.ownedBy(empire_id):
return []
if len(list(
fleet.shipIDs)) <= 1: # fleet with only one ship cannot be split
return []
ship_ids = list(fleet.shipIDs)
for ship_id in ship_ids[1:]:
new_fleet_id = fo.issueNewFleetOrder("Fleet %4d" % ship_id, ship_id)
if new_fleet_id:
new_fleet = universe.getFleet(new_fleet_id)
if not new_fleet:
print "Error: newly split fleet %d not available from universe" % new_fleet_id
fo.issueRenameOrder(
new_fleet_id,
"Fleet %4d" % new_fleet_id) # to ease review of debugging logs
fo.issueAggressionOrder(new_fleet_id, True)
foAI.foAIstate.get_rating(new_fleet_id)
newfleets.append(new_fleet_id)
foAI.foAIstate.newlySplitFleets[new_fleet_id] = True
else:
if fleet.systemID == -1:
print "Error - tried to split ship id (%d) from fleet %d when fleet is in starlane" % (
ship_id, fleet_id)
else:
print "Error - got no fleet ID back after trying to split ship id (%d) from fleet %d" % (
ship_id, fleet_id)
foAI.foAIstate.get_fleet_role(fleet_id, force_new=True)
foAI.foAIstate.update_fleet_rating(fleet_id)
if newfleets:
foAI.foAIstate.ensure_have_fleet_missions(newfleets)
return newfleets
def issue_order(self):
if not super(OrderRepair, self).issue_order():
return
fleet_id = self.fleet.id
system_id = self.target.get_system().id
fleet = self.fleet.get_object()
if system_id not in [fleet.systemID, fleet.nextSystemID]:
fo.issueAggressionOrder(fleet_id, False)
start_id = FleetUtilsAI.get_fleet_system(fleet)
dest_id = MoveUtilsAI.get_safe_path_leg_to_dest(fleet_id, start_id, system_id)
print "fleet %d with order type(%s) sent to safe leg dest %s and ultimate dest %s" % (
fleet_id, self.ORDER_NAME, PlanetUtilsAI.sys_name_ids([dest_id]),
PlanetUtilsAI.sys_name_ids([system_id]))
fo.issueFleetMoveOrder(fleet_id, dest_id)
print "Order issued: %s fleet: %s target: %s" % (self.ORDER_NAME, self.fleet, self.target)
if system_id == fleet.systemID:
if foAI.foAIstate.get_fleet_role(fleet_id) == MissionType.EXPLORATION:
if system_id in foAI.foAIstate.needsEmergencyExploration:
foAI.foAIstate.needsEmergencyExploration.remove(system_id)
self.order_issued = True
def issue_order(self):
if not super(OrderRepair, self).issue_order():
return False
fleet_id = self.fleet.id
system_id = self.target.get_system().id
fleet = self.fleet.get_object() # type: fo.fleet
if system_id == fleet.systemID:
if foAI.foAIstate.get_fleet_role(fleet_id) == MissionType.EXPLORATION:
if system_id in foAI.foAIstate.needsEmergencyExploration:
foAI.foAIstate.needsEmergencyExploration.remove(system_id)
elif system_id != fleet.nextSystemID:
fo.issueAggressionOrder(fleet_id, False)
start_id = FleetUtilsAI.get_fleet_system(fleet)
dest_id = MoveUtilsAI.get_safe_path_leg_to_dest(fleet_id, start_id, system_id)
universe = fo.getUniverse()
print "fleet %d with order type(%s) sent to safe leg dest %s and ultimate dest %s" % (
fleet_id, self.ORDER_NAME, universe.getSystem(dest_id), universe.getSystem(system_id))
fo.issueFleetMoveOrder(fleet_id, dest_id)
print "Order issued: %s fleet: %s target: %s" % (self.ORDER_NAME, self.fleet, self.target)
ships_cur_health, ships_max_health = FleetUtilsAI.get_current_and_max_structure(fleet_id)
self.executed = (ships_cur_health == ships_max_health)
return True
def split_fleet(fleetID):
"""splits a fleet into its ships"""
universe = fo.getUniverse()
empireID = fo.empireID()
fleet = universe.getFleet(fleetID)
newfleets = []
if fleet is None: return []
if not fleet.ownedBy(empireID): return []
if len(list(fleet.shipIDs)) <= 1: # fleet with only one ship cannot be split
return []
shipIDs = list( fleet.shipIDs )
for shipID in shipIDs[1:]:
newFleetID = fo.issueNewFleetOrder("Fleet %d"% shipID, shipID)
if newFleetID:
newFleet=universe.getFleet(newFleetID)
if not newFleet:
print "Error: newly split fleet %d not available from universe"%newFleetID
fo.issueRenameOrder(newFleetID, "Fleet %5d"%newFleetID) #to ease review of debugging logs
fo.issueAggressionOrder(newFleetID, True)
role = foAI.foAIstate.get_fleet_role(newFleetID) #and mission?
foAI.foAIstate.get_rating(newFleetID) #
newfleets.append(newFleetID)
foAI.foAIstate.newlySplitFleets[newFleetID]=True
else:
if fleet.systemID==-1:
print "Error - tried to split ship id (%d) from fleet %d when fleet is in starlane"%(shipID, fleetID)
else:
print "Error - got no fleet ID back after trying to split ship id (%d) from fleet %d"%(shipID, fleetID)
foAI.foAIstate.get_fleet_role(fleetID, forceNew=True) #
foAI.foAIstate.update_fleet_rating(fleetID) #
if newfleets:
foAI.foAIstate.ensure_have_fleet_missions(newfleets)
return newfleets
def split_ship_from_fleet(fleet_id, ship_id):
universe = fo.getUniverse()
fleet = universe.getFleet(fleet_id)
if assertion_fails(fleet is not None):
return
if assertion_fails(ship_id in fleet.shipIDs):
return
if assertion_fails(fleet.numShips > 1, "Can't split last ship from fleet"):
return
new_fleet_id = fo.issueNewFleetOrder("Fleet %4d" % ship_id, ship_id)
if new_fleet_id:
aistate = get_aistate()
new_fleet = universe.getFleet(new_fleet_id)
if not new_fleet:
warn("Newly split fleet %d not available from universe" %
new_fleet_id)
debug("Successfully split ship %d from fleet %d into new fleet %d",
ship_id, fleet_id, new_fleet_id)
fo.issueRenameOrder(new_fleet_id, "Fleet %4d" %
new_fleet_id) # to ease review of debugging logs
fo.issueAggressionOrder(new_fleet_id, True)
aistate.update_fleet_rating(new_fleet_id)
aistate.newlySplitFleets[new_fleet_id] = True
else:
if fleet.systemID == INVALID_ID:
warn(
"Tried to split ship id (%d) from fleet %d when fleet is in starlane"
% (ship_id, fleet_id))
else:
warn(
"Got no fleet ID back after trying to split ship id (%d) from fleet %d"
% (ship_id, fleet_id))
return new_fleet_id
def assign_military_fleets_to_systems(useFleetIDList=None, allocations=None):
# assign military fleets to military theater systems
global MilitaryAllocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doingMain = (useFleetIDList is None)
if doingMain:
baseDefenseIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE)
unassignedBaseDefenseIDs = FleetUtilsAI.extract_fleet_ids_without_mission_types(baseDefenseIDs)
for fleetID in unassignedBaseDefenseIDs:
fleet = universe.getFleet(fleetID)
if not fleet:
continue
sysID = fleet.systemID
aiTarget = AITarget.AITarget(AITargetType.TARGET_SYSTEM, sysID)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
aiFleetMission.clear_fleet_orders()
aiFleetMission.clear_targets( (aiFleetMission.get_mission_types() + [-1])[0] )
missionType = AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE
aiFleetMission.add_target( missionType , aiTarget)
allMilitaryFleetIDs = FleetUtilsAI.get_empire_fleet_ids_by_role(AIFleetMissionType.FLEET_MISSION_MILITARY)
AIstate.militaryFleetIDs = allMilitaryFleetIDs
if not allMilitaryFleetIDs:
MilitaryAllocations = []
return
availMilFleetIDs = list( FleetUtilsAI.extract_fleet_ids_without_mission_types(allMilitaryFleetIDs) )
mil_needing_repair_ids, availMilFleetIDs = avail_mil_needing_repair(availMilFleetIDs)
availMilRating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), availMilFleetIDs ) )
under_repair_mil_rating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), mil_needing_repair_ids ) )
theseAllocations = MilitaryAllocations
print "=================================================="
print "assigning military fleets"
print "---------------------------------"
else:
availMilFleetIDs = list( useFleetIDList )
mil_needing_repair_ids, availMilFleetIDs = avail_mil_needing_repair(availMilFleetIDs)
availMilRating = sum( map(lambda x: foAI.foAIstate.get_rating(x).get('overall', 0), availMilFleetIDs ) )
theseAllocations = allocations
remainingMilRating = availMilRating
#send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
availMilFleetIDs = set(availMilFleetIDs)
for sysID, alloc, minalloc, takeAny in theseAllocations:
if not doingMain and len(availMilFleetIDs)==0:
break
foundFleets = []
foundStats={}
try:
theseFleets = FleetUtilsAI.get_fleets_for_mission(1, {'rating':alloc}, {'rating':minalloc}, foundStats, "", systems_to_check=[sysID], systems_checked=[],
fleet_pool_set=availMilFleetIDs, fleet_list=foundFleets, verbose=False)
except:
continue
if not theseFleets:
if foundFleets==[] or not ( FleetUtilsAI.stats_meet_reqs( foundStats, {'rating':minalloc}) or takeAny):
if doingMain:
if verboseMilReporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s"%(sysID, universe.getSystem(sysID).name, minalloc, foundStats.get('rating', 0), foundFleets)
availMilFleetIDs.update(foundFleets)
continue
else:
theseFleets = foundFleets
#rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, foundFleets )
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum([fr.get('health', 0) for fr in ratings])
if doingMain and verboseMilReporting:
if rating < minMilAllocations.get(sysID, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s"%(sysID, universe.getSystem(sysID).name, minalloc, rating, theseFleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s "%(sysID, universe.getSystem(sysID).name, minMilAllocations.get(sysID, 0) , rating, theseFleets)
elif doingMain and verboseMilReporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s"%(sysID, universe.getSystem(sysID).name, alloc, foundStats.get('rating', 0), theseFleets)
aiTarget = AITarget.AITarget(AITargetType.TARGET_SYSTEM, sysID)
for fleetID in theseFleets:
fleet=universe.getFleet(fleetID)
fo.issueAggressionOrder(fleetID, True)
aiFleetMission = foAI.foAIstate.get_fleet_mission(fleetID)
aiFleetMission.clear_fleet_orders()
aiFleetMission.clear_targets( (aiFleetMission.get_mission_types() + [-1])[0] )
if sysID in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)):
missionType = AIFleetMissionType.FLEET_MISSION_SECURE
else:
missionType = AIFleetMissionType.FLEET_MISSION_MILITARY
aiFleetMission.add_target( missionType , aiTarget)
aiFleetMission.generate_fleet_orders()
if not doingMain:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(aiFleetMission)
if doingMain:
print "---------------------------------"
def assignMilitaryFleetsToSystems():
# assign military fleets to military theater systems
global MilitaryAllocations
universe = fo.getUniverse()
baseDefenseIDs = FleetUtilsAI.getEmpireFleetIDsByRole(AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE)
unassignedBaseDefenseIDs = FleetUtilsAI.extractFleetIDsWithoutMissionTypes(baseDefenseIDs)
for fleetID in unassignedBaseDefenseIDs:
fleet = universe.getFleet(fleetID)
if not fleet:
continue
sysID = fleet.systemID
aiTarget = AITarget.AITarget(AITargetType.TARGET_SYSTEM, sysID)
aiFleetMission = foAI.foAIstate.getAIFleetMission(fleetID)
aiFleetMission.clearAIFleetOrders()
aiFleetMission.clearAITargets( (aiFleetMission.getAIMissionTypes() + [-1])[0] )
missionType = AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE
aiFleetMission.addAITarget( missionType , aiTarget)
allMilitaryFleetIDs = FleetUtilsAI.getEmpireFleetIDsByRole(AIFleetMissionType.FLEET_MISSION_MILITARY)
if allMilitaryFleetIDs == []:
MilitaryAllocations = []
return
#TODO: keep some continuity of missions
AIstate.militaryFleetIDs = FleetUtilsAI.extractFleetIDsWithoutMissionTypes(allMilitaryFleetIDs)
availMilFleetIDs = list( AIstate.militaryFleetIDs )
#availMilFleetIDs = list( allMilitaryFleetIDs)
totMilRating = sum( map(lambda x: foAI.foAIstate.getRating(x).get('overall', 0), allMilitaryFleetIDs ) )
availMilRating = sum( map(lambda x: foAI.foAIstate.getRating(x).get('overall', 0), availMilFleetIDs ) )
print "=================================================="
print "assigning military fleets"
print "---------------------------------"
remainingMilRating = availMilRating
# get systems to defend
availMilFleetIDs = set(availMilFleetIDs)
for sysID, alloc, minalloc, takeAny in MilitaryAllocations:
foundFleets = []
foundStats={}
theseFleets = FleetUtilsAI.getFleetsForMission(1, {'rating':alloc}, {'rating':minalloc}, foundStats, "", systemsToCheck=[sysID], systemsChecked=[],
fleetPoolSet=availMilFleetIDs, fleetList=foundFleets, verbose=False)
if theseFleets == []:
if foundFleets==[] or not ( FleetUtilsAI.statsMeetReqs( foundStats, {'rating':minalloc}) or takeAny):
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s"%(sysID, universe.getSystem(sysID).name, minalloc, foundStats.get('rating', 0), foundFleets)
availMilFleetIDs.update(foundFleets)
continue
else:
theseFleets = foundFleets
#rating = sum( map(lambda x: foAI.foAIstate.rateFleet(x), foundFleets ) )
ratings = map(lambda x: foAI.foAIstate.rateFleet(x), foundFleets )
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum([fr.get('health', 0) for fr in ratings])
if rating < minMilAllocations.get(sysID, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s"%(sysID, universe.getSystem(sysID).name, minalloc, rating, theseFleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s "%(sysID, universe.getSystem(sysID).name, minMilAllocations.get(sysID, 0) , rating, theseFleets)
else:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s"%(sysID, universe.getSystem(sysID).name, alloc, foundStats.get('rating', 0), theseFleets)
aiTarget = AITarget.AITarget(AITargetType.TARGET_SYSTEM, sysID)
for fleetID in theseFleets:
fleet=universe.getFleet(fleetID)
fo.issueAggressionOrder(fleetID, True)
aiFleetMission = foAI.foAIstate.getAIFleetMission(fleetID)
aiFleetMission.clearAIFleetOrders()
aiFleetMission.clearAITargets( (aiFleetMission.getAIMissionTypes() + [-1])[0] )
if sysID in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)):
missionType = AIFleetMissionType.FLEET_MISSION_SECURE
else:
missionType = AIFleetMissionType.FLEET_MISSION_MILITARY
aiFleetMission.addAITarget( missionType , aiTarget)
print "---------------------------------"
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
if doing_main:
foAI.foAIstate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = universe_object.System(sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.add_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = military_allocations
print "=================================================="
print "Assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
try:
these_fleets = FleetUtilsAI.get_fleets_for_mission(1, {'rating': alloc}, {'rating': minalloc}, found_stats, "", systems_to_check=[sys_id], systems_checked=[],
fleet_pool_set=avail_mil_fleet_ids, fleet_list=found_fleets, verbose=False)
except:
continue
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
# rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, found_fleets)
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum([fr.get('health', 0) for fr in ratings])
if doing_main and verbose_mil_reporting:
if rating < minMilAllocations.get(sys_id, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, rating, these_fleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, minMilAllocations.get(sys_id, 0), rating, these_fleets)
elif doing_main and verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets)
target = universe_object.System(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in list(set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs + AIstate.blockadeTargetedSystemIDs)):
mission_type = MissionType.SECURE
else:
mission_type = MissionType.MILITARY
fleet_mission.add_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
print "---------------------------------"
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
print "Still have available military fleets: %s" % avail_mil_fleet_ids
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
def issueOrder(self, considerMergers=False):
global dumpTurn
if not self.canIssueOrder(considerMergers=False): #appears to be redundant with check in IAFleetMission?
print "\tcan't issue %s"%self
else:
universe=fo.getUniverse()
self.__setExecuted()
# outpost
if AIFleetOrderType.ORDER_OUTPOST == self.getAIFleetOrderType():
planet=universe.getPlanet(self.getTargetAITarget().target_id)
if not planet.unowned:
self.__setExecutionCompleted()
return
shipID = None
if AITargetType.TARGET_SHIP == self.getSourceAITarget().target_type:
shipID = self.getSourceAITarget().target_id
elif AITargetType.TARGET_FLEET == self.getSourceAITarget().target_type:
fleetID = self.getSourceAITarget().target_id
shipID = FleetUtilsAI.getShipIDWithRole(fleetID, AIShipRoleType.SHIP_ROLE_CIVILIAN_OUTPOST)
if shipID is None:
shipID = FleetUtilsAI.getShipIDWithRole(fleetID, AIShipRoleType.SHIP_ROLE_BASE_OUTPOST)
result=fo.issueColonizeOrder(shipID, self.getTargetAITarget().target_id)
if result==0:
self.__executed = False
# colonise
elif AIFleetOrderType.ORDER_COLONISE == self.getAIFleetOrderType():
shipID = None
if AITargetType.TARGET_SHIP == self.getSourceAITarget().target_type:
shipID = self.getSourceAITarget().target_id
elif AITargetType.TARGET_FLEET == self.getSourceAITarget().target_type:
fleetID = self.getSourceAITarget().target_id
shipID = FleetUtilsAI.getShipIDWithRole(fleetID, AIShipRoleType.SHIP_ROLE_CIVILIAN_COLONISATION)
if shipID is None:
shipID = FleetUtilsAI.getShipIDWithRole(fleetID, AIShipRoleType.SHIP_ROLE_BASE_COLONISATION)
planetID = self.getTargetAITarget().target_id
planet=universe.getPlanet(planetID)
planetName = (planet and planet.name) or "apparently invisible"
result = fo.issueColonizeOrder(shipID, planetID)
print "Ordered colony ship ID %d to colonize %s, got result %d"%(shipID, planetName, result)
if result==0:
self.__executed = False
# invade
elif AIFleetOrderType.ORDER_INVADE == self.getAIFleetOrderType():
result = False
shipID = None
planetID = self.getTargetAITarget().target_id
planet=universe.getPlanet(planetID)
planetName = (planet and planet.name) or "invisible"
if AITargetType.TARGET_SHIP == self.getSourceAITarget().target_type:
shipID = self.getSourceAITarget().target_id
elif AITargetType.TARGET_FLEET == self.getSourceAITarget().target_type:
fleetID = self.getSourceAITarget().target_id
fleet = fo.getUniverse().getFleet(fleetID)
for shipID in fleet.shipIDs:
ship = universe.getShip(shipID)
if (foAI.foAIstate.getShipRole(ship.design.id) in [AIShipRoleType.SHIP_ROLE_MILITARY_INVASION, AIShipRoleType.SHIP_ROLE_BASE_INVASION]):
result = fo.issueInvadeOrder(shipID, planetID) or result #will track if at least one invasion troops successfully deployed
detailStr = ""
if result == 0:
pstealth = planet.currentMeterValue(fo.meterType.stealth)
pop = planet.currentMeterValue(fo.meterType.population)
shields = planet.currentMeterValue(fo.meterType.shield)
owner = planet.owner
detailStr= " -- planet has %.1f stealth, shields %.1f, %.1f population and is owned by empire %d"%(pstealth, shields, pop, owner)
print "Ordered troop ship ID %d to invade %s, got result %d"%(shipID, planetName, result), detailStr
if result == 0:
if 'needsEmergencyExploration' not in dir(foAI.foAIstate):
foAI.foAIstate.needsEmergencyExploration=[]
if fleet.systemID not in foAI.foAIstate.needsEmergencyExploration:
foAI.foAIstate.needsEmergencyExploration.append(fleet.systemID)
print "Due to trouble invading, adding system %d to Emergency Exploration List"%fleet.systemID
self.__executed = False
if shields >0 and owner==-1 and dumpTurn<fo.currentTurn():
dumpTurn=fo.currentTurn()
print "Universe Dump to debug invasions:"
universe.dump()
break
if result:
print "Successfully ordered troop ship(s) to invade %s, with detail%s "%(planetName, detailStr)
# military
elif AIFleetOrderType.ORDER_MILITARY == self.getAIFleetOrderType():
shipID = None
if AITargetType.TARGET_SHIP == self.getSourceAITarget().target_type:
shipID = self.getSourceAITarget().target_id
elif AITargetType.TARGET_FLEET == self.getSourceAITarget().target_type:
fleetID = self.getSourceAITarget().target_id
shipID = FleetUtilsAI.getShipIDWithRole(fleetID, AIShipRoleType.SHIP_ROLE_MILITARY)
#fo.issueFleetMoveOrder(fleetID, self.getTargetAITarget().target_id) #moving is already taken care of separately
targetSysID = self.getTargetAITarget().target_id
fleet = fo.getUniverse().getFleet(fleetID)
systemStatus = foAI.foAIstate.systemStatus.get(targetSysID, {})
if (fleet )and ( fleet.systemID==targetSysID ) and ((systemStatus.get('fleetThreat', 0) + systemStatus.get('planetThreat', 0)+ systemStatus.get('monsterThreat', 0))==0):
self.__setExecutionCompleted()
# move or resupply
elif self.getAIFleetOrderType() in [ AIFleetOrderType.ORDER_MOVE, AIFleetOrderType.ORDER_REPAIR, AIFleetOrderType.ORDER_RESUPPLY]:
fleetID = self.getSourceAITarget().target_id
system_id = self.getTargetAITarget().target_id
fleet = fo.getUniverse().getFleet(fleetID)
if system_id not in [fleet.systemID, fleet.nextSystemID] :
if self.getAIFleetOrderType() == AIFleetOrderType.ORDER_MOVE:
dest_id = system_id
else:
if self.getAIFleetOrderType() == AIFleetOrderType.ORDER_REPAIR:
fo.issueAggressionOrder(fleetID, False)
start_id = [fleet.systemID, fleet.nextSystemID][ fleet.systemID == -1 ]
dest_id = MoveUtilsAI.get_safe_path_leg_to_dest(fleetID, start_id, system_id)
print "fleet %d with order type(%s) sent to safe leg dest %s and ultimate dest %s"%(fleetID, AIFleetOrderTypeNames.name(self.getAIFleetOrderType()),
PlanetUtilsAI.sysNameIDs([dest_id]),
PlanetUtilsAI.sysNameIDs([system_id]))
fo.issueFleetMoveOrder(fleetID, dest_id)
if system_id == fleet.systemID:
if foAI.foAIstate.getFleetRole(fleetID) == AIFleetMissionType.FLEET_MISSION_EXPLORATION :
if system_id in foAI.foAIstate.needsEmergencyExploration:
del foAI.foAIstate.needsEmergencyExploration[ foAI.foAIstate.needsEmergencyExploration.index(system_id) ]
self.__setExecutionCompleted()
# split fleet
elif AIFleetOrderType.ORDER_SPLIT_FLEET == self.getAIFleetOrderType():
fleetID = self.getSourceAITarget().target_id
shipID = self.getTargetAITarget().target_id
fleet = fo.getUniverse().getFleet(fleetID)
if shipID in fleet.shipIDs:
fo.issueNewFleetOrder(str(shipID), shipID)
self.__setExecutionCompleted()
# attack
elif (AIFleetOrderType.ORDER_ATTACK == self.getAIFleetOrderType()):
fleetID = self.getSourceAITarget().target_id
systemID = self.getTargetAITarget().get_required_system_ai_targets()[0].target_id
fo.issueFleetMoveOrder(fleetID, systemID)
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global _military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
aistate = get_aistate()
if doing_main:
aistate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = TargetSystem(sys_id)
fleet_mission = aistate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.set_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
_military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = _military_allocations
debug("==================================================")
debug("Assigning military fleets")
debug("---------------------------------")
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, rvp, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
debug("Allocating for: %s", TargetSystem(sys_id))
found_fleets = []
found_stats = {}
ensure_return = sys_id not in set(AIstate.colonyTargetedSystemIDs
+ AIstate.outpostTargetedSystemIDs
+ AIstate.invasionTargetedSystemIDs)
these_fleets = FleetUtilsAI.get_fleets_for_mission(
target_stats={'rating': alloc, 'ratingVsPlanets': rvp, 'target_system': TargetSystem(sys_id)},
min_stats={'rating': minalloc, 'ratingVsPlanets': rvp, 'target_system': TargetSystem(sys_id)},
cur_stats=found_stats, starting_system=sys_id, fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets, ensure_return=ensure_return)
if not these_fleets:
debug("Could not allocate any fleets.")
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if _verbose_mil_reporting:
debug("NO available/suitable military allocation for system %d ( %s ) "
"-- requested allocation %8d, found available rating %8d in fleets %s"
% (sys_id, universe.getSystem(sys_id).name, minalloc,
found_stats.get('rating', 0), found_fleets))
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
else:
debug("Assigning fleets %s to target %s", these_fleets, TargetSystem(sys_id))
if doing_main and _verbose_mil_reporting:
debug("FULL+ military allocation for system %d ( %s )"
" -- requested allocation %8d, got %8d with fleets %s"
% (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets))
target = TargetSystem(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = aistate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs):
mission_type = MissionType.SECURE
elif state.get_empire_planets_by_system(sys_id):
mission_type = MissionType.PROTECT_REGION
else:
mission_type = MissionType.MILITARY
fleet_mission.set_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
aistate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
debug("---------------------------------")
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
debug("Round %s - still have available military fleets: %s", thisround, avail_mil_fleet_ids)
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
else:
# assign remaining fleets to nearest systems to protect.
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
def system_score(_fid, _sys_id):
"""Helper function to rank systems by priority"""
jump_distance = universe.jumpDistance(_fid, _sys_id)
if get_system_local_threat(_sys_id):
weight = 10
elif get_system_neighbor_threat(_sys_id):
weight = 3
elif get_system_jump2_threat(_sys_id):
weight = 1
else:
weight = 1 / max(.5, float(state.get_distance_to_enemy_supply(_sys_id)))**1.25
return float(weight) / (jump_distance+1)
for fid in avail_mil_fleet_ids:
fleet = universe.getFleet(fid)
FleetUtilsAI.get_fleet_system(fleet)
systems = state.get_empire_planets_by_system().keys()
if not systems:
continue
sys_id = max(systems, key=lambda x: system_score(fid, x))
debug("Assigning leftover %s to system %d "
"- nothing better to do.", fleet, sys_id)
fleet_mission = aistate.get_fleet_mission(fid)
fleet_mission.clear_fleet_orders()
target_system = TargetSystem(sys_id)
fleet_mission.set_target(MissionType.PROTECT_REGION, target_system)
fleet_mission.generate_fleet_orders()
def assign_military_fleets_to_systems(useFleetIDList=None, allocations=None):
# assign military fleets to military theater systems
global military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (useFleetIDList is None)
if doing_main:
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(
base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = AITarget.AITarget(TargetType.TARGET_SYSTEM, sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_targets(
(fleet_mission.get_mission_types() + [-1])[0])
mission_type = AIFleetMissionType.FLEET_MISSION_ORBITAL_DEFENSE
fleet_mission.add_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(
AIFleetMissionType.FLEET_MISSION_MILITARY)
AIstate.militaryFleetIDs = all_military_fleet_ids
if not all_military_fleet_ids:
military_allocations = []
return
avail_mil_fleet_ids = list(
FleetUtilsAI.extract_fleet_ids_without_mission_types(
all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(
avail_mil_fleet_ids)
these_allocations = military_allocations
print "=================================================="
print "assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(useFleetIDList)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(
avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
try:
these_fleets = FleetUtilsAI.get_fleets_for_mission(
1, {'rating': alloc}, {'rating': minalloc},
found_stats,
"",
systems_to_check=[sys_id],
systems_checked=[],
fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets,
verbose=False)
except:
continue
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(
found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (
sys_id, universe.getSystem(sys_id).name, minalloc,
found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
# rating = sum( map(lambda x: foAI.foAIstate.rate_fleet(x), foundFleets ) )
ratings = map(foAI.foAIstate.get_rating, found_fleets)
rating = sum([fr.get('attack', 0) for fr in ratings]) * sum(
[fr.get('health', 0) for fr in ratings])
if doing_main and verbose_mil_reporting:
if rating < minMilAllocations.get(sys_id, 0):
print "PARTIAL military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (
sys_id, universe.getSystem(sys_id).name, minalloc,
rating, these_fleets)
else:
print "FULL MIN military allocation for system %d ( %s ) -- requested allocation %8d -- got %8d with fleets %s" % (
sys_id, universe.getSystem(sys_id).name,
minMilAllocations.get(sys_id,
0), rating, these_fleets)
elif doing_main and verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (
sys_id, universe.getSystem(sys_id).name, alloc,
found_stats.get('rating', 0), these_fleets)
target = AITarget.AITarget(TargetType.TARGET_SYSTEM, sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_targets(
(fleet_mission.get_mission_types() + [-1])[0])
if sys_id in list(
set(AIstate.colonyTargetedSystemIDs +
AIstate.outpostTargetedSystemIDs +
AIstate.invasionTargetedSystemIDs +
AIstate.blockadeTargetedSystemIDs)):
mission_type = AIFleetMissionType.FLEET_MISSION_SECURE
else:
mission_type = AIFleetMissionType.FLEET_MISSION_MILITARY
fleet_mission.add_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions',
[]).append(fleet_mission)
if doing_main:
print "---------------------------------"
def assign_military_fleets_to_systems(use_fleet_id_list=None, allocations=None, round=1):
# assign military fleets to military theater systems
global _military_allocations
universe = fo.getUniverse()
if allocations is None:
allocations = []
doing_main = (use_fleet_id_list is None)
if doing_main:
foAI.foAIstate.misc['ReassignedFleetMissions'] = []
base_defense_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.ORBITAL_DEFENSE)
unassigned_base_defense_ids = FleetUtilsAI.extract_fleet_ids_without_mission_types(base_defense_ids)
for fleet_id in unassigned_base_defense_ids:
fleet = universe.getFleet(fleet_id)
if not fleet:
continue
sys_id = fleet.systemID
target = universe_object.System(sys_id)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
mission_type = MissionType.ORBITAL_DEFENSE
fleet_mission.set_target(mission_type, target)
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
if not all_military_fleet_ids:
_military_allocations = []
return
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = _military_allocations
print "=================================================="
print "Assigning military fleets"
print "---------------------------------"
else:
avail_mil_fleet_ids = list(use_fleet_id_list)
mil_needing_repair_ids, avail_mil_fleet_ids = avail_mil_needing_repair(avail_mil_fleet_ids)
these_allocations = allocations
# send_for_repair(mil_needing_repair_ids) #currently, let get taken care of by AIFleetMission.generate_fleet_orders()
# get systems to defend
avail_mil_fleet_ids = set(avail_mil_fleet_ids)
for sys_id, alloc, minalloc, rvp, takeAny in these_allocations:
if not doing_main and not avail_mil_fleet_ids:
break
found_fleets = []
found_stats = {}
these_fleets = FleetUtilsAI.get_fleets_for_mission({'rating': alloc, 'ratingVsPlanets': rvp},
{'rating': minalloc, 'ratingVsPlanets': rvp}, found_stats,
starting_system=sys_id, fleet_pool_set=avail_mil_fleet_ids,
fleet_list=found_fleets)
if not these_fleets:
if not found_fleets or not (FleetUtilsAI.stats_meet_reqs(found_stats, {'rating': minalloc}) or takeAny):
if doing_main:
if _verbose_mil_reporting:
print "NO available/suitable military allocation for system %d ( %s ) -- requested allocation %8d, found available rating %8d in fleets %s" % (sys_id, universe.getSystem(sys_id).name, minalloc, found_stats.get('rating', 0), found_fleets)
avail_mil_fleet_ids.update(found_fleets)
continue
else:
these_fleets = found_fleets
elif doing_main and _verbose_mil_reporting:
print "FULL+ military allocation for system %d ( %s ) -- requested allocation %8d, got %8d with fleets %s" % (sys_id, universe.getSystem(sys_id).name, alloc, found_stats.get('rating', 0), these_fleets)
target = universe_object.System(sys_id)
for fleet_id in these_fleets:
fo.issueAggressionOrder(fleet_id, True)
fleet_mission = foAI.foAIstate.get_fleet_mission(fleet_id)
fleet_mission.clear_fleet_orders()
fleet_mission.clear_target()
if sys_id in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs):
mission_type = MissionType.SECURE
else:
mission_type = MissionType.MILITARY
fleet_mission.set_target(mission_type, target)
fleet_mission.generate_fleet_orders()
if not doing_main:
foAI.foAIstate.misc.setdefault('ReassignedFleetMissions', []).append(fleet_mission)
if doing_main:
print "---------------------------------"
last_round = 3
last_round_name = "LastRound"
if round <= last_round:
# check if any fleets remain unassigned
all_military_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role(MissionType.MILITARY)
avail_mil_fleet_ids = list(FleetUtilsAI.extract_fleet_ids_without_mission_types(all_military_fleet_ids))
allocations = []
round += 1
thisround = "Extras Remaining Round %d" % round if round < last_round else last_round_name
if avail_mil_fleet_ids:
print "Still have available military fleets: %s" % avail_mil_fleet_ids
allocations = get_military_fleets(mil_fleets_ids=avail_mil_fleet_ids, try_reset=False, thisround=thisround)
if allocations:
assign_military_fleets_to_systems(use_fleet_id_list=avail_mil_fleet_ids, allocations=allocations, round=round)
def issue_order(self):
global dumpTurn
if not self.can_issue_order(): # appears to be redundant with check in IAFleetMission?
print "\tcan't issue %s" % self
else:
universe = fo.getUniverse()
self.executed = True
# outpost
if AIFleetOrderType.ORDER_OUTPOST == self.order_type:
planet = universe.getPlanet(self.target.target_id)
if not planet.unowned:
self.execution_completed = True
return
fleet_id = self.fleet.target_id
ship_id = FleetUtilsAI.get_ship_id_with_role(fleet_id, AIShipRoleType.SHIP_ROLE_CIVILIAN_OUTPOST)
if ship_id is None:
ship_id = FleetUtilsAI.get_ship_id_with_role(fleet_id, AIShipRoleType.SHIP_ROLE_BASE_OUTPOST)
result = fo.issueColonizeOrder(ship_id, self.target.target_id)
if not result:
self.executed = False
# colonise
elif AIFleetOrderType.ORDER_COLONISE == self.order_type:
fleet_id = self.fleet.target_id
ship_id = FleetUtilsAI.get_ship_id_with_role(fleet_id, AIShipRoleType.SHIP_ROLE_CIVILIAN_COLONISATION)
if ship_id is None:
ship_id = FleetUtilsAI.get_ship_id_with_role(fleet_id, AIShipRoleType.SHIP_ROLE_BASE_COLONISATION)
planet_id = self.target.target_id
planet = universe.getPlanet(planet_id)
planet_name = planet and planet.name or "apparently invisible"
result = fo.issueColonizeOrder(ship_id, planet_id)
print "Ordered colony ship ID %d to colonize %s, got result %d" % (ship_id, planet_name, result)
if not result:
self.executed = False
# invade
elif AIFleetOrderType.ORDER_INVADE == self.order_type:
result = False
planet_id = self.target.target_id
planet = universe.getPlanet(planet_id)
planet_name = planet and planet.name or "invisible"
fleet_id = self.fleet.target_id
fleet = fo.getUniverse().getFleet(fleet_id)
detail_str = ""
for ship_id in fleet.shipIDs:
ship = universe.getShip(ship_id)
if foAI.foAIstate.get_ship_role(ship.design.id) in [AIShipRoleType.SHIP_ROLE_MILITARY_INVASION, AIShipRoleType.SHIP_ROLE_BASE_INVASION]:
result = fo.issueInvadeOrder(ship_id, planet_id) or result # will track if at least one invasion troops successfully deployed
shields = planet.currentMeterValue(fo.meterType.shield)
owner = planet.owner
if not result:
pstealth = planet.currentMeterValue(fo.meterType.stealth)
pop = planet.currentMeterValue(fo.meterType.population)
detail_str = " -- planet has %.1f stealth, shields %.1f, %.1f population and is owned by empire %d" % (pstealth, shields, pop, owner)
print "Ordered troop ship ID %d to invade %s, got result %d" % (ship_id, planet_name, result), detail_str
if not result:
if 'needsEmergencyExploration' not in dir(foAI.foAIstate):
foAI.foAIstate.needsEmergencyExploration = []
if fleet.systemID not in foAI.foAIstate.needsEmergencyExploration:
foAI.foAIstate.needsEmergencyExploration.append(fleet.systemID)
print "Due to trouble invading, adding system %d to Emergency Exploration List" % fleet.systemID
self.executed = False
if shields > 0 and owner == -1 and dumpTurn < fo.currentTurn():
dumpTurn = fo.currentTurn()
print "Universe Dump to debug invasions:"
universe.dump()
break
if result:
print "Successfully ordered troop ship(s) to invade %s, with detail %s" % (planet_name, detail_str)
# military
elif AIFleetOrderType.ORDER_MILITARY == self.order_type:
fleet_id = self.fleet.target_id
#fo.issueFleetMoveOrder(fleet_id, self.target.target_id) #moving is already taken care of separately
target_sys_id = self.target.target_id
fleet = fo.getUniverse().getFleet(fleet_id)
system_status = foAI.foAIstate.systemStatus.get(target_sys_id, {})
if fleet and fleet.systemID == target_sys_id and not (system_status.get('fleetThreat', 0) + system_status.get('planetThreat', 0) + system_status.get('monsterThreat', 0)):
self.execution_completed = True
# move or resupply
elif self.order_type in [AIFleetOrderType.ORDER_MOVE, AIFleetOrderType.ORDER_REPAIR, AIFleetOrderType.ORDER_RESUPPLY]:
fleet_id = self.fleet.target_id
system_id = self.target.target_id
fleet = fo.getUniverse().getFleet(fleet_id)
if system_id not in [fleet.systemID, fleet.nextSystemID]:
if self.order_type == AIFleetOrderType.ORDER_MOVE:
dest_id = system_id
else:
if self.order_type == AIFleetOrderType.ORDER_REPAIR:
fo.issueAggressionOrder(fleet_id, False)
start_id = [fleet.systemID, fleet.nextSystemID][fleet.systemID == -1]
dest_id = MoveUtilsAI.get_safe_path_leg_to_dest(fleet_id, start_id, system_id)
print "fleet %d with order type(%s) sent to safe leg dest %s and ultimate dest %s" % (fleet_id, AIFleetOrderTypeNames.name(self.order_type),
PlanetUtilsAI.sys_name_ids([dest_id]),
PlanetUtilsAI.sys_name_ids([system_id]))
fo.issueFleetMoveOrder(fleet_id, dest_id)
if system_id == fleet.systemID:
if foAI.foAIstate.get_fleet_role(fleet_id) == AIFleetMissionType.FLEET_MISSION_EXPLORATION:
if system_id in foAI.foAIstate.needsEmergencyExploration:
del foAI.foAIstate.needsEmergencyExploration[foAI.foAIstate.needsEmergencyExploration.index(system_id)]
self.execution_completed = True
# split fleet
elif AIFleetOrderType.ORDER_SPLIT_FLEET == self.order_type:
fleet_id = self.fleet.target_id
ship_id = self.target.target_id
fleet = fo.getUniverse().getFleet(fleet_id)
if ship_id in fleet.shipIDs:
fo.issueNewFleetOrder(str(ship_id), ship_id)
self.execution_completed = True
# attack
elif AIFleetOrderType.ORDER_ATTACK == self.order_type:
fleet_id = self.fleet.target_id
fo.issueFleetMoveOrder(fleet_id, self.target.get_required_system_ai_targets()[0].target_id)
