Move more SAMs off runways in Syria Full.

(cherry picked from commit e5bca224e9)

.github/workflows/build.yml

@@ -18,15 +18,29 @@ jobs:
 
     - name: Install environment
       run: |
-        py -m venv ./venv
+        python -m venv ./venv
 
     - name: Install dependencies
       run: |
         ./venv/scripts/activate
-        pip install -r requirements.txt
+        python -m pip install -r requirements.txt
         # For some reason the shiboken2.abi3.dll is not found properly, so I copy it instead
         Copy-Item .\venv\Lib\site-packages\shiboken2\shiboken2.abi3.dll .\venv\Lib\site-packages\PySide2\ -Force
 
+    - name: mypy game
+      run: |
+        ./venv/scripts/activate
+        mypy game
+
+    - name: mypy gen
+      run: |
+        ./venv/scripts/activate
+        mypy gen
+      
+    - name: update build number
+      run: |
+        [IO.File]::WriteAllLines($pwd.path + "\resources\buildnumber", $env:GITHUB_RUN_NUMBER)
+
     - name: Build binaries
       run: |
         ./venv/scripts/activate

.github/workflows/release.yml

@@ -20,15 +20,29 @@ jobs:
 
     - name: Install environment
       run: |
-        py -m venv ./venv
+        python -m venv ./venv
 
     - name: Install dependencies
       run: |
         ./venv/scripts/activate
-        pip install -r requirements.txt
+        python -m pip install -r requirements.txt
         # For some reason the shiboken2.abi3.dll is not found properly, so I copy it instead
         Copy-Item .\venv\Lib\site-packages\shiboken2\shiboken2.abi3.dll .\venv\Lib\site-packages\PySide2\ -Force
 
+    - name: Finalize version
+      run: |
+        New-Item -ItemType file resources\final
+
+    - name: mypy game
+      run: |
+        ./venv/scripts/activate
+        mypy game
+
+    - name: mypy gen
+      run: |
+        ./venv/scripts/activate
+        mypy gen
+
     - name: Build binaries
       run: |
         ./venv/scripts/activate
@@ -39,11 +53,6 @@ jobs:
       env:
         TAG_NAME: ${{ github.ref }}
       run: |
-        $version = ($env:TAG_NAME -split "/") | Select-Object -Last 1
-        (Get-Content .\installer\dcs_liberation.iss) -replace "{{version}}",$version | Out-File .\build\installer.iss
-        cd .\installer
-        iscc.exe ..\build\installer.iss
-        cd ..
         Copy-Item .\changelog.md .\dist
 
     - uses: actions/upload-artifact@v2
@@ -86,15 +95,7 @@ jobs:
         body_path: releasenotes.md
         draft: false
         prerelease: ${{ steps.version.outputs.prerelease }}
-    
-    - uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./dcs_liberation.exe
-        asset_name: dcs_liberation.${{ steps.version.outputs.number }}.exe
-        asset_content_type: application/exe
+
 
     - uses: actions/upload-release-asset@v1
       env:

.gitignore

@@ -8,7 +8,6 @@ logs.txt
 dist/**
 a.py
 resources/tools/a.miz
-tests/**
 # User-specific stuff
 .idea/
 
@@ -16,9 +15,8 @@ tests/**
 /liberation_preferences.json
 /state.json
 
-logs/liberation.log
+logs/
 
 qt_ui/logs/liberation.log
 
 *.psd
-resources/scripts/plugins/*

.vscode/settings.json

@@ -1,4 +0,0 @@
-{
-  "python.pythonPath": "g:\\python\\dcs_liberation\\venv\\Scripts\\python.exe",
-  "vsintellicode.python.completionsEnabled": true
-}

README.md

@@ -12,10 +12,10 @@
 ![GitHub stars](https://img.shields.io/github/stars/khopa/dcs_liberation?style=social)
 
 ## About DCS Liberation
-DCS Liberation is a [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) turn based single-player semi dynamic campaign. 
+DCS Liberation is a [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) turn based single-player or co-op dynamic campaign. 
 It is an external program that generates full and complex DCS missions and manage a persistent combat environment.  
 
-![Logo](https://imgur.com/B6tvlBJ.png)
+![Logo](https://i.imgur.com/4hq0rLq.png)
 
 ## Downloads
 
@@ -31,6 +31,10 @@ First, a big thanks to shdwp, for starting the original DCS Liberation project.
 
 Then, DCS Liberation uses [pydcs](http://github.com/pydcs/dcs) for mission generation, and nothing would be possible without this.
 It also uses the popular [Mist](https://github.com/mrSkortch/MissionScriptingTools) lua framework for mission scripting.
-And for the JTAC feature, DCS Liberation embed Ciribob's JTAC Autolase [script](https://github.com/ciribob/DCS-JTACAutoLaze).
+
+Excellent lua scripts DCS Liberation uses as plugins:
+
+* For the JTAC feature, DCS Liberation embeds Ciribob's JTAC Autolase [script](https://github.com/ciribob/DCS-JTACAutoLaze).
+* Walder's [Skynet-IADS](https://github.com/walder/Skynet-IADS) is used for Integrated Air Defense System.
 
 Please also show some support to these projects ! 

changelog.md

@@ -1,9 +1,140 @@
+# 2.3.2
+
+## Features/Improvements
+* **[Units]** Support for newly added BTR-82A, T-72B3
+* **[Units]** Added ZSU-57 AAA sites
+* **[Culling]** BARCAP missions no longer create culling exclusion zones.
+* **[Flight Planner]** Improved TOT planning. Negative start times no longer occur with TARCAPs and hold times no longer affect planning for flight plans without hold points.
+* **[Factions]** Added Iraq 1991 faction (thanks again to Hawkmoon!)
+
+## Fixes:
+* **[Mission Generator]** Fix mission generation error when there are too many radio frequency to setup for the Mig-21
+* **[Mission Generator]** Fix ground units not moving forward
+* **[Mission Generator]** Fixed assigned radio channels overlapping with beacons.
+* **[Flight Planner]** Fix creation of custom waypoints.
+* **[Campaigns]** Fixed many cases of SAMs spawning on the runways/taxiways in Syria Full.
+
+# 2.3.1
+
+## Features/Improvements
+* **[UX]** Added a warning message when the player is attempting to buy more planes at an already full airbase. 
+* **[Campaigns]** Migrated Syria full map to new format. (Thanks to Hawkmoon)
+* **[Faction]** Added NATO desert Storm faction (Thanks to Hawkmoon)
+
+## Fixes:
+* **[AI]** CAP flights will engage enemies again.
+* **[Campaigns]** Fixed a missing path on the Caucasus Full Map campaign
+
+# 2.3.0
+
+## Features/Improvements
+* **[Campaign Map]** Overhauled the campaign model
+* **[Campaign Map]** Possible to add FOB as control points
+* **[Campaign Map]** Added off-map spawn locations
+* **[Campaign AI]** Overhauled AI recruiting behaviour
+* **[Campaign AI]** Added AI procurement for Blue
+* **[Campaign]** New Campaign: "Black Sea"
+* **[Mission Planner]** Possible to move carrier and tarawa on the campaign map
+* **[Mission Generator]** Infantry squads on frontline can have manpads
+* **[Mission Generator]** Unused aircraft now spawned to allow for OCA strikes
+* **[Mission Generator]** Opfor now obeys parking limits
+* **[Mission Generator]** Support for Anubis C-130 Hercules mod
+* **[Flight Planner]** Added fighter sweep missions.
+* **[Flight Planner]** Added BAI missions.
+* **[Flight Planner]** Added anti-ship missions.
+* **[Flight Planner]** Differentiated BARCAP and TARCAP. TARCAP is now for hostile areas and will arrive before the package.
+* **[Flight Planner]** Added OCA missions
+* **[Flight Planner]** Added Alternate/divert airfields
+* **[Culling]** Added possibility to include/exclude carriers from culling zones
+* **[QOL]** On liberation startup, your latest save game is loaded automatically
+* **[Units]** Reduced starting fuel load for C101
+* **[UI]** Inform the user of the weather
+* **[UI]** Added toolbar buttons to change map display settings
+* **[Game]** Added new Economy options for adjusting income multipliers and starting budgets.
+
+## Fixes :
+* **[Map]** Missiles sites now have a proper icon and will not re-use the SAM sites icon
+* **[Mission Generator]** Ground unit waypoints improperly set to "On Road" - fixed
+* **[Mission Generator]** Target waypoints not at ground level - fixed
+* **[Mission Generator]** Selected skill not applied to Helicopters - fixed
+* **[Mission Generator]** Ground units do not always spawn - fixed
+* **[Kneeboard]** Briefing waypoints off by one - fixed
+* **[Game]** Destroyed buildings still granting budget - fixed
+
+# 2.2.1
+
+## Features/Improvements
+* **[Factions]** Added factions : Georgia 2008, USN 1985, France 2005 Frenchpack by HerrTom
+* **[Factions]** Added map Persian Gulf full by Plob
+* **[Flight Planner]** Player flights with start delays under ten minutes will spawn immediately.
+* **[UI]** Mission start screen now informs players about delayed flights.
+* **[Units]** Added support for F-14A-135-GR
+* **[Modding]** Possible to setup liveries overrides in factions definition files
+
+## Fixes :
+* **[Flight Planner]** Hold, join, and split points are planned cautiously near enemy airfields. Ascend/descend points are no longer planned.
+* **[Flight Planner]** Custom waypoints are usable again. Not that in most cases custom flight plans will revert to the 2.1 flight planning behavior.
+* **[Flight Planner]** Fixed UI bug that made it possible to create empty flights which would throw an error.
+* **[Flight Planner]** Player flights from carriers will now be delayed correctly according to the player's settings.
+* **[Misc]** Spitfire variant with clipped wings was not seen as flyable by DCS Liberation (hence could not be setup as client/player slot)
+* **[Misc]** Updated Syria terrain parking slots database, the out-of-date database could end up generating aircraft in wrong slots (We are still experiencing issues with somes airbases, such as Khalkhalah though)
+
+# 2.2.0
+
+## Features/Improvements :
+* **[Campaign Generator]** Added early warning radar generation
+* **[Campaign Generator]** Added scud launcher sites
+* **[Cheat Menu]** Added ability to capture base from mission planner
+* **[Cheat Menu]** Added ability to show red ATO
+* **[Factions]** Added WW2 factions that do not depend on WW2 asset pack
+* **[Factions]** Cold War / Middle eastern factions will use Flak sites
+* **[Flight Planner]** Flight planner overhaul, with package and TOT system
+* **[Flight Planner]** Pick runways and ascent/descent based on headwind
+* **[Map]** Added polygon debug mode display
+* **[Map]** Highlight the selected flight path on the map
+* **[Map]** Improved SAM display settings
+* **[Map]** Improved flight plan display settings
+* **[Map]** Caucasus and The Channel map use a new system to generate SAM and strike target location to reduce probability of targets generated in the middle of a forests
+* **[Misc]** Flexible Dedicated Hosting Options for Mission Files via environment variables
+* **[Moddability]** Custom campaigns can be designed through json files
+* **[Moddability]** LUA plugins can now be injected into Liberation missions.
+* **[Moddability]** Optional Skynet IADS lua plugin now included
+* **[New Game]** Starting budget can be freely selected
+* **[New Game]** Exanded information for faction and campaign selection in the new game wizard
+* **[UI]** Add double and right click actions to many UI elements.
+* **[UI]** Add polygon drawing mode for map background
+* **[UI]** Added a warning if you press takeoff with no player enabled flights
+* **[UI]** Packages and flights now visible in the main window sidebar
+* **[Units/Factions]** Added bombers to some coalitions
+* **[Units/Factions]** Added support for SU-57 mod by Cubanace
+* **[Units]** Added Freya EWR sites to german WW2 factions
+* **[Units]** Added support for many bombers (B-52H, B-1B, Tu-22, Tu-142)
+* **[Units]** Added support for new P-47 variants
+
+## Fixes :
+* **[Campaign Generator]** Big airbases could end up without any airbase defense.
+* **[Campaign generator]** Ship group and offshore buildings should not be generated on land anymore
+* **[Flight Planner]** Fix waypoint alitudes for helicopters
+* **[Flight Planner]** Fixed CAS aircraft wandering away from frontline
+* **[Maps]** Incirlik airbase was missing exclusions zones, so SAMS could end up being generated on the runway
+* **[Mission Generator]** Fixed player/client confusion when a flight had only one player slot.
+* **[Radios]** Fix A-10C radio
+* **[UI]** Many missing unit icons were added
+* **[UI]** Missing TER weapons in custom payload now selectable.
+
+# 2.1.5
+
+## Features/Improvements :
+* **[Units/Factions]** Enabled EPLRS for ground units that supports it (so they appear on A-10C II TAD and Helmet)
+
+## Fixes :
+* **[UI]** Fixed an issue that prevent saving after aborting a mission
+* **[Mission Generator]** Fixed aircraft landing point type being wrong
+
 # 2.1.4
 
 ## Fixes :
-* **[UI]** Fixed an issue that prevent generating the mission (take off button no working) on old savegames.
-
-# 2.1.3
+* **[UI]** Fixed an issue that prevented generating the mission (take off button no working) on old savegames.
 
 ## Features/Improvements :
 * **[Units/Factions]** Added A-10C_2 to USA 2005 and Bluefor modern factions
@@ -267,4 +398,4 @@ Sorry :(
 * **[Mission Generator]** Planned flights will spawn even if their home base has been captured or is being contested by enemy ground units. 
 * **[Campaign Generator]** Base defenses would not be generated on Normandy map and in some rare cases on others maps as well
 * **[Mission Planning]** CAS waypoints created from the "Predefined waypoint selector" would not be at the exact location of the frontline
-* **[Naming]** CAP mission flown from airbase are not named BARCAP anymore (CAP from carrier is still named BARCAP)
+* **[Naming]** CAP mission flown from airbase are not named BARCAP anymore (CAP from carrier is still named BARCAP)

game/__init__.py

@@ -1,2 +1,3 @@
 from .game import Game
-from . import db
+from . import db
+from .version import VERSION

game/data/building_data.py

@@ -1,10 +1,11 @@
 import inspect
 import dcs
 
-DEFAULT_AVAILABLE_BUILDINGS = ['fuel', 'ammo', 'comms', 'oil', 'ware', 'farp', 'fob', 'power', 'factory', 'derrick', 'aa']
+DEFAULT_AVAILABLE_BUILDINGS = ['fuel', 'ammo', 'comms', 'oil', 'ware', 'farp', 'fob', 'power', 'factory', 'derrick']
 
-WW2_GERMANY_BUILDINGS = ['fuel', 'factory', 'ww2bunker', 'ww2bunker', 'ww2bunker', 'allycamp', 'allycamp', 'aa']
-WW2_ALLIES_BUILDINGS = ['fuel', 'factory', 'allycamp', 'allycamp', 'allycamp', 'allycamp', 'allycamp', 'aa']
+WW2_FREE = ['fuel', 'factory', 'ware', 'fob']
+WW2_GERMANY_BUILDINGS = ['fuel', 'factory', 'ww2bunker', 'ww2bunker', 'ww2bunker', 'allycamp', 'allycamp', 'fob']
+WW2_ALLIES_BUILDINGS = ['fuel', 'factory', 'allycamp', 'allycamp', 'allycamp', 'allycamp', 'allycamp', 'fob']
 
 FORTIFICATION_BUILDINGS = ['Siegfried Line', 'Concertina wire', 'Concertina Wire', 'Czech hedgehogs 1', 'Czech hedgehogs 2',
                            'Dragonteeth 1', 'Dragonteeth 2', 'Dragonteeth 3', 'Dragonteeth 4', 'Dragonteeth 5',

game/data/cap_capabilities_db.py

@@ -1,4 +1,24 @@
-from dcs.planes import *
+from dcs.planes import (
+    Bf_109K_4,
+    C_101CC,
+    FW_190A8,
+    FW_190D9,
+    F_5E_3,
+    F_86F_Sabre,
+    I_16,
+    L_39ZA,
+    MiG_15bis,
+    MiG_19P,
+    MiG_21Bis,
+    P_47D_30,
+    P_47D_30bl1,
+    P_47D_40,
+    P_51D,
+    P_51D_30_NA,
+    SpitfireLFMkIX,
+    SpitfireLFMkIXCW
+)
+
 from pydcs_extensions.a4ec.a4ec import A_4E_C
 
 """
@@ -23,6 +43,8 @@ GUNFIGHTERS = [
     P_51D_30_NA,
     P_51D,
     P_47D_30,
+    P_47D_30bl1,
+    P_47D_40,
     SpitfireLFMkIXCW,
     SpitfireLFMkIX,
     Bf_109K_4,

game/data/doctrine.py

@@ -1,95 +1,124 @@
+from dataclasses import dataclass
+from datetime import timedelta
+
 from game.utils import nm_to_meter, feet_to_meter
 
-MODERN_DOCTRINE = {
 
-    "GENERATORS": {
-        "CAS": True,
-        "CAP": True,
-        "SEAD": True,
-        "STRIKE": True,
-        "ANTISHIP": True,
-    },
+@dataclass(frozen=True)
+class Doctrine:
+    cas: bool
+    cap: bool
+    sead: bool
+    strike: bool
+    antiship: bool
 
-    "STRIKE_MAX_RANGE": 1500000,
-    "SEAD_MAX_RANGE": 1500000,
+    strike_max_range: int
+    sead_max_range: int
 
-    "CAP_EVERY_X_MINUTES": 20,
-    "CAS_EVERY_X_MINUTES": 30,
-    "SEAD_EVERY_X_MINUTES": 40,
-    "STRIKE_EVERY_X_MINUTES": 40,
+    rendezvous_altitude: int
+    hold_distance: int
+    push_distance: int
+    join_distance: int
+    split_distance: int
+    ingress_egress_distance: int
+    ingress_altitude: int
+    egress_altitude: int
 
-    "INGRESS_EGRESS_DISTANCE": nm_to_meter(45),
-    "INGRESS_ALT": feet_to_meter(20000),
-    "EGRESS_ALT": feet_to_meter(20000),
-    "PATROL_ALT_RANGE": (feet_to_meter(15000), feet_to_meter(33000)),
-    "PATTERN_ALTITUDE": feet_to_meter(5000),
+    min_patrol_altitude: int
+    max_patrol_altitude: int
+    pattern_altitude: int
 
-    "CAP_PATTERN_LENGTH": (nm_to_meter(15), nm_to_meter(40)),
-    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(6), nm_to_meter(15)),
-    "CAP_DISTANCE_FROM_CP": (nm_to_meter(10), nm_to_meter(40)),
+    cap_duration: timedelta
+    cap_min_track_length: int
+    cap_max_track_length: int
+    cap_min_distance_from_cp: int
+    cap_max_distance_from_cp: int
 
-    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
-}
+    cas_duration: timedelta
 
-COLDWAR_DOCTRINE = {
+    sweep_distance: int
 
-    "GENERATORS": {
-        "CAS": True,
-        "CAP": True,
-        "SEAD": True,
-        "STRIKE": True,
-        "ANTISHIP": True,
-    },
 
-    "STRIKE_MAX_RANGE": 1500000,
-    "SEAD_MAX_RANGE": 1500000,
+MODERN_DOCTRINE = Doctrine(
+    cap=True,
+    cas=True,
+    sead=True,
+    strike=True,
+    antiship=True,
+    strike_max_range=1500000,
+    sead_max_range=1500000,
+    rendezvous_altitude=feet_to_meter(25000),
+    hold_distance=nm_to_meter(15),
+    push_distance=nm_to_meter(20),
+    join_distance=nm_to_meter(20),
+    split_distance=nm_to_meter(20),
+    ingress_egress_distance=nm_to_meter(45),
+    ingress_altitude=feet_to_meter(20000),
+    egress_altitude=feet_to_meter(20000),
+    min_patrol_altitude=feet_to_meter(15000),
+    max_patrol_altitude=feet_to_meter(33000),
+    pattern_altitude=feet_to_meter(5000),
+    cap_duration=timedelta(minutes=30),
+    cap_min_track_length=nm_to_meter(15),
+    cap_max_track_length=nm_to_meter(40),
+    cap_min_distance_from_cp=nm_to_meter(10),
+    cap_max_distance_from_cp=nm_to_meter(40),
+    cas_duration=timedelta(minutes=30),
+    sweep_distance=nm_to_meter(60),
+)
 
-    "CAP_EVERY_X_MINUTES": 20,
-    "CAS_EVERY_X_MINUTES": 30,
-    "SEAD_EVERY_X_MINUTES": 40,
-    "STRIKE_EVERY_X_MINUTES": 40,
+COLDWAR_DOCTRINE = Doctrine(
+    cap=True,
+    cas=True,
+    sead=True,
+    strike=True,
+    antiship=True,
+    strike_max_range=1500000,
+    sead_max_range=1500000,
+    rendezvous_altitude=feet_to_meter(22000),
+    hold_distance=nm_to_meter(10),
+    push_distance=nm_to_meter(10),
+    join_distance=nm_to_meter(10),
+    split_distance=nm_to_meter(10),
+    ingress_egress_distance=nm_to_meter(30),
+    ingress_altitude=feet_to_meter(18000),
+    egress_altitude=feet_to_meter(18000),
+    min_patrol_altitude=feet_to_meter(10000),
+    max_patrol_altitude=feet_to_meter(24000),
+    pattern_altitude=feet_to_meter(5000),
+    cap_duration=timedelta(minutes=30),
+    cap_min_track_length=nm_to_meter(12),
+    cap_max_track_length=nm_to_meter(24),
+    cap_min_distance_from_cp=nm_to_meter(8),
+    cap_max_distance_from_cp=nm_to_meter(25),
+    cas_duration=timedelta(minutes=30),
+    sweep_distance=nm_to_meter(40),
+)
 
-    "INGRESS_EGRESS_DISTANCE": nm_to_meter(30),
-    "INGRESS_ALT": feet_to_meter(18000),
-    "EGRESS_ALT": feet_to_meter(18000),
-    "PATROL_ALT_RANGE": (feet_to_meter(10000), feet_to_meter(24000)),
-    "PATTERN_ALTITUDE": feet_to_meter(5000),
-
-    "CAP_PATTERN_LENGTH": (nm_to_meter(12), nm_to_meter(24)),
-    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(2), nm_to_meter(8)),
-    "CAP_DISTANCE_FROM_CP": (nm_to_meter(8), nm_to_meter(25)),
-
-    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
-}
-
-WWII_DOCTRINE = {
-
-    "GENERATORS": {
-        "CAS": True,
-        "CAP": True,
-        "SEAD": False,
-        "STRIKE": True,
-        "ANTISHIP": True,
-    },
-
-    "STRIKE_MAX_RANGE": 1500000,
-    "SEAD_MAX_RANGE": 1500000,
-
-    "CAP_EVERY_X_MINUTES": 20,
-    "CAS_EVERY_X_MINUTES": 30,
-    "SEAD_EVERY_X_MINUTES": 40,
-    "STRIKE_EVERY_X_MINUTES": 40,
-
-    "INGRESS_EGRESS_DISTANCE": nm_to_meter(7),
-    "INGRESS_ALT": feet_to_meter(8000),
-    "EGRESS_ALT": feet_to_meter(8000),
-    "PATROL_ALT_RANGE": (feet_to_meter(4000), feet_to_meter(15000)),
-    "PATTERN_ALTITUDE": feet_to_meter(5000),
-
-    "CAP_PATTERN_LENGTH": (nm_to_meter(8), nm_to_meter(18)),
-    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(1), nm_to_meter(6)),
-    "CAP_DISTANCE_FROM_CP": (nm_to_meter(0), nm_to_meter(5)),
-
-    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
-
-}
+WWII_DOCTRINE = Doctrine(
+    cap=True,
+    cas=True,
+    sead=False,
+    strike=True,
+    antiship=True,
+    strike_max_range=1500000,
+    sead_max_range=1500000,
+    hold_distance=nm_to_meter(5),
+    push_distance=nm_to_meter(5),
+    join_distance=nm_to_meter(5),
+    split_distance=nm_to_meter(5),
+    rendezvous_altitude=feet_to_meter(10000),
+    ingress_egress_distance=nm_to_meter(7),
+    ingress_altitude=feet_to_meter(8000),
+    egress_altitude=feet_to_meter(8000),
+    min_patrol_altitude=feet_to_meter(4000),
+    max_patrol_altitude=feet_to_meter(15000),
+    pattern_altitude=feet_to_meter(5000),
+    cap_duration=timedelta(minutes=30),
+    cap_min_track_length=nm_to_meter(8),
+    cap_max_track_length=nm_to_meter(18),
+    cap_min_distance_from_cp=nm_to_meter(0),
+    cap_max_distance_from_cp=nm_to_meter(5),
+    cas_duration=timedelta(minutes=30),
+    sweep_distance=nm_to_meter(10),
+)

game/data/radar_db.py

@@ -1,5 +1,26 @@
+from dcs.ships import (
+    CGN_1144_2_Pyotr_Velikiy,
+    CG_1164_Moskva,
+    CVN_70_Carl_Vinson,
+    CVN_71_Theodore_Roosevelt,
+    CVN_72_Abraham_Lincoln,
+    CVN_73_George_Washington,
+    CVN_74_John_C__Stennis,
+    CV_1143_5_Admiral_Kuznetsov,
+    CV_1143_5_Admiral_Kuznetsov_2017,
+    FFG_11540_Neustrashimy,
+    FFL_1124_4_Grisha,
+    FF_1135M_Rezky,
+    FSG_1241_1MP_Molniya,
+    LHA_1_Tarawa,
+    Oliver_Hazzard_Perry_class,
+    Ticonderoga_class,
+    Type_052B_Destroyer,
+    Type_052C_Destroyer,
+    Type_054A_Frigate,
+    USS_Arleigh_Burke_IIa,
+)
 from dcs.vehicles import AirDefence
-from dcs.ships import *
 
 UNITS_WITH_RADAR = [
 

game/debriefing.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import itertools
+import json
+import logging
+import os
+import threading
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Type,
+    TYPE_CHECKING,
+)
+
+from dcs.unittype import FlyingType, UnitType
+
+from game import db
+from game.theater import Airfield, ControlPoint
+from game.unitmap import Building, FrontLineUnit, GroundObjectUnit, UnitMap
+from gen.flights.flight import Flight
+
+if TYPE_CHECKING:
+    from game import Game
+
+DEBRIEFING_LOG_EXTENSION = "log"
+
+
+@dataclass(frozen=True)
+class AirLosses:
+    player: List[Flight]
+    enemy: List[Flight]
+
+    @property
+    def losses(self) -> Iterator[Flight]:
+        return itertools.chain(self.player, self.enemy)
+
+    def by_type(self, player: bool) -> Dict[Type[FlyingType], int]:
+        losses_by_type: Dict[Type[FlyingType], int] = defaultdict(int)
+        losses = self.player if player else self.enemy
+        for loss in losses:
+            losses_by_type[loss.unit_type] += 1
+        return losses_by_type
+
+    def surviving_flight_members(self, flight: Flight) -> int:
+        losses = 0
+        for loss in self.losses:
+            if loss == flight:
+                losses += 1
+        return flight.count - losses
+
+
+@dataclass
+class GroundLosses:
+    player_front_line: List[FrontLineUnit] = field(default_factory=list)
+    enemy_front_line: List[FrontLineUnit] = field(default_factory=list)
+
+    player_ground_objects: List[GroundObjectUnit] = field(default_factory=list)
+    enemy_ground_objects: List[GroundObjectUnit] = field(default_factory=list)
+
+    player_buildings: List[Building] = field(default_factory=list)
+    enemy_buildings: List[Building] = field(default_factory=list)
+
+    player_airfields: List[Airfield] = field(default_factory=list)
+    enemy_airfields: List[Airfield] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class StateData:
+    #: True if the mission ended. If False, the mission exited abnormally.
+    mission_ended: bool
+
+    #: Names of aircraft units that were killed during the mission.
+    killed_aircraft: List[str]
+
+    #: Names of vehicle (and ship) units that were killed during the mission.
+    killed_ground_units: List[str]
+
+    #: Names of static units that were destroyed during the mission.
+    destroyed_statics: List[str]
+
+    #: Mangled names of bases that were captured during the mission.
+    base_capture_events: List[str]
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> StateData:
+        return cls(
+            mission_ended=data["mission_ended"],
+            killed_aircraft=data["killed_aircrafts"],
+            # Airfields emit a new "dead" event every time a bomb is dropped on
+            # them when they've already dead. Dedup.
+            killed_ground_units=list(set(data["killed_ground_units"])),
+            destroyed_statics=data["destroyed_objects_positions"],
+            base_capture_events=data["base_capture_events"]
+        )
+
+
+class Debriefing:
+    def __init__(self, state_data: Dict[str, Any], game: Game,
+                 unit_map: UnitMap) -> None:
+        self.state_data = StateData.from_json(state_data)
+        self.unit_map = unit_map
+
+        self.player_country = game.player_country
+        self.enemy_country = game.enemy_country
+        self.player_country_id = db.country_id_from_name(game.player_country)
+        self.enemy_country_id = db.country_id_from_name(game.enemy_country)
+
+        self.air_losses = self.dead_aircraft()
+        self.ground_losses = self.dead_ground_units()
+
+    @property
+    def front_line_losses(self) -> Iterator[FrontLineUnit]:
+        yield from self.ground_losses.player_front_line
+        yield from self.ground_losses.enemy_front_line
+
+    @property
+    def ground_object_losses(self) -> Iterator[GroundObjectUnit]:
+        yield from self.ground_losses.player_ground_objects
+        yield from self.ground_losses.enemy_ground_objects
+
+    @property
+    def building_losses(self) -> Iterator[Building]:
+        yield from self.ground_losses.player_buildings
+        yield from self.ground_losses.enemy_buildings
+
+    @property
+    def damaged_runways(self) -> Iterator[Airfield]:
+        yield from self.ground_losses.player_airfields
+        yield from self.ground_losses.enemy_airfields
+
+    def casualty_count(self, control_point: ControlPoint) -> int:
+        return len(
+            [x for x in self.front_line_losses if x.origin == control_point]
+        )
+
+    def front_line_losses_by_type(
+            self, player: bool) -> Dict[Type[UnitType], int]:
+        losses_by_type: Dict[Type[UnitType], int] = defaultdict(int)
+        if player:
+            losses = self.ground_losses.player_front_line
+        else:
+            losses = self.ground_losses.enemy_front_line
+        for loss in losses:
+            losses_by_type[loss.unit_type] += 1
+        return losses_by_type
+
+    def building_losses_by_type(self, player: bool) -> Dict[str, int]:
+        losses_by_type: Dict[str, int] = defaultdict(int)
+        if player:
+            losses = self.ground_losses.player_buildings
+        else:
+            losses = self.ground_losses.enemy_buildings
+        for loss in losses:
+            if loss.ground_object.control_point.captured != player:
+                continue
+
+            losses_by_type[loss.ground_object.dcs_identifier] += 1
+        return losses_by_type
+
+    def dead_aircraft(self) -> AirLosses:
+        player_losses = []
+        enemy_losses = []
+        for unit_name in self.state_data.killed_aircraft:
+            flight = self.unit_map.flight(unit_name)
+            if flight is None:
+                logging.error(f"Could not find Flight matching {unit_name}")
+                continue
+            if flight.departure.captured:
+                player_losses.append(flight)
+            else:
+                enemy_losses.append(flight)
+        return AirLosses(player_losses, enemy_losses)
+
+    def dead_ground_units(self) -> GroundLosses:
+        losses = GroundLosses()
+        for unit_name in self.state_data.killed_ground_units:
+            front_line_unit = self.unit_map.front_line_unit(unit_name)
+            if front_line_unit is not None:
+                if front_line_unit.origin.captured:
+                    losses.player_front_line.append(front_line_unit)
+                else:
+                    losses.enemy_front_line.append(front_line_unit)
+                continue
+
+            ground_object_unit = self.unit_map.ground_object_unit(unit_name)
+            if ground_object_unit is not None:
+                if ground_object_unit.ground_object.control_point.captured:
+                    losses.player_ground_objects.append(ground_object_unit)
+                else:
+                    losses.enemy_ground_objects.append(ground_object_unit)
+                continue
+
+            building = self.unit_map.building_or_fortification(unit_name)
+            if building is not None:
+                if building.ground_object.control_point.captured:
+                    losses.player_buildings.append(building)
+                else:
+                    losses.enemy_buildings.append(building)
+                continue
+
+            airfield = self.unit_map.airfield(unit_name)
+            if airfield is not None:
+                if airfield.captured:
+                    losses.player_airfields.append(airfield)
+                else:
+                    losses.enemy_airfields.append(airfield)
+                continue
+
+            # Only logging as debug because we don't currently track infantry
+            # deaths, so we expect to see quite a few unclaimed dead ground
+            # units. We should start tracking those and covert this to a
+            # warning.
+            logging.debug(f"Death of untracked ground unit {unit_name} will "
+                          "have no effect. This may be normal behavior.")
+
+        return losses
+
+    @property
+    def base_capture_events(self):
+        """Keeps only the last instance of a base capture event for each base ID."""
+        reversed_captures = list(reversed(self.state_data.base_capture_events))
+        last_base_cap_indexes = []
+        for idx, base in enumerate(i.split("||")[0] for i in reversed_captures):
+            if base not in [x[1] for x in last_base_cap_indexes]:
+                last_base_cap_indexes.append((idx, base))
+        return [reversed_captures[idx[0]] for idx in last_base_cap_indexes]        
+
+
+class PollDebriefingFileThread(threading.Thread):
+    """Thread class with a stop() method. The thread itself has to check
+    regularly for the stopped() condition."""
+
+    def __init__(self, callback: Callable[[Debriefing], None],
+                 game: Game, unit_map: UnitMap) -> None:
+        super().__init__()
+        self._stop_event = threading.Event()
+        self.callback = callback
+        self.game = game
+        self.unit_map = unit_map
+
+    def stop(self):
+        self._stop_event.set()
+
+    def stopped(self):
+        return self._stop_event.is_set()
+
+    def run(self):
+        if os.path.isfile("state.json"):
+            last_modified = os.path.getmtime("state.json")
+        else:
+            last_modified = 0
+        while not self.stopped():
+            if os.path.isfile("state.json") and os.path.getmtime("state.json") > last_modified:
+                with open("state.json", "r") as json_file:
+                    json_data = json.load(json_file)
+                    debriefing = Debriefing(json_data, self.game, self.unit_map)
+                    self.callback(debriefing)
+                break
+            time.sleep(5)
+
+
+def wait_for_debriefing(callback: Callable[[Debriefing], None],
+                        game: Game, unit_map) -> PollDebriefingFileThread:
+    thread = PollDebriefingFileThread(callback, game, unit_map)
+    thread.start()
+    return thread

game/event/airwar.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from .event import Event
+
+if TYPE_CHECKING:
+    from game.theater import ConflictTheater
+
+
+class AirWarEvent(Event):
+    """Event handler for the air battle"""
+
+    def __str__(self):
+        return "AirWar"

game/event/event.py

@@ -1,24 +1,25 @@
-import typing
+from __future__ import annotations
+
 import logging
+import math
+from typing import Dict, List, TYPE_CHECKING, Type
 
-from dcs.action import Coalition
-from dcs.unittype import UnitType
-from dcs.task import *
-from dcs.vehicles import AirDefence
+from dcs.mapping import Point
+from dcs.task import Task
 from dcs.unittype import UnitType
 
-from game import *
+from game import persistency
+from game.debriefing import AirLosses, Debriefing
 from game.infos.information import Information
-from theater import *
-from gen.environmentgen import EnvironmentSettings
-from gen.conflictgen import Conflict
-from game.db import assigned_units_from, unitdict_from
-from theater.start_generator import generate_airbase_defense_group
+from game.operation.operation import Operation
+from game.theater import ControlPoint
+from gen import AirTaskingOrder
+from gen.ground_forces.combat_stance import CombatStance
+from ..unitmap import UnitMap
 
-from userdata.debriefing import Debriefing
-from userdata import persistency
+if TYPE_CHECKING:
+    from ..game import Game
 
-import game.db as db
 
 DIFFICULTY_LOG_BASE = 1.1
 EVENT_DEPARTURE_MAX_DISTANCE = 340000
@@ -28,26 +29,20 @@ MINOR_DEFEAT_INFLUENCE = 0.1
 DEFEAT_INFLUENCE = 0.3
 STRONG_DEFEAT_INFLUENCE = 0.5
 
+
 class Event:
     silent = False
     informational = False
-    is_awacs_enabled = False
-    ca_slots = 0
 
     game = None  # type: Game
     location = None  # type: Point
     from_cp = None  # type: ControlPoint
-    departure_cp = None  # type: ControlPoint
     to_cp = None  # type: ControlPoint
-
-    operation = None  # type: Operation
     difficulty = 1  # type: int
-    environment_settings = None  # type: EnvironmentSettings
     BONUS_BASE = 5
 
     def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str, defender_name: str):
         self.game = game
-        self.departure_cp = None
         self.from_cp = from_cp
         self.to_cp = target_cp
         self.location = location
@@ -59,138 +54,129 @@ class Event:
         return self.attacker_name == self.game.player_name
 
     @property
-    def enemy_cp(self) -> ControlPoint:
-        if self.attacker_name == self.game.player_name:
-            return self.to_cp
-        else:
-            return self.departure_cp
-
-    @property
-    def tasks(self) -> typing.Collection[typing.Type[Task]]:
+    def tasks(self) -> List[Type[Task]]:
         return []
 
-    @property
-    def global_cp_available(self) -> bool:
-        return False
-
-    def is_departure_available_from(self, cp: ControlPoint) -> bool:
-        if not cp.captured:
-            return False
-
-        if self.location.distance_to_point(cp.position) > EVENT_DEPARTURE_MAX_DISTANCE:
-            return False
-
-        if cp.is_global and not self.global_cp_available:
-            return False
-
-        return True
-
     def bonus(self) -> int:
         return int(math.log(self.to_cp.importance + 1, DIFFICULTY_LOG_BASE) * self.BONUS_BASE)
 
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return self.operation.is_successfull(debriefing)
+    def generate(self) -> UnitMap:
+        Operation.prepare(self.game)
+        unit_map = Operation.generate()
+        Operation.current_mission.save(
+            persistency.mission_path_for("liberation_nextturn.miz"))
+        return unit_map
 
-    def player_attacking(self, cp: ControlPoint, flights: db.TaskForceDict):
-        if self.is_player_attacking:
-            self.departure_cp = cp
-        else:
-            self.to_cp = cp
-
-    def player_defending(self, cp: ControlPoint, flights: db.TaskForceDict):
-        if self.is_player_attacking:
-            self.departure_cp = cp
-        else:
-            self.to_cp = cp
-
-    def generate(self):
-        self.operation.is_awacs_enabled = self.is_awacs_enabled
-        self.operation.ca_slots = self.ca_slots
-
-        self.operation.prepare(self.game.theater.terrain, is_quick=False)
-        self.operation.generate()
-        self.operation.current_mission.save(persistency.mission_path_for("liberation_nextturn.miz"))
-        self.environment_settings = self.operation.environment_settings
-
-    def commit(self, debriefing: Debriefing):
-
-        logging.info("Commiting mission results")
-
-        # ------------------------------
-        # Destroyed aircrafts
-        cp_map = {cp.id: cp for cp in self.game.theater.controlpoints}
-        for destroyed_aircraft in debriefing.killed_aircrafts:
-            try:
-                cpid = int(destroyed_aircraft.split("|")[3])
-                type = db.unit_type_from_name(destroyed_aircraft.split("|")[4])
-                if cpid in cp_map.keys():
-                    cp = cp_map[cpid]
-                    if type in cp.base.aircraft.keys():
-                        logging.info("Aircraft destroyed : " + str(type))
-                        cp.base.aircraft[type] = max(0, cp.base.aircraft[type]-1)
-            except Exception as e:
-                print(e)
-
-        # ------------------------------
-        # Destroyed ground units
-        killed_unit_count_by_cp = {cp.id: 0 for cp in self.game.theater.controlpoints}
-        cp_map = {cp.id: cp for cp in self.game.theater.controlpoints}
-        for killed_ground_unit in debriefing.killed_ground_units:
-            try:
-                cpid = int(killed_ground_unit.split("|")[3])
-                type = db.unit_type_from_name(killed_ground_unit.split("|")[4])
-                if cpid in cp_map.keys():
-                    killed_unit_count_by_cp[cpid] = killed_unit_count_by_cp[cpid] + 1
-                    cp = cp_map[cpid]
-                    if type in cp.base.armor.keys():
-                        logging.info("Ground unit destroyed : " + str(type))
-                        cp.base.armor[type] = max(0, cp.base.armor[type] - 1)
-            except Exception as e:
-                print(e)
-
-        # ------------------------------
-        # Static ground objects
-        for destroyed_ground_unit_name in debriefing.killed_ground_units:
-            for cp in self.game.theater.controlpoints:
-                if not cp.ground_objects:
+    @staticmethod
+    def _transfer_aircraft(ato: AirTaskingOrder, losses: AirLosses,
+                           for_player: bool) -> None:
+        for package in ato.packages:
+            for flight in package.flights:
+                # No need to transfer to the same location.
+                if flight.departure == flight.arrival:
                     continue
 
-                # -- Static ground objects
-                for i, ground_object in enumerate(cp.ground_objects):
-                    if ground_object.is_dead:
-                        continue
+                # Don't transfer to bases that were captured. Note that if the
+                # airfield was back-filling transfers it may overflow. We could
+                # attempt to be smarter in the future by performing transfers in
+                # order up a graph to prevent transfers to full airports and
+                # send overflow off-map, but overflow is fine for now.
+                if flight.arrival.captured != for_player:
+                    logging.info(
+                        f"Not transferring {flight} because {flight.arrival} "
+                        "was captured")
+                    continue
 
-                    if ground_object.matches_string_identifier(destroyed_ground_unit_name):
-                        logging.info("cp {} killing ground object {}".format(cp, ground_object.string_identifier))
-                        cp.ground_objects[i].is_dead = True
+                transfer_count = losses.surviving_flight_members(flight)
+                if transfer_count < 0:
+                    logging.error(f"{flight} had {flight.count} aircraft but "
+                                  f"{transfer_count} losses were recorded.")
+                    continue
 
-                        info = Information("Building destroyed",
-                                           ground_object.dcs_identifier + " has been destroyed at location " + ground_object.obj_name,
-                                           self.game.turn)
-                        self.game.informations.append(info)
+                aircraft = flight.unit_type
+                available = flight.departure.base.total_units_of_type(aircraft)
+                if available < transfer_count:
+                    logging.error(
+                        f"Found killed {aircraft} from {flight.departure} but "
+                        f"that airbase has only {available} available.")
+                    continue
 
+                flight.departure.base.aircraft[aircraft] -= transfer_count
+                if aircraft not in flight.arrival.base.aircraft:
+                    # TODO: Should use defaultdict.
+                    flight.arrival.base.aircraft[aircraft] = 0
+                flight.arrival.base.aircraft[aircraft] += transfer_count
 
-                # -- AA Site groups
-                destroyed_units = 0
-                info = Information("Units destroyed at " + ground_object.obj_name,
-                                   "",
-                                   self.game.turn)
-                for i, ground_object in enumerate(cp.ground_objects):
-                    if ground_object.dcs_identifier in ["AA", "CARRIER", "LHA"]:
-                        for g in ground_object.groups:
-                            if not hasattr(g, "units_losts"):
-                                g.units_losts = []
-                            for u in g.units:
-                                if u.name == destroyed_ground_unit_name:
-                                    g.units.remove(u)
-                                    g.units_losts.append(u)
-                                    destroyed_units = destroyed_units + 1
-                                    info.text = u.type
-                        ucount = sum([len(g.units) for g in ground_object.groups])
-                        if ucount == 0:
-                            ground_object.is_dead = True
-                if destroyed_units > 0:
-                    self.game.informations.append(info)
+    def complete_aircraft_transfers(self, debriefing: Debriefing) -> None:
+        self._transfer_aircraft(self.game.blue_ato, debriefing.air_losses,
+                                for_player=True)
+        self._transfer_aircraft(self.game.red_ato, debriefing.air_losses,
+                                for_player=False)
+
+    @staticmethod
+    def commit_air_losses(debriefing: Debriefing) -> None:
+        for loss in debriefing.air_losses.losses:
+            aircraft = loss.unit_type
+            cp = loss.departure
+            available = cp.base.total_units_of_type(aircraft)
+            if available <= 0:
+                logging.error(
+                    f"Found killed {aircraft} from {cp} but that airbase has "
+                    "none available.")
+                continue
+
+            logging.info(f"{aircraft} destroyed from {cp}")
+            cp.base.aircraft[aircraft] -= 1
+
+    @staticmethod
+    def commit_front_line_losses(debriefing: Debriefing) -> None:
+        for loss in debriefing.front_line_losses:
+            unit_type = loss.unit_type
+            control_point = loss.origin
+            available = control_point.base.total_units_of_type(unit_type)
+            if available <= 0:
+                logging.error(
+                    f"Found killed {unit_type} from {control_point} but that "
+                    "airbase has none available.")
+                continue
+
+            logging.info(f"{unit_type} destroyed from {control_point}")
+            control_point.base.armor[unit_type] -= 1
+
+    @staticmethod
+    def commit_ground_object_losses(debriefing: Debriefing) -> None:
+        for loss in debriefing.ground_object_losses:
+            # TODO: This should be stored in the TGO, not in the pydcs Group.
+            if not hasattr(loss.group, "units_losts"):
+                loss.group.units_losts = []
+
+            loss.group.units.remove(loss.unit)
+            loss.group.units_losts.append(loss.unit)
+            if not loss.ground_object.alive_unit_count:
+                loss.ground_object.is_dead = True
+
+    def commit_building_losses(self, debriefing: Debriefing) -> None:
+        for loss in debriefing.building_losses:
+            loss.ground_object.is_dead = True
+            self.game.informations.append(Information(
+                "Building destroyed",
+                f"{loss.ground_object.dcs_identifier} has been destroyed at "
+                f"location {loss.ground_object.obj_name}", self.game.turn
+            ))
+
+    @staticmethod
+    def commit_damaged_runways(debriefing: Debriefing) -> None:
+        for damaged_runway in debriefing.damaged_runways:
+            damaged_runway.damage_runway()
+
+    def commit(self, debriefing: Debriefing):
+        logging.info("Committing mission results")
+
+        self.commit_air_losses(debriefing)
+        self.commit_front_line_losses(debriefing)
+        self.commit_ground_object_losses(debriefing)
+        self.commit_building_losses(debriefing)
+        self.commit_damaged_runways(debriefing)
 
         # ------------------------------
         # Captured bases
@@ -209,41 +195,31 @@ class Event:
                     if cp.id == id:
 
                         if cp.captured and new_owner_coalition != coalition:
-                            cp.captured = False
+                            for_player = False
                             info = Information(cp.name + " lost !", "The ennemy took control of " + cp.name + "\nShame on us !", self.game.turn)
                             self.game.informations.append(info)
-                            pname = self.game.enemy_name
                             captured_cps.append(cp)
                         elif not(cp.captured) and new_owner_coalition == coalition:
-                            cp.captured = True
+                            for_player = True
                             info = Information(cp.name + " captured !", "We took control of " + cp.name + "! Great job !", self.game.turn)
                             self.game.informations.append(info)
-                            pname = self.game.player_name
                             captured_cps.append(cp)
                         else:
                             continue
 
-                        cp.base.aircraft = {}
-                        cp.base.armor = {}
-
-                        airbase_def_id = 0
-                        for g in cp.ground_objects:
-                            g.groups = []
-                            if g.airbase_group and pname != "":
-                                generate_airbase_defense_group(airbase_def_id, g, pname, self.game, cp)
-                                airbase_def_id = airbase_def_id + 1
+                        cp.capture(self.game, for_player)
 
                 for cp in captured_cps:
                     logging.info("Will run redeploy for " + cp.name)
                     self.redeploy_units(cp)
+            except Exception:
+                logging.exception(f"Could not process base capture {captured}")
 
-
-            except Exception as e:
-                print(e)
+        self.complete_aircraft_transfers(debriefing)
 
         # Destroyed units carcass
         # -------------------------
-        for destroyed_unit in debriefing.destroyed_units:
+        for destroyed_unit in debriefing.state_data.destroyed_statics:
             self.game.add_destroyed_units(destroyed_unit)
 
         # -----------------------------------
@@ -253,10 +229,10 @@ class Event:
             for enemy_cp in enemy_cps:
                 print("Compute frontline progression for : " + cp.name + " to " + enemy_cp.name)
 
-                delta = 0
+                delta = 0.0
                 player_won = True
-                ally_casualties = killed_unit_count_by_cp[cp.id]
-                enemy_casualties = killed_unit_count_by_cp[enemy_cp.id]
+                ally_casualties = debriefing.casualty_count(cp)
+                enemy_casualties = debriefing.casualty_count(enemy_cp)
                 ally_units_alive = cp.base.total_armor
                 enemy_units_alive = enemy_cp.base.total_armor
 
@@ -373,12 +349,13 @@ class Event:
                     logging.info(info.text)
 
 
-
 class UnitsDeliveryEvent(Event):
-    informational = True
-    units = None  # type: typing.Dict[UnitType, int]
 
-    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
+    informational = True
+
+    def __init__(self, attacker_name: str, defender_name: str,
+                 from_cp: ControlPoint, to_cp: ControlPoint,
+                 game: Game) -> None:
         super(UnitsDeliveryEvent, self).__init__(game=game,
                                                  location=to_cp.position,
                                                  from_cp=from_cp,
@@ -386,19 +363,22 @@ class UnitsDeliveryEvent(Event):
                                                  attacker_name=attacker_name,
                                                  defender_name=defender_name)
 
-        self.units = {}
+        self.units: Dict[Type[UnitType], int] = {}
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "Pending delivery to {}".format(self.to_cp)
 
-    def deliver(self, units: typing.Dict[UnitType, int]):
+    def deliver(self, units: Dict[Type[UnitType], int]) -> None:
         for k, v in units.items():
             self.units[k] = self.units.get(k, 0) + v
 
-    def skip(self):
-
+    def skip(self) -> None:
         for k, v in self.units.items():
-            info = Information("Ally Reinforcement", str(k.id) + " x " + str(v) + " at " + self.to_cp.name, self.game.turn)
-            self.game.informations.append(info)
+            if self.to_cp.captured:
+                name = "Ally "
+            else:
+                name = "Enemy "
+            self.game.message(
+                f"{name} reinforcements: {k.id} x {v} at {self.to_cp.name}")
 
         self.to_cp.base.commision_units(self.units)

game/event/frontlineattack.py

@@ -1,53 +1,11 @@
-from game.event import *
-from game.operation.frontlineattack import FrontlineAttackOperation
-from userdata.debriefing import Debriefing
+from .event import Event
 
 
 class FrontlineAttackEvent(Event):
-
-    @property
-    def tasks(self) -> typing.Collection[typing.Type[Task]]:
-        if self.is_player_attacking:
-            return [CAS, CAP]
-        else:
-            return [CAP]
-
-    @property
-    def global_cp_available(self) -> bool:
-        return True
-
+    """
+    An event centered on a FrontLine Conflict.
+    Currently the same as its parent, but here for legacy compatibility as well as to allow for
+    future unique Event handling
+    """
     def __str__(self):
         return "Frontline attack"
-
-    def is_successfull(self, debriefing: Debriefing):
-        attackers_success = True
-        if self.from_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def commit(self, debriefing: Debriefing):
-        super(FrontlineAttackEvent, self).commit(debriefing)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-0.1)
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        op = FrontlineAttackOperation(game=self.game,
-                                      attacker_name=self.attacker_name,
-                                      defender_name=self.defender_name,
-                                      from_cp=self.from_cp,
-                                      departure_cp=self.departure_cp,
-                                      to_cp=self.to_cp)
-        self.operation = op
-
-    def player_defending(self, flights: db.TaskForceDict):
-        op = FrontlineAttackOperation(game=self.game,
-                                      attacker_name=self.attacker_name,
-                                      defender_name=self.defender_name,
-                                      from_cp=self.from_cp,
-                                      departure_cp=self.departure_cp,
-                                      to_cp=self.to_cp)
-        self.operation = op
-

game/factions/australia_2005.py

@@ -1,50 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Australia_2005 = {
-    "country": "Australia",
-    "side": "blue",
-    "units": [
-        FA_18C_hornet,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        Armor.MBT_M1A2_Abrams,
-        Armor.MBT_Leopard_1A3,
-        Armor.APC_M113,
-        Armor.IFV_LAV_25,
-        Armor.IFV_MCV_80,
-
-        UH_1H,
-        AH_1W, # Standing as EC Tiger
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.Rapier_FSA_Launcher,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.Rapier_FSA_Launcher,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "lhanames": [
-        "HMAS Canberra",
-        "HMAS Adelaide"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/bluefor_coldwar.py

@@ -1,58 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-BLUEFOR_COLDWAR = {
-    "country": "Combined Joint Task Forces Blue",
-    "side": "blue",
-    "units": [
-
-        F_14B,
-        F_4E,
-        F_5E_3,
-        A_10A,
-        AJS37,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        SA342M,
-        SA342L,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Chaparral_M48,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.AAA_Vulcan_M163,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "carrier_names": [
-        "CVN-71 Theodore Roosevelt",
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 George Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat": [
-    ], "has_jtac": True
-}

game/factions/bluefor_coldwar_a4.py

@@ -1,65 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from pydcs_extensions.a4ec.a4ec import A_4E_C
-
-BLUEFOR_COLDWAR_A4 = {
-    "country": "Combined Joint Task Forces Blue",
-    "side": "blue",
-    "units": [
-
-        F_14B,
-        F_4E,
-        F_5E_3,
-        A_10A,
-        AJS37,
-        A_4E_C,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        SA342M,
-        SA342L,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Chaparral_M48,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.AAA_Vulcan_M163,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "CVN-71 Theodore Roosevelt",
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 George Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat": [
-    ], "requirements": {
-        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
-    }, "has_jtac": True
-}

game/factions/bluefor_coldwar_mods.py

@@ -1,68 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from pydcs_extensions.a4ec.a4ec import A_4E_C
-from pydcs_extensions.mb339.mb339 import MB_339PAN
-
-BLUEFOR_COLDWAR_MODS = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-
-        F_14B,
-        F_4E,
-        F_5E_3,
-        A_10A,
-        AJS37,
-        A_4E_C,
-        MB_339PAN,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        SA342M,
-        SA342L,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Chaparral_M48,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.AAA_Vulcan_M163,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "CVN-71 Theodore Roosevelt",
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 George Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat": [
-    ], "requirements": {
-        "MB-339A": "http://www.freccetricolorivirtuali.net/",
-        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
-    }, "has_jtac": True
-}

game/factions/bluefor_modern.py

@@ -1,83 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-BLUEFOR_MODERN = {
-    "country": "Combined Joint Task Forces Blue",
-    "side": "blue",
-    "units": [
-
-        F_15C,
-        F_14B,
-        FA_18C_hornet,
-        F_16C_50,
-        JF_17,
-        M_2000C,
-        F_5E_3,
-        Su_27,
-
-        Su_25T,
-        A_10A,
-        A_10C,
-        A_10C_2,
-        AV8BNA,
-        AJS37,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        AH_64D,
-        Ka_50,
-        SA342M,
-        SA342L,
-
-        Armor.MBT_M1A2_Abrams,
-        Armor.MBT_Leopard_2,
-        Armor.ATGM_M1134_Stryker,
-        Armor.IFV_M2A2_Bradley,
-        Armor.IFV_Marder,
-        Armor.APC_M1043_HMMWV_Armament,
-
-        Artillery.MLRS_M270,
-        Artillery.SPH_M109_Paladin,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Patriot_EPP_III,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.SAM_Avenger_M1097,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "CVN-71 Theodore Roosevelt",
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 George Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/canada_2005.py

@@ -1,43 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Canada_2005 = {
-    "country": "Canada",
-    "side": "blue",
-    "units": [
-        FA_18C_hornet,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        Armor.MBT_Leopard_1A3,
-        Armor.MBT_Leopard_2,
-        Armor.IFV_LAV_25,
-        Armor.APC_M113,
-        Armor.IFV_MCV_80,
-
-        UH_1H,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Avenger_M1097,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.SAM_Avenger_M1097,
-    ], "destroyer": [
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "boat":[
-        "ArleighBurkeGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/china_2010.py

@@ -1,80 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-China_2010 = {
-    "country": "China",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis, # Standing as J-7
-        Su_30,
-        Su_33,
-        J_11A,
-        JF_17,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        KJ_2000,
-
-        Mi_8MT,
-        Mi_28N,
-
-        AirDefence.SAM_SA_10_S_300PS_LN_5P85C, # Standing as HQ-9+
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.HQ_7_Self_Propelled_LN,
-
-        Armor.ZTZ_96B,
-        Armor.MBT_T_55,
-        Armor.ZBD_04A,
-        Armor.IFV_BMP_1,
-        Artillery.MLRS_9A52_Smerch,
-        Artillery.SPH_2S9_Nona,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Paratrooper_AKS,
-        Infantry.Infantry_Soldier_Rus,
-        Infantry.Paratrooper_RPG_16,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160
-    ],
-    "shorad":[
-        AirDefence.SPAAA_ZSU_23_4_Shilka,
-        AirDefence.Rapier_FSA_Launcher, # Standing as PL-9C Shorad
-        AirDefence.HQ_7_Self_Propelled_LN
-    ], "aircraft_carrier": [
-        CV_1143_5_Admiral_Kuznetsov,
-    ], "destroyer": [
-        Type_052B_Destroyer,
-        Type_052C_Destroyer
-    ], "cruiser": [
-        Type_054A_Frigate,
-    ], "helicopter_carrier": [
-        Type_071_Amphibious_Transport_Dock,
-    ], "lhanames": [
-        "Kunlun Shan",
-        "Jinggang Shan",
-        "Changbai Shan",
-        "Yimeng Shan",
-        "Longhu Shan",
-        "Wuzhi Shan",
-        "Wudang Shan"
-    ], "carrier_names": [
-        "001 Liaoning",
-        "002 Shandong",
-    ], "boat":[
-        "Type54GroupGenerator"
-    ],
-    "has_jtac": True,
-    "jtac_unit": WingLoong_I
-}

game/factions/faction.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Type, List, Any, cast
+
+import dcs
+from dcs.countries import country_dict
+from dcs.planes import plane_map
+from dcs.unittype import FlyingType, ShipType, VehicleType, UnitType
+from dcs.vehicles import Armor, Unarmed, Infantry, Artillery, AirDefence
+
+from game.data.building_data import WW2_ALLIES_BUILDINGS, DEFAULT_AVAILABLE_BUILDINGS, WW2_GERMANY_BUILDINGS, WW2_FREE
+from game.data.doctrine import Doctrine, MODERN_DOCTRINE, COLDWAR_DOCTRINE, WWII_DOCTRINE
+from pydcs_extensions.mod_units import MODDED_VEHICLES, MODDED_AIRPLANES
+
+
+@dataclass
+class Faction:
+
+    # Country used by this faction
+    country: str = field(default="")
+
+    # Nice name of the faction
+    name: str = field(default="")
+
+    # List of faction file authors
+    authors: str = field(default="")
+
+    # A description of the faction
+    description: str = field(default="")
+
+    # Available aircraft
+    aircrafts: List[Type[FlyingType]] = field(default_factory=list)
+
+    # Available awacs aircraft
+    awacs: List[Type[FlyingType]] = field(default_factory=list)
+
+    # Available tanker aircraft
+    tankers: List[Type[FlyingType]] = field(default_factory=list)
+
+    # Available frontline units
+    frontline_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Available artillery units
+    artillery_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Infantry units used
+    infantry_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Logistics units used
+    logistics_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Possible SAMS site generators for this faction
+    air_defenses: List[str] = field(default_factory=list)
+
+    # Possible EWR generators for this faction.
+    ewrs: List[str] = field(default_factory=list)
+
+    # Possible Missile site generators for this faction
+    missiles: List[str] = field(default_factory=list)
+
+    # Required mods or asset packs
+    requirements: Dict[str, str] = field(default_factory=dict)
+
+    # possible aircraft carrier units
+    aircraft_carrier: List[Type[UnitType]] = field(default_factory=list)
+
+    # possible helicopter carrier units
+    helicopter_carrier: List[Type[UnitType]] = field(default_factory=list)
+
+    # Possible carrier names
+    carrier_names: List[str] = field(default_factory=list)
+
+    # Possible helicopter carrier names
+    helicopter_carrier_names: List[str] = field(default_factory=list)
+
+    # Navy group generators
+    navy_generators: List[str] = field(default_factory=list)
+
+    # Available destroyers
+    destroyers: List[Type[ShipType]] = field(default_factory=list)
+
+    # Available cruisers
+    cruisers: List[Type[ShipType]] = field(default_factory=list)
+
+    # How many navy group should we try to generate per CP on startup for this faction
+    navy_group_count: int = field(default=1)
+
+    # How many missiles group should we try to generate per CP on startup for this faction
+    missiles_group_count: int = field(default=1)
+
+    # Whether this faction has JTAC access
+    has_jtac: bool = field(default=False)
+
+    # Unit to use as JTAC for this faction
+    jtac_unit: Optional[Type[FlyingType]] = field(default=None)
+
+    # doctrine
+    doctrine: Doctrine = field(default=MODERN_DOCTRINE)
+
+    # List of available buildings for this faction
+    building_set: List[str] = field(default_factory=list)
+
+    # List of default livery overrides
+    liveries_overrides: Dict[Type[UnitType], List[str]] = field(
+        default_factory=dict)
+
+    #: Set to True if the faction should force the "Unrestricted satnav" option
+    #: for the mission. This option enables GPS for capable aircraft regardless
+    #: of the time period or operator. For example, the CJTF "countries" don't
+    #: appear to have GPS capability, so they need this.
+    #:
+    #: Note that this option cannot be set per-side. If either faction needs it,
+    #: both will use it.
+    unrestricted_satnav: bool = False
+
+    @classmethod
+    def from_json(cls: Type[Faction], json: Dict[str, Any]) -> Faction:
+
+        faction = Faction()
+
+        faction.country = json.get("country", "/")
+        if faction.country not in [c.name for c in country_dict.values()]:
+            raise AssertionError("Faction's country (\"{}\") is not a valid DCS country ID".format(faction.country))
+
+        faction.name = json.get("name", "")
+        if not faction.name:
+            raise AssertionError("Faction has no valid name")
+
+        faction.authors = json.get("authors", "")
+        faction.description = json.get("description", "")
+
+        faction.aircrafts = load_all_aircraft(json.get("aircrafts", []))
+        faction.awacs = load_all_aircraft(json.get("awacs", []))
+        faction.tankers = load_all_aircraft(json.get("tankers", []))
+
+        faction.frontline_units = load_all_vehicles(
+            json.get("frontline_units", []))
+        faction.artillery_units = load_all_vehicles(
+            json.get("artillery_units", []))
+        faction.infantry_units = load_all_vehicles(
+            json.get("infantry_units", []))
+        faction.logistics_units = load_all_vehicles(
+            json.get("logistics_units", []))
+
+        faction.ewrs = json.get("ewrs", [])
+
+        faction.air_defenses = json.get("air_defenses", [])
+        # Compatibility for older factions. All air defenses now belong to a
+        # single group and the generator decides what belongs where.
+        faction.air_defenses.extend(json.get("sams", []))
+        faction.air_defenses.extend(json.get("shorads", []))
+
+        faction.missiles = json.get("missiles", [])
+        faction.requirements = json.get("requirements", {})
+
+        faction.carrier_names = json.get("carrier_names", [])
+        faction.helicopter_carrier_names = json.get(
+            "helicopter_carrier_names", [])
+        faction.navy_generators = json.get("navy_generators", [])
+        faction.aircraft_carrier = load_all_ships(
+            json.get("aircraft_carrier", []))
+        faction.helicopter_carrier = load_all_ships(
+            json.get("helicopter_carrier", []))
+        faction.destroyers = load_all_ships(json.get("destroyers", []))
+        faction.cruisers = load_all_ships(json.get("cruisers", []))
+        faction.has_jtac = json.get("has_jtac", False)
+        jtac_name = json.get("jtac_unit", None)
+        if jtac_name is not None:
+            faction.jtac_unit = load_aircraft(jtac_name)
+        else:
+            faction.jtac_unit = None
+        faction.navy_group_count = int(json.get("navy_group_count", 1))
+        faction.missiles_group_count = int(json.get("missiles_group_count", 0))
+
+        # Load doctrine
+        doctrine = json.get("doctrine", "modern")
+        if doctrine == "modern":
+            faction.doctrine = MODERN_DOCTRINE
+        elif doctrine == "coldwar":
+            faction.doctrine = COLDWAR_DOCTRINE
+        elif doctrine == "ww2":
+            faction.doctrine = WWII_DOCTRINE
+        else:
+            faction.doctrine = MODERN_DOCTRINE
+
+        # Load the building set
+        building_set = json.get("building_set", "default")
+        if building_set == "default":
+            faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
+        elif building_set == "ww2free":
+            faction.building_set = WW2_FREE
+        elif building_set == "ww2ally":
+            faction.building_set = WW2_ALLIES_BUILDINGS
+        elif building_set == "ww2germany":
+            faction.building_set = WW2_GERMANY_BUILDINGS
+        else:
+            faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
+
+        # Load liveries override
+        faction.liveries_overrides = {}
+        liveries_overrides = json.get("liveries_overrides", {})
+        for k, v in liveries_overrides.items():
+            k = load_aircraft(k)
+            if k is not None:
+                faction.liveries_overrides[k] = [s.lower() for s in v]
+
+        faction.unrestricted_satnav = json.get("unrestricted_satnav", False)
+
+        return faction
+
+    @property
+    def units(self) -> List[Type[UnitType]]:
+        return (self.infantry_units + self.aircrafts + self.awacs +
+                self.artillery_units + self.frontline_units +
+                self.tankers + self.logistics_units)
+
+
+def unit_loader(
+        unit: str, class_repository: List[Any]) -> Optional[Type[UnitType]]:
+    """
+    Find unit by name
+    :param unit: Unit name as string
+    :param class_repository: Repository of classes (Either a module, a class, or a list of classes)
+    :return: The unit as a PyDCS type
+    """
+    if unit is None:
+        return None
+    elif unit in plane_map.keys():
+        return plane_map[unit]
+    else:
+        for mother_class in class_repository:
+            if getattr(mother_class, unit, None) is not None:
+                return getattr(mother_class, unit)
+            if type(mother_class) is list:
+                for m in mother_class:
+                    if m.__name__ == unit:
+                        return m
+        logging.error(f"FACTION ERROR : Unable to find {unit} in pydcs")
+        return None
+
+
+def load_aircraft(name: str) -> Optional[Type[FlyingType]]:
+    return cast(Optional[FlyingType], unit_loader(
+        name, [dcs.planes, dcs.helicopters, MODDED_AIRPLANES]
+    ))
+
+
+def load_all_aircraft(data) -> List[Type[FlyingType]]:
+    items = []
+    for name in data:
+        item = load_aircraft(name)
+        if item is not None:
+            items.append(item)
+    return items
+
+
+def load_vehicle(name: str) -> Optional[Type[VehicleType]]:
+    return cast(Optional[FlyingType], unit_loader(
+        name, [Infantry, Unarmed, Armor, AirDefence, Artillery, MODDED_VEHICLES]
+    ))
+
+
+def load_all_vehicles(data) -> List[Type[VehicleType]]:
+    items = []
+    for name in data:
+        item = load_vehicle(name)
+        if item is not None:
+            items.append(item)
+    return items
+
+
+def load_ship(name: str) -> Optional[Type[ShipType]]:
+    return cast(Optional[FlyingType], unit_loader(name, [dcs.ships]))
+
+
+def load_all_ships(data) -> List[Type[ShipType]]:
+    items = []
+    for name in data:
+        item = load_ship(name)
+        if item is not None:
+            items.append(item)
+    return items

game/factions/faction_loader.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import json
+import logging
+from pathlib import Path
+from typing import Dict, Iterator, Optional, Type
+
+from game.factions.faction import Faction
+
+FACTION_DIRECTORY = Path("./resources/factions/")
+
+
+class FactionLoader:
+    def __init__(self) -> None:
+        self._factions: Optional[Dict[str, Faction]] = None
+
+    @property
+    def factions(self) -> Dict[str, Faction]:
+        self.initialize()
+        assert self._factions is not None
+        return self._factions
+
+    def initialize(self) -> None:
+        if self._factions is None:
+            self._factions = self.load_factions()
+
+    @classmethod
+    def load_factions(cls: Type[FactionLoader]) -> Dict[str, Faction]:
+        files = [f for f in FACTION_DIRECTORY.glob("*.json") if f.is_file()]
+        factions = {}
+
+        for f in files:
+            try:
+                with f.open("r", encoding="utf-8") as fdata:
+                    data = json.load(fdata, encoding="utf-8")
+                    factions[data["name"]] = Faction.from_json(data)
+                    logging.info("Loaded faction : " + str(f))
+            except Exception:
+                logging.exception(f"Unable to load faction : {f}")
+
+        return factions
+
+    def __getitem__(self, name: str) -> Faction:
+        return self.factions[name]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.factions.keys())

game/factions/france_1995.py

@@ -1,47 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-France_1995 = {
-    "country": "France",
-    "side": "blue",
-    "units": [
-        M_2000C,
-        Mirage_2000_5,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        SA342M,
-        SA342L,
-        SA342Mistral,
-
-        Armor.MBT_Leclerc,
-        Armor.TPz_Fuchs,  # Standing as VAB
-        Armor.APC_Cobra,  # Standing as VBL
-        Armor.ATGM_M1134_Stryker,  # Standing as VAB Mephisto
-        Artillery.SPH_M109_Paladin,  # Standing as AMX30 AuF1
-        Artillery.MLRS_M270,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Roland_ADS,
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.HQ_7_Self_Propelled_LN,  # Standing as Crotale
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-
-    ], "shorad": [
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.SAM_Roland_ADS
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/france_2005.py

@@ -1,62 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-France_2005 = {
-    "country": "France",
-    "side": "blue",
-    "units":[
-        M_2000C,
-        Mirage_2000_5,
-        FA_18C_hornet, # Standing as Rafale M
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        SA342M,
-        SA342L,
-        SA342Mistral,
-
-        Armor.MBT_Leclerc,
-        Armor.TPz_Fuchs, # Standing as VAB
-        Armor.APC_Cobra, # Standing as VBL
-        Armor.ATGM_M1134_Stryker, # Standing as VAB Mephisto
-        Artillery.SPH_M109_Paladin, # Standing as AMX30 AuF1
-        Artillery.MLRS_M270,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Roland_ADS,
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.HQ_7_Self_Propelled_LN, # Standing as Crotale
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-        
-    ], "shorad":[
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.SAM_Roland_ADS
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis, # Standing as CDG Aircraft Carrier
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa, # Standing as Mistral Class
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "PA Charles de Gaulle",
-    ], "lhanames": [
-        "L9013 Mistral",
-        "L9014 Tonerre",
-        "L9015 Dixmude"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/france_modded.py

@@ -1,80 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-import pydcs_extensions.frenchpack.frenchpack as frenchpack
-from pydcs_extensions.rafale.rafale import Rafale_M, Rafale_A_S
-
-France_2005_Modded = {
-    "country": "France",
-    "side": "blue",
-    "units": [
-        M_2000C,
-        Mirage_2000_5,
-        Rafale_M,
-        Rafale_A_S,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        SA342M,
-        SA342L,
-        SA342Mistral,
-
-        Armor.MBT_Leclerc,
-        Artillery.SPH_M109_Paladin,  # Standing as AMX30 AuF1
-        Artillery.MLRS_M270,
-
-        frenchpack.AMX_10RCR,
-        frenchpack.AMX_10RCR_SEPAR,
-        frenchpack.ERC_90,
-        frenchpack.TRM_2000_PAMELA,
-        frenchpack.VAB__50,
-        frenchpack.VAB_MEPHISTO,
-        frenchpack.VAB_T20_13,
-        frenchpack.VBL__50,
-        frenchpack.VBL_AANF1,
-        frenchpack.VBAE_CRAB,
-        frenchpack.VBAE_CRAB_MMP,
-        frenchpack.AMX_30B2,
-        frenchpack.Leclerc_Serie_XXI,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Roland_ADS,
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.HQ_7_Self_Propelled_LN,  # Standing as Crotale
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-
-    ], "shorad": [
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.SAM_Roland_ADS
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,  # Standing as CDG Aircraft Carrier
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,  # Standing as Mistral Class
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "PA Charles de Gaulle",
-    ], "lhanames": [
-        "L9013 Mistral",
-        "L9014 Tonerre",
-        "L9015 Dixmude"
-    ], "boat": [
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ], "requirements": {
-        "frenchpack V3.5": "https://forums.eagle.ru/showthread.php?t=279974",
-        "RAFALE 2.5.5": "https://www.digitalcombatsimulator.com/fr/files/3307478/",
-    }, "has_jtac": True
-}

game/factions/germany_1944.py

@@ -1,47 +0,0 @@
-from dcs.planes import *
-from dcs.vehicles import *
-
-from game.data.building_data import WW2_GERMANY_BUILDINGS
-from game.data.doctrine import WWII_DOCTRINE
-
-Germany_1944 = {
-    "country": "Third Reich",
-    "side": "red",
-    "units": [
-
-        FW_190A8,
-        FW_190D9,
-        Bf_109K_4,
-        Ju_88A4,
-
-        Armor.MT_Pz_Kpfw_V_Panther_Ausf_G,
-        Armor.MT_Pz_Kpfw_IV_Ausf_H,
-        Armor.HT_Pz_Kpfw_VI_Tiger_I,
-        Armor.HT_Pz_Kpfw_VI_Ausf__B__Tiger_II,
-        Armor.APC_Sd_Kfz_251,
-        Armor.IFV_Sd_Kfz_234_2_Puma,
-        Armor.Sd_Kfz_184_Elefant,
-        Armor.TD_Jagdpanther_G1,
-        Armor.TD_Jagdpanzer_IV,
-
-        Artillery.Sturmpanzer_IV_Brummbär,
-
-        Unarmed.Sd_Kfz_2,
-        Unarmed.Sd_Kfz_7,
-        Unarmed.Kübelwagen_82,
-
-        Infantry.Infantry_Mauser_98,
-        AirDefence.AAA_8_8cm_Flak_36,
-    ],"requirements":{
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "shorad": [
-        AirDefence.AAA_8_8cm_Flak_36,
-    ],
-    "objects": WW2_GERMANY_BUILDINGS,
-    "doctrine": WWII_DOCTRINE,
-    "boat": ["UBoatGroupGenerator", "SchnellbootGroupGenerator"],
-    "boat_count": 2,
-    "missiles": ["V1GroupGenerator"],
-    "missiles_count": 1
-}

game/factions/germany_1944_easy.py

@@ -1,40 +0,0 @@
-from dcs.planes import *
-from dcs.vehicles import *
-
-from game.data.building_data import WW2_GERMANY_BUILDINGS
-from game.data.doctrine import WWII_DOCTRINE
-
-Germany_1944_Easy = {
-    "country": "Third Reich",
-    "side": "red",
-    "units": [
-
-        FW_190A8,
-        FW_190D9,
-        Bf_109K_4,
-        Ju_88A4,
-
-        Armor.MT_Pz_Kpfw_IV_Ausf_H,
-        Armor.APC_Sd_Kfz_251,
-        Armor.IFV_Sd_Kfz_234_2_Puma,
-        Artillery.Sturmpanzer_IV_Brummbär,
-
-        Unarmed.Sd_Kfz_2,
-        Unarmed.Sd_Kfz_7,
-        Unarmed.Kübelwagen_82,
-
-        Infantry.Infantry_Mauser_98,
-        AirDefence.AAA_8_8cm_Flak_36,
-    ],"requirements":{
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "shorad":[
-        AirDefence.AAA_8_8cm_Flak_36,
-    ],
-    "objects": WW2_GERMANY_BUILDINGS,
-    "doctrine": WWII_DOCTRINE,
-    "boat": ["UBoatGroupGenerator", "SchnellbootGroupGenerator"],
-    "boat_count": 1,
-    "missiles": ["V1GroupGenerator"],
-    "missiles_count": 1
-}

game/factions/germany_1990.py

@@ -1,45 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Germany_1990 = {
-    "country": "Germany",
-    "side": "blue",
-    "units":[
-        MiG_29G,
-        Tornado_IDS,
-        F_4E,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        SA342M,
-        SA342L,
-
-        Armor.TPz_Fuchs,
-        Armor.MBT_Leopard_1A3,
-        Armor.MBT_Leopard_2,
-        Armor.IFV_Marder,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Roland_ADS,
-        AirDefence.SAM_Hawk_PCP,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
-    "shorad":[
-        AirDefence.SPAAA_Gepard,
-        AirDefence.SAM_Roland_ADS,
-    ], "boat":[
-        "OliverHazardPerryGroupGenerator"
-    ]
-}

game/factions/india_2010.py

@@ -1,55 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-India_2010 = {
-    "country": "India",
-    "side": "blue",
-    "units": [
-        Mirage_2000_5,
-        M_2000C,
-        MiG_27K,
-        MiG_21Bis,
-        MiG_29S,
-        Su_30,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        AH_64A,
-        Mi_8MT,
-
-        Armor.MBT_T_90,
-        Armor.MBT_T_72B,
-        Armor.IFV_BMP_2,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
-    "shorad":[
-        AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.AAA_ZU_23_Emplacement,
-        AirDefence.SPAAA_ZSU_23_4_Shilka,
-        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
-        AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_19_Tunguska_2S6
-    ], "aircraft_carrier": [
-        CV_1143_5_Admiral_Kuznetsov,
-    ], "destroyer": [
-        FSG_1241_1MP_Molniya,
-    ], "carrier_names": [
-        "INS Vikramaditya"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator", "MolniyaGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/insurgent.py

@@ -1,27 +0,0 @@
-from dcs.vehicles import *
-from dcs.ships import *
-from dcs.planes import *
-from dcs.helicopters import *
-
-Insurgent = {
-    "country": "Insurgents",
-    "side": "red",
-    "units": [
-
-        AirDefence.AAA_ZU_23_Insurgent_Closed,
-        AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
-
-        Armor.APC_Cobra,
-        Armor.APC_MTLB,
-        Armor.ARV_BRDM_2,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-        Infantry.Infantry_Soldier_Insurgents,
-        Infantry.Soldier_RPG,
-
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160
-    ]
-}

game/factions/insurgent_modded.py

@@ -1,33 +0,0 @@
-from dcs.ships import *
-from dcs.vehicles import *
-
-from pydcs_extensions.frenchpack.frenchpack import DIM__TOYOTA_BLUE, DIM__TOYOTA_DESERT, DIM__TOYOTA_GREEN, \
-    DIM__KAMIKAZE
-
-Insurgent_modded = {
-    "country": "Insurgents",
-    "side": "red",
-    "units": [
-
-        AirDefence.AAA_ZU_23_Insurgent_Closed,
-        AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
-
-        DIM__TOYOTA_BLUE,
-        DIM__TOYOTA_DESERT,
-        DIM__TOYOTA_GREEN,
-        DIM__KAMIKAZE,
-        Armor.ARV_BRDM_2,
-        Armor.APC_Cobra,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-        Infantry.Soldier_AK,
-        Infantry.Infantry_Soldier_Insurgents,
-
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160
-    ], "requirements": {
-        "frenchpack V3.5": "https://forums.eagle.ru/showthread.php?t=279974",
-    }
-}

game/factions/iran_2015.py

@@ -1,58 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Iran_2015 = {
-    "country": "Iran",
-    "side": "red",
-    "units": [
-
-        MiG_29A,
-        F_4E,
-        F_14B,
-        F_5E_3,
-
-        MiG_21Bis,
-        Su_24M,
-        Su_25,
-        Su_17M4,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        A_50,
-
-        Mi_28N,
-        Mi_24V,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_SA_2_LN_SM_90,
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
-
-        Armor.APC_M113,
-        Armor.APC_BTR_80,
-        Armor.MBT_M60A3_Patton,
-        Armor.MBT_T_72B,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-        Infantry.Soldier_AK,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160
-    ],
-    "shorad":[
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.AAA_ZU_23_Insurgent_Closed
-    ], "boat":[
-        "GrishaGroupGenerator", "MolniyaGroupGenerator", "KiloSubGroupGenerator"
-    ]
-}

game/factions/israel_1948.py

@@ -1,33 +0,0 @@
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Israel_1948 = {
-    "country": "Israel",
-    "side": "blue",
-    "units":[
-        SpitfireLFMkIXCW,
-        SpitfireLFMkIX,
-        P_51D,
-        P_51D_30_NA,
-        Bf_109K_4, # Standing as Avia S-199
-        B_17G,
-
-        Armor.MT_M4A4_Sherman_Firefly,
-        Armor.APC_M2A1,
-        Armor.MT_M4_Sherman,
-        Armor.LAC_M8_Greyhound,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_SMLE_No_4_Mk_1,
-
-        AirDefence.AAA_Bofors_40mm,
-        Armed_speedboat,
-    ],"requirements":{
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "shorad": [
-        AirDefence.AAA_Bofors_40mm
-    ], "boat": [
-    ], "has_jtac": False
-}

game/factions/israel_1973.py

@@ -1,112 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from pydcs_extensions.a4ec.a4ec import A_4E_C
-
-Israel_1973 = {
-    "country": "Israel",
-    "side": "blue",
-    "units":[
-        F_4E,
-        A_4E_C,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-
-        Armor.MT_M4A4_Sherman_Firefly,
-        Armor.APC_M2A1,
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.AAA_Bofors_40mm,
-        AirDefence.SAM_Chaparral_M48,
-
-        Armed_speedboat,
-    ], "requirements": {
-        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    }, "shorad": [
-        AirDefence.SAM_Chaparral_M48,
-        AirDefence.AAA_Bofors_40mm
-    ], "boat": [
-    ], "has_jtac": True
-}
-
-Israel_1973_NO_WW2_UNITS = {
-    "country": "Israel",
-    "side": "blue",
-    "units":[
-        F_4E,
-        A_4E_C,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Chaparral_M48,
-
-        Armed_speedboat,
-    ], "requirements": {
-        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
-    }, "shorad": [
-        AirDefence.SAM_Chaparral_M48,
-    ], "boat": [
-    ], "has_jtac": True
-}
-
-Israel_1982 = {
-    "country": "Israel",
-    "side": "blue",
-    "units":[
-        F_4E,
-        A_4E_C,
-        F_15C,
-        F_16A,
-        F_16C_50,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        AH_1W,
-
-        Armor.APC_M113,
-        Armor.MBT_M60A3_Patton,
-        Armor.MBT_Merkava_Mk__4,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Chaparral_M48,
-
-        Armed_speedboat,
-    ], "requirements": {
-        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
-    }, "shorad": [
-        AirDefence.SAM_Chaparral_M48,
-    ], "boat": [
-    ], "has_jtac": True
-}

game/factions/israel_2000.py

@@ -1,44 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Israel_2000 = {
-    "country": "Israel",
-    "side": "blue",
-    "units":[
-        F_16C_50,
-        F_15C,
-        F_15E,
-        F_4E,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        AH_1W,
-        AH_64D,
-
-        Armor.MBT_Merkava_Mk__4,
-        Armor.APC_M113,
-        Armor.APC_M1043_HMMWV_Armament,
-        Armor.ATGM_M1045_HMMWV_TOW,
-        Artillery.SPH_M109_Paladin,
-        Artillery.MLRS_M270,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_Patriot_EPP_III,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
-    "shorad": [
-        AirDefence.SAM_Avenger_M1097
-    ], "boat": [
-        "ArleighBurkeGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/italy_1990.py

@@ -1,48 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Italy_1990 = {
-     "country": "Italy",
-     "side": "blue",
-     "units": [
-         Tornado_IDS,
-         AV8BNA,
-         # MB339,
-
-         KC_135,
-         S_3B_Tanker,
-         C_130,
-         E_3A,
-
-         AH_1W,
-         UH_1H,
-
-         Armor.MBT_Leopard_1A3,  # OF-40 MBT
-         Armor.APC_M113,
-
-         Unarmed.Transport_M818,
-         Infantry.Infantry_M4,
-
-         AirDefence.SAM_Hawk_PCP,
-         AirDefence.SAM_Avenger_M1097,
-
-         CVN_74_John_C__Stennis,
-         LHA_1_Tarawa,
-         Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "lhanames": [
-        "Giuseppe Garibaldi",
-        "Cavour",
-    ], "boat":[
-        "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/italy_1990_mb339.py

@@ -1,52 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from pydcs_extensions.mb339.mb339 import MB_339PAN
-
-Italy_1990_MB339 = {
-     "country": "Italy",
-     "side": "blue",
-     "units": [
-         Tornado_IDS,
-         AV8BNA,
-         MB_339PAN,
-
-         KC_135,
-         S_3B_Tanker,
-         C_130,
-         E_3A,
-
-         AH_1W,
-         UH_1H,
-
-         Armor.MBT_Leopard_1A3,  # OF-40 MBT
-         Armor.APC_M113,
-
-         Unarmed.Transport_M818,
-         Infantry.Infantry_M4,
-
-         AirDefence.SAM_Hawk_PCP,
-         AirDefence.SAM_Avenger_M1097,
-
-         CVN_74_John_C__Stennis,
-         LHA_1_Tarawa,
-         Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "lhanames": [
-        "Giuseppe Garibaldi",
-        "Cavour",
-    ], "boat": [
-        "OliverHazardPerryGroupGenerator"
-    ], "requirements": {
-        "MB-339A": "http://www.freccetricolorivirtuali.net/",
-    }, "has_jtac": True
-}

game/factions/japan_2005.py

@@ -1,54 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Japan_2005 = {
-    "country": "Japan",
-    "side": "blue",
-    "units": [
-        F_15C,     # F-15J/DJ
-        F_16C_50,  # F-2A/B
-        F_4E,      # F-4EJ
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        AH_1W,
-        AH_64D,
-
-        Armor.MBT_Merkava_Mk__4,  # Standing as Type 10 MBT
-        Armor.MBT_M1A2_Abrams,    # Standing as Type 90 MBT
-        Armor.IFV_Marder,         # Standing as Type 89 IFV
-        Armor.TPz_Fuchs,          # Standing as Type 96 APC
-        Armor.IFV_LAV_25,         # Standing as Type 16 or Type 87
-        Armor.APC_M1043_HMMWV_Armament,
-
-        Artillery.MLRS_M270,
-        Artillery.SPH_M109_Paladin,  # Standing as Type 99 SPH
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Patriot_EPP_III,
-
-        LHA_1_Tarawa,
-    ], "shorad": [
-        AirDefence.SPAAA_Gepard,  # Type 87 SPAG
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa, # Standing as Hyuga-class helicopter carrier
-    ], "destroyer": [
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "lhanames": [
-        "Hyuga",
-        "Ise",
-    ], "boat":[
-        "ArleighBurkeGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/libya_2011.py

@@ -1,49 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.vehicles import *
-
-Libya_2011 = {
-    "country": "Libya",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_23MLD,
-        Su_24M,
-        Su_17M4,
-        Mi_24V,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-        A_50,
-
-        AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_2_LN_SM_90,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.HQ_7_Self_Propelled_LN,
-
-        Armor.IFV_BMP_1,
-        Armor.FDDM_Grad,
-        Armor.ARV_BRDM_2,
-        Armor.MBT_T_55,
-        Armor.MBT_T_72B,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Paratrooper_RPG_16,
-        Infantry.Infantry_Soldier_Insurgents
-
-    ],
-    "shorad":[
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.SAM_SA_8_Osa_9A33,
-    ], "boat": [
-        "GrishaGroupGenerator", "MolniyaGroupGenerator"
-    ]
-}

game/factions/netherlands_1990.py

@@ -1,38 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Netherlands_1990 = {
-    "country": "The Netherlands",
-    "side": "blue",
-    "units": [
-        F_16C_50,
-        F_5E_3,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        AH_64A,
-
-        Armor.APC_M113,
-        Armor.MBT_Leopard_1A3,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Avenger_M1097,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
-    "shorad": [
-        AirDefence.SAM_Avenger_M1097
-    ], "boat": [
-        "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/north_korea_2000.py

@@ -1,53 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-NorthKorea_2000 = {
-    "country": "North Korea",
-    "side": "red",
-    "units":[
-        MiG_29A,
-        Su_25,
-        MiG_15bis,
-        MiG_21Bis,
-        MiG_23MLD,
-        MiG_19P,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        A_50,
-
-        Mi_8MT,
-        Mi_24V,
-
-        Armor.MBT_T_55,
-        Armor.MBT_T_72B,
-        Armor.MBT_T_80U,
-        Armor.IFV_BMP_1,
-        Armor.APC_BTR_80,
-        Armor.ARV_BRDM_2,
-
-        Unarmed.Transport_M818,
-        Infantry.Soldier_AK,
-
-        AirDefence.SAM_SA_2_LN_SM_90,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160
-    ],
-    "shorad":[
-        AirDefence.AAA_ZU_23_Emplacement,
-        AirDefence.SPAAA_ZSU_23_4_Shilka
-    ],
-    "boat": [
-        "GrishaGroupGenerator", "MolniyaGroupGenerator"
-    ]
-}

game/factions/pakistan_2015.py

@@ -1,42 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Pakistan_2015 = {
-    "country": "Pakistan",
-    "side": "blue",
-    "units": [
-        JF_17,
-        F_16C_50,
-        MiG_21Bis, # Standing as J-7
-        MiG_19P, # Standing as J-6
-        IL_78M,
-        E_3A,
-
-        UH_1H,
-        AH_1W,
-
-        Armor.MBT_T_80U,
-        Armor.MBT_T_55, # Standing as Al-Zarrar / Type 59 MBT
-        Armor.ZBD_04A,
-        Armor.APC_BTR_80,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_SA_2_LN_SM_90,          # Standing as HQ-2
-        AirDefence.SAM_SA_10_S_300PS_LN_5P85C, # Standing as HQ-9
-
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.HQ_7_Self_Propelled_LN,
-        AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
-        AirDefence.AAA_ZU_23_Closed
-    ], "boat": [
-        "Type54GroupGenerator", "OliverHazardPerryGroupGenerator"
-    ],
-    "has_jtac": True,
-    "jtac_unit": WingLoong_I
-}

game/factions/private_miltary_companies.py

@@ -1,91 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from pydcs_extensions.mb339.mb339 import MB_339PAN
-
-PMC_WESTERN_A = {
-     "country": "USA",
-     "side": "blue",
-     "units": [
-         C_101CC,
-
-         UH_1H,
-         Mi_8MT,
-         OH_58D,
-         SA342M,
-
-         Armor.APC_M1043_HMMWV_Armament,
-         Armor.IFV_MCV_80,
-
-         Unarmed.Transport_M818,
-         Infantry.Infantry_M4,
-         Infantry.Soldier_M249,
-
-         AirDefence.SAM_Avenger_M1097,
-
-         Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "has_jtac": True
-}
-
-PMC_WESTERN_B = {
-     "country": "USA",
-     "side": "blue",
-     "units": [
-         MB_339PAN,
-         C_101CC,
-
-         UH_1H,
-         Mi_8MT,
-         OH_58D,
-         SA342M,
-
-         Armor.APC_M1043_HMMWV_Armament,
-         Armor.IFV_MCV_80,
-
-         Unarmed.Transport_M818,
-         Infantry.Infantry_M4,
-         Infantry.Soldier_M249,
-
-         AirDefence.SAM_Avenger_M1097,
-
-         Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "has_jtac": True,
-    "requirements": {
-        "MB-339A": "http://www.freccetricolorivirtuali.net/",
-    }
-}
-
-PMC_RUSSIAN = {
-     "country": "Russia",
-     "side": "blue",
-     "units": [
-         L_39C,
-         L_39ZA,
-
-         Mi_8MT,
-         Mi_24V,
-         Ka_50,
-
-         Armor.APC_Cobra,
-         Armor.APC_BTR_80,
-         Armor.ARV_BRDM_2,
-
-         Unarmed.Transport_Ural_375,
-         Infantry.Paratrooper_AKS,
-         Infantry.Paratrooper_RPG_16,
-
-         AirDefence.AAA_ZU_23_on_Ural_375,
-
-         Armed_speedboat,
-    ], "shorad":[
-        AirDefence.AAA_ZU_23_on_Ural_375,
-        AirDefence.AAA_ZU_23_Closed,
-    ], "has_jtac": True
-}
-

game/factions/russia_1955.py

@@ -1,38 +0,0 @@
-from dcs.planes import MiG_15bis, IL_76MD, IL_78M, An_26B, An_30M, Yak_40
-from dcs.ships import CV_1143_5_Admiral_Kuznetsov, Bulk_cargo_ship_Yakushev, Dry_cargo_ship_Ivanov, Tanker_Elnya_160
-from dcs.vehicles import AirDefence, Armor, Unarmed, Infantry, Artillery
-
-Russia_1955 = {
-    "country": "Russia",
-    "side": "red",
-    "units": [
-        MiG_15bis,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        AirDefence.AAA_ZU_23_Closed,
-        AirDefence.AAA_ZU_23_on_Ural_375,
-        Armor.ARV_BRDM_2,
-        Armor.FDDM_Grad,
-        Armor.APC_MTLB,
-        Armor.MBT_T_55,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-
-        # Infantry squad
-        Infantry.Paratrooper_AKS,
-        Infantry.Infantry_Soldier_Rus,
-        Infantry.Paratrooper_RPG_16,
-    ]
-}

game/factions/russia_1965.py

@@ -1,55 +0,0 @@
-from dcs.helicopters import Mi_8MT
-from dcs.planes import MiG_15bis, MiG_19P, MiG_21Bis, IL_76MD, IL_78M, An_26B, An_30M, Yak_40, A_50
-from dcs.ships import CV_1143_5_Admiral_Kuznetsov, Bulk_cargo_ship_Yakushev, Dry_cargo_ship_Ivanov, Tanker_Elnya_160
-from dcs.vehicles import AirDefence, Armor, Unarmed, Infantry, Artillery
-
-Russia_1965 = {
-    "country": "Russia",
-    "side": "red",
-    "units": [
-        MiG_15bis,
-        MiG_19P,
-        MiG_21Bis,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        A_50,
-
-        Mi_8MT,
-
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_2_LN_SM_90,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-
-        Armor.ARV_BRDM_2,
-        Armor.APC_BTR_80,
-        Armor.ARV_BTR_RD,
-        Armor.IFV_BMD_1,
-        Armor.IFV_BMP_1,
-        Armor.MBT_T_55,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-
-        # Infantry squad
-        Infantry.Paratrooper_AKS,
-        Infantry.Infantry_Soldier_Rus,
-        Infantry.Paratrooper_RPG_16,
-
-    ],
-    "shorad":[
-        AirDefence.AAA_ZU_23_Closed
-    ], "boat": [
-        "GrishaGroupGenerator"
-    ]
-}

game/factions/russia_1975.py

@@ -1,71 +0,0 @@
-from dcs.helicopters import Mi_8MT, Mi_24V
-from dcs.planes import MiG_21Bis, MiG_23MLD, MiG_25PD, MiG_29A, Su_17M4, Su_24M, Su_25, IL_76MD, IL_78M, An_26B, An_30M, \
-    Yak_40, A_50
-from dcs.ships import *
-from dcs.vehicles import AirDefence, Armor, Unarmed, Infantry, Artillery
-
-Russia_1975 = {
-    "country": "Russia",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_23MLD,
-        MiG_25PD,
-        MiG_29A,
-
-        Su_17M4,
-        Su_24M,
-        Su_25,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        A_50,
-
-        Mi_8MT,
-        Mi_24V,
-
-        AirDefence.AAA_ZU_23_Closed,
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-
-        Armor.ARV_BRDM_2,
-        Armor.APC_BTR_80,
-        Armor.IFV_BMD_1,
-        Armor.IFV_BMP_1,
-        Armor.MBT_T_55,
-
-        Artillery.SPH_2S9_Nona,
-        Artillery.SPH_2S1_Gvozdika,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-
-        # Infantry squad
-        Infantry.Paratrooper_AKS,
-        Infantry.Infantry_Soldier_Rus,
-        Infantry.Paratrooper_RPG_16,
-
-    ],
-    "shorad": [
-        AirDefence.AAA_ZU_23_Emplacement,
-        AirDefence.SPAAA_ZSU_23_4_Shilka
-    ], "aircraft_carrier": [
-        CV_1143_5_Admiral_Kuznetsov,
-    ], "destroyer": [
-        FF_1135M_Rezky,
-    ], "cruiser": [
-        CGN_1144_2_Pyotr_Velikiy,
-    ], "boat": [
-        "RussianNavyGroupGenerator", "KiloSubGroupGenerator", "MolniyaGroupGenerator"
-    ]
-}

game/factions/russia_1990.py

@@ -1,74 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Russia_1990 = {
-    "country": "Russia",
-    "side": "red",
-    "units": [
-
-        MiG_23MLD,
-        MiG_25PD,
-        MiG_29A,
-        MiG_29S,
-        MiG_31,
-        Su_27,
-
-        Su_24M,
-        Su_25,
-        Ka_50,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        A_50,
-
-        Mi_8MT,
-        Mi_24V,
-
-        AirDefence.AAA_ZU_23_Closed,
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-
-        Armor.ARV_BRDM_2,
-        Armor.APC_BTR_80,
-        Armor.IFV_BMD_1,
-        Armor.IFV_BMP_1,
-        Armor.MBT_T_55,
-        Artillery.MLRS_9K57_Uragan_BM_27,
-        Artillery.SPH_2S19_Msta,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-
-        # Infantry squad
-        Infantry.Paratrooper_AKS,
-        Infantry.Infantry_Soldier_Rus,
-        Infantry.Paratrooper_RPG_16,
-    ],
-    "shorad":[
-        AirDefence.SAM_SA_9_Strela_1_9P31,
-        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
-        AirDefence.SPAAA_ZSU_23_4_Shilka
-    ], "carrier_names": [
-        "Admiral Kuznetov",
-        "Admiral Gorshkov"
-    ], "aircraft_carrier": [
-        CV_1143_5_Admiral_Kuznetsov,
-    ], "destroyer": [
-        FF_1135M_Rezky,
-    ], "cruiser": [
-        FSG_1241_1MP_Molniya,
-    ], "boat":[
-        "RussianNavyGroupGenerator", "KiloSubGroupGenerator"
-    ]
-}

game/factions/russia_2010.py

@@ -1,77 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Russia_2010 = {
-    "country": "Russia",
-    "side": "red",
-    "units": [
-
-        Su_27,
-        Su_30,
-        Su_33,
-        MiG_29S,
-        MiG_31,
-
-        Su_25,
-        Su_25T,
-        Su_34,
-        Su_24M,
-        L_39ZA,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-        A_50,
-
-        Ka_50,
-        Mi_8MT,
-        Mi_24V,
-        Mi_28N,
-
-        AirDefence.SAM_SA_19_Tunguska_2S6,
-        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
-        AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
-
-        Armor.APC_BTR_80,
-        Armor.MBT_T_90,
-        Armor.MBT_T_80U,
-        Armor.MBT_T_72B,
-        Armor.IFV_BMP_1,
-        Armor.IFV_BMP_2,
-        Armor.IFV_BMP_3,
-
-        Artillery.MLRS_9K57_Uragan_BM_27,
-        Artillery.SPH_2S19_Msta,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-
-        # Infantry squad
-        Infantry.Paratrooper_AKS,
-        Infantry.Infantry_Soldier_Rus,
-        Infantry.Paratrooper_RPG_16,
-    ],
-    "shorad":[
-        AirDefence.SAM_SA_19_Tunguska_2S6,
-        AirDefence.SAM_SA_13_Strela_10M3_9A35M3
-    ], "aircraft_carrier": [
-        CV_1143_5_Admiral_Kuznetsov,
-    ], "carrier_names": [
-        "Admiral Kuznetov"
-    ], "destroyer": [
-        FF_1135M_Rezky,
-    ], "cruiser": [
-        FSG_1241_1MP_Molniya,
-    ], "boat": [
-        "RussianNavyGroupGenerator", "KiloSubGroupGenerator"
-    ]
-}

game/factions/spain_1990.py

@@ -1,50 +0,0 @@
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Spain_1990 = {
-    "country": "Spain",
-    "side": "blue",
-    "units": [
-        FA_18C_hornet,
-        AV8BNA,
-        F_5E_3,
-        C_101CC,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.MBT_Leopard_2,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Avenger_M1097,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis, # Standing as Principe de Asturias
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa, # Standing as Juan Carlos
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "Principe de Asturias",
-    ], "lhanames": [
-        "Juan Carlos I",
-    ], "boat":[
-        "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/sweden_1990.py

@@ -1,31 +0,0 @@
-from dcs.vehicles import *
-from dcs.ships import *
-from dcs.planes import *
-from dcs.helicopters import *
-
-Sweden_1990 = {
-    "country": "Sweden",
-    "side": "blue",
-    "units": [
-        AJS37,
-
-        UH_1H,
-
-        AirDefence.SAM_Hawk_PCP,
-
-        Armor.IFV_MCV_80, # Standing  as Strf 90
-        Armor.MBT_Leopard_2,
-        Armor.APC_M1126_Stryker_ICV, # Closest thing available
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-        Infantry.Soldier_AK,
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-    ],
-    "shorad": [
-        AirDefence.SAM_Avenger_M1097
-    ], "has_jtac": True
-}

game/factions/syria.py

@@ -1,267 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.vehicles import *
-
-Syria_2011 = {
-    "country": "Syria",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_23MLD,
-        MiG_25PD,
-        MiG_29S,
-
-        Su_17M4,
-        Su_24M,
-
-        L_39ZA,
-
-        Mi_24V,
-        Mi_8MT,
-        SA342M,
-        SA342L,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-        A_50,
-
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-        AirDefence.SAM_SA_2_LN_SM_90,
-        AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
-        AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
-
-        Armor.IFV_BMP_1,
-        Armor.IFV_BMP_2,
-        Armor.APC_BTR_80,
-        Armor.ARV_BRDM_2,
-        Armor.APC_MTLB,
-        Armor.APC_Cobra,
-        Armor.MBT_T_55,
-        Armor.MBT_T_72B,
-        Armor.MBT_T_90,
-        Artillery.MLRS_BM_21_Grad,
-        Artillery.MLRS_9K57_Uragan_BM_27,
-        Artillery.SPH_2S1_Gvozdika,
-        Artillery.SPH_2S9_Nona,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Paratrooper_RPG_16,
-        Infantry.Soldier_AK
-
-    ],
-    "shorad": [
-        AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
-        AirDefence.SAM_SA_9_Strela_1_9P31,
-        AirDefence.SAM_SA_19_Tunguska_2S6,
-        AirDefence.AAA_ZU_23_on_Ural_375,
-    ], "boat": [
-        "GrishaGroupGenerator", "MolniyaGroupGenerator"
-    ]
-}
-
-Syria_1973 = {
-    "country": "Syria",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_19P,
-        MiG_15bis,  # Standing as Mig-17
-
-        Su_17M4,  # Standing as Su-7
-        Mi_8MT,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-        AirDefence.SAM_SA_2_LN_SM_90,
-
-        Armor.IFV_BMP_1,
-        Armor.APC_MTLB,
-        Armor.MBT_T_55,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Paratrooper_RPG_16,
-        Infantry.Soldier_AK
-
-    ],
-    "shorad": [
-        AirDefence.AAA_ZU_23_on_Ural_375,
-    ], "boat": [
-        "GrishaGroupGenerator"
-    ]
-}
-
-
-Syria_1982 = {
-    "country": "Syria",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_23MLD,
-        MiG_25PD,
-        MiG_19P,
-
-        Su_17M4,  # Standing as Su-7
-        Mi_8MT,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        AirDefence.SAM_SA_6_Kub_LN_2P25,
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-        AirDefence.SAM_SA_2_LN_SM_90,
-
-        Armor.IFV_BMP_1,
-        Armor.APC_MTLB,
-        Armor.MBT_T_55,
-        Armor.MBT_T_72B,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Paratrooper_RPG_16,
-        Infantry.Soldier_AK
-
-    ],
-    "shorad": [
-        AirDefence.AAA_ZU_23_on_Ural_375,
-    ], "boat": [
-        "GrishaGroupGenerator"
-    ]
-}
-
-
-Syria_1967 = {
-    "country": "Syria",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_19P,
-        MiG_15bis,  # Standing as Mig-17
-
-        Su_17M4,  # Standing as Su-7
-        Mi_8MT,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        AirDefence.SAM_SA_2_LN_SM_90,
-
-        Armor.ARV_BRDM_2,
-        Armor.MBT_T_55,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Paratrooper_RPG_16,
-        Infantry.Soldier_AK
-
-    ],
-    "shorad": [
-        AirDefence.AAA_ZU_23_on_Ural_375,
-    ], "boat": [
-        "GrishaGroupGenerator"
-    ]
-}
-
-Syria_1967_WW2_Weapons = {
-    "country": "Syria",
-    "side": "red",
-    "units": [
-
-        MiG_21Bis,
-        MiG_19P,
-        MiG_15bis,  # Standing as Mig-17
-
-        Su_17M4,  # Standing as Su-7
-        Mi_8MT,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-
-        AirDefence.SAM_SA_2_LN_SM_90,
-
-        Armor.ARV_BRDM_2,
-        Armor.MBT_T_55,
-        Armor.MT_Pz_Kpfw_IV_Ausf_H,
-        Armor.StuG_III_Ausf__G,
-        Armor.TD_Jagdpanzer_IV,
-        Artillery.MLRS_BM_21_Grad,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Soldier_RPG,
-        Infantry.Soldier_AK
-
-    ], "requirements": {
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "shorad": [
-        AirDefence.AAA_ZU_23_on_Ural_375,
-    ], "boat": [
-        "GrishaGroupGenerator"
-    ]
-}
-
-Arab_Armies_1948 = {
-    "country": "Syria",
-    "side": "red",
-    "units": [
-        SpitfireLFMkIX,
-        SpitfireLFMkIXCW,
-
-        AirDefence.SAM_SA_2_LN_SM_90,
-
-        Armor.MT_M4_Sherman,
-        Armor.MT_Pz_Kpfw_IV_Ausf_H,
-        Armor.APC_Sd_Kfz_251,
-        Armor.IFV_Sd_Kfz_234_2_Puma,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-
-        Infantry.Infantry_SMLE_No_4_Mk_1,
-
-        AirDefence.AAA_8_8cm_Flak_36,
-
-    ], "requirements": {
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "shorad": [
-        AirDefence.AAA_8_8cm_Flak_36,
-    ], "boat": [
-        "GrishaGroupGenerator"
-    ]
-}

game/factions/turkey_2005.py

@@ -1,41 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Turkey_2005 = {
-    "country": "Turkey",
-    "side": "blue",
-    "units":[
-        F_16C_50,
-        F_4E,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        AH_1W,
-
-        Armor.MBT_Leopard_2,
-        Armor.MBT_Leopard_1A3,
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_Cobra,
-        Armor.APC_BTR_80,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.SAM_Avenger_M1097,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad":[
-        AirDefence.AAA_ZU_23_Emplacement,
-        AirDefence.SPAAA_ZSU_23_4_Shilka
-    ], "boat":[
-        "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/uae_2005.py

@@ -1,38 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-UAE_2005 = {
-    "country": "United Arab Emirates",
-    "side": "blue",
-    "units":[
-        M_2000C,
-        Mirage_2000_5,
-        F_16C_50,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        AH_64D,
-
-        Armor.MBT_Leclerc,
-        Armor.IFV_BMP_3,
-        Armor.TPz_Fuchs,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.Rapier_FSA_Launcher,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "boat":[
-        "OliverHazardPerryGroupGenerator"
-    ],
-    "has_jtac": True,
-    "jtac_unit": WingLoong_I
-}

game/factions/uk_1944.py

@@ -1,44 +0,0 @@
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from game.data.building_data import WW2_ALLIES_BUILDINGS
-from game.data.doctrine import WWII_DOCTRINE
-
-UK_1944 = {
-    "country": "UK",
-    "side": "blue",
-    "units": [
-        P_51D,
-        P_51D_30_NA,
-        P_47D_30,
-        SpitfireLFMkIX,
-        SpitfireLFMkIXCW,
-        A_20G,
-        B_17G,
-
-        Armor.MT_M4A4_Sherman_Firefly,
-        Armor.MT_M4_Sherman,
-        Armor.APC_M2A1,
-        Armor.CT_Cromwell_IV,
-        Armor.ST_Centaur_IV,
-        Armor.HIT_Churchill_VII,
-
-        Infantry.Infantry_SMLE_No_4_Mk_1,
-
-        LS_Samuel_Chase,
-        LST_Mk_II,
-        LCVP__Higgins_boat,
-
-        Unarmed.CCKW_353,
-        AirDefence.AAA_Bofors_40mm,
-    ], "shorad":[
-        AirDefence.AAA_Bofors_40mm,
-    ],"requirements":{
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "objects": WW2_ALLIES_BUILDINGS,
-    "doctrine": WWII_DOCTRINE,
-    "boat": ["WW2LSTGroupGenerator"],
-    "boat_count": 1
-}

game/factions/uk_1990.py

@@ -1,52 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-UnitedKingdom_1990 = {
-    "country": "UK",
-    "side": "blue",
-    "units":[
-        AV8BNA, # Standing as BAE Harrier 2
-        Tornado_GR4,
-        F_4E,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        SA342M,
-        AH_64A,
-
-        Armor.MBT_Challenger_II,
-        Armor.IFV_MCV_80,
-        Armor.APC_M1043_HMMWV_Armament,
-        Armor.ATGM_M1045_HMMWV_TOW,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.Rapier_FSA_Launcher,
-        AirDefence.SAM_Avenger_M1097, # Standing as Starstreak
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "lhanames": [
-        "HMS Invincible",
-        "HMS Illustrious",
-        "HMS Ark Royal",
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/ukraine_2010.py

@@ -1,53 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-Ukraine_2010 = {
-    "country": "Ukraine",
-    "side": "blue",
-    "units": [
-        Su_25,
-        Su_25T,
-        Su_24M,
-        Su_27,
-        MiG_29S,
-        L_39ZA,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-        A_50,
-
-        Mi_8MT,
-        Mi_24V,
-
-        AirDefence.SAM_SA_3_S_125_LN_5P73,
-        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
-        AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
-
-        Armor.APC_M1043_HMMWV_Armament,
-        Armor.IFV_BMP_3,
-        Armor.IFV_BMP_2,
-        Armor.APC_BTR_80,
-        Armor.MBT_T_80U,
-        Armor.MBT_T_72B,
-
-        Unarmed.Transport_Ural_375,
-        Unarmed.Transport_UAZ_469,
-        Infantry.Soldier_AK,
-        CV_1143_5_Admiral_Kuznetsov,
-        Bulk_cargo_ship_Yakushev,
-        Dry_cargo_ship_Ivanov,
-        Tanker_Elnya_160,
-    ],
-    "shorad":[
-        AirDefence.SAM_SA_19_Tunguska_2S6,
-        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
-        AirDefence.AAA_ZU_23_on_Ural_375
-    ], "boat":[
-        "GrishaGroupGenerator"
-    ]
-}

game/factions/us_aggressors.py

@@ -1,72 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-US_Aggressors = {
-    "country": "USAF Aggressors",
-    "side": "red",
-    "units": [
-
-        F_15C,
-        F_5E_3,
-        FA_18C_hornet,
-        F_16C_50,
-        Su_27,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        AH_64D,
-        Ka_50,
-        SA342M,
-        SA342L,
-
-        Armor.MBT_M1A2_Abrams,
-        Armor.MBT_Leopard_2,
-        Armor.ATGM_M1134_Stryker,
-        Armor.IFV_M2A2_Bradley,
-        Armor.APC_M1043_HMMWV_Armament,
-
-        Artillery.MLRS_M270,
-        Artillery.SPH_M109_Paladin,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Patriot_EPP_III,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.SAM_Avenger_M1097,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "CVN-71 Theodore Roosevelt",
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 George Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ]
-}

game/factions/usa_1944.py

@@ -1,86 +0,0 @@
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-from game.data.building_data import WW2_ALLIES_BUILDINGS
-from game.data.doctrine import WWII_DOCTRINE
-
-USA_1944 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-        P_51D,
-        P_51D_30_NA,
-        P_47D_30,
-        A_20G,
-        B_17G,
-
-        Armor.MT_M4_Sherman,
-        Armor.M30_Cargo_Carrier,
-        Armor.APC_M2A1,
-        Armor.LAC_M8_Greyhound,
-        Armor.TD_M10_GMC,
-        Artillery.M12_GMC,
-
-        Infantry.Infantry_M1_Garand,
-
-        LS_Samuel_Chase,
-        LST_Mk_II,
-        LCVP__Higgins_boat,
-
-        Unarmed.CCKW_353,
-        AirDefence.AAA_Bofors_40mm,
-    ], "shorad":[
-        AirDefence.AAA_Bofors_40mm,
-    ],"requirements":{
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "objects": WW2_ALLIES_BUILDINGS,
-    "doctrine": WWII_DOCTRINE,
-    "boat": ["WW2LSTGroupGenerator"],
-    "boat_count": 2
-}
-
-ALLIES_1944 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-        P_51D,
-        P_51D_30_NA,
-        P_47D_30,
-        SpitfireLFMkIX,
-        SpitfireLFMkIXCW,
-        A_20G,
-        B_17G,
-
-        Armor.MT_M4_Sherman,
-        Armor.MT_M4A4_Sherman_Firefly,
-        Armor.CT_Cromwell_IV,
-        Armor.M30_Cargo_Carrier,
-        Armor.APC_M2A1,
-        Armor.CT_Cromwell_IV,
-        Armor.ST_Centaur_IV,
-        Armor.HIT_Churchill_VII,
-        Armor.LAC_M8_Greyhound,
-        Armor.TD_M10_GMC,
-        Artillery.M12_GMC,
-
-        Infantry.Infantry_M1_Garand,
-        Infantry.Infantry_SMLE_No_4_Mk_1,
-
-        LS_Samuel_Chase,
-        LST_Mk_II,
-        LCVP__Higgins_boat,
-
-        Unarmed.CCKW_353,
-        AirDefence.AAA_Bofors_40mm,
-    ], "shorad":[
-        AirDefence.AAA_Bofors_40mm,
-    ],"requirements":{
-        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
-    },
-    "objects": WW2_ALLIES_BUILDINGS,
-    "doctrine": WWII_DOCTRINE,
-    "boat": ["WW2LSTGroupGenerator"],
-    "boat_count": 2
-}

game/factions/usa_1955.py

@@ -1,33 +0,0 @@
-from dcs.vehicles import *
-from dcs.ships import *
-from dcs.planes import *
-from dcs.helicopters import *
-
-USA_1955 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-        F_86F_Sabre,
-        P_51D,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        Armor.MT_M4A4_Sherman_Firefly,
-        Armor.MT_M4_Sherman,
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M2A1,
-        Armor.M30_Cargo_Carrier,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.AAA_Bofors_40mm,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ]
-}

game/factions/usa_1960.py

@@ -1,36 +0,0 @@
-from dcs.vehicles import *
-from dcs.ships import *
-from dcs.planes import *
-from dcs.helicopters import *
-
-USA_1960 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-        F_86F_Sabre,
-        P_51D,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.AAA_Vulcan_M163,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
-    "shorad":[
-        AirDefence.AAA_Vulcan_M163
-    ]
-}

game/factions/usa_1965.py

@@ -1,41 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-USA_1965 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-
-        F_5E_3,
-        F_4E,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        B_52H,
-
-        UH_1H,
-
-        Armor.MBT_M60A3_Patton,
-        Armor.APC_M113,
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Chaparral_M48,
-        AirDefence.SAM_Hawk_PCP,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
-    "shorad":[
-        AirDefence.AAA_Vulcan_M163,
-        AirDefence.SAM_Chaparral_M48
-    ], "boat":[
-    ]
-}

game/factions/usa_1990.py

@@ -1,65 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-USA_1990 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-        F_15C,
-        F_15E,
-        F_14B,
-        FA_18C_hornet,
-        F_16C_50,
-
-        A_10A,
-        AV8BNA,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        AH_64A,
-
-        Armor.MBT_M1A2_Abrams,
-        Armor.IFV_LAV_25,
-        Armor.APC_M1043_HMMWV_Armament,
-        Armor.ATGM_M1045_HMMWV_TOW,
-        Armor.ATGM_M1134_Stryker,
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad":[
-        AirDefence.SAM_Avenger_M1097,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        Oliver_Hazzard_Perry_class,
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 Georges Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
-    ], "has_jtac": True
-}

game/factions/usa_2005.py

@@ -1,73 +0,0 @@
-from dcs.helicopters import *
-from dcs.planes import *
-from dcs.ships import *
-from dcs.vehicles import *
-
-USA_2005 = {
-    "country": "USA",
-    "side": "blue",
-    "units": [
-        F_15C,
-        F_15E,
-        F_14B,
-        FA_18C_hornet,
-        F_16C_50,
-        A_10C,
-        A_10C_2,
-        AV8BNA,
-        MQ_9_Reaper,
-
-        KC_135,
-        KC130,
-        C_130,
-        E_3A,
-
-        UH_1H,
-        AH_64D,
-
-        Armor.MBT_M1A2_Abrams,
-        Armor.ATGM_M1134_Stryker,
-        Armor.APC_M1126_Stryker_ICV,
-        Armor.IFV_M2A2_Bradley,
-        Armor.IFV_LAV_25,
-        Armor.APC_M1043_HMMWV_Armament,
-        Armor.ATGM_M1045_HMMWV_TOW,
-
-        Artillery.MLRS_M270,
-        Artillery.SPH_M109_Paladin,
-
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-        Infantry.Soldier_M249,
-
-        AirDefence.SAM_Hawk_PCP,
-        AirDefence.SAM_Patriot_EPP_III,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ], "shorad": [
-        AirDefence.SAM_Avenger_M1097,
-    ], "aircraft_carrier": [
-        CVN_74_John_C__Stennis,
-    ], "helicopter_carrier": [
-        LHA_1_Tarawa,
-    ], "destroyer": [
-        USS_Arleigh_Burke_IIa,
-    ], "cruiser": [
-        Ticonderoga_class,
-    ], "carrier_names": [
-        "CVN-71 Theodore Roosevelt",
-        "CVN-72 Abraham Lincoln",
-        "CVN-73 George Washington",
-        "CVN-74 John C. Stennis",
-    ], "lhanames": [
-        "LHA-1 Tarawa",
-        "LHA-2 Saipan",
-        "LHA-3 Belleau Wood",
-        "LHA-4 Nassau",
-        "LHA-5 Peleliu"
-    ], "boat":[
-        "ArleighBurkeGroupGenerator"
-    ], "has_jtac": True
-}

game/game.py

@@ -1,11 +1,38 @@
-from datetime import datetime, timedelta
+import itertools
+import logging
+import random
+import sys
+from datetime import date, datetime, timedelta
+from enum import Enum
+from typing import Dict, List
 
-from game.db import REWARDS, PLAYER_BUDGET_BASE, sys
+from dcs.action import Coalition
+from dcs.mapping import Point
+from dcs.task import CAP, CAS, PinpointStrike
+from dcs.vehicles import AirDefence
+
+from game import db
+from game.db import PLAYER_BUDGET_BASE, REWARDS
+from game.inventory import GlobalAircraftInventory
 from game.models.game_stats import GameStats
-from gen.flights.ai_flight_planner import FlightPlanner
+from game.plugins import LuaPluginManager
+from gen.ato import AirTaskingOrder
+from gen.conflictgen import Conflict
+from gen.flights.ai_flight_planner import CoalitionMissionPlanner
+from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.flights.flight import FlightType
 from gen.ground_forces.ai_ground_planner import GroundPlanner
-from .event import *
+from . import persistency
+from .debriefing import Debriefing
+from .event.event import Event, UnitsDeliveryEvent
+from .event.frontlineattack import FrontlineAttackEvent
+from .factions.faction import Faction
+from .infos.information import Information
+from .procurement import ProcurementAi
 from .settings import Settings
+from .theater import ConflictTheater, ControlPoint
+from .unitmap import UnitMap
+from .weather import Conditions, TimeOfDay
 
 COMMISION_UNIT_VARIETY = 4
 COMMISION_LIMITS_SCALE = 1.5
@@ -37,49 +64,71 @@ ENEMY_BASE_STRENGTH_RECOVERY = 0.05
 # cost of AWACS for single operation
 AWACS_BUDGET_COST = 4
 
-# Initial budget value
-PLAYER_BUDGET_INITIAL = 650
-
 # Bonus multiplier logarithm base
 PLAYER_BUDGET_IMPORTANCE_LOG = 2
 
+class TurnState(Enum):
+    WIN = 0
+    LOSS = 1
+    CONTINUE = 2
 
 class Game:
-    settings = None  # type: Settings
-    budget = PLAYER_BUDGET_INITIAL
-    events = None  # type: typing.List[Event]
-    pending_transfers = None  # type: typing.Dict[]
-    ignored_cps = None  # type: typing.Collection[ControlPoint]
-    turn = 0
-    game_stats: GameStats = None
-
-    current_unit_id = 0
-    current_group_id = 0
-
-    def __init__(self, player_name: str, enemy_name: str, theater: ConflictTheater, start_date: datetime, settings):
+    def __init__(self, player_name: str, enemy_name: str,
+                 theater: ConflictTheater, start_date: datetime,
+                 settings: Settings, player_budget: int,
+                 enemy_budget: int) -> None:
         self.settings = settings
-        self.events = []
+        self.events: List[Event] = []
         self.theater = theater
         self.player_name = player_name
-        self.player_country = db.FACTIONS[player_name]["country"]
+        self.player_country = db.FACTIONS[player_name].country
         self.enemy_name = enemy_name
-        self.enemy_country = db.FACTIONS[enemy_name]["country"]
+        self.enemy_country = db.FACTIONS[enemy_name].country
         self.turn = 0
-        self.date = datetime(start_date.year, start_date.month, start_date.day)
+        self.date = date(start_date.year, start_date.month, start_date.day)
         self.game_stats = GameStats()
         self.game_stats.update(self)
-        self.planners = {}
-        self.ground_planners = {}
+        self.ground_planners: Dict[int, GroundPlanner] = {}
         self.informations = []
         self.informations.append(Information("Game Start", "-" * 40, 0))
-        self.__culling_points = self.compute_conflicts_position()
-        self.__frontlineData = []
-        self.__destroyed_units = []
-        self.jtacs = []
+        self.__culling_points: List[Point] = []
+        self.__destroyed_units: List[str] = []
         self.savepath = ""
+        self.budget = player_budget
+        self.enemy_budget = enemy_budget
+        self.current_unit_id = 0
+        self.current_group_id = 0
+
+        self.conditions = self.generate_conditions()
+
+        self.blue_ato = AirTaskingOrder()
+        self.red_ato = AirTaskingOrder()
+
+        self.aircraft_inventory = GlobalAircraftInventory(
+            self.theater.controlpoints
+        )
+
+        for cp in self.theater.controlpoints:
+            cp.pending_unit_deliveries = self.units_delivery_event(cp)
 
         self.sanitize_sides()
 
+        self.on_load()
+
+        # Turn 0 procurement. We don't actually have any missions to plan, but
+        # the planner will tell us what it would like to plan so we can use that
+        # to drive purchase decisions.
+        blue_planner = CoalitionMissionPlanner(self, is_player=True)
+        blue_planner.plan_missions()
+
+        red_planner = CoalitionMissionPlanner(self, is_player=False)
+        red_planner.plan_missions()
+
+        self.plan_procurement(blue_planner, red_planner)
+
+    def generate_conditions(self) -> Conditions:
+        return Conditions.generate(self.theater, self.date,
+                                   self.current_turn_time_of_day, self.settings)
 
     def sanitize_sides(self):
         """
@@ -95,11 +144,11 @@ class Game:
                 self.enemy_country = "Russia"
 
     @property
-    def player_faction(self):
+    def player_faction(self) -> Faction:
         return db.FACTIONS[self.player_name]
 
     @property
-    def enemy_faction(self):
+    def enemy_faction(self) -> Faction:
         return db.FACTIONS[self.enemy_name]
 
     def _roll(self, prob, mult):
@@ -113,51 +162,35 @@ class Game:
         self.events.append(event_class(self, player_cp, enemy_cp, enemy_cp.position, self.player_name, self.enemy_name))
 
     def _generate_events(self):
-        for player_cp, enemy_cp in self.theater.conflicts(True):
-            self._generate_player_event(FrontlineAttackEvent, player_cp, enemy_cp)
-
-    def commision_unit_types(self, cp: ControlPoint, for_task: Task) -> typing.Collection[UnitType]:
-        importance_factor = (cp.importance - IMPORTANCE_LOW) / (IMPORTANCE_HIGH - IMPORTANCE_LOW)
-
-        if for_task == AirDefence and not self.settings.sams:
-            return [x for x in db.find_unittype(AirDefence, self.enemy_name) if x not in db.SAM_BAN]
-        else:
-            return db.choose_units(for_task, importance_factor, COMMISION_UNIT_VARIETY, self.enemy_name)
-
-    def _commision_units(self, cp: ControlPoint):
-        for for_task in [CAS, CAP, AirDefence]:
-            limit = COMMISION_LIMITS_FACTORS[for_task] * math.pow(cp.importance,
-                                                                  COMMISION_LIMITS_SCALE) * self.settings.multiplier
-            missing_units = limit - cp.base.total_units(for_task)
-            if missing_units > 0:
-                awarded_points = COMMISION_AMOUNTS_FACTORS[for_task] * math.pow(cp.importance,
-                                                                                COMMISION_AMOUNTS_SCALE) * self.settings.multiplier
-                points_to_spend = cp.base.append_commision_points(for_task, awarded_points)
-                if points_to_spend > 0:
-                    unittypes = self.commision_unit_types(cp, for_task)
-                    if len(unittypes) > 0:
-                        d = {random.choice(unittypes): points_to_spend}
-                        logging.info("Commision {}: {}".format(cp, d))
-                        cp.base.commision_units(d)
+        for front_line in self.theater.conflicts(True):
+            self._generate_player_event(FrontlineAttackEvent,
+                                        front_line.control_point_a,
+                                        front_line.control_point_b)
 
     @property
-    def budget_reward_amount(self):
-        reward = 0
-        if len(self.theater.player_points()) > 0:
-            reward = PLAYER_BUDGET_BASE * len(self.theater.player_points())
-            for cp in self.theater.player_points():
-                for g in cp.ground_objects:
-                    if g.category in REWARDS.keys():
-                        reward = reward + REWARDS[g.category]
-            return reward
-        else:
-            return reward
+    def budget_reward_amount(self) -> int:
+        reward = PLAYER_BUDGET_BASE * len(self.theater.player_points())
+        for cp in self.theater.player_points():
+            for g in cp.ground_objects:
+                if g.category in REWARDS.keys() and not g.is_dead:
+                    reward += REWARDS[g.category]
+        return int(reward * self.settings.player_income_multiplier)
 
-    def _budget_player(self):
+    def process_player_income(self):
         self.budget += self.budget_reward_amount
 
-    def awacs_expense_commit(self):
-        self.budget -= AWACS_BUDGET_COST
+    def process_enemy_income(self):
+        # TODO: Clean up save compat.
+        if not hasattr(self, "enemy_budget"):
+            self.enemy_budget = 0
+
+        production = 0.0
+        for enemy_point in self.theater.enemy_points():
+            for g in enemy_point.ground_objects:
+                if g.category in REWARDS.keys() and not g.is_dead:
+                    production = production + REWARDS[g.category]
+
+        self.enemy_budget += production * self.settings.enemy_income_multiplier
 
     def units_delivery_event(self, to_cp: ControlPoint) -> UnitsDeliveryEvent:
         event = UnitsDeliveryEvent(attacker_name=self.player_name,
@@ -168,20 +201,16 @@ class Game:
         self.events.append(event)
         return event
 
-    def units_delivery_remove(self, event: Event):
-        if event in self.events:
-            self.events.remove(event)
-
-    def initiate_event(self, event: Event):
+    def initiate_event(self, event: Event) -> UnitMap:
         #assert event in self.events
         logging.info("Generating {} (regular)".format(event))
-        event.generate()
+        return event.generate()
 
     def finish_event(self, event: Event, debriefing: Debriefing):
         logging.info("Finishing event {}".format(event))
         event.commit(debriefing)
-        if event.is_successfull(debriefing):
-            self.budget += event.bonus()
+        self.budget += int(event.bonus() *
+                           self.settings.player_income_multiplier)
 
         if event in self.events:
             self.events.remove(event)
@@ -192,13 +221,17 @@ class Game:
         if isinstance(event, Event):
             return event and event.attacker_name and event.attacker_name == self.player_name
         else:
-            return event and event.name and event.name == self.player_name
+            raise RuntimeError(f"{event} was passed when an Event type was expected")
 
-    def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint] = None):
+    def on_load(self) -> None:
+        LuaPluginManager.load_settings(self.settings)
+        ObjectiveDistanceCache.set_theater(self.theater)
+        self.compute_conflicts_position()
 
+    def pass_turn(self, no_action: bool = False) -> None:
         logging.info("Pass turn")
         self.informations.append(Information("End of turn #" + str(self.turn), "-" * 40, 0))
-        self.turn = self.turn + 1
+        self.turn += 1
 
         for event in self.events:
             if self.settings.version == "dev":
@@ -208,8 +241,12 @@ class Game:
             else:
                 event.skip()
 
-        self._enemy_reinforcement()
-        self._budget_player()
+        for control_point in self.theater.controlpoints:
+            control_point.process_turn()
+
+        self.process_enemy_income()
+
+        self.process_player_income()
 
         if not no_action and self.turn > 1:
             for cp in self.theater.player_points():
@@ -219,111 +256,87 @@ class Game:
                 if not cp.is_carrier and not cp.is_lha:
                     cp.base.affect_strength(-PLAYER_BASE_STRENGTH_RECOVERY)
 
-        self.ignored_cps = []
-        if ignored_cps:
-            self.ignored_cps = ignored_cps
+        self.conditions = self.generate_conditions()
 
-        self.events = []  # type: typing.List[Event]
+        self.initialize_turn()
+
+        # Autosave progress
+        persistency.autosave(self)
+
+    def check_win_loss(self):
+        captured_states = {i.captured for i in self.theater.controlpoints}
+        if True not in captured_states:
+            return TurnState.LOSS
+        if False not in captured_states:
+            return TurnState.WIN
+        return TurnState.CONTINUE
+
+    def initialize_turn(self) -> None:
+        self.events = []
         self._generate_events()
 
         # Update statistics
         self.game_stats.update(self)
 
-        # Plan flights & combat for next turn
-        self.__culling_points = self.compute_conflicts_position()
-        self.planners = {}
-        self.ground_planners = {}
+        self.aircraft_inventory.reset()
         for cp in self.theater.controlpoints:
-            if cp.has_runway():
-                planner = FlightPlanner(cp, self)
-                planner.plan_flights()
-                self.planners[cp.id] = planner
+            cp.pending_unit_deliveries = self.units_delivery_event(cp)
+            self.aircraft_inventory.set_from_control_point(cp)
 
+        # Check for win or loss condition
+        turn_state = self.check_win_loss()
+        if turn_state in (TurnState.LOSS,TurnState.WIN):
+            return self.process_win_loss(turn_state)
+
+        # Plan flights & combat for next turn
+        self.compute_conflicts_position()
+        self.ground_planners = {}
+        self.blue_ato.clear()
+        self.red_ato.clear()
+
+        blue_planner = CoalitionMissionPlanner(self, is_player=True)
+        blue_planner.plan_missions()
+
+        red_planner = CoalitionMissionPlanner(self, is_player=False)
+        red_planner.plan_missions()
+
+        for cp in self.theater.controlpoints:
             if cp.has_frontline:
                 gplanner = GroundPlanner(cp, self)
                 gplanner.plan_groundwar()
                 self.ground_planners[cp.id] = gplanner
 
-        # Autosave progress
-        persistency.autosave(self)
+        self.plan_procurement(blue_planner, red_planner)
 
-    def _enemy_reinforcement(self):
-        """
-        Compute and commision reinforcement for enemy bases
-        """
+    def plan_procurement(self, blue_planner: CoalitionMissionPlanner,
+                         red_planner: CoalitionMissionPlanner) -> None:
+        self.budget = ProcurementAi(
+            self,
+            for_player=True,
+            faction=self.player_faction,
+            manage_runways=self.settings.automate_runway_repair,
+            manage_front_line=self.settings.automate_front_line_reinforcements,
+            manage_aircraft=self.settings.automate_aircraft_reinforcements
+        ).spend_budget(self.budget, blue_planner.procurement_requests)
 
-        MAX_ARMOR = 30 * self.settings.multiplier
-        MAX_AIRCRAFT = 25 * self.settings.multiplier
+        self.enemy_budget = ProcurementAi(
+            self,
+            for_player=False,
+            faction=self.enemy_faction,
+            manage_runways=True,
+            manage_front_line=True,
+            manage_aircraft=True
+        ).spend_budget(self.enemy_budget, red_planner.procurement_requests)
 
-        production = 0.0
-        for enemy_point in self.theater.enemy_points():
-            for g in enemy_point.ground_objects:
-                if g.category in REWARDS.keys():
-                    production = production + REWARDS[g.category]
-
-        production = production * 0.75
-        budget_for_armored_units = production / 2
-        budget_for_aircraft = production / 2
-
-        potential_cp_armor = []
-        for cp in self.theater.enemy_points():
-            for cpe in cp.connected_points:
-                if cpe.captured and cp.base.total_armor < MAX_ARMOR:
-                    potential_cp_armor.append(cp)
-        if len(potential_cp_armor) == 0:
-            potential_cp_armor = self.theater.enemy_points()
-
-        i = 0
-        potential_units = [u for u in db.FACTIONS[self.enemy_name]["units"] if u in db.UNIT_BY_TASK[PinpointStrike]]
-
-        print("Enemy Recruiting")
-        print(potential_cp_armor)
-        print(budget_for_armored_units)
-        print(potential_units)
-
-        if len(potential_units) > 0 and len(potential_cp_armor) > 0:
-            while budget_for_armored_units > 0:
-                i = i + 1
-                if i > 50 or budget_for_armored_units <= 0:
-                    break
-                target_cp = random.choice(potential_cp_armor)
-                if target_cp.base.total_armor >= MAX_ARMOR:
-                    continue
-                unit = random.choice(potential_units)
-                price = db.PRICES[unit] * 2
-                budget_for_armored_units -= price * 2
-                target_cp.base.armor[unit] = target_cp.base.armor.get(unit, 0) + 2
-                info = Information("Enemy Reinforcement", unit.id + " x 2 at " + target_cp.name, self.turn)
-                print(str(info))
-                self.informations.append(info)
-
-        if budget_for_armored_units > 0:
-            budget_for_aircraft += budget_for_armored_units
-
-        potential_units = [u for u in db.FACTIONS[self.enemy_name]["units"] if
-                           u in db.UNIT_BY_TASK[CAS] or u in db.UNIT_BY_TASK[CAP]]
-        if len(potential_units) > 0 and len(potential_cp_armor) > 0:
-            while budget_for_aircraft > 0:
-                i = i + 1
-                if i > 50 or budget_for_aircraft <= 0:
-                    break
-                target_cp = random.choice(potential_cp_armor)
-                if target_cp.base.total_planes >= MAX_AIRCRAFT:
-                    continue
-                unit = random.choice(potential_units)
-                price = db.PRICES[unit] * 2
-                budget_for_aircraft -= price * 2
-                target_cp.base.aircraft[unit] = target_cp.base.aircraft.get(unit, 0) + 2
-                info = Information("Enemy Reinforcement", unit.id + " x 2 at " + target_cp.name, self.turn)
-                print(str(info))
-                self.informations.append(info)
+    def message(self, text: str) -> None:
+        self.informations.append(Information(text, turn=self.turn))
 
     @property
-    def current_turn_daytime(self):
-        return ["dawn", "day", "dusk", "night"][self.turn % 4]
+    def current_turn_time_of_day(self) -> TimeOfDay:
+        return list(TimeOfDay)[self.turn % 4]
 
     @property
-    def current_day(self):
+    def current_day(self) -> date:
         return self.date + timedelta(days=self.turn // 4)
 
     def next_unit_id(self):
@@ -348,10 +361,19 @@ class Game:
         points = []
 
         # By default, use the existing frontline conflict position
-        for conflict in self.theater.conflicts():
-            points.append(Conflict.frontline_position(self.theater, conflict[0], conflict[1])[0])
-            points.append(conflict[0].position)
-            points.append(conflict[1].position)
+        for front_line in self.theater.conflicts():
+            position = Conflict.frontline_position(front_line.control_point_a,
+                                                   front_line.control_point_b,
+                                                   self.theater)
+            points.append(position[0])
+            points.append(front_line.control_point_a.position)
+            points.append(front_line.control_point_b.position)
+
+        # If do_not_cull_carrier is enabled, add carriers as culling point
+        if self.settings.perf_do_not_cull_carrier:
+            for cp in self.theater.controlpoints:
+                if cp.is_carrier or cp.is_lha:
+                    points.append(cp.position)
 
         # If there is no conflict take the center point between the two nearest opposing bases
         if len(points) == 0:
@@ -371,12 +393,24 @@ class Game:
             if cpoint is not None:
                 points.append(cpoint)
 
+        packages = itertools.chain(self.blue_ato.packages,
+                                   self.red_ato.packages)
+        for package in packages:
+            if package.primary_task is FlightType.BARCAP:
+                # BARCAPs will be planned at most locations on smaller theaters,
+                # rendering culling fairly useless. BARCAP packages don't really
+                # need the ground detail since they're defensive. SAMs nearby
+                # are only interesting if there are enemies in the area, and if
+                # there are they won't be culled because of the enemy's mission.
+                continue
+            points.append(package.target.position)
+
         # Else 0,0, since we need a default value
         # (in this case this means the whole map is owned by the same player, so it is not an issue)
         if len(points) == 0:
             points.append(Point(0, 0))
 
-        return points
+        self.__culling_points = points
 
     def add_destroyed_units(self, data):
         pos = Point(data["x"], data["z"])
@@ -400,6 +434,13 @@ class Game:
                     return False
             return True
 
+    def get_culling_points(self):
+        """
+        Check culling points
+        :return: List of culling points
+        """
+        return self.__culling_points
+
     # 1 = red, 2 = blue
     def get_player_coalition_id(self):
         return 2
@@ -408,13 +449,19 @@ class Game:
         return 1
 
     def get_player_coalition(self):
-        return dcs.action.Coalition.Blue
+        return Coalition.Blue
 
     def get_enemy_coalition(self):
-        return dcs.action.Coalition.Red
+        return Coalition.Red
 
     def get_player_color(self):
         return "blue"
 
     def get_enemy_color(self):
-        return "red"
+        return "red"
+
+    def process_win_loss(self, turn_state: TurnState):
+        if turn_state is TurnState.WIN:
+            return self.message("Congratulations, you are victorious!  Start a new campaign to continue.")
+        elif turn_state is TurnState.LOSS:
+            return self.message("Game Over, you lose. Start a new campaign to continue.")

game/infos/information.py

@@ -1,3 +1,4 @@
+import datetime
 
 class Information():
 
@@ -5,7 +6,12 @@ class Information():
         self.title = title
         self.text = text
         self.turn = turn
+        self.timestamp = datetime.datetime.now()
 
     def __str__(self):
-        s = "[" + str(self.turn) + "] " + self.title + "\n" + self.text
-        return s
+        return '[{}][{}] {} {}'.format(
+            self.timestamp.strftime("%Y-%m-%d %H:%M:%S") if self.timestamp is not None else '',
+            self.turn,
+            self.title,
+            self.text
+        )

game/inventory.py

@@ -0,0 +1,129 @@
+"""Inventory management APIs."""
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Dict, Iterable, Iterator, Set, Tuple, TYPE_CHECKING, Type
+
+from dcs.unittype import FlyingType
+
+from gen.flights.flight import Flight
+
+if TYPE_CHECKING:
+    from game.theater import ControlPoint
+
+
+class ControlPointAircraftInventory:
+    """Aircraft inventory for a single control point."""
+
+    def __init__(self, control_point: ControlPoint) -> None:
+        self.control_point = control_point
+        self.inventory: Dict[Type[FlyingType], int] = defaultdict(int)
+
+    def add_aircraft(self, aircraft: Type[FlyingType], count: int) -> None:
+        """Adds aircraft to the inventory.
+
+        Args:
+            aircraft: The type of aircraft to add.
+            count: The number of aircraft to add.
+        """
+        self.inventory[aircraft] += count
+
+    def remove_aircraft(self, aircraft: Type[FlyingType], count: int) -> None:
+        """Removes aircraft from the inventory.
+
+        Args:
+            aircraft: The type of aircraft to remove.
+            count: The number of aircraft to remove.
+
+        Raises:
+            ValueError: The control point cannot fulfill the requested number of
+            aircraft.
+        """
+        available = self.inventory[aircraft]
+        if available < count:
+            raise ValueError(
+                f"Cannot remove {count} {aircraft.id} from "
+                f"{self.control_point.name}. Only have {available}."
+            )
+        self.inventory[aircraft] -= count
+
+    def available(self, aircraft: Type[FlyingType]) -> int:
+        """Returns the number of available aircraft of the given type.
+
+        Args:
+            aircraft: The type of aircraft to query.
+        """
+        try:
+            return self.inventory[aircraft]
+        except KeyError:
+            return 0
+
+    @property
+    def types_available(self) -> Iterator[Type[FlyingType]]:
+        """Iterates over all available aircraft types."""
+        for aircraft, count in self.inventory.items():
+            if count > 0:
+                yield aircraft
+
+    @property
+    def all_aircraft(self) -> Iterator[Tuple[Type[FlyingType], int]]:
+        """Iterates over all available aircraft types, including amounts."""
+        for aircraft, count in self.inventory.items():
+            if count > 0:
+                yield aircraft, count
+
+    def clear(self) -> None:
+        """Clears all aircraft from the inventory."""
+        self.inventory.clear()
+
+
+class GlobalAircraftInventory:
+    """Game-wide aircraft inventory."""
+    def __init__(self, control_points: Iterable[ControlPoint]) -> None:
+        self.inventories: Dict[ControlPoint, ControlPointAircraftInventory] = {
+            cp: ControlPointAircraftInventory(cp) for cp in control_points
+        }
+
+    def reset(self) -> None:
+        """Clears all control points and their inventories."""
+        for inventory in self.inventories.values():
+            inventory.clear()
+
+    def set_from_control_point(self, control_point: ControlPoint) -> None:
+        """Set the control point's aircraft inventory.
+
+        If the inventory for the given control point has already been set for
+        the turn, it will be overwritten.
+        """
+        inventory = self.inventories[control_point]
+        for aircraft, count in control_point.base.aircraft.items():
+            inventory.add_aircraft(aircraft, count)
+
+    def for_control_point(
+            self,
+            control_point: ControlPoint) -> ControlPointAircraftInventory:
+        """Returns the inventory specific to the given control point."""
+        return self.inventories[control_point]
+
+    @property
+    def available_types_for_player(self) -> Iterator[Type[FlyingType]]:
+        """Iterates over all aircraft types available to the player."""
+        seen: Set[Type[FlyingType]] = set()
+        for control_point, inventory in self.inventories.items():
+            if control_point.captured:
+                for aircraft in inventory.types_available:
+                    if not control_point.can_operate(aircraft):
+                        continue
+                    if aircraft not in seen:
+                        seen.add(aircraft)
+                        yield aircraft
+
+    def claim_for_flight(self, flight: Flight) -> None:
+        """Removes aircraft from the inventory for the given flight."""
+        inventory = self.for_control_point(flight.from_cp)
+        inventory.remove_aircraft(flight.unit_type, flight.count)
+
+    def return_from_flight(self, flight: Flight) -> None:
+        """Returns a flight's aircraft to the inventory."""
+        inventory = self.for_control_point(flight.from_cp)
+        inventory.add_aircraft(flight.unit_type, flight.count)

game/models/frontline_data.py

@@ -1,4 +1,4 @@
-from theater import ControlPoint
+from game.theater import ControlPoint
 
 
 class FrontlineData:

game/models/game_stats.py

@@ -1,3 +1,5 @@
+from typing import List
+
 class FactionTurnMetadata:
     """
     Store metadata about a faction
@@ -31,10 +33,8 @@ class GameStats:
     Store statistics for the current game
     """
 
-    data_per_turn: [GameTurnMetadata] = []
-
     def __init__(self):
-        self.data_per_turn = []
+        self.data_per_turn: List[GameTurnMetadata] = []
 
     def update(self, game):
         """

game/operation/frontlineattack.py

@@ -1,39 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-MAX_DISTANCE_BETWEEN_GROUPS = 12000
-
-
-class FrontlineAttackOperation(Operation):
-    interceptors = None  # type: db.AssignedUnitsDict
-    escort = None  # type: db.AssignedUnitsDict
-    strikegroup = None  # type: db.AssignedUnitsDict
-
-    attackers = None  # type: db.ArmorDict
-    defenders = None  # type: db.ArmorDict
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(FrontlineAttackOperation, self).prepare(terrain, is_quick)
-        if self.defender_name == self.game.player_name:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
-
-        conflict = Conflict.frontline_cas_conflict(
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            attacker=self.current_mission.country(self.attacker_country),
-            defender=self.current_mission.country(self.defender_country),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.briefinggen.title = "Frontline CAS"
-        self.briefinggen.description = "Provide CAS for the ground forces attacking enemy lines. Operation will be considered successful if total number of enemy units will be lower than your own by a factor of 1.5 (i.e. with 12 units from both sides, enemy forces need to be reduced to at least 8), meaning that you (and, probably, your wingmans) should concentrate on destroying the enemy units. Target base strength will be lowered as a result. Be advised that your flight will not attack anything until you explicitly tell them so by comms menu."
-        super(FrontlineAttackOperation, self).generate()

game/operation/operation.py

@@ -1,367 +1,224 @@
-from typing import Set
+from __future__ import annotations
+from game.theater.theatergroundobject import TheaterGroundObject
 
-from gen import *
-from gen.airfields import AIRFIELD_DATA
-from gen.beacons import load_beacons_for_terrain
-from gen.radios import RadioRegistry
-from gen.tacan import TacanRegistry
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable, List, Optional, Set
+
+from dcs import Mission
+from dcs.action import DoScript, DoScriptFile
+from dcs.coalition import Coalition
 from dcs.countries import country_dict
 from dcs.lua.parse import loads
-from dcs.terrain.terrain import Terrain
-from userdata.debriefing import *
+from dcs.mapping import Point
+from dcs.translation import String
+from dcs.triggers import TriggerStart
+from game.plugins import LuaPluginManager
+from gen import Conflict, FlightType, VisualGenerator
+from gen.aircraft import AIRCRAFT_DATA, AircraftConflictGenerator, FlightData
+from gen.airfields import AIRFIELD_DATA
+from gen.airsupportgen import AirSupport, AirSupportConflictGenerator
+from gen.armor import GroundConflictGenerator, JtacInfo
+from gen.beacons import load_beacons_for_terrain
+from gen.briefinggen import BriefingGenerator, MissionInfoGenerator
+from gen.environmentgen import EnvironmentGenerator
+from gen.forcedoptionsgen import ForcedOptionsGenerator
+from gen.groundobjectsgen import GroundObjectsGenerator
+from gen.kneeboard import KneeboardGenerator
+from gen.radios import RadioFrequency, RadioRegistry
+from gen.tacan import TacanRegistry
+from gen.triggergen import TRIGGER_RADIUS_MEDIUM, TriggersGenerator
+
+from .. import db
+from ..debriefing import Debriefing
+from ..theater import Airfield
+from ..unitmap import UnitMap
+
+if TYPE_CHECKING:
+    from game import Game
 
 
 class Operation:
-    attackers_starting_position = None  # type: db.StartingPosition
-    defenders_starting_position = None  # type: db.StartingPosition
-
-    current_mission = None  # type: dcs.Mission
-    regular_mission = None  # type: dcs.Mission
-    quick_mission = None  # type: dcs.Mission
-    conflict = None  # type: Conflict
-    armorgen = None  # type: ArmorConflictGenerator
+    """Static class for managing the final Mission generation"""
+    current_mission = None  # type: Mission
     airgen = None  # type: AircraftConflictGenerator
     triggersgen = None  # type: TriggersGenerator
     airsupportgen = None  # type: AirSupportConflictGenerator
     visualgen = None  # type: VisualGenerator
-    envgen = None  # type: EnvironmentGenerator
     groundobjectgen = None  # type: GroundObjectsGenerator
     briefinggen = None  # type: BriefingGenerator
     forcedoptionsgen = None  # type: ForcedOptionsGenerator
     radio_registry: Optional[RadioRegistry] = None
     tacan_registry: Optional[TacanRegistry] = None
-
+    game = None  # type: Game
     environment_settings = None
     trigger_radius = TRIGGER_RADIUS_MEDIUM
     is_quick = None
-    is_awacs_enabled = False
-    ca_slots = 0
+    player_awacs_enabled = True
+    #  TODO: #436 Generate Air Support for red
+    enemy_awacs_enabled = True
+    ca_slots = 1
+    unit_map: UnitMap
+    jtacs: List[JtacInfo] = []
+    plugin_scripts: List[str] = []
 
-    def __init__(self,
-                 game,
-                 attacker_name: str,
-                 defender_name: str,
-                 from_cp: ControlPoint,
-                 departure_cp: ControlPoint,
-                 to_cp: ControlPoint = None):
-        self.game = game
-        self.attacker_name = attacker_name
-        self.attacker_country = db.FACTIONS[attacker_name]["country"]
-        self.defender_name = defender_name
-        self.defender_country = db.FACTIONS[defender_name]["country"]
-        print(self.defender_country, self.attacker_country)
-        self.from_cp = from_cp
-        self.departure_cp = departure_cp
-        self.to_cp = to_cp
-        self.is_quick = False
-
-    def units_of(self, country_name: str) -> typing.Collection[UnitType]:
-        return []
-
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return True
-
-    @property
-    def is_player_attack(self) -> bool:
-        return self.from_cp.captured
-
-    def initialize(self, mission: Mission, conflict: Conflict):
-        self.current_mission = mission
-        self.conflict = conflict
-        self.radio_registry = RadioRegistry()
-        self.tacan_registry = TacanRegistry()
-        self.airgen = AircraftConflictGenerator(
-            mission, conflict, self.game.settings, self.game,
-            self.radio_registry)
-        self.airsupportgen = AirSupportConflictGenerator(
-            mission, conflict, self.game, self.radio_registry,
-            self.tacan_registry)
-        self.triggersgen = TriggersGenerator(mission, conflict, self.game)
-        self.visualgen = VisualGenerator(mission, conflict, self.game)
-        self.envgen = EnviromentGenerator(mission, conflict, self.game)
-        self.forcedoptionsgen = ForcedOptionsGenerator(mission, conflict, self.game)
-        self.groundobjectgen = GroundObjectsGenerator(
-            mission,
-            conflict,
-            self.game,
-            self.radio_registry,
-            self.tacan_registry
-        )
-        self.briefinggen = BriefingGenerator(mission, conflict, self.game)
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
+    @classmethod
+    def prepare(cls, game: Game):
         with open("resources/default_options.lua", "r") as f:
             options_dict = loads(f.read())["options"]
+        cls._set_mission(Mission(game.theater.terrain))
+        cls.game = game
+        cls._setup_mission_coalitions()
+        cls.current_mission.options.load_from_dict(options_dict)
 
-        self.current_mission = dcs.Mission(terrain)
+    @classmethod
+    def conflicts(cls) -> Iterable[Conflict]:
+        assert cls.game
+        for frontline in cls.game.theater.conflicts():
+            yield Conflict(
+                cls.game.theater,
+                frontline.control_point_a,
+                frontline.control_point_b,
+                cls.game.player_name,
+                cls.game.enemy_name,
+                cls.game.player_country,
+                cls.game.enemy_country,
+                frontline.position
+            )
+    
+    @classmethod
+    def air_conflict(cls) -> Conflict:
+        assert cls.game
+        player_cp, enemy_cp = cls.game.theater.closest_opposing_control_points()
+        mid_point = player_cp.position.point_from_heading(
+            player_cp.position.heading_between_point(enemy_cp.position),
+            player_cp.position.distance_to_point(enemy_cp.position) / 2
+        )
+        return Conflict(
+            cls.game.theater,
+            player_cp,
+            enemy_cp,
+            cls.game.player_name,
+            cls.game.enemy_name,
+            cls.game.player_country,
+            cls.game.enemy_country,
+            mid_point            
+        )
 
-        print(self.game.player_country)
-        print(country_dict[db.country_id_from_name(self.game.player_country)])
-        print(country_dict[db.country_id_from_name(self.game.player_country)]())
+    @classmethod
+    def _set_mission(cls, mission: Mission) -> None:
+        cls.current_mission = mission
 
-        # Setup coalition :
-        self.current_mission.coalition["blue"] = Coalition("blue")
-        self.current_mission.coalition["red"] = Coalition("red")
+    @classmethod
+    def _setup_mission_coalitions(cls):
+        cls.current_mission.coalition["blue"] = Coalition("blue")
+        cls.current_mission.coalition["red"] = Coalition("red")
 
-        p_country = self.game.player_country
-        e_country = self.game.enemy_country
-        self.current_mission.coalition["blue"].add_country(country_dict[db.country_id_from_name(p_country)]())
-        self.current_mission.coalition["red"].add_country(country_dict[db.country_id_from_name(e_country)]())
+        p_country = cls.game.player_country
+        e_country = cls.game.enemy_country
+        cls.current_mission.coalition["blue"].add_country(
+            country_dict[db.country_id_from_name(p_country)]())
+        cls.current_mission.coalition["red"].add_country(
+            country_dict[db.country_id_from_name(e_country)]())
 
-        print([c for c in self.current_mission.coalition["blue"].countries.keys()])
-        print([c for c in self.current_mission.coalition["red"].countries.keys()])
+    @classmethod
+    def inject_lua_trigger(cls, contents: str, comment: str) -> None:
+        trigger = TriggerStart(comment=comment)
+        trigger.add_action(DoScript(String(contents)))
+        cls.current_mission.triggerrules.triggers.append(trigger)
 
-        if is_quick:
-            self.quick_mission = self.current_mission
+    @classmethod
+    def bypass_plugin_script(cls, mnemonic: str) -> None:
+        cls.plugin_scripts.append(mnemonic)
+
+    @classmethod
+    def inject_plugin_script(cls, plugin_mnemonic: str, script: str,
+                             script_mnemonic: str) -> None:
+        if script_mnemonic in cls.plugin_scripts:
+            logging.debug(
+                f"Skipping already loaded {script} for {plugin_mnemonic}"
+            )
         else:
-            self.regular_mission = self.current_mission
+            cls.plugin_scripts.append(script_mnemonic)
 
-        self.current_mission.options.load_from_dict(options_dict)
-        self.is_quick = is_quick
+            plugin_path = Path("./resources/plugins", plugin_mnemonic)
 
-        if is_quick:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
-        else:
-            self.attackers_starting_position = self.departure_cp.at
-            self.defenders_starting_position = self.to_cp.at
+            script_path = Path(plugin_path, script)
+            if not script_path.exists():
+                logging.error(
+                    f"Cannot find {script_path} for plugin {plugin_mnemonic}"
+                )
+                return
 
-    def generate(self):
-        # Dedup beacon/radio frequencies, since some maps have some frequencies
-        # used multiple times.
-        beacons = load_beacons_for_terrain(self.game.theater.terrain.name)
+            trigger = TriggerStart(comment=f"Load {script_mnemonic}")
+            filename = script_path.resolve()
+            fileref = cls.current_mission.map_resource.add_resource_file(
+                filename)
+            trigger.add_action(DoScriptFile(fileref))
+            cls.current_mission.triggerrules.triggers.append(trigger)
+
+    @classmethod
+    def notify_info_generators(
+        cls,
+        groundobjectgen: GroundObjectsGenerator,
+        airsupportgen: AirSupportConflictGenerator,
+        jtacs: List[JtacInfo],
+        airgen: AircraftConflictGenerator,
+    ):
+        """Generates subscribed MissionInfoGenerator objects (currently kneeboards and briefings)
+        """
+        gens: List[MissionInfoGenerator] = [
+            KneeboardGenerator(cls.current_mission, cls.game),
+            BriefingGenerator(cls.current_mission, cls.game)
+        ]
+        for gen in gens:
+            for dynamic_runway in groundobjectgen.runways.values():
+                gen.add_dynamic_runway(dynamic_runway)
+
+            for tanker in airsupportgen.air_support.tankers:
+                gen.add_tanker(tanker)
+
+            if cls.player_awacs_enabled:
+                for awacs in airsupportgen.air_support.awacs:
+                    gen.add_awacs(awacs)
+
+            for jtac in jtacs:
+                gen.add_jtac(jtac)
+
+            for flight in airgen.flights:
+                gen.add_flight(flight)
+            gen.generate()
+
+    @classmethod
+    def create_unit_map(cls) -> None:
+        cls.unit_map = UnitMap()
+        for control_point in cls.game.theater.controlpoints:
+            if isinstance(control_point, Airfield):
+                cls.unit_map.add_airfield(control_point)
+
+    @classmethod
+    def create_radio_registries(cls) -> None:
         unique_map_frequencies: Set[RadioFrequency] = set()
-        for beacon in beacons:
-            unique_map_frequencies.add(beacon.frequency)
-            if beacon.is_tacan:
-                if beacon.channel is None:
-                    logging.error(
-                        f"TACAN beacon has no channel: {beacon.callsign}")
-                else:
-                    self.tacan_registry.reserve(beacon.tacan_channel)
-
-        for airfield, data in AIRFIELD_DATA.items():
-            if data.theater == self.game.theater.terrain.name:
-                unique_map_frequencies.add(data.atc.hf)
-                unique_map_frequencies.add(data.atc.vhf_fm)
-                unique_map_frequencies.add(data.atc.vhf_am)
-                unique_map_frequencies.add(data.atc.uhf)
-                # No need to reserve ILS or TACAN because those are in the
-                # beacon list.
+        cls._create_tacan_registry(unique_map_frequencies)
+        cls._create_radio_registry(unique_map_frequencies)
 
+        assert cls.radio_registry is not None
         for frequency in unique_map_frequencies:
-            self.radio_registry.reserve(frequency)
+            cls.radio_registry.reserve(frequency)
 
-        # Generate meteo
-        if self.environment_settings is None:
-            self.environment_settings = self.envgen.generate()
-        else:
-            self.envgen.load(self.environment_settings)
-
-        # Generate ground object first
-        self.groundobjectgen.generate()
-
-        # Generate destroyed units
-        for d in self.game.get_destroyed_units():
-            try:
-                utype = db.unit_type_from_name(d["type"])
-            except KeyError:
-                continue
-
-            pos = Point(d["x"], d["z"])
-            if utype is not None and not self.game.position_culled(pos) and self.game.settings.perf_destroyed_units:
-                self.current_mission.static_group(
-                    country=self.current_mission.country(self.game.player_country),
-                    name="",
-                    _type=utype,
-                    hidden=True,
-                    position=pos,
-                    heading=d["orientation"],
-                    dead=True,
-                )
-
-
-        # Air Support (Tanker & Awacs)
-        self.airsupportgen.generate(self.is_awacs_enabled)
-
-        # Generate Activity on the map
-        for cp in self.game.theater.controlpoints:
-            side = cp.captured
-            if side:
-                country = self.current_mission.country(self.game.player_country)
-            else:
-                country = self.current_mission.country(self.game.enemy_country)
-            if cp.id in self.game.planners.keys():
-                self.airgen.generate_flights(
-                    cp,
-                    country,
-                    self.game.planners[cp.id],
-                    self.groundobjectgen.runways
-                )
-
-        # Generate ground units on frontline everywhere
-        jtacs: List[JtacInfo] = []
-        for player_cp, enemy_cp in self.game.theater.conflicts(True):
-            conflict = Conflict.frontline_cas_conflict(self.attacker_name, self.defender_name,
-                                                       self.current_mission.country(self.attacker_country),
-                                                       self.current_mission.country(self.defender_country),
-                                                       player_cp, enemy_cp, self.game.theater)
-            # Generate frontline ops
-            player_gp = self.game.ground_planners[player_cp.id].units_per_cp[enemy_cp.id]
-            enemy_gp = self.game.ground_planners[enemy_cp.id].units_per_cp[player_cp.id]
-            groundConflictGen = GroundConflictGenerator(self.current_mission, conflict, self.game, player_gp, enemy_gp, player_cp.stances[enemy_cp.id])
-            groundConflictGen.generate()
-            jtacs.extend(groundConflictGen.jtacs)
-
-        # Setup combined arms parameters
-        self.current_mission.groundControl.pilot_can_control_vehicles = self.ca_slots > 0
-        if self.game.player_country in [country.name for country in self.current_mission.coalition["blue"].countries.values()]:
-            self.current_mission.groundControl.blue_tactical_commander = self.ca_slots
-        else:
-            self.current_mission.groundControl.red_tactical_commander = self.ca_slots
-
-        # Triggers
-        if self.game.is_player_attack(self.conflict.attackers_country):
-            cp = self.conflict.from_cp
-        else:
-            cp = self.conflict.to_cp
-        self.triggersgen.generate()
-
-        # Options
-        self.forcedoptionsgen.generate()
-
-        # Generate Visuals Smoke Effects
-        if self.game.settings.perf_smoke_gen:
-            self.visualgen.generate()
-
-        # Inject Plugins Lua Scripts
-        listOfPluginsScripts = []
-        plugin_file_path = Path("./resources/scripts/plugins/__plugins.lst")
-        if plugin_file_path.exists():
-            for line in plugin_file_path.read_text().splitlines():
-                name = line.strip()
-                if not name.startswith( '#' ):
-                    trigger = TriggerStart(comment="Load " + name)
-                    listOfPluginsScripts.append(name)
-                    fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/plugins/" + name)
-                    trigger.add_action(DoScriptFile(fileref))
-                    self.current_mission.triggerrules.triggers.append(trigger)
-        else:
-            logging.info(
-                f"Not loading plugins, {plugin_file_path} does not exist")
-
-        # Inject Mist Script if not done already in the plugins
-        if not "mist.lua" in listOfPluginsScripts and not "mist_4_3_74.lua" in listOfPluginsScripts: # don't load the script twice
-            trigger = TriggerStart(comment="Load Mist Lua framework")
-            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/mist_4_3_74.lua")
-            trigger.add_action(DoScriptFile(fileref))
-            self.current_mission.triggerrules.triggers.append(trigger)
-
-        # Inject JSON library if not done already in the plugins
-        if not "json.lua" in listOfPluginsScripts : # don't load the script twice
-            trigger = TriggerStart(comment="Load JSON Lua library")
-            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/json.lua")
-            trigger.add_action(DoScriptFile(fileref))
-            self.current_mission.triggerrules.triggers.append(trigger)
-
-        # Inject Ciribob's JTACAutoLase if not done already in the plugins
-        if not "JTACAutoLase.lua" in listOfPluginsScripts : # don't load the script twice
-            trigger = TriggerStart(comment="Load JTACAutoLase.lua script")
-            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/JTACAutoLase.lua")
-            trigger.add_action(DoScriptFile(fileref))
-            self.current_mission.triggerrules.triggers.append(trigger)
-
-        # set a LUA table with data from Liberation that we want to set
-        # at the moment it contains Liberation's install path, and an overridable definition for the JTACAutoLase function
-        # later, we'll add data about the units and points having been generated, in order to facilitate the configuration of the plugin lua scripts
-        state_location = "[[" + os.path.abspath("state.json") + "]]"
-        lua = """
-        -- setting configuration table
-        env.info("DCSLiberation|: setting configuration table")
-        
-        -- all data in this table is overridable.
-        dcsLiberation = {}
-        
-        -- the base location for state.json; if non-existent, it'll be replaced with LIBERATION_EXPORT_DIR, TEMP, or DCS working directory
-        dcsLiberation.installPath=""" + state_location + """
-        
-        -- you can override dcsLiberation.JTACAutoLase to make it use your own function ; it will be called with these parameters : ({jtac.unit_name}, {jtac.code}, {smoke}, 'vehicle') for all JTACs
-        if ctld then
-            dcsLiberation.JTACAutoLase=ctld.JTACAutoLase
-        elseif JTACAutoLase then
-            dcsLiberation.JTACAutoLase=JTACAutoLase
-        end
-        
-        -- later, we'll add more data to the table
-        --dcsLiberation.POIs = {}
-        --dcsLiberation.BASEs = {}
-        --dcsLiberation.JTACs = {}
-        """
-
-        trigger = TriggerStart(comment="Set DCS Liberation data")
-        trigger.add_action(DoScript(String(lua)))
-        self.current_mission.triggerrules.triggers.append(trigger)
-
-        # Inject DCS-Liberation script if not done already in the plugins
-        if not "dcs_liberation.lua" in listOfPluginsScripts : # don't load the script twice
-            trigger = TriggerStart(comment="Load DCS Liberation script")
-            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/dcs_liberation.lua")
-            trigger.add_action(DoScriptFile(fileref))
-            self.current_mission.triggerrules.triggers.append(trigger)
-
-        # add a configuration for JTACAutoLase and start lasing for all JTACs
-        smoke = "true"
-        if hasattr(self.game.settings, "jtac_smoke_on"):
-            if not self.game.settings.jtac_smoke_on:
-                smoke = "false"
-
-        lua = """
-        -- setting and starting JTACs
-        env.info("DCSLiberation|: setting and starting JTACs")
-        """
-
-        for jtac in jtacs:
-            lua += f"if dcsLiberation.JTACAutoLase then dcsLiberation.JTACAutoLase('{jtac.unit_name}', {jtac.code}, {smoke}, 'vehicle') end\n"
-
-        trigger = TriggerStart(comment="Start JTACs")
-        trigger.add_action(DoScript(String(lua)))
-        self.current_mission.triggerrules.triggers.append(trigger)
-
-        self.assign_channels_to_flights()
-
-        kneeboard_generator = KneeboardGenerator(self.current_mission)
-
-        for dynamic_runway in self.groundobjectgen.runways.values():
-            self.briefinggen.add_dynamic_runway(dynamic_runway)
-
-        for tanker in self.airsupportgen.air_support.tankers:
-            self.briefinggen.add_tanker(tanker)
-            kneeboard_generator.add_tanker(tanker)
-
-        if self.is_awacs_enabled:
-            for awacs in self.airsupportgen.air_support.awacs:
-                self.briefinggen.add_awacs(awacs)
-                kneeboard_generator.add_awacs(awacs)
-
-        for jtac in jtacs:
-            self.briefinggen.add_jtac(jtac)
-            kneeboard_generator.add_jtac(jtac)
-
-        for flight in self.airgen.flights:
-            self.briefinggen.add_flight(flight)
-            kneeboard_generator.add_flight(flight)
-
-        self.briefinggen.generate()
-        kneeboard_generator.generate()
-
-    def assign_channels_to_flights(self) -> None:
+    @classmethod
+    def assign_channels_to_flights(cls, flights: List[FlightData],
+                                   air_support: AirSupport) -> None:
         """Assigns preset radio channels for client flights."""
-        for flight in self.airgen.flights:
+        for flight in flights:
             if not flight.client_units:
                 continue
-            self.assign_channels_to_flight(flight)
+            cls.assign_channels_to_flight(flight, air_support)
 
-    def assign_channels_to_flight(self, flight: FlightData) -> None:
+    @staticmethod
+    def assign_channels_to_flight(flight: FlightData,
+                                  air_support: AirSupport) -> None:
         """Assigns preset radio channels for a client flight."""
         airframe = flight.aircraft_type
 
@@ -371,5 +228,344 @@ class Operation:
             logging.warning(f"No aircraft data for {airframe.id}")
             return
 
-        aircraft_data.channel_allocator.assign_channels_for_flight(
-            flight, self.airsupportgen.air_support)
+        if aircraft_data.channel_allocator is not None:
+            aircraft_data.channel_allocator.assign_channels_for_flight(
+                flight, air_support
+            )
+
+    @classmethod
+    def _create_tacan_registry(cls, unique_map_frequencies: Set[RadioFrequency]) -> None:
+        """
+        Dedup beacon/radio frequencies, since some maps have some frequencies
+        used multiple times.
+        """
+        cls.tacan_registry = TacanRegistry()
+        beacons = load_beacons_for_terrain(cls.game.theater.terrain.name)
+
+        for beacon in beacons:
+            unique_map_frequencies.add(beacon.frequency)
+            if beacon.is_tacan:
+                if beacon.channel is None:
+                    logging.error(
+                        f"TACAN beacon has no channel: {beacon.callsign}")
+                else:
+                    cls.tacan_registry.reserve(beacon.tacan_channel)
+
+    @classmethod
+    def _create_radio_registry(cls, unique_map_frequencies: Set[RadioFrequency]) -> None:
+        cls.radio_registry = RadioRegistry()
+        for data in AIRFIELD_DATA.values():
+            if data.theater == cls.game.theater.terrain.name and data.atc:
+                unique_map_frequencies.add(data.atc.hf)
+                unique_map_frequencies.add(data.atc.vhf_fm)
+                unique_map_frequencies.add(data.atc.vhf_am)
+                unique_map_frequencies.add(data.atc.uhf)
+                # No need to reserve ILS or TACAN because those are in the
+                # beacon list.
+
+    @classmethod
+    def _generate_ground_units(cls):
+        cls.groundobjectgen = GroundObjectsGenerator(
+            cls.current_mission,
+            cls.game,
+            cls.radio_registry,
+            cls.tacan_registry,
+            cls.unit_map
+        )
+        cls.groundobjectgen.generate()
+
+    @classmethod
+    def _generate_destroyed_units(cls) -> None:
+        """Add destroyed units to the Mission"""
+        for d in cls.game.get_destroyed_units():
+            try:
+                utype = db.unit_type_from_name(d["type"])
+            except KeyError:
+                continue
+
+            pos = Point(d["x"], d["z"])
+            if utype is not None and not cls.game.position_culled(pos) and cls.game.settings.perf_destroyed_units:
+                cls.current_mission.static_group(
+                    country=cls.current_mission.country(
+                        cls.game.player_country),
+                    name="",
+                    _type=utype,
+                    hidden=True,
+                    position=pos,
+                    heading=d["orientation"],
+                    dead=True,
+                )
+    
+    @classmethod
+    def generate(cls) -> UnitMap:
+        """Build the final Mission to be exported"""
+        cls.create_unit_map()
+        cls.create_radio_registries()
+        # Set mission time and weather conditions.
+        EnvironmentGenerator(cls.current_mission,
+                             cls.game.conditions).generate()
+        cls._generate_ground_units()
+        cls._generate_destroyed_units()
+        cls._generate_air_units()
+        cls.assign_channels_to_flights(cls.airgen.flights,
+                                        cls.airsupportgen.air_support)
+        cls._generate_ground_conflicts()
+
+        # Triggers
+        triggersgen = TriggersGenerator(cls.current_mission, cls.game)
+        triggersgen.generate()
+
+        # Setup combined arms parameters
+        cls.current_mission.groundControl.pilot_can_control_vehicles = cls.ca_slots > 0
+        if cls.game.player_country in [country.name for country in cls.current_mission.coalition["blue"].countries.values()]:
+            cls.current_mission.groundControl.blue_tactical_commander = cls.ca_slots
+        else:
+            cls.current_mission.groundControl.red_tactical_commander = cls.ca_slots
+
+        # Options
+        forcedoptionsgen = ForcedOptionsGenerator(
+            cls.current_mission, cls.game)
+        forcedoptionsgen.generate()
+
+        # Generate Visuals Smoke Effects
+        visualgen = VisualGenerator(cls.current_mission, cls.game)
+        if cls.game.settings.perf_smoke_gen:
+            visualgen.generate()
+
+        cls.generate_lua(cls.airgen, cls.airsupportgen, cls.jtacs)
+
+        # Inject Plugins Lua Scripts and data
+        cls.plugin_scripts.clear()
+        for plugin in LuaPluginManager.plugins():
+            if plugin.enabled:
+                plugin.inject_scripts(cls)
+                plugin.inject_configuration(cls)
+
+        cls.assign_channels_to_flights(cls.airgen.flights,
+                                        cls.airsupportgen.air_support)
+        cls.notify_info_generators(
+            cls.groundobjectgen,
+            cls.airsupportgen,
+            cls.jtacs,
+            cls.airgen
+        )
+
+        return cls.unit_map
+
+    @classmethod
+    def _generate_air_units(cls) -> None:
+        """Generate the air units for the Operation"""
+
+        # Air Support (Tanker & Awacs)
+        assert cls.radio_registry and cls.tacan_registry
+        cls.airsupportgen = AirSupportConflictGenerator(
+            cls.current_mission, cls.air_conflict(), cls.game, cls.radio_registry,
+            cls.tacan_registry)
+        cls.airsupportgen.generate()
+
+        # Generate Aircraft Activity on the map
+        cls.airgen = AircraftConflictGenerator(
+            cls.current_mission, cls.game.settings, cls.game,
+            cls.radio_registry, cls.unit_map)
+        cls.airgen.clear_parking_slots()
+
+        cls.airgen.generate_flights(
+            cls.current_mission.country(cls.game.player_country),
+            cls.game.blue_ato,
+            cls.groundobjectgen.runways
+        )
+        cls.airgen.generate_flights(
+            cls.current_mission.country(cls.game.enemy_country),
+            cls.game.red_ato,
+            cls.groundobjectgen.runways
+        )
+        cls.airgen.spawn_unused_aircraft(
+            cls.current_mission.country(cls.game.player_country),
+            cls.current_mission.country(cls.game.enemy_country))
+
+    @classmethod
+    def _generate_ground_conflicts(cls) -> None:
+        """For each frontline in the Operation, generate the ground conflicts and JTACs"""
+        for front_line in cls.game.theater.conflicts(True):
+            player_cp = front_line.control_point_a
+            enemy_cp = front_line.control_point_b
+            conflict = Conflict.frontline_cas_conflict(
+                cls.game.player_name,
+                cls.game.enemy_name,
+                cls.current_mission.country(cls.game.player_country),
+                cls.current_mission.country(cls.game.enemy_country),
+                player_cp,
+                enemy_cp,
+                cls.game.theater
+            )
+            # Generate frontline ops
+            player_gp = cls.game.ground_planners[player_cp.id].units_per_cp[enemy_cp.id]
+            enemy_gp = cls.game.ground_planners[enemy_cp.id].units_per_cp[player_cp.id]
+            ground_conflict_gen = GroundConflictGenerator(
+                cls.current_mission,
+                conflict, cls.game,
+                player_gp, enemy_gp,
+                player_cp.stances[enemy_cp.id],
+                cls.unit_map
+            )
+            ground_conflict_gen.generate()
+            cls.jtacs.extend(ground_conflict_gen.jtacs)
+
+    @classmethod
+    def generate_lua(cls, airgen: AircraftConflictGenerator,
+                     airsupportgen: AirSupportConflictGenerator,
+                     jtacs: List[JtacInfo]) -> None:
+        #  TODO: Refactor this
+        luaData = {
+            "AircraftCarriers": {},
+            "Tankers": {},
+            "AWACs": {},
+            "JTACs": {},
+            "TargetPoints": {},
+        }  # type: ignore
+
+        for tanker in airsupportgen.air_support.tankers:
+            luaData["Tankers"][tanker.callsign] = {
+                "dcsGroupName": tanker.dcsGroupName,
+                "callsign": tanker.callsign,
+                "variant": tanker.variant,
+                "radio": tanker.freq.mhz,
+                "tacan": str(tanker.tacan.number) + tanker.tacan.band.name
+            }
+
+        if airsupportgen.air_support.awacs:
+            for awacs in airsupportgen.air_support.awacs:
+                luaData["AWACs"][awacs.callsign] = {
+                    "dcsGroupName": awacs.dcsGroupName,
+                    "callsign": awacs.callsign,
+                    "radio": awacs.freq.mhz
+                }
+
+        for jtac in jtacs:
+            luaData["JTACs"][jtac.callsign] = {
+                "dcsGroupName": jtac.dcsGroupName,
+                "callsign": jtac.callsign,
+                "zone": jtac.region,
+                "dcsUnit": jtac.unit_name,
+                "laserCode": jtac.code
+            }
+
+        for flight in airgen.flights:
+            if flight.friendly and flight.flight_type in [FlightType.ANTISHIP,
+                                                          FlightType.DEAD,
+                                                          FlightType.SEAD,
+                                                          FlightType.STRIKE]:
+                flightType = str(flight.flight_type)
+                flightTarget = flight.package.target
+                if flightTarget:
+                    flightTargetName = None
+                    flightTargetType = None
+                    if isinstance(flightTarget, TheaterGroundObject):
+                        flightTargetName = flightTarget.obj_name
+                        flightTargetType = flightType + \
+                            f" TGT ({flightTarget.category})"
+                    elif hasattr(flightTarget, 'name'):
+                        flightTargetName = flightTarget.name
+                        flightTargetType = flightType + " TGT (Airbase)"
+                    luaData["TargetPoints"][flightTargetName] = {
+                        "name": flightTargetName,
+                        "type": flightTargetType,
+                        "position": {"x": flightTarget.position.x,
+                                     "y": flightTarget.position.y}
+                    }
+
+        # set a LUA table with data from Liberation that we want to set
+        # at the moment it contains Liberation's install path, and an overridable definition for the JTACAutoLase function
+        # later, we'll add data about the units and points having been generated, in order to facilitate the configuration of the plugin lua scripts
+        state_location = "[[" + os.path.abspath(".") + "]]"
+        lua = """
+        -- setting configuration table
+        env.info("DCSLiberation|: setting configuration table")
+
+        -- all data in this table is overridable.
+        dcsLiberation = {}
+
+        -- the base location for state.json; if non-existent, it'll be replaced with LIBERATION_EXPORT_DIR, TEMP, or DCS working directory
+        dcsLiberation.installPath=""" + state_location + """
+
+        """
+        # Process the tankers
+        lua += """
+
+        -- list the tankers generated by Liberation
+        dcsLiberation.Tankers = {
+        """
+        for key in luaData["Tankers"]:
+            data = luaData["Tankers"][key]
+            dcsGroupName = data["dcsGroupName"]
+            callsign = data["callsign"]
+            variant = data["variant"]
+            tacan = data["tacan"]
+            radio = data["radio"]
+            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', variant='{variant}', tacan='{tacan}', radio='{radio}' }}, \n"
+            # lua += f"    {{name='{dcsGroupName}', description='{callsign} ({variant})', information='Tacan:{tacan} Radio:{radio}' }}, \n"
+        lua += "}"
+
+        # Process the AWACSes
+        lua += """
+
+        -- list the AWACs generated by Liberation
+        dcsLiberation.AWACs = {
+        """
+        for key in luaData["AWACs"]:
+            data = luaData["AWACs"][key]
+            dcsGroupName = data["dcsGroupName"]
+            callsign = data["callsign"]
+            radio = data["radio"]
+            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', radio='{radio}' }}, \n"
+            # lua += f"    {{name='{dcsGroupName}', description='{callsign} (AWACS)', information='Radio:{radio}' }}, \n"
+        lua += "}"
+
+        # Process the JTACs
+        lua += """
+
+        -- list the JTACs generated by Liberation
+        dcsLiberation.JTACs = {
+        """
+        for key in luaData["JTACs"]:
+            data = luaData["JTACs"][key]
+            dcsGroupName = data["dcsGroupName"]
+            callsign = data["callsign"]
+            zone = data["zone"]
+            laserCode = data["laserCode"]
+            dcsUnit = data["dcsUnit"]
+            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', zone='{zone}', laserCode='{laserCode}', dcsUnit='{dcsUnit}' }}, \n"
+            # lua += f"    {{name='{dcsGroupName}', description='JTAC {callsign} ', information='Laser:{laserCode}', jtac={laserCode} }}, \n"
+        lua += "}"
+
+        # Process the Target Points
+        lua += """
+
+        -- list the target points generated by Liberation
+        dcsLiberation.TargetPoints = {
+        """
+        for key in luaData["TargetPoints"]:
+            data = luaData["TargetPoints"][key]
+            name = data["name"]
+            pointType = data["type"]
+            positionX = data["position"]["x"]
+            positionY = data["position"]["y"]
+            lua += f"    {{name='{name}', pointType='{pointType}', positionX='{positionX}', positionY='{positionY}' }}, \n"
+            # lua += f"    {{name='{pointType} {name}', point{{x={positionX}, z={positionY} }} }}, \n"
+        lua += "}"
+
+        lua += """
+
+        -- list the airbases generated by Liberation
+        -- dcsLiberation.Airbases = {}
+
+        -- list the aircraft carriers generated by Liberation
+        -- dcsLiberation.Carriers = {}
+
+        -- later, we'll add more data to the table
+
+        """
+
+        trigger = TriggerStart(comment="Set DCS Liberation data")
+        trigger.add_action(DoScript(String(lua)))
+        Operation.current_mission.triggerrules.triggers.append(trigger)

game/persistency.py

@@ -2,68 +2,58 @@ import logging
 import os
 import pickle
 import shutil
+from typing import Optional
 
-_dcs_saved_game_folder = None  # type: str
+_dcs_saved_game_folder: Optional[str] = None
 _file_abs_path = None
 
+
 def setup(user_folder: str):
     global _dcs_saved_game_folder
     _dcs_saved_game_folder = user_folder
     _file_abs_path = os.path.join(base_path(), "default.liberation")
 
+
 def base_path() -> str:
     global _dcs_saved_game_folder
     assert _dcs_saved_game_folder
     return _dcs_saved_game_folder
 
-def _save_file() -> str:
-    return os.path.join(base_path(), "default.liberation")
 
 def _temporary_save_file() -> str:
     return os.path.join(base_path(), "tmpsave.liberation")
 
+
 def _autosave_path() -> str:
     return os.path.join(base_path(), "autosave.liberation")
 
-def _save_file_exists() -> bool:
-    return os.path.exists(_save_file())
 
 def mission_path_for(name: str) -> str:
     return os.path.join(base_path(), "Missions", "{}".format(name))
 
 
-def restore_game():
-    if not _save_file_exists():
-        return None
-
-    with open(_save_file(), "rb") as f:
-        try:
-            save = pickle.load(f)
-            return save
-        except:
-            logging.error("Invalid Save game")
-            return None
-
 def load_game(path):
     with open(path, "rb") as f:
         try:
             save = pickle.load(f)
             save.savepath = path
             return save
-        except:
-            logging.error("Invalid Save game")
+        except Exception:
+            logging.exception("Invalid Save game")
             return None
 
+
 def save_game(game) -> bool:
     try:
         with open(_temporary_save_file(), "wb") as f:
             pickle.dump(game, f)
         shutil.copy(_temporary_save_file(), game.savepath)
         return True
-    except Exception as e:
-        logging.error(e)
+    except Exception:
+        logging.exception("Could not save game")
         return False
 
+
 def autosave(game) -> bool:
     """
     Autosave to the autosave location
@@ -74,7 +64,7 @@ def autosave(game) -> bool:
         with open(_autosave_path(), "wb") as f:
             pickle.dump(game, f)
         return True
-    except Exception as e:
-        logging.error(e)
+    except Exception:
+        logging.exception("Could not save game")
         return False
 

game/plugins/__init__.py

@@ -0,0 +1,2 @@
+from .luaplugin import LuaPlugin
+from .manager import LuaPluginManager

game/plugins/luaplugin.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import json
+import logging
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, TYPE_CHECKING, Type
+
+from game.settings import Settings
+
+if TYPE_CHECKING:
+    from game.operation.operation import Operation
+
+
+class LuaPluginWorkOrder:
+
+    def __init__(self, parent_mnemonic: str, filename: str, mnemonic: str,
+                 disable: bool) -> None:
+        self.parent_mnemonic = parent_mnemonic
+        self.filename = filename
+        self.mnemonic = mnemonic
+        self.disable = disable
+
+    def work(self, operation: Type[Operation]) -> None:
+        if self.disable:
+            operation.bypass_plugin_script(self.mnemonic)
+        else:
+            operation.inject_plugin_script(self.parent_mnemonic, self.filename,
+                                           self.mnemonic)
+
+
+class PluginSettings:
+    def __init__(self, identifier: str, enabled_by_default: bool) -> None:
+        self.identifier = identifier
+        self.enabled_by_default = enabled_by_default
+        self.settings = Settings()
+        self.initialize_settings()
+
+    def set_settings(self, settings: Settings):
+        self.settings = settings
+        self.initialize_settings()
+
+    def initialize_settings(self) -> None:
+        # Plugin options are saved in the game's Settings, but it's possible for
+        # plugins to change across loads. If new plugins are added or new
+        # options added to those plugins, initialize the new settings.
+        self.settings.initialize_plugin_option(self.identifier,
+                                               self.enabled_by_default)
+
+    @property
+    def enabled(self) -> bool:
+        return self.settings.plugin_option(self.identifier)
+
+    def set_enabled(self, enabled: bool) -> None:
+        self.settings.set_plugin_option(self.identifier, enabled)
+
+
+class LuaPluginOption(PluginSettings):
+    def __init__(self, identifier: str, name: str,
+                 enabled_by_default: bool) -> None:
+        super().__init__(identifier, enabled_by_default)
+        self.name = name
+
+
+@dataclass(frozen=True)
+class LuaPluginDefinition:
+    identifier: str
+    name: str
+    present_in_ui: bool
+    enabled_by_default: bool
+    options: List[LuaPluginOption]
+    work_orders: List[LuaPluginWorkOrder]
+    config_work_orders: List[LuaPluginWorkOrder]
+
+    @classmethod
+    def from_json(cls, name: str, path: Path) -> LuaPluginDefinition:
+        data = json.loads(path.read_text())
+
+        options = []
+        for option in data.get("specificOptions"):
+            option_id = option["mnemonic"]
+            options.append(LuaPluginOption(
+                identifier=f"{name}.{option_id}",
+                name=option.get("nameInUI", name),
+                enabled_by_default=option.get("defaultValue")
+            ))
+
+        work_orders = []
+        for work_order in data.get("scriptsWorkOrders"):
+            work_orders.append(LuaPluginWorkOrder(
+                name, work_order.get("file"), work_order["mnemonic"],
+                work_order.get("disable", False)
+            ))
+        config_work_orders = []
+        for work_order in data.get("configurationWorkOrders"):
+            config_work_orders.append(LuaPluginWorkOrder(
+                name, work_order.get("file"), work_order["mnemonic"],
+                work_order.get("disable", False)
+            ))
+
+        return cls(
+            identifier=name,
+            name=data["nameInUI"],
+            present_in_ui=not data.get("skipUI", False),
+            enabled_by_default=data.get("defaultValue", False),
+            options=options,
+            work_orders=work_orders,
+            config_work_orders=config_work_orders
+        )
+
+
+class LuaPlugin(PluginSettings):
+
+    def __init__(self, definition: LuaPluginDefinition) -> None:
+        self.definition = definition
+        super().__init__(self.definition.identifier,
+                         self.definition.enabled_by_default)
+
+    @property
+    def name(self) -> str:
+        return self.definition.name
+
+    @property
+    def show_in_ui(self) -> bool:
+        return self.definition.present_in_ui
+
+    @property
+    def options(self) -> List[LuaPluginOption]:
+        return self.definition.options
+
+    @classmethod
+    def from_json(cls, name: str, path: Path) -> Optional[LuaPlugin]:
+        try:
+            definition = LuaPluginDefinition.from_json(name, path)
+        except KeyError:
+            logging.exception("Required plugin configuration value missing")
+            return None
+
+        return cls(definition)
+
+    def set_settings(self, settings: Settings):
+        super().set_settings(settings)
+        for option in self.definition.options:
+            option.set_settings(self.settings)
+
+    def inject_scripts(self, operation: Type[Operation]) -> None:
+        for work_order in self.definition.work_orders:
+            work_order.work(operation)
+
+    def inject_configuration(self, operation: Type[Operation]) -> None:
+        # inject the plugin options
+        if self.options:
+            option_decls = []
+            for option in self.options:
+                enabled = str(option.enabled).lower()
+                name = option.identifier
+                option_decls.append(
+                    f"    dcsLiberation.plugins.{name} = {enabled}")
+
+            joined_options = "\n".join(option_decls)
+
+            lua = textwrap.dedent(f"""\
+                -- {self.identifier} plugin configuration.
+
+                if dcsLiberation then
+                    if not dcsLiberation.plugins then
+                        dcsLiberation.plugins = {{}}
+                    end
+                    dcsLiberation.plugins.{self.identifier} = {{}}
+                    {joined_options}
+                end
+
+            """)
+
+            operation.inject_lua_trigger(
+                lua, f"{self.identifier} plugin configuration")
+
+        for work_order in self.definition.config_work_orders:
+            work_order.work(operation)

game/plugins/manager.py

@@ -0,0 +1,50 @@
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from game.settings import Settings
+from game.plugins.luaplugin import LuaPlugin
+
+
+class LuaPluginManager:
+    _plugins_loaded = False
+    _plugins: Dict[str, LuaPlugin] = {}
+
+    @classmethod
+    def _load_plugins(cls) -> None:
+        plugins_path = Path("resources/plugins")
+
+        path = plugins_path / "plugins.json"
+        if not path.exists():
+            raise RuntimeError(f"{path} does not exist. Cannot continue.")
+
+        logging.info(f"Reading plugins list from {path}")
+
+        data = json.loads(path.read_text())
+        for name in data:
+            plugin_path = plugins_path / name / "plugin.json"
+            if not plugin_path.exists():
+                raise RuntimeError(
+                    f"Invalid plugin configuration: required plugin {name} "
+                    f"does not exist at {plugin_path}")
+            logging.info(f"Loading plugin {name} from {plugin_path}")
+            plugin = LuaPlugin.from_json(name, plugin_path)
+            if plugin is not None:
+                cls._plugins[name] = plugin
+        cls._plugins_loaded = True
+
+    @classmethod
+    def _get_plugins(cls) -> Dict[str, LuaPlugin]:
+        if not cls._plugins_loaded:
+            cls._load_plugins()
+        return cls._plugins
+
+    @classmethod
+    def plugins(cls) -> List[LuaPlugin]:
+        return list(cls._get_plugins().values())
+
+    @classmethod
+    def load_settings(cls, settings: Settings) -> None:
+        for plugin in cls.plugins():
+            plugin.set_settings(settings)

game/procurement.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+import random
+from typing import Iterator, List, Optional, TYPE_CHECKING, Type
+
+from dcs.task import CAP, CAS
+from dcs.unittype import FlyingType, UnitType, VehicleType
+
+from game import db
+from game.factions.faction import Faction
+from game.theater import ControlPoint, MissionTarget
+from gen.flights.ai_flight_planner_db import (
+    capable_aircraft_for_task,
+    preferred_aircraft_for_task,
+)
+from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.flights.flight import FlightType
+
+if TYPE_CHECKING:
+    from game import Game
+
+
+@dataclass(frozen=True)
+class AircraftProcurementRequest:
+    near: MissionTarget
+    range: int
+    task_capability: FlightType
+    number: int
+
+
+class ProcurementAi:
+    def __init__(self, game: Game, for_player: bool, faction: Faction,
+                 manage_runways: bool, manage_front_line: bool,
+                 manage_aircraft: bool) -> None:
+        self.game = game
+        self.is_player = for_player
+        self.faction = faction
+        self.manage_runways = manage_runways
+        self.manage_front_line = manage_front_line
+        self.manage_aircraft = manage_aircraft
+
+    def spend_budget(
+            self, budget: int,
+            aircraft_requests: List[AircraftProcurementRequest]) -> int:
+        if self.manage_runways:
+            budget = self.repair_runways(budget)
+        if self.manage_front_line:
+            armor_budget = math.ceil(budget / 2)
+            budget -= armor_budget
+            budget += self.reinforce_front_line(armor_budget)
+        if self.manage_aircraft:
+            budget = self.purchase_aircraft(budget, aircraft_requests)
+        return budget
+
+    def repair_runways(self, budget: int) -> int:
+        for control_point in self.owned_points:
+            if budget < db.RUNWAY_REPAIR_COST:
+                break
+            if control_point.runway_can_be_repaired:
+                control_point.begin_runway_repair()
+                budget -= db.RUNWAY_REPAIR_COST
+                if self.is_player:
+                    self.game.message(
+                        "OPFOR has begun repairing the runway at "
+                        f"{control_point}"
+                    )
+                else:
+                    self.game.message(
+                        "We have begun repairing the runway at "
+                        f"{control_point}"
+                    )
+        return budget
+
+    def random_affordable_ground_unit(
+            self, budget: int) -> Optional[Type[VehicleType]]:
+        affordable_units = [u for u in self.faction.frontline_units if
+                            db.PRICES[u] <= budget]
+        if not affordable_units:
+            return None
+        return random.choice(affordable_units)
+
+    def reinforce_front_line(self, budget: int) -> int:
+        if not self.faction.frontline_units:
+            return budget
+
+        while budget > 0:
+            candidates = self.front_line_candidates()
+            if not candidates:
+                break
+
+            cp = random.choice(candidates)
+            unit = self.random_affordable_ground_unit(budget)
+            if unit is None:
+                # Can't afford any more units.
+                break
+
+            budget -= db.PRICES[unit]
+            assert cp.pending_unit_deliveries is not None
+            cp.pending_unit_deliveries.deliver({unit: 1})
+
+        return budget
+
+    def _affordable_aircraft_of_types(
+            self, types: List[Type[FlyingType]], airbase: ControlPoint,
+            number: int, max_price: int) -> Optional[Type[FlyingType]]:
+        unit_pool = [u for u in self.faction.aircrafts if u in types]
+        affordable_units = [
+            u for u in unit_pool
+            if db.PRICES[u] * number <= max_price and airbase.can_operate(u)
+        ]
+        if not affordable_units:
+            return None
+        return random.choice(affordable_units)
+
+    def affordable_aircraft_for(
+            self, request: AircraftProcurementRequest,
+            airbase: ControlPoint, budget: int) -> Optional[Type[FlyingType]]:
+        aircraft = self._affordable_aircraft_of_types(
+            preferred_aircraft_for_task(request.task_capability),
+            airbase, request.number, budget)
+        if aircraft is not None:
+            return aircraft
+        return self._affordable_aircraft_of_types(
+            capable_aircraft_for_task(request.task_capability),
+            airbase, request.number, budget)
+
+    def purchase_aircraft(
+            self, budget: int,
+            aircraft_requests: List[AircraftProcurementRequest]) -> int:
+        unit_pool = [u for u in self.faction.aircrafts
+                     if u in db.UNIT_BY_TASK[CAS] or u in db.UNIT_BY_TASK[CAP]]
+        if not unit_pool:
+            return budget
+
+        for request in aircraft_requests:
+            for airbase in self.best_airbases_for(request):
+                unit = self.affordable_aircraft_for(request, airbase, budget)
+                if unit is None:
+                    # Can't afford any aircraft capable of performing the
+                    # required mission that can operate from this airbase. We
+                    # might be able to afford aircraft at other airbases though,
+                    # in the case where the airbase we attempted to use is only
+                    # able to operate expensive aircraft.
+                    continue
+
+                budget -= db.PRICES[unit] * request.number
+                assert airbase.pending_unit_deliveries is not None
+                airbase.pending_unit_deliveries.deliver({unit: request.number})
+
+        return budget
+
+    @property
+    def owned_points(self) -> List[ControlPoint]:
+        if self.is_player:
+            return self.game.theater.player_points()
+        else:
+            return self.game.theater.enemy_points()
+
+    def best_airbases_for(
+            self,
+            request: AircraftProcurementRequest) -> Iterator[ControlPoint]:
+        distance_cache = ObjectiveDistanceCache.get_closest_airfields(
+            request.near
+        )
+        for cp in distance_cache.airfields_within(request.range):
+            if not cp.is_friendly(self.is_player):
+                continue
+            if not cp.runway_is_operational():
+                continue
+            if cp.unclaimed_parking(self.game) < request.number:
+                continue
+            yield cp
+
+    def front_line_candidates(self) -> List[ControlPoint]:
+        candidates = []
+
+        # Prefer to buy front line units at active front lines that are not
+        # already overloaded.
+        for cp in self.owned_points:
+            if cp.base.total_armor >= 30:
+                # Control point is already sufficiently defended.
+                continue
+            for connected in cp.connected_points:
+                if not connected.is_friendly(to_player=self.is_player):
+                    candidates.append(cp)
+
+        if not candidates:
+            # Otherwise buy them anywhere valid.
+            candidates = [p for p in self.owned_points
+                          if p.can_deploy_ground_units]
+
+        return candidates

game/settings.py

@@ -1,43 +1,79 @@
+from dataclasses import dataclass, field
+from typing import Dict, Optional
 
+from dcs.forcedoptions import ForcedOptions
+
+
+@dataclass
 class Settings:
 
-    def __init__(self):
-        # Generator settings
-        self.inverted = False
-        self.do_not_generate_carrier = False # TODO : implement
-        self.do_not_generate_lha = False     # TODO : implement
-        self.do_not_generate_player_navy = True          # TODO : implement
-        self.do_not_generate_enemy_navy = True           # TODO : implement
+    # Difficulty settings
+    player_skill: str = "Good"
+    enemy_skill: str = "Average"
+    enemy_vehicle_skill: str = "Average"
+    map_coalition_visibility: ForcedOptions.Views = ForcedOptions.Views.All
+    labels: str = "Full"
+    only_player_takeoff: bool = True  # Legacy parameter do not use
+    night_disabled: bool = False
+    external_views_allowed: bool = True
+    supercarrier: bool = False
+    generate_marks: bool = True
+    manpads: bool = True
+    cold_start: bool = False  # Legacy parameter do not use
+    version: Optional[str] = None
+    player_income_multiplier: float = 1.0
+    enemy_income_multiplier: float = 1.0
 
-        # Difficulty settings
-        self.player_skill = "Good"
-        self.enemy_skill = "Average"
-        self.enemy_vehicle_skill = "Average"
-        self.map_coalition_visibility = "All Units"
-        self.labels = "Full"
-        self.only_player_takeoff = True  # Legacy parameter do not use
-        self.night_disabled = False
-        self.external_views_allowed = True
-        self.supercarrier = False
-        self.multiplier = 1
-        self.generate_marks = True
-        self.sams = True # Legacy parameter do not use
-        self.cold_start = False # Legacy parameter do not use
-        self.version = None
-        self.include_jtac_if_available = True
-        self.jtac_smoke_on = True
+    # Campaign management
+    automate_runway_repair: bool = False
+    automate_front_line_reinforcements: bool = False
+    automate_aircraft_reinforcements: bool = False
 
-        # Performance oriented
-        self.perf_red_alert_state = True
-        self.perf_smoke_gen = True
-        self.perf_artillery = True
-        self.perf_moving_units = True
-        self.perf_infantry = True
-        self.perf_ai_parking_start = True
-        self.perf_destroyed_units = True
+    # Performance oriented
+    perf_red_alert_state: bool = True
+    perf_smoke_gen: bool = True
+    perf_artillery: bool = True
+    perf_moving_units: bool = True
+    perf_infantry: bool = True
+    perf_ai_parking_start: bool = True
+    perf_destroyed_units: bool = True
 
-        # Performance culling
-        self.perf_culling = False
-        self.perf_culling_distance = 100
+    # Performance culling
+    perf_culling: bool = False
+    perf_culling_distance: int = 100
+    perf_do_not_cull_carrier = True
 
+    # LUA Plugins system
+    plugins: Dict[str, bool] = field(default_factory=dict)
 
+    # Cheating
+    show_red_ato: bool = False
+
+    never_delay_player_flights: bool = False
+
+    @staticmethod
+    def plugin_settings_key(identifier: str) -> str:
+        return f"plugins.{identifier}"
+
+    def initialize_plugin_option(self, identifier: str,
+                                 default_value: bool) -> None:
+        try:
+            self.plugin_option(identifier)
+        except KeyError:
+            self.set_plugin_option(identifier, default_value)
+
+    def plugin_option(self, identifier: str) -> bool:
+        return self.plugins[self.plugin_settings_key(identifier)]
+
+    def set_plugin_option(self, identifier: str, enabled: bool) -> None:
+        self.plugins[self.plugin_settings_key(identifier)] = enabled
+
+    def __setstate__(self, state) -> None:
+        # __setstate__ is called with the dict of the object being unpickled. We
+        # can provide save compatibility for new settings options (which
+        # normally would not be present in the unpickled object) by creating a
+        # new settings object, updating it with the unpickled state, and
+        # updating our dict with that.
+        new_state = Settings().__dict__
+        new_state.update(state)
+        self.__dict__.update(new_state)

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

@@ -1,14 +1,14 @@
-import logging
-import typing
-import math
 import itertools
+import logging
+import math
+import typing
+from typing import Dict, Type
 
-from dcs.planes import *
-from dcs.vehicles import *
-from dcs.task import *
+from dcs.task import CAP, CAS, Embarking, PinpointStrike, Task
+from dcs.unittype import FlyingType, UnitType, VehicleType
+from dcs.vehicles import AirDefence, Armor
 
 from game import db
-from gen import aaa
 
 STRENGTH_AA_ASSEMBLE_MIN = 0.2
 PLANES_SCRAMBLE_MIN_BASE = 2
@@ -20,21 +20,16 @@ BASE_MIN_STRENGTH = 0
 
 
 class Base:
-    aircraft = {}  # type: typing.Dict[PlaneType, int]
-    armor = {}  # type: typing.Dict[Armor, int]
-    aa = {}  # type: typing.Dict[AirDefence, int]
-    strength = 1  # type: float
-    commision_points = {}
 
     def __init__(self):
-        self.aircraft = {}
-        self.armor = {}
-        self.aa = {}
-        self.commision_points = {}
+        self.aircraft: Dict[Type[FlyingType], int] = {}
+        self.armor: Dict[Type[VehicleType], int] = {}
+        self.aa: Dict[AirDefence, int] = {}
+        self.commision_points: Dict[Type, float] = {}
         self.strength = 1
 
     @property
-    def total_planes(self) -> int:
+    def total_aircraft(self) -> int:
         return sum(self.aircraft.values())
 
     @property
@@ -55,17 +50,19 @@ class Base:
     def all_units(self):
         return itertools.chain(self.aircraft.items(), self.armor.items(), self.aa.items())
 
-    def _find_best_unit(self, dict, for_type: Task, count: int) -> typing.Dict:
+    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 dict.keys() if key in db.UNIT_BY_TASK[for_type]]
+        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 = {}
+        result: Dict[UnitType, int] = {}
         for unit_type in sorted_units:
-            existing_count = dict[unit_type]  # type: int
+            existing_count = available_units[unit_type]  # type: int
             if not existing_count:
                 continue
 
@@ -81,7 +78,7 @@ class Base:
         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]:
+    def _find_best_planes(self, for_type: Task, count: int) -> typing.Dict[FlyingType, 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]:
@@ -116,8 +113,10 @@ class Base:
             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
+            if target_dict is not None:
+                target_dict[unit_type] = target_dict.get(unit_type, 0) + unit_count
+            else:
+                logging.error("Unable to determine target dict for " + str(unit_type))
 
     def commit_losses(self, units_lost: typing.Dict[typing.Any, int]):
 
@@ -146,11 +145,14 @@ class Base:
         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 = self.total_aircraft
 
         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)
@@ -162,18 +164,18 @@ class Base:
         # 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]:
+    def scramble_sweep(self, multiplier: float) -> typing.Dict[FlyingType, 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))
+        return self._find_best_planes(CAP, min(self.total_aircraft, 20))
 
-    def scramble_cas(self, multiplier: float) -> typing.Dict[PlaneType, int]:
+    def scramble_cas(self, multiplier: float) -> typing.Dict[FlyingType, int]:
         return self._find_best_planes(CAS, self.scramble_count(multiplier, CAS))
 
-    def scramble_interceptors(self, multiplier: float) -> typing.Dict[PlaneType, int]:
+    def scramble_interceptors(self, multiplier: float) -> typing.Dict[FlyingType, int]:
         return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
 
     def assemble_attack(self) -> typing.Dict[Armor, int]:

game/theater/conflicttheater.py

@@ -0,0 +1,936 @@
+from __future__ import annotations
+
+import itertools
+import json
+import logging
+from dataclasses import dataclass
+from functools import cached_property
+from itertools import tee
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union, cast
+
+from shapely import geometry
+from shapely import ops
+
+from dcs import Mission
+from dcs.countries import (
+    CombinedJointTaskForcesBlue,
+    CombinedJointTaskForcesRed,
+)
+from dcs.country import Country
+from dcs.mapping import Point
+from dcs.planes import F_15C
+from dcs.ships import (
+    CVN_74_John_C__Stennis,
+    LHA_1_Tarawa,
+    USS_Arleigh_Burke_IIa,
+)
+from dcs.statics import Fortification
+from dcs.terrain import (
+    caucasus,
+    nevada,
+    normandy,
+    persiangulf,
+    syria,
+    thechannel,
+)
+from dcs.terrain.terrain import Airport, Terrain
+from dcs.unitgroup import (
+    FlyingGroup,
+    Group,
+    ShipGroup,
+    StaticGroup,
+    VehicleGroup,
+)
+from dcs.vehicles import AirDefence, Armor, MissilesSS, Unarmed
+
+from gen.flights.flight import FlightType
+from .controlpoint import (
+    Airfield,
+    Carrier,
+    ControlPoint,
+    Lha,
+    MissionTarget,
+    OffMapSpawn,
+    Fob,
+)
+from .landmap import Landmap, load_landmap, poly_contains
+from ..utils import nm_to_meter
+
+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
+
+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 MizCampaignLoader:
+    BLUE_COUNTRY = CombinedJointTaskForcesBlue()
+    RED_COUNTRY = CombinedJointTaskForcesRed()
+
+    OFF_MAP_UNIT_TYPE = F_15C.id
+
+    CV_UNIT_TYPE = CVN_74_John_C__Stennis.id
+    LHA_UNIT_TYPE = LHA_1_Tarawa.id
+    FRONT_LINE_UNIT_TYPE = Armor.APC_M113.id
+
+    FOB_UNIT_TYPE = Unarmed.CP_SKP_11_ATC_Mobile_Command_Post.id
+
+    EWR_UNIT_TYPE = AirDefence.EWR_55G6.id
+    SAM_UNIT_TYPE = AirDefence.SAM_SA_10_S_300PS_SR_64H6E.id
+    GARRISON_UNIT_TYPE = AirDefence.SAM_SA_19_Tunguska_2S6.id
+    OFFSHORE_STRIKE_TARGET_UNIT_TYPE = Fortification.Oil_platform.id
+    SHIP_UNIT_TYPE = USS_Arleigh_Burke_IIa.id
+    MISSILE_SITE_UNIT_TYPE = MissilesSS.SRBM_SS_1C_Scud_B_9K72_LN_9P117M.id
+    COASTAL_DEFENSE_UNIT_TYPE = MissilesSS.SS_N_2_Silkworm.id
+
+    # Multiple options for the required SAMs so campaign designers can more
+    # accurately see the coverage of their IADS for the expected type.
+    REQUIRED_LONG_RANGE_SAM_UNIT_TYPES = {
+        AirDefence.SAM_Patriot_LN_M901.id,
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85C.id,
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85D.id,
+    }
+
+    REQUIRED_MEDIUM_RANGE_SAM_UNIT_TYPES = {
+        AirDefence.SAM_Hawk_LN_M192.id,
+        AirDefence.SAM_SA_2_LN_SM_90.id,
+        AirDefence.SAM_SA_3_S_125_LN_5P73.id,
+    }
+
+    BASE_DEFENSE_RADIUS = nm_to_meter(2)
+
+    def __init__(self, miz: Path, theater: ConflictTheater) -> None:
+        self.theater = theater
+        self.mission = Mission()
+        self.mission.load_file(str(miz))
+        self.control_point_id = itertools.count(1000)
+
+        # If there are no red carriers there usually aren't red units. Make sure
+        # both countries are initialized so we don't have to deal with None.
+        if self.mission.country(self.BLUE_COUNTRY.name) is None:
+            self.mission.coalition["blue"].add_country(self.BLUE_COUNTRY)
+        if self.mission.country(self.RED_COUNTRY.name) is None:
+            self.mission.coalition["red"].add_country(self.RED_COUNTRY)
+
+    @staticmethod
+    def control_point_from_airport(airport: Airport) -> ControlPoint:
+
+        # The wiki says this is a legacy property and to just use regular.
+        size = SIZE_REGULAR
+
+        # The importance is taken from the periodicity of the airport's
+        # warehouse divided by 10. 30 is the default, and out of range (valid
+        # values are between 1.0 and 1.4). If it is used, pick the default
+        # importance.
+        if airport.periodicity == 30:
+            importance = IMPORTANCE_MEDIUM
+        else:
+            importance = airport.periodicity / 10
+
+        cp = Airfield(airport, size, importance)
+        cp.captured = airport.is_blue()
+
+        # Use the unlimited aircraft option to determine if an airfield should
+        # be owned by the player when the campaign is "inverted".
+        cp.captured_invert = airport.unlimited_aircrafts
+
+        return cp
+
+    def country(self, blue: bool) -> Country:
+        country = self.mission.country(
+            self.BLUE_COUNTRY.name if blue else self.RED_COUNTRY.name)
+        # Should be guaranteed because we initialized them.
+        assert country
+        return country
+
+    @property
+    def blue(self) -> Country:
+        return self.country(blue=True)
+
+    @property
+    def red(self) -> Country:
+        return self.country(blue=False)
+
+    def off_map_spawns(self, blue: bool) -> Iterator[FlyingGroup]:
+        for group in self.country(blue).plane_group:
+            if group.units[0].type == self.OFF_MAP_UNIT_TYPE:
+                yield group
+
+    def carriers(self, blue: bool) -> Iterator[ShipGroup]:
+        for group in self.country(blue).ship_group:
+            if group.units[0].type == self.CV_UNIT_TYPE:
+                yield group
+
+    def lhas(self, blue: bool) -> Iterator[ShipGroup]:
+        for group in self.country(blue).ship_group:
+            if group.units[0].type == self.LHA_UNIT_TYPE:
+                yield group
+    
+    def fobs(self, blue: bool) -> Iterator[VehicleGroup]:
+        for group in self.country(blue).vehicle_group:
+            if group.units[0].type == self.FOB_UNIT_TYPE:
+                yield group
+
+    @property
+    def ships(self) -> Iterator[ShipGroup]:
+        for group in self.blue.ship_group:
+            if group.units[0].type == self.SHIP_UNIT_TYPE:
+                yield group
+
+    @property
+    def ewrs(self) -> Iterator[VehicleGroup]:
+        for group in self.blue.vehicle_group:
+            if group.units[0].type == self.EWR_UNIT_TYPE:
+                yield group
+
+    @property
+    def sams(self) -> Iterator[VehicleGroup]:
+        for group in self.blue.vehicle_group:
+            if group.units[0].type == self.SAM_UNIT_TYPE:
+                yield group
+
+    @property
+    def garrisons(self) -> Iterator[VehicleGroup]:
+        for group in self.blue.vehicle_group:
+            if group.units[0].type == self.GARRISON_UNIT_TYPE:
+                yield group
+
+    @property
+    def offshore_strike_targets(self) -> Iterator[StaticGroup]:
+        for group in self.blue.static_group:
+            if group.units[0].type == self.OFFSHORE_STRIKE_TARGET_UNIT_TYPE:
+                yield group
+
+    @property
+    def missile_sites(self) -> Iterator[VehicleGroup]:
+        for group in self.blue.vehicle_group:
+            if group.units[0].type == self.MISSILE_SITE_UNIT_TYPE:
+                yield group
+
+    @property
+    def coastal_defenses(self) -> Iterator[VehicleGroup]:
+        for group in self.blue.vehicle_group:
+            if group.units[0].type == self.COASTAL_DEFENSE_UNIT_TYPE:
+                yield group
+
+    @property
+    def required_long_range_sams(self) -> Iterator[VehicleGroup]:
+        for group in self.red.vehicle_group:
+            if group.units[0].type in self.REQUIRED_LONG_RANGE_SAM_UNIT_TYPES:
+                yield group
+
+    @property
+    def required_medium_range_sams(self) -> Iterator[VehicleGroup]:
+        for group in self.red.vehicle_group:
+            if group.units[0].type in self.REQUIRED_MEDIUM_RANGE_SAM_UNIT_TYPES:
+                yield group
+
+    @cached_property
+    def control_points(self) -> Dict[int, ControlPoint]:
+        control_points = {}
+        for airport in self.mission.terrain.airport_list():
+            if airport.is_blue() or airport.is_red():
+                control_point = self.control_point_from_airport(airport)
+                control_points[control_point.id] = control_point
+
+        for blue in (False, True):
+            for group in self.off_map_spawns(blue):
+                control_point = OffMapSpawn(next(self.control_point_id),
+                                            str(group.name), group.position)
+                control_point.captured = blue
+                control_point.captured_invert = group.late_activation
+                control_points[control_point.id] = control_point
+            for group in self.carriers(blue):
+                # TODO: Name the carrier.
+                control_point = Carrier(
+                    "carrier", group.position, next(self.control_point_id))
+                control_point.captured = blue
+                control_point.captured_invert = group.late_activation
+                control_points[control_point.id] = control_point
+            for group in self.lhas(blue):
+                # TODO: Name the LHA.
+                control_point = Lha(
+                    "lha", group.position, next(self.control_point_id))
+                control_point.captured = blue
+                control_point.captured_invert = group.late_activation
+                control_points[control_point.id] = control_point
+            for group in self.fobs(blue):
+                control_point = Fob(
+                    str(group.name), group.position, next(self.control_point_id)
+                )
+                control_point.captured = blue
+                control_point.captured_invert = group.late_activation
+                control_points[control_point.id] = control_point
+
+        return control_points
+
+    @property
+    def front_line_path_groups(self) -> Iterator[VehicleGroup]:
+        for group in self.country(blue=True).vehicle_group:
+            if group.units[0].type == self.FRONT_LINE_UNIT_TYPE:
+                yield group
+
+    @cached_property
+    def front_lines(self) -> Dict[str, ComplexFrontLine]:
+        # Dict of front line ID to a front line.
+        front_lines = {}
+        for group in self.front_line_path_groups:
+            # The unit will have its first waypoint at the source CP and the
+            # final waypoint at the destination CP. Intermediate waypoints
+            # define the curve of the front line.
+            waypoints = [p.position for p in group.points]
+            origin =  self.theater.closest_control_point(waypoints[0])
+            if origin is None:
+                raise RuntimeError(
+                    f"No control point near the first waypoint of {group.name}")
+            destination = self.theater.closest_control_point(waypoints[-1])
+            if destination is None:
+                raise RuntimeError(
+                    f"No control point near the final waypoint of {group.name}")
+
+            # Snap the begin and end points to the control points.
+            waypoints[0] = origin.position
+            waypoints[-1] = destination.position
+            front_line_id = f"{origin.id}|{destination.id}"
+            front_lines[front_line_id] = ComplexFrontLine(origin, waypoints)
+            self.control_points[origin.id].connect(
+                self.control_points[destination.id])
+            self.control_points[destination.id].connect(
+                self.control_points[origin.id])
+        return front_lines
+
+    def objective_info(self, group: Group) -> Tuple[ControlPoint, int]:
+        closest = self.theater.closest_control_point(group.position)
+        distance = closest.position.distance_to_point(group.position)
+        return closest, distance
+
+    def add_preset_locations(self) -> None:
+        for group in self.garrisons:
+            closest, distance = self.objective_info(group)
+            if distance < self.BASE_DEFENSE_RADIUS:
+                closest.preset_locations.base_garrisons.append(group.position)
+            else:
+                logging.warning(
+                    f"Found garrison unit too far from base: {group.name}")
+
+        for group in self.sams:
+            closest, distance = self.objective_info(group)
+            if distance < self.BASE_DEFENSE_RADIUS:
+                closest.preset_locations.base_air_defense.append(group.position)
+            else:
+                closest.preset_locations.strike_locations.append(group.position)
+
+        for group in self.ewrs:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.ewrs.append(group.position)
+
+        for group in self.offshore_strike_targets:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.offshore_strike_locations.append(
+                group.position)
+
+        for group in self.ships:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.ships.append(group.position)
+
+        for group in self.missile_sites:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.missile_sites.append(group.position)
+
+        for group in self.coastal_defenses:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.coastal_defenses.append(group.position)
+
+        for group in self.required_long_range_sams:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.required_long_range_sams.append(
+                group.position
+            )
+
+        for group in self.required_medium_range_sams:
+            closest, distance = self.objective_info(group)
+            closest.preset_locations.required_medium_range_sams.append(
+                group.position
+            )
+
+    def populate_theater(self) -> None:
+        for control_point in self.control_points.values():
+            self.theater.add_controlpoint(control_point)
+        self.add_preset_locations()
+        self.theater.set_frontline_data(self.front_lines)
+
+
+@dataclass
+class ReferencePoint:
+    world_coordinates: Point
+    image_coordinates: Point
+
+
+class ConflictTheater:
+    terrain: Terrain
+
+    reference_points: Tuple[ReferencePoint, ReferencePoint]
+    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: Optional[Dict[str, ComplexFrontLine]] = None
+        """
+        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))
+        """
+
+    @property
+    def frontline_data(self) -> Optional[Dict[str, ComplexFrontLine]]:
+        if self._frontline_data is None:
+            self.load_frontline_data_from_file()
+        return self._frontline_data
+
+    def load_frontline_data_from_file(self) -> None:
+        if self._frontline_data is not None:
+            logging.warning("Replacing existing frontline data from file")
+        self._frontline_data = FrontLine.load_json_frontlines(self)
+        if self._frontline_data is None:
+            self._frontline_data = {}
+
+    def set_frontline_data(self, data: Dict[str, ComplexFrontLine]) -> None:
+        if self._frontline_data is not None:
+            logging.warning("Replacing existing frontline data")
+        self._frontline_data = data
+
+    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 exclusion_zone in self.landmap[1]:
+            if poly_contains(point.x, point.y, exclusion_zone):
+                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 nearest_land_pos(self, point: Point, extend_dist: int = 50) -> Point:
+        """Returns the nearest point inside a land exclusion zone from point
+        `extend_dist` determines how far inside the zone the point should be placed"""
+        if self.is_on_land(point):
+            return point
+        point = geometry.Point(point.x, point.y)
+        nearest_points = []
+        if not self.landmap:
+            raise RuntimeError("Landmap not initialized")
+        for inclusion_zone in self.landmap[0]:
+            nearest_pair = ops.nearest_points(point, inclusion_zone)
+            nearest_points.append(nearest_pair[1])
+        min_distance = point.distance(nearest_points[0]) # type: geometry.Point
+        nearest_point = nearest_points[0] # type: geometry.Point
+        for pt in nearest_points[1:]:
+            distance = point.distance(pt)
+            if distance < min_distance:
+                min_distance = distance
+                nearest_point = pt
+        assert isinstance(nearest_point, geometry.Point)
+        point = Point(point.x, point.y)
+        nearest_point = Point(nearest_point.x, nearest_point.y)
+        new_point = point.point_from_heading(
+            point.heading_between_point(nearest_point),
+            point.distance_to_point(nearest_point) + extend_dist
+        )
+        return new_point
+
+    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 closest_control_point(self, point: Point) -> ControlPoint:
+        closest = self.controlpoints[0]
+        closest_distance = point.distance_to_point(closest.position)
+        for control_point in self.controlpoints[1:]:
+            distance = point.distance_to_point(control_point.position)
+            if distance < closest_distance:
+                closest = control_point
+                closest_distance = distance
+        return closest
+    
+    def closest_opposing_control_points(self) -> Tuple[ControlPoint, ControlPoint]:
+        """
+        Returns a tuple of the two nearest opposing ControlPoints in theater.
+        (player_cp, enemy_cp)
+        """
+        all_cp_min_distances = {}
+        for idx, control_point in enumerate(self.controlpoints):
+            distances = {}
+            closest_distance = None
+            for i, cp in enumerate(self.controlpoints):
+                if i != idx and cp.captured is not control_point.captured:
+                    dist = cp.position.distance_to_point(control_point.position)
+                    if not closest_distance:
+                        closest_distance = dist
+                        distances[cp.id] = dist
+                    if dist < closest_distance:
+                        distances[cp.id] = dist
+            closest_cp_id = min(distances, key=distances.get)  # type: ignore
+
+            all_cp_min_distances[(control_point.id, closest_cp_id)] = distances[closest_cp_id]
+        closest_opposing_cps = [
+            self.find_control_point_by_id(i)
+            for i
+            in min(all_cp_min_distances, key=all_cp_min_distances.get)  # type: ignore
+          ]  # type: List[ControlPoint]
+        assert len(closest_opposing_cps) == 2
+        if closest_opposing_cps[0].captured:
+            return cast(Tuple[ControlPoint, ControlPoint], tuple(closest_opposing_cps))
+        else:
+            return cast(Tuple[ControlPoint, ControlPoint], tuple(reversed(closest_opposing_cps)))
+
+    def find_control_point_by_id(self, id: int) -> ControlPoint:
+        for i in self.controlpoints:
+            if i.id == id:
+                return i
+        raise RuntimeError(f"Cannot find ControlPoint with ID {id}")
+
+    def add_json_cp(self, theater, p: dict) -> ControlPoint:
+        cp: ControlPoint
+        if p["type"] == "airbase":
+
+            airbase = theater.terrain.airports[p["id"]]
+
+            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 = Airfield(airbase, size, importance)
+        elif p["type"] == "carrier":
+            cp = Carrier("carrier", Point(p["x"], p["y"]), p["id"])
+        else:
+            cp = 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(directory: Path, 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()
+
+        miz = data.get("miz", None)
+        if miz is not None:
+            MizCampaignLoader(directory / miz, t).populate_theater()
+            return t
+
+        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 = (
+        ReferencePoint(caucasus.Gelendzhik.position, Point(176, 298)),
+        ReferencePoint(caucasus.Batumi.position, Point(1307, 1205)),
+    )
+
+    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 = (
+        ReferencePoint(persiangulf.Jiroft_Airport.position,
+                       Point(1692, 1343)),
+        ReferencePoint(persiangulf.Liwa_Airbase.position, Point(358, 3238)),
+    )
+    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 = (
+        ReferencePoint(nevada.Mina_Airport_3Q0.position, Point(252, 295)),
+        ReferencePoint(nevada.Laughlin_Airport.position, Point(844, 909)),
+    )
+    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 = (
+        ReferencePoint(normandy.Needs_Oar_Point.position, Point(515, 329)),
+        ReferencePoint(normandy.Evreux.position, Point(2029, 1709)),
+    )
+    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 = (
+        ReferencePoint(thechannel.Abbeville_Drucat.position, Point(2005, 2390)),
+        ReferencePoint(thechannel.Detling.position, Point(706, 382))
+    )
+    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 = (
+        ReferencePoint(syria.Eyn_Shemer.position, Point(564, 1289)),
+        ReferencePoint(syria.Tabqa.position, Point(1329, 491)),
+    )
+    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 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,722 @@
+from __future__ import annotations
+
+import itertools
+import logging
+import random
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, Iterator, List, Optional, TYPE_CHECKING, Type
+
+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, ParkingSlot
+from dcs.unittype import FlyingType
+
+from game import db
+from gen.runways import RunwayAssigner, RunwayData
+from gen.ground_forces.combat_stance import CombatStance
+from .base import Base
+from .missiontarget import MissionTarget
+from .theatergroundobject import (
+    BaseDefenseGroundObject,
+    EwrGroundObject,
+    SamGroundObject,
+    TheaterGroundObject,
+    VehicleGroupGroundObject, GenericCarrierGroundObject,
+)
+from ..weather import Conditions
+
+if TYPE_CHECKING:
+    from game import Game
+    from gen.flights.flight import FlightType
+    from ..event import UnitsDeliveryEvent
+
+
+class ControlPointType(Enum):
+    #: An airbase with slots for everything.
+    AIRBASE = 0
+    #: A group with a Stennis type carrier (F/A-18, F-14 compatible).
+    AIRCRAFT_CARRIER_GROUP = 1
+    #: A group with a Tarawa carrier (Helicopters & Harrier).
+    LHA_GROUP = 2
+    #: A FARP, with slots for helicopters
+    FARP = 4
+    #: A FOB (ground units only)
+    FOB = 5
+    OFF_MAP = 6
+
+
+class LocationType(Enum):
+    BaseAirDefense = "base air defense"
+    Coastal = "coastal defense"
+    Ewr = "EWR"
+    Garrison = "garrison"
+    MissileSite = "missile site"
+    OffshoreStrikeTarget = "offshore strike target"
+    Sam = "SAM"
+    Ship = "ship"
+    Shorad = "SHORAD"
+    StrikeTarget = "strike target"
+
+
+@dataclass
+class PresetLocations:
+    """Defines the preset locations loaded from the campaign mission file."""
+
+    #: Locations used for spawning ground defenses for bases.
+    base_garrisons: List[Point] = field(default_factory=list)
+
+    #: Locations used for spawning air defenses for bases. Used by SAMs, AAA,
+    #: and SHORADs.
+    base_air_defense: List[Point] = field(default_factory=list)
+
+    #: Locations used by EWRs.
+    ewrs: List[Point] = field(default_factory=list)
+
+    #: Locations used by non-carrier ships. Carriers and LHAs are not random.
+    ships: List[Point] = field(default_factory=list)
+
+    #: Locations used by coastal defenses.
+    coastal_defenses: List[Point] = field(default_factory=list)
+
+    #: Locations used by ground based strike objectives.
+    strike_locations: List[Point] = field(default_factory=list)
+
+    #: Locations used by offshore strike objectives.
+    offshore_strike_locations: List[Point] = field(default_factory=list)
+
+    #: Locations used by missile sites like scuds and V-2s.
+    missile_sites: List[Point] = field(default_factory=list)
+
+    #: Locations of long range SAMs which should always be spawned.
+    required_long_range_sams: List[Point] = field(default_factory=list)
+
+    #: Locations of medium range SAMs which should always be spawned.
+    required_medium_range_sams: List[Point] = field(default_factory=list)
+
+    @staticmethod
+    def _random_from(points: List[Point]) -> Optional[Point]:
+        """Finds, removes, and returns a random position from the given list."""
+        if not points:
+            return None
+        point = random.choice(points)
+        points.remove(point)
+        return point
+
+    def random_for(self, location_type: LocationType) -> Optional[Point]:
+        """Returns a position suitable for the given location type.
+
+        The location, if found, will be claimed by the caller and not available
+        to subsequent calls.
+        """
+        if location_type == LocationType.BaseAirDefense:
+            return self._random_from(self.base_air_defense)
+        if location_type == LocationType.Coastal:
+            return self._random_from(self.coastal_defenses)
+        if location_type == LocationType.Ewr:
+            return self._random_from(self.ewrs)
+        if location_type == LocationType.Garrison:
+            return self._random_from(self.base_garrisons)
+        if location_type == LocationType.MissileSite:
+            return self._random_from(self.missile_sites)
+        if location_type == LocationType.OffshoreStrikeTarget:
+            return self._random_from(self.offshore_strike_locations)
+        if location_type == LocationType.Sam:
+            return self._random_from(self.strike_locations)
+        if location_type == LocationType.Ship:
+            return self._random_from(self.ships)
+        if location_type == LocationType.Shorad:
+            return self._random_from(self.base_garrisons)
+        if location_type == LocationType.StrikeTarget:
+            return self._random_from(self.strike_locations)
+        logging.error(f"Unknown location type: {location_type}")
+        return None
+
+
+@dataclass(frozen=True)
+class PendingOccupancy:
+    present: int
+    ordered: int
+    transferring: int
+
+    @property
+    def total(self) -> int:
+        return self.present + self.ordered + self.transferring
+
+
+@dataclass
+class RunwayStatus:
+    damaged: bool = False
+    repair_turns_remaining: Optional[int] = None
+
+    def damage(self) -> None:
+        self.damaged = True
+        # If the runway is already under repair and is damaged again, progress
+        # is reset.
+        self.repair_turns_remaining = None
+
+    def begin_repair(self) -> None:
+        if self.repair_turns_remaining is not None:
+            logging.error("Runway already under repair. Restarting.")
+        self.repair_turns_remaining = 4
+
+    def process_turn(self) -> None:
+        if self.repair_turns_remaining is not None:
+            if self.repair_turns_remaining == 1:
+                self.repair_turns_remaining = None
+                self.damaged = False
+            else:
+                self.repair_turns_remaining -= 1
+
+    @property
+    def needs_repair(self) -> bool:
+        return self.damaged and self.repair_turns_remaining is None
+
+    def __str__(self) -> str:
+        if not self.damaged:
+            return "Runway operational"
+
+        turns_remaining = self.repair_turns_remaining
+        if turns_remaining is None:
+            return "Runway damaged"
+
+        return f"Runway repairing, {turns_remaining} turns remaining"
+
+
+class ControlPoint(MissionTarget, ABC):
+
+    position = None  # type: Point
+    name = None  # type: str
+
+    captured = False
+    has_frontline = True
+
+    alt = 0
+
+    # TODO: Only airbases have IDs.
+    # TODO: has_frontline is only reasonable for airbases.
+    # TODO: cptype is obsolete.
+    def __init__(self, cp_id: int, name: str, position: Point,
+                 at: db.StartingPosition, size: int,
+                 importance: float, has_frontline=True,
+                 cptype=ControlPointType.AIRBASE):
+        super().__init__(" ".join(re.split(r"[ \-]", name)[:2]), position)
+        # TODO: Should be Airbase specific.
+        self.id = cp_id
+        self.full_name = name
+        self.at = at
+        self.connected_objectives: List[TheaterGroundObject] = []
+        self.base_defenses: List[BaseDefenseGroundObject] = []
+        self.preset_locations = PresetLocations()
+
+        # TODO: Should be Airbase specific.
+        self.size = size
+        self.importance = importance
+        self.captured = False
+        self.captured_invert = False
+        # TODO: Should be Airbase specific.
+        self.has_frontline = has_frontline
+        self.connected_points: List[ControlPoint] = []
+        self.base: Base = Base()
+        self.cptype = cptype
+        # TODO: Should be Airbase specific.
+        self.stances: Dict[int, CombatStance] = {}
+        self.pending_unit_deliveries: Optional[UnitsDeliveryEvent] = None
+
+        self.target_position: Optional[Point] = None
+    
+    def __repr__(self):
+        return f"<{__class__}: {self.name}>"
+
+    @property
+    def ground_objects(self) -> List[TheaterGroundObject]:
+        return list(
+            itertools.chain(self.connected_objectives, self.base_defenses))
+
+    @property
+    @abstractmethod
+    def heading(self) -> int:
+        ...
+
+    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 False
+
+    @property
+    def is_fleet(self):
+        """
+        :return: Whether this control point is a boat (mobile)
+        """
+        return False
+
+    @property
+    def is_lha(self):
+        """
+        :return: Whether this control point is an LHA
+        """
+        return False
+
+    @property
+    def moveable(self) -> bool:
+        """
+        :return: Whether this control point can be moved around
+        """
+        return False
+
+    @property
+    @abstractmethod
+    def can_deploy_ground_units(self) -> bool:
+        ...
+
+    @property
+    @abstractmethod
+    def total_aircraft_parking(self):
+        """
+        :return: The maximum number of aircraft that can be stored in this
+                 control point
+        """
+        ...
+
+    # TODO: Should be Airbase specific.
+    def connect(self, to: ControlPoint) -> None:
+        self.connected_points.append(to)
+        self.stances[to.id] = CombatStance.DEFENSIVE
+
+    @abstractmethod
+    def runway_is_operational(self) -> bool:
+        """
+        Check whether this control point supports taking offs and landings.
+        :return:
+        """
+        ...
+
+    # TODO: Should be naval specific.
+    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
+
+    # TODO: Should be Airbase specific.
+    def is_connected(self, to) -> bool:
+        return to in self.connected_points
+
+    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
+
+    # TODO: Should be Airbase specific.
+    def clear_base_defenses(self) -> None:
+        for base_defense in self.base_defenses:
+            if isinstance(base_defense, EwrGroundObject):
+                self.preset_locations.ewrs.append(base_defense.position)
+            elif isinstance(base_defense, SamGroundObject):
+                self.preset_locations.base_air_defense.append(
+                    base_defense.position)
+            elif isinstance(base_defense, VehicleGroupGroundObject):
+                self.preset_locations.base_garrisons.append(
+                    base_defense.position)
+            else:
+                logging.error(
+                    "Could not determine preset location type for "
+                    f"{base_defense}. Assuming garrison type.")
+                self.preset_locations.base_garrisons.append(
+                    base_defense.position)
+        self.base_defenses = []
+
+    # TODO: Should be Airbase specific.
+    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 = {}
+
+        self.clear_base_defenses()
+        from .start_generator import BaseDefenseGenerator
+        BaseDefenseGenerator(game, self).generate()
+
+    @abstractmethod
+    def can_operate(self, aircraft: Type[FlyingType]) -> bool:
+        ...
+
+    def aircraft_transferring(self, game: Game) -> int:
+        if self.captured:
+            ato = game.blue_ato
+        else:
+            ato = game.red_ato
+
+        total = 0
+        for package in ato.packages:
+            for flight in package.flights:
+                if flight.departure == flight.arrival:
+                    continue
+                if flight.departure == self:
+                    total -= flight.count
+                elif flight.arrival == self:
+                    total += flight.count
+        return total
+
+    def expected_aircraft_next_turn(self, game: Game) -> PendingOccupancy:
+        assert self.pending_unit_deliveries
+        on_order = 0
+        for unit_bought in self.pending_unit_deliveries.units:
+            if issubclass(unit_bought, FlyingType):
+                on_order += self.pending_unit_deliveries.units[unit_bought]
+
+        return PendingOccupancy(self.base.total_aircraft, on_order,
+                                self.aircraft_transferring(game))
+
+    def unclaimed_parking(self, game: Game) -> int:
+        return (self.total_aircraft_parking -
+                self.expected_aircraft_next_turn(game).total)
+
+    @abstractmethod
+    def active_runway(self, conditions: Conditions,
+                      dynamic_runways: Dict[str, RunwayData]) -> RunwayData:
+        ...
+
+    @property
+    def parking_slots(self) -> Iterator[ParkingSlot]:
+        yield from []
+
+    @property
+    @abstractmethod
+    def runway_status(self) -> RunwayStatus:
+        ...
+
+    @property
+    def runway_can_be_repaired(self) -> bool:
+        return self.runway_status.needs_repair
+
+    def begin_runway_repair(self) -> None:
+        if not self.runway_can_be_repaired:
+            logging.error(f"Cannot repair runway at {self}")
+            return
+        self.runway_status.begin_repair()
+
+    def process_turn(self) -> None:
+        runway_status = self.runway_status
+        if runway_status is not None:
+            runway_status.process_turn()
+
+        # Process movements for ships control points group
+        if self.target_position is not None:
+            delta = self.target_position - self.position
+            self.position = self.target_position
+            self.target_position = None
+
+            # Move the linked unit groups
+            for ground_object in self.ground_objects:
+                if isinstance(ground_object, GenericCarrierGroundObject):
+                    for group in ground_object.groups:
+                        for u in group.units:
+                            u.position.x = u.position.x + delta.x
+                            u.position.y = u.position.y + delta.y
+
+
+class Airfield(ControlPoint):
+
+    def __init__(self, airport: Airport, size: int,
+                 importance: float, has_frontline=True):
+        super().__init__(airport.id, airport.name, airport.position, airport,
+                         size, importance, has_frontline,
+                         cptype=ControlPointType.AIRBASE)
+        self.airport = airport
+        self._runway_status = RunwayStatus()
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        # TODO: Allow helicopters.
+        # Need to implement ground spawns so the helos don't use the runway.
+        # TODO: Allow harrier.
+        # Needs ground spawns just like helos do, but also need to be able to
+        # limit takeoff weight to ~20500 lbs or it won't be able to take off.
+        return self.runway_is_operational()
+
+    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.INTERCEPTION
+                # TODO: FlightType.LOGISTICS
+            ]
+        else:
+            yield from [
+                FlightType.OCA_AIRCRAFT,
+                FlightType.OCA_RUNWAY,
+            ]
+        yield from super().mission_types(for_player)
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return len(self.airport.parking_slots)
+
+    @property
+    def heading(self) -> int:
+        return self.airport.runways[0].heading
+
+    def runway_is_operational(self) -> bool:
+        return not self.runway_status.damaged
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return self._runway_status
+
+    def damage_runway(self) -> None:
+        self.runway_status.damage()
+
+    def active_runway(self, conditions: Conditions,
+                      dynamic_runways: Dict[str, RunwayData]) -> RunwayData:
+        assigner = RunwayAssigner(conditions)
+        return assigner.get_preferred_runway(self.airport)
+
+    @property
+    def parking_slots(self) -> Iterator[ParkingSlot]:
+        yield from self.airport.parking_slots
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return True
+
+
+class NavalControlPoint(ControlPoint, ABC):
+
+    @property
+    def is_fleet(self) -> bool:
+        return True
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        yield from super().mission_types(for_player)
+        from gen.flights.flight import FlightType
+        if self.is_friendly(for_player):
+            yield from [
+                # TODO: FlightType.INTERCEPTION
+                # TODO: Buddy tanking for the A-4?
+                # TODO: Rescue chopper?
+                # TODO: Inter-ship logistics?
+            ]
+        else:
+            yield FlightType.ANTISHIP
+
+    @property
+    def heading(self) -> int:
+        return 0  # TODO compute heading
+
+    def runway_is_operational(self) -> bool:
+        # Necessary because it's possible for the carrier itself to have sunk
+        # while its escorts are still alive.
+        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
+
+    def active_runway(self, conditions: Conditions,
+                      dynamic_runways: Dict[str, RunwayData]) -> RunwayData:
+        # TODO: Assign TACAN and ICLS earlier so we don't need this.
+        fallback = RunwayData(self.full_name, runway_heading=0, runway_name="")
+        return dynamic_runways.get(self.name, fallback)
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return RunwayStatus(damaged=not self.runway_is_operational())
+
+    @property
+    def runway_can_be_repaired(self) -> bool:
+        return False
+
+    @property
+    def moveable(self) -> bool:
+        return True
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return False
+
+
+class Carrier(NavalControlPoint):
+
+    def __init__(self, name: str, at: Point, cp_id: int):
+        import game.theater.conflicttheater
+        super().__init__(cp_id, name, at, at,
+                         game.theater.conflicttheater.SIZE_SMALL, 1,
+                         has_frontline=False, cptype=ControlPointType.AIRCRAFT_CARRIER_GROUP)
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        raise RuntimeError("Carriers cannot be captured")
+
+    @property
+    def is_carrier(self):
+        return True
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return aircraft in db.CARRIER_CAPABLE
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 90
+
+
+class Lha(NavalControlPoint):
+
+    def __init__(self, name: str, at: Point, cp_id: int):
+        import game.theater.conflicttheater
+        super().__init__(cp_id, name, at, at,
+                         game.theater.conflicttheater.SIZE_SMALL, 1,
+                         has_frontline=False, cptype=ControlPointType.LHA_GROUP)
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        raise RuntimeError("LHAs cannot be captured")
+
+    @property
+    def is_lha(self) -> bool:
+        return True
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return aircraft in db.LHA_CAPABLE
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 20
+
+
+class OffMapSpawn(ControlPoint):
+
+    def runway_is_operational(self) -> bool:
+        return True
+
+    def __init__(self, cp_id: int, name: str, position: Point):
+        from . import IMPORTANCE_MEDIUM, SIZE_REGULAR
+        super().__init__(cp_id, name, position, at=position,
+                         size=SIZE_REGULAR, importance=IMPORTANCE_MEDIUM,
+                         has_frontline=False, cptype=ControlPointType.OFF_MAP)
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        raise RuntimeError("Off map control points cannot be captured")
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        yield from []
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 1000
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return True
+
+    @property
+    def heading(self) -> int:
+        return 0
+
+    def active_runway(self, conditions: Conditions,
+                      dynamic_runways: Dict[str, RunwayData]) -> RunwayData:
+        logging.warning("TODO: Off map spawns have no runways.")
+        return RunwayData(self.full_name, runway_heading=0, runway_name="")
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return RunwayStatus()
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return False
+
+
+class Fob(ControlPoint):
+
+    def __init__(self, name: str, at: Point, cp_id: int):
+        import game.theater.conflicttheater
+        super().__init__(cp_id, name, at, at,
+                         game.theater.conflicttheater.SIZE_SMALL, 1,
+                         has_frontline=True, cptype=ControlPointType.FOB)
+        self.name = name
+    
+    def runway_is_operational(self) -> bool:
+        return False
+    
+    def active_runway(self, conditions: Conditions,
+                      dynamic_runways: Dict[str, RunwayData]) -> RunwayData:
+        logging.warning("TODO: FOBs have no runways.")
+        return RunwayData(self.full_name, runway_heading=0, runway_name="")
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return RunwayStatus()
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+        if self.is_friendly(for_player):
+            yield from [
+                FlightType.BARCAP,
+                # TODO: FlightType.LOGISTICS
+            ]
+        else:
+            yield from [
+                FlightType.STRIKE,
+                FlightType.SWEEP,
+                FlightType.ESCORT,
+                FlightType.SEAD,
+            ]
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 0
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return False
+
+    @property
+    def heading(self) -> int:
+        return 0
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return True

game/theater/landmap.py

@@ -0,0 +1,30 @@
+import pickle
+from typing import Collection, Optional, Tuple
+import logging
+
+from shapely import geometry
+
+Zone = Collection[Tuple[float, float]]
+Landmap = Tuple[Collection[geometry.Polygon], Collection[geometry.Polygon], Collection[geometry.Polygon]]
+
+
+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:geometry.Polygon):
+    return poly.contains(geometry.Point(x, y))
+
+
+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,741 @@
+from __future__ import annotations
+
+import logging
+import math
+import pickle
+import random
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Iterable, List, Optional, Set
+
+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.theater import Carrier, Lha, LocationType
+from game.theater.conflicttheater import IMPORTANCE_HIGH, IMPORTANCE_LOW
+from game.theater.theatergroundobject import (
+    BuildingGroundObject,
+    CarrierGroundObject,
+    EwrGroundObject,
+    LhaGroundObject,
+    MissileSiteGroundObject,
+    SamGroundObject,
+    ShipGroundObject,
+    VehicleGroupGroundObject,
+)
+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 MizDataLocationFinder
+from gen.missiles.missiles_group_generator import generate_missile_group
+from gen.sam.airdefensegroupgenerator import AirDefenseRange
+from gen.sam.sam_group_generator import (
+    generate_anti_air_group,
+    generate_ewr_group,
+)
+from . import (
+    ConflictTheater,
+    ControlPoint,
+    ControlPointType,
+    Fob,
+    OffMapSpawn,
+)
+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
+
+
+class GameGenerator:
+    def __init__(self, player: str, enemy: str, theater: ConflictTheater,
+                 settings: Settings,
+                 generator_settings: GeneratorSettings) -> None:
+        self.player = player
+        self.enemy = enemy
+        self.theater = theater
+        self.settings = settings
+        self.generator_settings = generator_settings
+
+    def generate(self) -> Game:
+        # Reset name generator
+        namegen.reset()
+        self.prepare_theater()
+        game = Game(
+            player_name=self.player,
+            enemy_name=self.enemy,
+            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 LocationFinder:
+    def __init__(self, game: Game, control_point: ControlPoint) -> None:
+        self.game = game
+        self.control_point = control_point
+        self.miz_data = MizDataLocationFinder.compute_possible_locations(
+            game.theater.terrain.name, control_point.full_name)
+
+    def location_for(self, location_type: LocationType) -> Optional[Point]:
+        position = self.control_point.preset_locations.random_for(location_type)
+        if position is not None:
+            return position
+
+        logging.warning(f"No campaign location for %s at %s",
+                        location_type.value, self.control_point)
+        position = self.random_from_miz_data(
+            location_type == LocationType.OffshoreStrikeTarget)
+        if position is not None:
+            return position
+
+        logging.debug(f"No mizdata location for %s at %s", location_type.value,
+                      self.control_point)
+        position = self.random_position(location_type)
+        if position is not None:
+            return position
+
+        logging.error(f"Could not find position for %s at %s",
+                      location_type.value, self.control_point)
+        return None
+
+    def random_from_miz_data(self, offshore: bool) -> Optional[Point]:
+        if offshore:
+            locations = self.miz_data.offshore_locations
+        else:
+            locations = self.miz_data.ashore_locations
+        if self.miz_data.offshore_locations:
+            preset = random.choice(locations)
+            locations.remove(preset)
+            return preset.position
+        return None
+
+    def random_position(self, location_type: LocationType) -> Optional[Point]:
+        # TODO: Flesh out preset locations so we never hit this case.
+        logging.warning("Falling back to random location for %s at %s",
+                        location_type.value, self.control_point)
+
+        is_base_defense = location_type in {
+            LocationType.BaseAirDefense,
+            LocationType.Garrison,
+            LocationType.Shorad,
+        }
+
+        on_land = location_type not in {
+            LocationType.OffshoreStrikeTarget,
+            LocationType.Ship,
+        }
+
+        avoid_others = location_type not in {
+            LocationType.Garrison,
+            LocationType.MissileSite,
+            LocationType.Sam,
+            LocationType.Ship,
+            LocationType.Shorad,
+        }
+
+        if is_base_defense:
+            min_range = 400
+            max_range = 3200
+        elif location_type == LocationType.Ship:
+            min_range = 5000
+            max_range = 40000
+        elif location_type == LocationType.MissileSite:
+            min_range = 2500
+            max_range = 40000
+        else:
+            min_range = 10000
+            max_range = 40000
+
+        position = self._find_random_position(min_range, max_range,
+                                              on_land, is_base_defense,
+                                              avoid_others)
+
+        # Retry once, searching a bit further (On some big airbases, 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.
+        if position is None and is_base_defense:
+            position = self._find_random_position(3200, 4800,
+                                                  on_land, is_base_defense,
+                                                  avoid_others)
+        return position
+
+    def _find_random_position(self, min_range: int, max_range: int,
+                              on_ground: bool, is_base_defense: bool,
+                              avoid_others: bool) -> Optional[Point]:
+        """
+        Find a valid ground object location
+        :param on_ground: Whether it should be on ground or on sea (True = on
+        ground)
+        :param min_range: Minimal range from point
+        :param max_range: Max range from point
+        :param is_base_defense: True if the location is for base defense.
+        :return:
+        """
+        near = self.control_point.position
+        others = self.control_point.ground_objects
+
+        def is_valid(point: Optional[Point]) -> bool:
+            if point is None:
+                return False
+
+            if on_ground and not self.game.theater.is_on_land(point):
+                return False
+            elif not on_ground and not self.game.theater.is_in_sea(point):
+                return False
+
+            if avoid_others:
+                for other in others:
+                    if other.position.distance_to_point(point) < 10000:
+                        return False
+
+            if is_base_defense:
+                # If it's a base defense we don't care how close it is to other
+                # points.
+                return True
+
+            # Else verify that it's not too close to another control point.
+            for control_point in self.game.theater.controlpoints:
+                if control_point != self.control_point:
+                    if control_point.position.distance_to_point(point) < 30000:
+                        return False
+                    for ground_obj in control_point.ground_objects:
+                        if ground_obj.position.distance_to_point(point) < 10000:
+                            return False
+            return True
+
+        for _ in range(300):
+            # Check if on land or sea
+            p = near.random_point_within(max_range, min_range)
+            if is_valid(p):
+                return p
+        return None
+
+
+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
+        self.location_finder = LocationFinder(game, 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) -> 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.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 _ in range(self.faction.navy_group_count):
+            self.generate_ship()
+
+    def generate_ship(self) -> None:
+        point = self.location_finder.location_for(
+            LocationType.OffshoreStrikeTarget)
+        if point is None:
+            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)
+
+
+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 BaseDefenseGenerator:
+    def __init__(self, game: Game, control_point: ControlPoint) -> None:
+        self.game = game
+        self.control_point = control_point
+        self.location_finder = LocationFinder(game, 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.location_finder.location_for(LocationType.Ewr)
+        if position is None:
+            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)
+        if group is None:
+            logging.error(f"Could not generate EWR at {self.control_point}")
+            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.location_finder.location_for(LocationType.Garrison)
+        if position is None:
+            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 None:
+            logging.error(
+                f"Could not generate garrison at {self.control_point}")
+            return
+        g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+    def generate_sam(self) -> None:
+        position = self.location_finder.location_for(
+            LocationType.BaseAirDefense)
+        if position is None:
+            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)
+        if group is None:
+            logging.error(f"Could not generate SAM at {self.control_point}")
+            return
+        g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+    def generate_shorad(self) -> None:
+        position = self.location_finder.location_for(
+            LocationType.BaseAirDefense)
+        if position is None:
+            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,
+                                        ranges=[{AirDefenseRange.Short}])
+        if group is None:
+            logging.error(
+                f"Could not generate SHORAD group at {self.control_point}")
+            return
+        g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+
+class FobDefenseGenerator(BaseDefenseGenerator):
+    def generate(self) -> None:
+        self.generate_garrison()
+        self.generate_fob_defenses()
+    
+    def generate_fob_defenses(self):
+        # First group has a 1/2 chance of being a SHORAD,
+        # and a 1/2 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_shorad()
+            elif i == 0 and random.randint(0, 1) == 0:
+                self.generate_garrison()
+            elif random.randint(0, 2) == 1:
+                self.generate_shorad()
+            else:
+                self.generate_garrison()
+
+
+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
+
+        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."""
+        skip_sams = self.generate_required_aa()
+
+        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:
+                if skip_sams > 0:
+                    skip_sams -= 1
+                else:
+                    self.generate_aa_site()
+            else:
+                self.generate_ground_point()
+
+    def generate_required_aa(self) -> int:
+        """Generates the AA sites that are required by the campaign.
+
+        Returns:
+            The number of AA sites that were generated.
+        """
+        presets = self.control_point.preset_locations
+        for position in presets.required_long_range_sams:
+            self.generate_aa_at(position, ranges=[
+                {AirDefenseRange.Long},
+                {AirDefenseRange.Medium},
+                {AirDefenseRange.Short},
+            ])
+        for position in presets.required_medium_range_sams:
+            self.generate_aa_at(position, ranges=[
+                {AirDefenseRange.Medium},
+                {AirDefenseRange.Short},
+            ])
+        return (len(presets.required_long_range_sams) +
+                len(presets.required_medium_range_sams))
+
+    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()))
+
+        if category == "oil":
+            location_type = LocationType.OffshoreStrikeTarget
+        else:
+            location_type = LocationType.StrikeTarget
+
+        # Pick from preset locations
+        point = self.location_finder.location_for(location_type)
+        if point is None:
+            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:
+        position = self.location_finder.location_for(LocationType.Sam)
+        if position is None:
+            return
+        self.generate_aa_at(position, ranges=[
+            # Prefer to use proper SAMs, but fall back to SHORADs if needed.
+            {AirDefenseRange.Long, AirDefenseRange.Medium},
+            {AirDefenseRange.Short},
+        ])
+
+    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, for_airbase=False)
+        group = generate_anti_air_group(self.game, g, self.faction, ranges)
+        if group is None:
+            logging.error("Could not generate air defense group for %s at %s",
+                          g.name, self.control_point)
+            return
+        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:
+        position = self.location_finder.location_for(LocationType.MissileSite)
+        if position is None:
+            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 FobGroundObjectGenerator(AirbaseGroundObjectGenerator):
+    def generate(self) -> bool:
+        self.generate_fob()
+        FobDefenseGenerator(self.game, self.control_point).generate()
+        self.generate_required_aa()
+        return True
+
+    def generate_fob(self) -> None:
+        try:
+            category = self.faction.building_set[self.faction.building_set.index('fob')]
+        except IndexError:
+            logging.exception("Faction has no fob buildings defined")
+            return
+
+        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"], airbase_group=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()

game/theater/theatergroundobject.py

@@ -0,0 +1,364 @@
+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}"
+
+    @property
+    def waypoint_name(self) -> str:
+        return f"[{self.name}] {self.category}"
+
+    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)
+
+    @property
+    def alive_unit_count(self) -> int:
+        return sum(len(g.units) for g in self.groups)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return False
+
+
+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, airbase_group=False) -> 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=airbase_group,
+            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}"
+
+    @property
+    def waypoint_name(self) -> str:
+        return f"{super().waypoint_name} #{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)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return True
+
+
+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). 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)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return True
+
+
+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)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return True
+
+
+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}"

game/unitmap.py

@@ -0,0 +1,133 @@
+"""Maps generated units back to their Liberation types."""
+from dataclasses import dataclass
+from typing import Dict, Optional, Type
+
+from dcs.unit import Unit
+from dcs.unitgroup import FlyingGroup, Group, VehicleGroup
+from dcs.unittype import VehicleType
+
+from game import db
+from game.theater import Airfield, ControlPoint, TheaterGroundObject
+from game.theater.theatergroundobject import BuildingGroundObject
+from gen.flights.flight import Flight
+
+
+@dataclass(frozen=True)
+class FrontLineUnit:
+    unit_type: Type[VehicleType]
+    origin: ControlPoint
+
+
+@dataclass(frozen=True)
+class GroundObjectUnit:
+    ground_object: TheaterGroundObject
+    group: Group
+    unit: Unit
+
+
+@dataclass(frozen=True)
+class Building:
+    ground_object: BuildingGroundObject
+
+
+class UnitMap:
+    def __init__(self) -> None:
+        self.aircraft: Dict[str, Flight] = {}
+        self.airfields: Dict[str, Airfield] = {}
+        self.front_line_units: Dict[str, FrontLineUnit] = {}
+        self.ground_object_units: Dict[str, GroundObjectUnit] = {}
+        self.buildings: Dict[str, Building] = {}
+
+    def add_aircraft(self, group: FlyingGroup, flight: Flight) -> None:
+        for unit in group.units:
+            # The actual name is a String (the pydcs translatable string), which
+            # doesn't define __eq__.
+            name = str(unit.name)
+            if name in self.aircraft:
+                raise RuntimeError(f"Duplicate unit name: {name}")
+            self.aircraft[name] = flight
+
+    def flight(self, unit_name: str) -> Optional[Flight]:
+        return self.aircraft.get(unit_name, None)
+
+    def add_airfield(self, airfield: Airfield) -> None:
+        if airfield.name in self.airfields:
+            raise RuntimeError(f"Duplicate airfield: {airfield.name}")
+        self.airfields[airfield.name] = airfield
+
+    def airfield(self, name: str) -> Optional[Airfield]:
+        return self.airfields.get(name, None)
+
+    def add_front_line_units(self, group: Group, origin: ControlPoint) -> None:
+        for unit in group.units:
+            # The actual name is a String (the pydcs translatable string), which
+            # doesn't define __eq__.
+            name = str(unit.name)
+            if name in self.front_line_units:
+                raise RuntimeError(f"Duplicate front line unit: {name}")
+            unit_type = db.unit_type_from_name(unit.type)
+            if unit_type is None:
+                raise RuntimeError(f"Unknown unit type: {unit.type}")
+            if not issubclass(unit_type, VehicleType):
+                raise RuntimeError(
+                    f"{name} is a {unit_type.__name__}, expected a VehicleType")
+            self.front_line_units[name] = FrontLineUnit(unit_type, origin)
+
+    def front_line_unit(self, name: str) -> Optional[FrontLineUnit]:
+        return self.front_line_units.get(name, None)
+
+    def add_ground_object_units(self, ground_object: TheaterGroundObject,
+                                persistence_group: Group,
+                                miz_group: Group) -> None:
+        """Adds a group associated with a TGO to the unit map.
+
+        Args:
+            ground_object: The TGO the group is associated with.
+            persistence_group: The Group tracked by the TGO itself.
+            miz_group: The Group spawned for the miz to match persistence_group.
+        """
+        # Deaths for units at TGOs are recorded in the Group that is contained
+        # by the TGO, but when groundobjectsgen populates the miz it creates new
+        # groups based on that template, so the units and groups in the miz are
+        # not a direct match for the units and groups that persist in the TGO.
+        #
+        # This means that we need to map the spawned unit names back to the
+        # original TGO units, not the ones in the miz.
+        if len(persistence_group.units) != len(miz_group.units):
+            raise ValueError("Persistent group does not match generated group")
+        unit_pairs = zip(persistence_group.units, miz_group.units)
+        for persistent_unit, miz_unit in unit_pairs:
+            # The actual name is a String (the pydcs translatable string), which
+            # doesn't define __eq__.
+            name = str(miz_unit.name)
+            if name in self.ground_object_units:
+                raise RuntimeError(f"Duplicate TGO unit: {name}")
+            self.ground_object_units[name] = GroundObjectUnit(
+                ground_object, persistence_group, persistent_unit)
+
+    def ground_object_unit(self, name: str) -> Optional[GroundObjectUnit]:
+        return self.ground_object_units.get(name, None)
+
+    def add_building(self, ground_object: BuildingGroundObject,
+                     group: Group) -> None:
+        # The actual name is a String (the pydcs translatable string), which
+        # doesn't define __eq__.
+        name = str(group.name)
+        if name in self.buildings:
+            raise RuntimeError(f"Duplicate TGO unit: {name}")
+        self.buildings[name] = Building(ground_object)
+
+    def add_fortification(self, ground_object: BuildingGroundObject,
+                          group: VehicleGroup) -> None:
+        if len(group.units) != 1:
+            raise ValueError("Fortification groups must have exactly one unit.")
+        unit = group.units[0]
+        # The actual name is a String (the pydcs translatable string), which
+        # doesn't define __eq__.
+        name = str(unit.name)
+        if name in self.buildings:
+            raise RuntimeError(f"Duplicate TGO unit: {name}")
+        self.buildings[name] = Building(ground_object)
+
+    def building_or_fortification(self, name: str) -> Optional[Building]:
+        return self.buildings.get(name, None)

game/utils.py

@@ -1,14 +1,75 @@
-def meter_to_feet(value_in_meter):
+def meter_to_feet(value_in_meter: float) -> int:
+    """Converts meters to feets
+
+    :arg value_in_meter Value in meters
+    """
     return int(3.28084 * value_in_meter)
 
 
-def feet_to_meter(value_in_feet):
-    return int(float(value_in_feet)/3.048)
+def feet_to_meter(value_in_feet: float) -> int:
+    """Converts feets to meters
+
+    :arg value_in_feet Value in feets
+    """
+    return int(value_in_feet / 3.28084)
 
 
-def meter_to_nm(value_in_meter):
-    return int(float(value_in_meter)*0.000539957)
+def meter_to_nm(value_in_meter: float) -> int:
+    """Converts meters to nautic miles
+
+    :arg value_in_meter Value in meters
+    """
+    return int(value_in_meter / 1852)
 
 
-def nm_to_meter(value_in_nm):
-    return int(float(value_in_nm)*1852)
+def nm_to_meter(value_in_nm: float) -> int:
+    """Converts nautic miles to meters
+
+    :arg value_in_nm Value in nautic miles
+    """
+    return int(value_in_nm * 1852)
+
+
+def knots_to_kph(value_in_knots: float) -> int:
+    """Converts Knots to Kilometer Per Hour
+
+    :arg value_in_knots Knots 
+    """
+    return int(value_in_knots * 1.852)
+
+
+def mps_to_knots(value_in_mps: float) -> int:
+    """Converts Meters Per Second To Knots
+
+    :arg value_in_mps Meters Per Second
+    """
+    return int(value_in_mps * 1.943)
+
+
+def mps_to_kph(speed: float) -> int:
+    """Converts meters per second to kilometers per hour.
+
+    :arg speed Speed in m/s.
+    """
+    return int(speed * 3.6)
+
+
+def kph_to_mps(speed: float) -> int:
+    """Converts kilometers per hour to meters per second.
+
+    :arg speed Speed in KPH.
+    """
+    return int(speed / 3.6)
+
+
+def heading_sum(h, a) -> int:
+    h += a
+    if h > 360:
+        return h - 360
+    elif h < 0:
+        return 360 + h
+    else:
+        return h
+
+def opposite_heading(h):
+    return heading_sum(h, 180)

game/version.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+
+def _build_version_string() -> str:
+    components = ["2.3.2"]
+    build_number_path = Path("resources/buildnumber")
+    if build_number_path.exists():
+        with build_number_path.open("r") as build_number_file:
+            components.append(build_number_file.readline())
+
+    if not Path("resources/final").exists():
+        components.append("preview")
+
+    return "-".join(components)
+
+
+#: Current version of Liberation.
+VERSION = _build_version_string()

game/weather.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import datetime
+import logging
+import random
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional, TYPE_CHECKING
+
+from dcs.weather import Weather as PydcsWeather, Wind
+
+from game.settings import Settings
+
+if TYPE_CHECKING:
+    from game.theater import ConflictTheater
+
+
+class TimeOfDay(Enum):
+    Dawn = "dawn"
+    Day = "day"
+    Dusk = "dusk"
+    Night = "night"
+
+
+@dataclass(frozen=True)
+class WindConditions:
+    at_0m: Wind
+    at_2000m: Wind
+    at_8000m: Wind
+
+
+@dataclass(frozen=True)
+class Clouds:
+    base: int
+    density: int
+    thickness: int
+    precipitation: PydcsWeather.Preceptions
+
+
+@dataclass(frozen=True)
+class Fog:
+    visibility: int
+    thickness: int
+
+
+class Weather:
+    def __init__(self) -> None:
+        self.clouds = self.generate_clouds()
+        self.fog = self.generate_fog()
+        self.wind = self.generate_wind()
+
+    def generate_clouds(self) -> Optional[Clouds]:
+        raise NotImplementedError
+
+    def generate_fog(self) -> Optional[Fog]:
+        if random.randrange(5) != 0:
+            return None
+        return Fog(
+            visibility=random.randint(2500, 5000),
+            thickness=random.randint(100, 500)
+        )
+
+    def generate_wind(self) -> WindConditions:
+        raise NotImplementedError
+
+    @staticmethod
+    def random_wind(minimum: int, maximum) -> WindConditions:
+        wind_direction = random.randint(0, 360)
+        at_0m_factor = 1
+        at_2000m_factor = 2
+        at_8000m_factor = 3
+        base_wind = random.randint(minimum, maximum)
+
+        return WindConditions(
+            # Always some wind to make the smoke move a bit.
+            at_0m=Wind(wind_direction, max(1, base_wind * at_0m_factor)),
+            at_2000m=Wind(wind_direction, base_wind * at_2000m_factor),
+            at_8000m=Wind(wind_direction, base_wind * at_8000m_factor)
+        )
+
+    @staticmethod
+    def random_cloud_base() -> int:
+        return random.randint(2000, 3000)
+
+    @staticmethod
+    def random_cloud_thickness() -> int:
+        return random.randint(100, 400)
+
+
+class ClearSkies(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return None
+
+    def generate_fog(self) -> Optional[Fog]:
+        return None
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 0)
+
+
+class Cloudy(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return Clouds(
+            base=self.random_cloud_base(),
+            density=random.randint(1, 8),
+            thickness=self.random_cloud_thickness(),
+            precipitation=PydcsWeather.Preceptions.None_
+        )
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 4)
+
+
+class Raining(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return Clouds(
+            base=self.random_cloud_base(),
+            density=random.randint(5, 8),
+            thickness=self.random_cloud_thickness(),
+            precipitation=PydcsWeather.Preceptions.Rain
+        )
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 6)
+
+
+class Thunderstorm(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return Clouds(
+            base=self.random_cloud_base(),
+            density=random.randint(9, 10),
+            thickness=self.random_cloud_thickness(),
+            precipitation=PydcsWeather.Preceptions.Thunderstorm
+        )
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 8)
+
+
+@dataclass
+class Conditions:
+    time_of_day: TimeOfDay
+    start_time: datetime.datetime
+    weather: Weather
+
+    @classmethod
+    def generate(cls, theater: ConflictTheater, day: datetime.date,
+                 time_of_day: TimeOfDay, settings: Settings) -> Conditions:
+        return cls(
+            time_of_day=time_of_day,
+            start_time=cls.generate_start_time(
+                theater, day, time_of_day, settings.night_disabled
+            ),
+            weather=cls.generate_weather()
+        )
+
+    @classmethod
+    def generate_start_time(cls, theater: ConflictTheater, day: datetime.date,
+                            time_of_day: TimeOfDay,
+                            night_disabled: bool) -> datetime.datetime:
+        if night_disabled:
+            logging.info("Skip Night mission due to user settings")
+            time_range = {
+                TimeOfDay.Dawn: (8, 9),
+                TimeOfDay.Day: (10, 12),
+                TimeOfDay.Dusk: (12, 14),
+                TimeOfDay.Night: (14, 17),
+            }[time_of_day]
+        else:
+            time_range = theater.daytime_map[time_of_day.value]
+
+        time = datetime.time(hour=random.randint(*time_range))
+        return datetime.datetime.combine(day, time)
+
+    @classmethod
+    def generate_weather(cls) -> Weather:
+        chances = {
+            Thunderstorm: 1,
+            Raining: 20,
+            Cloudy: 60,
+            ClearSkies: 20,
+        }
+        weather_type = random.choices(list(chances.keys()),
+                                      weights=list(chances.values()))[0]
+        return weather_type()

gen/__init__.py

@@ -1,4 +1,3 @@
-from .aaa import *
 from .aircraft import *
 from .armor import *
 from .airsupportgen import *
@@ -12,4 +11,3 @@ from .forcedoptionsgen import *
 from .kneeboard import *
 
 from . import naming
-

gen/aaa.py

@@ -1,51 +0,0 @@
-from .conflictgen import *
-from .naming import *
-
-from dcs.mission import *
-from dcs.mission import *
-
-from .conflictgen import *
-from .naming import *
-
-DISTANCE_FACTOR = 0.5, 1
-EXTRA_AA_MIN_DISTANCE = 50000
-EXTRA_AA_MAX_DISTANCE = 150000
-EXTRA_AA_POSITION_FROM_CP = 550
-
-class ExtraAAConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game, player_country: Country, enemy_country: Country):
-        self.mission = mission
-        self.game = game
-        self.conflict = conflict
-        self.player_country = player_country
-        self.enemy_country = enemy_country
-
-    def generate(self):
-
-        for cp in self.game.theater.controlpoints:
-            if cp.is_global:
-                continue
-
-            if cp.position.distance_to_point(self.conflict.position) < EXTRA_AA_MIN_DISTANCE:
-                continue
-
-            if cp.position.distance_to_point(self.conflict.from_cp.position) < EXTRA_AA_MIN_DISTANCE:
-                continue
-
-            if cp.position.distance_to_point(self.conflict.to_cp.position) < EXTRA_AA_MIN_DISTANCE:
-                continue
-
-            if cp.position.distance_to_point(self.conflict.position) > EXTRA_AA_MAX_DISTANCE:
-                continue
-
-            country_name = cp.captured and self.player_country or self.enemy_country
-            position = cp.position.point_from_heading(0, EXTRA_AA_POSITION_FROM_CP)
-
-            self.mission.vehicle_group(
-                country=self.mission.country(country_name),
-                name=namegen.next_basedefense_name(),
-                _type=db.EXTRA_AA[country_name],
-                position=position,
-                group_size=1
-            )
-

gen/airfields.py

@@ -3,11 +3,11 @@
 Remove once https://github.com/pydcs/dcs/issues/69 tracks getting the missing
 data added to pydcs. Until then, missing data can be manually filled in here.
 """
-from dataclasses import dataclass, field
-import logging
-from typing import Dict, Iterator, Optional, Tuple
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Tuple
 
-from dcs.terrain.terrain import Airport
 from .radios import MHz, RadioFrequency
 from .tacan import TacanBand, TacanChannel
 
@@ -83,7 +83,7 @@ AIRFIELD_DATA = {
         tacan_callsign="BTM",
         atc=AtcData(MHz(4, 250), MHz(131, 0), MHz(40, 400), MHz(260, 0)),
         ils={
-            "13": ("ILU", MHz(110, 30)),
+            "13": ("ILU", MHz(110, 300)),
         },
     ),
 
@@ -96,7 +96,7 @@ AIRFIELD_DATA = {
         tacan_callsign="KBL",
         atc=AtcData(MHz(4, 350), MHz(133, 0), MHz(40, 800), MHz(262, 0)),
         ils={
-            "07": ("IKB", MHz(111, 50)),
+            "07": ("IKB", MHz(111, 500)),
         },
         outer_ndb={
             "07": ("KT", MHz(870, 0)),
@@ -115,7 +115,7 @@ AIRFIELD_DATA = {
         tacan_callsign="TSK",
         atc=AtcData(MHz(4, 300), MHz(132, 0), MHz(40, 600), MHz(261, 0)),
         ils={
-            "09": ("ITS", MHz(108, 90)),
+            "09": ("ITS", MHz(108, 900)),
         },
         outer_ndb={
             "09": ("BI", MHz(335, 0)),
@@ -134,7 +134,7 @@ AIRFIELD_DATA = {
         tacan_callsign="KTS",
         atc=AtcData(MHz(4, 400), MHz(134, 0), MHz(41, 0), MHz(263, 0)),
         ils={
-            "08": ("IKS", MHz(109, 75)),
+            "08": ("IKS", MHz(109, 750)),
         },
     ),
 
@@ -167,7 +167,7 @@ AIRFIELD_DATA = {
         runway_length=9686,
         atc=AtcData(MHz(4, 50), MHz(127, 0), MHz(39, 600), MHz(256, 0)),
         ils={
-            "06": ("ISO", MHz(111, 10)),
+            "06": ("ISO", MHz(111, 100)),
         },
     ),
 
@@ -195,10 +195,12 @@ AIRFIELD_DATA = {
         runway_length=8623,
         atc=AtcData(MHz(3, 750), MHz(121, 0), MHz(38, 400), MHz(250, 0)),
         outer_ndb={
-            "22": ("AP", MHz(443, 0)), "4": "443.00 (AN)"
+            "22": ("AP", MHz(443, 0)),
+            "04": ("AN", MHz(443)),
         },
         inner_ndb={
-            "22": ("P", MHz(215, 0)), "4": "215.00 (N)"
+            "22": ("P", MHz(215, 0)),
+            "04": ("N", MHz(215)),
         },
     ),
 
@@ -288,8 +290,8 @@ AIRFIELD_DATA = {
         vor=("MN", MHz(117, 10)),
         atc=AtcData(MHz(4, 450), MHz(135, 0), MHz(41, 200), MHz(264, 0)),
         ils={
-            "30": ("IMW", MHz(109, 30)),
-            "12": ("IMD", MHz(111, 70)),
+            "30": ("IMW", MHz(109, 300)),
+            "12": ("IMD", MHz(111, 700)),
         },
         outer_ndb={
             "30": ("NR", MHz(583, 0)),
@@ -308,7 +310,7 @@ AIRFIELD_DATA = {
         runway_length=7082,
         atc=AtcData(MHz(4, 500), MHz(136, 0), MHz(41, 400), MHz(265, 0)),
         ils={
-            "24": ("INL", MHz(110, 50)),
+            "24": ("INL", MHz(110, 500)),
         },
         outer_ndb={
             "24": ("NL", MHz(718, 0)),
@@ -346,7 +348,7 @@ AIRFIELD_DATA = {
         runway_length=9327,
         atc=AtcData(MHz(4, 750), MHz(141, 0), MHz(42, 400), MHz(270, 0)),
         ils={
-            "10": ("ICH", MHz(110, 50)),
+            "10": ("ICH", MHz(110, 500)),
         },
         outer_ndb={
             "10": ("CX", MHz(1, 5)),
@@ -365,8 +367,8 @@ AIRFIELD_DATA = {
         tacan_callsign="GTB",
         atc=AtcData(MHz(4, 600), MHz(138, 0), MHz(41, 800), MHz(267, 0)),
         ils={
-            "13": ("INA", MHz(110, 30)),
-            "30": ("INA", MHz(108, 90)),
+            "13": ("INA", MHz(110, 300)),
+            "30": ("INA", MHz(108, 900)),
         },
         outer_ndb={
             "13": ("BP", MHz(342, 0)),
@@ -397,8 +399,8 @@ AIRFIELD_DATA = {
         tacan_callsign="VAS",
         atc=AtcData(MHz(4, 700), MHz(140, 0), MHz(42, 200), MHz(269, 0)),
         ils={
-            "13": ("IVZ", MHz(108, 75)),
-            "31": ("IVZ", MHz(108, 75)),
+            "13": ("IVZ", MHz(108, 750)),
+            "31": ("IVZ", MHz(108, 750)),
         },
     ),
 
@@ -1014,8 +1016,8 @@ AIRFIELD_DATA = {
         tacan_callsign="TQQ",
         atc=AtcData(MHz(3, 800), MHz(124, 750), MHz(38, 500), MHz(257, 950)),
         ils={
-            "32": ("I-UVV", MHz(111, 70)),
-            "14": ("I-RVP", MHz(108, 30)),
+            "32": ("I-UVV", MHz(111, 700)),
+            "14": ("I-RVP", MHz(108, 300)),
         },
     ),
 
@@ -1041,7 +1043,7 @@ AIRFIELD_DATA = {
         tacan_callsign="GRL",
         atc=AtcData(MHz(3, 850), MHz(118, 0), MHz(38, 600), MHz(250, 50)),
         ils={
-            "32": ("GLRI", MHz(109, 30)),
+            "32": ("GLRI", MHz(109, 300)),
         },
     ),
 
@@ -1067,7 +1069,7 @@ AIRFIELD_DATA = {
         tacan_callsign="INS",
         atc=AtcData(MHz(3, 825), MHz(118, 300), MHz(38, 550), MHz(360, 600)),
         ils={
-            "8": ("ICRR", MHz(108, 70)),
+            "8": ("ICRR", MHz(108, 700)),
         },
     ),
 
@@ -1090,7 +1092,7 @@ AIRFIELD_DATA = {
         tacan_callsign="LSV",
         atc=AtcData(MHz(3, 900), MHz(132, 550), MHz(38, 700), MHz(327, 0)),
         ils={
-            "21": ("IDIQ", MHz(109, 10)),
+            "21": ("IDIQ", MHz(109, 100)),
         },
     ),
 
@@ -1111,7 +1113,7 @@ AIRFIELD_DATA = {
         tacan_callsign="LAS",
         atc=AtcData(MHz(3, 875), MHz(119, 900), MHz(38, 650), MHz(257, 800)),
         ils={
-            "25": ("I-LAS", MHz(110, 30)),
+            "25": ("I-LAS", MHz(110, 300)),
         },
     ),
 
@@ -1501,61 +1503,3 @@ AIRFIELD_DATA = {
         atc=AtcData(MHz(3, 775), MHz(118, 50), MHz(38, 450), MHz(250, 50)),
     ),
 }
-
-
-@dataclass(frozen=True)
-class RunwayData:
-    airfield_name: str
-    runway_name: str
-    atc: Optional[RadioFrequency] = None
-    tacan: Optional[TacanChannel] = None
-    tacan_callsign: Optional[str] = None
-    ils: Optional[RadioFrequency] = None
-    icls: Optional[int] = None
-
-    @classmethod
-    def for_airfield(cls, airport: Airport, runway: str) -> "RunwayData":
-        """Creates RunwayData for the given runway of an airfield.
-
-        Args:
-            airport: The airfield the runway belongs to.
-            runway: Identifier of the runway to use. e.g. "03" or "20L".
-        """
-        atc: Optional[RadioFrequency] = None
-        tacan: Optional[TacanChannel] = None
-        tacan_callsign: Optional[str] = None
-        ils: Optional[RadioFrequency] = None
-        try:
-            airfield = AIRFIELD_DATA[airport.name]
-            if airfield.atc is not None:
-                atc = airfield.atc.uhf
-            else:
-                atc = None
-            tacan = airfield.tacan
-            tacan_callsign = airfield.tacan_callsign
-            ils = airfield.ils_freq(runway)
-        except KeyError:
-            logging.warning(f"No airfield data for {airport.name}")
-        return cls(
-            airfield_name=airport.name,
-            runway_name=runway,
-            atc=atc,
-            tacan=tacan,
-            tacan_callsign=tacan_callsign,
-            ils=ils
-        )
-
-    @classmethod
-    def for_pydcs_airport(cls, airport: Airport) -> Iterator["RunwayData"]:
-        for runway in airport.runways:
-            runway_number = runway.heading // 10
-            runway_side = ["", "L", "R"][runway.leftright]
-            runway_name = f"{runway_number:02}{runway_side}"
-            yield cls.for_airfield(airport, runway_name)
-
-            # pydcs only exposes one runway per physical runway, so to expose
-            # both sides of the runway we need to generate the other.
-            runway_number = ((runway.heading + 180) % 360) // 10
-            runway_side = ["", "R", "L"][runway.leftright]
-            runway_name = f"{runway_number:02}{runway_side}"
-            yield cls.for_airfield(airport, runway_name)

gen/airsupportgen.py

@@ -1,8 +1,23 @@
+import logging
 from dataclasses import dataclass, field
+from typing import List, Type, Tuple
 
+from dcs.mission import Mission, StartType
+from dcs.planes import IL_78M, KC130, KC135MPRS, KC_135
+from dcs.unittype import UnitType
+from dcs.task import (
+    AWACS,
+    ActivateBeaconCommand,
+    MainTask,
+    Refueling,
+    SetImmortalCommand,
+    SetInvisibleCommand,
+)
+
+from game import db
+from .naming import namegen
 from .callsigns import callsign_for_support_unit
-from .conflictgen import *
-from .naming import *
+from .conflictgen import Conflict
 from .radios import RadioFrequency, RadioRegistry
 from .tacan import TacanBand, TacanChannel, TacanRegistry
 
@@ -17,6 +32,7 @@ AWACS_ALT = 13000
 @dataclass
 class AwacsInfo:
     """AWACS information for the kneeboard."""
+    dcsGroupName: str
     callsign: str
     freq: RadioFrequency
 
@@ -24,6 +40,7 @@ class AwacsInfo:
 @dataclass
 class TankerInfo:
     """Tanker information for the kneeboard."""
+    dcsGroupName: str
     callsign: str
     variant: str
     freq: RadioFrequency
@@ -49,16 +66,27 @@ class AirSupportConflictGenerator:
         self.tacan_registry = tacan_registry
 
     @classmethod
-    def support_tasks(cls) -> typing.Collection[typing.Type[MainTask]]:
+    def support_tasks(cls) -> List[Type[MainTask]]:
         return [Refueling, AWACS]
 
-    def generate(self, is_awacs_enabled):
+    @staticmethod
+    def _get_tanker_params(unit_type: Type[UnitType]) -> Tuple[int, int]:
+        if unit_type is KC130:
+            return (TANKER_ALT - 500, 596)
+        elif unit_type is KC_135:
+            return (TANKER_ALT, 770)
+        elif unit_type is KC135MPRS:
+            return (TANKER_ALT + 500, 596)
+        return (TANKER_ALT, 574)
+        
+    def generate(self):
         player_cp = self.conflict.from_cp if self.conflict.from_cp.captured else self.conflict.to_cp
 
         fallback_tanker_number = 0
 
         for i, tanker_unit_type in enumerate(db.find_unittype(Refueling, self.conflict.attackers_side)):
-            variant = db.unit_type_name(tanker_unit_type)
+            alt, airspeed = self._get_tanker_params(tanker_unit_type)
+            variant = db.unit_type_name(tanker_unit_type)            
             freq = self.radio_registry.alloc_uhf()
             tacan = self.tacan_registry.alloc_for_band(TacanBand.Y)
             tanker_heading = self.conflict.to_cp.position.heading_between_point(self.conflict.from_cp.position) + TANKER_HEADING_OFFSET * i
@@ -69,13 +97,14 @@ class AirSupportConflictGenerator:
                 airport=None,
                 plane_type=tanker_unit_type,
                 position=tanker_position,
-                altitude=TANKER_ALT,
+                altitude=alt,
                 race_distance=58000,
                 frequency=freq.mhz,
                 start_type=StartType.Warm,
-                speed=574,
+                speed=airspeed,
                 tacanchannel=str(tacan),
             )
+            tanker_group.set_frequency(freq.mhz)
 
             callsign = callsign_for_support_unit(tanker_group)
             tacan_callsign = {
@@ -102,26 +131,30 @@ class AirSupportConflictGenerator:
             tanker_group.points[0].tasks.append(SetInvisibleCommand(True))
             tanker_group.points[0].tasks.append(SetImmortalCommand(True))
 
-            self.air_support.tankers.append(TankerInfo(callsign, variant, freq, tacan))
+            self.air_support.tankers.append(TankerInfo(str(tanker_group.name), callsign, variant, freq, tacan))
 
-        if is_awacs_enabled:
-            try:
-                freq = self.radio_registry.alloc_uhf()
-                awacs_unit = db.find_unittype(AWACS, self.conflict.attackers_side)[0]
-                awacs_flight = self.mission.awacs_flight(
-                    country=self.mission.country(self.game.player_country),
-                    name=namegen.next_awacs_name(self.mission.country(self.game.player_country)),
-                    plane_type=awacs_unit,
-                    altitude=AWACS_ALT,
-                    airport=None,
-                    position=self.conflict.position.random_point_within(AWACS_DISTANCE, AWACS_DISTANCE),
-                    frequency=freq.mhz,
-                    start_type=StartType.Warm,
-                )
-                awacs_flight.points[0].tasks.append(SetInvisibleCommand(True))
-                awacs_flight.points[0].tasks.append(SetImmortalCommand(True))
+        possible_awacs = db.find_unittype(AWACS, self.conflict.attackers_side)
 
-                self.air_support.awacs.append(AwacsInfo(
-                    callsign_for_support_unit(awacs_flight), freq))
-            except:
-                print("No AWACS for faction")
+        if len(possible_awacs) > 0:
+            awacs_unit = possible_awacs[0]
+            freq = self.radio_registry.alloc_uhf()
+            
+            awacs_flight = self.mission.awacs_flight(
+                country=self.mission.country(self.game.player_country),
+                name=namegen.next_awacs_name(self.mission.country(self.game.player_country)),
+                plane_type=awacs_unit,
+                altitude=AWACS_ALT,
+                airport=None,
+                position=self.conflict.position.random_point_within(AWACS_DISTANCE, AWACS_DISTANCE),
+                frequency=freq.mhz,
+                start_type=StartType.Warm,
+            )
+            awacs_flight.set_frequency(freq.mhz)
+
+            awacs_flight.points[0].tasks.append(SetInvisibleCommand(True))
+            awacs_flight.points[0].tasks.append(SetImmortalCommand(True))
+
+            self.air_support.awacs.append(AwacsInfo(
+                str(awacs_flight.name), callsign_for_support_unit(awacs_flight), freq))
+        else:
+            logging.warning("No AWACS for faction")

gen/armor.py

@@ -1,13 +1,39 @@
+from __future__ import annotations
+
+import logging
+import random
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional, Tuple
 
+from dcs import Mission
 from dcs.action import AITaskPush
-from dcs.condition import TimeAfter, UnitDamaged, Or, GroupLifeLess
-from dcs.triggers import TriggerOnce, Event
+from dcs.condition import GroupLifeLess, Or, TimeAfter, UnitDamaged
+from dcs.country import Country
+from dcs.mapping import Point
+from dcs.planes import MQ_9_Reaper
+from dcs.point import PointAction
+from dcs.task import (EPLRS, AttackGroup, ControlledTask, FireAtPoint,
+                      GoToWaypoint, Hold, OrbitAction, SetImmortalCommand,
+                      SetInvisibleCommand)
+from dcs.triggers import Event, TriggerOnce
+from dcs.unit import Vehicle
+from dcs.unitgroup import VehicleGroup
+from dcs.unittype import VehicleType
+from game import db
+from game.unitmap import UnitMap
+from game.utils import heading_sum, opposite_heading
+from game.theater.controlpoint import ControlPoint
+
+from gen.ground_forces.ai_ground_planner import (DISTANCE_FROM_FRONTLINE,
+                                                 CombatGroup, CombatGroupRole)
 
-from gen import namegen
-from gen.ground_forces.ai_ground_planner import CombatGroupRole, DISTANCE_FROM_FRONTLINE
 from .callsigns import callsign_for_support_unit
-from .conflictgen import *
+from .conflictgen import Conflict
+from .ground_forces.combat_stance import CombatStance
+from .naming import namegen
+
+if TYPE_CHECKING:
+    from game import Game
 
 SPREAD_DISTANCE_FACTOR = 0.1, 0.3
 SPREAD_DISTANCE_SIZE_FACTOR = 0.1
@@ -28,6 +54,7 @@ RANDOM_OFFSET_ATTACK = 250
 @dataclass(frozen=True)
 class JtacInfo:
     """JTAC information."""
+    dcsGroupName: str
     unit_name: str
     callsign: str
     region: str
@@ -37,88 +64,96 @@ class JtacInfo:
 
 class GroundConflictGenerator:
 
-    def __init__(self, mission: Mission, conflict: Conflict, game, player_planned_combat_groups, enemy_planned_combat_groups, player_stance):
+    def __init__(
+            self,
+            mission: Mission,
+            conflict: Conflict,
+            game: Game,
+            player_planned_combat_groups: List[CombatGroup],
+            enemy_planned_combat_groups: List[CombatGroup],
+            player_stance: CombatStance,
+            unit_map: UnitMap) -> None:
         self.mission = mission
         self.conflict = conflict
         self.enemy_planned_combat_groups = enemy_planned_combat_groups
         self.player_planned_combat_groups = player_planned_combat_groups
         self.player_stance = CombatStance(player_stance)
-        self.enemy_stance = random.choice([CombatStance.AGGRESSIVE, CombatStance.AGGRESSIVE, CombatStance.AGGRESSIVE, CombatStance.ELIMINATION, CombatStance.BREAKTHROUGH]) if len(enemy_planned_combat_groups) > len(player_planned_combat_groups) else random.choice([CombatStance.DEFENSIVE, CombatStance.DEFENSIVE, CombatStance.DEFENSIVE, CombatStance.AMBUSH, CombatStance.AGGRESSIVE])
+        self.enemy_stance = self._enemy_stance()
         self.game = game
+        self.unit_map = unit_map
         self.jtacs: List[JtacInfo] = []
 
-    def _group_point(self, point) -> Point:
-        distance = randint(
-                int(self.conflict.size * SPREAD_DISTANCE_FACTOR[0]),
-                int(self.conflict.size * SPREAD_DISTANCE_FACTOR[1]),
+    def _enemy_stance(self):
+        """Picks the enemy stance according to the number of planned groups on the frontline for each side"""
+        if len(self.enemy_planned_combat_groups) > len(self.player_planned_combat_groups):
+            return random.choice(
+                [
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.ELIMINATION,
+                    CombatStance.BREAKTHROUGH
+                ]
+            )
+        else:
+            return random.choice(
+                [
+                    CombatStance.DEFENSIVE,
+                    CombatStance.DEFENSIVE,
+                    CombatStance.DEFENSIVE,
+                    CombatStance.AMBUSH,
+                    CombatStance.AGGRESSIVE
+                ]
+            )
+
+    @staticmethod
+    def _group_point(point: Point, base_distance) -> Point:
+        distance = random.randint(
+                int(base_distance * SPREAD_DISTANCE_FACTOR[0]),
+                int(base_distance * SPREAD_DISTANCE_FACTOR[1]),
                 )
-        return point.random_point_within(distance, self.conflict.size * SPREAD_DISTANCE_SIZE_FACTOR)
+        return point.random_point_within(distance, base_distance * SPREAD_DISTANCE_SIZE_FACTOR)
 
     def generate(self):
-
-        player_groups = []
-        enemy_groups = []
-
-        combat_width = self.conflict.distance/2
-        if combat_width > 500000:
-            combat_width = 500000
-        if combat_width < 35000:
-            combat_width = 35000
-
-        position = Conflict.frontline_position(self.game.theater, self.conflict.from_cp, self.conflict.to_cp)
+        position = Conflict.frontline_position(self.conflict.from_cp, self.conflict.to_cp, self.game.theater)
+        frontline_vector = Conflict.frontline_vector(
+            self.conflict.from_cp,
+            self.conflict.to_cp,
+            self.game.theater
+            )
 
         # Create player groups at random position
-        for group in self.player_planned_combat_groups:
-            if group.role == CombatGroupRole.ARTILLERY:
-                distance_from_frontline = self.get_artilery_group_distance_from_frontline(group)
-            else:
-                distance_from_frontline = DISTANCE_FROM_FRONTLINE[group.role]
-            final_position = self.get_valid_position_for_group(position, True, combat_width, distance_from_frontline)
-
-            if final_position is not None:
-                g = self._generate_group(
-                    side=self.mission.country(self.game.player_country),
-                    unit=group.units[0],
-                    heading=self.conflict.heading+90,
-                    count=len(group.units),
-                    at=final_position)
-                g.set_skill(self.game.settings.player_skill)
-                player_groups.append((g,group))
-
-                self.gen_infantry_group_for_group(g, True, self.mission.country(self.game.player_country), self.conflict.heading + 90)
+        player_groups = self._generate_groups(self.player_planned_combat_groups, frontline_vector, True)
 
         # Create enemy groups at random position
-        for group in self.enemy_planned_combat_groups:
-            if group.role == CombatGroupRole.ARTILLERY:
-                distance_from_frontline = self.get_artilery_group_distance_from_frontline(group)
-            else:
-                distance_from_frontline = DISTANCE_FROM_FRONTLINE[group.role]
-            final_position = self.get_valid_position_for_group(position, False, combat_width, distance_from_frontline)
-
-            if final_position is not None:
-                g = self._generate_group(
-                    side=self.mission.country(self.game.enemy_country),
-                    unit=group.units[0],
-                    heading=self.conflict.heading - 90,
-                    count=len(group.units),
-                    at=final_position)
-                g.set_skill(self.game.settings.enemy_vehicle_skill)
-                enemy_groups.append((g, group))
-
-                self.gen_infantry_group_for_group(g, False, self.mission.country(self.game.enemy_country), self.conflict.heading - 90)
+        enemy_groups = self._generate_groups(self.enemy_planned_combat_groups, frontline_vector, False)
 
         # Plan combat actions for groups
-        self.plan_action_for_groups(self.player_stance, player_groups, enemy_groups, self.conflict.heading + 90, self.conflict.from_cp, self.conflict.to_cp)
-        self.plan_action_for_groups(self.enemy_stance, enemy_groups, player_groups, self.conflict.heading - 90, self.conflict.to_cp, self.conflict.from_cp)
+        self.plan_action_for_groups(
+            self.player_stance,
+            player_groups,
+            enemy_groups,
+            self.conflict.heading + 90,
+            self.conflict.from_cp,
+            self.conflict.to_cp
+        )
+        self.plan_action_for_groups(
+            self.enemy_stance,
+            enemy_groups,
+            player_groups,
+            self.conflict.heading - 90,
+            self.conflict.to_cp,
+            self.conflict.from_cp
+        )
 
         # Add JTAC
-        if "has_jtac" in self.game.player_faction and self.game.player_faction["has_jtac"] and self.game.settings.include_jtac_if_available:
+        if self.game.player_faction.has_jtac:
             n = "JTAC" + str(self.conflict.from_cp.id) + str(self.conflict.to_cp.id)
             code = 1688 - len(self.jtacs)
 
             utype = MQ_9_Reaper
-            if "jtac_unit" in self.game.player_faction:
-                utype = self.game.player_faction["jtac_unit"]
+            if self.game.player_faction.jtac_unit is not None:
+                utype = self.game.player_faction.jtac_unit
 
             jtac = self.mission.flight_group(country=self.mission.country(self.game.player_country),
                                              name=n,
@@ -132,16 +167,25 @@ class GroundConflictGenerator:
             frontline = f"Frontline {self.conflict.from_cp.name}/{self.conflict.to_cp.name}"
             # Note: Will need to change if we ever add ground based JTAC.
             callsign = callsign_for_support_unit(jtac)
-            self.jtacs.append(JtacInfo(n, callsign, frontline, str(code)))
+            self.jtacs.append(JtacInfo(str(jtac.name), n, callsign, frontline, str(code)))
 
-    def gen_infantry_group_for_group(self, group, is_player, side:Country, forward_heading):
+    def gen_infantry_group_for_group(
+        self,
+        group: VehicleGroup,
+        is_player: bool,
+        side: Country,
+        forward_heading: int
+    ) -> None:
 
-        # Disable infantry unit gen if disabled
-        if not self.game.settings.perf_infantry:
+        infantry_position = self.conflict.find_ground_position(
+            group.points[0].position.random_point_within(250, 50),
+            500,
+            forward_heading,
+            self.conflict.theater
+            )
+        if not infantry_position:
+            logging.warning("Could not find infantry position")
             return
-
-        infantry_position = group.points[0].position.random_point_within(250, 50)
-
         if side == self.conflict.attackers_country:
             cp = self.conflict.from_cp
         else:
@@ -152,7 +196,24 @@ class GroundConflictGenerator:
         else:
             faction = self.game.enemy_name
 
-        possible_infantry_units = db.find_infantry(faction)
+        # Disable infantry unit gen if disabled
+        if not self.game.settings.perf_infantry:
+            if self.game.settings.manpads:
+                # 50% of armored units protected by manpad
+                if random.choice([True, False]):
+                    manpads = db.find_manpad(faction)
+                    if len(manpads) > 0:
+                        u = random.choice(manpads)
+                        self.mission.vehicle_group(
+                            side,
+                            namegen.next_infantry_name(side, cp, u), u,
+                            position=infantry_position,
+                            group_size=1,
+                            heading=forward_heading,
+                            move_formation=PointAction.OffRoad)
+            return
+
+        possible_infantry_units = db.find_infantry(faction, allow_manpad=self.game.settings.manpads)
         if len(possible_infantry_units) == 0:
             return
 
@@ -165,7 +226,7 @@ class GroundConflictGenerator:
                 heading=forward_heading,
                 move_formation=PointAction.OffRoad)
 
-        for i in range(randint(3, 10)):
+        for i in range(random.randint(3, 10)):
             u = random.choice(possible_infantry_units)
             position = infantry_position.random_point_within(55, 5)
             self.mission.vehicle_group(
@@ -176,120 +237,217 @@ class GroundConflictGenerator:
                 heading=forward_heading,
                 move_formation=PointAction.OffRoad)
 
+    def _set_reform_waypoint(
+        self,
+        dcs_group: VehicleGroup,
+        forward_heading: int
+    ) -> None:
+        """Setting a waypoint close to the spawn position allows the group to reform gracefully
+        rather than spin        
+        """
+        reform_point = dcs_group.position.point_from_heading(forward_heading, 50)
+        dcs_group.add_waypoint(reform_point)
 
-    def plan_action_for_groups(self, stance, ally_groups, enemy_groups, forward_heading, from_cp, to_cp):
+    def _plan_artillery_action(
+        self,
+        stance: CombatStance,
+        gen_group: CombatGroup,
+        dcs_group: VehicleGroup,
+        forward_heading: int,
+        target: Point
+    ) -> bool:
+        """
+        Handles adding the DCS tasks for artillery groups for all combat stances.
+        Returns True if tasking was added, returns False if the stance was not a combat stance.
+        """
+        self._set_reform_waypoint(dcs_group, forward_heading)
+        if stance != CombatStance.RETREAT:
+            hold_task = Hold()
+            hold_task.number = 1
+            dcs_group.add_trigger_action(hold_task)
+
+        # Artillery strike random start
+        artillery_trigger = TriggerOnce(Event.NoEvent, "ArtilleryFireTask #" + str(dcs_group.id))
+        artillery_trigger.add_condition(TimeAfter(seconds=random.randint(1, 45) * 60))
+        # TODO: Update to fire at group instead of point
+        fire_task = FireAtPoint(target, len(gen_group.units) * 10, 100)
+        fire_task.number = 2 if stance != CombatStance.RETREAT else 1
+        dcs_group.add_trigger_action(fire_task)
+        artillery_trigger.add_action(AITaskPush(dcs_group.id, len(dcs_group.tasks)))
+        self.mission.triggerrules.triggers.append(artillery_trigger)
+
+        # Artillery will fall back when under attack
+        if stance != CombatStance.RETREAT:
+
+            # Hold position
+            dcs_group.points[1].tasks.append(Hold())
+            retreat = self.find_retreat_point(dcs_group, heading_sum(forward_heading, 180), (int)(RETREAT_DISTANCE/3))
+            dcs_group.add_waypoint(dcs_group.position.point_from_heading(forward_heading, 1), PointAction.OffRoad)
+            dcs_group.points[2].tasks.append(Hold())
+            dcs_group.add_waypoint(retreat, PointAction.OffRoad)
+
+            artillery_fallback = TriggerOnce(Event.NoEvent, "ArtilleryRetreat #" + str(dcs_group.id))
+            for i, u in enumerate(dcs_group.units):
+                artillery_fallback.add_condition(UnitDamaged(u.id))
+                if i < len(dcs_group.units) - 1:
+                    artillery_fallback.add_condition(Or())
+
+            hold_2 = Hold()
+            hold_2.number = 3
+            dcs_group.add_trigger_action(hold_2)
+
+            retreat_task = GoToWaypoint(to_index=3)
+            retreat_task.number = 4
+            dcs_group.add_trigger_action(retreat_task)
+
+            artillery_fallback.add_action(AITaskPush(dcs_group.id, len(dcs_group.tasks)))
+            self.mission.triggerrules.triggers.append(artillery_fallback)
+
+            for u in dcs_group.units:
+                u.initial = True
+                u.heading = forward_heading + random.randint(-5, 5)
+            return True
+        return False
+
+    def _plan_tank_ifv_action(
+        self,
+        stance: CombatStance,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        dcs_group: VehicleGroup,
+        forward_heading: int,
+        to_cp: ControlPoint,
+    ) -> bool:
+        """
+        Handles adding the DCS tasks for tank and IFV groups for all combat stances.
+        Returns True if tasking was added, returns False if the stance was not a combat stance.
+        """
+        self._set_reform_waypoint(dcs_group, forward_heading)
+        if stance == CombatStance.AGGRESSIVE:
+            # Attack nearest enemy if any
+            # Then move forward OR Attack enemy base if it is not too far away
+            target = self.find_nearest_enemy_group(dcs_group, enemy_groups)
+            if target is not None:
+                rand_offset = Point(
+                    random.randint(
+                        -RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK
+                    ),
+                    random.randint(
+                        -RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK
+                    )
+                )
+                target_point = self.conflict.theater.nearest_land_pos(
+                    target.points[0].position + rand_offset
+                )
+                dcs_group.add_waypoint(target_point)
+                dcs_group.points[2].tasks.append(AttackGroup(target.id))
+
+            if (
+                to_cp.position.distance_to_point(dcs_group.points[0].position)
+                <=
+                AGGRESIVE_MOVE_DISTANCE
+            ):
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+            else:
+                attack_point = self.find_offensive_point(
+                    dcs_group,
+                    forward_heading,
+                    AGGRESIVE_MOVE_DISTANCE
+                )
+            dcs_group.add_waypoint(attack_point, PointAction.OffRoad)
+        elif stance == CombatStance.BREAKTHROUGH:
+            # In breakthrough mode, the units will move forward
+            # If the enemy base is close enough, the units will attack the base
+            if to_cp.position.distance_to_point(
+                    dcs_group.points[0].position) <= BREAKTHROUGH_OFFENSIVE_DISTANCE:
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+            else:
+                attack_point = self.find_offensive_point(dcs_group, forward_heading, BREAKTHROUGH_OFFENSIVE_DISTANCE)
+            dcs_group.add_waypoint(attack_point, PointAction.OffRoad)
+        elif stance == CombatStance.ELIMINATION:
+            # In elimination mode, the units focus on destroying as much enemy groups as possible
+            targets = self.find_n_nearest_enemy_groups(dcs_group, enemy_groups, 3)
+            for i, target in enumerate(targets, start=1):
+                rand_offset = Point(
+                    random.randint(
+                        -RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK
+                    ),
+                    random.randint(
+                        -RANDOM_OFFSET_ATTACK,
+                        RANDOM_OFFSET_ATTACK
+                    )
+                )
+                target_point = self.conflict.theater.nearest_land_pos(
+                    target.points[0].position+rand_offset
+                )
+                dcs_group.add_waypoint(target_point, PointAction.OffRoad)
+                dcs_group.points[i + 1].tasks.append(AttackGroup(target.id))
+            if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+                dcs_group.add_waypoint(attack_point)
+
+        if stance != CombatStance.RETREAT:
+            self.add_morale_trigger(dcs_group, forward_heading)
+            return True
+        return False
+
+    def _plan_apc_atgm_action(
+        self,
+        stance: CombatStance,
+        dcs_group: VehicleGroup,
+        forward_heading: int,
+        to_cp: ControlPoint,
+    ) -> bool:
+        """
+        Handles adding the DCS tasks for APC and ATGM groups for all combat stances.
+        Returns True if tasking was added, returns False if the stance was not a combat stance.
+        """
+        self._set_reform_waypoint(dcs_group, forward_heading)
+        if stance in [CombatStance.AGGRESSIVE, CombatStance.BREAKTHROUGH, CombatStance.ELIMINATION]:
+            # APC & ATGM will never move too much forward, but will follow along any offensive
+            if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
+                attack_point = self.conflict.theater.nearest_land_pos(to_cp.position.random_point_within(500, 0))
+            else:
+                attack_point = self.find_offensive_point(dcs_group, forward_heading, AGGRESIVE_MOVE_DISTANCE)
+            dcs_group.add_waypoint(attack_point, PointAction.OffRoad)
+
+        if stance != CombatStance.RETREAT:
+            self.add_morale_trigger(dcs_group, forward_heading)
+            return True
+        return False
+
+    def plan_action_for_groups(
+        self, stance: CombatStance,
+        ally_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        forward_heading: int,
+        from_cp: ControlPoint,
+        to_cp: ControlPoint
+    ) -> None:
 
         if not self.game.settings.perf_moving_units:
             return
 
         for dcs_group, group in ally_groups:
+            if hasattr(group.units[0], 'eplrs') and group.units[0].eplrs:
+                dcs_group.points[0].tasks.append(EPLRS(dcs_group.id))
+
             if group.role == CombatGroupRole.ARTILLERY:
-                # Fire on any ennemy in range
                 if self.game.settings.perf_artillery:
                     target = self.get_artillery_target_in_range(dcs_group, group, enemy_groups)
                     if target is not None:
-
-                        if stance != CombatStance.RETREAT:
-                            hold_task = Hold()
-                            hold_task.number = 1
-                            dcs_group.add_trigger_action(hold_task)
-
-                        # Artillery strike random start
-                        artillery_trigger = TriggerOnce(Event.NoEvent, "ArtilleryFireTask #" + str(dcs_group.id))
-                        artillery_trigger.add_condition(TimeAfter(seconds=random.randint(1, 45)* 60))
-
-                        fire_task = FireAtPoint(target, len(group.units) * 10, 100)
-                        if stance != CombatStance.RETREAT:
-                            fire_task.number = 2
-                        else:
-                            fire_task.number = 1
-                        dcs_group.add_trigger_action(fire_task)
-                        artillery_trigger.add_action(AITaskPush(dcs_group.id, len(dcs_group.tasks)))
-                        self.mission.triggerrules.triggers.append(artillery_trigger)
-
-                        # Artillery will fall back when under attack
-                        if stance != CombatStance.RETREAT:
-
-                            # Hold position
-                            dcs_group.points[0].tasks.append(Hold())
-                            retreat = self.find_retreat_point(dcs_group, forward_heading, (int)(RETREAT_DISTANCE/3))
-                            dcs_group.add_waypoint(dcs_group.position.point_from_heading(forward_heading, 1), PointAction.OffRoad)
-                            dcs_group.points[1].tasks.append(Hold())
-                            dcs_group.add_waypoint(retreat, PointAction.OffRoad)
-
-                            artillery_fallback = TriggerOnce(Event.NoEvent, "ArtilleryRetreat #" + str(dcs_group.id))
-                            for i, u in enumerate(dcs_group.units):
-                                artillery_fallback.add_condition(UnitDamaged(u.id))
-                                if i < len(dcs_group.units) - 1:
-                                    artillery_fallback.add_condition(Or())
-
-                            hold_2 = Hold()
-                            hold_2.number = 3
-                            dcs_group.add_trigger_action(hold_2)
-
-                            retreat_task = GoToWaypoint(toIndex=3)
-                            retreat_task.number = 4
-                            dcs_group.add_trigger_action(retreat_task)
-
-                            artillery_fallback.add_action(AITaskPush(dcs_group.id, len(dcs_group.tasks)))
-                            self.mission.triggerrules.triggers.append(artillery_fallback)
-
-                            for u in dcs_group.units:
-                                u.initial = True
-                                u.heading = forward_heading + random.randint(-5,5)
+                        self._plan_artillery_action(stance, group, dcs_group, forward_heading, target)
 
             elif group.role in [CombatGroupRole.TANK, CombatGroupRole.IFV]:
-                if stance == CombatStance.AGGRESSIVE:
-                    # Attack nearest enemy if any
-                    # Then move forward OR Attack enemy base if it is not too far away
-                    target = self.find_nearest_enemy_group(dcs_group, enemy_groups)
-                    if target is not None:
-                        rand_offset = Point(random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK), random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK))
-                        dcs_group.add_waypoint(target.points[0].position + rand_offset, PointAction.OffRoad)
-                        dcs_group.points[1].tasks.append(AttackGroup(target.id))
-
-                    if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
-                        attack_point = to_cp.position.random_point_within(500, 0)
-                    else:
-                        attack_point = self.find_offensive_point(dcs_group, forward_heading, AGGRESIVE_MOVE_DISTANCE)
-                    dcs_group.add_waypoint(attack_point, PointAction.OnRoad)
-                elif stance == CombatStance.BREAKTHROUGH:
-                    # In breakthrough mode, the units will move forward
-                    # If the enemy base is close enough, the units will attack the base
-                    if to_cp.position.distance_to_point(
-                            dcs_group.points[0].position) <= BREAKTHROUGH_OFFENSIVE_DISTANCE:
-                        attack_point = to_cp.position.random_point_within(500, 0)
-                    else:
-                        attack_point = self.find_offensive_point(dcs_group, forward_heading, BREAKTHROUGH_OFFENSIVE_DISTANCE)
-                    dcs_group.add_waypoint(attack_point, PointAction.OnRoad)
-                elif stance == CombatStance.ELIMINATION:
-                    # In elimination mode, the units focus on destroying as much enemy groups as possible
-                    targets = self.find_n_nearest_enemy_groups(dcs_group, enemy_groups, 3)
-                    i = 1
-                    for target in targets:
-                        rand_offset = Point(random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK), random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK))
-                        dcs_group.add_waypoint(target.points[0].position+rand_offset, PointAction.OffRoad)
-                        dcs_group.points[i].tasks.append(AttackGroup(target.id))
-                        i = i + 1
-                    if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
-                        attack_point = to_cp.position.random_point_within(500, 0)
-                        dcs_group.add_waypoint(attack_point)
-
-                if stance != CombatStance.RETREAT:
-                    self.add_morale_trigger(dcs_group, forward_heading)
+                self._plan_tank_ifv_action(stance, enemy_groups, dcs_group, forward_heading, to_cp)
 
             elif group.role in [CombatGroupRole.APC, CombatGroupRole.ATGM]:
-
-                if stance in [CombatStance.AGGRESSIVE, CombatStance.BREAKTHROUGH, CombatStance.ELIMINATION]:
-                    # APC & ATGM will never move too much forward, but will follow along any offensive
-                    if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
-                        attack_point = to_cp.position.random_point_within(500, 0)
-                    else:
-                        attack_point = self.find_offensive_point(dcs_group, forward_heading, AGGRESIVE_MOVE_DISTANCE)
-                    dcs_group.add_waypoint(attack_point, PointAction.OnRoad)
-
-                if stance != CombatStance.RETREAT:
-                    self.add_morale_trigger(dcs_group, forward_heading)
+                self._plan_apc_atgm_action(stance, dcs_group, forward_heading, to_cp)
 
             if stance == CombatStance.RETREAT:
                 # In retreat mode, the units will fall back
@@ -299,11 +457,10 @@ class GroundConflictGenerator:
                 else:
                     retreat_point = self.find_retreat_point(dcs_group, forward_heading)
                 reposition_point = retreat_point.point_from_heading(forward_heading, 10)  # Another point to make the unit face the enemy
-                dcs_group.add_waypoint(retreat_point, PointAction.OnRoad)
+                dcs_group.add_waypoint(retreat_point, PointAction.OffRoad)
                 dcs_group.add_waypoint(reposition_point, PointAction.OffRoad)
 
-
-    def add_morale_trigger(self, dcs_group, forward_heading):
+    def add_morale_trigger(self, dcs_group: VehicleGroup, forward_heading: int) -> None:
         """
         This add a trigger to manage units fleeing whenever their group is hit hard, or being engaged by CAS
         """
@@ -320,10 +477,13 @@ class GroundConflictGenerator:
         dcs_group.manualHeading = True
 
         # We add a new retreat waypoint
-        dcs_group.add_waypoint(self.find_retreat_point(dcs_group, forward_heading, (int)(RETREAT_DISTANCE / 8)), PointAction.OffRoad)
+        dcs_group.add_waypoint(
+            self.find_retreat_point(dcs_group, forward_heading, (int)(RETREAT_DISTANCE / 8)),
+            PointAction.OffRoad
+        )
 
         # Fallback task
-        fallback = ControlledTask(GoToWaypoint(toIndex=len(dcs_group.points)))
+        fallback = ControlledTask(GoToWaypoint(to_index=len(dcs_group.points)))
         fallback.enabled = False
         dcs_group.add_trigger_action(Hold())
         dcs_group.add_trigger_action(fallback)
@@ -339,17 +499,30 @@ class GroundConflictGenerator:
 
         self.mission.triggerrules.triggers.append(fallback)
 
-
-    def find_retreat_point(self, dcs_group, frontline_heading, distance=RETREAT_DISTANCE):
+    def find_retreat_point(
+        self,
+        dcs_group: VehicleGroup,
+        frontline_heading: int,
+        distance: int = RETREAT_DISTANCE
+    ) -> Point:
         """
         Find a point to retreat to
         :param dcs_group: DCS mission group we are searching a retreat point for
         :param frontline_heading: Heading of the frontline
         :return: dcs.mapping.Point object with the desired position
         """
-        return dcs_group.points[0].position.point_from_heading(frontline_heading-180, distance)
+        desired_point = dcs_group.points[0].position.point_from_heading(heading_sum(frontline_heading, +180), distance)
+        if self.conflict.theater.is_on_land(desired_point):
+            return desired_point
+        return self.conflict.theater.nearest_land_pos(desired_point)
 
-    def find_offensive_point(self, dcs_group, frontline_heading, distance):
+
+    def find_offensive_point(
+        self,
+        dcs_group: VehicleGroup,
+        frontline_heading: int,
+        distance: int
+    ) -> Point:
         """
         Find a point to attack
         :param dcs_group:  DCS mission group we are searching an attack point for
@@ -357,26 +530,41 @@ class GroundConflictGenerator:
         :param distance: Distance of the offensive (how far unit should move)
         :return: dcs.mapping.Point object with the desired position
         """
-        return dcs_group.points[0].position.point_from_heading(frontline_heading, distance)
+        desired_point = dcs_group.points[0].position.point_from_heading(frontline_heading, distance)
+        if self.conflict.theater.is_on_land(desired_point):
+            return desired_point
+        return self.conflict.theater.nearest_land_pos(desired_point)
 
-    def find_n_nearest_enemy_groups(self, player_group, enemy_groups, n):
+    @staticmethod
+    def find_n_nearest_enemy_groups(
+        player_group: VehicleGroup,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        n: int
+    ) -> List[VehicleGroup]:
         """
-        Return the neaarest enemy group for the player group
+        Return the nearest enemy group for the player group
         @param group Group for which we should find the nearest ennemies
         @param enemy_groups Potential enemy groups
         @param n number of nearby groups to take
         """
-        targets = []
-        sorted_list = sorted(enemy_groups, key=lambda group: player_group.points[0].position.distance_to_point(group[0].points[0].position))
+        targets = []  # type: List[Optional[VehicleGroup]]
+        sorted_list = sorted(
+            enemy_groups,
+            key=lambda group: player_group.points[0].position.distance_to_point(group[0].points[0].position)
+        )
         for i in range(n):
+            # TODO: Is this supposed to return no groups if enemy_groups is less than n?
             if len(sorted_list) <= i:
                 break
             else:
                 targets.append(sorted_list[i][0])
         return targets
 
-
-    def find_nearest_enemy_group(self, player_group, enemy_groups):
+    @staticmethod
+    def find_nearest_enemy_group(
+        player_group: VehicleGroup,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]]
+    ) -> Optional[VehicleGroup]:
         """
         Search the enemy groups for a potential target suitable to armored assault
         @param group Group for which we should find the nearest ennemy
@@ -384,57 +572,130 @@ class GroundConflictGenerator:
         """
         min_distance = 99999999
         target = None
-        for dcs_group, group in enemy_groups:
+        for dcs_group, _ in enemy_groups:
             dist = player_group.points[0].position.distance_to_point(dcs_group.points[0].position)
             if dist < min_distance:
                 min_distance = dist
                 target = dcs_group
         return target
 
-
-    def get_artillery_target_in_range(self, dcs_group, group, enemy_groups):
+    @staticmethod
+    def get_artillery_target_in_range(
+        dcs_group: VehicleGroup,
+        group: CombatGroup,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]]
+    ) -> Optional[Point]:
         """
         Search the enemy groups for a potential target suitable to an artillery unit
         """
+        # TODO: Update to return a list of groups instead of a single point
         rng = group.units[0].threat_range
-        if len(enemy_groups) == 0:
+        if not enemy_groups:
             return None
-        for o in range(10):
+        for _ in range(10):
             potential_target = random.choice(enemy_groups)[0]
             distance_to_target = dcs_group.points[0].position.distance_to_point(potential_target.points[0].position)
             if distance_to_target < rng:
                 return potential_target.points[0].position
         return None
 
-
-    def get_artilery_group_distance_from_frontline(self, group):
+    @staticmethod
+    def get_artilery_group_distance_from_frontline(group: CombatGroup) -> int:
         """
         For artilery group, decide the distance from frontline with the range of the unit
         """
         rg = group.units[0].threat_range - 7500
-        if rg > DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY]:
-            rg = DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY]
-        if rg < DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK]:
-            rg = DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK] + 100
+        if rg > DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1]:
+            rg = random.randint(
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][0],
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1]
+            )
+        elif rg < DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1]:
+            rg = random.randint(
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK][0],
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK][1]
+            )
         return rg
 
+    def get_valid_position_for_group(
+        self,
+        conflict_position: Point,
+        combat_width: int,
+        distance_from_frontline: int,
+        heading: int,
+        spawn_heading: int
+    ):
+        shifted = conflict_position.point_from_heading(heading, random.randint(0, combat_width))
+        desired_point = shifted.point_from_heading(
+            spawn_heading,
+            distance_from_frontline
+        )
+        return Conflict.find_ground_position(desired_point, combat_width, heading, self.conflict.theater)
 
-    def get_valid_position_for_group(self, conflict_position, isplayer, combat_width, distance_from_frontline):
-        i = 0
-        while i < 25: # 25 attempt for valid position
-            heading_diff = -90 if isplayer else 90
-            shifted = conflict_position[0].point_from_heading(self.conflict.heading,
-                                                     random.randint((int)(-combat_width / 2), (int)(combat_width / 2)))
-            final_position = shifted.point_from_heading(self.conflict.heading + heading_diff, distance_from_frontline)
 
-            if self.conflict.theater.is_on_land(final_position):
-                return final_position
+    def _generate_groups(
+        self,
+        groups: List[CombatGroup],
+        frontline_vector: Tuple[Point, int, int],
+        is_player: bool
+    ) -> List[Tuple[VehicleGroup, CombatGroup]]:
+        """Finds valid positions for planned groups and generates a pydcs group for them"""
+        positioned_groups = []
+        position, heading, combat_width = frontline_vector
+        spawn_heading = int(heading_sum(heading, -90)) if is_player else int(heading_sum(heading, 90))
+        country = self.game.player_country if is_player else self.game.enemy_country
+        for group in groups:
+            if group.role == CombatGroupRole.ARTILLERY:
+                distance_from_frontline = self.get_artilery_group_distance_from_frontline(group)
             else:
-                i = i + 1
-                continue
-        return None
+                distance_from_frontline = random.randint(
+                    DISTANCE_FROM_FRONTLINE[group.role][0], 
+                    DISTANCE_FROM_FRONTLINE[group.role][1]
+                )
 
-    def _generate_group(self, side: Country, unit: VehicleType, count: int, at: Point, move_formation: PointAction = PointAction.OffRoad, heading=0):
+            final_position = self.get_valid_position_for_group(
+                position,
+                combat_width,
+                distance_from_frontline,
+                heading,
+                spawn_heading
+            )
+
+            if final_position is not None:
+                g = self._generate_group(
+                    self.mission.country(country),
+                    group.units[0],
+                    len(group.units),
+                    final_position,
+                    distance_from_frontline,
+                    heading=opposite_heading(spawn_heading),
+                )
+                if is_player:
+                    g.set_skill(self.game.settings.player_skill)
+                else:
+                    g.set_skill(self.game.settings.enemy_vehicle_skill)
+                positioned_groups.append((g, group))
+                self.gen_infantry_group_for_group(
+                    g,
+                    is_player,
+                    self.mission.country(country),
+                    opposite_heading(spawn_heading)
+                )
+            else:
+                logging.warning(f"Unable to get valid position for {group}")
+
+        return positioned_groups
+
+    def _generate_group(
+        self,
+        side: Country,
+        unit: VehicleType,
+        count: int,
+        at: Point,
+        distance_from_frontline,
+        move_formation: PointAction = PointAction.OffRoad,
+        heading=0,
+    ) -> VehicleGroup:
 
         if side == self.conflict.attackers_country:
             cp = self.conflict.from_cp
@@ -445,13 +706,15 @@ class GroundConflictGenerator:
         group = self.mission.vehicle_group(
                 side,
                 namegen.next_unit_name(side, cp.id, unit), unit,
-                position=self._group_point(at),
+                position=at,
                 group_size=count,
                 heading=heading,
                 move_formation=move_formation)
 
+        self.unit_map.add_front_line_units(group, cp)
+
         for c in range(count):
             vehicle: Vehicle = group.units[c]
             vehicle.player_can_drive = True
 
-        return group
+        return group

gen/ato.py

@@ -0,0 +1,203 @@
+"""Air Tasking Orders.
+
+The classes of the Air Tasking Order (ATO) define all of the missions that have
+been planned, and which aircraft have been assigned to them. Each planned
+mission, or "package" is composed of individual flights. The package may contain
+dissimilar aircraft performing different roles, but all for the same goal. For
+example, the package to strike an enemy airfield may contain an escort flight,
+a SEAD flight, and the strike aircraft themselves. CAP packages may contain only
+the single CAP flight.
+"""
+import logging
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Dict, List, Optional
+
+from dcs.mapping import Point
+
+from game.theater.missiontarget import MissionTarget
+from .flights.flight import Flight, FlightType
+from .flights.flightplan import FormationFlightPlan
+
+
+@dataclass(frozen=True)
+class Task:
+    """The main task of a flight or package."""
+
+    #: The type of task.
+    task_type: FlightType
+
+    #: The location of the objective.
+    location: str
+
+
+@dataclass(frozen=True)
+class PackageWaypoints:
+    join: Point
+    ingress: Point
+    egress: Point
+    split: Point
+
+
+@dataclass
+class Package:
+    """A mission package."""
+
+    #: The mission target. Currently can be either a ControlPoint or a
+    #: TheaterGroundObject (non-ControlPoint map objectives).
+    target: MissionTarget
+
+    #: The set of flights in the package.
+    flights: List[Flight] = field(default_factory=list)
+
+    delay: int = field(default=0)
+
+    #: Desired TOT as an offset from mission start.
+    time_over_target: timedelta = field(default=timedelta())
+
+    waypoints: Optional[PackageWaypoints] = field(default=None)
+
+    @property
+    def formation_speed(self) -> Optional[int]:
+        """The speed of the package when in formation.
+
+        If none of the flights in the package will join a formation, this
+        returns None. This is nto uncommon, since only strike-like (strike,
+        DEAD, anti-ship, BAI, etc.) flights and their escorts fly in formation.
+        Others (CAP and CAS, currently) will coordinate in target timing but
+        fly their own path to the target.
+        """
+        speeds = []
+        for flight in self.flights:
+            if isinstance(flight.flight_plan, FormationFlightPlan):
+                speeds.append(flight.flight_plan.best_flight_formation_speed)
+        if not speeds:
+            return None
+        return min(speeds)
+
+    # TODO: Should depend on the type of escort.
+    # SEAD might be able to leave before CAP.
+    @property
+    def escort_start_time(self) -> Optional[timedelta]:
+        times = []
+        for flight in self.flights:
+            waypoint = flight.flight_plan.request_escort_at()
+            if waypoint is None:
+                continue
+            tot = flight.flight_plan.tot_for_waypoint(waypoint)
+            if tot is None:
+                logging.error(
+                    f"{flight} requested escort at {waypoint} but that "
+                    "waypoint has no TOT. It may not be escorted.")
+                continue
+            times.append(tot)
+        if times:
+            return min(times)
+        return None
+
+    @property
+    def escort_end_time(self) -> Optional[timedelta]:
+        times = []
+        for flight in self.flights:
+            waypoint = flight.flight_plan.dismiss_escort_at()
+            if waypoint is None:
+                continue
+            tot = flight.flight_plan.tot_for_waypoint(waypoint)
+            if tot is None:
+                tot = flight.flight_plan.depart_time_for_waypoint(waypoint)
+            if tot is None:
+                logging.error(
+                    f"{flight} dismissed escort at {waypoint} but that "
+                    "waypoint has no TOT or departure time. It may not be "
+                    "escorted.")
+                continue
+            times.append(tot)
+        if times:
+            return max(times)
+        return None
+
+    def add_flight(self, flight: Flight) -> None:
+        """Adds a flight to the package."""
+        self.flights.append(flight)
+
+    def remove_flight(self, flight: Flight) -> None:
+        """Removes a flight from the package."""
+        self.flights.remove(flight)
+        if not self.flights:
+            self.waypoints = None
+
+    @property
+    def primary_task(self) -> Optional[FlightType]:
+        if not self.flights:
+            return None
+
+        flight_counts: Dict[FlightType, int] = defaultdict(lambda: 0)
+        for flight in self.flights:
+            flight_counts[flight.flight_type] += 1
+
+        # The package will contain a mix of mission types, but in general we can
+        # determine the goal of the mission because some mission types are more
+        # likely to be the main task than others. For example, a package with
+        # only CAP flights is a CAP package, a flight with CAP and strike is a
+        # strike package, a flight with CAP and DEAD is a DEAD package, and a
+        # flight with strike and SEAD is an OCA/Strike package. The type of
+        # package is determined by the highest priority flight in the package.
+        task_priorities = [
+            FlightType.CAS,
+            FlightType.STRIKE,
+            FlightType.ANTISHIP,
+            FlightType.OCA_AIRCRAFT,
+            FlightType.OCA_RUNWAY,
+            FlightType.BAI,
+            FlightType.DEAD,
+            FlightType.SEAD,
+            FlightType.TARCAP,
+            FlightType.BARCAP,
+            FlightType.SWEEP,
+            FlightType.ESCORT,
+        ]
+        for task in task_priorities:
+            if flight_counts[task]:
+                return task
+
+        # If we get here, our task_priorities list above is incomplete. Log the
+        # issue and return the type of *any* flight in the package.
+        some_mission = next(iter(self.flights)).flight_type
+        logging.warning(f"Unhandled mission type: {some_mission}")
+        return some_mission
+
+    @property
+    def package_description(self) -> str:
+        """Generates a package description based on flight composition."""
+        task = self.primary_task
+        if task is None:
+            return "No mission"
+        oca_strike_types = {FlightType.OCA_AIRCRAFT, FlightType.OCA_RUNWAY}
+        if task in oca_strike_types:
+            return "OCA Strike"
+        return str(task)
+
+    def __hash__(self) -> int:
+        # TODO: Far from perfect. Number packages?
+        return hash(self.target.name)
+
+
+@dataclass
+class AirTaskingOrder:
+    """The entire ATO for one coalition."""
+
+    #: The set of all planned packages in the ATO.
+    packages: List[Package] = field(default_factory=list)
+
+    def add_package(self, package: Package) -> None:
+        """Adds a package to the ATO."""
+        self.packages.append(package)
+
+    def remove_package(self, package: Package) -> None:
+        """Removes a package from the ATO."""
+        self.packages.remove(package)
+
+    def clear(self) -> None:
+        """Removes all packages from the ATO."""
+        self.packages.clear()

gen/briefinggen.py

@@ -1,19 +1,27 @@
-import os
-from collections import defaultdict
-from dataclasses import dataclass
-import random
-from typing import List
+"""
+Briefing generation logic
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Dict, List, TYPE_CHECKING
 
-from game import db
 from dcs.mission import Mission
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from game.theater import ControlPoint, FrontLine
 from .aircraft import FlightData
-from .airfields import RunwayData
 from .airsupportgen import AwacsInfo, TankerInfo
 from .armor import JtacInfo
-from .conflictgen import Conflict
+from .flights.flight import FlightWaypoint
 from .ground_forces.combat_stance import CombatStance
 from .radios import RadioFrequency
+from .runways import RunwayData
 
+if TYPE_CHECKING:
+    from game import Game
 
 @dataclass
 class CommInfo:
@@ -22,19 +30,33 @@ class CommInfo:
     freq: RadioFrequency
 
 
+class FrontLineInfo:
+    def __init__(self, front_line: FrontLine):
+        self.front_line: FrontLine = front_line
+        self.player_base: ControlPoint = front_line.control_point_a
+        self.enemy_base: ControlPoint = front_line.control_point_b
+        self.player_zero: bool = self.player_base.base.total_armor == 0
+        self.enemy_zero: bool = self.enemy_base.base.total_armor == 0
+        self.advantage: bool = self.player_base.base.total_armor > self.enemy_base.base.total_armor
+        self.stance: CombatStance = self.player_base.stances[self.enemy_base.id]
+        self.combat_stances = CombatStance
+
 class MissionInfoGenerator:
     """Base type for generators of mission information for the player.
 
     Examples of subtypes include briefing generators, kneeboard generators, etc.
     """
 
-    def __init__(self, mission: Mission) -> None:
+    def __init__(self, mission: Mission, game: Game) -> None:
         self.mission = mission
+        self.game = game
         self.awacs: List[AwacsInfo] = []
         self.comms: List[CommInfo] = []
         self.flights: List[FlightData] = []
         self.jtacs: List[JtacInfo] = []
         self.tankers: List[TankerInfo] = []
+        self.frontlines: List[FrontLineInfo] = []
+        self.dynamic_runways: List[RunwayData] = []
 
     def add_awacs(self, awacs: AwacsInfo) -> None:
         """Adds an AWACS/GCI to the mission.
@@ -77,20 +99,13 @@ class MissionInfoGenerator:
         """
         self.tankers.append(tanker)
 
-    def generate(self) -> None:
-        """Generates the mission information."""
-        raise NotImplementedError
+    def add_frontline(self, frontline: FrontLineInfo) -> None:
+        """Adds a frontline to the briefing
 
-
-class BriefingGenerator(MissionInfoGenerator):
-
-    def __init__(self, mission: Mission, conflict: Conflict, game):
-        super().__init__(mission)
-        self.conflict = conflict
-        self.game = game
-        self.title = ""
-        self.description = ""
-        self.dynamic_runways: List[RunwayData] = []
+        Arguments:
+            frontline: Frontline conflict information
+        """
+        self.frontlines.append(frontline)
 
     def add_dynamic_runway(self, runway: RunwayData) -> None:
         """Adds a dynamically generated runway to the briefing.
@@ -100,148 +115,62 @@ class BriefingGenerator(MissionInfoGenerator):
         """
         self.dynamic_runways.append(runway)
 
-    def add_flight_description(self, flight: FlightData):
-        assert flight.client_units
-
-        aircraft = flight.aircraft_type
-        flight_unit_name = db.unit_type_name(aircraft)
-        self.description += "-" * 50 + "\n"
-        self.description += f"{flight_unit_name} x {flight.size + 2}\n\n"
-
-        for i, wpt in enumerate(flight.waypoints):
-            self.description += f"#{i + 1} -- {wpt.name} : {wpt.description}\n"
-        self.description += f"#{len(flight.waypoints) + 1} -- RTB\n\n"
-
-    def add_ally_flight_description(self, flight: FlightData):
-        assert not flight.client_units
-        aircraft = flight.aircraft_type
-        flight_unit_name = db.unit_type_name(aircraft)
-        self.description += (
-            f"{flight.flight_type.name} {flight_unit_name} x {flight.size}, "
-            f"departing in {flight.departure_delay} minutes\n"
-        )
-
-    def generate(self):
-        self.description = ""
-
-        self.description += "DCS Liberation turn #" + str(self.game.turn) + "\n"
-        self.description += "=" * 15 + "\n\n"
-
-        self.generate_ongoing_war_text()
-
-        self.description += "\n"*2
-        self.description += "Your flights:" + "\n"
-        self.description += "=" * 15 + "\n\n"
-
-        for flight in self.flights:
-            if flight.client_units:
-                self.add_flight_description(flight)
-
-        self.description += "\n"*2
-        self.description += "Planned ally flights:" + "\n"
-        self.description += "=" * 15 + "\n"
-        allied_flights_by_departure = defaultdict(list)
-        for flight in self.flights:
-            if not flight.client_units and flight.friendly:
-                name = flight.departure.airfield_name
-                allied_flights_by_departure[name].append(flight)
-        for departure, flights in allied_flights_by_departure.items():
-            self.description += f"\nFrom {departure}\n"
-            self.description += "-" * 50 + "\n\n"
-            for flight in flights:
-                self.add_ally_flight_description(flight)
-
-        if self.comms:
-            self.description += "\n\nComms Frequencies:\n"
-            self.description += "=" * 15 + "\n"
-            for comm_info in self.comms:
-                self.description += f"{comm_info.name}: {comm_info.freq}\n"
-        self.description += ("-" * 50) + "\n"
-
-        for runway in self.dynamic_runways:
-            self.description += f"{runway.airfield_name}\n"
-            self.description += f"RADIO : {runway.atc}\n"
-            if runway.tacan is not None:
-                self.description += f"TACAN : {runway.tacan} {runway.tacan_callsign}\n"
-            if runway.icls is not None:
-                self.description += f"ICLS Channel : {runway.icls}\n"
-            self.description += "-" * 50 + "\n"
+    def generate(self) -> None:
+        """Generates the mission information."""
+        raise NotImplementedError
 
 
-        self.description += "JTACS [F-10 Menu] : \n"
-        self.description += "===================\n\n"
-        for jtac in self.jtacs:
-            self.description += f"{jtac.region} -- Code : {jtac.code}\n"
+def format_waypoint_time(waypoint: FlightWaypoint, depart_prefix: str) -> str:
+    if waypoint.tot is not None:
+        time = timedelta(seconds=int(waypoint.tot.total_seconds()))
+        return f"T+{time} "
+    elif waypoint.departure_time is not None:
+        time = timedelta(seconds=int(waypoint.departure_time.total_seconds()))
+        return f"{depart_prefix} T+{time} "
+    return ""
 
-        self.mission.set_description_text(self.description)
 
+class BriefingGenerator(MissionInfoGenerator):
+
+    def __init__(self, mission: Mission, game: Game):
+        super().__init__(mission, game)
+        self.allied_flights_by_departure: Dict[str, List[FlightData]] = {}
+        env = Environment(
+            loader=FileSystemLoader("resources/briefing/templates"),
+            autoescape=select_autoescape(
+                disabled_extensions=("",),
+                default_for_string=True,
+                default=True,
+                ),
+            trim_blocks=True,
+            lstrip_blocks=True,
+            )
+        env.filters["waypoint_timing"] = format_waypoint_time
+        self.template = env.get_template("briefingtemplate_EN.j2")
+
+    def generate(self) -> None:
+        """Generate the mission briefing
+        """
+        self._generate_frontline_info()
+        self.generate_allied_flights_by_departure()
+        self.mission.set_description_text(self.template.render(vars(self)))
         self.mission.add_picture_blue(os.path.abspath(
             "./resources/ui/splash_screen.png"))
 
+    def _generate_frontline_info(self) -> None:
+        """Build FrontLineInfo objects from FrontLine type and append to briefing.
+        """
+        for front_line in self.game.theater.conflicts(from_player=True):
+            self.add_frontline(FrontLineInfo(front_line))
 
-    def generate_ongoing_war_text(self):
-
-        self.description += "Current situation:\n"
-        self.description += "=" * 15 + "\n\n"
-
-        conflict_number = 0
-
-        for c in self.game.theater.conflicts():
-            conflict_number = conflict_number + 1
-            if c[0].captured:
-                player_base = c[0]
-                enemy_base = c[1]
-            else:
-                player_base = c[1]
-                enemy_base = c[0]
-
-            has_numerical_superiority = player_base.base.total_armor > enemy_base.base.total_armor
-            self.description += self.__random_frontline_sentence(player_base.name, enemy_base.name)
-
-            if enemy_base.id in player_base.stances.keys():
-                stance = player_base.stances[enemy_base.id]
-
-                if player_base.base.total_armor == 0:
-                    self.description += "We do not have a single vehicle available to hold our position, the situation is critical, and we will lose ground inevitably.\n"
-                elif enemy_base.base.total_armor == 0:
-                    self.description += "The enemy forces have been crushed, we will be able to make significant progress toward " + enemy_base.name + ". \n"
-                if stance == CombatStance.AGGRESSIVE:
-                    if has_numerical_superiority:
-                        self.description += "On this location, our ground forces will try to make progress against the enemy"
-                        self.description += ". As the enemy is outnumbered, our forces should have no issue making progress.\n"
-                    elif has_numerical_superiority:
-                        self.description += "On this location, our ground forces will try an audacious assault against enemies in superior numbers. The operation is risky, and the enemy might counter attack.\n"
-                elif stance == CombatStance.ELIMINATION:
-                    if has_numerical_superiority:
-                        self.description += "On this location, our ground forces will focus on the destruction of enemy assets, before attempting to make progress toward " + enemy_base.name + ". "
-                        self.description += "The enemy is already outnumbered, and this maneuver might draw a final blow to their forces.\n"
-                    elif has_numerical_superiority:
-                        self.description += "On this location, our ground forces will try an audacious assault against enemies in superior numbers. The operation is risky, and the enemy might counter attack.\n"
-                elif stance == CombatStance.BREAKTHROUGH:
-                    if has_numerical_superiority:
-                        self.description += "On this location, our ground forces will focus on progression toward " + enemy_base.name + ".\n"
-                    elif has_numerical_superiority:
-                        self.description += "On this location, our ground forces have been ordered to rush toward " + enemy_base.name + ". Wish them luck... We are also expecting a counter attack.\n"
-                elif stance in [CombatStance.DEFENSIVE, CombatStance.AMBUSH]:
-                    if has_numerical_superiority:
-                        self.description += "On this location, our ground forces will hold position. We are not expecting an enemy assault.\n"
-                    elif has_numerical_superiority:
-                        self.description += "On this location, our ground forces have been ordered to hold still, and defend against enemy attacks. An enemy assault might be iminent.\n"
-
-        if conflict_number == 0:
-            self.description += "There are currently no fights on the ground.\n"
-
-        self.description += "\n\n"
-
-
-    def __random_frontline_sentence(self, player_base_name, enemy_base_name):
-        templates = [
-            "There are combats between {} and {}. ",
-            "The war on the ground is still going on between {} and {}. ",
-            "Our ground forces in {} are opposed to enemy forces based in {}. ",
-            "Our forces from {} are fighting enemies based in {}. ",
-            "There is an active frontline between {} and {}. ",
-        ]
-        return random.choice(templates).format(player_base_name, enemy_base_name)
-
-
+    # TODO: This should determine if runway is friendly through a method more robust than the existing string match
+    def generate_allied_flights_by_departure(self) -> None:
+        """Create iterable to display allied flights grouped by departure airfield.
+        """
+        for flight in self.flights:
+            if not flight.client_units and flight.friendly:
+                name = flight.departure.airfield_name
+                if name in self.allied_flights_by_departure:  # where else can we get this?
+                    self.allied_flights_by_departure[name].append(flight)
+                else:
+                    self.allied_flights_by_departure[name] = [flight]

gen/conflictgen.py

@@ -1,88 +1,18 @@
 import logging
-import typing
-import pdb
-import dcs
+import random
+from typing import Tuple, Optional
 
-from random import randint
-from dcs import Mission
+from dcs.country import Country
+from dcs.mapping import Point
 
-from dcs.mission import *
-from dcs.vehicles import *
-from dcs.unitgroup import *
-from dcs.unittype import *
-from dcs.mapping import *
-from dcs.point import *
-from dcs.task import *
-from dcs.country import *
+from game.theater.conflicttheater import ConflictTheater, FrontLine
+from game.theater.controlpoint import ControlPoint
+from game.utils import heading_sum, opposite_heading
 
-from theater import *
-
-AIR_DISTANCE = 40000
-
-CAPTURE_AIR_ATTACKERS_DISTANCE = 25000
-CAPTURE_AIR_DEFENDERS_DISTANCE = 60000
-STRIKE_AIR_ATTACKERS_DISTANCE = 45000
-STRIKE_AIR_DEFENDERS_DISTANCE = 25000
-
-CAP_CAS_DISTANCE = 10000, 120000
-
-GROUND_INTERCEPT_SPREAD = 5000
-GROUND_DISTANCE_FACTOR = 1.4
-GROUND_DISTANCE = 2000
-
-GROUND_ATTACK_DISTANCE = 25000, 13000
-
-TRANSPORT_FRONTLINE_DIST = 1800
-
-INTERCEPT_ATTACKERS_HEADING = -45, 45
-INTERCEPT_DEFENDERS_HEADING = -10, 10
-INTERCEPT_CONFLICT_DISTANCE = 50000
-INTERCEPT_ATTACKERS_DISTANCE = 100000
-INTERCEPT_MAX_DISTANCE = 160000
-INTERCEPT_MIN_DISTANCE = 100000
-
-NAVAL_INTERCEPT_DISTANCE_FACTOR = 1
-NAVAL_INTERCEPT_DISTANCE_MAX = 40000
-NAVAL_INTERCEPT_STEP = 5000
 
 FRONTLINE_LENGTH = 80000
-FRONTLINE_MIN_CP_DISTANCE = 5000
-FRONTLINE_DISTANCE_STRENGTH_FACTOR = 0.7
-
-
-def _opposite_heading(h):
-    return h+180
-
-
-def _heading_sum(h, a) -> int:
-    h += a
-    if h > 360:
-        return h - 360
-    elif h < 0:
-        return 360 + h
-    else:
-        return h
-
 
 class Conflict:
-    attackers_side = None  # type: str
-    defenders_side = None  # type: str
-    attackers_country = None  # type: Country
-    defenders_country = None  # type: Country
-    from_cp = None  # type: ControlPoint
-    to_cp = None  # type: ControlPoint
-    position = None  # type: Point
-    size = None  # type: int
-    radials = None  # type: typing.List[int]
-
-    heading = None  # type: int
-    distance = None  # type: int
-
-    ground_attackers_location = None  # type: Point
-    ground_defenders_location = None  # type: Point
-    air_attackers_location = None  # type: Point
-    air_defenders_location = None  # type: Point
-
     def __init__(self,
                  theater: ConflictTheater,
                  from_cp: ControlPoint,
@@ -92,12 +22,9 @@ class Conflict:
                  attackers_country: Country,
                  defenders_country: Country,
                  position: Point,
-                 heading=None,
-                 distance=None,
-                 ground_attackers_location: Point = None,
-                 ground_defenders_location: Point = None,
-                 air_attackers_location: Point = None,
-                 air_defenders_location: Point = None):
+                 heading: Optional[int] = None,
+                 size: Optional[int] = None
+                 ):
 
         self.attackers_side = attackers_side
         self.defenders_side = defenders_side
@@ -109,308 +36,39 @@ class Conflict:
         self.theater = theater
         self.position = position
         self.heading = heading
-        self.distance = distance
-        self.size = to_cp.size
-        self.radials = to_cp.radials
-        self.ground_attackers_location = ground_attackers_location
-        self.ground_defenders_location = ground_defenders_location
-        self.air_attackers_location = air_attackers_location
-        self.air_defenders_location = air_defenders_location
-
-    @property
-    def center(self) -> Point:
-        return self.position.point_from_heading(self.heading, self.distance / 2)
-
-    @property
-    def tail(self) -> Point:
-        return self.position.point_from_heading(self.heading, self.distance)
-
-    @property
-    def is_vector(self) -> bool:
-        return self.heading is not None
-
-    @property
-    def opposite_heading(self) -> int:
-        return _heading_sum(self.heading, 180)
-
-    @property
-    def to_size(self):
-        return self.to_cp.size * GROUND_DISTANCE_FACTOR
-
-    def find_insertion_point(self, other_point: Point) -> Point:
-        if self.is_vector:
-            dx = self.position.x - self.tail.x
-            dy = self.position.y - self.tail.y
-            dr2 = float(dx ** 2 + dy ** 2)
-
-            lerp = ((other_point.x - self.tail.x) * dx + (other_point.y - self.tail.y) * dy) / dr2
-            if lerp < 0:
-                lerp = 0
-            elif lerp > 1:
-                lerp = 1
-
-            x = lerp * dx + self.tail.x
-            y = lerp * dy + self.tail.y
-            return Point(x, y)
-        else:
-            return self.position
-
-    def find_ground_position(self, at: Point, heading: int, max_distance: int = 40000) -> typing.Optional[Point]:
-        return Conflict._find_ground_position(at, max_distance, heading, self.theater)
+        self.size = size
 
     @classmethod
     def has_frontline_between(cls, from_cp: ControlPoint, to_cp: ControlPoint) -> bool:
         return from_cp.has_frontline and to_cp.has_frontline
 
     @classmethod
-    def frontline_position(cls, theater: ConflictTheater, from_cp: ControlPoint, to_cp: ControlPoint) -> typing.Optional[typing.Tuple[Point, int]]:
-        attack_heading = from_cp.position.heading_between_point(to_cp.position)
-        attack_distance = from_cp.position.distance_to_point(to_cp.position)
-        middle_point = from_cp.position.point_from_heading(attack_heading, attack_distance / 2)
-
-        strength_delta = (from_cp.base.strength - to_cp.base.strength) / 1.0
-        position = middle_point.point_from_heading(attack_heading, strength_delta * attack_distance / 2 - FRONTLINE_MIN_CP_DISTANCE)
-        return position, _opposite_heading(attack_heading)
-
+    def frontline_position(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> Tuple[Point, int]:
+        frontline = FrontLine(from_cp, to_cp, theater)
+        attack_heading = frontline.attack_heading
+        position = cls.find_ground_position(frontline.position, FRONTLINE_LENGTH, heading_sum(attack_heading, 90), theater)
+        return position, opposite_heading(attack_heading)
 
     @classmethod
-    def frontline_vector(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> typing.Optional[typing.Tuple[Point, int, int]]:
-        initial, heading = cls.frontline_position(theater, from_cp, to_cp)
-
+    def frontline_vector(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> Tuple[Point, int, int]:
         """
-        probe_end_point = initial.point_from_heading(heading, FRONTLINE_LENGTH)
-        probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y) ])
-        intersection = probe.intersection(theater.land_poly)
-
-        if isinstance(intersection, geometry.LineString):
-            intersection = intersection
-        elif isinstance(intersection, geometry.MultiLineString):
-            intersection = intersection.geoms[0]
-        else:
-            print(intersection)
-            return None
-
-        return Point(*intersection.xy[0]), _heading_sum(heading, 90), intersection.length
+        Returns a vector for a valid frontline location avoiding exclusion zones.
         """
-        frontline = cls.frontline_position(theater, from_cp, to_cp)
-        if not frontline:
-            return None
-
-        center_position, heading = frontline
-        left_position, right_position = None, None
-
-        if not theater.is_on_land(center_position):
-            pos = cls._find_ground_position(center_position, FRONTLINE_LENGTH, _heading_sum(heading, -90), theater)
-            if pos:
-                right_position = pos
-                center_position = pos
-            else:
-                pos = cls._find_ground_position(center_position, FRONTLINE_LENGTH, _heading_sum(heading, +90), theater)
-                if pos:
-                    left_position = pos
-                    center_position = pos
-
-        if left_position is None:
-            left_position = cls._extend_ground_position(center_position, int(FRONTLINE_LENGTH/2), _heading_sum(heading, -90), theater)
-
-        if right_position is None:
-            right_position = cls._extend_ground_position(center_position, int(FRONTLINE_LENGTH/2), _heading_sum(heading, 90), theater)
-
-        return left_position, _heading_sum(heading, 90), int(right_position.distance_to_point(left_position))
-
-    @classmethod
-    def _extend_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> Point:
-        pos = initial
-        for offset in range(0, int(max_distance), 500):
-            new_pos = initial.point_from_heading(heading, offset)
-            if theater.is_on_land(new_pos):
-                pos = new_pos
-            else:
-                return pos
-        return pos
-
-        """
-        probe_end_point = initial.point_from_heading(heading, max_distance)
-        probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y)])
-
-        intersection = probe.intersection(theater.land_poly)
-        if intersection is geometry.LineString:
-            return Point(*intersection.xy[1])
-        elif intersection is geometry.MultiLineString:
-            return Point(*intersection.geoms[0].xy[1])
-
-        return None
-        """
-
-    @classmethod
-    def _find_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> typing.Optional[Point]:
-        pos = initial
-        for _ in range(0, int(max_distance), 500):
-            if theater.is_on_land(pos):
-                return pos
-
-            pos = pos.point_from_heading(heading, 500)
-        """
-        probe_end_point = initial.point_from_heading(heading, max_distance)
-        probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y) ])
-
-        intersection = probe.intersection(theater.land_poly)
-        if isinstance(intersection, geometry.LineString):
-            return Point(*intersection.xy[1])
-        elif isinstance(intersection, geometry.MultiLineString):
-            return Point(*intersection.geoms[0].xy[1])
-        """
-
-        logging.error("Didn't find ground position ({})!".format(initial))
-        return initial
-
-    @classmethod
-    def capture_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        position = to_cp.position
-        attack_raw_heading = to_cp.position.heading_between_point(from_cp.position)
-        attack_heading = to_cp.find_radial(attack_raw_heading)
-        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
-
-        distance = GROUND_DISTANCE
-        attackers_location = position.point_from_heading(attack_heading, distance)
-        attackers_location = Conflict._find_ground_position(attackers_location, distance * 2, attack_heading, theater)
-
-        defenders_location = position.point_from_heading(defense_heading, 0)
-        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, defense_heading, theater)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=attackers_location,
-            ground_defenders_location=defenders_location,
-            air_attackers_location=position.point_from_heading(attack_raw_heading, CAPTURE_AIR_ATTACKERS_DISTANCE),
-            air_defenders_location=position.point_from_heading(_opposite_heading(attack_raw_heading), CAPTURE_AIR_DEFENDERS_DISTANCE)
-        )
-
-    @classmethod
-    def strike_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        position = to_cp.position
-        attack_raw_heading = to_cp.position.heading_between_point(from_cp.position)
-        attack_heading = to_cp.find_radial(attack_raw_heading)
-        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
-
-        distance = to_cp.size * GROUND_DISTANCE_FACTOR
-        attackers_location = position.point_from_heading(attack_heading, distance)
-        attackers_location = Conflict._find_ground_position(attackers_location, distance * 2, _heading_sum(attack_heading, 180), theater)
-
-        defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=attackers_location,
-            ground_defenders_location=defenders_location,
-            air_attackers_location=position.point_from_heading(attack_raw_heading, STRIKE_AIR_ATTACKERS_DISTANCE),
-            air_defenders_location=position.point_from_heading(_opposite_heading(attack_raw_heading), STRIKE_AIR_DEFENDERS_DISTANCE)
-        )
-
-    @classmethod
-    def intercept_position(cls, from_cp: ControlPoint, to_cp: ControlPoint) -> Point:
-        raw_distance = from_cp.position.distance_to_point(to_cp.position) * 1.5
-        distance = max(min(raw_distance, INTERCEPT_MAX_DISTANCE), INTERCEPT_MIN_DISTANCE)
-        heading = _heading_sum(from_cp.position.heading_between_point(to_cp.position), random.choice([-1, 1]) * random.randint(60, 100))
-        return from_cp.position.point_from_heading(heading, distance)
-
-    @classmethod
-    def intercept_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, position: Point, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        heading = from_cp.position.heading_between_point(position)
-        return cls(
-            position=position.point_from_heading(position.heading_between_point(to_cp.position), INTERCEPT_CONFLICT_DISTANCE),
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=None,
-            air_attackers_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, INTERCEPT_ATTACKERS_DISTANCE),
-            air_defenders_location=position
-        )
-
-    @classmethod
-    def ground_attack_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        heading = random.choice(to_cp.radials)
-        initial_location = to_cp.position.random_point_within(*GROUND_ATTACK_DISTANCE)
-        position = Conflict._find_ground_position(initial_location, GROUND_INTERCEPT_SPREAD, _heading_sum(heading, 180), theater)
-        if not position:
-            heading = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
-            position = to_cp.position.point_from_heading(heading, to_cp.size * GROUND_DISTANCE_FACTOR)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=position,
-            ground_defenders_location=None,
-            air_attackers_location=None,
-            air_defenders_location=position.point_from_heading(heading, AIR_DISTANCE),
-        )
-
-    @classmethod
-    def convoy_strike_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        frontline_position, frontline_heading, frontline_length = Conflict.frontline_vector(from_cp, to_cp, theater)
-        if not frontline_position:
-            assert False
-
-        heading = frontline_heading
-        starting_position = Conflict._find_ground_position(frontline_position.point_from_heading(heading, 7000),
-                                                           GROUND_INTERCEPT_SPREAD,
-                                                           _opposite_heading(heading), theater)
-        if not starting_position:
-            starting_position = frontline_position
-            destination_position = frontline_position
-        else:
-            destination_position = frontline_position
-
-        return cls(
-            position=destination_position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=starting_position,
-            air_attackers_location=starting_position.point_from_heading(_opposite_heading(heading), AIR_DISTANCE),
-            air_defenders_location=starting_position.point_from_heading(heading, AIR_DISTANCE),
-        )
+        center_position, heading = cls.frontline_position(from_cp, to_cp, theater)
+        left_heading = heading_sum(heading, -90)
+        right_heading =  heading_sum(heading, 90)
+        left_position = cls.extend_ground_position(center_position, int(FRONTLINE_LENGTH / 2), left_heading, theater)
+        right_position = cls.extend_ground_position(center_position, int(FRONTLINE_LENGTH / 2), right_heading, theater)
+        distance = int(left_position.distance_to_point(right_position))
+        return left_position, right_heading, distance
 
     @classmethod
     def frontline_cas_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         assert cls.has_frontline_between(from_cp, to_cp)
         position, heading, distance = cls.frontline_vector(from_cp, to_cp, theater)
-
-        return cls(
+        conflict = cls(
             position=position,
             heading=heading,
-            distance=distance,
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
@@ -418,112 +76,38 @@ class Conflict:
             defenders_side=defender_name,
             attackers_country=attacker,
             defenders_country=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=None,
-            air_attackers_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, AIR_DISTANCE),
-            air_defenders_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + _opposite_heading(heading), AIR_DISTANCE),
+            size=distance
         )
+        return conflict
 
     @classmethod
-    def frontline_cap_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        assert cls.has_frontline_between(from_cp, to_cp)
-
-        position, heading, distance = cls.frontline_vector(from_cp, to_cp, theater)
-        attack_position = position.point_from_heading(heading, randint(0, int(distance)))
-        attackers_position = attack_position.point_from_heading(heading - 90, AIR_DISTANCE)
-        defenders_position = attack_position.point_from_heading(heading + 90, random.randint(*CAP_CAS_DISTANCE))
-
-        return cls(
-            position=position,
-            heading=heading,
-            distance=distance,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            air_attackers_location=attackers_position,
-            air_defenders_location=defenders_position,
-        )
+    def extend_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> Point:
+        """Finds the first intersection with an exclusion zone in one heading from an initial point up to max_distance"""
+        pos = initial
+        for distance in range(0, int(max_distance), 100):
+            pos = initial.point_from_heading(heading, distance)
+            if not theater.is_on_land(pos):
+                return initial.point_from_heading(heading, distance - 100)
+        return pos
 
     @classmethod
-    def ground_base_attack(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        position = to_cp.position
-        attack_heading = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
-        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
-
-        distance = to_cp.size * GROUND_DISTANCE_FACTOR
-        defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=defenders_location,
-            air_attackers_location=position.point_from_heading(attack_heading, AIR_DISTANCE),
-            air_defenders_location=position
-        )
-
-    @classmethod
-    def naval_intercept_position(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        radial = random.choice(to_cp.sea_radials)
-
-        initial_distance = min(int(from_cp.position.distance_to_point(to_cp.position) * NAVAL_INTERCEPT_DISTANCE_FACTOR), NAVAL_INTERCEPT_DISTANCE_MAX)
-        initial_position = to_cp.position.point_from_heading(radial, initial_distance)
-        for offset in range(0, initial_distance, NAVAL_INTERCEPT_STEP):
-            position = initial_position.point_from_heading(_opposite_heading(radial), offset)
-
-            if not theater.is_on_land(position):
-                break
-        return position
-
-    @classmethod
-    def naval_intercept_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, position: Point, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        attacker_heading = from_cp.position.heading_between_point(to_cp.position)
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=position,
-            air_attackers_location=position.point_from_heading(attacker_heading, AIR_DISTANCE),
-            air_defenders_location=position.point_from_heading(_opposite_heading(attacker_heading), AIR_DISTANCE)
-        )
-
-    @classmethod
-    def transport_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        frontline_position, heading = cls.frontline_position(theater, from_cp, to_cp)
-        initial_dest = frontline_position.point_from_heading(heading, TRANSPORT_FRONTLINE_DIST)
-        dest = cls._find_ground_position(initial_dest, from_cp.position.distance_to_point(to_cp.position) / 3, heading, theater)
-        if not dest:
-            radial = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
-            dest = to_cp.position.point_from_heading(radial, to_cp.size * GROUND_DISTANCE_FACTOR)
-
-        return cls(
-            position=dest,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker_name,
-            defenders_side=defender_name,
-            attackers_country=attacker,
-            defenders_country=defender,
-            ground_attackers_location=from_cp.position,
-            ground_defenders_location=frontline_position,
-            air_attackers_location=from_cp.position.point_from_heading(0, 100),
-            air_defenders_location=frontline_position
-        )
+    def find_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater, coerce=True) -> Optional[Point]:
+        """
+        Finds the nearest valid ground position along a provided heading and it's inverse up to max_distance.
+        `coerce=True` will return the closest land position to `initial` regardless of heading or distance
+        `coerce=False` will return None if a point isn't found
+        """
+        pos = initial
+        if theater.is_on_land(pos):
+            return pos
+        for distance in range(0, int(max_distance), 100):
+            pos = initial.point_from_heading(heading, distance)
+            if theater.is_on_land(pos):
+                return pos
+            pos = initial.point_from_heading(opposite_heading(heading), distance)
+        if coerce:
+            pos = theater.nearest_land_pos(initial)
+            return pos
+        logging.error("Didn't find ground position ({})!".format(initial))
+        return None
+