from __future__ import annotations import logging import pickle import random from dataclasses import dataclass from datetime import datetime from typing import Any, Dict, Iterable, List, Set from dcs.mapping import Point from dcs.task import CAP, CAS, PinpointStrike from dcs.vehicles import AirDefence from game import Game from game.factions.faction import Faction from game.scenery_group import SceneryGroup from game.theater import Carrier, Lha, PointWithHeading from game.theater.theatergroundobject import ( BuildingGroundObject, CarrierGroundObject, EwrGroundObject, FactoryGroundObject, LhaGroundObject, MissileSiteGroundObject, SamGroundObject, ShipGroundObject, SceneryGroundObject, VehicleGroupGroundObject, CoastalSiteGroundObject, ) from game.version import VERSION from gen import namegen from gen.coastal.coastal_group_generator import generate_coastal_group from gen.defenses.armor_group_generator import generate_armor_group from gen.fleet.ship_group_generator import ( generate_carrier_group, generate_lha_group, generate_ship_group, ) from gen.missiles.missiles_group_generator import generate_missile_group from gen.sam.airdefensegroupgenerator import AirDefenseRange from gen.sam.ewr_group_generator import generate_ewr_group from gen.sam.sam_group_generator import generate_anti_air_group from . import ( ConflictTheater, ControlPoint, ControlPointType, Fob, OffMapSpawn, ) from ..profiling import logged_duration from ..settings import Settings GroundObjectTemplates = Dict[str, Dict[str, Any]] UNIT_VARIETY = 6 UNIT_AMOUNT_FACTOR = 16 UNIT_COUNT_IMPORTANCE_LOG = 1.3 COUNT_BY_TASK = { PinpointStrike: 12, CAP: 8, CAS: 4, AirDefence: 1, } @dataclass(frozen=True) class GeneratorSettings: start_date: datetime player_budget: int enemy_budget: int midgame: bool inverted: bool no_carrier: bool no_lha: bool no_player_navy: bool no_enemy_navy: bool @dataclass class ModSettings: a4_skyhawk: bool = False f22_raptor: bool = False hercules: bool = False jas39_gripen: bool = False su57_felon: bool = False frenchpack: bool = False high_digit_sams: bool = False class GameGenerator: def __init__( self, player: Faction, enemy: Faction, theater: ConflictTheater, settings: Settings, generator_settings: GeneratorSettings, mod_settings: ModSettings, ) -> None: self.player = player self.enemy = enemy self.theater = theater self.settings = settings self.generator_settings = generator_settings self.mod_settings = mod_settings def generate(self) -> Game: with logged_duration("TGO population"): # Reset name generator namegen.reset() self.prepare_theater() game = Game( player_faction=self.player.apply_mod_settings(self.mod_settings), enemy_faction=self.enemy.apply_mod_settings(self.mod_settings), theater=self.theater, start_date=self.generator_settings.start_date, settings=self.settings, player_budget=self.generator_settings.player_budget, enemy_budget=self.generator_settings.enemy_budget, ) GroundObjectGenerator(game, self.generator_settings).generate() game.settings.version = VERSION return game def prepare_theater(self) -> None: to_remove: List[ControlPoint] = [] # Auto-capture half the bases if midgame. if self.generator_settings.midgame: control_points = self.theater.controlpoints for control_point in control_points[: len(control_points) // 2]: control_point.captured = True # Remove carrier and lha, invert situation if needed for cp in self.theater.controlpoints: if isinstance(cp, Carrier) and self.generator_settings.no_carrier: to_remove.append(cp) elif isinstance(cp, Lha) and self.generator_settings.no_lha: to_remove.append(cp) if self.generator_settings.inverted: cp.captured = cp.captured_invert # do remove for cp in to_remove: self.theater.controlpoints.remove(cp) # TODO: Fix this. This captures all bases for blue. # reapply midgame inverted if needed if self.generator_settings.midgame and self.generator_settings.inverted: for i, cp in enumerate(reversed(self.theater.controlpoints)): if i > len(self.theater.controlpoints): break else: cp.captured = True class ControlPointGroundObjectGenerator: def __init__( self, game: Game, generator_settings: GeneratorSettings, control_point: ControlPoint, ) -> None: self.game = game self.generator_settings = generator_settings self.control_point = control_point @property def faction_name(self) -> str: return self.faction.name @property def faction(self) -> Faction: return self.game.coalition_for(self.control_point.captured).faction def generate(self) -> bool: self.control_point.connected_objectives = [] if self.faction.navy_generators: # Even airbases can generate navies if they are close enough to the water. self.generate_navy() return True def generate_navy(self) -> None: skip_player_navy = self.generator_settings.no_player_navy if self.control_point.captured and skip_player_navy: return skip_enemy_navy = self.generator_settings.no_enemy_navy if not self.control_point.captured and skip_enemy_navy: return for position in self.control_point.preset_locations.ships: self.generate_ship_at(position) def generate_ship_at(self, position: PointWithHeading) -> None: group_id = self.game.next_group_id() g = ShipGroundObject( namegen.random_objective_name(), group_id, position, self.control_point ) group = generate_ship_group(self.game, g, self.faction_name) g.groups = [] if group is not None: g.groups.append(group) self.control_point.connected_objectives.append(g) class NoOpGroundObjectGenerator(ControlPointGroundObjectGenerator): def generate(self) -> bool: return True class CarrierGroundObjectGenerator(ControlPointGroundObjectGenerator): def generate(self) -> bool: if not super().generate(): return False carrier_names = self.faction.carrier_names if not carrier_names: logging.info( f"Skipping generation of {self.control_point.name} because " f"{self.faction_name} has no carriers" ) return False # Create ground object group group_id = self.game.next_group_id() g = CarrierGroundObject( namegen.random_objective_name(), group_id, self.control_point ) group = generate_carrier_group(self.faction_name, self.game, g) g.groups = [] if group is not None: g.groups.append(group) self.control_point.connected_objectives.append(g) self.control_point.name = random.choice(carrier_names) return True class LhaGroundObjectGenerator(ControlPointGroundObjectGenerator): def generate(self) -> bool: if not super().generate(): return False lha_names = self.faction.helicopter_carrier_names if not lha_names: logging.info( f"Skipping generation of {self.control_point.name} because " f"{self.faction_name} has no LHAs" ) return False # Create ground object group group_id = self.game.next_group_id() g = LhaGroundObject( namegen.random_objective_name(), group_id, self.control_point ) group = generate_lha_group(self.faction_name, self.game, g) g.groups = [] if group is not None: g.groups.append(group) self.control_point.connected_objectives.append(g) self.control_point.name = random.choice(lha_names) return True class AirbaseGroundObjectGenerator(ControlPointGroundObjectGenerator): def __init__( self, game: Game, generator_settings: GeneratorSettings, control_point: ControlPoint, templates: GroundObjectTemplates, ) -> None: super().__init__(game, generator_settings, control_point) self.templates = templates def generate(self) -> bool: if not super().generate(): return False self.generate_ground_points() return True def generate_ground_points(self) -> None: """Generate ground objects and AA sites for the control point.""" self.generate_armor_groups() self.generate_aa() self.generate_ewrs() self.generate_scenery_sites() self.generate_strike_targets() self.generate_offshore_strike_targets() self.generate_factories() self.generate_ammunition_depots() if self.faction.missiles: self.generate_missile_sites() if self.faction.coastal_defenses: self.generate_coastal_sites() def generate_armor_groups(self) -> None: for position in self.control_point.preset_locations.armor_groups: self.generate_armor_at(position) def generate_armor_at(self, position: PointWithHeading) -> None: group_id = self.game.next_group_id() g = VehicleGroupGroundObject( namegen.random_objective_name(), group_id, position, self.control_point, ) group = generate_armor_group(self.faction_name, self.game, g) if group is None: logging.error( "Could not generate armor group for %s at %s", g.name, self.control_point, ) return g.groups = [group] self.control_point.connected_objectives.append(g) def generate_aa(self) -> None: presets = self.control_point.preset_locations for position in presets.long_range_sams: self.generate_aa_at( position, ranges=[ {AirDefenseRange.Long}, {AirDefenseRange.Medium}, {AirDefenseRange.Short}, {AirDefenseRange.AAA}, ], ) for position in presets.medium_range_sams: self.generate_aa_at( position, ranges=[ {AirDefenseRange.Medium}, {AirDefenseRange.Short}, {AirDefenseRange.AAA}, ], ) for position in presets.short_range_sams: self.generate_aa_at( position, ranges=[{AirDefenseRange.Short}, {AirDefenseRange.AAA}], ) for position in presets.aaa: self.generate_aa_at( position, ranges=[{AirDefenseRange.AAA}], ) def generate_ewrs(self) -> None: presets = self.control_point.preset_locations for position in presets.ewrs: self.generate_ewr_at(position) def generate_strike_target_at(self, category: str, position: Point) -> None: obj_name = namegen.random_objective_name() template = random.choice(list(self.templates[category].values())) object_id = 0 group_id = self.game.next_group_id() # TODO: Create only one TGO per objective, each with multiple units. for unit in template: object_id += 1 template_point = Point(unit["offset"].x, unit["offset"].y) g = BuildingGroundObject( obj_name, category, group_id, object_id, position + template_point, unit["heading"], self.control_point, unit["type"], ) self.control_point.connected_objectives.append(g) def generate_ammunition_depots(self) -> None: for position in self.control_point.preset_locations.ammunition_depots: self.generate_strike_target_at(category="ammo", position=position) def generate_factories(self) -> None: for position in self.control_point.preset_locations.factories: self.generate_factory_at(position) def generate_factory_at(self, point: PointWithHeading) -> None: obj_name = namegen.random_objective_name() group_id = self.game.next_group_id() g = FactoryGroundObject( obj_name, group_id, point, point.heading, self.control_point, ) self.control_point.connected_objectives.append(g) def generate_aa_at( self, position: Point, ranges: Iterable[Set[AirDefenseRange]] ) -> None: group_id = self.game.next_group_id() g = SamGroundObject( namegen.random_objective_name(), group_id, position, self.control_point, ) groups = generate_anti_air_group(self.game, g, self.faction, ranges) if not groups: logging.error( "Could not generate air defense group for %s at %s", g.name, self.control_point, ) return g.groups = groups self.control_point.connected_objectives.append(g) def generate_ewr_at(self, position: PointWithHeading) -> None: group_id = self.game.next_group_id() g = EwrGroundObject( namegen.random_objective_name(), group_id, position, self.control_point, ) group = generate_ewr_group(self.game, g, self.faction) if group is None: logging.error( "Could not generate ewr group for %s at %s", g.name, self.control_point, ) return g.groups = [group] self.control_point.connected_objectives.append(g) def generate_scenery_sites(self) -> None: presets = self.control_point.preset_locations for scenery_group in presets.scenery: self.generate_tgo_for_scenery(scenery_group) def generate_tgo_for_scenery(self, scenery: SceneryGroup) -> None: obj_name = namegen.random_objective_name() category = scenery.category group_id = self.game.next_group_id() object_id = 0 # Each nested trigger zone is a target/building/unit for an objective. for zone in scenery.zones: object_id += 1 local_position = zone.position local_dcs_identifier = zone.name g = SceneryGroundObject( obj_name, category, group_id, object_id, local_position, self.control_point, local_dcs_identifier, zone, ) self.control_point.connected_objectives.append(g) return def generate_missile_sites(self) -> None: for position in self.control_point.preset_locations.missile_sites: self.generate_missile_site_at(position) def generate_missile_site_at(self, position: PointWithHeading) -> None: group_id = self.game.next_group_id() g = MissileSiteGroundObject( namegen.random_objective_name(), group_id, position, self.control_point ) group = generate_missile_group(self.game, g, self.faction_name) g.groups = [] if group is not None: g.groups.append(group) self.control_point.connected_objectives.append(g) return def generate_coastal_sites(self) -> None: for position in self.control_point.preset_locations.coastal_defenses: self.generate_coastal_site_at(position) def generate_coastal_site_at(self, position: PointWithHeading) -> None: group_id = self.game.next_group_id() g = CoastalSiteGroundObject( namegen.random_objective_name(), group_id, position, self.control_point, position.heading, ) group = generate_coastal_group(self.game, g, self.faction_name) g.groups = [] if group is not None: g.groups.append(group) self.control_point.connected_objectives.append(g) return def generate_strike_targets(self) -> None: building_set = list(set(self.faction.building_set) - {"oil"}) if not building_set: logging.error("Faction has no buildings defined") return for position in self.control_point.preset_locations.strike_locations: category = random.choice(building_set) self.generate_strike_target_at(category, position) def generate_offshore_strike_targets(self) -> None: if "oil" not in self.faction.building_set: logging.error("Faction does not support offshore strike targets") return for position in self.control_point.preset_locations.offshore_strike_locations: self.generate_strike_target_at("oil", position) class FobGroundObjectGenerator(AirbaseGroundObjectGenerator): def generate(self) -> bool: self.generate_fob() self.generate_armor_groups() self.generate_factories() self.generate_ammunition_depots() self.generate_aa() self.generate_ewrs() self.generate_scenery_sites() self.generate_strike_targets() self.generate_offshore_strike_targets() if self.faction.missiles: self.generate_missile_sites() if self.faction.coastal_defenses: self.generate_coastal_sites() return True def generate_fob(self) -> None: category = "fob" obj_name = self.control_point.name template = random.choice(list(self.templates[category].values())) point = self.control_point.position # Pick from preset locations object_id = 0 group_id = self.game.next_group_id() # TODO: Create only one TGO per objective, each with multiple units. for unit in template: object_id += 1 template_point = Point(unit["offset"].x, unit["offset"].y) g = BuildingGroundObject( obj_name, category, group_id, object_id, point + template_point, unit["heading"], self.control_point, unit["type"], is_fob_structure=True, ) self.control_point.connected_objectives.append(g) class GroundObjectGenerator: def __init__(self, game: Game, generator_settings: GeneratorSettings) -> None: self.game = game self.generator_settings = generator_settings with open("resources/groundobject_templates.p", "rb") as f: self.templates: GroundObjectTemplates = pickle.load(f) def generate(self) -> None: # Copied so we can remove items from the original list without breaking # the iterator. control_points = list(self.game.theater.controlpoints) for control_point in control_points: if not self.generate_for_control_point(control_point): self.game.theater.controlpoints.remove(control_point) def generate_for_control_point(self, control_point: ControlPoint) -> bool: generator: ControlPointGroundObjectGenerator if control_point.cptype == ControlPointType.AIRCRAFT_CARRIER_GROUP: generator = CarrierGroundObjectGenerator( self.game, self.generator_settings, control_point ) elif control_point.cptype == ControlPointType.LHA_GROUP: generator = LhaGroundObjectGenerator( self.game, self.generator_settings, control_point ) elif isinstance(control_point, OffMapSpawn): generator = NoOpGroundObjectGenerator( self.game, self.generator_settings, control_point ) elif isinstance(control_point, Fob): generator = FobGroundObjectGenerator( self.game, self.generator_settings, control_point, self.templates ) else: generator = AirbaseGroundObjectGenerator( self.game, self.generator_settings, control_point, self.templates ) return generator.generate()