Move theater into game.

game/game.py

@@ -1,5 +1,4 @@
 import logging
-import math
 import random
 import sys
 from datetime import date, datetime, timedelta
@@ -7,8 +6,7 @@ from typing import Dict, List
 
 from dcs.action import Coalition
 from dcs.mapping import Point
-from dcs.task import CAP, CAS, PinpointStrike, Task
-from dcs.unittype import UnitType
+from dcs.task import CAP, CAS, PinpointStrike
 from dcs.vehicles import AirDefence
 
 from game import db
@@ -21,8 +19,6 @@ from gen.conflictgen import Conflict
 from gen.flights.ai_flight_planner import CoalitionMissionPlanner
 from gen.flights.closestairfields import ObjectiveDistanceCache
 from gen.ground_forces.ai_ground_planner import GroundPlanner
-from theater import ConflictTheater, ControlPoint
-from theater.conflicttheater import IMPORTANCE_HIGH, IMPORTANCE_LOW
 from . import persistency
 from .debriefing import Debriefing
 from .event.event import Event, UnitsDeliveryEvent
@@ -30,6 +26,7 @@ from .event.frontlineattack import FrontlineAttackEvent
 from .factions.faction import Faction
 from .infos.information import Information
 from .settings import Settings
+from .theater import ConflictTheater, ControlPoint
 from .weather import Conditions, TimeOfDay
 
 COMMISION_UNIT_VARIETY = 4

game/theater/__init__.py

@@ -0,0 +1,5 @@
+from .base import *
+from .conflicttheater import *
+from .controlpoint import *
+from .missiontarget import MissionTarget
+from .theatergroundobject import SamGroundObject

game/theater/base.py

@@ -0,0 +1,192 @@
+import itertools
+import logging
+import math
+import typing
+from typing import Dict, Type
+
+from dcs.planes import PlaneType
+from dcs.task import CAP, CAS, Embarking, PinpointStrike, Task
+from dcs.unittype import UnitType, VehicleType
+from dcs.vehicles import AirDefence, Armor
+
+from game import db
+
+STRENGTH_AA_ASSEMBLE_MIN = 0.2
+PLANES_SCRAMBLE_MIN_BASE = 2
+PLANES_SCRAMBLE_MAX_BASE = 8
+PLANES_SCRAMBLE_FACTOR = 0.3
+
+BASE_MAX_STRENGTH = 1
+BASE_MIN_STRENGTH = 0
+
+
+class Base:
+    aircraft = {}  # type: typing.Dict[PlaneType, int]
+    armor = {}  # type: typing.Dict[VehicleType, int]
+    aa = {}  # type: typing.Dict[AirDefence, int]
+    strength = 1  # type: float
+
+    def __init__(self):
+        self.aircraft = {}
+        self.armor = {}
+        self.aa = {}
+        self.commision_points: Dict[Type, float] = {}
+        self.strength = 1
+
+    @property
+    def total_planes(self) -> int:
+        return sum(self.aircraft.values())
+
+    @property
+    def total_armor(self) -> int:
+        return sum(self.armor.values())
+
+    @property
+    def total_aa(self) -> int:
+        return sum(self.aa.values())
+
+    def total_units(self, task: Task) -> int:
+        return sum([c for t, c in itertools.chain(self.aircraft.items(), self.armor.items(), self.aa.items()) if t in db.UNIT_BY_TASK[task]])
+
+    def total_units_of_type(self, unit_type) -> int:
+        return sum([c for t, c in itertools.chain(self.aircraft.items(), self.armor.items(), self.aa.items()) if t == unit_type])
+
+    @property
+    def all_units(self):
+        return itertools.chain(self.aircraft.items(), self.armor.items(), self.aa.items())
+
+    def _find_best_unit(self, available_units: Dict[UnitType, int],
+                        for_type: Task, count: int) -> Dict[UnitType, int]:
+        if count <= 0:
+            logging.warning("{}: no units for {}".format(self, for_type))
+            return {}
+
+        sorted_units = [key for key in available_units if
+                        key in db.UNIT_BY_TASK[for_type]]
+        sorted_units.sort(key=lambda x: db.PRICES[x], reverse=True)
+
+        result: Dict[UnitType, int] = {}
+        for unit_type in sorted_units:
+            existing_count = available_units[unit_type]  # type: int
+            if not existing_count:
+                continue
+
+            if count <= 0:
+                break
+
+            result_unit_count = min(count, existing_count)
+            count -= result_unit_count
+
+            assert result_unit_count > 0
+            result[unit_type] = result.get(unit_type, 0) + result_unit_count
+
+        logging.info("{} for {} ({}): {}".format(self, for_type, count, result))
+        return result
+
+    def _find_best_planes(self, for_type: Task, count: int) -> typing.Dict[PlaneType, int]:
+        return self._find_best_unit(self.aircraft, for_type, count)
+
+    def _find_best_armor(self, for_type: Task, count: int) -> typing.Dict[Armor, int]:
+        return self._find_best_unit(self.armor, for_type, count)
+
+    def append_commision_points(self, for_type, points: float) -> int:
+        self.commision_points[for_type] = self.commision_points.get(for_type, 0) + points
+        points = self.commision_points[for_type]
+        if points >= 1:
+            self.commision_points[for_type] = points - math.floor(points)
+            return int(math.floor(points))
+
+        return 0
+
+    def filter_units(self, applicable_units: typing.Collection):
+        self.aircraft = {k: v for k, v in self.aircraft.items() if k in applicable_units}
+        self.armor = {k: v for k, v in self.armor.items() if k in applicable_units}
+
+    def commision_units(self, units: typing.Dict[typing.Any, int]):
+        for value in units.values():
+            assert value > 0
+            assert value == math.floor(value)
+
+        for unit_type, unit_count in units.items():
+            for_task = db.unit_task(unit_type)
+
+            target_dict = None
+            if for_task == CAS or for_task == CAP or for_task == Embarking:
+                target_dict = self.aircraft
+            elif for_task == PinpointStrike:
+                target_dict = self.armor
+            elif for_task == AirDefence:
+                target_dict = self.aa
+
+            assert target_dict is not None
+            target_dict[unit_type] = target_dict.get(unit_type, 0) + unit_count
+
+    def commit_losses(self, units_lost: typing.Dict[typing.Any, int]):
+
+        for unit_type, count in units_lost.items():
+
+            if unit_type in self.aircraft:
+                target_array = self.aircraft
+            elif unit_type in self.armor:
+                target_array = self.armor
+            else:
+                print("Base didn't find event type {}".format(unit_type))
+                continue
+
+            if unit_type not in target_array:
+                print("Base didn't find event type {}".format(unit_type))
+                continue
+                
+            target_array[unit_type] = max(target_array[unit_type] - count, 0)
+            if target_array[unit_type] == 0:
+                del target_array[unit_type]
+
+    def affect_strength(self, amount):
+        self.strength += amount
+        if self.strength > BASE_MAX_STRENGTH:
+            self.strength = BASE_MAX_STRENGTH
+        elif self.strength <= 0:
+            self.strength = BASE_MIN_STRENGTH
+
+    def set_strength_to_minimum(self) -> None:
+        self.strength = BASE_MIN_STRENGTH
+
+    def scramble_count(self, multiplier: float, task: Task = None) -> int:
+        if task:
+            count = sum([v for k, v in self.aircraft.items() if db.unit_task(k) == task])
+        else:
+            count = self.total_planes
+
+        count = int(math.ceil(count * PLANES_SCRAMBLE_FACTOR * self.strength))
+        return min(min(max(count, PLANES_SCRAMBLE_MIN_BASE), int(PLANES_SCRAMBLE_MAX_BASE * multiplier)), count)
+
+    def assemble_count(self):
+        return int(self.total_armor * 0.5)
+
+    def assemble_aa_count(self) -> int:
+        # previous logic removed because we always want the full air defense capabilities.
+        return self.total_aa
+
+    def scramble_sweep(self, multiplier: float) -> typing.Dict[PlaneType, int]:
+        return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
+
+    def scramble_last_defense(self):
+        # return as many CAP-capable aircraft as we can since this is the last defense of the base
+        # (but not more than 20 - that's just nuts)
+        return self._find_best_planes(CAP, min(self.total_planes, 20))
+
+    def scramble_cas(self, multiplier: float) -> typing.Dict[PlaneType, int]:
+        return self._find_best_planes(CAS, self.scramble_count(multiplier, CAS))
+
+    def scramble_interceptors(self, multiplier: float) -> typing.Dict[PlaneType, int]:
+        return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
+
+    def assemble_attack(self) -> typing.Dict[Armor, int]:
+        return self._find_best_armor(PinpointStrike, self.assemble_count())
+
+    def assemble_defense(self) -> typing.Dict[Armor, int]:
+        count = int(self.total_armor * min(self.strength + 0.5, 1))
+        return self._find_best_armor(PinpointStrike, count)
+
+    def assemble_aa(self, count=None) -> typing.Dict[AirDefence, int]:
+        return self._find_best_unit(self.aa, AirDefence, count and min(count, self.total_aa) or self.assemble_aa_count())

