def create_move_orders_to_system( fleet: TargetFleet, target: TargetSystem) -> List["fleet_orders.OrderMove"]: """ Create a list of move orders from the fleet's current system to the target system. :param fleet: Fleet to be moved :param target: target system :return: list of move orders """ # TODO: use Graph Theory to construct move orders # TODO: add priority starting_system = fleet.get_system( ) # current fleet location or current target system if on starlane if starting_system == target: # nothing to do here return [] # if the mission does not end at the targeted system, make sure we can actually return to supply after moving. ensure_return = target.id not in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs) system_targets = can_travel_to_system(fleet.id, starting_system, target, ensure_return=ensure_return) result = [ fleet_orders.OrderMove(fleet, system) for system in system_targets ] if not result and starting_system.id != target.id: warning("fleet %s can't travel to system %s" % (fleet.id, target)) return result
class AIFleetMission(object): """ Stores information about AI mission. Every mission has fleetID and AI targets depending upon AI fleet mission type. :type orders: list[AIFleetOrder] :type target: target.Target | None """ def __init__(self, fleet_id): self.orders = [] self.fleet = TargetFleet(fleet_id) self.type = None self.target = None def __setstate__(self, state): target_type = state.pop("target_type") if state["target"] is not None: object_map = { TargetPlanet.object_name: TargetPlanet, TargetSystem.object_name: TargetSystem, TargetFleet.object_name: TargetFleet } state["target"] = object_map[target_type](state["target"]) state["fleet"] = TargetFleet(state["fleet"]) self.__dict__ = state def __getstate__(self): retval = dict(self.__dict__) # do only store the fleet id not the Fleet object retval["fleet"] = self.fleet.id # store target type and id rather than the object if self.target is not None: retval["target_type"] = self.target.object_name retval["target"] = self.target.id else: retval["target_type"] = None retval["target"] = None return retval def set_target(self, mission_type, target): """ Set mission and target for this fleet. :type mission_type: MissionType :type target: target.Target """ if self.type == mission_type and self.target == target: return if self.type or self.target: debug("Change mission assignment from %s:%s to %s:%s" % (self.type, self.target, mission_type, target)) self.type = mission_type self.target = target def clear_target(self): """Clear target and mission for this fleet.""" self.target = None self.type = None def has_target(self, mission_type, target): """ Check if fleet has specified mission_type and target. :type mission_type: MissionType :type target: target.Target :rtype: bool """ return self.type == mission_type and self.target == target def clear_fleet_orders(self): """Clear this fleets orders but do not clear mission and target.""" self.orders = [] def _get_fleet_order_from_target(self, mission_type, target): """ Get a fleet order according to mission type and target. :type mission_type: MissionType :type target: target.Target :rtype: AIFleetOrder """ fleet_target = TargetFleet(self.fleet.id) return ORDERS_FOR_MISSION[mission_type](fleet_target, target) def check_mergers(self, context=""): """ If possible and reasonable, merge this fleet with others. :param context: Context of the function call for logging purposes :type context: str """ if self.type not in MERGEABLE_MISSION_TYPES: return universe = fo.getUniverse() empire_id = fo.empireID() fleet_id = self.fleet.id main_fleet = universe.getFleet(fleet_id) system_id = main_fleet.systemID if system_id == INVALID_ID: return # can't merge fleets in middle of starlane aistate = get_aistate() system_status = aistate.systemStatus[system_id] # if a combat mission, and only have final order (so must be at final target), don't try # merging if there is no local threat (it tends to lead to fleet object churn) if self.type in COMBAT_MISSION_TYPES and len( self.orders) == 1 and not system_status.get('totalThreat', 0): return destroyed_list = list(universe.destroyedObjectIDs(empire_id)) other_fleets_here = [ fid for fid in system_status.get('myFleetsAccessible', []) if fid != fleet_id and fid not in destroyed_list and universe.getFleet(fid).ownedBy(empire_id) ] if not other_fleets_here: return target_id = self.target.id if self.target else None main_fleet_role = aistate.get_fleet_role(fleet_id) for fid in other_fleets_here: fleet_role = aistate.get_fleet_role(fid) if fleet_role not in COMPATIBLE_ROLES_MAP[main_fleet_role]: continue fleet = universe.getFleet(fid) if not fleet or fleet.systemID != system_id or len( fleet.shipIDs) == 0: continue if not (fleet.speed > 0 or main_fleet.speed == 0): # TODO(Cjkjvfnby) Check this condition continue fleet_mission = aistate.get_fleet_mission(fid) do_merge = False need_left = 0 if (main_fleet_role == MissionType.ORBITAL_DEFENSE) or ( fleet_role == MissionType.ORBITAL_DEFENSE): if main_fleet_role == fleet_role: do_merge = True elif (main_fleet_role == MissionType.ORBITAL_INVASION) or ( fleet_role == MissionType.ORBITAL_INVASION): if main_fleet_role == fleet_role: do_merge = False # TODO: could allow merger if both orb invaders and both same target elif not fleet_mission and (main_fleet.speed > 0) and (fleet.speed > 0): do_merge = True else: if not self.target and (main_fleet.speed > 0 or fleet.speed == 0): do_merge = True else: target = fleet_mission.target.id if fleet_mission.target else None if target == target_id: info( "Military fleet %d (%d ships) has same target as %s fleet %d (%d ships). Merging former " "into latter." % (fid, fleet.numShips, fleet_role, fleet_id, len(main_fleet.shipIDs))) # TODO: should probably ensure that fleetA has aggression on now do_merge = float(min( main_fleet.speed, fleet.speed)) / max( main_fleet.speed, fleet.speed) >= 0.6 elif main_fleet.speed > 0: neighbors = aistate.systemStatus.get( system_id, {}).get('neighbors', []) if target == system_id and target_id in neighbors and self.type == MissionType.SECURE: # consider 'borrowing' for work in neighbor system # TODO check condition need_left = 1.5 * sum( aistate.systemStatus.get(nid, {}).get( 'fleetThreat', 0) for nid in neighbors if nid != target_id) fleet_rating = CombatRatingsAI.get_fleet_rating( fid) if need_left < fleet_rating: do_merge = True if do_merge: FleetUtilsAI.merge_fleet_a_into_b( fid, fleet_id, need_left, context="Order %s of mission %s" % (context, self)) return def _is_valid_fleet_mission_target(self, mission_type, target): if not target: return False if mission_type == MissionType.EXPLORATION: if isinstance(target, TargetSystem): empire = fo.getEmpire() if not empire.hasExploredSystem(target.id): return True elif mission_type in [ MissionType.OUTPOST, MissionType.ORBITAL_OUTPOST ]: fleet = self.fleet.get_object() if not fleet.hasOutpostShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() if planet.unowned: return True elif mission_type == MissionType.COLONISATION: fleet = self.fleet.get_object() if not fleet.hasColonyShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() population = planet.initialMeterValue(fo.meterType.population) if planet.unowned or (planet.owner == fleet.owner and population == 0): return True elif mission_type in [ MissionType.INVASION, MissionType.ORBITAL_INVASION ]: fleet = self.fleet.get_object() if not fleet.hasTroopShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() # TODO remove latter portion of next check in light of invasion retargeting, or else correct logic if not planet.unowned or planet.owner != fleet.owner: return True elif mission_type in [ MissionType.MILITARY, MissionType.SECURE, MissionType.ORBITAL_DEFENSE ]: if isinstance(target, TargetSystem): return True # TODO: implement other mission types return False def clean_invalid_targets(self): """clean invalid AITargets""" if not self._is_valid_fleet_mission_target(self.type, self.target): self.target = None self.type = None def _check_abort_mission(self, fleet_order): """ checks if current mission (targeting a planet) should be aborted""" planet_stealthed = False target_is_planet = fleet_order.target and isinstance( fleet_order.target, TargetPlanet) planet = None if target_is_planet: planet = fleet_order.target.get_object() # Check visibility prediction, but if somehow still have current visibility, don't # abort the mission yet if not EspionageAI.colony_detectable_by_empire( planet.id, empire=fo.empireID()): if get_partial_visibility_turn(planet.id) == fo.currentTurn(): debug( "EspionageAI predicts planet id %d to be stealthed" % planet.id + ", but somehow have current visibity anyway, so won't trigger mission abort" ) else: debug( "EspionageAI predicts we can no longer detect %s, will abort mission" % fleet_order.target) planet_stealthed = True if target_is_planet and not planet_stealthed: if isinstance(fleet_order, OrderColonize): if (planet.initialMeterValue(fo.meterType.population) == 0 and (planet.ownedBy(fo.empireID()) or planet.unowned)): return False elif isinstance(fleet_order, OrderOutpost): if planet.unowned: return False elif isinstance(fleet_order, OrderInvade): # TODO add substantive abort check return False else: return False # canceling fleet orders debug(" %s" % fleet_order) debug( "Fleet %d had a target planet that is no longer valid for this mission; aborting." % self.fleet.id) self.clear_fleet_orders() self.clear_target() FleetUtilsAI.split_fleet(self.fleet.id) return True def _check_retarget_invasion(self): """checks if an invasion mission should be retargeted""" universe = fo.getUniverse() empire_id = fo.empireID() fleet_id = self.fleet.id fleet = universe.getFleet(fleet_id) if fleet.systemID == INVALID_ID: # next_loc = fleet.nextSystemID return # TODO: still check system = universe.getSystem(fleet.systemID) if not system: return orders = self.orders last_sys_target = INVALID_ID if orders: last_sys_target = orders[-1].target.id if last_sys_target == fleet.systemID: return # TODO: check for best local target open_targets = [] already_targeted = InvasionAI.get_invasion_targeted_planet_ids( system.planetIDs, MissionType.INVASION) aistate = get_aistate() for pid in system.planetIDs: if pid in already_targeted or ( pid in aistate.qualifyingTroopBaseTargets): continue planet = universe.getPlanet(pid) if planet.unowned or (planet.owner == empire_id): continue if (planet.initialMeterValue(fo.meterType.shield)) <= 0: open_targets.append(pid) if not open_targets: return troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id) target_id = INVALID_ID best_score = -1 target_troops = 0 # for pid, rating in InvasionAI.assign_invasion_values( open_targets).items(): p_score, p_troops = rating if p_score > best_score: if p_troops >= troops_in_fleet: continue best_score = p_score target_id = pid target_troops = p_troops if target_id == INVALID_ID: return debug("\t Splitting and retargetting fleet %d" % fleet_id) new_fleets = FleetUtilsAI.split_fleet(fleet_id) self.clear_target() # TODO: clear from foAIstate self.clear_fleet_orders() troops_needed = max( 0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id)) min_stats = {'rating': 0, 'troopCapacity': troops_needed} target_stats = {'rating': 10, 'troopCapacity': troops_needed} found_fleets = [] # TODO check if next statement does not mutate any global states and can be removed _ = FleetUtilsAI.get_fleets_for_mission( target_stats, min_stats, {}, starting_system=fleet.systemID, # noqa: F841 fleet_pool_set=set(new_fleets), fleet_list=found_fleets) for fid in found_fleets: FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id) target = TargetPlanet(target_id) self.set_target(MissionType.INVASION, target) self.generate_fleet_orders() def need_to_pause_movement(self, last_move_target_id, new_move_order): """ When a fleet has consecutive move orders, assesses whether something about the interim destination warrants forcing a stop (such as a military fleet choosing to engage with an enemy fleet about to enter the same system, or it may provide a good vantage point to view current status of next system in path). Assessments about whether the new destination is suitable to move to are (currently) separately made by OrderMove.can_issue_order() :param last_move_target_id: :type last_move_target_id: int :param new_move_order: :type new_move_order: OrderMove :rtype: bool """ fleet = self.fleet.get_object() # don't try skipping over more than one System if fleet.nextSystemID != last_move_target_id: return True universe = fo.getUniverse() current_dest_system = universe.getSystem(fleet.nextSystemID) if not current_dest_system: # shouldn't really happen, but just to be safe return True distance_to_next_system = ((fleet.x - current_dest_system.x)**2 + (fleet.y - current_dest_system.y)**2)**0.5 surplus_travel_distance = fleet.speed - distance_to_next_system # if need more than one turn to reach current destination, then don't add another jump yet if surplus_travel_distance < 0: return True # TODO: add assessments for other situations we'd prefer to pause, such as cited above re military fleets, and # for situations where high value fleets like colony fleets might deem it safest to stop and look around # before proceeding return False def issue_fleet_orders(self): """issues AIFleetOrders which can be issued in system and moves to next one if is possible""" # TODO: priority order_completed = True debug( "\nChecking orders for fleet %s (on turn %d), with mission type %s" % (self.fleet.get_object(), fo.currentTurn(), self.type or 'No mission')) if MissionType.INVASION == self.type: self._check_retarget_invasion() just_issued_move_order = False last_move_target_id = INVALID_ID # Note: the following abort check somewhat assumes only one major mission type for fleet_order in self.orders: if (isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)) and self._check_abort_mission(fleet_order)): return aistate = get_aistate() for fleet_order in self.orders: if just_issued_move_order and self.fleet.get_object( ).systemID != last_move_target_id: # having just issued a move order, we will normally stop issuing orders this turn, except that if there # are consecutive move orders we will consider moving through the first destination rather than stopping # Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test # noinspection PyTypeChecker if (not isinstance(fleet_order, OrderMove) or self.need_to_pause_movement(last_move_target_id, fleet_order)): break debug("Checking order: %s" % fleet_order) self.check_mergers(context=str(fleet_order)) if fleet_order.can_issue_order(verbose=False): if isinstance( fleet_order, OrderMove ) and order_completed: # only move if all other orders completed debug("Issuing fleet order %s" % fleet_order) fleet_order.issue_order() just_issued_move_order = True last_move_target_id = fleet_order.target.id elif not isinstance(fleet_order, OrderMove): debug("Issuing fleet order %s" % fleet_order) fleet_order.issue_order() else: debug( "NOT issuing (even though can_issue) fleet order %s" % fleet_order) debug("Order issued: %s" % fleet_order.order_issued) if not fleet_order.executed: order_completed = False else: # check that we're not held up by a Big Monster if fleet_order.order_issued: # A previously issued order that wasn't instantly executed must have had cirumstances change so that # the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same # turn the order was issued). if not fleet_order.executed: order_completed = False # Go on to the next order. continue debug("CAN'T issue fleet order %s" % fleet_order) if isinstance(fleet_order, OrderMove): this_system_id = fleet_order.target.id this_status = aistate.systemStatus.setdefault( this_system_id, {}) threat_threshold = fo.currentTurn( ) * MilitaryAI.cur_best_mil_ship_rating() / 4.0 if this_status.get('monsterThreat', 0) > threat_threshold: # if this move order is not this mil fleet's final destination, and blocked by Big Monster, # release and hope for more effective reassignment if (self.type not in (MissionType.MILITARY, MissionType.SECURE) or fleet_order != self.orders[-1]): debug( "Aborting mission due to being blocked by Big Monster at system %d, threat %d" % (this_system_id, aistate.systemStatus[this_system_id] ['monsterThreat'])) debug("Full set of orders were:") for this_order in self.orders: debug(" - %s" % this_order) self.clear_fleet_orders() self.clear_target() return break # do not order the next order until this one is finished. else: # went through entire order list if order_completed: debug("Final order is completed") orders = self.orders last_order = orders[-1] if orders else None universe = fo.getUniverse() if last_order and isinstance(last_order, OrderColonize): planet = universe.getPlanet(last_order.target.id) sys_partial_vis_turn = get_partial_visibility_turn( planet.systemID) planet_partial_vis_turn = get_partial_visibility_turn( planet.id) if (planet_partial_vis_turn == sys_partial_vis_turn and not planet.initialMeterValue( fo.meterType.population)): warn( "Fleet %d has tentatively completed its " "colonize mission but will wait to confirm population." % self.fleet.id) debug(" Order details are %s" % last_order) debug( " Order is valid: %s; issued: %s; executed: %s" % (last_order.is_valid(), last_order.order_issued, last_order.executed)) if not last_order.is_valid(): source_target = last_order.fleet target_target = last_order.target debug( " source target validity: %s; target target validity: %s " % (bool(source_target), bool(target_target))) return # colonize order must not have completed yet clear_all = True last_sys_target = INVALID_ID if last_order and isinstance(last_order, OrderMilitary): last_sys_target = last_order.target.id # not doing this until decide a way to release from a SECURE mission # if (MissionType.SECURE == self.type) or secure_targets = set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs) if last_sys_target in secure_targets: # consider a secure mission if last_sys_target in AIstate.colonyTargetedSystemIDs: secure_type = "Colony" elif last_sys_target in AIstate.outpostTargetedSystemIDs: secure_type = "Outpost" elif last_sys_target in AIstate.invasionTargetedSystemIDs: secure_type = "Invasion" else: secure_type = "Unidentified" debug( "Fleet %d has completed initial stage of its mission " "to secure system %d (targeted for %s), " "may release a portion of ships" % (self.fleet.id, last_sys_target, secure_type)) clear_all = False fleet_id = self.fleet.id if clear_all: if orders: debug( "Fleet %d has completed its mission; clearing all orders and targets." % self.fleet.id) debug("Full set of orders were:") for this_order in orders: debug("\t\t %s" % this_order) self.clear_fleet_orders() self.clear_target() if aistate.get_fleet_role(fleet_id) in ( MissionType.MILITARY, MissionType.SECURE): allocations = MilitaryAI.get_military_fleets( mil_fleets_ids=[fleet_id], try_reset=False, thisround="Fleet %d Reassignment" % fleet_id) if allocations: MilitaryAI.assign_military_fleets_to_systems( use_fleet_id_list=[fleet_id], allocations=allocations) else: # no orders debug("No Current Orders") else: # TODO: evaluate releasing a smaller portion or none of the ships system_status = aistate.systemStatus.setdefault( last_sys_target, {}) new_fleets = [] threat_present = system_status.get( 'totalThreat', 0) + system_status.get( 'neighborThreat', 0) > 0 target_system = universe.getSystem(last_sys_target) if not threat_present and target_system: for pid in target_system.planetIDs: planet = universe.getPlanet(pid) if (planet and planet.owner != fo.empireID() and planet.currentMeterValue( fo.meterType.maxDefense) > 0): threat_present = True break if not threat_present: debug( "No current threat in target system; releasing a portion of ships." ) # at least first stage of current task is done; # release extra ships for potential other deployments new_fleets = FleetUtilsAI.split_fleet(self.fleet.id) else: debug( "Threat remains in target system; NOT releasing any ships." ) new_military_fleets = [] for fleet_id in new_fleets: if aistate.get_fleet_role( fleet_id) in COMBAT_MISSION_TYPES: new_military_fleets.append(fleet_id) allocations = [] if new_military_fleets: allocations = MilitaryAI.get_military_fleets( mil_fleets_ids=new_military_fleets, try_reset=False, thisround="Fleet Reassignment %s" % new_military_fleets) if allocations: MilitaryAI.assign_military_fleets_to_systems( use_fleet_id_list=new_military_fleets, allocations=allocations) def generate_fleet_orders(self): """generates AIFleetOrders from fleets targets to accomplish""" universe = fo.getUniverse() fleet_id = self.fleet.id fleet = universe.getFleet(fleet_id) if (not fleet) or fleet.empty or (fleet_id in universe.destroyedObjectIDs( fo.empireID())): # fleet was probably merged into another or was destroyed get_aistate().delete_fleet_info(fleet_id) return # TODO: priority self.clear_fleet_orders() system_id = fleet.systemID start_sys_id = [fleet.nextSystemID, system_id][system_id >= 0] # if fleet doesn't have any mission, # then repair if needed or resupply if is current location not in supplyable system empire = fo.getEmpire() fleet_supplyable_system_ids = empire.fleetSupplyableSystemIDs # if (not self.hasAnyAIMissionTypes()): if not self.target and (system_id not in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs)): if self._need_repair(): repair_fleet_order = MoveUtilsAI.get_repair_fleet_order( self.fleet, start_sys_id) if repair_fleet_order and repair_fleet_order.is_valid(): self.orders.append(repair_fleet_order) cur_fighter_capacity, max_fighter_capacity = FleetUtilsAI.get_fighter_capacity_of_fleet( fleet_id) if (fleet.fuel < fleet.maxFuel or cur_fighter_capacity < max_fighter_capacity and self.get_location_target().id not in fleet_supplyable_system_ids): resupply_fleet_order = MoveUtilsAI.get_resupply_fleet_order( self.fleet, self.get_location_target()) if resupply_fleet_order.is_valid(): self.orders.append(resupply_fleet_order) return # no targets if self.target: # for some targets fleet has to visit systems and therefore fleet visit them system_to_visit = self.target.get_system() orders_to_visit_systems = MoveUtilsAI.create_move_orders_to_system( self.fleet, system_to_visit) # TODO: if fleet doesn't have enough fuel to get to final target, consider resetting Mission for fleet_order in orders_to_visit_systems: self.orders.append(fleet_order) # also generate appropriate final orders fleet_order = self._get_fleet_order_from_target( self.type, self.target) self.orders.append(fleet_order) def _need_repair(self, repair_limit=0.70): """Check if fleet needs to be repaired. If the fleet is already at a system where it can be repaired, stay there until fully repaired. Otherwise, repair if fleet health is below specified *repair_limit*. For military fleets, there is a special evaluation called, cf. *MilitaryAI.avail_mil_needing_repair()* :param repair_limit: percentage of health below which the fleet is sent to repair :type repair_limit: float :return: True if fleet needs repair :rtype: bool """ # TODO: More complex evaluation if fleet needs repair (consider self-repair, distance, threat, mission...) fleet_id = self.fleet.id # if we are already at a system where we can repair, make sure we use it... system = self.fleet.get_system() # TODO starlane obstruction is not considered in the next call nearest_dock = MoveUtilsAI.get_best_drydock_system_id( system.id, fleet_id) if nearest_dock == system.id: repair_limit = 0.99 # if combat fleet, use military repair check if get_aistate().get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES: return fleet_id in MilitaryAI.avail_mil_needing_repair( [fleet_id], on_mission=bool(self.orders), repair_limit=repair_limit)[0] # TODO: Allow to split fleet to send only damaged ships to repair ships_cur_health, ships_max_health = FleetUtilsAI.get_current_and_max_structure( fleet_id) return ships_cur_health < repair_limit * ships_max_health def get_location_target(self): """system AITarget where fleet is or will be""" # TODO add parameter turn fleet = fo.getUniverse().getFleet(self.fleet.id) system_id = fleet.systemID if system_id >= 0: return TargetSystem(system_id) else: # in starlane, so return next system return TargetSystem(fleet.nextSystemID) def __eq__(self, other): return isinstance(other, self.__class__) and self.fleet == other.target def __str__(self): fleet = self.fleet.get_object() fleet_id = self.fleet.id return "%-25s [%-11s] ships: %2d; total rating: %4d; target: %s" % ( fleet, "NONE" if self.type is None else self.type, (fleet and len(fleet.shipIDs)) or 0, CombatRatingsAI.get_fleet_rating(fleet_id), self.target or 'no target')
class AIFleetMission(object): """ Stores information about AI mission. Every mission has fleetID and AI targets depending upon AI fleet mission type. :type orders: list[AIFleetOrder] :type target: target.Target | None """ def __init__(self, fleet_id): self.orders = [] self.fleet = TargetFleet(fleet_id) self.type = None self.target = None def __setstate__(self, state): target_type = state.pop("target_type") if state["target"] is not None: object_map = {TargetPlanet.object_name: TargetPlanet, TargetSystem.object_name: TargetSystem, TargetFleet.object_name: TargetFleet} state["target"] = object_map[target_type](state["target"]) state["fleet"] = TargetFleet(state["fleet"]) self.__dict__ = state def __getstate__(self): retval = dict(self.__dict__) # do only store the fleet id not the Fleet object retval["fleet"] = self.fleet.id # store target type and id rather than the object if self.target is not None: retval["target_type"] = self.target.object_name retval["target"] = self.target.id else: retval["target_type"] = None retval["target"] = None return retval def set_target(self, mission_type, target): """ Set mission and target for this fleet. :type mission_type: MissionType :type target: target.Target """ if self.type == mission_type and self.target == target: return if self.type or self.target: debug("%s: change mission assignment from %s:%s to %s:%s" % ( self.fleet, self.type, self.target, mission_type, target)) self.type = mission_type self.target = target def clear_target(self): """Clear target and mission for this fleet.""" self.target = None self.type = None def has_target(self, mission_type, target): """ Check if fleet has specified mission_type and target. :type mission_type: MissionType :type target: target.Target :rtype: bool """ return self.type == mission_type and self.target == target def clear_fleet_orders(self): """Clear this fleets orders but do not clear mission and target.""" self.orders = [] def _get_fleet_order_from_target(self, mission_type, target): """ Get a fleet order according to mission type and target. :type mission_type: MissionType :type target: target.Target :rtype: AIFleetOrder """ fleet_target = TargetFleet(self.fleet.id) return ORDERS_FOR_MISSION[mission_type](fleet_target, target) def check_mergers(self, context=""): """ Merge local fleets with same mission into this fleet. :param context: Context of the function call for logging purposes :type context: str """ debug("Considering to merge %s", self.__str__()) if self.type not in MERGEABLE_MISSION_TYPES: debug("Mission type does not allow merging.") return if not self.target: debug("Mission has no valid target - do not merge.") return universe = fo.getUniverse() empire_id = fo.empireID() fleet_id = self.fleet.id main_fleet = universe.getFleet(fleet_id) main_fleet_system_id = main_fleet.systemID if main_fleet_system_id == INVALID_ID: debug("Can't merge: fleet in middle of starlane.") return # only merge PROTECT_REGION if there is any threat near target if self.type == MissionType.PROTECT_REGION: neighbor_systems = universe.getImmediateNeighbors(self.target.id, empire_id) if not any(MilitaryAI.get_system_local_threat(sys_id) for sys_id in neighbor_systems): debug("Not merging PROTECT_REGION fleet - no threat nearby.") return destroyed_list = set(universe.destroyedObjectIDs(empire_id)) aistate = get_aistate() system_status = aistate.systemStatus[main_fleet_system_id] other_fleets_here = [fid for fid in system_status.get('myFleetsAccessible', []) if fid != fleet_id and fid not in destroyed_list and universe.getFleet(fid).ownedBy(empire_id)] if not other_fleets_here: debug("No other fleets here") return for fid in other_fleets_here: fleet_mission = aistate.get_fleet_mission(fid) if fleet_mission.type != self.type or fleet_mission.target != self.target: debug("Local candidate %s does not have same mission." % fleet_mission) continue FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id, context="Order %s of mission %s" % (context, self)) def _is_valid_fleet_mission_target(self, mission_type, target): if not target: return False if mission_type == MissionType.EXPLORATION: if isinstance(target, TargetSystem): empire = fo.getEmpire() if not empire.hasExploredSystem(target.id): return True elif mission_type in [MissionType.OUTPOST, MissionType.ORBITAL_OUTPOST]: fleet = self.fleet.get_object() if not fleet.hasOutpostShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() if planet.unowned: return True elif mission_type == MissionType.COLONISATION: fleet = self.fleet.get_object() if not fleet.hasColonyShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() population = planet.initialMeterValue(fo.meterType.population) if planet.unowned or (planet.owner == fleet.owner and population == 0): return True elif mission_type in [MissionType.INVASION, MissionType.ORBITAL_INVASION]: fleet = self.fleet.get_object() if not fleet.hasTroopShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() # TODO remove latter portion of next check in light of invasion retargeting, or else correct logic if not planet.unowned or planet.owner != fleet.owner: return True elif mission_type in [MissionType.MILITARY, MissionType.SECURE, MissionType.ORBITAL_DEFENSE, MissionType.PROTECT_REGION]: if isinstance(target, TargetSystem): return True # TODO: implement other mission types return False def clean_invalid_targets(self): """clean invalid AITargets""" if not self._is_valid_fleet_mission_target(self.type, self.target): self.target = None self.type = None def _check_abort_mission(self, fleet_order): """ checks if current mission (targeting a planet) should be aborted""" planet_stealthed = False target_is_planet = fleet_order.target and isinstance(fleet_order.target, TargetPlanet) planet = None if target_is_planet: planet = fleet_order.target.get_object() # Check visibility prediction, but if somehow still have current visibility, don't # abort the mission yet if not EspionageAI.colony_detectable_by_empire(planet.id, empire=fo.empireID()): if get_partial_visibility_turn(planet.id) == fo.currentTurn(): debug("EspionageAI predicts planet id %d to be stealthed" % planet.id + ", but somehow have current visibity anyway, so won't trigger mission abort") else: debug("EspionageAI predicts we can no longer detect %s, will abort mission" % fleet_order.target) planet_stealthed = True if target_is_planet and not planet_stealthed: if isinstance(fleet_order, OrderColonize): if (planet.initialMeterValue(fo.meterType.population) == 0 and (planet.ownedBy(fo.empireID()) or planet.unowned)): return False elif isinstance(fleet_order, OrderOutpost): if planet.unowned: return False elif isinstance(fleet_order, OrderInvade): # TODO add substantive abort check return False else: return False # canceling fleet orders debug(" %s" % fleet_order) debug("Fleet %d had a target planet that is no longer valid for this mission; aborting." % self.fleet.id) self.clear_fleet_orders() self.clear_target() FleetUtilsAI.split_fleet(self.fleet.id) return True def _check_retarget_invasion(self): """checks if an invasion mission should be retargeted""" universe = fo.getUniverse() empire_id = fo.empireID() fleet_id = self.fleet.id fleet = universe.getFleet(fleet_id) if fleet.systemID == INVALID_ID: # next_loc = fleet.nextSystemID return # TODO: still check system = universe.getSystem(fleet.systemID) if not system: return orders = self.orders last_sys_target = INVALID_ID if orders: last_sys_target = orders[-1].target.id if last_sys_target == fleet.systemID: return # TODO: check for best local target open_targets = [] already_targeted = InvasionAI.get_invasion_targeted_planet_ids(system.planetIDs, MissionType.INVASION) aistate = get_aistate() for pid in system.planetIDs: if pid in already_targeted or (pid in aistate.qualifyingTroopBaseTargets): continue planet = universe.getPlanet(pid) if planet.unowned or (planet.owner == empire_id): continue if (planet.initialMeterValue(fo.meterType.shield)) <= 0: open_targets.append(pid) if not open_targets: return troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id) target_id = INVALID_ID best_score = -1 target_troops = 0 # for pid, rating in InvasionAI.assign_invasion_values(open_targets).items(): p_score, p_troops = rating if p_score > best_score: if p_troops >= troops_in_fleet: continue best_score = p_score target_id = pid target_troops = p_troops if target_id == INVALID_ID: return debug("\t Splitting and retargetting fleet %d" % fleet_id) new_fleets = FleetUtilsAI.split_fleet(fleet_id) self.clear_target() # TODO: clear from foAIstate self.clear_fleet_orders() troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id)) min_stats = {'rating': 0, 'troopCapacity': troops_needed} target_stats = {'rating': 10, 'troopCapacity': troops_needed} found_fleets = [] # TODO check if next statement does not mutate any global states and can be removed _ = FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, {}, starting_system=fleet.systemID, # noqa: F841 fleet_pool_set=set(new_fleets), fleet_list=found_fleets) for fid in found_fleets: FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id) target = TargetPlanet(target_id) self.set_target(MissionType.INVASION, target) self.generate_fleet_orders() def need_to_pause_movement(self, last_move_target_id, new_move_order): """ When a fleet has consecutive move orders, assesses whether something about the interim destination warrants forcing a stop (such as a military fleet choosing to engage with an enemy fleet about to enter the same system, or it may provide a good vantage point to view current status of next system in path). Assessments about whether the new destination is suitable to move to are (currently) separately made by OrderMove.can_issue_order() :param last_move_target_id: :type last_move_target_id: int :param new_move_order: :type new_move_order: OrderMove :rtype: bool """ fleet = self.fleet.get_object() # don't try skipping over more than one System if fleet.nextSystemID != last_move_target_id: return True universe = fo.getUniverse() current_dest_system = universe.getSystem(fleet.nextSystemID) if not current_dest_system: # shouldn't really happen, but just to be safe return True distance_to_next_system = ((fleet.x - current_dest_system.x)**2 + (fleet.y - current_dest_system.y)**2)**0.5 surplus_travel_distance = fleet.speed - distance_to_next_system # if need more than one turn to reach current destination, then don't add another jump yet if surplus_travel_distance < 0: return True # TODO: add assessments for other situations we'd prefer to pause, such as cited above re military fleets, and # for situations where high value fleets like colony fleets might deem it safest to stop and look around # before proceeding return False def issue_fleet_orders(self): """issues AIFleetOrders which can be issued in system and moves to next one if is possible""" # TODO: priority order_completed = True debug("\nChecking orders for fleet %s (on turn %d), with mission type %s and target %s", self.fleet.get_object(), fo.currentTurn(), self.type or 'No mission', self.target or 'No Target') if MissionType.INVASION == self.type: self._check_retarget_invasion() just_issued_move_order = False last_move_target_id = INVALID_ID # Note: the following abort check somewhat assumes only one major mission type for fleet_order in self.orders: if (isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)) and self._check_abort_mission(fleet_order)): return aistate = get_aistate() for fleet_order in self.orders: if just_issued_move_order and self.fleet.get_object().systemID != last_move_target_id: # having just issued a move order, we will normally stop issuing orders this turn, except that if there # are consecutive move orders we will consider moving through the first destination rather than stopping # Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test # noinspection PyTypeChecker if (not isinstance(fleet_order, OrderMove) or self.need_to_pause_movement(last_move_target_id, fleet_order)): break debug("Checking order: %s" % fleet_order) self.check_mergers(context=str(fleet_order)) if fleet_order.can_issue_order(verbose=False): # only move if all other orders completed if isinstance(fleet_order, OrderMove) and order_completed: debug("Issuing fleet order %s" % fleet_order) fleet_order.issue_order() just_issued_move_order = True last_move_target_id = fleet_order.target.id elif not isinstance(fleet_order, OrderMove): debug("Issuing fleet order %s" % fleet_order) fleet_order.issue_order() else: debug("NOT issuing (even though can_issue) fleet order %s" % fleet_order) status_words = tuple(["not", ""][_s] for _s in [fleet_order.order_issued, fleet_order.executed]) debug("Order %s issued and %s fully executed." % status_words) if not fleet_order.executed: order_completed = False else: # check that we're not held up by a Big Monster if fleet_order.order_issued: # A previously issued order that wasn't instantly executed must have had cirumstances change so that # the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same # turn the order was issued). if not fleet_order.executed: order_completed = False # Go on to the next order. continue debug("CAN'T issue fleet order %s because:" % fleet_order) fleet_order.can_issue_order(verbose=True) if isinstance(fleet_order, OrderMove): this_system_id = fleet_order.target.id this_status = aistate.systemStatus.setdefault(this_system_id, {}) threat_threshold = fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating() / 4.0 if this_status.get('monsterThreat', 0) > threat_threshold: # if this move order is not this mil fleet's final destination, and blocked by Big Monster, # release and hope for more effective reassignment if (self.type not in (MissionType.MILITARY, MissionType.SECURE) or fleet_order != self.orders[-1]): debug("Aborting mission due to being blocked by Big Monster at system %d, threat %d" % ( this_system_id, aistate.systemStatus[this_system_id]['monsterThreat'])) debug("Full set of orders were:") for this_order in self.orders: debug(" - %s" % this_order) self.clear_fleet_orders() self.clear_target() return break # do not order the next order until this one is finished. else: # went through entire order list if order_completed: debug("Final order is completed") orders = self.orders last_order = orders[-1] if orders else None universe = fo.getUniverse() if last_order and isinstance(last_order, OrderColonize): planet = universe.getPlanet(last_order.target.id) sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID) planet_partial_vis_turn = get_partial_visibility_turn(planet.id) if (planet_partial_vis_turn == sys_partial_vis_turn and not planet.initialMeterValue(fo.meterType.population)): warn("Fleet %d has tentatively completed its " "colonize mission but will wait to confirm population." % self.fleet.id) debug(" Order details are %s" % last_order) debug(" Order is valid: %s; issued: %s; executed: %s" % ( last_order.is_valid(), last_order.order_issued, last_order.executed)) if not last_order.is_valid(): source_target = last_order.fleet target_target = last_order.target debug(" source target validity: %s; target target validity: %s " % ( bool(source_target), bool(target_target))) return # colonize order must not have completed yet clear_all = True last_sys_target = INVALID_ID if last_order and isinstance(last_order, OrderMilitary): last_sys_target = last_order.target.id # not doing this until decide a way to release from a SECURE mission # if (MissionType.SECURE == self.type) or secure_targets = set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs) if last_sys_target in secure_targets: # consider a secure mission if last_sys_target in AIstate.colonyTargetedSystemIDs: secure_type = "Colony" elif last_sys_target in AIstate.outpostTargetedSystemIDs: secure_type = "Outpost" elif last_sys_target in AIstate.invasionTargetedSystemIDs: secure_type = "Invasion" else: secure_type = "Unidentified" debug("Fleet %d has completed initial stage of its mission " "to secure system %d (targeted for %s), " "may release a portion of ships" % (self.fleet.id, last_sys_target, secure_type)) clear_all = False # for PROTECT_REGION missions, only release fleet if no more threat if self.type == MissionType.PROTECT_REGION: # use military logic code below to determine if can release # any or even all of the ships. clear_all = False last_sys_target = self.target.id debug("Check if PROTECT_REGION mission with target %d is finished.", last_sys_target) fleet_id = self.fleet.id if clear_all: if orders: debug("Fleet %d has completed its mission; clearing all orders and targets." % self.fleet.id) debug("Full set of orders were:") for this_order in orders: debug("\t\t %s" % this_order) self.clear_fleet_orders() self.clear_target() if aistate.get_fleet_role(fleet_id) in (MissionType.MILITARY, MissionType.SECURE): allocations = MilitaryAI.get_military_fleets(mil_fleets_ids=[fleet_id], try_reset=False, thisround="Fleet %d Reassignment" % fleet_id) if allocations: MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=[fleet_id], allocations=allocations) else: # no orders debug("No Current Orders") else: potential_threat = CombatRatingsAI.combine_ratings( MilitaryAI.get_system_local_threat(last_sys_target), MilitaryAI.get_system_neighbor_threat(last_sys_target) ) threat_present = potential_threat > 0 debug("Fleet threat present? %s", threat_present) target_system = universe.getSystem(last_sys_target) if not threat_present and target_system: for pid in target_system.planetIDs: planet = universe.getPlanet(pid) if (planet and planet.owner != fo.empireID() and planet.currentMeterValue(fo.meterType.maxDefense) > 0): debug("Found local planetary threat: %s", planet) threat_present = True break if not threat_present: debug("No current threat in target system; releasing a portion of ships.") # at least first stage of current task is done; # release extra ships for potential other deployments new_fleets = FleetUtilsAI.split_fleet(self.fleet.id) if self.type == MissionType.PROTECT_REGION: self.clear_fleet_orders() self.clear_target() new_fleets.append(self.fleet.id) else: debug("Threat remains in target system; Considering to release some ships.") new_fleets = [] fleet_portion_to_remain = self._portion_of_fleet_needed_here() if fleet_portion_to_remain > 1: debug("Can not release fleet yet due to large threat.") elif fleet_portion_to_remain > 0: debug("Not all ships are needed here - considering releasing a few") fleet_remaining_rating = CombatRatingsAI.get_fleet_rating(fleet_id) fleet_min_rating = fleet_portion_to_remain * fleet_remaining_rating debug("Starting rating: %.1f, Target rating: %.1f", fleet_remaining_rating, fleet_min_rating) allowance = CombatRatingsAI.rating_needed(fleet_remaining_rating, fleet_min_rating) debug("May release ships with total rating of %.1f", allowance) ship_ids = list(self.fleet.get_object().shipIDs) for ship_id in ship_ids: ship_rating = CombatRatingsAI.get_ship_rating(ship_id) debug("Considering to release ship %d with rating %.1f", ship_id, ship_rating) if ship_rating > allowance: debug("Remaining rating insufficient. Not released.") continue debug("Splitting from fleet.") new_fleet_id = FleetUtilsAI.split_ship_from_fleet(fleet_id, ship_id) if assertion_fails(new_fleet_id and new_fleet_id != INVALID_ID): break new_fleets.append(new_fleet_id) fleet_remaining_rating = CombatRatingsAI.rating_difference( fleet_remaining_rating, ship_rating) allowance = CombatRatingsAI.rating_difference( fleet_remaining_rating, fleet_min_rating) debug("Remaining fleet rating: %.1f - Allowance: %.1f", fleet_remaining_rating, allowance) if new_fleets: aistate.get_fleet_role(fleet_id, force_new=True) aistate.update_fleet_rating(fleet_id) aistate.ensure_have_fleet_missions(new_fleets) else: debug("Planetary defenses are deemed sufficient. Release fleet.") new_fleets = FleetUtilsAI.split_fleet(self.fleet.id) new_military_fleets = [] for fleet_id in new_fleets: if aistate.get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES: new_military_fleets.append(fleet_id) allocations = [] if new_military_fleets: allocations = MilitaryAI.get_military_fleets( mil_fleets_ids=new_military_fleets, try_reset=False, thisround="Fleet Reassignment %s" % new_military_fleets ) if allocations: MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=new_military_fleets, allocations=allocations) def _portion_of_fleet_needed_here(self): """Calculate the portion of the fleet needed in target system considering enemy forces.""" # TODO check rating against planets if assertion_fails(self.type in COMBAT_MISSION_TYPES, msg=str(self)): return 0 if assertion_fails(self.target and self.target.id != INVALID_ID, msg=str(self)): return 0 system_id = self.target.id aistate = get_aistate() local_defenses = MilitaryAI.get_my_defense_rating_in_system(system_id) potential_threat = CombatRatingsAI.combine_ratings( MilitaryAI.get_system_local_threat(system_id), MilitaryAI.get_system_neighbor_threat(system_id) ) universe = fo.getUniverse() system = universe.getSystem(system_id) # tally planetary defenses total_defense = total_shields = 0 for planet_id in system.planetIDs: planet = universe.getPlanet(planet_id) total_defense += planet.currentMeterValue(fo.meterType.defense) total_shields += planet.currentMeterValue(fo.meterType.shield) planetary_ratings = total_defense * (total_shields + total_defense) potential_threat += planetary_ratings # TODO: rewrite to return min rating vs planets as well # consider safety factor just once here rather than everywhere below safety_factor = aistate.character.military_safety_factor() potential_threat *= safety_factor fleet_rating = CombatRatingsAI.get_fleet_rating(self.fleet.id) return CombatRatingsAI.rating_needed(potential_threat, local_defenses) / float(fleet_rating) def generate_fleet_orders(self): """generates AIFleetOrders from fleets targets to accomplish""" universe = fo.getUniverse() fleet_id = self.fleet.id fleet = universe.getFleet(fleet_id) if (not fleet) or fleet.empty or (fleet_id in universe.destroyedObjectIDs(fo.empireID())): # fleet was probably merged into another or was destroyed get_aistate().delete_fleet_info(fleet_id) return # TODO: priority self.clear_fleet_orders() system_id = fleet.systemID start_sys_id = [fleet.nextSystemID, system_id][system_id >= 0] # if fleet doesn't have any mission, # then repair if needed or resupply if is current location not in supplyable system empire = fo.getEmpire() fleet_supplyable_system_ids = empire.fleetSupplyableSystemIDs # if (not self.hasAnyAIMissionTypes()): if not self.target and (system_id not in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs)): if self._need_repair(): repair_fleet_order = MoveUtilsAI.get_repair_fleet_order(self.fleet, start_sys_id) if repair_fleet_order and repair_fleet_order.is_valid(): self.orders.append(repair_fleet_order) cur_fighter_capacity, max_fighter_capacity = FleetUtilsAI.get_fighter_capacity_of_fleet(fleet_id) if (fleet.fuel < fleet.maxFuel or cur_fighter_capacity < max_fighter_capacity and self.get_location_target().id not in fleet_supplyable_system_ids): resupply_fleet_order = MoveUtilsAI.get_resupply_fleet_order(self.fleet, self.get_location_target()) if resupply_fleet_order.is_valid(): self.orders.append(resupply_fleet_order) return # no targets if self.target: # for some targets fleet has to visit systems and therefore fleet visit them system_to_visit = (self.target.get_system() if not self.type == MissionType.PROTECT_REGION else TargetSystem(self._get_target_for_protection_mission())) if not system_to_visit: return orders_to_visit_systems = MoveUtilsAI.create_move_orders_to_system(self.fleet, system_to_visit) # TODO: if fleet doesn't have enough fuel to get to final target, consider resetting Mission for fleet_order in orders_to_visit_systems: self.orders.append(fleet_order) # also generate appropriate final orders fleet_order = self._get_fleet_order_from_target(self.type, self.target) self.orders.append(fleet_order) def _need_repair(self, repair_limit=0.70): """Check if fleet needs to be repaired. If the fleet is already at a system where it can be repaired, stay there until fully repaired. Otherwise, repair if fleet health is below specified *repair_limit*. For military fleets, there is a special evaluation called, cf. *MilitaryAI.avail_mil_needing_repair()* :param repair_limit: percentage of health below which the fleet is sent to repair :type repair_limit: float :return: True if fleet needs repair :rtype: bool """ # TODO: More complex evaluation if fleet needs repair (consider self-repair, distance, threat, mission...) fleet_id = self.fleet.id # if we are already at a system where we can repair, make sure we use it... system = self.fleet.get_system() # TODO starlane obstruction is not considered in the next call nearest_dock = MoveUtilsAI.get_best_drydock_system_id(system.id, fleet_id) if nearest_dock == system.id: repair_limit = 0.99 # if combat fleet, use military repair check if get_aistate().get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES: return fleet_id in MilitaryAI.avail_mil_needing_repair([fleet_id], on_mission=bool(self.orders), repair_limit=repair_limit)[0] # TODO: Allow to split fleet to send only damaged ships to repair ships_cur_health, ships_max_health = FleetUtilsAI.get_current_and_max_structure(fleet_id) return ships_cur_health < repair_limit * ships_max_health def get_location_target(self): """system AITarget where fleet is or will be""" # TODO add parameter turn fleet = fo.getUniverse().getFleet(self.fleet.id) system_id = fleet.systemID if system_id >= 0: return TargetSystem(system_id) else: # in starlane, so return next system return TargetSystem(fleet.nextSystemID) def __eq__(self, other): return isinstance(other, self.__class__) and self.fleet == other.target def __str__(self): fleet = self.fleet.get_object() fleet_id = self.fleet.id return "%-25s [%-11s] ships: %2d; total rating: %4d; target: %s" % (fleet, "NONE" if self.type is None else self.type, (fleet and len(fleet.shipIDs)) or 0, CombatRatingsAI.get_fleet_rating(fleet_id), self.target or 'no target') def _get_target_for_protection_mission(self): """Get a target for a PROTECT_REGION mission. 1) If primary target (system target of this mission) is under attack, move to primary target. 2) If neighbors of primary target have local enemy forces weaker than this fleet, may move to attack 3) If no neighboring fleets or strongest enemy force is too strong, move to defend primary target """ # TODO: Also check fleet rating vs planets in decision making below not only vs fleets universe = fo.getUniverse() primary_objective = self.target.id debug("Trying to find target for protection mission. Target: %s", self.target) immediate_threat = MilitaryAI.get_system_local_threat(primary_objective) if immediate_threat: debug("Immediate threat! Moving to primary mission target") return primary_objective else: debug("No immediate threats.") # Try to eliminate neighbouring fleets neighbors = universe.getImmediateNeighbors(primary_objective, fo.empireID()) threat_list = sorted(map( lambda x: (MilitaryAI.get_system_local_threat(x), x), neighbors ), reverse=True) if not threat_list: debug("No neighbors (?!). Moving to primary mission target") return primary_objective debug("%s", threat_list) top_threat, candidate_system = threat_list[0] if not top_threat: # TODO: Move into second ring but needs more careful evaluation # For now, consider staying at the current location if enemy # owns a planet here which we can bombard. current_system_id = self.fleet.get_current_system_id() if current_system_id in neighbors: system = universe.getSystem(current_system_id) if assertion_fails(system is not None): return primary_objective empire_id = fo.empireID() for planet_id in system.planetIDs: planet = universe.getPlanet(planet_id) if (planet and not planet.ownedBy(empire_id) and not planet.unowned): debug("Currently no neighboring threats. " "Staying for bombardment of planet %s", planet) self.clear_fleet_orders() self.set_target(MissionType.MILITARY, TargetSystem(current_system_id)) self.generate_fleet_orders() self.issue_fleet_orders() return INVALID_ID # TODO consider attacking neighboring, non-military fleets # - needs more careful evaluation against neighboring threats # empire_id = fo.empireID() # for sys_id in neighbors: # system = universe.getSystem(sys_id) # if assertion_fails(system is not None): # continue # local_fleets = system.fleetIDs # for fleet_id in local_fleets: # fleet = universe.getFleet(fleet_id) # if not fleet or fleet.ownedBy(empire_id): # continue # return sys_id debug("No neighboring threats. Moving to primary mission target") return primary_objective # TODO rate against threat in target system # TODO only engage if can reach in 1 turn or leaves sufficient defense behind fleet_rating = CombatRatingsAI.get_fleet_rating(self.fleet.id) debug("This fleet rating: %d. Enemy Rating: %d", fleet_rating, top_threat) safety_factor = get_aistate().character.military_safety_factor() if fleet_rating < safety_factor*top_threat: debug("Neighboring threat is too powerful. Moving to primary mission target") return primary_objective # do not engage! debug("Engaging neighboring threat: %d", candidate_system) return candidate_system
class AIFleetMission: """ Stores information about AI mission. Every mission has fleetID and AI targets depending upon AI fleet mission type. :type orders: list[AIFleetOrder] :type target: target.Target | None """ def __init__(self, fleet_id: int): self.orders = [] self.fleet = TargetFleet(fleet_id) self.type = None self.target = None def __setstate__(self, state): target_type = state.pop("target_type") if state["target"] is not None: object_map = {TargetPlanet.object_name: TargetPlanet, TargetSystem.object_name: TargetSystem, TargetFleet.object_name: TargetFleet} state["target"] = object_map[target_type](state["target"]) state["fleet"] = TargetFleet(state["fleet"]) self.__dict__ = state def __getstate__(self): retval = dict(self.__dict__) # do only store the fleet id not the Fleet object retval["fleet"] = self.fleet.id # store target type and id rather than the object if self.target is not None: retval["target_type"] = self.target.object_name retval["target"] = self.target.id else: retval["target_type"] = None retval["target"] = None return retval def set_target(self, mission_type: MissionType, target: Target): """ Set mission and target for this fleet. """ if self.type == mission_type and self.target == target: return if self.type or self.target: debug("%s: change mission assignment from %s:%s to %s:%s" % ( self.fleet, self.type, self.target, mission_type, target)) self.type = mission_type self.target = target def clear_target(self): """Clear target and mission for this fleet.""" self.target = None self.type = None def has_target(self, mission_type: MissionType, target: Target) -> bool: """ Check if fleet has specified mission_type and target. """ return self.type == mission_type and self.target == target def clear_fleet_orders(self): """Clear this fleets orders but do not clear mission and target.""" self.orders = [] def _get_fleet_order_from_target(self, mission_type: MissionType, target: Target) -> AIFleetOrder: """ Get a fleet order according to mission type and target. """ fleet_target = TargetFleet(self.fleet.id) return ORDERS_FOR_MISSION[mission_type](fleet_target, target) def check_mergers(self, context: str = ""): """ Merge local fleets with same mission into this fleet. :param context: Context of the function call for logging purposes """ debug("Considering to merge %s", self.__str__()) if self.type not in MERGEABLE_MISSION_TYPES: debug("Mission type does not allow merging.") return if not self.target: debug("Mission has no valid target - do not merge.") return universe = fo.getUniverse() empire_id = fo.empireID() fleet_id = self.fleet.id main_fleet = universe.getFleet(fleet_id) main_fleet_system_id = main_fleet.systemID if main_fleet_system_id == INVALID_ID: debug("Can't merge: fleet in middle of starlane.") return # only merge PROTECT_REGION if there is any threat near target if self.type == MissionType.PROTECT_REGION: neighbor_systems = universe.getImmediateNeighbors(self.target.id, empire_id) if not any(MilitaryAI.get_system_local_threat(sys_id) for sys_id in neighbor_systems): debug("Not merging PROTECT_REGION fleet - no threat nearby.") return destroyed_list = set(universe.destroyedObjectIDs(empire_id)) aistate = get_aistate() system_status = aistate.systemStatus[main_fleet_system_id] other_fleets_here = [fid for fid in system_status.get('myFleetsAccessible', []) if fid != fleet_id and fid not in destroyed_list and universe.getFleet(fid).ownedBy(empire_id)] if not other_fleets_here: debug("No other fleets here") return for fid in other_fleets_here: fleet_mission = aistate.get_fleet_mission(fid) if fleet_mission.type != self.type or fleet_mission.target != self.target: debug("Local candidate %s does not have same mission." % fleet_mission) continue FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id, context="Order %s of mission %s" % (context, self)) def _is_valid_fleet_mission_target(self, mission_type: MissionType, target: Target): if not target: return False if mission_type == MissionType.EXPLORATION: if isinstance(target, TargetSystem): empire = fo.getEmpire() if not empire.hasExploredSystem(target.id): return True elif mission_type in [MissionType.OUTPOST, MissionType.ORBITAL_OUTPOST]: fleet = self.fleet.get_object() if not fleet.hasOutpostShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() if planet.unowned: return True elif mission_type == MissionType.COLONISATION: fleet = self.fleet.get_object() if not fleet.hasColonyShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() population = planet.initialMeterValue(fo.meterType.population) if planet.unowned or (planet.owner == fleet.owner and population == 0): return True elif mission_type in [MissionType.INVASION, MissionType.ORBITAL_INVASION]: fleet = self.fleet.get_object() if not fleet.hasTroopShips: return False if isinstance(target, TargetPlanet): planet = target.get_object() # TODO remove latter portion of next check in light of invasion retargeting, or else correct logic if not planet.unowned or planet.owner != fleet.owner: return True elif mission_type in [MissionType.MILITARY, MissionType.SECURE, MissionType.ORBITAL_DEFENSE, MissionType.PROTECT_REGION]: if isinstance(target, TargetSystem): return True # TODO: implement other mission types return False def clean_invalid_targets(self): """clean invalid AITargets""" if not self._is_valid_fleet_mission_target(self.type, self.target): self.target = None self.type = None def _check_abort_mission(self, fleet_order: AIFleetOrder): """ checks if current mission (targeting a planet) should be aborted""" planet_stealthed = False target_is_planet = fleet_order.target and isinstance(fleet_order.target, TargetPlanet) planet = None if target_is_planet: planet = fleet_order.target.get_object() # Check visibility prediction, but if somehow still have current visibility, don't # abort the mission yet if not EspionageAI.colony_detectable_by_empire(planet.id, empire=fo.empireID()): if get_partial_visibility_turn(planet.id) == fo.currentTurn(): debug("EspionageAI predicts planet id %d to be stealthed" % planet.id + ", but somehow have current visibity anyway, so won't trigger mission abort") else: debug("EspionageAI predicts we can no longer detect %s, will abort mission" % fleet_order.target) planet_stealthed = True if target_is_planet and not planet_stealthed: if isinstance(fleet_order, OrderColonize): if (planet.initialMeterValue(fo.meterType.population) == 0 and (planet.ownedBy(fo.empireID()) or planet.unowned)): return False elif isinstance(fleet_order, OrderOutpost): if planet.unowned: return False elif isinstance(fleet_order, OrderInvade): # TODO add substantive abort check return False else: return False # canceling fleet orders debug(" %s" % fleet_order) debug("Fleet %d had a target planet that is no longer valid for this mission; aborting." % self.fleet.id) self.clear_fleet_orders() self.clear_target() FleetUtilsAI.split_fleet(self.fleet.id) return True def _check_retarget_invasion(self): """checks if an invasion mission should be retargeted""" universe = fo.getUniverse() empire_id = fo.empireID() fleet_id = self.fleet.id fleet = universe.getFleet(fleet_id) if fleet.systemID == INVALID_ID: # next_loc = fleet.nextSystemID return # TODO: still check system = universe.getSystem(fleet.systemID) if not system: return orders = self.orders last_sys_target = INVALID_ID if orders: last_sys_target = orders[-1].target.id if last_sys_target == fleet.systemID: return # TODO: check for best local target open_targets = [] already_targeted = InvasionAI.get_invasion_targeted_planet_ids(system.planetIDs, MissionType.INVASION) aistate = get_aistate() for pid in system.planetIDs: if pid in already_targeted or (pid in aistate.qualifyingTroopBaseTargets): continue planet = universe.getPlanet(pid) if planet.unowned or (planet.owner == empire_id): continue if (planet.initialMeterValue(fo.meterType.shield)) <= 0: open_targets.append(pid) if not open_targets: return troops_in_fleet = FleetUtilsAI.count_troops_in_fleet(fleet_id) target_id = INVALID_ID best_score = -1 target_troops = 0 # for pid, rating in InvasionAI.assign_invasion_values(open_targets).items(): p_score, p_troops = rating if p_score > best_score: if p_troops >= troops_in_fleet: continue best_score = p_score target_id = pid target_troops = p_troops if target_id == INVALID_ID: return debug("\t Splitting and retargetting fleet %d" % fleet_id) new_fleets = FleetUtilsAI.split_fleet(fleet_id) self.clear_target() # TODO: clear from foAIstate self.clear_fleet_orders() troops_needed = max(0, target_troops - FleetUtilsAI.count_troops_in_fleet(fleet_id)) min_stats = {'rating': 0, 'troopCapacity': troops_needed} target_stats = {'rating': 10, 'troopCapacity': troops_needed} found_fleets = [] # TODO check if next statement does not mutate any global states and can be removed _ = FleetUtilsAI.get_fleets_for_mission(target_stats, min_stats, {}, starting_system=fleet.systemID, # noqa: F841 fleet_pool_set=set(new_fleets), fleet_list=found_fleets) for fid in found_fleets: FleetUtilsAI.merge_fleet_a_into_b(fid, fleet_id) target = TargetPlanet(target_id) self.set_target(MissionType.INVASION, target) self.generate_fleet_orders() def need_to_pause_movement(self, last_move_target_id: int, new_move_order: OrderMove) -> bool: """ When a fleet has consecutive move orders, assesses whether something about the interim destination warrants forcing a stop (such as a military fleet choosing to engage with an enemy fleet about to enter the same system, or it may provide a good vantage point to view current status of next system in path). Assessments about whether the new destination is suitable to move to are (currently) separately made by OrderMove.can_issue_order() :param last_move_target_id: :param new_move_order: """ fleet = self.fleet.get_object() # don't try skipping over more than one System if fleet.nextSystemID != last_move_target_id: return True universe = fo.getUniverse() current_dest_system = universe.getSystem(fleet.nextSystemID) if not current_dest_system: # shouldn't really happen, but just to be safe return True distance_to_next_system = ((fleet.x - current_dest_system.x)**2 + (fleet.y - current_dest_system.y)**2)**0.5 surplus_travel_distance = fleet.speed - distance_to_next_system # if need more than one turn to reach current destination, then don't add another jump yet if surplus_travel_distance < 0: return True # TODO: add assessments for other situations we'd prefer to pause, such as cited above re military fleets, and # for situations where high value fleets like colony fleets might deem it safest to stop and look around # before proceeding return False def issue_fleet_orders(self): """issues AIFleetOrders which can be issued in system and moves to next one if is possible""" # TODO: priority order_completed = True debug("\nChecking orders for fleet %s (on turn %d), with mission type %s and target %s", self.fleet.get_object(), fo.currentTurn(), self.type or 'No mission', self.target or 'No Target') if MissionType.INVASION == self.type: self._check_retarget_invasion() just_issued_move_order = False last_move_target_id = INVALID_ID # Note: the following abort check somewhat assumes only one major mission type for fleet_order in self.orders: if (isinstance(fleet_order, (OrderColonize, OrderOutpost, OrderInvade)) and self._check_abort_mission(fleet_order)): return aistate = get_aistate() for fleet_order in self.orders: if just_issued_move_order and self.fleet.get_object().systemID != last_move_target_id: # having just issued a move order, we will normally stop issuing orders this turn, except that if there # are consecutive move orders we will consider moving through the first destination rather than stopping # Without the below noinspection directive, PyCharm is concerned about the 2nd part of the test # noinspection PyTypeChecker if (not isinstance(fleet_order, OrderMove) or self.need_to_pause_movement(last_move_target_id, fleet_order)): break debug("Checking order: %s" % fleet_order) self.check_mergers(context=str(fleet_order)) if fleet_order.can_issue_order(verbose=False): # only move if all other orders completed if isinstance(fleet_order, OrderMove) and order_completed: debug("Issuing fleet order %s" % fleet_order) fleet_order.issue_order() just_issued_move_order = True last_move_target_id = fleet_order.target.id elif not isinstance(fleet_order, OrderMove): debug("Issuing fleet order %s" % fleet_order) fleet_order.issue_order() else: debug("NOT issuing (even though can_issue) fleet order %s" % fleet_order) status_words = tuple(["not", ""][_s] for _s in [fleet_order.order_issued, fleet_order.executed]) debug("Order %s issued and %s fully executed." % status_words) if not fleet_order.executed: order_completed = False else: # check that we're not held up by a Big Monster if fleet_order.order_issued: # A previously issued order that wasn't instantly executed must have had cirumstances change so that # the order can't currently be reissued (or perhaps simply a savegame has been reloaded on the same # turn the order was issued). if not fleet_order.executed: order_completed = False # Go on to the next order. continue debug("CAN'T issue fleet order %s because:" % fleet_order) fleet_order.can_issue_order(verbose=True) if isinstance(fleet_order, OrderMove): this_system_id = fleet_order.target.id this_status = aistate.systemStatus.setdefault(this_system_id, {}) threat_threshold = fo.currentTurn() * MilitaryAI.cur_best_mil_ship_rating() / 4.0 if this_status.get('monsterThreat', 0) > threat_threshold: # if this move order is not this mil fleet's final destination, and blocked by Big Monster, # release and hope for more effective reassignment if (self.type not in (MissionType.MILITARY, MissionType.SECURE) or fleet_order != self.orders[-1]): debug("Aborting mission due to being blocked by Big Monster at system %d, threat %d" % ( this_system_id, aistate.systemStatus[this_system_id]['monsterThreat'])) debug("Full set of orders were:") for this_order in self.orders: debug(" - %s" % this_order) self.clear_fleet_orders() self.clear_target() return break # do not order the next order until this one is finished. else: # went through entire order list if order_completed: debug("Final order is completed") orders = self.orders last_order = orders[-1] if orders else None universe = fo.getUniverse() if last_order and isinstance(last_order, OrderColonize): planet = universe.getPlanet(last_order.target.id) sys_partial_vis_turn = get_partial_visibility_turn(planet.systemID) planet_partial_vis_turn = get_partial_visibility_turn(planet.id) if (planet_partial_vis_turn == sys_partial_vis_turn and not planet.initialMeterValue(fo.meterType.population)): warning("Fleet %s has tentatively completed its " "colonize mission but will wait to confirm population.", self.fleet) debug(" Order details are %s" % last_order) debug(" Order is valid: %s; issued: %s; executed: %s" % ( last_order.is_valid(), last_order.order_issued, last_order.executed)) if not last_order.is_valid(): source_target = last_order.fleet target_target = last_order.target debug(" source target validity: %s; target target validity: %s " % ( bool(source_target), bool(target_target))) return # colonize order must not have completed yet clear_all = True last_sys_target = INVALID_ID if last_order and isinstance(last_order, OrderMilitary): last_sys_target = last_order.target.id # not doing this until decide a way to release from a SECURE mission # if (MissionType.SECURE == self.type) or secure_targets = set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs) if last_sys_target in secure_targets: # consider a secure mission if last_sys_target in AIstate.colonyTargetedSystemIDs: secure_type = "Colony" elif last_sys_target in AIstate.outpostTargetedSystemIDs: secure_type = "Outpost" elif last_sys_target in AIstate.invasionTargetedSystemIDs: secure_type = "Invasion" else: secure_type = "Unidentified" debug("Fleet %d has completed initial stage of its mission " "to secure system %d (targeted for %s), " "may release a portion of ships" % (self.fleet.id, last_sys_target, secure_type)) clear_all = False # for PROTECT_REGION missions, only release fleet if no more threat if self.type == MissionType.PROTECT_REGION: # use military logic code below to determine if can release # any or even all of the ships. clear_all = False last_sys_target = self.target.id debug("Check if PROTECT_REGION mission with target %d is finished.", last_sys_target) fleet_id = self.fleet.id if clear_all: if orders: debug("Fleet %d has completed its mission; clearing all orders and targets." % self.fleet.id) debug("Full set of orders were:") for this_order in orders: debug("\t\t %s" % this_order) self.clear_fleet_orders() self.clear_target() if aistate.get_fleet_role(fleet_id) in (MissionType.MILITARY, MissionType.SECURE): allocations = MilitaryAI.get_military_fleets(mil_fleets_ids=[fleet_id], try_reset=False, thisround="Fleet %d Reassignment" % fleet_id) if allocations: MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=[fleet_id], allocations=allocations) else: # no orders debug("No Current Orders") else: potential_threat = combine_ratings( MilitaryAI.get_system_local_threat(last_sys_target), MilitaryAI.get_system_neighbor_threat(last_sys_target) ) threat_present = potential_threat > 0 debug("Fleet threat present? %s", threat_present) target_system = universe.getSystem(last_sys_target) if not threat_present and target_system: for pid in target_system.planetIDs: planet = universe.getPlanet(pid) if (planet and planet.owner != fo.empireID() and planet.currentMeterValue(fo.meterType.maxDefense) > 0): debug("Found local planetary threat: %s", planet) threat_present = True break if not threat_present: debug("No current threat in target system; releasing a portion of ships.") # at least first stage of current task is done; # release extra ships for potential other deployments new_fleets = FleetUtilsAI.split_fleet(self.fleet.id) if self.type == MissionType.PROTECT_REGION: self.clear_fleet_orders() self.clear_target() new_fleets.append(self.fleet.id) else: debug("Threat remains in target system; Considering to release some ships.") new_fleets = [] fleet_portion_to_remain = self._portion_of_fleet_needed_here() if fleet_portion_to_remain >= 1: debug("Can not release fleet yet due to large threat.") elif fleet_portion_to_remain > 0: debug("Not all ships are needed here - considering releasing a few") # TODO: Rate against specific enemy threat cause fleet_remaining_rating = CombatRatingsAI.get_fleet_rating(fleet_id) fleet_min_rating = fleet_portion_to_remain * fleet_remaining_rating debug("Starting rating: %.1f, Target rating: %.1f", fleet_remaining_rating, fleet_min_rating) allowance = CombatRatingsAI.rating_needed(fleet_remaining_rating, fleet_min_rating) debug("May release ships with total rating of %.1f", allowance) ship_ids = list(self.fleet.get_object().shipIDs) for ship_id in ship_ids: ship_rating = CombatRatingsAI.get_ship_rating(ship_id) debug("Considering to release ship %d with rating %.1f", ship_id, ship_rating) if ship_rating > allowance: debug("Remaining rating insufficient. Not released.") continue debug("Splitting from fleet.") new_fleet_id = FleetUtilsAI.split_ship_from_fleet(fleet_id, ship_id) if assertion_fails(new_fleet_id and new_fleet_id != INVALID_ID): break new_fleets.append(new_fleet_id) fleet_remaining_rating = CombatRatingsAI.rating_difference( fleet_remaining_rating, ship_rating) allowance = CombatRatingsAI.rating_difference( fleet_remaining_rating, fleet_min_rating) debug("Remaining fleet rating: %.1f - Allowance: %.1f", fleet_remaining_rating, allowance) if new_fleets: aistate.get_fleet_role(fleet_id, force_new=True) aistate.update_fleet_rating(fleet_id) aistate.ensure_have_fleet_missions(new_fleets) else: debug("Planetary defenses are deemed sufficient. Release fleet.") new_fleets = FleetUtilsAI.split_fleet(self.fleet.id) new_military_fleets = [] for fleet_id in new_fleets: if aistate.get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES: new_military_fleets.append(fleet_id) allocations = [] if new_military_fleets: allocations = MilitaryAI.get_military_fleets( mil_fleets_ids=new_military_fleets, try_reset=False, thisround="Fleet Reassignment %s" % new_military_fleets ) if allocations: MilitaryAI.assign_military_fleets_to_systems(use_fleet_id_list=new_military_fleets, allocations=allocations) def _portion_of_fleet_needed_here(self): """Calculate the portion of the fleet needed in target system considering enemy forces.""" # TODO check rating against planets if assertion_fails(self.type in COMBAT_MISSION_TYPES, msg=str(self)): return 0 if assertion_fails(self.target and self.target.id != INVALID_ID, msg=str(self)): return 0 system_id = self.target.id aistate = get_aistate() local_defenses = MilitaryAI.get_my_defense_rating_in_system(system_id) potential_threat = combine_ratings( MilitaryAI.get_system_local_threat(system_id), MilitaryAI.get_system_neighbor_threat(system_id) ) universe = fo.getUniverse() system = universe.getSystem(system_id) # tally planetary defenses total_defense = total_shields = 0 for planet_id in system.planetIDs: planet = universe.getPlanet(planet_id) total_defense += planet.currentMeterValue(fo.meterType.defense) total_shields += planet.currentMeterValue(fo.meterType.shield) planetary_ratings = total_defense * (total_shields + total_defense) potential_threat += planetary_ratings # TODO: rewrite to return min rating vs planets as well # consider safety factor just once here rather than everywhere below safety_factor = aistate.character.military_safety_factor() potential_threat *= safety_factor # TODO: Rate against specific threat here fleet_rating = CombatRatingsAI.get_fleet_rating(self.fleet.id) return CombatRatingsAI.rating_needed(potential_threat, local_defenses) / float(max(fleet_rating, 1.)) def generate_fleet_orders(self): """generates AIFleetOrders from fleets targets to accomplish""" universe = fo.getUniverse() fleet_id = self.fleet.id fleet = universe.getFleet(fleet_id) if (not fleet) or fleet.empty or (fleet_id in universe.destroyedObjectIDs(fo.empireID())): # fleet was probably merged into another or was destroyed get_aistate().delete_fleet_info(fleet_id) return # TODO: priority self.clear_fleet_orders() system_id = fleet.systemID # if fleet doesn't have any mission, # then repair if needed or resupply if is current location not in supplyable system empire = fo.getEmpire() fleet_supplyable_system_ids = empire.fleetSupplyableSystemIDs # if (not self.hasAnyAIMissionTypes()): if not self.target and (system_id not in set(AIstate.colonyTargetedSystemIDs + AIstate.outpostTargetedSystemIDs + AIstate.invasionTargetedSystemIDs)): if self._need_repair(): repair_fleet_order = MoveUtilsAI.get_repair_fleet_order(self.fleet) if repair_fleet_order and repair_fleet_order.is_valid(): self.orders.append(repair_fleet_order) cur_fighter_capacity, max_fighter_capacity = FleetUtilsAI.get_fighter_capacity_of_fleet(fleet_id) if (fleet.fuel < fleet.maxFuel or cur_fighter_capacity < max_fighter_capacity and get_fleet_position(self.fleet.id) not in fleet_supplyable_system_ids): resupply_fleet_order = MoveUtilsAI.get_resupply_fleet_order(self.fleet) if resupply_fleet_order.is_valid(): self.orders.append(resupply_fleet_order) return # no targets if self.target: # for some targets fleet has to visit systems and therefore fleet visit them system_to_visit = (self.target.get_system() if not self.type == MissionType.PROTECT_REGION else TargetSystem(self._get_target_for_protection_mission())) if not system_to_visit: return orders_to_visit_systems = MoveUtilsAI.create_move_orders_to_system(self.fleet, system_to_visit) # TODO: if fleet doesn't have enough fuel to get to final target, consider resetting Mission for fleet_order in orders_to_visit_systems: self.orders.append(fleet_order) # also generate appropriate final orders fleet_order = self._get_fleet_order_from_target(self.type, self.target if not self.type == MissionType.PROTECT_REGION else system_to_visit) self.orders.append(fleet_order) def _need_repair(self, repair_limit: float = 0.70) -> bool: """Check if fleet needs to be repaired. If the fleet is already at a system where it can be repaired, stay there until fully repaired. Otherwise, repair if fleet health is below specified *repair_limit*. For military fleets, there is a special evaluation called, cf. *MilitaryAI.avail_mil_needing_repair()* :param repair_limit: percentage of health below which the fleet is sent to repair :return: True if fleet needs repair """ # TODO: More complex evaluation if fleet needs repair (consider self-repair, distance, threat, mission...) fleet_id = self.fleet.id # if we are already at a system where we can repair, make sure we use it... system = self.fleet.get_system() # TODO starlane obstruction is not considered in the next call nearest_dock = MoveUtilsAI.get_best_drydock_system_id(system.id, fleet_id) if nearest_dock == system.id: repair_limit = 0.99 # if combat fleet, use military repair check if get_aistate().get_fleet_role(fleet_id) in COMBAT_MISSION_TYPES: return fleet_id in MilitaryAI.avail_mil_needing_repair([fleet_id], on_mission=bool(self.orders), repair_limit=repair_limit)[0] # TODO: Allow to split fleet to send only damaged ships to repair ships_cur_health, ships_max_health = FleetUtilsAI.get_current_and_max_structure(fleet_id) return ships_cur_health < repair_limit * ships_max_health def get_location_target(self) -> TargetSystem: # TODO add parameter turn return TargetSystem(get_fleet_position(self.fleet.id)) def __eq__(self, other): return isinstance(other, self.__class__) and self.fleet == other.target def __hash__(self): return hash(self.fleet) def __str__(self): fleet = self.fleet.get_object() fleet_id = self.fleet.id return "%-25s [%-11s] ships: %2d; total rating: %4d; target: %s" % (fleet, "NONE" if self.type is None else self.type, (fleet and len(fleet.shipIDs)) or 0, CombatRatingsAI.get_fleet_rating(fleet_id), self.target or 'no target') def _get_target_for_protection_mission(self): """Get a target for a PROTECT_REGION mission. 1) If primary target (system target of this mission) is under attack, move to primary target. 2) If neighbors of primary target have local enemy forces weaker than this fleet, may move to attack 3) If no neighboring fleets or strongest enemy force is too strong, move to defend primary target """ # TODO: Also check fleet rating vs planets in decision making below not only vs fleets universe = fo.getUniverse() primary_objective = self.target.id # TODO: Rate against specific threats fleet_rating = CombatRatingsAI.get_fleet_rating(self.fleet.id) debug("%s finding target for protection mission (primary target %s). Fleet Rating: %.1f", self.fleet, self.target, fleet_rating) immediate_threat = MilitaryAI.get_system_local_threat(primary_objective) if immediate_threat: debug(" Immediate threat! Moving to primary mission target") return primary_objective else: debug(" No immediate threats.") # Try to eliminate neighbouring fleets neighbors = universe.getImmediateNeighbors(primary_objective, fo.empireID()) threat_list = sorted(map( lambda x: (MilitaryAI.get_system_local_threat(x), x), neighbors ), reverse=True) if not threat_list: debug(" No neighbors (?!). Moving to primary mission target") return primary_objective else: debug(" Neighboring threats:") for threat, sys_id in threat_list: debug(" %s - %.1f", TargetSystem(sys_id), threat) top_threat, candidate_system = threat_list[0] if not top_threat: # TODO: Move into second ring but needs more careful evaluation # For now, consider staying at the current location if enemy # owns a planet here which we can bombard. current_system_id = self.fleet.get_current_system_id() if current_system_id in neighbors: system = universe.getSystem(current_system_id) if assertion_fails(system is not None): return primary_objective empire_id = fo.empireID() for planet_id in system.planetIDs: planet = universe.getPlanet(planet_id) if (planet and not planet.ownedBy(empire_id) and not planet.unowned): debug("Currently no neighboring threats. " "Staying for bombardment of planet %s", planet) return current_system_id # TODO consider attacking neighboring, non-military fleets # - needs more careful evaluation against neighboring threats # empire_id = fo.empireID() # for sys_id in neighbors: # system = universe.getSystem(sys_id) # if assertion_fails(system is not None): # continue # local_fleets = system.fleetIDs # for fleet_id in local_fleets: # fleet = universe.getFleet(fleet_id) # if not fleet or fleet.ownedBy(empire_id): # continue # return sys_id debug("No neighboring threats. Moving to primary mission target") return primary_objective # TODO rate against threat in target system # TODO only engage if can reach in 1 turn or leaves sufficient defense behind safety_factor = get_aistate().character.military_safety_factor() if fleet_rating < safety_factor*top_threat: debug(" Neighboring threat is too powerful. Moving to primary mission target") return primary_objective # do not engage! debug(" Engaging neighboring threat: %s", TargetSystem(candidate_system)) return candidate_system