def log_planets(): universe = fo.get_universe() planets_table = Table([ Text('id'), Text('name'), Text('system'), Text('type'), Sequence('specials'), Text('species'), Sequence('buildings') ], table_name='Planets summary') # group planets by system for sid in fo.get_systems(): for pid in fo.sys_get_planets(sid): planet = universe.getPlanet(pid) planet_type = fo.planet_get_type(pid).name planet_size = fo.planet_get_size(pid).name if planet_type != planet_size: planet_type = '%s %s' % (planet_type, planet_size) buildings = [ universe.getBuilding(x).name for x in planet.buildingIDs ] planets_table.add_row([ pid, planet.name, planet.systemID, planet_type, list(planet.specials), planet.speciesName, buildings ]) # Printing too much info at once will lead to truncation of text for line in planets_table.get_table().split('\n'): print line
def __print_candidate_table(candidates, mission, show_detail=False): universe = fo.getUniverse() if mission == "Colonization": first_column = Text("Score/Species") def get_first_column_value(x): return round(x[0], 2), x[1] elif mission == "Outposts": first_column = Number("Score") get_first_column_value = itemgetter(0) else: warning("__print_candidate_table(%s, %s): Invalid mission type" % (candidates, mission)) return columns = [first_column, Text("Planet"), Text("System"), Sequence("Specials")] if show_detail: columns.append(Sequence("Detail")) candidate_table = Table(*columns, table_name="Potential Targets for %s in Turn %d" % (mission, fo.currentTurn())) for planet_id, score_tuple in candidates: if score_tuple[0] > 0.5: planet = universe.getPlanet(planet_id) entries = [ get_first_column_value(score_tuple), planet, universe.getSystem(planet.systemID), planet.specials, ] if show_detail: entries.append(score_tuple[-1]) candidate_table.add_row(*entries) candidate_table.print_table(info)
def print_capital_info(homeworld): table = Table( Text("Id", description="Building id"), Text("Name"), Text("Type"), Sequence("Tags"), Sequence("Specials"), Text("Owner Id"), table_name="Buildings present at empire Capital in Turn %d" % fo.currentTurn(), ) universe = fo.getUniverse() for building_id in homeworld.buildingIDs: building = universe.getBuilding(building_id) table.add_row( building_id, building.name, "_".join(building.buildingTypeName.split("_")[-2:]), sorted(building.tags), sorted(building.specials), building.owner, ) table.print_table(info)
def __report_system_threats(self): """Print a table with system threats to the logfile.""" current_turn = fo.currentTurn() if current_turn >= 100: return threat_table = Table([ Text('System'), Text('Vis.'), Float('Total'), Float('by Monsters'), Float('by Fleets'), Float('by Planets'), Float('1 jump away'), Float('2 jumps'), Float('3 jumps')], table_name="System Threat Turn %d" % current_turn ) universe = fo.getUniverse() for sys_id in universe.systemIDs: sys_status = self.systemStatus.get(sys_id, {}) system = universe.getSystem(sys_id) threat_table.add_row([ system, "Yes" if sys_status.get('currently_visible', False) else "No", sys_status.get('totalThreat', 0), sys_status.get('monsterThreat', 0), sys_status.get('fleetThreat', 0), sys_status.get('planetThreat', 0), sys_status.get('neighborThreat', 0.0), sys_status.get('jump2_threat', 0.0), sys_status.get('jump3_threat', 0.0), ]) info(threat_table)
def log_planet_count_dist(sys_list): planet_count_dist = {} planet_size_dist = {size: 0 for size in planets.planet_sizes} for system in sys_list: planet_count = 0 for planet in fo.sys_get_planets(system): this_size = fo.planet_get_size(planet) if this_size in planets.planet_sizes: planet_count += 1 planet_size_dist[this_size] += 1 planet_count_dist.setdefault(planet_count, [0])[0] += 1 planet_tally = sum(planet_size_dist.values()) count_distribution_table = Table( [Text('planets in system'), Text('num of systems'), Float('% of systems', precession=1)], table_name='Planet Count Distribution' ) for planet_count, sys_count in planet_count_dist.items(): count_distribution_table.add_row((planet_count, sys_count[0], 100.0 * sys_count[0] / len(sys_list))) print(count_distribution_table) print() size_distribution = Table( [Text('size'), Text('count'), Float('% of planets', precession=1)], table_name='Planet Size Distribution' ) for planet_size, planet_count in sorted(planet_size_dist.items()): size_distribution.add_row((planet_size, planet_count, 100.0 * planet_count / planet_tally)) print(size_distribution) print()
def log_specials_summary(): special_placement_count_table = Table( Text("special"), Text("times placed"), table_name="Special Placement Summary", ) for special in sorted(specials_summary): special_placement_count_table.add_row(special, specials_summary[special]) special_placement_count_table.print_table(print) print() special_placement = Table( Text("count"), Text("tally"), Number("% of objects", precession=1), table_name="Specials Count(Repeat) Distribution", ) objects_tally = sum(specials_repeat_dist.values()) for number, tally in specials_repeat_dist.items(): special_placement.add_row( number, tally, 100.0 * tally / (1e-10 + objects_tally), ) special_placement.print_table(print) print()
def report_system_threats(self): if fo.currentTurn() >= 100: return universe = fo.getUniverse() sys_id_list = sorted( universe.systemIDs ) # will normally look at this, the list of all known systems current_turn = fo.currentTurn() # assess fleet and planet threats threat_table = Table([ Text('System'), Text('Vis.'), Float('Total'), Float('by Monsters'), Float('by Fleets'), Float('by Planets'), Float('1 jump away'), Float('2 jumps'), Float('3 jumps') ], table_name="System Threat Turn %d" % current_turn) defense_table = Table([ Text('System Defenses'), Float('Total'), Float('by Planets'), Float('by Fleets'), Float('Fleets 1 jump away'), Float('2 jumps'), Float('3 jumps') ], table_name="System Defenses Turn %d" % current_turn) for sys_id in sys_id_list: sys_status = self.systemStatus.get(sys_id, {}) system = universe.getSystem(sys_id) threat_table.add_row([ system, "Yes" if sys_status.get('currently_visible', False) else "No", sys_status.get('totalThreat', 0), sys_status.get('monsterThreat', 0), sys_status.get('fleetThreat', 0), sys_status.get('planetThreat', 0), sys_status.get('neighborThreat', 0.0), sys_status.get('jump2_threat', 0.0), sys_status.get('jump3_threat', 0.0), ]) defense_table.add_row([ system, sys_status.get('all_local_defenses', 0.0), sys_status.get('mydefenses', {}).get('overall', 0.0), sys_status.get('myFleetRating', 0.0), sys_status.get('my_neighbor_rating', 0.0), sys_status.get('my_jump2_rating', 0.0), sys_status.get('my_jump3_rating', 0.0), ]) threat_table.print_table() defense_table.print_table()
def split_new_fleets(self): """Split any new fleets (at new game creation, can have unplanned mix of ship roles).""" universe = fo.getUniverse() mission_table = Table( [ Text('Fleet'), Text('Mission'), Text('Ships'), Float('Rating'), Float('Troops'), Text('Target') ], table_name="Turn %d: Fleet Mission Review from Last Turn" % fo.currentTurn()) for fleet_id, mission in self.get_fleet_missions_map().items(): fleet = universe.getFleet(fleet_id) if not fleet: continue if not mission: mission_table.add_row([fleet]) else: mission_table.add_row([ fleet, mission.type or "None", len(fleet.shipIDs), CombatRatingsAI.get_fleet_rating(fleet_id), FleetUtilsAI.count_troops_in_fleet(fleet_id), mission.target or "-" ]) mission_table.print_table() # TODO: check length of fleets for losses or do in AIstat.__cleanRoles known_fleets = self.get_fleet_roles_map() self.newlySplitFleets.clear() fleets_to_split = [ fleet_id for fleet_id in FleetUtilsAI.get_empire_fleet_ids() if fleet_id not in known_fleets ] if fleets_to_split: print "Splitting new fleets" for fleet_id in fleets_to_split: fleet = universe.getFleet(fleet_id) if not fleet: print >> sys.stderr, "After splitting fleet: resulting fleet ID %d appears to not exist" % fleet_id continue fleet_len = len(list(fleet.shipIDs)) if fleet_len == 1: continue new_fleets = FleetUtilsAI.split_fleet( fleet_id) # try splitting fleet print "\t from splitting fleet ID %4d with %d ships, got %d new fleets:" % ( fleet_id, fleet_len, len(new_fleets))
def log_systems(): universe = fo.get_universe() systems_table = Table( [Text('id'), Text('name'), Sequence('planets'), Sequence('connections'), Text('star')], table_name='System summary') for sid in fo.get_systems(): system = universe.getSystem(sid) systems_table.add_row([ sid, system.name, fo.sys_get_planets(sid), fo.sys_get_starlanes(sid), system.starType.name ]) # Printing too much info at once will lead to truncation of text for line in systems_table.get_table().split('\n'): print(line)
def _report_classes_without_instances(classes_map, instance_names, classes_to_ignore: set): missed_instances = instance_names.symmetric_difference( classes_map).difference(classes_to_ignore) if not missed_instances: return warning("") warning( "In order to get more information about the classes in API we need to process an instances of thea classes." ) warning( "Classes mentioned bellow does not have instances so their specs are not full." ) warning("Please provide instances or add them to ignored,") warning( "check generate_stub usage in the freeorion/default/python/handlers folder." ) warning("") table = Table([Text("classes")], ) for inst in sorted(missed_instances, key=str.lower): table.add_row((str(inst), )) warning(table.get_table())
def test_empty_table(): empty = Table( [Text('name', description='Name for first column'), Float('value', description='VValue'), Sequence('zzz'), Sequence('zzzzzzzzzzzzzzzzzz')], table_name='Wooho' ) assert empty.get_table() == EXPECTED_EMPTY_TABLE
def _report_classes_without_instances(classes_map: Iterable[str], instance_names, classes_to_ignore: Set[str]): missed_instances = instance_names.symmetric_difference( classes_map).difference(classes_to_ignore) if not missed_instances: return warning("") warning( fill( "In order to get more information about the classes in API" " we need to process an instances of classes." " Classes mentioned bellow does not have instances so their specs are not full." " Please provide instances or add them to ignored," " check generate_stub usage in the" " freeorion/default/python/handlers folder.", width=60, )) table = Table(Text("classes without instances")) for inst in sorted(missed_instances, key=str.lower): table.add_row(inst) table.print_table(warning)
def log_monsters_summary(monster_freq): monster_place_table = Table( Text("monster"), Text("count"), table_name="Monster placement", ) for monster, counter in sorted(monsters_summary): monster_place_table.add_row(monster, counter) monster_place_table.print_table(print) print() monster_chance = universe_tables.MONSTER_FREQUENCY[monster_freq] monster_table = Table( Text("monster"), Number("chance"), Text("attempts"), Text("number placed"), Text("number valid sys locs"), Text("number valid nest planet locs"), table_name=( "Space Monsters Placement Summary\n" "Tracked Monster and Nest Summary (base monster freq: %4.1f%%)" % (100 * monster_chance)), ) for monster in sorted(tracked_monsters_summary): monster_table.add_row( monster, tracked_monsters_chance[monster], tracked_monsters_tries[monster], tracked_monsters_summary[monster], tracked_monsters_location_summary[monster], tracked_nest_location_summary[monster], ) monster_table.print_table(print) print()
def log_monsters_summary(monster_freq): monster_place_table = Table( [Text('monster'), Text('count')], table_name='Monster placement') for monster, counter in sorted(monsters_summary): monster_place_table.add_row([monster, counter]) monster_place_table.print_table() print monster_chance = universe_tables.MONSTER_FREQUENCY[monster_freq] monster_table = Table( [ Text('monster'), Float('chance'), Text('attempts'), Text('number placed'), Text('number valid sys locs'), Text('number valid nest planet locs') ], table_name=( "Space Monsters Placement Summary\n" "Tracked Monster and Nest Summary (base monster freq: %4.1f%%)" % (100 * monster_chance))) for monster in sorted(tracked_monsters_summary): monster_table.add_row((monster, tracked_monsters_chance[monster], tracked_monsters_tries[monster], tracked_monsters_summary[monster], tracked_monsters_location_summary[monster], tracked_nest_location_summary[monster])) monster_table.print_table() print
def log_planet_count_dist(sys_list): planet_count_dist = {} planet_size_dist = {size: 0 for size in planets.planet_sizes} for system in sys_list: planet_count = 0 for planet in fo.sys_get_planets(system): this_size = fo.planet_get_size(planet) if this_size in planets.planet_sizes: planet_count += 1 planet_size_dist[this_size] += 1 planet_count_dist.setdefault(planet_count, [0])[0] += 1 planet_tally = sum(planet_size_dist.values()) count_distribution_table = Table( Text("planets in system"), Text("num of systems"), Number("% of systems", precession=1), table_name="Planet Count Distribution", ) for planet_count, sys_count in planet_count_dist.items(): count_distribution_table.add_row( planet_count, sys_count[0], 100.0 * sys_count[0] / len(sys_list), ) count_distribution_table.print_table(print) print() size_distribution = Table( Text("size"), Text("count"), Number("% of planets", precession=1), table_name="Planet Size Distribution", ) for planet_size, planet_count in sorted(planet_size_dist.items()): size_distribution.add_row( planet_size, planet_count, 100.0 * planet_count / planet_tally, ) size_distribution.print_table(print) print()
def _print_empire_species_roster(): """Print empire species roster in table format to log.""" grade_map = {"ULTIMATE": "+++", "GREAT": "++", "GOOD": "+", "AVERAGE": "o", "BAD": "-", "NO": "---"} grade_tags = [ Tags.INDUSTRY, Tags.RESEARCH, Tags.POPULATION, Tags.SUPPLY, Tags.WEAPONS, Tags.ATTACKTROOPS, ] grade_tags_names = { Tags.INDUSTRY: "Ind.", Tags.RESEARCH: "Res.", Tags.POPULATION: "Pop.", Tags.SUPPLY: "Supply", Tags.WEAPONS: "Pilot", Tags.ATTACKTROOPS: "Troop", } species_table = Table( Text("species"), Sequence("PIDs"), Bool("Colonize"), Text("Shipyards"), *[Text(grade_tags_names[v]) for v in grade_tags], Sequence("Tags"), table_name="Empire species roster Turn %d" % fo.currentTurn(), ) for species_name, planet_ids in get_empire_planets_by_species().items(): species_tags = fo.getSpecies(species_name).tags number_of_shipyards = len(get_ship_builder_locations(species_name)) species_table.add_row( species_name, planet_ids, can_build_colony_for_species(species_name), number_of_shipyards, *[grade_map.get(get_species_tag_grade(species_name, tag).upper(), "o") for tag in grade_tags], [tag for tag in species_tags if not any(s in tag for s in grade_tags) and "PEDIA" not in tag], ) species_table.print_table(info)
def log_specials_summary(): special_placement_count_table = Table( [Text('special'), Text('times placed')], table_name="Special Placement Summary" ) for special in sorted(specials_summary): special_placement_count_table.add_row([special, specials_summary[special]]) print(special_placement_count_table) print() special_placement = Table( [Text('count'), Text('tally'), Float('% of objects', precession=1)], table_name="Specials Count(Repeat) Distribution" ) objects_tally = sum(specials_repeat_dist.values()) for number, tally in specials_repeat_dist.items(): special_placement.add_row((number, tally, 100.0 * tally / (1E-10 + objects_tally))) print(special_placement) print()
def test_simple_table(): t = Table( [Text('name', description='Name for first column'), Float('value', description='VValue'), Sequence('zzz'), Sequence('zzzzzzzzzzzzzzzzzz')], table_name='Wooho') t.add_row(['hello', 144444, 'abcffff', 'a']) t.add_row([u'Plato aa\u03b2 III', 21, 'de', 'a']) t.add_row([u'Plato \u03b2 III', 21, 'de', 'a']) t.add_row(['Plato B III', 21, 'd', 'a']) t.add_row(['Plato Bddddd III', 21, 'd', 'a']) t.add_row(['Plato III', 21, 'd', 'a']) assert t.get_table() == EXPECTED_SIMPLE_TABLE
def log_systems(): universe = fo.get_universe() systems_table = Table( Text("id"), Text("name"), Sequence("planets"), Sequence("connections"), Text("star"), table_name="System summary", ) for sid in fo.get_systems(): system = universe.getSystem(sid) systems_table.add_row( sid, system.name, fo.sys_get_planets(sid), fo.sys_get_starlanes(sid), system.starType.name, ) systems_table.print_table(print)
def print_resources_priority(): """Calculate top resource priority.""" universe = fo.getUniverse() empire = fo.getEmpire() empire_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire( universe.planetIDs) debug("Resource Priorities:") resource_priorities = {} aistate = get_aistate() for priority_type in get_priority_resource_types(): resource_priorities[priority_type] = aistate.get_priority( priority_type) sorted_priorities = sorted(resource_priorities.items(), key=itemgetter(1), reverse=True) top_priority = -1 for evaluation_priority, evaluation_score in sorted_priorities: if top_priority < 0: top_priority = evaluation_priority debug(" %s: %.2f", evaluation_priority, evaluation_score) # what is the focus of available resource centers? debug("") warnings = {} foci_table = Table( Text("Planet"), Text("Size"), Text("Type"), Text("Focus"), Text("Species"), Text("Pop"), table_name="Planetary Foci Overview Turn %d" % fo.currentTurn(), ) for pid in empire_planet_ids: planet = universe.getPlanet(pid) population = planet.currentMeterValue(fo.meterType.population) max_population = planet.currentMeterValue( fo.meterType.targetPopulation) if max_population < 1 and population > 0: warnings[planet.name] = (population, max_population) foci_table.add_row( planet, planet.size, planet.type, "_".join(str(planet.focus).split("_")[1:])[:8], planet.speciesName, "%.1f/%.1f" % (population, max_population), ) foci_table.print_table(info) debug( "Empire Totals:\nPopulation: %5d \nProduction: %5d\nResearch: %5d\n", empire.population(), empire.productionPoints, empire.resourceProduction(fo.resourceType.research), ) for name, (cp, mp) in warnings.items(): warning( "Population Warning! -- %s has unsustainable current pop %d -- target %d", name, cp, mp)
def print_production_queue(after_turn=False): """Print production queue content with relevant info in table format.""" universe = fo.getUniverse() s = "after" if after_turn else "before" title = "Production Queue Turn %d %s ProductionAI calls" % ( fo.currentTurn(), s) prod_queue_table = Table( Text("Object"), Text("Location"), Text("Quantity"), Text("Progress"), Text("Allocated PP"), Text("Turns left"), table_name=title, ) for element in fo.getEmpire().productionQueue: if element.buildType == EmpireProductionTypes.BT_SHIP: item = fo.getShipDesign(element.designID) elif element.buildType == EmpireProductionTypes.BT_BUILDING: item = fo.getBuildingType(element.name) else: continue cost = item.productionCost(fo.empireID(), element.locationID) prod_queue_table.add_row( element.name, universe.getPlanet(element.locationID), "%dx %d" % (element.remaining, element.blocksize), "%.1f / %.1f" % (element.progress * cost, cost), "%.1f" % element.allocation, "%d" % element.turnsLeft, ) prod_queue_table.print_table(info)
def __report_last_turn_fleet_missions(self): """Print a table reviewing last turn fleet missions to the log file.""" universe = fo.getUniverse() mission_table = Table( [Text('Fleet'), Text('Mission'), Text('Ships'), Float('Rating'), Float('Troops'), Text('Target')], table_name="Turn %d: Fleet Mission Review from Last Turn" % fo.currentTurn()) for fleet_id, mission in self.get_fleet_missions_map().items(): fleet = universe.getFleet(fleet_id) if not fleet: continue if not mission: mission_table.add_row([fleet]) else: mission_table.add_row([ fleet, mission.type or "None", len(fleet.shipIDs), CombatRatingsAI.get_fleet_rating(fleet_id), FleetUtilsAI.count_troops_in_fleet(fleet_id), mission.target or "-" ]) info(mission_table)
def log_planets(): universe = fo.get_universe() planets_table = Table( Text("id"), Text("name"), Text("system"), Text("type"), Sequence("specials"), Text("species"), Sequence("buildings"), table_name="Planets summary", ) # group planets by system for sid in fo.get_systems(): for pid in fo.sys_get_planets(sid): planet = universe.getPlanet(pid) planet_type = fo.planet_get_type(pid).name planet_size = fo.planet_get_size(pid).name if planet_type != planet_size: planet_type = "%s %s" % (planet_type, planet_size) buildings = [ universe.getBuilding(x).name for x in planet.buildingIDs ] planets_table.add_row( pid, planet.name, planet.systemID, planet_type, list(planet.specials), planet.speciesName, buildings, ) planets_table.print_table(print)
def make_table(): t = Table( Text("name", description="Name for first column"), Number("value", description="VValue"), Sequence("zzz"), Sequence("zzzzzzzzzzzzzzzzzz"), table_name="Wooho", ) t.add_row("hello", 144444, "abcffff", "a") t.add_row("Plato aa\u03b2 III", 21, "de", "a") t.add_row("Plato \u03b2 III", 21, "de", "a") t.add_row("Plato B III", 21, "d", "a") t.add_row("Plato Bddddd III", 21, "d", "a") t.add_row("Plato III", 21, "d", "a") return t
def log_planet_type_summary(sys_list): planet_type_summary_table = {k: 0 for k in planets.planet_types} for system in sys_list: for planet in fo.sys_get_planets(system): planet_type_summary_table[fo.planet_get_type(planet)] += 1 planet_total = sum(planet_type_summary_table.values()) type_summary_table = Table( [Text('planet type', align='<'), Float('% of planets', precession=1)], table_name='Planet Type Summary for a total of %d placed planets' % planet_total ) for planet_type, planet_count in sorted(planet_type_summary_table.items()): type_summary_table.add_row((planet_type.name, 100.0 * planet_count / planet_total)) print(type_summary_table) print()
def print_resources_priority(): """Calculate top resource priority.""" universe = fo.getUniverse() empire = fo.getEmpire() empire_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire( universe.planetIDs) print "Resource Priorities:" resource_priorities = {} for priority_type in get_priority_resource_types(): resource_priorities[priority_type] = foAI.foAIstate.get_priority( priority_type) sorted_priorities = resource_priorities.items() sorted_priorities.sort(lambda x, y: cmp(x[1], y[1]), reverse=True) top_priority = -1 for evaluation_priority, evaluation_score in sorted_priorities: if top_priority < 0: top_priority = evaluation_priority print " %s: %.2f" % (evaluation_priority, evaluation_score) # what is the focus of available resource centers? print warnings = {} foci_table = Table([ Text('Planet'), Text('Size'), Text('Type'), Text('Focus'), Text('Species'), Text('Pop') ], table_name="Planetary Foci Overview Turn %d" % fo.currentTurn()) for pid in empire_planet_ids: planet = universe.getPlanet(pid) population = planet.currentMeterValue(fo.meterType.population) max_population = planet.currentMeterValue( fo.meterType.targetPopulation) if max_population < 1 and population > 0: warnings[planet.name] = (population, max_population) foci_table.add_row([ planet, planet.size, planet.type, "_".join(str(planet.focus).split("_")[1:])[:8], planet.speciesName, "%.1f/%.1f" % (population, max_population) ]) foci_table.print_table() print "Empire Totals:\nPopulation: %5d \nProduction: %5d\nResearch: %5d\n" % ( empire.population(), empire.productionPoints, empire.resourceProduction(fo.resourceType.research)) for name, (cp, mp) in warnings.iteritems(): print "Population Warning! -- %s has unsustainable current pop %d -- target %d" % ( name, cp, mp)
def test_empty_table(): empty = Table( Text("name", description="Name for first column"), Number("value", description="VValue"), Sequence("zzz"), Sequence("zzzzzzzzzzzzzzzzzz"), table_name="Wooho", ) io = StringIO() def writer(row): io.write(row) io.write("\n") empty.print_table(writer) assert io.getvalue() == EXPECTED_EMPTY_TABLE
def log_planet_type_summary(sys_list): planet_type_summary_table = {k: 0 for k in planets.planet_types} for system in sys_list: for planet in fo.sys_get_planets(system): planet_type_summary_table[fo.planet_get_type(planet)] += 1 planet_total = sum(planet_type_summary_table.values()) type_summary_table = Table( Text("planet type", align="<"), Number("% of planets", precession=1), table_name="Planet Type Summary for a total of %d placed planets" % planet_total, ) for planet_type, planet_count in sorted(planet_type_summary_table.items()): type_summary_table.add_row( planet_type.name, 100.0 * planet_count / planet_total, ) type_summary_table.print_table(print) print()
def __report_system_defenses(self): """Print a table with system defenses to the logfile.""" current_turn = fo.currentTurn() if current_turn >= 100: return defense_table = Table([ Text('System Defenses'), Float('Total'), Float('by Planets'), Float('by Fleets'), Float('Fleets 1 jump away'), Float('2 jumps'), Float('3 jumps')], table_name="System Defenses Turn %d" % current_turn ) universe = fo.getUniverse() for sys_id in universe.systemIDs: sys_status = self.systemStatus.get(sys_id, {}) system = universe.getSystem(sys_id) defense_table.add_row([ system, sys_status.get('all_local_defenses', 0.0), sys_status.get('mydefenses', {}).get('overall', 0.0), sys_status.get('myFleetRating', 0.0), sys_status.get('my_neighbor_rating', 0.0), sys_status.get('my_jump2_rating', 0.0), sys_status.get('my_jump3_rating', 0.0), ]) info(defense_table)
def get_invasion_fleets(): invasion_timer.start("gathering initial info") universe = fo.getUniverse() empire = fo.getEmpire() empire_id = fo.empireID() home_system_id = PlanetUtilsAI.get_capital_sys_id() aistate = get_aistate() visible_system_ids = list(aistate.visInteriorSystemIDs) + list( aistate.visBorderSystemIDs) if home_system_id != INVALID_ID: accessible_system_ids = [ sys_id for sys_id in visible_system_ids if systems_connected(sys_id, home_system_id) ] else: debug( "Empire has no identifiable homeworld; will treat all visible planets as accessible." ) # TODO: check if any troop ships owned, use their system as home system accessible_system_ids = visible_system_ids acessible_planet_ids = PlanetUtilsAI.get_planets_in__systems_ids( accessible_system_ids) all_owned_planet_ids = PlanetUtilsAI.get_all_owned_planet_ids( acessible_planet_ids) # includes unpopulated outposts all_populated_planets = PlanetUtilsAI.get_populated_planet_ids( acessible_planet_ids) # includes unowned natives empire_owned_planet_ids = PlanetUtilsAI.get_owned_planets_by_empire( universe.planetIDs) invadable_planet_ids = set(all_owned_planet_ids).union( all_populated_planets) - set(empire_owned_planet_ids) invasion_targeted_planet_ids = get_invasion_targeted_planet_ids( universe.planetIDs, MissionType.INVASION) invasion_targeted_planet_ids.extend( get_invasion_targeted_planet_ids(universe.planetIDs, MissionType.ORBITAL_INVASION)) all_invasion_targeted_system_ids = set( PlanetUtilsAI.get_systems(invasion_targeted_planet_ids)) invasion_fleet_ids = FleetUtilsAI.get_empire_fleet_ids_by_role( MissionType.INVASION) num_invasion_fleets = len( FleetUtilsAI.extract_fleet_ids_without_mission_types( invasion_fleet_ids)) debug("Current Invasion Targeted SystemIDs: %s" % PlanetUtilsAI.sys_name_ids(AIstate.invasionTargetedSystemIDs)) debug("Current Invasion Targeted PlanetIDs: %s" % PlanetUtilsAI.planet_string(invasion_targeted_planet_ids)) debug(invasion_fleet_ids and "Invasion Fleet IDs: %s" % invasion_fleet_ids or "Available Invasion Fleets: 0") debug("Invasion Fleets Without Missions: %s" % num_invasion_fleets) invasion_timer.start("planning troop base production") reserved_troop_base_targets = [] if aistate.character.may_invade_with_bases(): available_pp = {} for el in empire.planetsWithAvailablePP: # keys are sets of ints; data is doubles avail_pp = el.data() for pid in el.key(): available_pp[pid] = avail_pp # For planning base trooper invasion targets we have a two-pass system. (1) In the first pass we consider all # the invasion targets and figure out which ones appear to be suitable for using base troopers against (i.e., we # already have a populated planet in the same system that could build base troopers) and we have at least a # minimal amount of PP available, and (2) in the second pass we go through the reserved base trooper target list # and check to make sure that there does not appear to be too much military action still needed before the # target is ready to be invaded, we double check that not too many base troopers would be needed, and if things # look clear then we queue up the base troopers on the Production Queue and keep track of where we are building # them, and how many; we may also disqualify and remove previously qualified targets (in case, for example, # we lost our base trooper source planet since it was first added to list). # # For planning and tracking base troopers under construction, we use a dictionary store in # get_aistate().qualifyingTroopBaseTargets, keyed by the invasion target planet ID. We only store values # for invasion targets that appear likely to be suitable for base trooper use, and store a 2-item list. # The first item in this list is the ID of the planet where we expect to build the base troopers, and the second # entry initially is set to INVALID_ID (-1). The presence of this entry in qualifyingTroopBaseTargets # flags this target as being reserved as a base-trooper invasion target. # In the second pass, if/when we actually start construction, then we modify the record, replacing that second # value with the ID of the planet where the troopers are actually being built. (Right now that is always the # same as the source planet originally identified, but we could consider reevaluating that, or use that second # value to instead record how many base troopers have been queued, so that on later turns we can assess if the # process got delayed & perhaps more troopers need to be queued). # Pass 1: identify qualifying base troop invasion targets for pid in invadable_planet_ids: # TODO: reorganize if pid in aistate.qualifyingTroopBaseTargets: continue planet = universe.getPlanet(pid) if not planet: continue sys_id = planet.systemID sys_partial_vis_turn = get_partial_visibility_turn(sys_id) planet_partial_vis_turn = get_partial_visibility_turn(pid) if planet_partial_vis_turn < sys_partial_vis_turn: continue best_base_planet = INVALID_ID best_trooper_count = 0 for pid2 in get_colonized_planets_in_system(sys_id): if available_pp.get( pid2, 0 ) < 2: # TODO: improve troop base PP sufficiency determination break planet2 = universe.getPlanet(pid2) if not planet2 or not can_build_ship_for_species( planet2.speciesName): continue best_base_trooper_here = get_best_ship_info( PriorityType.PRODUCTION_ORBITAL_INVASION, pid2)[1] if not best_base_trooper_here: continue troops_per_ship = best_base_trooper_here.troopCapacity if not troops_per_ship: continue species_troop_grade = get_species_tag_grade( planet2.speciesName, Tags.ATTACKTROOPS) troops_per_ship = CombatRatingsAI.weight_attack_troops( troops_per_ship, species_troop_grade) if troops_per_ship > best_trooper_count: best_base_planet = pid2 best_trooper_count = troops_per_ship if best_base_planet != INVALID_ID: aistate.qualifyingTroopBaseTargets.setdefault( pid, [best_base_planet, INVALID_ID]) # Pass 2: for each target previously identified for base troopers, check that still qualifies and # check how many base troopers would be needed; if reasonable then queue up the troops and record this in # get_aistate().qualifyingTroopBaseTargets for pid in list(aistate.qualifyingTroopBaseTargets.keys()): planet = universe.getPlanet(pid) if planet and planet.owner == empire_id: del aistate.qualifyingTroopBaseTargets[pid] continue if pid in invasion_targeted_planet_ids: # TODO: consider overriding standard invasion mission continue if aistate.qualifyingTroopBaseTargets[pid][1] != -1: reserved_troop_base_targets.append(pid) if planet: all_invasion_targeted_system_ids.add(planet.systemID) # TODO: evaluate changes to situation, any more troops needed, etc. continue # already building for here _, planet_troops = evaluate_invasion_planet(pid) sys_id = planet.systemID this_sys_status = aistate.systemStatus.get(sys_id, {}) troop_tally = 0 for _fid in this_sys_status.get("myfleets", []): troop_tally += FleetUtilsAI.count_troops_in_fleet(_fid) if troop_tally > planet_troops: # base troopers appear unneeded del aistate.qualifyingTroopBaseTargets[pid] continue if planet.currentMeterValue(fo.meterType.shield) > 0 and ( this_sys_status.get("myFleetRating", 0) < 0.8 * this_sys_status.get("totalThreat", 0) or this_sys_status.get("myFleetRatingVsPlanets", 0) < this_sys_status.get("planetThreat", 0)): # this system not secured, so ruling out invasion base troops for now # don't immediately delete from qualifyingTroopBaseTargets or it will be opened up for regular troops continue loc = aistate.qualifyingTroopBaseTargets[pid][0] best_base_trooper_here = get_best_ship_info( PriorityType.PRODUCTION_ORBITAL_INVASION, loc)[1] loc_planet = universe.getPlanet(loc) if best_base_trooper_here is None: # shouldn't be possible at this point, but just to be safe warning( "Could not find a suitable orbital invasion design at %s" % loc_planet) continue # TODO: have TroopShipDesigner give the expected number of troops including species effects directly troops_per_ship = best_base_trooper_here.troopCapacity species_troop_grade = get_species_tag_grade( loc_planet.speciesName, Tags.ATTACKTROOPS) troops_per_ship = CombatRatingsAI.weight_attack_troops( troops_per_ship, species_troop_grade) if not troops_per_ship: warning( "The best orbital invasion design at %s seems not to have any troop capacity." % loc_planet) continue _, col_design, build_choices = get_best_ship_info( PriorityType.PRODUCTION_ORBITAL_INVASION, loc) if not col_design: continue if loc not in build_choices: warning( "Best troop design %s can not be produced at planet with id: %s" % (col_design, build_choices)) continue n_bases = math.ceil( (planet_troops + 1) / troops_per_ship) # TODO: reconsider this +1 safety factor # TODO: evaluate cost and time-to-build of best base trooper here versus cost and time-to-build-and-travel # for best regular trooper elsewhere # For now, we assume what building base troopers is best so long as either (1) we would need no more than # MAX_BASE_TROOPERS_POOR_INVADERS base troop ships, or (2) our base troopers have more than 1 trooper per # ship and we would need no more than MAX_BASE_TROOPERS_GOOD_INVADERS base troop ships if n_bases > MAX_BASE_TROOPERS_POOR_INVADERS or ( troops_per_ship > 1 and n_bases > MAX_BASE_TROOPERS_GOOD_INVADERS): debug( "ruling out base invasion troopers for %s due to high number (%d) required." % (planet, n_bases)) del aistate.qualifyingTroopBaseTargets[pid] continue debug( "Invasion base planning, need %d troops at %d per ship, will build %d ships." % ((planet_troops + 1), troops_per_ship, n_bases)) retval = fo.issueEnqueueShipProductionOrder(col_design.id, loc) debug("Enqueueing %d Troop Bases at %s for %s" % (n_bases, PlanetUtilsAI.planet_string(loc), PlanetUtilsAI.planet_string(pid))) if retval != 0: all_invasion_targeted_system_ids.add(planet.systemID) reserved_troop_base_targets.append(pid) aistate.qualifyingTroopBaseTargets[pid][1] = loc fo.issueChangeProductionQuantityOrder( empire.productionQueue.size - 1, 1, int(n_bases)) fo.issueRequeueProductionOrder(empire.productionQueue.size - 1, 0) invasion_timer.start("evaluating target planets") # TODO: check if any invasion_targeted_planet_ids need more troops assigned evaluated_planet_ids = list( set(invadable_planet_ids) - set(invasion_targeted_planet_ids) - set(reserved_troop_base_targets)) evaluated_planets = assign_invasion_values(evaluated_planet_ids) sorted_planets = [(pid, pscore % 10000, ptroops) for pid, (pscore, ptroops) in evaluated_planets.items()] sorted_planets.sort(key=lambda x: x[1], reverse=True) sorted_planets = [(pid, pscore % 10000, ptroops) for pid, pscore, ptroops in sorted_planets] invasion_table = Table( Text("Planet"), Number("Score"), Text("Species"), Number("Troops"), table_name="Potential Targets for Invasion Turn %d" % fo.currentTurn(), ) for pid, pscore, ptroops in sorted_planets: planet = universe.getPlanet(pid) invasion_table.add_row(planet, pscore, planet and planet.speciesName or "unknown", ptroops) invasion_table.print_table(info) sorted_planets = [x for x in sorted_planets if x[1] > 0] # export opponent planets for other AI modules AIstate.opponentPlanetIDs = [pid for pid, __, __ in sorted_planets] AIstate.invasionTargets = sorted_planets # export invasion targeted systems for other AI modules AIstate.invasionTargetedSystemIDs = list(all_invasion_targeted_system_ids) invasion_timer.stop(section_name="evaluating %d target planets" % (len(evaluated_planet_ids))) invasion_timer.stop_print_and_clear()