game/theater/conflicttheater.py

@@ -0,0 +1,515 @@
+from __future__ import annotations
+
+import logging
+import json
+from dataclasses import dataclass
+from itertools import tee
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+from dcs.mapping import Point
+from dcs.terrain import (
+    caucasus,
+    nevada,
+    normandy,
+    persiangulf,
+    syria,
+    thechannel,
+)
+from dcs.terrain.terrain import Terrain
+
+from gen.flights.flight import FlightType
+from .controlpoint import ControlPoint, MissionTarget
+from .landmap import Landmap, load_landmap, poly_contains
+
+Numeric = Union[int, float]
+
+SIZE_TINY = 150
+SIZE_SMALL = 600
+SIZE_REGULAR = 1000
+SIZE_BIG = 2000
+SIZE_LARGE = 3000
+
+IMPORTANCE_LOW = 1
+IMPORTANCE_MEDIUM = 1.2
+IMPORTANCE_HIGH = 1.4
+
+"""
+ALL_RADIALS = [0, 45, 90, 135, 180, 225, 270, 315, ]
+COAST_NS_E = [45, 90, 135, ]
+COAST_EW_N = [315, 0, 45, ]
+COAST_NSEW_E = [225, 270, 315, ]
+COAST_NSEW_W = [45, 90, 135, ]
+
+COAST_NS_W = [225, 270, 315, ]
+COAST_EW_S = [135, 180, 225, ]
+"""
+
+LAND = [0, 45, 90, 135, 180, 225, 270, 315, ]
+
+COAST_V_E = [0, 45, 90, 135, 180]
+COAST_V_W = [180, 225, 270, 315, 0]
+
+COAST_A_W = [315, 0, 45, 135, 180, 225, 270]
+COAST_A_E = [0, 45, 90, 135, 180, 225, 315]
+
+COAST_H_N = [270, 315, 0, 45, 90]
+COAST_H_S = [90, 135, 180, 225, 270]
+
+COAST_DL_E = [45, 90, 135, 180, 225]
+COAST_DL_W = [225, 270, 315, 0, 45]
+COAST_DR_E = [315, 0, 45, 90, 135]
+COAST_DR_W = [135, 180, 225, 315]
+
+FRONTLINE_MIN_CP_DISTANCE = 5000
+
+def pairwise(iterable):
+    """
+    itertools recipe
+    s -> (s0,s1), (s1,s2), (s2, s3), ...
+    """
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+class ConflictTheater:
+    terrain: Terrain
+
+    reference_points: Dict[Tuple[float, float], Tuple[float, float]]
+    overview_image: str
+    landmap: Optional[Landmap]
+    """
+    land_poly = None  # type: Polygon
+    """
+    daytime_map: Dict[str, Tuple[int, int]]
+    frontline_data: Optional[Dict[str, ComplexFrontLine]] = None
+
+    def __init__(self):
+        self.controlpoints: List[ControlPoint] = []
+        self.frontline_data = FrontLine.load_json_frontlines(self)
+        """
+        self.land_poly = geometry.Polygon(self.landmap[0][0])
+        for x in self.landmap[1]:
+            self.land_poly = self.land_poly.difference(geometry.Polygon(x))
+        """
+
+    def add_controlpoint(self, point: ControlPoint,
+                         connected_to: Optional[List[ControlPoint]] = None):
+        if connected_to is None:
+            connected_to = []
+        for connected_point in connected_to:
+            point.connect(to=connected_point)
+
+        self.controlpoints.append(point)
+
+    def find_ground_objects_by_obj_name(self, obj_name):
+        found = []
+        for cp in self.controlpoints:
+            for g in cp.ground_objects:
+                if g.obj_name == obj_name:
+                    found.append(g)
+        return found
+
+    def is_in_sea(self, point: Point) -> bool:
+        if not self.landmap:
+            return False
+
+        if self.is_on_land(point):
+            return False
+
+        for sea in self.landmap[2]:
+            if poly_contains(point.x, point.y, sea):
+                return True
+
+        return False
+
+    def is_on_land(self, point: Point) -> bool:
+        if not self.landmap:
+            return True
+
+        is_point_included = False
+        for inclusion_zone in self.landmap[0]:
+            if poly_contains(point.x, point.y, inclusion_zone):
+                is_point_included = True
+
+        if not is_point_included:
+            return False
+
+        for exclusion_zone in self.landmap[1]:
+            if poly_contains(point.x, point.y, exclusion_zone):
+                return False
+
+        return True
+
+    def player_points(self) -> List[ControlPoint]:
+        return [point for point in self.controlpoints if point.captured]
+
+    def conflicts(self, from_player=True) -> Iterator[FrontLine]:
+        for cp in [x for x in self.controlpoints if x.captured == from_player]:
+            for connected_point in [x for x in cp.connected_points if x.captured != from_player]:
+                yield FrontLine(cp, connected_point, self)
+
+    def enemy_points(self) -> List[ControlPoint]:
+        return [point for point in self.controlpoints if not point.captured]
+
+    def add_json_cp(self, theater, p: dict) -> ControlPoint:
+
+        if p["type"] == "airbase":
+
+            airbase = theater.terrain.airports[p["id"]].__class__
+
+            if "radials" in p.keys():
+                radials = p["radials"]
+            else:
+                radials = LAND
+
+            if "size" in p.keys():
+                size = p["size"]
+            else:
+                size = SIZE_REGULAR
+
+            if "importance" in p.keys():
+                importance = p["importance"]
+            else:
+                importance = IMPORTANCE_MEDIUM
+
+            cp = ControlPoint.from_airport(airbase, radials, size, importance)
+        elif p["type"] == "carrier":
+            cp = ControlPoint.carrier("carrier", Point(p["x"], p["y"]), p["id"])
+        else:
+            cp = ControlPoint.lha("lha", Point(p["x"], p["y"]), p["id"])
+
+        if "captured_invert" in p.keys():
+            cp.captured_invert = p["captured_invert"]
+        else:
+            cp.captured_invert = False
+
+        return cp
+        
+    @staticmethod
+    def from_json(data: Dict[str, Any]) -> ConflictTheater:
+        theaters = {
+            "Caucasus": CaucasusTheater,
+            "Nevada": NevadaTheater,
+            "Persian Gulf": PersianGulfTheater,
+            "Normandy": NormandyTheater,
+            "The Channel": TheChannelTheater,
+            "Syria": SyriaTheater,
+        }
+        theater = theaters[data["theater"]]
+        t = theater()
+        cps = {}
+        for p in data["player_points"]:
+            cp = t.add_json_cp(theater, p)
+            cp.captured = True
+            cps[p["id"]] = cp
+            t.add_controlpoint(cp)
+
+        for p in data["enemy_points"]:
+            cp = t.add_json_cp(theater, p)
+            cps[p["id"]] = cp
+            t.add_controlpoint(cp)
+
+        for l in data["links"]:
+            cps[l[0]].connect(cps[l[1]])
+            cps[l[1]].connect(cps[l[0]])
+
+        return t
+    
+
+class CaucasusTheater(ConflictTheater):
+    terrain = caucasus.Caucasus()
+    overview_image = "caumap.gif"
+    reference_points = {(-317948.32727306, 635639.37385346): (278.5 * 4, 319 * 4),
+                        (-355692.3067714, 617269.96285781): (263 * 4, 352 * 4), }
+
+    landmap = load_landmap("resources\\caulandmap.p")
+    daytime_map = {
+        "dawn": (6, 9),
+        "day": (9, 18),
+        "dusk": (18, 20),
+        "night": (0, 5),
+    }
+
+
+class PersianGulfTheater(ConflictTheater):
+    terrain = persiangulf.PersianGulf()
+    overview_image = "persiangulf.gif"
+    reference_points = {
+        (persiangulf.Shiraz_International_Airport.position.x, persiangulf.Shiraz_International_Airport.position.y): (
+        772, -1970),
+        (persiangulf.Liwa_Airbase.position.x, persiangulf.Liwa_Airbase.position.y): (1188, 78), }
+    landmap = load_landmap("resources\\gulflandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (8, 16),
+        "dusk": (16, 18),
+        "night": (0, 5),
+    }
+
+class NevadaTheater(ConflictTheater):
+    terrain = nevada.Nevada()
+    overview_image = "nevada.gif"
+    reference_points = {(nevada.Mina_Airport_3Q0.position.x, nevada.Mina_Airport_3Q0.position.y): (45 * 2, -360 * 2),
+                        (nevada.Laughlin_Airport.position.x, nevada.Laughlin_Airport.position.y): (440 * 2, 80 * 2), }
+    landmap = load_landmap("resources\\nevlandmap.p")
+    daytime_map = {
+        "dawn": (4, 6),
+        "day": (6, 17),
+        "dusk": (17, 18),
+        "night": (0, 5),
+    }
+
+class NormandyTheater(ConflictTheater):
+    terrain = normandy.Normandy()
+    overview_image = "normandy.gif"
+    reference_points = {(normandy.Needs_Oar_Point.position.x, normandy.Needs_Oar_Point.position.y): (-170, -1000),
+                        (normandy.Evreux.position.x, normandy.Evreux.position.y): (2020, 500)}
+    landmap = load_landmap("resources\\normandylandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (10, 17),
+        "dusk": (17, 18),
+        "night": (0, 5),
+    }
+
+class TheChannelTheater(ConflictTheater):
+    terrain = thechannel.TheChannel()
+    overview_image = "thechannel.gif"
+    reference_points = {(thechannel.Abbeville_Drucat.position.x, thechannel.Abbeville_Drucat.position.y): (2400, 4100),
+                        (thechannel.Detling.position.x, thechannel.Detling.position.y): (1100, 2000)}
+    landmap = load_landmap("resources\\channellandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (10, 17),
+        "dusk": (17, 18),
+        "night": (0, 5),
+    }
+
+class SyriaTheater(ConflictTheater):
+    terrain = syria.Syria()
+    overview_image = "syria.gif"
+    reference_points = {(syria.Eyn_Shemer.position.x, syria.Eyn_Shemer.position.y): (1300, 1380),
+                        (syria.Tabqa.position.x, syria.Tabqa.position.y): (2060, 570)}
+    landmap = load_landmap("resources\\syrialandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (8, 16),
+        "dusk": (16, 18),
+        "night": (0, 5),
+    }
+
+@dataclass
+class ComplexFrontLine:
+    """
+    Stores data necessary for building a multi-segment frontline.
+    "points" should be ordered from closest to farthest distance originating from start_cp.position
+    """
+
+    start_cp: ControlPoint
+    points: List[Point]
+
+
+@dataclass
+class FrontLineSegment:
+    """
+    Describes a line segment of a FrontLine
+    """
+
+    point_a: Point
+    point_b: Point
+
+    @property
+    def attack_heading(self) -> Numeric:
+        """The heading of the frontline segment from player to enemy control point"""
+        return self.point_a.heading_between_point(self.point_b)
+
+    @property
+    def attack_distance(self) -> Numeric:
+        """Length of the segment"""
+        return self.point_a.distance_to_point(self.point_b)
+
+
+class FrontLine(MissionTarget):
+    """Defines a front line location between two control points.
+    Front lines are the area where ground combat happens.
+    Overwrites the entirety of MissionTarget __init__ method to allow for
+    dynamic position calculation.
+    """
+
+    def __init__(
+        self,
+        control_point_a: ControlPoint,
+        control_point_b: ControlPoint,
+        theater: ConflictTheater
+    ) -> None:
+        self.control_point_a = control_point_a
+        self.control_point_b = control_point_b
+        self.segments: List[FrontLineSegment] = []
+        self.theater = theater
+        self._build_segments()
+        self.name = f"Front line {control_point_a}/{control_point_b}"
+
+    def is_friendly(self, to_player: bool) -> bool:
+        """Returns True if the objective is in friendly territory."""
+        return False
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        yield from [
+            FlightType.CAS,
+            # TODO: FlightType.TROOP_TRANSPORT
+            # TODO: FlightType.EVAC
+        ]
+        yield from super().mission_types(for_player)
+
+    @property
+    def position(self):
+        """
+        The position where the conflict should occur
+        according to the current strength of each control point.
+        """
+        return self.point_from_a(self._position_distance)
+
+    @property
+    def control_points(self) -> Tuple[ControlPoint, ControlPoint]:
+        """Returns a tuple of the two control points."""
+        return self.control_point_a, self.control_point_b
+
+    @property
+    def middle_point(self):
+        self.point_from_a(self.attack_distance / 2)
+
+    @property
+    def attack_distance(self):
+        """The total distance of all segments"""
+        return sum(i.attack_distance for i in self.segments)
+
+    @property
+    def attack_heading(self):
+        """The heading of the active attack segment from player to enemy control point"""
+        return self.active_segment.attack_heading
+
+    @property
+    def active_segment(self) -> FrontLineSegment:
+        """The FrontLine segment where there can be an active conflict"""
+        if self._position_distance <= self.segments[0].attack_distance:
+            return self.segments[0]
+
+        remaining_dist = self._position_distance
+        for segment in self.segments:
+            if remaining_dist <= segment.attack_distance:
+                return segment
+            else:
+                remaining_dist -= segment.attack_distance
+        logging.error(
+            "Frontline attack distance is greater than the sum of its segments"
+        )
+        return self.segments[0]
+
+    def point_from_a(self, distance: Numeric) -> Point:
+        """
+        Returns a point {distance} away from control_point_a along the frontline segments.
+        """
+        if distance < self.segments[0].attack_distance:
+            return self.control_point_a.position.point_from_heading(
+                self.segments[0].attack_heading, distance
+            )
+        remaining_dist = distance
+        for segment in self.segments:
+            if remaining_dist < segment.attack_distance:
+                return segment.point_a.point_from_heading(
+                    segment.attack_heading, remaining_dist
+                )
+            else:
+                remaining_dist -= segment.attack_distance
+
+    @property
+    def _position_distance(self) -> float:
+        """
+        The distance from point "a" where the conflict should occur
+        according to the current strength of each control point
+        """
+        total_strength = (
+            self.control_point_a.base.strength + self.control_point_b.base.strength
+        )
+        if self.control_point_a.base.strength == 0:
+            return self._adjust_for_min_dist(0)
+        if self.control_point_b.base.strength == 0:
+            return self._adjust_for_min_dist(self.attack_distance)
+        strength_pct = self.control_point_a.base.strength / total_strength
+        return self._adjust_for_min_dist(strength_pct * self.attack_distance)
+
+    def _adjust_for_min_dist(self, distance: Numeric) -> Numeric:
+        """
+        Ensures the frontline conflict is never located within the minimum distance
+        constant of either end control point.
+        """
+        if (distance > self.attack_distance / 2) and (
+            distance + FRONTLINE_MIN_CP_DISTANCE > self.attack_distance
+        ):
+            distance = self.attack_distance - FRONTLINE_MIN_CP_DISTANCE
+        elif (distance < self.attack_distance / 2) and (
+            distance < FRONTLINE_MIN_CP_DISTANCE
+        ):
+            distance = FRONTLINE_MIN_CP_DISTANCE
+        return distance
+
+    def _build_segments(self) -> None:
+        """Create line segments for the frontline"""
+        control_point_ids = "|".join(
+            [str(self.control_point_a.id), str(self.control_point_b.id)]
+        )  # from_cp.id|to_cp.id
+        reversed_cp_ids = "|".join(
+            [str(self.control_point_b.id), str(self.control_point_a.id)]
+        )
+        complex_frontlines = self.theater.frontline_data
+        if (complex_frontlines) and (
+            (control_point_ids in complex_frontlines)
+            or (reversed_cp_ids in complex_frontlines)
+        ):
+            # The frontline segments must be stored in the correct order for the distance algorithms to work.
+            # The points in the frontline are ordered from the id before the | to the id after.
+            # First, check if control point id pair matches in order, and create segments if a match is found.
+            if control_point_ids in complex_frontlines:
+                point_pairs = pairwise(complex_frontlines[control_point_ids].points)
+                for i in point_pairs:
+                    self.segments.append(FrontLineSegment(i[0], i[1]))
+            # Check the reverse order and build in reverse if found.
+            elif reversed_cp_ids in complex_frontlines:
+                point_pairs = pairwise(
+                    reversed(complex_frontlines[reversed_cp_ids].points)
+                )
+                for i in point_pairs:
+                    self.segments.append(FrontLineSegment(i[0], i[1]))
+        # If no complex frontline has been configured, fall back to the old straight line method.
+        else:
+            self.segments.append(
+                FrontLineSegment(
+                    self.control_point_a.position, self.control_point_b.position
+                )
+            )
+
+
+    @staticmethod
+    def load_json_frontlines(
+        theater: ConflictTheater
+    ) -> Optional[Dict[str, ComplexFrontLine]]:
+        """Load complex frontlines from json"""
+        try:
+            path = Path(f"resources/frontlines/{theater.terrain.name.lower()}.json")
+            with open(path, "r") as file:
+                logging.debug(f"Loading frontline from {path}...")
+                data = json.load(file)
+            return {
+                frontline: ComplexFrontLine(
+                    data[frontline]["start_cp"],
+                    [Point(i[0], i[1]) for i in data[frontline]["points"]],
+                )
+                for frontline in data
+            }
+        except OSError:
+            logging.warning(
+                f"Unable to load preset frontlines for {theater.terrain.name}"
+            )
+            return None

game/theater/controlpoint.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import itertools
+import re
+from enum import Enum
+from typing import Dict, Iterator, List, TYPE_CHECKING
+
+from dcs.mapping import Point
+from dcs.ships import (
+    CVN_74_John_C__Stennis,
+    CV_1143_5_Admiral_Kuznetsov,
+    LHA_1_Tarawa,
+    Type_071_Amphibious_Transport_Dock,
+)
+from dcs.terrain.terrain import Airport
+
+from game import db
+from gen.ground_forces.combat_stance import CombatStance
+from .base import Base
+from .missiontarget import MissionTarget
+from .theatergroundobject import (
+    BaseDefenseGroundObject,
+    TheaterGroundObject,
+)
+
+if TYPE_CHECKING:
+    from game import Game
+    from gen.flights.flight import FlightType
+
+
+class ControlPointType(Enum):
+    AIRBASE = 0                # An airbase with slots for everything
+    AIRCRAFT_CARRIER_GROUP = 1 # A group with a Stennis type carrier (F/A-18, F-14 compatible)
+    LHA_GROUP = 2              # A group with a Tarawa carrier (Helicopters & Harrier)
+    FARP = 4                   # A FARP, with slots for helicopters
+    FOB = 5                    # A FOB (ground units only)
+
+
+class ControlPoint(MissionTarget):
+
+    position = None  # type: Point
+    name = None  # type: str
+
+    captured = False
+    has_frontline = True
+    frontline_offset = 0.0
+
+    alt = 0
+
+    def __init__(self, id: int, name: str, position: Point,
+                 at: db.StartingPosition, radials: List[int], size: int,
+                 importance: float, has_frontline=True,
+                 cptype=ControlPointType.AIRBASE):
+        super().__init__(" ".join(re.split(r" |-", name)[:2]), position)
+        self.id = id
+        self.full_name = name
+        self.at = at
+        self.connected_objectives: List[TheaterGroundObject] = []
+        self.base_defenses: List[BaseDefenseGroundObject] = []
+
+        self.size = size
+        self.importance = importance
+        self.captured = False
+        self.captured_invert = False
+        self.has_frontline = has_frontline
+        self.radials = radials
+        self.connected_points: List[ControlPoint] = []
+        self.base: Base = Base()
+        self.cptype = cptype
+        self.stances: Dict[int, CombatStance] = {}
+        self.airport = None
+
+    @property
+    def ground_objects(self) -> List[TheaterGroundObject]:
+        return list(
+            itertools.chain(self.connected_objectives, self.base_defenses))
+
+    @classmethod
+    def from_airport(cls, airport: Airport, radials: List[int], size: int, importance: float, has_frontline=True):
+        assert airport
+        obj = cls(airport.id, airport.name, airport.position, airport, radials, size, importance, has_frontline, cptype=ControlPointType.AIRBASE)
+        obj.airport = airport()
+        return obj
+
+    @classmethod
+    def carrier(cls, name: str, at: Point, id: int):
+        import game.theater.conflicttheater
+        cp = cls(id, name, at, at, game.theater.conflicttheater.LAND, game.theater.conflicttheater.SIZE_SMALL, 1,
+                 has_frontline=False, cptype=ControlPointType.AIRCRAFT_CARRIER_GROUP)
+        return cp
+
+    @classmethod
+    def lha(cls, name: str, at: Point, id: int):
+        import game.theater.conflicttheater
+        cp = cls(id, name, at, at, game.theater.conflicttheater.LAND, game.theater.conflicttheater.SIZE_SMALL, 1,
+                 has_frontline=False, cptype=ControlPointType.LHA_GROUP)
+        return cp
+
+    @property
+    def heading(self):
+        if self.cptype == ControlPointType.AIRBASE:
+            return self.airport.runways[0].heading
+        elif self.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP]:
+            return 0 # TODO compute heading
+        else:
+            return 0
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def is_global(self):
+        return not self.connected_points
+
+    @property
+    def is_carrier(self):
+        """
+        :return: Whether this control point is an aircraft carrier
+        """
+        return self.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP]
+
+    @property
+    def is_fleet(self):
+        """
+        :return: Whether this control point is a boat (mobile)
+        """
+        return self.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP]
+
+    @property
+    def is_lha(self):
+        """
+        :return: Whether this control point is an LHA
+        """
+        return self.cptype in [ControlPointType.LHA_GROUP]
+
+    @property
+    def sea_radials(self) -> List[int]:
+        # TODO: fix imports
+        all_radials = [0, 45, 90, 135, 180, 225, 270, 315, ]
+        result = []
+        for r in all_radials:
+            if r not in self.radials:
+                result.append(r)
+        return result
+
+    @property
+    def available_aircraft_slots(self):
+        """
+        :return: The maximum number of aircraft that can be stored in this control point
+        """
+        if self.cptype == ControlPointType.AIRBASE:
+            return len(self.airport.parking_slots)
+        elif self.is_lha:
+            return 20
+        elif self.is_carrier:
+            return 90
+        else:
+            return 0
+
+    def connect(self, to):
+        self.connected_points.append(to)
+        self.stances[to.id] = CombatStance.DEFENSIVE
+
+    def has_runway(self):
+        """
+        Check whether this control point can have aircraft taking off or landing.
+        :return:
+        """
+        if self.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP] :
+            for g in self.ground_objects:
+                if g.dcs_identifier in ["CARRIER", "LHA"]:
+                    for group in g.groups:
+                        for u in group.units:
+                            if db.unit_type_from_name(u.type) in [CVN_74_John_C__Stennis, LHA_1_Tarawa, CV_1143_5_Admiral_Kuznetsov, Type_071_Amphibious_Transport_Dock]:
+                                return True
+            return False
+        elif self.cptype in [ControlPointType.AIRBASE, ControlPointType.FARP]:
+            return True
+        else:
+            return True
+
+    def get_carrier_group_name(self):
+        """
+        Get the carrier group name if the airbase is a carrier
+        :return: Carrier group name
+        """
+        if self.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP] :
+            for g in self.ground_objects:
+                if g.dcs_identifier == "CARRIER":
+                    for group in g.groups:
+                        for u in group.units:
+                            if db.unit_type_from_name(u.type) in [CVN_74_John_C__Stennis, CV_1143_5_Admiral_Kuznetsov]:
+                                return group.name
+                elif g.dcs_identifier == "LHA":
+                    for group in g.groups:
+                        for u in group.units:
+                            if db.unit_type_from_name(u.type) in [LHA_1_Tarawa]:
+                                return group.name
+        return None
+
+    def is_connected(self, to) -> bool:
+        return to in self.connected_points
+
+    def find_radial(self, heading: int, ignored_radial: int = None) -> int:
+        closest_radial = 0
+        closest_radial_delta = 360
+        for radial in [x for x in self.radials if x != ignored_radial]:
+            delta = abs(radial - heading)
+            if delta < closest_radial_delta:
+                closest_radial = radial
+                closest_radial_delta = delta
+
+        return closest_radial
+
+    def find_ground_objects_by_obj_name(self, obj_name):
+        found = []
+        for g in self.ground_objects:
+            if g.obj_name == obj_name:
+                found.append(g)
+        return found
+
+    def is_friendly(self, to_player: bool) -> bool:
+        return self.captured == to_player
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        if for_player:
+            self.captured = True
+        else:
+            self.captured = False
+
+        self.base.set_strength_to_minimum()
+
+        self.base.aircraft = {}
+        self.base.armor = {}
+
+        # Handle cyclic dependency.
+        from .start_generator import BaseDefenseGenerator
+        self.base_defenses = []
+        BaseDefenseGenerator(game, self).generate()
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        yield from super().mission_types(for_player)
+        if self.is_friendly(for_player):
+            if self.is_fleet:
+                yield from [
+                    # TODO: FlightType.INTERCEPTION
+                    # TODO: Buddy tanking for the A-4?
+                    # TODO: Rescue chopper?
+                    # TODO: Inter-ship logistics?
+                ]
+            else:
+                yield from [
+                    # TODO: FlightType.INTERCEPTION
+                    # TODO: FlightType.LOGISTICS
+                ]
+        else:
+            if self.is_fleet:
+                yield FlightType.ANTISHIP
+            else:
+                yield from [
+                    # TODO: FlightType.STRIKE
+                ]

game/theater/frontline.py

@@ -0,0 +1 @@
+"""Only here to keep compatibility for save games generated in version 2.2.0"""

game/theater/landmap.py

@@ -0,0 +1,41 @@
+import pickle
+from typing import Collection, Optional, Tuple
+import logging
+
+Zone = Collection[Tuple[float, float]]
+Landmap = Tuple[Collection[Zone], Collection[Zone], Collection[Zone]]
+
+
+def load_landmap(filename: str) -> Optional[Landmap]:
+    try:
+        with open(filename, "rb") as f:
+            return pickle.load(f)
+    except:
+        logging.exception(f"Failed to load landmap {filename}")
+        return None
+
+
+def poly_contains(x, y, poly):
+    n = len(poly)
+    inside = False
+    xints = 0.0
+    p1x, p1y = poly[0]
+    for i in range(n+1):
+        p2x, p2y = poly[i % n]
+        if y > min(p1y, p2y):
+            if y <= max(p1y, p2y):
+                if x <= max(p1x, p2x):
+                    if p1y != p2y:
+                        xints = (y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
+                    if p1x == p2x or x <= xints:
+                        inside = not inside
+        p1x, p1y = p2x, p2y
+    return inside
+
+def poly_centroid(poly) -> Tuple[float, float]:
+    x_list = [vertex[0] for vertex in poly]
+    y_list = [vertex[1] for vertex in poly]
+    x = sum(x_list) / len(poly)
+    y = sum(y_list) / len(poly)
+    return (x, y)
+

game/theater/missiontarget.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Iterator, TYPE_CHECKING
+
+from dcs.mapping import Point
+
+if TYPE_CHECKING:
+    from gen.flights.flight import FlightType
+
+
+class MissionTarget:
+    def __init__(self, name: str, position: Point) -> None:
+        """Initializes a mission target.
+
+        Args:
+            name: The name of the mission target.
+            position: The location of the mission target.
+        """
+        self.name = name
+        self.position = position
+
+    def distance_to(self, other: MissionTarget) -> int:
+        """Computes the distance to the given mission target."""
+        return self.position.distance_to_point(other.position)
+
+    def is_friendly(self, to_player: bool) -> bool:
+        """Returns True if the objective is in friendly territory."""
+        raise NotImplementedError
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+        if self.is_friendly(for_player):
+            yield FlightType.BARCAP
+        else:
+            yield from [
+                FlightType.ESCORT,
+                FlightType.TARCAP,
+                FlightType.SEAD,
+                FlightType.SWEEP,
+                # TODO: FlightType.ELINT,
+                # TODO: FlightType.EWAR,
+                # TODO: FlightType.RECON,
+            ]

game/theater/start_generator.py

@@ -0,0 +1,648 @@
+from __future__ import annotations
+
+import logging
+import math
+import pickle
+import random
+from typing import Any, Dict, List, Optional
+
+from dcs.mapping import Point
+from dcs.task import CAP, CAS, PinpointStrike
+from dcs.vehicles import AirDefence
+
+from game import Game, db
+from game.factions.faction import Faction
+from game.settings import Settings
+from game.version import VERSION
+from gen import namegen
+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.locations.preset_location_finder import PresetLocationFinder
+from gen.locations.preset_locations import PresetLocation
+from gen.missiles.missiles_group_generator import generate_missile_group
+from gen.sam.sam_group_generator import (
+    generate_anti_air_group,
+    generate_ewr_group, generate_shorad_group,
+)
+from theater import (
+    ConflictTheater,
+    ControlPoint,
+    ControlPointType,
+    TheaterGroundObject,
+)
+from game.theater.conflicttheater import IMPORTANCE_HIGH, IMPORTANCE_LOW
+from game.theater.theatergroundobject import (
+    EwrGroundObject,
+    SamGroundObject,
+    BuildingGroundObject,
+    CarrierGroundObject,
+    LhaGroundObject,
+    MissileSiteGroundObject,
+    ShipGroundObject,
+    VehicleGroupGroundObject,
+)
+
+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,
+}
+
+
+class GameGenerator:
+    def __init__(self, player: str, enemy: str, theater: ConflictTheater,
+                 settings: Settings, start_date, starting_budget: int,
+                 multiplier: float, midgame: bool) -> None:
+        self.player = player
+        self.enemy = enemy
+        self.theater = theater
+        self.settings = settings
+        self.start_date = start_date
+        self.starting_budget = starting_budget
+        self.multiplier = multiplier
+        self.midgame = midgame
+
+    def generate(self) -> Game:
+        # Reset name generator
+        namegen.reset()
+        self.prepare_theater()
+        self.populate_red_airbases()
+        game = Game(player_name=self.player,
+                    enemy_name=self.enemy,
+                    theater=self.theater,
+                    start_date=self.start_date,
+                    settings=self.settings)
+
+        GroundObjectGenerator(game).generate()
+        game.budget = self.starting_budget
+        game.settings.multiplier = self.multiplier
+        game.settings.sams = True
+        game.settings.version = VERSION
+        return game
+
+    def prepare_theater(self) -> None:
+        to_remove = []
+        # Auto-capture half the bases if midgame.
+        if self.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:
+            no_carrier = self.settings.do_not_generate_carrier
+            no_lha = self.settings.do_not_generate_lha
+            if cp.cptype is ControlPointType.AIRCRAFT_CARRIER_GROUP and \
+                    no_carrier:
+                to_remove.append(cp)
+            elif cp.cptype is ControlPointType.LHA_GROUP and no_lha:
+                to_remove.append(cp)
+
+            if self.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.midgame and self.settings.inverted:
+            for i, cp in enumerate(reversed(self.theater.controlpoints)):
+                if i > len(self.theater.controlpoints):
+                    break
+                else:
+                    cp.captured = True
+
+    def populate_red_airbases(self) -> None:
+        for control_point in self.theater.enemy_points():
+            if control_point.captured:
+                continue
+            self.populate_red_airbase(control_point)
+
+    def populate_red_airbase(self, control_point: ControlPoint) -> None:
+        # Force reset cp on generation
+        control_point.base.aircraft = {}
+        control_point.base.armor = {}
+        control_point.base.aa = {}
+        control_point.base.commision_points = {}
+        control_point.base.strength = 1
+
+        for task in [PinpointStrike, CAP, CAS, AirDefence]:
+            if IMPORTANCE_HIGH <= control_point.importance <= IMPORTANCE_LOW:
+                raise ValueError(
+                    f"CP importance must be between {IMPORTANCE_LOW} and "
+                    f"{IMPORTANCE_HIGH}, is {control_point.importance}")
+
+            importance_factor = ((control_point.importance - IMPORTANCE_LOW) /
+                                 (IMPORTANCE_HIGH - IMPORTANCE_LOW))
+            # noinspection PyTypeChecker
+            unit_types = db.choose_units(task, importance_factor, UNIT_VARIETY,
+                                         self.enemy)
+            if not unit_types:
+                continue
+
+            count_log = math.log(control_point.importance + 0.01,
+                                 UNIT_COUNT_IMPORTANCE_LOG)
+            count = max(
+                COUNT_BY_TASK[task] * self.multiplier * (1 + count_log), 1
+            )
+
+            count_per_type = max(int(float(count) / len(unit_types)), 1)
+            for unit_type in unit_types:
+                control_point.base.commision_units({unit_type: count_per_type})
+
+
+class ControlPointGroundObjectGenerator:
+    def __init__(self, game: Game, control_point: ControlPoint) -> None:
+        self.game = game
+        self.control_point = control_point
+        self.preset_locations = PresetLocationFinder.compute_possible_locations(game.theater.terrain.name, control_point.full_name)
+
+    @property
+    def faction_name(self) -> str:
+        if self.control_point.captured:
+            return self.game.player_name
+        else:
+            return self.game.enemy_name
+
+    @property
+    def faction(self) -> Faction:
+        return db.FACTIONS[self.faction_name]
+
+    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. This is not controlled by the control point definition, but
+            # rather by whether or not the generator can find a valid position
+            # for the ship.
+            self.generate_navy()
+
+        return True
+
+    def generate_navy(self) -> None:
+        skip_player_navy = self.game.settings.do_not_generate_player_navy
+        if self.control_point.captured and skip_player_navy:
+            return
+
+        skip_enemy_navy = self.game.settings.do_not_generate_enemy_navy
+        if not self.control_point.captured and skip_enemy_navy:
+            return
+
+        for _ in range(self.faction.navy_group_count):
+            self.generate_ship()
+
+    def generate_ship(self) -> None:
+        point = find_location(False, self.control_point.position,
+                              self.game.theater, 5000, 40000, [], False)
+        if point is None:
+            logging.error(
+                f"Could not find point for {self.control_point}'s navy")
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = ShipGroundObject(namegen.random_objective_name(), group_id, point,
+                             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)
+
+    def pick_preset_location(self, offshore=False) -> Optional[PresetLocation]:
+        """
+        Return a preset location if any is setup and still available for this point
+        @:param offshore Whether this should be an offshore location
+        @:return The preset location if found; None if it couldn't be found
+        """
+        if offshore:
+            if len(self.preset_locations.offshore_locations) > 0:
+                location = random.choice(self.preset_locations.offshore_locations)
+                self.preset_locations.offshore_locations.remove(location)
+                logging.info("Picked a preset offshore location")
+                return location
+        else:
+            if len(self.preset_locations.ashore_locations) > 0:
+                location = random.choice(self.preset_locations.ashore_locations)
+                self.preset_locations.ashore_locations.remove(location)
+                logging.info("Picked a preset ashore location")
+                return location
+        logging.info("No preset location found")
+        return None
+
+
+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 BaseDefenseGenerator:
+    def __init__(self, game: Game, control_point: ControlPoint) -> None:
+        self.game = game
+        self.control_point = control_point
+
+    @property
+    def faction_name(self) -> str:
+        if self.control_point.captured:
+            return self.game.player_name
+        else:
+            return self.game.enemy_name
+
+    @property
+    def faction(self) -> Faction:
+        return db.FACTIONS[self.faction_name]
+
+    def generate(self) -> None:
+        self.generate_ewr()
+        self.generate_garrison()
+        self.generate_base_defenses()
+
+    def generate_ewr(self) -> None:
+        position = self._find_location()
+        if position is None:
+            logging.error("Could not find position for "
+                          f"{self.control_point} EWR")
+            return
+
+        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_name)
+        if group is None:
+            return
+
+        g.groups = [group]
+        self.control_point.base_defenses.append(g)
+
+    def generate_base_defenses(self) -> None:
+        # First group has a 1/2 chance of being a SAM, 1/6 chance of SHORAD,
+        # and a 1/6 chance of a garrison.
+        #
+        # Further groups have a 1/3 chance of being SHORAD and 2/3 chance of
+        # being a garrison.
+        for i in range(random.randint(2, 5)):
+            if i == 0 and random.randint(0, 1) == 0:
+                self.generate_sam()
+            elif random.randint(0, 2) == 1:
+                self.generate_shorad()
+            else:
+                self.generate_garrison()
+
+    def generate_garrison(self) -> None:
+        position = self._find_location()
+        if position is None:
+            logging.error("Could not find position for "
+                          f"{self.control_point} garrison")
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = VehicleGroupGroundObject(namegen.random_objective_name(), group_id,
+                                     position, self.control_point,
+                                     for_airbase=True)
+
+        group = generate_armor_group(self.faction_name, self.game, g)
+        if group is not None:
+            g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+    def generate_sam(self) -> None:
+        position = self._find_location()
+        if position is None:
+            logging.error("Could not find position for "
+                          f"{self.control_point} SAM")
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = SamGroundObject(namegen.random_objective_name(), group_id,
+                            position, self.control_point, for_airbase=True)
+
+        group = generate_anti_air_group(self.game, g, self.faction_name)
+        if group is not None:
+            g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+    def generate_shorad(self) -> None:
+        position = self._find_location()
+        if position is None:
+            logging.error("Could not find position for "
+                          f"{self.control_point} SHORAD")
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = SamGroundObject(namegen.random_objective_name(), group_id,
+                            position, self.control_point, for_airbase=True)
+
+        group = generate_shorad_group(self.game, g, self.faction_name)
+        if group is not None:
+            g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+    def _find_location(self) -> Optional[Point]:
+        position = find_location(True, self.control_point.position,
+                                 self.game.theater, 400, 3200, [], True)
+
+        # Retry once, searching a bit further (On some big airbase, 3200 is too short (Ex : Incirlik))
+        # But searching farther on every base would be problematic, as some base defense units
+        # would end up very far away from small airfields.
+        # (I know it's not good for performance, but this is only done on campaign generation)
+        # TODO : Make the whole process less stupid with preset possible positions for each airbase
+        if position is None:
+            position = find_location(True, self.control_point.position,
+                                     self.game.theater, 3200, 4800, [], True)
+        return position
+
+
+class AirbaseGroundObjectGenerator(ControlPointGroundObjectGenerator):
+    def __init__(self, game: Game, control_point: ControlPoint,
+                 templates: GroundObjectTemplates) -> None:
+        super().__init__(game, control_point)
+        self.templates = templates
+
+    def generate(self) -> bool:
+        if not super().generate():
+            return False
+
+        BaseDefenseGenerator(self.game, self.control_point).generate()
+        self.generate_ground_points()
+
+        if self.faction.missiles:
+            self.generate_missile_sites()
+
+        return True
+
+    def generate_ground_points(self) -> None:
+        """Generate ground objects and AA sites for the control point."""
+        if self.control_point.is_global:
+            return
+
+        # Always generate at least one AA point.
+        self.generate_aa_site()
+
+        # And between 2 and 7 other objectives.
+        amount = random.randrange(2, 7)
+        for i in range(amount):
+            # 1 in 4 additional objectives are AA.
+            if random.randint(0, 3) == 0:
+                self.generate_aa_site()
+            else:
+                self.generate_ground_point()
+
+    def generate_ground_point(self) -> None:
+        try:
+            category = random.choice(self.faction.building_set)
+        except IndexError:
+            logging.exception("Faction has no buildings defined")
+            return
+
+        obj_name = namegen.random_objective_name()
+        template = random.choice(list(self.templates[category].values()))
+
+        offshore = category == "oil"
+
+        # Pick from preset locations
+        location = self.pick_preset_location(offshore)
+
+        # Else try the old algorithm
+        if location is None:
+            point = find_location(not offshore,
+                                  self.control_point.position,
+                                  self.game.theater, 10000, 40000,
+                                  self.control_point.ground_objects)
+        else:
+            point = location.position
+
+        if point is None:
+            logging.error(
+                f"Could not find point for {obj_name} at {self.control_point}")
+            return
+
+        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"])
+
+            self.control_point.connected_objectives.append(g)
+
+    def generate_aa_site(self) -> None:
+        obj_name = namegen.random_objective_name()
+
+        # Pick from preset locations
+        location = self.pick_preset_location(False)
+
+        # If no preset location, then try the old algorithm
+        if location is None:
+            position = find_location(True, self.control_point.position,
+                                 self.game.theater, 10000, 40000,
+                                 self.control_point.ground_objects)
+        else:
+            position = location.position
+
+        if position is None:
+            logging.error(
+                f"Could not find point for {obj_name} at {self.control_point}")
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = SamGroundObject(namegen.random_objective_name(), group_id,
+                            position, self.control_point, for_airbase=False)
+        group = generate_anti_air_group(self.game, g, self.faction_name)
+        if group is not None:
+            g.groups = [group]
+        self.control_point.connected_objectives.append(g)
+
+    def generate_missile_sites(self) -> None:
+        for i in range(self.faction.missiles_group_count):
+            self.generate_missile_site()
+
+    def generate_missile_site(self) -> None:
+
+        # Pick from preset locations
+        location = self.pick_preset_location(False)
+
+        # If no preset location, then try the old algorithm
+        if location is None:
+            position = find_location(True, self.control_point.position,
+                                     self.game.theater, 2500, 40000,
+                                     [], False)
+        else:
+            position = location.position
+
+
+        if position is None:
+            logging.info(
+                f"Could not find point for {self.control_point} missile site")
+            return
+
+        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
+
+
+class GroundObjectGenerator:
+    def __init__(self, game: Game) -> None:
+        self.game = game
+        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, control_point)
+        elif control_point.cptype == ControlPointType.LHA_GROUP:
+            generator = LhaGroundObjectGenerator(self.game, control_point)
+        else:
+            generator = AirbaseGroundObjectGenerator(self.game, control_point,
+                                                     self.templates)
+        return generator.generate()
+
+
+# TODO: https://stackoverflow.com/a/19482012/632035
+# A lot of the time spent on mission generation is spent in this function since
+# just randomly guess up to 1800 times and often fail. This is particularly
+# problematic while trying to find placement for navies in Nevada.
+def find_location(on_ground: bool, near: Point, theater: ConflictTheater,
+                  min_range: int, max_range: int,
+                  others: List[TheaterGroundObject],
+                  is_base_defense: bool = False) -> Optional[Point]:
+    """
+    Find a valid ground object location
+    :param on_ground: Whether it should be on ground or on sea (True = on
+    ground)
+    :param near: Point
+    :param theater: Theater object
+    :param min_range: Minimal range from point
+    :param max_range: Max range from point
+    :param others: Other already existing ground objects
+    :param is_base_defense: True if the location is for base defense.
+    :return:
+    """
+    point = None
+    for _ in range(300):
+
+        # Check if on land or sea
+        p = near.random_point_within(max_range, min_range)
+        if on_ground and theater.is_on_land(p):
+            point = p
+        elif not on_ground and theater.is_in_sea(p):
+            point = p
+
+        if point:
+            for angle in range(0, 360, 45):
+                p = point.point_from_heading(angle, 2500)
+                if on_ground and not theater.is_on_land(p):
+                    point = None
+                    break
+                elif not on_ground and not theater.is_in_sea(p):
+                    point = None
+                    break
+        if point:
+            for other in others:
+                if other.position.distance_to_point(point) < 10000:
+                    point = None
+                    break
+
+        if point:
+            for control_point in theater.controlpoints:
+                if is_base_defense:
+                    break
+                if control_point.position != near:
+                    if point is None:
+                        break
+                    if control_point.position.distance_to_point(point) < 30000:
+                        point = None
+                        break
+                    for ground_obj in control_point.ground_objects:
+                        if ground_obj.position.distance_to_point(point) < 10000:
+                            point = None
+                            break
+
+        if point:
+            return point
+    return None

game/theater/theatergroundobject.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import itertools
+from typing import Iterator, List, TYPE_CHECKING
+
+from dcs.mapping import Point
+from dcs.unit import Unit
+from dcs.unitgroup import Group
+
+if TYPE_CHECKING:
+    from .controlpoint import ControlPoint
+    from gen.flights.flight import FlightType
+
+from .missiontarget import MissionTarget
+
+NAME_BY_CATEGORY = {
+    "power": "Power plant",
+    "ammo": "Ammo depot",
+    "fuel": "Fuel depot",
+    "aa": "AA Defense Site",
+    "ware": "Warehouse",
+    "farp": "FARP",
+    "fob": "FOB",
+    "factory": "Factory",
+    "comms": "Comms. tower",
+    "oil": "Oil platform",
+    "derrick": "Derrick",
+    "ww2bunker": "Bunker",
+    "village": "Village",
+    "allycamp": "Camp",
+    "EWR":"EWR",
+}
+
+ABBREV_NAME = {
+    "power": "PLANT",
+    "ammo": "AMMO",
+    "fuel": "FUEL",
+    "aa": "AA",
+    "ware": "WARE",
+    "farp": "FARP",
+    "fob": "FOB",
+    "factory": "FACTORY",
+    "comms": "COMMST",
+    "oil": "OILP",
+    "derrick": "DERK",
+    "ww2bunker": "BUNK",
+    "village": "VLG",
+    "allycamp": "CMP",
+}
+
+CATEGORY_MAP = {
+
+    # Special cases
+    "CARRIER": ["CARRIER"],
+    "LHA": ["LHA"],
+    "aa": ["AA"],
+
+    # Buildings
+    "power": ["Workshop A", "Electric power box", "Garage small A", "Farm B", "Repair workshop", "Garage B"],
+    "ware": ["Warehouse", "Hangar A"],
+    "fuel": ["Tank", "Tank 2", "Tank 3", "Fuel tank"],
+    "ammo": [".Ammunition depot", "Hangar B"],
+    "farp": ["FARP Tent", "FARP Ammo Dump Coating", "FARP Fuel Depot", "FARP Command Post", "FARP CP Blindage"],
+    "fob": ["Bunker 2", "Bunker 1", "Garage small B", ".Command Center", "Barracks 2"],
+    "factory": ["Tech combine", "Tech hangar A"],
+    "comms": ["TV tower", "Comms tower M"],
+    "oil": ["Oil platform"],
+    "derrick": ["Oil derrick", "Pump station", "Subsidiary structure 2"],
+    "ww2bunker": ["Siegfried Line", "Fire Control Bunker", "SK_C_28_naval_gun", "Concertina Wire", "Czech hedgehogs 1"],
+    "village": ["Small house 1B", "Small House 1A", "Small warehouse 1"],
+    "allycamp": [],
+}
+
+
+class TheaterGroundObject(MissionTarget):
+
+    def __init__(self, name: str, category: str, group_id: int, position: Point,
+                 heading: int, control_point: ControlPoint, dcs_identifier: str,
+                 airbase_group: bool, sea_object: bool) -> None:
+        super().__init__(name, position)
+        self.category = category
+        self.group_id = group_id
+        self.heading = heading
+        self.control_point = control_point
+        self.dcs_identifier = dcs_identifier
+        self.airbase_group = airbase_group
+        self.sea_object = sea_object
+        self.is_dead = False
+        # TODO: There is never more than one group.
+        self.groups: List[Group] = []
+
+    @property
+    def units(self) -> List[Unit]:
+        """
+        :return: all the units at this location
+        """
+        return list(itertools.chain.from_iterable([g.units for g in self.groups]))
+
+    @property
+    def group_name(self) -> str:
+        """The name of the unit group."""
+        return f"{self.category}|{self.group_id}"
+
+    def __str__(self) -> str:
+        return NAME_BY_CATEGORY[self.category]
+
+    def is_same_group(self, identifier: str) -> bool:
+        return self.group_id == identifier
+
+    @property
+    def obj_name(self) -> str:
+        return self.name
+
+    @property
+    def faction_color(self) -> str:
+        return "BLUE" if self.control_point.captured else "RED"
+
+    def is_friendly(self, to_player: bool) -> bool:
+        return self.control_point.is_friendly(to_player)
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+        if self.is_friendly(for_player):
+            yield from [
+                # TODO: FlightType.LOGISTICS
+                # TODO: FlightType.TROOP_TRANSPORT
+            ]
+        else:
+            yield from [
+                FlightType.STRIKE,
+                FlightType.BAI,
+            ]
+        yield from super().mission_types(for_player)
+
+
+class BuildingGroundObject(TheaterGroundObject):
+    def __init__(self, name: str, category: str, group_id: int, object_id: int,
+                 position: Point, heading: int, control_point: ControlPoint,
+                 dcs_identifier: str) -> None:
+        super().__init__(
+            name=name,
+            category=category,
+            group_id=group_id,
+            position=position,
+            heading=heading,
+            control_point=control_point,
+            dcs_identifier=dcs_identifier,
+            airbase_group=False,
+            sea_object=False
+        )
+        self.object_id = object_id
+
+    @property
+    def group_name(self) -> str:
+        """The name of the unit group."""
+        return f"{self.category}|{self.group_id}|{self.object_id}"
+
+
+class NavalGroundObject(TheaterGroundObject):
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+        if not self.is_friendly(for_player):
+            yield FlightType.ANTISHIP
+        yield from super().mission_types(for_player)
+
+
+class GenericCarrierGroundObject(NavalGroundObject):
+    pass
+
+
+# TODO: Why is this both a CP and a TGO?
+class CarrierGroundObject(GenericCarrierGroundObject):
+    def __init__(self, name: str, group_id: int,
+                 control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="CARRIER",
+            group_id=group_id,
+            position=control_point.position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="CARRIER",
+            airbase_group=True,
+            sea_object=True
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them,
+        # add to EWR.
+        return f"{self.faction_color}|EWR|{super().group_name}"
+
+
+# TODO: Why is this both a CP and a TGO?
+class LhaGroundObject(GenericCarrierGroundObject):
+    def __init__(self, name: str, group_id: int,
+                 control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="LHA",
+            group_id=group_id,
+            position=control_point.position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="LHA",
+            airbase_group=True,
+            sea_object=True
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them,
+        # add to EWR.
+        return f"{self.faction_color}|EWR|{super().group_name}"
+
+
+class MissileSiteGroundObject(TheaterGroundObject):
+    def __init__(self, name: str, group_id: int, position: Point,
+                 control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=False,
+            sea_object=False
+        )
+
+
+class BaseDefenseGroundObject(TheaterGroundObject):
+    """Base type for all base defenses."""
+
+
+# TODO: Differentiate types.
+# This type gets used both for AA sites (SAM, AAA, or SHORAD) but also for the
+# armor garrisons at airbases. These should each be split into their own types.
+class SamGroundObject(BaseDefenseGroundObject):
+    def __init__(self, name: str, group_id: int, position: Point,
+                 control_point: ControlPoint, for_airbase: bool) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=for_airbase,
+            sea_object=False
+        )
+        # Set by the SAM unit generator if the generated group is compatible
+        # with Skynet.
+        self.skynet_capable = False
+
+    @property
+    def group_name(self) -> str:
+        if self.skynet_capable:
+            # Prefix the group names of SAM sites with the side color so Skynet
+            # can find them.
+            return f"{self.faction_color}|SAM|{self.group_id}"
+        else:
+            return super().group_name
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+        if not self.is_friendly(for_player):
+            yield FlightType.DEAD
+        yield from super().mission_types(for_player)
+
+
+class VehicleGroupGroundObject(BaseDefenseGroundObject):
+    def __init__(self, name: str, group_id: int, position: Point,
+                 control_point: ControlPoint, for_airbase: bool) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=for_airbase,
+            sea_object=False
+        )
+
+
+class EwrGroundObject(BaseDefenseGroundObject):
+    def __init__(self, name: str, group_id: int, position: Point,
+                 control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="EWR",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="EWR",
+            airbase_group=True,
+            sea_object=False
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them.
+        return f"{self.faction_color}|{super().group_name}"
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+        if not self.is_friendly(for_player):
+            yield FlightType.DEAD
+        yield from super().mission_types(for_player)
+
+
+class ShipGroundObject(NavalGroundObject):
+    def __init__(self, name: str, group_id: int, position: Point,
+                 control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=False,
+            sea_object=True
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them,
+        # add to EWR.
+        return f"{self.faction_color}|EWR|{super().group_name}"