Update changelog

* Implemented support for the VSN Super Étendard v2.5.5

* Updated changelog and renamed the banner.

---------

Co-authored-by: Raffson <Raffson@users.noreply.github.com>

.coveragerc

@@ -0,0 +1,8 @@
+[report]
+exclude_lines =
+    pragma: no cover
+    if TYPE_CHECKING:
+
+[run]
+branch = True
+source = game,pydcs_extensions,qt_ui,resources/tools

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -31,7 +31,7 @@ body:
         If the bug was found in a test/development build, select "Test build" or "Development build"
         and provide a link to the applicable build in the field below.
       options:
-        - 1.0.0
+        - v1.2.1
         - Test build
         - Development build
   - type: input

.github/actions/setup-liberation-python/action.yaml

@@ -19,5 +19,3 @@ runs:
       run: |
         ./venv/scripts/activate
         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

.github/workflows/lint.yml

@@ -13,6 +13,7 @@ jobs:
         with:
           src: "."
           options: "--check"
+          version: "23.9.1"
 
   mypy:
     name: Type checking

.github/workflows/test.yml

@@ -15,4 +15,24 @@ jobs:
       - name: run tests
         run: |
           ./venv/scripts/activate
-          pytest tests
+          pytest --cov --cov-report=xml tests
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+
+  ts-tests:
+    name: Typescript tests
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up JS environment
+        uses: ./.github/actions/setup-liberation-js
+
+      - name: run tests
+        run: |
+          cd client
+          npm test -- --coverage
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3

.gitignore

@@ -1,11 +1,15 @@
 *.pyc
 __pycache__
 build/**
+# Sphinx
+docs/_build
 resources/payloads/*.lua
 venv
 .DS_Store
 .vscode/settings.json
 dist/**
+/.coverage
+/coverage.xml
 # User-specific stuff
 .idea/
 .env

.readthedocs.yaml

@@ -0,0 +1,13 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+  configuration: docs/conf.py
+
+python:
+  install:
+    - requirements: docs/requirements.txt

CONTRIBUTING.md

@@ -11,7 +11,7 @@ Note that you may need to remove the filter for open bugs if it's something we'v
 
 ## Making content for Liberation
 
-You can create new campaigns : See [campaign creation wiki](https://github.com/dcs-liberation/dcs_liberation/wiki/Custom-Campaigns).
+You can create new campaigns : See [campaign creation wiki](https://github.com/dcs-retribution/dcs-retribution/wiki/Custom-Campaigns).
 You can also improve existing campaigns.
 
 You can then submit new campaigns on the "campaigns" channel on Discord, or by making a pull request if you are comfortable with git. 

README.md

@@ -2,7 +2,7 @@
 
 (Github Readme Banner and Splash screen Artwork by Andriy Dankovych, CC BY-SA 4.0)
 
-[![Patreon](https://img.shields.io/badge/patreon-become%20a%20patron-orange?logo=patreon)](https://patreon.com/khopa)
+[![Patreon](https://img.shields.io/badge/patreon-become%20a%20patron-orange?logo=patreon)](https://patreon.com/dcsliberation)
 
 [![Download](https://img.shields.io/github/downloads/dcs-retribution/dcs-retribution/total?label=Download)](https://github.com/dcs-retribution/dcs-retribution/releases)
 
@@ -12,28 +12,29 @@
 [![GitHub issues](https://img.shields.io/github/issues/dcs-retribution/dcs-retribution)](https://github.com/dcs-retribution/dcs-retribution/issues)
 ![GitHub stars](https://img.shields.io/github/stars/dcs-retribution/dcs-retribution?style=social)
 
-## About DCS Retribution
-DCS Retribution was forked from [DCS Liberation](https://github.com/dcs-retribution/dcs-retribution),
+## About DCS Retribution 
+(Last update: 2023-05-20)
+
+DCS Retribution was forked from [DCS Liberation](https://github.com/dcs-liberation/dcs_liberation),
 which 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.
 
 ![Screenshot](https://user-images.githubusercontent.com/315852/120939254-0b4a9f80-c6cc-11eb-82f5-ce3f8d714bfe.png)
 
-DCS Retribution will rely heavily on Liberation in the near future,
-and possibly in a more distant future as well since Retribution will attempt
-to stay backwards compatible for as long as possible. Therefore,
+DCS Retribution is still relying on Liberation for certain updates,
+and will possibly stay that way in a more distant future. Therefore,
 the patreon link will keep pointing to [Khopa's](https://github.com/Khopa) account until further notice.
+However, we are no longer backwards compatible with Liberation, and will no longer attempt to do so.
 
-Currently, Retribution supports the following new features:
- * A livery selector in the air wing configuration dialog
- * Support for campaigns with quad-point triggers
- * Support for the F-15D 'Baz' mod
- * Support for the Su-30 mod
- * Elementary end-game mechanics
- * Variation in flight-size for BAI/ANTISHIP/DEAD/STRIKE main flight (randomize 2/3/4-ships)
- * More performance options
- * Various bug-fixes (including a fix for the zombie carrier)
- * And more... (See [changelog](https://github.com/dcs-retribution/dcs-retribution/blob/main/changelog.md))
+Instead, we are focussing on keeping our campaigns forward compatible so that you as a user
+can continue on whatever campaign you had going on.
+Please keep in mind that once you save a campaign that was started
+in a previous (save-compatibility breaking) build, your save file
+will have been migrated and thus no longer compatible with the previous build.
+Therefore, we recommend backing up your saves and perhaps organizing them by version/build number.
+
+For a more complete overview of our features, check the
+[changelog](https://github.com/dcs-retribution/dcs-retribution/blob/main/changelog.md).
 
 ## Downloads
 
@@ -43,11 +44,16 @@ To download preview builds of the next version of DCS Retribution, see https://g
 
 ## DCS bugs
 
-These DCS bugs prevent us from improving AI behavior. Please upvote them! (But please
-_don't_ spam them with comments):
+~~These DCS bugs prevent us from improving AI behavior. Please upvote them! (But please
+_don't_ spam them with comments):~~
 
-* [A2A and SEAD escorts don't escort](https://forums.eagle.ru/topic/251798-options-for-alternate-ai-escort-behavior/?tab=comments#comment-4668033)
-* [DEAD can't use mixed loadouts effectively](https://forums.eagle.ru/topic/271941-ai-rtbs-after-firing-decoys-despite-full-load-of-bombs/)
+* ~~[A2A and SEAD escorts don't escort](https://forums.eagle.ru/topic/251798-options-for-alternate-ai-escort-behavior/?tab=comments#comment-4668033)~~
+* ~~[DEAD can't use mixed loadouts effectively](https://forums.eagle.ru/topic/271941-ai-rtbs-after-firing-decoys-despite-full-load-of-bombs/)~~
+
+While DCS bugs are still a thing, we don't quite agree with the ones stated above.
+We believe to have addressed these, although some quirks still exist.
+For example, SEAD Escorts tend to be a little picky with what they engage,
+especially with older SAM systems.
 
 ## Bugs and feature requests
 
@@ -70,7 +76,7 @@ for that release. Items in the To do column are planned to be added to that rele
 Tutorials, contributors and developer's guides are available in the project's
 [Wiki](https://github.com/dcs-retribution/dcs-retribution/wiki/)
 
-(These need to be written again, meanwhile you can refer to
+(Some historical information is also availabe on
 [Liberation's Wiki](https://github.com/dcs-liberation/dcs_liberation/wiki/))
 
 ## Special Thanks

changelog.md

@@ -1,4 +1,163 @@
-# Retribution 1.1.0
+# Retribution v1.3.1
+#### Note: Re-save your missions in DCS' Mission Editor to avoid possible crashes due to datalink (usually the case when F-16C blk50s are used) when hosting missions on a dedicated server.
+
+## Fixes
+* **[UX]** Fix save-compatibility issue
+* **[UX]** Avoid crash on startup due to incompatible save
+
+
+# Retribution v1.3.0
+#### Note: Re-save your missions in DCS' Mission Editor to avoid possible crashes due to datalink (usually the case when F-16C blk50s are used) when hosting missions on a dedicated server.
+
+## Features/Improvements
+* **[Engine]** Support for DCS v2.9.3.51704
+* **[Package Planning]** Option to "Auto-Create" package
+* **[Modding]** Custom weapons injection system (definition in aircraft's yaml file)
+* **[Payload Editor]** Ability to save/back-up payloads
+* **[Options]** New option in Settings: CAS engagement range (nmi)
+* **[Options]** New option in Settings: Convert untasked OPFOR aircraft into client slots
+* **[Options]** Split the **Disable idle aircraft at airfields** setting into **Disable untasked BLUFOR aircraft at airfields** and **Disable untasked OPFOR aircraft at airfields**
+* **[Options]** Split off the **Automatic AWACS package planning** and **Automatic Theater tanker package planning** settings from **Automatic package planning behavior** so players can choose to have AWACS and theater tankers auto-planned, while managing everything else themselves
+* **[Modding]** Updated support for Su-30 mod to V2.7.3 Beta
+* **[Modding]** Updated support for Su-57 mod to build-04
+* **[Modding]** Updated support for F-4B/C Phantom mod to 2.8.7.204
+* **[Modding]** Updated Community A-4E-C mod version support to 2.2.0 release.
+* **[Modding]** Added F/A-18E/F Super Hornet AI Tanker mod support (Chiller Juice Studios SuperBug Tanker AI version 1.4)
+* **[Modding]** Added VSN Super Étendard mod support (v2.5.5)
+* **[Modding]** Added F9F Panther mod support (version v2.8.7.101)
+* **[Modding]** Updated Irondome support to IDF Assets Pack V1.1, adding support for the David's Sling
+* **[Radios]** Added HF-FM band for AN/ARC-222
+* **[Radios]** Ability to define preset channels for radios on squadron level (for human pilots only)
+* **[Mission Planning]** Avoid helicopters being assigned as escort to planes and vice-versa
+* **[Mission Planning]** Allow attack helicopters to escort other helicopters
+* **[UI]** Allow changing waypoint names in FlightEdit's waypoints tab
+* **[Waypoints]** Allow user to add navigation waypoints where possible without degrading to a custom flight-plan
+* **[Campaign Management]** Improve squadron retreat logic to account for parking-slot sizes
+* **[Autoplanner]** Support for auto-planning Air Assaults
+* **[UI]** Improved frequency selector to support all modeled bands for every aircraft's intra-flight radio
+* **[Options]** New options in Settings: Helicopter waypoint altitude (feet AGL) for combat & cruise waypoints
+* **[Options]** New options in Settings: Spawn ground power trucks at ground starts in airbases/roadbases
+* **[Options]** Option for hiding TGOs (with IADS roles) on MFD
+* **[Plugins]** Splash Damage 2.1 with Clusters and Ship Radar effects.
+* **[COMMs]** Aircraft-specific callsigns will now also be used.
+* **[COMMs]** Ability to set a specific callsign to a flight.
+* **[Mission Generator]** Channel terrain fix on exclusion zones, sea zones and inclusion zones
+* **[Options]** Cheat-option for accessing Air Wing Config Dialog after campaign start (re-initializes turn if applied, thus plan your mission ___after___ making changes)
+* **[Options]** Option to enable unlimited fuel for AI (player and non-player flights)
+* **[Mission Generator]** F-15E Strike targets are automatically added as Mission Set 1 
+* **[Mission Generator]** Set F-14's IP waypoint according to the flight-plan's ingress point
+* **[Mission Generator]** Automatically de-spawn aircraft when arrival/divert is an off-map spawn
+* **[Options]** Option to de-spawn AI flights in the air if their start-type was manually set to In-Flight
+* **[Config]** Preference setting to use custom Liberation payloads instead of prioritizing Retribution's default
+* **[Config]** Preference setting to configure the server-port on which Retribution's back-end will run
+* **[Options]** Made AI jettisoning empty fuel tanks optional (disabled by default)
+* **[Options]** Add option (so it can be disabled when fixed in DCS) to force air-starts (except for the slots that work) at Nevatim due to https://forum.dcs.world/topic/335545-29-nevatim-ramp-starts-still-bugged/
+* **[Cheat]** Add cheat option to manually manage REDFOR's TGOs
+* **[UX]** Buy/Replace TGOs for free before the campaign has started
+* **[Data]** Ability to define "cruise" & "combat" altitudes for airplanes
+* **[Options]** Option to randomize altitudes for flights with airplanes
+* **[Options]** Options to configure/override maximum mission distance for airplanes & helicopters 
+
+## Fixes
+* **[Mission Generation]** Anti-ship strikes should use "group attack" in their attack-task
+* **[New Game Wizard]** Faction selection overview doesn't update when inverting map
+* **[New Game Wizard]** Aircraft mods are now handled better when they are disabled
+* **[Payloads]** Added/Updated (missing) payloads
+* **[Aircraft Tasking]** Revised aircraft tasking, filtering out incompatible tasks for several aircraft
+* **[Data]** Corrected the class of the USS Samuel Chase from Logistics to LandingShip, in order to prevent it being spawned as part of AAA sites.
+* **[Mission Generation]** Helicopters oscillating due to over-speeding
+* **[Mission Generation]** Fix infinite loop when using "Fast-Forward to first contact"
+* **[Capture Logic]** Release all parking slots when an airbase is captured
+* **[Modding]** Swedish Military Assets Pack air defence presets are now correctly removed from the faction when the mod is disabled.
+* **[Mission Generation]** Naval aircraft not always returning to carrier
+* **[Mission Generation]** AI AirLift aircraft crashing into terrain due to insufficient waypoints
+* **[Mission Generation]** Fix friendly AI shooting at fires on the front-line
+
+# Retribution v1.2.1 (hotfix)
+
+## Fixes
+* **[Flight Plans]** SEAD Sweep not being auto-planned
+* **[Modding]** Python-4 no longer overwrites AIM-9X
+* **[Modding]** Restore original amount of pylons to F-16C when "ejecting" sufa mod
+
+# Retribution v1.2.0
+
+## Features/Improvements
+* **[Preset Groups]** Add SA-2 with ZSU-23/57
+* **[Campaign Design]** Ability to define almost all possible settings in the campaign's yaml file.
+* **[Campaign Design]** Ability to add roadbases and/or ground spawns to campaigns.
+* **[Campaign Design]** Ability to define SCENERY REMOVE OBJECTS ZONE triggers with the roadbase objects in campaign miz. This might not work reliably in multiplayer due to DCS issues. FARPs can be used to remove scenery objects in multiplayer.
+* **[Options]** Implemented an option in settings to disable the above SCENERY REMOVE OBJECTS ZONE triggers.
+* **[Campaign Management]** Improved squadron retreat logic at longer ranges.
+* **[Options]** Ability to load & save your settings.
+* **[Options]** Added a separate Doctrine page in settings with the following new options:
+  * Minimum number of aircraft for autoplanner to plan OCA packages against 
+  * Airbase threat range (nmi)
+  * SEAD Sweep threat buffer distance (nmi)
+  * SEAD Escort/Sweep threat buffer distance (nmi)
+  * TARCAP threat buffer distance (nmi)
+  * AEW&C threat buffer distance (nmi)
+  * Theater tanker threat buffer distance (nmi)
+* **[Options]** Improved the option to configure OPFOR autoplanner aggressiveness. The AI might now take even more risks and plan missions against defended targets.
+* **[Options]** Added three new options in Settings:
+  * Autoplanner plans refueling flights for Strike packages
+  * Autoplanner plans refueling flights for OCA packages
+  * Autoplanner plans refueling flights for DEAD packages
+* **[UI]** Added fuel selector in flight's edit window.
+* **[Plugins]** Expose Splash Damage's "game_messages" option and set its default to false.
+* **[Mission Generation]** Improved AI SEAD capabilities, allowing for mixed loadouts using Decoys, ARMs & ASMs.
+* **[Modding]** Support for A-7E Corsair II (presumed latest available version)
+* **[Squadrons]** Added many new squadron's by Adecarcer
+* **[Plugins]** Updated 'expl_table' in Splash Damage script.
+* **[Mission Generation]** Also save kneeboards in txt-format, found under "kneeboards" within Retribution's installation folder after pressing take-off.
+* **[Modding]** Support for SW mod v2.55
+* **[Modding]** Support for Spanish & Australian Naval Assets v3.2.0 by desdemicabina
+* **[Modding]** Support for Iron Dome v1.2 by IDF Mods Project
+* **[New Game Wizard]** Re-organized generator options & show the regular settings menu instead of the limited "Difficulty & Automation" page.
+* **[Campaign Management]** Ability to operate harriers from FOBs/FARPs for <ins>__human pilots only__</ins>. Please note that the autoplanner won't generate flights for harriers at FOBs/FARPs, which means you need to plan your missions manually.
+* **[Mission Planning]** Allow NAV/REFUEL/DIVERT waypoints to be deleted without degrading to a custom flight-plan, also warning the user before actually degrading the flight-plan.
+* **[Campaign Generation]** Split "full-strength start" from "squadron aircraft limits" option.
+* **[Mission Generation]** General improvement w.r.t. DCS tasking, including a check for incompatible tasking.
+* **[Mission Generation]** OCA-Runway flights will remain at altitude when using guided bombs.
+* **[UX]** Added error message to indicate save-compatibility issues + fix to avoid total crash upon loading of last save.
+* **[UI]** Improved parking space information in air wing configuration dialog.
+* **[Squadrons]** Warning messages when opening up a squadron through the air wing dialog, indicating squadrons that potentially won't fit w.r.t. parking space.
+* **[Squadrons Transfers]** Determine number of available parking slots more accurately w.r.t. squadron transfers, taking aircraft dimensions into account which should prevent forced air-starts.
+* **[UX]** Allow usage of CTRL/SHIFT modifiers in ground unit transfer window.
+* **[Campaign Design]** Ability to define "spawn-routes" for convoys, allowing them to start from the road without having to edit the mission
+* **[Plugins]** Added "DCS Dismount" plugin.
+* **[Plugins]** Added "EWR Jammer" plugin (only for humans, may change in the future).
+* **[Campaign]** New campaign (Operation Desert Sabre) by Chimiste
+* **[Plugins]** Updated CTLD to latest released version
+* **[Options]** Renamed Maximum frontline length -> Maximum frontline width.
+* **[Squadrons]** Add livery selector in Squadron Dialog, allowing you to change the livery during the campaign.
+* **[New Game Wizard]** Automatically invert factions when 'Invert Map' is selected.
+* **[Flight Plans]** Added "SEAD Sweep" flight plan, which basically reintroduces the legacy "SEAD Escort" flight plan where the flight will engage whatever it can find without actually escorting the primary flight.
+* **[Flight Plans]** Added SEAD capability to F-16A MLU and SEAD Escort & SEAD to F-16A. 
+* **[Mission Generation]** Spawn unused helicopters or LHA-capable aircraft at helipads at FOBs
+* **[Modding]** Support for F-15I Ra'am v1.0 by IDF Mods Project
+
+## Fixes
+* **[New Game Wizard]** Settings would not persist when going back to a previous page (obsolete due to overhaul).
+* **[Mission Generation]** Unused aircraft are no longer claimed, fixing a bug where these aircraft would no longer be available after aborting the mission.
+* **[Mission Generation]** Fixed (potential) bug in helipad assignments at FOBs/FARPs.
+* **[Mission Generation]** Fix AI immediately returning to base when forced to air-start due to insufficient parking space.
+* **[Modding]** Fixed a bug where F-16Ds were not correctly removed from the faction when the F-16I/F-16D mod was not selected
+* **[UI]** Fixed F-16A MLU icon and banner.
+
+# Retribution v1.1.1  (hotfix)
+
+## Features/Improvements
+* **[Modding]** Support for IDF Mod Project F-16I Sufa & F-16D v3.6 mod
+* **[Modding]** Support for JAS-39 Gripen v1.8.5-beta mod
+
+## Fixes
+* **[Plugins]** Fix bug where changes to plugin options doesn't do anything.
+* **[Campaign Management]** Fix bug in procurement when no squadrons are present.
+* **[Layouts]** Fix edge-case bug layout's group size.
+* **[Campaign Design]** Preset groups assigned to specific TGOs not working as intended.
+
+# Retribution v1.1.0
 
 ## Features/Improvements
 * **[Mission Generation]** Given a CAS flight was planned, delay ground force attack until first CAS flight is on station
@@ -32,6 +191,7 @@
 * **[Campaign Management]** New options to allow more control of randomized flight sizes (applicable for BARCAP/CAS/OCA/ANTI-SHIP).
 * **[Plugins]** Updated Splash Damage script to v2.0 by RotorOps.
 * **[Mission Generation]** Improvements to DEAD & STRIKE flights, allowing AI to handle a larger variety of weapons.
+* **[Campaign]** New campaign (1968 Yankee Station) by Adecarcer
 
 ## Fixes
 * **[UI]** Removed deprecated options
@@ -44,12 +204,11 @@
 * **[Modding]** Fixed conflicts caused by HDS units
 * **[UX]** Gracefully handle corrupted preferences file.
 * **[Mission Generation]** Aircraft not using decoys during SEAD.
-* **[Campaign]** New campaign (1968 Yankee Station) by Adecarcer
 
-# Retribution 1.0.1 (hotfix)
+# Retribution v1.0.1 (hotfix)
 * **[Mission Generation]** Fix serialization issue when STRIKE flight has no escorts
 
-# Retribution 1.0.0
+# Retribution v1.0.0
 
 ## Features/Improvements
 * **[Engine]** Support for DCS v2.8.1.34437.
@@ -88,7 +247,92 @@ BAI/ANTISHIP/DEAD/STRIKE/BARCAP/CAS/OCA/AIR-ASSAULT (main) missions
 * **[Mission Generation]** Kneeboard STRIKE coordinates would sometimes get clipped when not fitting.
 * **[UI]** Fix exception when trying to add a waypoints to a flightplan.
 
+
 # Liberation:
+## Features/Improvements
+
+* **[Data]** Added support for the ARA Veinticinco de Mayo.
+* **[Data]** Changed display name of the AI-only F-15E Strike Eagle for clarity.
+* **[Flight Planning]** Improved IP selection for targets that are near the center of a threat zone.
+* **[Flight Planning]** Moved CAS ingress point off the front line so that the AI begins their target search earlier.
+* **[Flight Planning]** Loadouts and aircraft properties can now be set per-flight member. Warning: AI flights should not use mixed loadouts.
+* **[Flight Planning]** Laser codes that are pre-assigned to weapons at mission start can now be chosen from a list in the loadout UI. This does not affect the aircraft's TGP, just the weapons. Currently only implemented for the F-15E S4+ and F-16C.
+* **[Mission Generation]** Configured target and initial points for F-15E S4+.
+* **[Modding]** Factions can now specify the ship type to be used for cargo shipping. The Handy Wind will be used by default, but WW2 factions can pick something more appropriate.
+* **[Modding]** Unit variants can now set a display name separate from their ID.
+* **[UI]** An error will be displayed when invalid fast-forward options are selected rather than beginning a never ending simulation.
+* **[UI]** Added cheats for instantly repairing and destroying runways.
+* **[UI]** Improved usability of the flight properties UI. It now shows human-readable names and uses more appropriate UI elements.
+* **[UI]** The map now shows the real front line bounds.
+
+## Fixes
+
+* **[Campaign]** Fixed error when canceling squadron transfer if the current location would be exactly full.
+* **[Data]** Fixed the class of the Samuel Chase so it can't be picked for a AAA or SHORAD site.
+* **[Data]** Allow CH-47D, CH-53E and UH-60A to operate from carriers and LHAs.
+* **[Data]** Added the F-15E's LANTIRN to the list of known targeting pods. Player F-15E flight with TGPs will now be assigned laser codes.
+* **[Flight Planning]** Patrolling flight plans (CAS, CAP, refueling, etc) now handle TOT offsets.
+* **[Mission Generation]** Restored previous AI behavior for anti-ship missions. A DCS update caused only a single aircraft in a flight to attack. The full flight will now attack like they used to.
+* **[Mission Generation]** Fix generation of OCA Runway missions to allow LGBs to be used.
+* **[Mission Generation]** Fixed AI flights flying far too slowly toward NAV points.
+* **[Mission Generation]** Fixed "division by zero" error on mission generation when a flight has an "In-Flight" start type and starts on top of a mission waypoint.
+* **[Modding]** Unit variants can now actually override base unit type properties.
+* **[Plugins]** Fixed Lua errors in Skynet plugin that would occur whenever one coalition had no IADS nodes.
+* **[UI]** Fixed deleting waypoints in custom flight plans deleting the wrong waypoint.
+* **[UI]** Fixed flight properties UI to support F-15E S4+ laser codes.
+* **[UI]** Fixed UI bug where altering an "ahead of package" TOT offset would change the offset back to a "behind pacakge" offset.
+* **[UI]** Fixed bug where changing TOT offsets could result in flight startup times that are in the past.
+* **[UI]** Flight plan paths are now drawn behind all other map elements, fixing rare cases where they could prevent other UI elements from being clickable.
+
+# 8.1.0
+
+Saves from 8.0.0 are compatible with 8.1.0
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41363, including F-15E support.
+* **[UI]** Flight loadout/properties tab is now scrollable.
+
+## Fixes
+
+* **[Campaign]** Fixed liveries for premade squadrons all being off-by-one.
+* **[UI]** Fixed numbering of waypoints in the map and flight dialog (first waypoint is now 0 rather than 1).
+
+# 8.0.0
+
+Saves from 7.x are not compatible with 8.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41066, including the new Sinai map.
+* **[UI]** Limited size of overfull airbase display and added scrollbar.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Moved air wing and transfer menus to the toolbar to improve UI fit on low resolution displays.
+* **[UI]** Added basic game over dialog.
+
+## Fixes
+
+* **[Campaign]** Fix bug introduced in 7.0 where map strike target deaths are no longer tracked.
+* **[Mission Generation]** Fix crash during mission generation caused by out of date DCS data for the Gazelle.
+* **[Mission Generation]** Fix crash during mission generation when DCS beacon data is inconsistent.
+
+# 7.1.0
+
+Saves from 7.0.0 are compatible with 7.1.0
+
+## Features/Improvements
+
+* **[Factions]** Replaced Patriot STRs "EWRs" with AN/FPS-117 for blue factions 1980 or newer.
+* **[Mission Generation]** Added option to prevent scud and V2 sites from firing at the start of the mission.
+* **[Mission Planning]** Per-flight TOT offsets can now be set in the flight details UI. This allows individual flights to be scheduled ahead of or behind the rest of the package.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Parking capacity of each squadron's base is now shown during air wing configuration to avoid overcrowding bases when beginning the game with full squadrons.
+
+## Fixes
+
+* **[Mission Planning]** BAI is once again plannable against missile sites and coastal defense batteries.
+* **[UI]** Fixed formatting of departure time in flight details dialog.
+
 # 7.0.0
 
 Saves from 6.x are not compatible with 7.0.
@@ -97,15 +341,47 @@ Saves from 6.x are not compatible with 7.0.
 
 * **[Engine]** Support for DCS 2.8.3.37556.
 * **[Engine]** Saved games are now a zip file of save assets for easier bug reporting. The new extension is .liberation.zip. Drag and drop that file into bug reports.
+* **[Campaign]** Added options to limit squadron sizes and to begin all squadrons at maximum strength. Maximum squadron size is defined during air wing configuration with default values provided by the campaign.
+* **[Campaign]** Added handling for more DCS death events. This probably does not catch any deaths that weren't previously tracked, but it should record them sooner, which will improve results for game crashes or other early exits.
+* **[Campaign AI]** The campaign AI now prefers fulfilling missions with squadrons which have a matching primary task. Previously distance from target held a stronger influence than task preference. Primary tasks for squadrons are set by campaign designers but are user-configurable.
 * **[Flight Planning]** Package TOT and composition can be modified after advancing time in Liberation.
 * **[Mission Generation]** Units on the front line are now hidden on MFDs.
 * **[Mission Generation]** Preset radio channels will now be configured for both A-10C modules.
-* **[Mission Generation]** Both A-10C modules now use separate radios for inter- and intra-flight comms (similar to other modern aircraft).
+* **[Mission Generation]** The A-10C II now uses separate radios for inter- and intra-flight comms (similar to other modern aircraft).
+* **[Mission Generation]** Wind speeds no longer follow a uniform distribution. Median wind speeds are now much lower and the standard deviation has been reduced considerably at altitude but increased somewhat at MSL.
+* **[Mission Generation]** Improved task generation for SEAD flights carrying TALDs.
+* **[Mission Generation]** Added task timeout for SEAD flights with TALDs to prevent AI from overflying the target.
 * **[Modding]** Updated Community A-4E-C mod version support to 2.1.0 release.
 * **[Modding]** Add support for VSN F-4B and F-4C mod.
+* **[Modding]** Aircraft task capabilities and preferred aircraft for each task are now moddable in the aircraft unit yaml files. Each aircraft has a weight per task. Higher weights are given higher preference.
+* **[Modding]** The `mission_types` field in squadron files has been removed. Squadron task capability is now determined by airframe, and the auto-assignable list has always been overridden by the campaign settings.
+* **[Modding]** Wind speed generation inputs are now moddable. See https://dcs-liberation.rtfd.io/en/latest/modding/weather.html.
+* **[New Game Wizard]** Choices for some options will be remembered for the next new game. Not all settings will be preserved, as many are campaign dependent.
+* **[New Game Wizard]** Lua plugins can now be set while creating a new game.
+* **[New Game Wizard]** Squadrons can be directly replaced with a preset during air wing configuration rather than needing to remove and create a new squadron.
+* **[New Game Wizard]** Squadron liveries can now be selected during air wing configuration.
+* **[Squadrons]** Squadron-specific mission capability lists no longer restrict players from assigning missions outside the squadron's preferences.
+* **[New Game Wizard]** Squadrons can be directly replaced with a preset during air wing configuration rather than needing to remove and create a new squadron.
+* **[UI]** The orientation of objects like SAMs, EWRs, garrisons, and ships can now be manually adjusted.
 
 ## Fixes
 
+* **[Campaign]** Fixed a longstanding bug where oversized airlifts could corrupt a save with empty convoys.
+* **[Campaign]** Aircraft with built-in TGPs but without an external pod will no longer degrade automatic loadouts to iron bombs.
+* **[Engine]** Fixed crash in startup caused by a corrupted Liberation preferences file.
+* **[Flight Planning]** AEW&C missions are now plannable over FOBs and LHAs.
+* **[Flight Planning]** BAI is no longer plannable against buildings.
+* **[Modding]** Fixed an issue where Falklands campaigns created or edited with new versions of DCS could not be loaded.
+* **[Modding]** Fixed decoding of campaign yaml files to use UTF-8 rather than the system locale's default. It's now possible to use "Bf 109 K-4 Kurfürst" as a preferred aircraft type.
+* **[Mission Generation]** Planes will no longer spawn in helipads that are not also designated for fixed wing parking.
+* **[Mission Generation]** Potentially an issue where ground war planning game state could become corrupted, preventing mission generation.
+* **[Mission Generation]** Refueling tasks will now only be created for flights that have a tanker in their package.
+* **[Mission Generation]** Fixed missing Tanker task on recovery tanker missions.
+* **[UI]** Fixed error when resetting air wing configuration during game setup.
+* **[UI]** Fixed flight plan recreation when changing mission type with "Recreate as" flight options.
+* **[UI]** Fixed failure to launch UI when Liberation persistent preferences file was corrupt.
+
+
 # 6.1.1
 
 ## Fixes

client/package.json

@@ -15,7 +15,7 @@
     "@types/react": "^18.0.21",
     "@types/react-dom": "^18.0.6",
     "@types/react-redux": "^7.1.24",
-    "axios": "^1.1.2",
+    "axios": "^1.6.0",
     "electron-window-state": "^5.0.3",
     "esri-leaflet": "^3.0.8",
     "leaflet": "^1.9.2",
@@ -62,18 +62,26 @@
   },
   "devDependencies": {
     "@rtk-query/codegen-openapi": "^1.0.0",
-    "@trivago/prettier-plugin-sort-imports": "^3.3.0",
+    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
     "@types/leaflet": "^1.8.0",
     "@types/redux-logger": "^3.0.9",
     "@types/websocket": "^1.0.5",
-    "electron": "^21.1.0",
+    "electron": "^22.3.25",
     "electron-is-dev": "^2.0.0",
     "generate-license-file": "^2.0.0",
-    "got": "^11.8.5",
+    "identity-obj-proxy": "^3.0.0",
     "license-checker": "^25.0.1",
     "nth-check": "^2.0.1",
     "react-scripts": "5.0.1",
     "ts-node": "^10.9.1",
     "wait-on": "^6.0.1"
+  },
+  "jest": {
+    "transformIgnorePatterns": [
+      "node_modules/(?!(@?react-leaflet|axios)/)"
+    ],
+    "moduleNameMapper": {
+      ".+\\.(css|styl|less|sass|scss|png|jpg|ttf|woff|woff2)$": "identity-obj-proxy"
+    }
   }
 }

client/src/App.test.tsx

@@ -1,11 +1,11 @@
 import App from "./App";
-import { store } from "./app/store";
+import { setupStore } from "./app/store";
 import { render } from "@testing-library/react";
 import { Provider } from "react-redux";
 
 test("app renders", () => {
   render(
-    <Provider store={store}>
+    <Provider store={setupStore()}>
       <App />
     </Provider>
   );

client/src/api/_liberationApi.ts

@@ -50,14 +50,6 @@ const injectedRtkApi = api.injectEndpoints({
         url: `/debug/waypoint-geometries/hold/${queryArg.flightId}`,
       }),
     }),
-    getDebugIpZones: build.query<
-      GetDebugIpZonesApiResponse,
-      GetDebugIpZonesApiArg
-    >({
-      query: (queryArg) => ({
-        url: `/debug/waypoint-geometries/ip/${queryArg.flightId}`,
-      }),
-    }),
     getDebugJoinZones: build.query<
       GetDebugJoinZonesApiResponse,
       GetDebugJoinZonesApiArg
@@ -245,11 +237,6 @@ export type GetDebugHoldZonesApiResponse =
 export type GetDebugHoldZonesApiArg = {
   flightId: string;
 };
-export type GetDebugIpZonesApiResponse =
-  /** status 200 Successful Response */ IpZones;
-export type GetDebugIpZonesApiArg = {
-  flightId: string;
-};
 export type GetDebugJoinZonesApiResponse =
   /** status 200 Successful Response */ JoinZones;
 export type GetDebugJoinZonesApiArg = {
@@ -379,12 +366,6 @@ export type HoldZones = {
   permissibleZones: LatLng[][][];
   preferredLines: LatLng[][];
 };
-export type IpZones = {
-  homeBubble: LatLng[][];
-  ipBubble: LatLng[][];
-  permissibleZone: LatLng[][];
-  safeZones: LatLng[][][];
-};
 export type JoinZones = {
   homeBubble: LatLng[][];
   targetBubble: LatLng[][];
@@ -426,6 +407,7 @@ export type Tgo = {
   detection_ranges: number[];
   dead: boolean;
   sidc: string;
+  task?: string[];
 };
 export type SupplyRoute = {
   id: string;
@@ -497,7 +479,6 @@ export const {
   useSetControlPointDestinationMutation,
   useClearControlPointDestinationMutation,
   useGetDebugHoldZonesQuery,
-  useGetDebugIpZonesQuery,
   useGetDebugJoinZonesQuery,
   useListFlightsQuery,
   useGetFlightByIdQuery,

client/src/api/liberationApi.ts

@@ -30,11 +30,6 @@ export const liberationApi = _liberationApi.enhanceEndpoints({
         { type: Tags.FLIGHT_PLAN, id: arg.flightId },
       ],
     },
-    getDebugIpZones: {
-      providesTags: (result, error, arg) => [
-        { type: Tags.FLIGHT_PLAN, id: arg.flightId },
-      ],
-    },
     getDebugJoinZones: {
       providesTags: (result, error, arg) => [
         { type: Tags.FLIGHT_PLAN, id: arg.flightId },

client/src/app/store.ts

@@ -3,36 +3,48 @@ import combatReducer from "../api/combatSlice";
 import controlPointsReducer from "../api/controlPointsSlice";
 import flightsReducer from "../api/flightsSlice";
 import frontLinesReducer from "../api/frontLinesSlice";
+import iadsNetworkReducer from "../api/iadsNetworkSlice";
 import mapReducer from "../api/mapSlice";
 import navMeshReducer from "../api/navMeshSlice";
 import supplyRoutesReducer from "../api/supplyRoutesSlice";
 import tgosReducer from "../api/tgosSlice";
-import iadsNetworkReducer from "../api/iadsNetworkSlice";
 import threatZonesReducer from "../api/threatZonesSlice";
-import unculledZonesReducer  from "../api/unculledZonesSlice";
-import { Action, ThunkAction, configureStore } from "@reduxjs/toolkit";
+import unculledZonesReducer from "../api/unculledZonesSlice";
+import {
+  Action,
+  PreloadedState,
+  ThunkAction,
+  combineReducers,
+  configureStore,
+} from "@reduxjs/toolkit";
 
-export const store = configureStore({
-  reducer: {
-    combat: combatReducer,
-    controlPoints: controlPointsReducer,
-    flights: flightsReducer,
-    frontLines: frontLinesReducer,
-    map: mapReducer,
-    navmeshes: navMeshReducer,
-    supplyRoutes: supplyRoutesReducer,
-    iadsNetwork: iadsNetworkReducer,
-    tgos: tgosReducer,
-    threatZones: threatZonesReducer,
-    [baseApi.reducerPath]: baseApi.reducer,
-    unculledZones: unculledZonesReducer,
-  },
-  middleware: (getDefaultMiddleware) =>
-    getDefaultMiddleware().concat(baseApi.middleware),
+const rootReducer = combineReducers({
+  combat: combatReducer,
+  controlPoints: controlPointsReducer,
+  flights: flightsReducer,
+  frontLines: frontLinesReducer,
+  map: mapReducer,
+  navmeshes: navMeshReducer,
+  supplyRoutes: supplyRoutesReducer,
+  iadsNetwork: iadsNetworkReducer,
+  tgos: tgosReducer,
+  threatZones: threatZonesReducer,
+  [baseApi.reducerPath]: baseApi.reducer,
+  unculledZones: unculledZonesReducer,
 });
 
-export type AppDispatch = typeof store.dispatch;
-export type RootState = ReturnType<typeof store.getState>;
+export function setupStore(preloadedState?: PreloadedState<RootState>) {
+  return configureStore({
+    reducer: rootReducer,
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware().concat(baseApi.middleware),
+    preloadedState: preloadedState,
+  });
+}
+
+export type AppStore = ReturnType<typeof setupStore>;
+export type AppDispatch = AppStore["dispatch"];
+export type RootState = ReturnType<typeof rootReducer>;
 export type AppThunk<ReturnType = void> = ThunkAction<
   ReturnType,
   RootState,

client/src/components/aircraft/Aircraft.test.tsx

@@ -0,0 +1,53 @@
+import Aircraft from "./Aircraft";
+import { render } from "@testing-library/react";
+import { Icon } from "leaflet";
+
+const mockMarker = jest.fn();
+jest.mock("react-leaflet", () => ({
+  Marker: (props: any) => {
+    mockMarker(props);
+  },
+}));
+
+test("grounded aircraft do not render", async () => {
+  const { container } = render(
+    <Aircraft
+      flight={{
+        id: "",
+        blue: true,
+        position: undefined,
+        sidc: "",
+        waypoints: [],
+      }}
+    />
+  );
+
+  expect(container).toBeEmptyDOMElement();
+});
+
+test("in-flight aircraft render", async () => {
+  render(
+    <Aircraft
+      flight={{
+        id: "",
+        blue: true,
+        position: {
+          lat: 10,
+          lng: 20,
+        },
+        sidc: "foobar",
+        waypoints: [],
+      }}
+    />
+  );
+
+  expect(mockMarker).toHaveBeenCalledWith(
+    expect.objectContaining({
+      position: {
+        lat: 10,
+        lng: 20,
+      },
+      icon: expect.any(Icon),
+    })
+  );
+});

client/src/components/aircraftlayer/AircraftLayer.test.tsx

@@ -0,0 +1,53 @@
+import { renderWithProviders } from "../../testutils";
+import AircraftLayer from "./AircraftLayer";
+import { PropsWithChildren } from "react";
+
+const mockLayerGroup = jest.fn();
+const mockMarker = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Marker: (props: any) => {
+    mockMarker(props);
+  },
+}));
+
+test("layer is empty by default", async () => {
+  renderWithProviders(<AircraftLayer />);
+  expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+  expect(mockMarker).not.toHaveBeenCalled();
+});
+
+test("layer has aircraft if non-empty", async () => {
+  renderWithProviders(<AircraftLayer />, {
+    preloadedState: {
+      flights: {
+        flights: {
+          foo: {
+            id: "foo",
+            blue: true,
+            sidc: "",
+            position: {
+              lat: 0,
+              lng: 0,
+            },
+          },
+          bar: {
+            id: "bar",
+            blue: false,
+            sidc: "",
+            position: {
+              lat: 0,
+              lng: 0,
+            },
+          },
+        },
+        selected: null,
+      },
+    },
+  });
+  expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+  expect(mockMarker).toHaveBeenCalledTimes(2);
+});

client/src/components/airdefenserangelayer/AirDefenseRangeLayer.test.tsx

@@ -0,0 +1,149 @@
+import { renderWithProviders } from "../../testutils";
+import AirDefenseRangeLayer, { colorFor } from "./AirDefenseRangeLayer";
+import { PropsWithChildren } from "react";
+
+const mockLayerGroup = jest.fn();
+const mockCircle = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Circle: (props: any) => {
+    mockCircle(props);
+  },
+}));
+
+describe("colorFor", () => {
+  it("has a unique color for each configuration", () => {
+    const params = [
+      [false, false],
+      [false, true],
+      [true, false],
+      [true, true],
+    ];
+    var colors = new Set<string>();
+    for (const [blue, detection] of params) {
+      colors.add(colorFor(blue, detection));
+    }
+    expect(colors.size).toEqual(4);
+  });
+});
+
+describe("AirDefenseRangeLayer", () => {
+  it("draws nothing when there are no TGOs", () => {
+    renderWithProviders(<AirDefenseRangeLayer blue={true} />);
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+    expect(mockCircle).not.toHaveBeenCalled();
+  });
+
+  it("does not draw wrong range types", () => {
+    renderWithProviders(<AirDefenseRangeLayer blue={true} />, {
+      preloadedState: {
+        tgos: {
+          tgos: {
+            foo: {
+              id: "foo",
+              name: "Foo",
+              control_point_name: "Bar",
+              category: "AA",
+              blue: false,
+              position: {
+                lat: 0,
+                lng: 0,
+              },
+              units: [],
+              threat_ranges: [],
+              detection_ranges: [20],
+              dead: false,
+              sidc: "",
+              task: [],
+            },
+          },
+        },
+      },
+    });
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+    expect(mockCircle).not.toHaveBeenCalled();
+  });
+
+  it("draws threat ranges", () => {
+    renderWithProviders(<AirDefenseRangeLayer blue={true} />, {
+      preloadedState: {
+        tgos: {
+          tgos: {
+            foo: {
+              id: "foo",
+              name: "Foo",
+              control_point_name: "Bar",
+              category: "AA",
+              blue: true,
+              position: {
+                lat: 10,
+                lng: 20,
+              },
+              units: [],
+              threat_ranges: [10],
+              detection_ranges: [20],
+              dead: false,
+              sidc: "",
+              task: [],
+            },
+          },
+        },
+      },
+    });
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+    expect(mockCircle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        center: {
+          lat: 10,
+          lng: 20,
+        },
+        radius: 10,
+        color: colorFor(true, false),
+        interactive: false,
+      })
+    );
+  });
+
+  it("draws detection ranges", () => {
+    renderWithProviders(<AirDefenseRangeLayer blue={true} detection />, {
+      preloadedState: {
+        tgos: {
+          tgos: {
+            foo: {
+              id: "foo",
+              name: "Foo",
+              control_point_name: "Bar",
+              category: "AA",
+              blue: true,
+              position: {
+                lat: 10,
+                lng: 20,
+              },
+              units: [],
+              threat_ranges: [10],
+              detection_ranges: [20],
+              dead: false,
+              sidc: "",
+              task: [],
+            },
+          },
+        },
+      },
+    });
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+    expect(mockCircle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        center: {
+          lat: 10,
+          lng: 20,
+        },
+        radius: 20,
+        color: colorFor(true, true),
+        interactive: false,
+      })
+    );
+  });
+});

client/src/components/airdefenserangelayer/AirDefenseRangeLayer.tsx

@@ -9,7 +9,7 @@ interface TgoRangeCirclesProps {
   detection?: boolean;
 }
 
-function colorFor(blue: boolean, detection: boolean) {
+export function colorFor(blue: boolean, detection: boolean) {
   if (blue) {
     return detection ? "#bb89ff" : "#0084ff";
   }

client/src/components/combat/Combat.test.tsx

@@ -0,0 +1,132 @@
+import { renderWithProviders } from "../../testutils";
+import Combat from "./Combat";
+import { LatLng } from "leaflet";
+
+const mockPolyline = jest.fn();
+const mockPolygon = jest.fn();
+jest.mock("react-leaflet", () => ({
+  Polyline: (props: any) => {
+    mockPolyline(props);
+  },
+  Polygon: (props: any) => {
+    mockPolygon(props);
+  },
+}));
+
+describe("Combat", () => {
+  describe("footprint", () => {
+    it("is not interactive", () => {
+      renderWithProviders(
+        <Combat
+          combat={{
+            id: "foo",
+            flight_position: null,
+            target_positions: null,
+            footprint: [[new LatLng(0, 0), new LatLng(0, 1), new LatLng(1, 0)]],
+          }}
+        />
+      );
+      expect(mockPolygon).toBeCalledWith(
+        expect.objectContaining({ interactive: false })
+      );
+    });
+
+    // Fails because we don't handle multi-poly combat footprints correctly.
+    it.skip("renders single polygons", () => {
+      const boundary = [new LatLng(0, 0), new LatLng(0, 1), new LatLng(1, 0)];
+      renderWithProviders(
+        <Combat
+          combat={{
+            id: "foo",
+            flight_position: null,
+            target_positions: null,
+            footprint: [boundary],
+          }}
+        />
+      );
+      expect(mockPolygon).toBeCalledWith(
+        expect.objectContaining({ positions: boundary })
+      );
+    });
+
+    // Fails because we don't handle multi-poly combat footprints correctly.
+    it.skip("renders multiple polygons", () => {
+      const boundary = [new LatLng(0, 0), new LatLng(0, 1), new LatLng(1, 0)];
+      renderWithProviders(
+        <Combat
+          combat={{
+            id: "foo",
+            flight_position: null,
+            target_positions: null,
+            footprint: [boundary, boundary],
+          }}
+        />
+      );
+      expect(mockPolygon).toBeCalledTimes(2);
+    });
+  });
+
+  describe("lines", () => {
+    it("is not interactive", () => {
+      renderWithProviders(
+        <Combat
+          combat={{
+            id: "foo",
+            flight_position: new LatLng(0, 0),
+            target_positions: [new LatLng(1, 0)],
+            footprint: null,
+          }}
+        />
+      );
+      expect(mockPolyline).toBeCalledWith(
+        expect.objectContaining({ interactive: false })
+      );
+    });
+
+    it("renders single line", () => {
+      renderWithProviders(
+        <Combat
+          combat={{
+            id: "foo",
+            flight_position: new LatLng(0, 0),
+            target_positions: [new LatLng(0, 1)],
+            footprint: null,
+          }}
+        />
+      );
+      expect(mockPolyline).toBeCalledWith(
+        expect.objectContaining({
+          positions: [new LatLng(0, 0), new LatLng(0, 1)],
+        })
+      );
+    });
+
+    it("renders multiple lines", () => {
+      renderWithProviders(
+        <Combat
+          combat={{
+            id: "foo",
+            flight_position: new LatLng(0, 0),
+            target_positions: [new LatLng(0, 1), new LatLng(1, 0)],
+            footprint: null,
+          }}
+        />
+      );
+      expect(mockPolyline).toBeCalledTimes(2);
+    });
+  });
+
+  it("renders nothing if no footprint or targets", () => {
+    const { container } = renderWithProviders(
+      <Combat
+        combat={{
+          id: "foo",
+          flight_position: new LatLng(0, 0),
+          target_positions: null,
+          footprint: null,
+        }}
+      />
+    );
+    expect(container).toBeEmptyDOMElement();
+  });
+});

client/src/components/combatlayer/CombatLayer.test.tsx

@@ -0,0 +1,48 @@
+import { renderWithProviders } from "../../testutils";
+import CombatLayer from "./CombatLayer";
+import { LatLng } from "leaflet";
+import { PropsWithChildren } from "react";
+
+const mockPolyline = jest.fn();
+const mockLayerGroup = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Polyline: (props: any) => {
+    mockPolyline(props);
+  },
+}));
+
+describe("CombatLayer", () => {
+  it("renders each combat", () => {
+    renderWithProviders(<CombatLayer />, {
+      preloadedState: {
+        combat: {
+          combat: {
+            foo: {
+              id: "foo",
+              flight_position: new LatLng(0, 0),
+              target_positions: [new LatLng(0, 1)],
+              footprint: null,
+            },
+            bar: {
+              id: "foo",
+              flight_position: new LatLng(0, 0),
+              target_positions: [new LatLng(0, 1)],
+              footprint: null,
+            },
+          },
+        },
+      },
+    });
+    expect(mockPolyline).toBeCalledTimes(2);
+  });
+
+  it("renders LayerGroup but no contents if no combat", () => {
+    renderWithProviders(<CombatLayer />);
+    expect(mockLayerGroup).toBeCalledTimes(1);
+    expect(mockPolyline).not.toHaveBeenCalled();
+  });
+});

client/src/components/controlpointslayer/ControlPointsLayer.test.tsx

@@ -0,0 +1,52 @@
+import { renderWithProviders } from "../../testutils";
+import ControlPointsLayer from "./ControlPointsLayer";
+import { LatLng } from "leaflet";
+import { PropsWithChildren } from "react";
+
+const mockMarker = jest.fn();
+const mockLayerGroup = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Marker: (props: any) => {
+    mockMarker(props);
+  },
+}));
+
+describe("ControlPointsLayer", () => {
+  it("renders each control point", () => {
+    renderWithProviders(<ControlPointsLayer />, {
+      preloadedState: {
+        controlPoints: {
+          controlPoints: {
+            foo: {
+              id: "foo",
+              name: "Foo",
+              blue: true,
+              position: new LatLng(0, 0),
+              mobile: false,
+              sidc: "",
+            },
+            bar: {
+              id: "bar",
+              name: "Bar",
+              blue: false,
+              position: new LatLng(1, 0),
+              mobile: false,
+              sidc: "",
+            },
+          },
+        },
+      },
+    });
+    expect(mockMarker).toBeCalledTimes(2);
+  });
+
+  it("renders LayerGroup but no contents if no combat", () => {
+    renderWithProviders(<ControlPointsLayer />);
+    expect(mockLayerGroup).toBeCalledTimes(1);
+    expect(mockMarker).not.toHaveBeenCalled();
+  });
+});

client/src/components/cullingexclusionzones/CullingExclusionZones.test.tsx

@@ -0,0 +1,78 @@
+import { renderWithProviders } from "../../testutils";
+import CullingExclusionZones from "./CullingExclusionZones";
+import { PropsWithChildren } from "react";
+
+const mockCircle = jest.fn();
+const mockLayerGroup = jest.fn();
+const mockLayerControlOverlay = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  LayersControl: {
+    Overlay: (props: PropsWithChildren<any>) => {
+      mockLayerControlOverlay(props);
+      return <>{props.children}</>;
+    },
+  },
+  Circle: (props: any) => {
+    mockCircle(props);
+  },
+}));
+
+describe("CullingExclusionZones", () => {
+  it("is empty there are no exclusion zones", () => {
+    renderWithProviders(<CullingExclusionZones />);
+    expect(mockCircle).not.toHaveBeenCalled();
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+    expect(mockLayerControlOverlay).toHaveBeenCalledTimes(1);
+  });
+
+  describe("zone circles", () => {
+    it("are drawn in the correct locations", () => {
+      renderWithProviders(<CullingExclusionZones />, {
+        preloadedState: {
+          unculledZones: {
+            zones: [
+              {
+                position: {
+                  lat: 0,
+                  lng: 0,
+                },
+                radius: 10,
+              },
+              {
+                position: {
+                  lat: 1,
+                  lng: 1,
+                },
+                radius: 2,
+              },
+            ],
+          },
+        },
+      });
+      expect(mockCircle).toHaveBeenCalledTimes(2);
+      expect(mockCircle).toHaveBeenCalledWith(
+        expect.objectContaining({
+          center: {
+            lat: 0,
+            lng: 0,
+          },
+          radius: 10,
+        })
+      );
+      expect(mockCircle).toHaveBeenCalledWith(
+        expect.objectContaining({
+          center: {
+            lat: 1,
+            lng: 1,
+          },
+          radius: 2,
+        })
+      );
+    });
+    it("are not interactive", () => {});
+  });
+});

client/src/components/cullingexclusionzones/CullingExclusionZones.tsx

@@ -30,18 +30,10 @@ const CullingExclusionCircles = (props: CullingExclusionCirclesProps) => {
 
 export default function CullingExclusionZones() {
   const data = useAppSelector(selectUnculledZones).zones;
-  var cez = <></>;
 
-  if (!data) {
-    console.log("Empty response when loading culling exclusion zones");
-  } else {
-    cez = (
-      <CullingExclusionCircles zones={data}></CullingExclusionCircles>
-    );
-  }
   return (
     <LayersControl.Overlay name="Culling exclusion zones">
-      {cez}
+      <CullingExclusionCircles zones={data}></CullingExclusionCircles>
     </LayersControl.Overlay>
   );
 }

client/src/components/flightplan/FlightPlan.tsx

@@ -1,7 +1,8 @@
 import { Flight } from "../../api/liberationApi";
 import { useGetCommitBoundaryForFlightQuery } from "../../api/liberationApi";
 import WaypointMarker from "../waypointmarker";
-import { ReactElement } from "react";
+import { Polyline as LPolyline } from "leaflet";
+import { ReactElement, useEffect, useRef } from "react";
 import { Polyline } from "react-leaflet";
 
 const BLUE_PATH = "#0084ff";
@@ -27,16 +28,44 @@ const pathColor = (props: FlightPlanProps) => {
 function FlightPlanPath(props: FlightPlanProps) {
   const color = pathColor(props);
   const waypoints = props.flight.waypoints;
+
+  const polylineRef = useRef<LPolyline | null>(null);
+
+  // Flight paths should be drawn under everything else. There seems to be an
+  // issue where `interactive: false` doesn't do as its told (there's nuance,
+  // see the bug for details). It looks better if we draw the other elements on
+  // top of the flight plans anyway, so just push the flight plan to the back.
+  //
+  // https://github.com/dcs-liberation/dcs_liberation/issues/3295
+  //
+  // It's not possible to z-index a polyline (and leaflet says it never will be,
+  // because this is a limitation of SVG, not leaflet:
+  // https://github.com/Leaflet/Leaflet/issues/185), so we need to use
+  // bringToBack() to push the flight paths to the back of the drawing once
+  // they've been added to the map. They'll still draw on top of the map, but
+  // behind everything than was added before them. Anything added after always
+  // goes on top.
+  useEffect(() => {
+    if (props.selected) {
+        polylineRef.current?.bringToFront();
+    }
+    else {
+        polylineRef.current?.bringToBack();
+    }
+  });
+
   if (waypoints == null) {
     return <></>;
   }
   const points = waypoints
     .filter((waypoint) => waypoint.include_in_path)
     .map((waypoint) => waypoint.position);
+
   return (
     <Polyline
       positions={points}
       pathOptions={{ color: color, interactive: false }}
+      ref={polylineRef}
     />
   );
 }

client/src/components/flightplanslayer/FlightPlansLayer.test.tsx

@@ -0,0 +1,409 @@
+import { renderWithProviders } from "../../testutils";
+import FlightPlansLayer from "./FlightPlansLayer";
+import { PropsWithChildren } from "react";
+
+const mockPolyline = jest.fn();
+const mockLayerGroup = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Polyline: (props: any) => {
+    mockPolyline(props);
+  },
+}));
+
+// The waypoints in test data below should all use `should_make: false`. Markers
+// need useMap() to check the zoom level to decide if they should be drawn or
+// not, and we don't have good options here for mocking that behavior.
+describe("FlightPlansLayer", () => {
+  describe("unselected flights", () => {
+    it("are drawn", () => {
+      renderWithProviders(<FlightPlansLayer blue={true} />, {
+        preloadedState: {
+          flights: {
+            flights: {
+              foo: {
+                id: "foo",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+              bar: {
+                id: "bar",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+            },
+            selected: null,
+          },
+        },
+      });
+
+      // For some reason passing ref to PolyLine causes it and its group to be
+      // redrawn, so these numbers don't match what you'd expect from the test.
+      // It probably needs to be rewritten without mocks.
+      expect(mockPolyline).toHaveBeenCalledTimes(3);
+      expect(mockLayerGroup).toBeCalledTimes(2);
+    });
+    it("are not drawn if wrong coalition", () => {
+      renderWithProviders(<FlightPlansLayer blue={true} />, {
+        preloadedState: {
+          flights: {
+            flights: {
+              foo: {
+                id: "foo",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+              bar: {
+                id: "bar",
+                blue: false,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+            },
+            selected: null,
+          },
+        },
+      });
+      expect(mockPolyline).toHaveBeenCalledTimes(1);
+      expect(mockLayerGroup).toBeCalledTimes(1);
+    });
+    it("are not drawn when only selected flights are to be drawn", () => {
+      renderWithProviders(<FlightPlansLayer blue={true} selectedOnly />, {
+        preloadedState: {
+          flights: {
+            flights: {
+              foo: {
+                id: "foo",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+            },
+            selected: null,
+          },
+        },
+      });
+      expect(mockPolyline).not.toHaveBeenCalled();
+      expect(mockLayerGroup).toBeCalledTimes(1);
+    });
+  });
+  describe("selected flights", () => {
+    it("are drawn", () => {
+      renderWithProviders(<FlightPlansLayer blue={true} />, {
+        preloadedState: {
+          flights: {
+            flights: {
+              foo: {
+                id: "foo",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+              bar: {
+                id: "bar",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+            },
+            selected: "foo",
+          },
+        },
+      });
+      expect(mockPolyline).toHaveBeenCalledTimes(2);
+      expect(mockLayerGroup).toBeCalledTimes(1);
+    });
+    it("are not drawn twice", () => {
+      renderWithProviders(<FlightPlansLayer blue={true} />, {
+        preloadedState: {
+          flights: {
+            flights: {
+              foo: {
+                id: "foo",
+                blue: true,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+            },
+            selected: "foo",
+          },
+        },
+      });
+      expect(mockPolyline).toHaveBeenCalledTimes(1);
+      expect(mockLayerGroup).toBeCalledTimes(1);
+    });
+    it("are not drawn if red", () => {
+      renderWithProviders(<FlightPlansLayer blue={false} selectedOnly />, {
+        preloadedState: {
+          flights: {
+            flights: {
+              foo: {
+                id: "foo",
+                blue: false,
+                sidc: "",
+                waypoints: [
+                  {
+                    name: "",
+                    position: {
+                      lat: 0,
+                      lng: 0,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                  {
+                    name: "",
+                    position: {
+                      lat: 1,
+                      lng: 1,
+                    },
+                    altitude_ft: 0,
+                    altitude_reference: "MSL",
+                    is_movable: true,
+                    should_mark: false,
+                    include_in_path: true,
+                    timing: "",
+                  },
+                ],
+              },
+            },
+            selected: "foo",
+          },
+        },
+      });
+      expect(mockPolyline).not.toHaveBeenCalled();
+      expect(mockLayerGroup).toBeCalledTimes(1);
+    });
+  });
+  it("are not drawn if there are no flights", () => {
+    renderWithProviders(<FlightPlansLayer blue={true} />);
+    expect(mockPolyline).not.toHaveBeenCalled();
+    expect(mockLayerGroup).toBeCalledTimes(1);
+  });
+});

client/src/components/frontline/FrontLine.test.tsx

@@ -0,0 +1,32 @@
+import { renderWithProviders } from "../../testutils";
+import FrontLine from "./FrontLine";
+import { PolylineProps } from "react-leaflet";
+
+const mockPolyline = jest.fn();
+jest.mock("react-leaflet", () => ({
+  Polyline: (props: PolylineProps) => {
+    mockPolyline(props);
+  },
+}));
+
+describe("FrontLine", () => {
+  it("is drawn in the correct location", () => {
+    const extents = [
+      { lat: 0, lng: 0 },
+      { lat: 1, lng: 0 },
+    ];
+    renderWithProviders(
+      <FrontLine
+        front={{
+          id: "",
+          extents: extents,
+        }}
+      />
+    );
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        positions: extents,
+      })
+    );
+  });
+});

client/src/components/frontlineslayer/FrontLinesLayer.test.tsx

@@ -0,0 +1,56 @@
+import { renderWithProviders } from "../../testutils";
+import FrontLinesLayer from "./FrontLinesLayer";
+import { PropsWithChildren } from "react";
+
+const mockPolyline = jest.fn();
+const mockLayerGroup = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Polyline: (props: any) => {
+    mockPolyline(props);
+  },
+}));
+
+// The waypoints in test data below should all use `should_make: false`. Markers
+// need useMap() to check the zoom level to decide if they should be drawn or
+// not, and we don't have good options here for mocking that behavior.
+describe("FrontLinesLayer", () => {
+  it("draws nothing when there are no front lines", () => {
+    renderWithProviders(<FrontLinesLayer />);
+    expect(mockPolyline).not.toHaveBeenCalled();
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+  });
+
+  it("draws front lines", () => {
+    const extents = [
+      { lat: 0, lng: 0 },
+      { lat: 1, lng: 1 },
+    ];
+    renderWithProviders(<FrontLinesLayer />, {
+      preloadedState: {
+        frontLines: {
+          fronts: {
+            foo: {
+              id: "foo",
+              extents: extents,
+            },
+            bar: {
+              id: "bar",
+              extents: extents,
+            },
+          },
+        },
+      },
+    });
+    expect(mockPolyline).toHaveBeenCalledTimes(2);
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        positions: extents,
+      })
+    );
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+  });
+});

client/src/components/frontlineslayer/FrontLinesLayer.tsx

@@ -3,7 +3,7 @@ import { useAppSelector } from "../../app/hooks";
 import FrontLine from "../frontline";
 import { LayerGroup } from "react-leaflet";
 
-export default function SupplyRoutesLayer() {
+export default function FrontLinesLayer() {
   const fronts = useAppSelector(selectFrontLines).fronts;
   return (
     <LayerGroup>

client/src/components/liberationmap/LiberationMap.tsx

@@ -53,6 +53,18 @@ export default function LiberationMap() {
         <LayersControl.Overlay name="Air defenses" checked>
           <TgosLayer categories={["aa"]} />
         </LayersControl.Overlay>
+        <LayersControl.Overlay name="LORAD" >
+          <TgosLayer categories={["aa"]} task={"LORAD"} />
+        </LayersControl.Overlay>
+        <LayersControl.Overlay name="MERAD" >
+          <TgosLayer categories={["aa"]} task={"MERAD"} />
+        </LayersControl.Overlay>
+        <LayersControl.Overlay name="SHORAD" >
+          <TgosLayer categories={["aa"]} task={"SHORAD"} />
+        </LayersControl.Overlay>
+        <LayersControl.Overlay name="AAA" >
+          <TgosLayer categories={["aa"]} task={"AAA"} />
+        </LayersControl.Overlay>
         <LayersControl.Overlay name="Factories" checked>
           <TgosLayer categories={["factory"]} />
         </LayersControl.Overlay>

client/src/components/navmesh/NavMeshLayer.test.tsx

@@ -0,0 +1,125 @@
+import { renderWithProviders } from "../../testutils";
+import NavMeshLayer from "./NavMeshLayer";
+import { PropsWithChildren } from "react";
+
+const mockPolygon = jest.fn();
+const mockLayerGroup = jest.fn();
+jest.mock("react-leaflet", () => ({
+  LayerGroup: (props: PropsWithChildren<any>) => {
+    mockLayerGroup(props);
+    return <>{props.children}</>;
+  },
+  Polygon: (props: any) => {
+    mockPolygon(props);
+  },
+}));
+
+// The waypoints in test data below should all use `should_make: false`. Markers
+// need useMap() to check the zoom level to decide if they should be drawn or
+// not, and we don't have good options here for mocking that behavior.
+describe("NavMeshLayer", () => {
+  it("draws blue meshes", () => {
+    const poly1 = [
+      [
+        { lat: -1, lng: 0 },
+        { lat: 0, lng: 1 },
+        { lat: 1, lng: 0 },
+      ],
+    ];
+    const poly2 = [
+      [
+        { lat: -1, lng: 0 },
+        { lat: 0, lng: -1 },
+        { lat: 1, lng: 0 },
+      ],
+    ];
+    renderWithProviders(<NavMeshLayer blue={true} />, {
+      preloadedState: {
+        navmeshes: {
+          blue: [
+            {
+              poly: poly1,
+              threatened: false,
+            },
+            {
+              poly: poly2,
+              threatened: true,
+            },
+          ],
+          red: [
+            {
+              poly: [
+                [
+                  { lat: -1, lng: 0 },
+                  { lat: 0, lng: 2 },
+                  { lat: 1, lng: 0 },
+                ],
+              ],
+              threatened: false,
+            },
+          ],
+        },
+      },
+    });
+    expect(mockPolygon).toHaveBeenCalledTimes(2);
+    expect(mockPolygon).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fillColor: "#00ff00",
+        positions: poly1,
+        interactive: false,
+      })
+    );
+    expect(mockPolygon).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fillColor: "#ff0000",
+        positions: poly2,
+        interactive: false,
+      })
+    );
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+  });
+  it("draws red navmesh", () => {
+    renderWithProviders(<NavMeshLayer blue={false} />, {
+      preloadedState: {
+        navmeshes: {
+          blue: [
+            {
+              poly: [
+                [
+                  { lat: -1, lng: 0 },
+                  { lat: 0, lng: 1 },
+                  { lat: 1, lng: 0 },
+                ],
+              ],
+              threatened: false,
+            },
+            {
+              poly: [
+                [
+                  { lat: -1, lng: 0 },
+                  { lat: 0, lng: -1 },
+                  { lat: 1, lng: 0 },
+                ],
+              ],
+              threatened: true,
+            },
+          ],
+          red: [
+            {
+              poly: [
+                [
+                  { lat: -1, lng: 0 },
+                  { lat: 0, lng: 2 },
+                  { lat: 1, lng: 0 },
+                ],
+              ],
+              threatened: false,
+            },
+          ],
+        },
+      },
+    });
+    expect(mockPolygon).toHaveBeenCalledTimes(1);
+    expect(mockLayerGroup).toHaveBeenCalledTimes(1);
+  });
+});

client/src/components/tgoslayer/TgosLayer.tsx

@@ -6,14 +6,21 @@ import { LayerGroup } from "react-leaflet";
 interface TgosLayerProps {
   categories?: string[];
   exclude?: true;
+  task?: string;
 }
 
 export default function TgosLayer(props: TgosLayerProps) {
   const allTgos = Object.values(useAppSelector(selectTgos).tgos);
   const categoryFilter = props.categories ?? [];
+  const taskFilter = props.task ?? "";
   const tgos = allTgos.filter(
-    (tgo) => categoryFilter.includes(tgo.category) === !(props.exclude ?? false)
-  );
+      (tgo) => {
+        if (taskFilter && tgo.task){
+          return taskFilter === tgo.task[0]
+        }
+        return categoryFilter.includes(tgo.category) === !(props.exclude ?? false)
+      }
+    );
   return (
     <LayerGroup>
       {tgos.map((tgo) => {

client/src/components/waypointdebugzones/IpZones.tsx

@@ -1,73 +0,0 @@
-import { useGetDebugIpZonesQuery } from "../../api/liberationApi";
-import { LayerGroup, Polygon } from "react-leaflet";
-
-interface IpZonesProps {
-  flightId: string;
-}
-
-function IpZones(props: IpZonesProps) {
-  const { data, error, isLoading } = useGetDebugIpZonesQuery({
-    flightId: props.flightId,
-  });
-
-  if (isLoading) {
-    return <></>;
-  }
-
-  if (error) {
-    console.error("Error while loading waypoint IP zone info", error);
-    return <></>;
-  }
-
-  if (!data) {
-    console.log("Waypoint IP zone returned empty response");
-    return <></>;
-  }
-
-  return (
-    <>
-      <Polygon
-        positions={data.homeBubble}
-        color="#ffff00"
-        fillOpacity={0.1}
-        interactive={false}
-      />
-      <Polygon
-        positions={data.ipBubble}
-        color="#bb89ff"
-        fillOpacity={0.1}
-        interactive={false}
-      />
-      <Polygon
-        positions={data.permissibleZone}
-        color="#ffffff"
-        fillOpacity={0.1}
-        interactive={false}
-      />
-
-      {data.safeZones.map((zone, idx) => {
-        return (
-          <Polygon
-            key={idx}
-            positions={zone}
-            color="#80BA80"
-            fillOpacity={0.1}
-            interactive={false}
-          />
-        );
-      })}
-    </>
-  );
-}
-
-interface IpZonesLayerProps {
-  flightId: string | null;
-}
-
-export function IpZonesLayer(props: IpZonesLayerProps) {
-  return (
-    <LayerGroup>
-      {props.flightId ? <IpZones flightId={props.flightId} /> : <></>}
-    </LayerGroup>
-  );
-}

client/src/components/waypointdebugzones/WaypointDebugZonesControls.tsx

@@ -1,7 +1,6 @@
 import { selectSelectedFlightId } from "../../api/flightsSlice";
 import { useAppSelector } from "../../app/hooks";
 import { HoldZonesLayer } from "./HoldZones";
-import { IpZonesLayer } from "./IpZones";
 import { JoinZonesLayer } from "./JoinZones";
 import { LayersControl } from "react-leaflet";
 
@@ -16,9 +15,6 @@ export function WaypointDebugZonesControls() {
 
   return (
     <>
-      <LayersControl.Overlay name="IP zones">
-        <IpZonesLayer flightId={selectedFlightId} />
-      </LayersControl.Overlay>
       <LayersControl.Overlay name="Join zones">
         <JoinZonesLayer flightId={selectedFlightId} />
       </LayersControl.Overlay>

client/src/index.tsx

@@ -1,5 +1,5 @@
 import App from "./App";
-import { store } from "./app/store";
+import { setupStore } from "./app/store";
 import { SocketProvider } from "./components/socketprovider/socketprovider";
 import "./index.css";
 import * as serviceWorker from "./serviceWorker";
@@ -12,7 +12,7 @@ const root = ReactDOM.createRoot(
 );
 root.render(
   <React.StrictMode>
-    <Provider store={store}>
+    <Provider store={setupStore()}>
       <SocketProvider>
         <App />
       </SocketProvider>

client/src/testutils/index.tsx

@@ -0,0 +1,30 @@
+// https://redux.js.org/usage/writing-tests
+import { setupStore } from "../app/store";
+import type { AppStore, RootState } from "../app/store";
+import type { PreloadedState } from "@reduxjs/toolkit";
+import { render } from "@testing-library/react";
+import type { RenderOptions } from "@testing-library/react";
+import React, { PropsWithChildren } from "react";
+import { Provider } from "react-redux";
+
+// This type interface extends the default options for render from RTL, as well
+// as allows the user to specify other things such as initialState, store.
+interface ExtendedRenderOptions extends Omit<RenderOptions, "queries"> {
+  preloadedState?: PreloadedState<RootState>;
+  store?: AppStore;
+}
+
+export function renderWithProviders(
+  ui: React.ReactElement,
+  {
+    preloadedState = {},
+    // Automatically create a store instance if no store was passed in
+    store = setupStore(preloadedState),
+    ...renderOptions
+  }: ExtendedRenderOptions = {}
+) {
+  function Wrapper({ children }: PropsWithChildren<{}>): JSX.Element {
+    return <Provider store={store}>{children}</Provider>;
+  }
+  return { store, ...render(ui, { wrapper: Wrapper, ...renderOptions }) };
+}

codecov.yaml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    patch:
+      default:
+        informational: true
+    project:
+      default:
+        informational: true

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/conf.py

@@ -0,0 +1,34 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = "DCS Retribution"
+copyright = "2023, DCS Retribution Team"
+author = "DCS Retribution Team"
+release = "1.3.1"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "myst_parser",
+    "sphinx_rtd_theme",
+    "sphinx.ext.autosectionlabel",
+    "sphinx.ext.todo",
+]
+
+templates_path = ["_templates"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "sphinx_rtd_theme"
+html_static_path = ["_static"]
+
+todo_include_todos = True

docs/dev/design/index.rst

@@ -0,0 +1,8 @@
+Design docs
+===========
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   turnless.md

docs/dev/index.rst

@@ -0,0 +1,8 @@
+Developer documentation
+=======================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   design/index.rst

docs/game/index.rst

@@ -0,0 +1,6 @@
+Manual
+======
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:

docs/index.rst

@@ -0,0 +1,16 @@
+DCS Liberation
+==============
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   game/index.rst
+   modding/index.rst
+   dev/index.rst
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/modding/index.rst

@@ -0,0 +1,10 @@
+Modding guide
+=============
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   fuel-consumption-measurement.md
+   layouts.rst
+   weather.rst

docs/modding/layouts.rst

@@ -0,0 +1,397 @@
+The Layout System
+=================
+
+.. note::
+    The documentation of the layout system is still WIP and not
+    complete as the development of this feature involves a major refactoring
+    of the base code. Therefore this documentation is currently used for
+    development purpose primarily. The documentation will be updated soon.
+    Any help in updating this wiki page is appreciated!
+
+The Layout System is a new way of defining how ground objects like SAM
+Sites or other Vehicle / Ship Groups will be generated (which type of
+units, how many units, alignment and orientation). It is a complete
+rework of the previous generator-based logic which was written in python
+code. The new system allows to define layouts with easy to write yaml
+code and the use of the DCS Mission Editor for easier placement of the
+units. The layout system also introduced a new logical grouping of Units
+and layouts for them, the Armed Forces, which will allow major
+improvements to the Ground Warfare in upcoming features.
+
+**Armed Forces**
+
+The Armed Forces is a new system introduced with the layout system which will
+allow to identitfy and group possible units from the faction together with
+available layouts for these groups. It is comparable to the AirWing and Squadron
+implementation but just for Ground and Naval Forces. All possible Force Groups
+(grouping of 1 or more units and and the available layouts for them) will be
+generated during campaign initialization and will be used later by many
+different systems. A Force Group can also include static objects which was not
+possible before the introduction of the layout system. It is also possible to
+define presets of these Force Groups within the faction file which is handy for
+more complex groups like a SA-10 Battery or similar. Example: `SA-10.yaml`_.
+which includes all the units like SR, TR, LN and has the layout of a
+`S-300_Site.yaml`_.
+
+.. _SA-10.yaml: https://github.com/dcs-liberation/dcs_liberation/blob/develop/resources/groups/SA-10.yaml
+.. _S-300_Site.yaml: https://github.com/dcs-liberation/dcs_liberation/blob/develop/resources/layouts/anti_air/S-300_Site.yaml
+
+**The Layout System**
+
+In the previous system the generator which created the ground object was written
+in python which made modifications and reusability very complicated. To allow
+easier handling of the layouts and decoupling of alignment of units and the
+actual unit type (for example Ural-375) the layout system was introduced.
+Previously we had a generator for every different SAM Site, now we can just
+reuse the alignemnt (e.g. 6 Launchers in a circle alignment) for multiple SAM
+Systems and introduce more variety.
+
+This new System allows Users and Designers to easily create or modify
+layouts as the new alginment and orientation of units is defined with
+the DCS Mission editor. An additional .yaml file allows the
+configuration of the layout with settings like allow unit types or
+random amounts of units. In total the new system reduces the complexity
+and allows to precisely align / orient units as needed and create
+realistic looking ground units.
+
+As the whole ground unit generation and handling was reworked it is now
+also possible to add static units to a ground object, so even
+Fortifcation or similar can be added to templates in the future.
+
+General Concept
+~~~~~~~~~~~~~~~
+
+.. figure:: images/layouts.png
+   :alt: Overview
+
+   Overview
+
+All possible Force Groups will be generated during campaign
+initialization by checking all possible units for the specific faction
+and all available layouts. The code will automatically match general
+layouts with available units. It is also possible to define preset
+groups within the faction files which group many units and the prefered
+layouts for the group. This is especially handy for unique layouts which
+are not defined as ``global``. For example complex sam sites like the
+S-300 or Patriot which have very specific alignment of the different
+units.
+
+Layouts will be matched to units based on the special definition given
+in the corresponding yaml file. For example a layout which is defined as
+global and allows the unit_class SHORAD will automatically be used for
+all available SHORAD units which are defined in the faction file.
+
+.. todo:: Describe the optional flag.
+
+All these generated ForceGroups will be managed by the ArmedForces class
+of the specific coalition. This class will be used by other parts of the
+system like the start_generator or the BuyMenu. The ArmedForces class
+will then generate the TheaterGroundObject which will be used by
+liberation.
+
+Example for a customized Ground Object Buy Menu which makes use of
+Templates and UnitGroups:
+
+.. figure:: images/ground_object_buy_menu.png
+   :alt: Ground object buy menu
+
+   Ground object buy menu
+
+How to modify or add layouts
+----------------------------
+
+.. warning::
+    Whenever changes were made to layouts they have to be re-imported into
+    Liberation. See :ref:`Import Layouts into Liberation`.
+
+A layout consists of two special files:
+
+-  layout.miz which defines the actual positioning and alignment of the
+   groups / units
+-  layout.yaml which defines the necessary information like amount of
+   units, possible types or classes.
+
+To add a new template a new yaml has to be created as every yaml can
+only define exact one template. Best practice is to copy paste an
+existing template which is similar to the one to be created as starting
+point. The next step is to create a new .miz file and align Units and
+statics to the wishes. Even if existing ones can be reused, best
+practice is to always create a fresh one to prevent side effects. The
+most important part is to use a new Group for every different Unit Type.
+It is not possible to mix Unit Types in one group within a template. For
+example it is not possible to have a logistic truck and a AAA in the
+same group. The miz file will only be used to get the exact position and
+orientation of the units, therefore it is irrelevant which type of unit
+will be used. The unit type will be later defined inside the yaml file.
+For the next step all Group names have to be added to the yaml file.
+Take care to that these names match exactly! Assign the unit_types or
+unit_classes properties to math the needs.
+
+The Layout miz
+~~~~~~~~~~~~~~
+
+The miz file is used to define the positioning and orientation of the
+different units for the template. The actual unit which is used is
+irrelevant. It is important to use a unique and meaningful name for the
+groups as this will be used in the yaml file as well. The information
+which will be extracted from the miz file are just the coordinates and
+heading of the units.
+
+*Important*: Every different unit type has to be in a separate Group for
+the template to work. You can not add units of different types to the
+same group. They can get merged back together during generation by
+setting the group property. In the example below both groups
+``AAA Site 0`` and ``AAA Site 1`` have the group = 1 which means that
+they will be in the same dcs group during generation.
+
+*Important*: Liberation expects every template to be designed with an
+orientation of heading 0 (North) in mind. The complete GroundObject will
+during the campaign generation process be rotated to match the
+orientation defined by the campaign designer. If the layout was not
+created with an orientation of heading 0 the later generated
+GroundObject will likely be misaligned and not work properly.
+
+.. todo::
+    max amount of possible units is defined from the miz. Example if later the
+    group should have 6 units than there have to be 6 defined in the miz.
+
+.. figure:: images/layout_miz_example.png
+   :alt: Example template mission
+
+   Example template mission
+
+The Layout configuration file
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. todo:: Description about the layout yaml file.
+
+Possible Information:
+
+.. list-table::
+    :header-rows: 1
+
+    * - Property
+      - Type
+      - Required
+      - Description
+      - Example
+    * - name
+      - ``str``
+      - Yes
+      - A name to identify the template
+      - .. code:: yaml
+
+           name: Armor Group
+    * - tasks
+      - list of ``GroupTask``
+      - Yes
+      - A list of tasks which the template can fulfill
+      - .. code:: yaml
+
+           tasks:
+             - AAA
+             - SHORAD
+    * - generic
+      - ``bool``, default false
+      - No
+      - True if this template will be used to create general ``UnitGroups``
+      -
+    * - description
+      - ``str``
+      - No
+      - Short description of the template
+      -
+    * - groups
+      - List of ``Groups``
+      - Yes
+      - See below for definition of a group
+      -
+    * - layout_file
+      - ``str``
+      - No
+      - The .miz file which has the groups/units of the layout included. Only
+        needed if the file has a different name than the yaml file
+      - .. code:: yaml
+
+           layout_file: resources/layouts/naval/legacy_naval_templates.miz
+
+.. todo:: Group and SubGroup
+
+A group has 1..N sub groups. The name of the Group will be used later
+within the DCS group name.
+
+All SubGroups will be merged into one DCS Group
+
+Every unit type has to be defined as a sub group as following:
+
+.. list-table::
+    :header-rows: 1
+
+    * - Property
+      - Type
+      - Required
+      - Description
+    * - name
+      - ``str``
+      - Yes
+      - The group name used in the .miz. Must match exactly!
+    * - optional
+      - ``bool``, default: false
+      - No
+      - Defines wether the layout can be used without this group if the faction
+        has no access to the unit type or the user wants to disable this group
+    * - fill
+      - ``bool``, default: false
+      - No
+      - If the group is optional the layout is used from a PresetGroup this
+        property tells the system if it should use any possible faction
+        accessible unit to fill up this slot if no capable one was defined in
+        the preset yaml.
+    * - unit_count
+      - list of ``int``
+      - No
+      - Amount of units to be generated for this group. Can be fixed or a range
+        where it will be picked randomly
+    * - unit_types
+      - list of DCS unit type IDs
+      - No
+      - Specific unit_types for ground units. Complete list from `vehicles.py`_.
+        This list is extended by all supported mods!
+    * - unit_classes
+      - list of unit classes
+      - No
+      - Unit classes of supported units. Defined by ``UnitClass`` in
+        `game/data/units.py`_.
+    * - statics
+      - list of static types
+      - No
+      - Specific unit_types of statics. Complete list from `statics.py`_
+
+.. _vehicles.py: https://github.com/pydcs/dcs/blob/master/dcs/vehicles.py
+.. _game/data/units.py: https://github.com/dcs-liberation/dcs_liberation/blob/develop/game/data/units.py
+.. _statics.py: https://github.com/pydcs/dcs/blob/master/dcs/statics.py
+
+Complete example of a generic template for an Aircraft Carrier group:
+
+.. code:: yaml
+
+   name: Carrier Group
+   generic: true
+   tasks:
+     - AircraftCarrier
+   groups:
+     - Carrier: # Group Name of the DCS Group
+       - name: Carrier Group 0 # Sub Group used in the layout.miz
+         unit_count:
+           - 1
+         unit_classes:
+           - AircraftCarrier
+     - Escort: # Group name of the 2nd Group
+       - name: Carrier Group 1
+         unit_count:
+           - 4
+         unit_classes:
+           - Destroyer
+   layout_file: resources/layouts/naval/legacy_naval_templates.miz
+
+Import Layouts into Liberation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For performance improvements all layouts are serialized to a so called
+pickle file inside the save folder defined in the liberation
+preferences. Every time changes are made to the layouts this file has to
+be recreated. It can be recreated by either deleting the layouts.p file
+manually or using the special option in the Liberation Toolbar
+(Developer Tools -> Import Layouts). It will also be recreated after
+each Liberation update as it will check the Version Number and recreate
+it when changes are recognized.
+
+Migration from Generators
+-------------------------
+
+The previous generators were migrated using a script which build a group using
+the generator. All of these groups were save into one .miz file
+`original_generator_layouts.miz`_. This miz file can be used to verify the
+templates and to generalize similar templates to decouple the layout from the
+actual units. As this is a time-consuming and sphisticated task this will be
+done over time. With the first step the technical requirements will be fulfilled
+so that the generalization can happen afterwards the technical pr gets merged.
+
+.. _original_generator_layouts.miz: https://github.com/dcs-liberation/dcs_liberation/blob/develop/resources/layouts/original_generator_layouts.miz
+
+Updates for Factions
+~~~~~~~~~~~~~~~~~~~~
+
+With the rework there were also some changes to the faction file
+definitions. Older faction files can not be loaded anymore and have to
+be adopted to the new changes. During migration all default factions
+were automatically updated, so they will work out of the box.
+
+You can find more detailed information about how to customize the
+faction file in `Custom factions`_.
+
+What was changed:
+
+* Removed the ``ewrs`` list. All EWRs are now defined in the list
+  ``air_defense_units``.
+* Added the ``air_defense_units`` list. All units with the Role AntiAir can be
+  defined here as `GroundUnitType`_. All possible units are defined in
+  `resources/units/ground_units`_.
+* Added ``preset_groups``. This list allows to define Preset Groups (described
+  above) like SAM Systems consisting of Launcher, SR, TR and so on instead of
+  adding them each to “air_defense_units”. The presets are defined in
+  `resources/groups`_
+* Migrated ``air_defenses`` to air_defense_units and preset_sets.
+* ``Missiles`` are migrated to GroundUnitTypes instead of Generator names (see
+  air_defense_units for how to use)
+* Removed ``cruisers``, ``destroyers`` and ``naval_generators``. Migrated them
+  to naval_units and preset_groups
+* Added ``naval_units`` with the correct ship name found in
+  `resources/units/ships`_.
+* ``aircraft_carrier`` and ``helicopter_carrier`` were moved to ``naval_units``
+  as well.
+
+.. _Custom factions: https://github.com/dcs-liberation/dcs_liberation/wiki/Custom-Factions
+.. _GroundUnitType: https://github.com/dcs-liberation/dcs_liberation/blob/develop/game/dcs/groundunittype.py
+.. _resources/units/ground_units: https://github.com/dcs-liberation/dcs_liberation/blob/develop/resources/units/ground_units
+.. _resources/units/ships: https://github.com/dcs-liberation/dcs_liberation/blob/develop/resources/units/ships
+.. _resources/groups: https://github.com/dcs-liberation/dcs_liberation/blob/develop/resources/groups
+
+Preset Groups
+-------------
+
+Instead of adding the exact name of the previous generator to add
+complex groups like SAM sites or similar to the faction it is now
+possible to add preset groups to the faction file. As described earlier
+such a preset group (Force Group) can be defined very easy with a yaml
+file. This file allows to define the name, tasking, units, statics and
+the prefered layouts. The first task defines the primary role of the
+ForceGroup which gets generated from the preset.
+
+Example:
+
+.. code:: yaml
+
+   name: SA-10/S-300PS  # The name of the group
+   tasks: # Define at least 1 task
+     - LORAD  # The task(s) the Group can fulfill
+   units: # Define at least 1 unit
+     - SAM SA-10 S-300 "Grumble" Clam Shell SR
+     - SAM SA-10 S-300 "Grumble" Big Bird SR
+     - SAM SA-10 S-300 "Grumble" C2
+     - SAM SA-10 S-300 "Grumble" Flap Lid TR
+     - SAM SA-10 S-300 "Grumble" TEL D
+     - SAM SA-10 S-300 "Grumble" TEL C
+   statics: # Optional
+     - # Add some statics here
+   layouts: # Define at least one layout
+     - S-300 Site  # prefered layouts for these groups
+
+Resources:
+
+* A list of all available preset groups can be found here: `resources/groups`_
+* All possible tasks can be found in the `game/data/groups.py`_
+* Units are defined with the variant name found in `resources/units`_
+
+.. _game/data/groups.py: https://github.com/dcs-liberation/dcs_liberation/blob/develop/game/data/groups.py
+.. _resources/units: https://github.com/dcs-liberation/dcs_liberation/tree/develop/resources/units

docs/modding/weather.rst

@@ -0,0 +1,76 @@
+#######
+Weather
+#######
+
+Weather conditions in DCS Liberation are randomly generated at the start of each
+turn. Some of the inputs to that generator (more to come) can be controlled via
+the config files in ``resources/weather``.
+
+**********
+Archetypes
+**********
+
+A weather archetype defines the the conditions for a style of weather, such as
+"clear", or "raining". There are currently four archetypes:
+
+1. clear
+2. cloudy
+3. raining
+4. thunderstorm
+
+The odds of each archetype appearing in each season are defined in the theater
+yaml files (``resources/theaters/*/info.yaml``).
+
+.. literalinclude:: ../../resources/weather/archetypes/clear.yaml
+  :language: yaml
+  :linenos:
+  :caption: resources/weather/archetypes/clear.yaml
+
+Wind speeds
+===========
+
+DCS missions define wind with a speed and heading at each of three altitudes:
+
+1. MSL
+2. 2000 meters
+3. 8000 meters
+
+Blending between each altitude band is done in a manner defined by DCS.
+
+Liberation randomly generates a direction for the wind at MSL, and each other
+altitude band will have wind within +/- 90 degrees of that heading.
+
+Wind speeds can be modded by altering the ``speed`` dict in the archetype yaml.
+The only random distribution currently supported is the Weibull distribution, so
+all archetypes currently use:
+
+.. code:: yaml
+
+   speed:
+     weibull:
+       ...
+
+The Weibull distribution has two parameters: a shape and a scale.
+
+The scale is simplest to understand. 63.2% of all outcomes of the distribution
+are below the scale parameter.
+
+The shape controls where the peak of the distribution is. See the examples in
+the links below for illustrations and guidelines, but generally speaking low
+values (between 1 and 2.6) will cause low speeds to be more common, medium
+values (around 3) will be fairly evenly distributed around the median, and high
+values (greater than 3.7) will cause high speeds to be more common. As wind
+speeds tend to be higher at higher altitudes and fairly slow close to the
+ground, you typically want a low value for MSL, a medium value for 2000m, and a
+high value for 8000m.
+
+For examples, see https://statisticsbyjim.com/probability/weibull-distribution/.
+To experiment with different inputs, use Wolfram Alpha, e.g.
+https://www.wolframalpha.com/input?i=weibull+distribution+1.5+5.
+
+When generating wind speeds, each subsequent altitude band will have the lower
+band's speed added to its scale parameter. That is, for the example above, the
+actual scale parameter of ``at_2000m`` will be ``20 + wind speed at MSL``, and
+the scale parameter of ``at_8000m`` will be ``20 + wind speed at 2000m``. This
+is to ensure that a generally windy day (high wind speed at MSL) will create
+similarly high winds at higher altitudes and vice versa.

docs/requirements.txt

@@ -0,0 +1,2 @@
+myst-parser
+sphinx_rtd_theme

game/armedforces/forcegroup.py

@@ -191,11 +191,12 @@ class ForceGroup:
         location: PresetLocation,
         control_point: ControlPoint,
         game: Game,
+        task: Optional[GroupTask],
     ) -> TheaterGroundObject:
         """Create a random TheaterGroundObject from the available templates"""
         layout = random.choice(self.layouts)
         return self.create_ground_object_for_layout(
-            layout, name, location, control_point, game
+            layout, name, location, control_point, game, task
         )
 
     def create_ground_object_for_layout(
@@ -205,9 +206,10 @@ class ForceGroup:
         location: PresetLocation,
         control_point: ControlPoint,
         game: Game,
+        task: Optional[GroupTask],
     ) -> TheaterGroundObject:
         """Create a TheaterGroundObject for the given template"""
-        go = layout.create_ground_object(name, location, control_point)
+        go = layout.create_ground_object(name, location, control_point, task)
         # Generate all groups using the randomization if it defined
         for tgo_group in layout.groups:
             for unit_group in tgo_group.unit_groups:
@@ -287,7 +289,7 @@ class ForceGroup:
             unit.id = game.next_unit_id()
             # Add unit name escaped so that we do not have scripting issues later
             unit.name = escape_string_for_lua(
-                unit.unit_type.name if unit.unit_type else unit.type.name
+                unit.unit_type.variant_id if unit.unit_type else unit.type.name
             )
             unit.position = PointWithHeading.from_point(
                 ground_object.position + unit.position,

game/ato/__init__.py

@@ -1,4 +1,4 @@
-from .flight import Flight
 from .flighttype import FlightType
+from .flight import Flight
 from .flightwaypoint import FlightWaypoint
 from .package import Package

game/ato/ai_flight_planner_db.py

@@ -1,774 +0,0 @@
-import logging
-from collections.abc import Sequence
-from typing import Type
-
-from dcs.helicopters import (
-    AH_1W,
-    AH_64A,
-    AH_64D,
-    AH_64D_BLK_II,
-    CH_47D,
-    CH_53E,
-    Ka_50,
-    Ka_50_3,
-    Mi_24P,
-    Mi_24V,
-    Mi_26,
-    Mi_28N,
-    Mi_8MT,
-    OH_58D,
-    SA342L,
-    SA342M,
-    SH_60B,
-    UH_1H,
-    UH_60A,
-)
-from dcs.planes import (
-    AJS37,
-    AV8BNA,
-    A_10A,
-    A_10C,
-    A_10C_2,
-    A_20G,
-    A_50,
-    An_26B,
-    B_17G,
-    B_1B,
-    B_52H,
-    Bf_109K_4,
-    C_101CC,
-    C_130,
-    C_17A,
-    C_47,
-    E_2C,
-    E_3A,
-    FA_18C_hornet,
-    FW_190A8,
-    FW_190D9,
-    F_117A,
-    F_14A,
-    F_14A_135_GR,
-    F_14B,
-    F_15C,
-    F_15E,
-    F_16A,
-    F_16A_MLU,
-    F_16C_50,
-    F_4E,
-    F_5E_3,
-    F_86F_Sabre,
-    H_6J,
-    IL_76MD,
-    IL_78M,
-    I_16,
-    JF_17,
-    J_11A,
-    Ju_88A4,
-    KC130,
-    KC135MPRS,
-    KC_135,
-    KJ_2000,
-    L_39ZA,
-    MQ_9_Reaper,
-    M_2000C,
-    MiG_15bis,
-    MiG_19P,
-    MiG_21Bis,
-    MiG_23MLD,
-    MiG_25PD,
-    MiG_27K,
-    MiG_29A,
-    MiG_29G,
-    MiG_29S,
-    MiG_31,
-    Mirage_2000_5,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1C_200,
-    Mirage_F1CT,
-    MosquitoFBMkVI,
-    P_47D_30,
-    P_47D_30bl1,
-    P_47D_40,
-    P_51D,
-    P_51D_30_NA,
-    RQ_1A_Predator,
-    S_3B,
-    S_3B_Tanker,
-    SpitfireLFMkIX,
-    SpitfireLFMkIXCW,
-    Su_17M4,
-    Su_24M,
-    Su_25,
-    Su_25T,
-    Su_25TM,
-    Su_27,
-    Su_30,
-    Su_33,
-    Su_34,
-    Tornado_GR4,
-    Tornado_IDS,
-    Tu_142,
-    Tu_160,
-    Tu_22M3,
-    Tu_95MS,
-    WingLoong_I,
-    Yak_40,
-    MB_339A,
-)
-from dcs.unittype import FlyingType
-
-from game.dcs.aircrafttype import AircraftType
-from pydcs_extensions.a4ec.a4ec import A_4E_C
-from pydcs_extensions.a6a.a6a import VSN_A6A
-from pydcs_extensions.f100.f100 import VSN_F100
-from pydcs_extensions.f104.f104 import VSN_F104C, VSN_F104G, VSN_F104S, VSN_F104S_AG
-from pydcs_extensions.f105.f105 import VSN_F105D, VSN_F105G
-from pydcs_extensions.f15d.f15d import F_15D
-from pydcs_extensions.f16i_idf.f16i_idf import (
-    F_16D_50,
-    F_16D_52,
-    F_16D_50_NS,
-    F_16D_52_NS,
-    F_16D_Barak_30,
-    F_16D_Barak_40,
-    F_16I,
-)
-from pydcs_extensions.f22a.f22a import F_22A
-from pydcs_extensions.f4b.f4b import VSN_F4B, VSN_F4C
-from pydcs_extensions.f84g.f84g import VSN_F84G
-from pydcs_extensions.fa18efg.fa18efg import FA_18E, FA_18F, EA_18G
-from pydcs_extensions.hercules.hercules import Hercules
-from pydcs_extensions.jas39.jas39 import JAS39Gripen, JAS39Gripen_AG
-from pydcs_extensions.su30.su30 import Su_30MKA, Su_30MKI, Su_30MKM, Su_30SM
-from pydcs_extensions.su57.su57 import Su_57
-from pydcs_extensions.ov10a.ov10a import Bronco_OV_10A
-from pydcs_extensions.uh60l.uh60l import KC130J, UH_60L
-from .flighttype import FlightType
-
-# All aircraft lists are in priority order. Aircraft higher in the list will be
-# preferred over those lower in the list.
-# TODO: These lists really ought to be era (faction) dependent.
-# Factions which have F-5s, F-86s, and A-4s will should prefer F-5s for CAP, but
-# factions that also have F-4s should not.
-
-# Used for CAP, Escort, and intercept if there is not a specialised aircraft available
-ESCORT_CAPABLE = [
-    Su_57,
-    F_22A,
-    F_15C,
-    F_15D,
-    F_14B,
-    F_14A_135_GR,
-    F_14A,
-    Su_33,
-    J_11A,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Su_27,
-    MiG_29S,
-    F_16C_50,
-    F_16I,
-    F_16D_Barak_40,
-    F_16D_Barak_30,
-    F_16D_50,
-    F_16D_50_NS,
-    F_16D_52,
-    F_16D_52_NS,
-    FA_18E,
-    FA_18F,
-    FA_18C_hornet,
-    JF_17,
-    JAS39Gripen,
-    F_16A_MLU,
-    F_16A,
-    F_4E,
-    VSN_F4C,
-    VSN_F4B,
-    MiG_31,
-    MiG_25PD,
-    MiG_29G,
-    MiG_29A,
-    MiG_23MLD,
-    MiG_21Bis,
-    Mirage_2000_5,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1C_200,
-    Mirage_F1CT,
-    F_15E,
-    M_2000C,
-    F_5E_3,
-    VSN_F104S,
-    VSN_F104G,
-    VSN_F104C,
-    MiG_19P,
-    VSN_F100,
-    A_4E_C,
-    F_86F_Sabre,
-    MiG_15bis,
-    C_101CC,
-    VSN_F84G,
-    P_51D_30_NA,
-    P_51D,
-    SpitfireLFMkIXCW,
-    SpitfireLFMkIX,
-    MosquitoFBMkVI,
-    Bf_109K_4,
-    FW_190D9,
-    FW_190A8,
-    P_47D_30,
-    P_47D_30bl1,
-    P_47D_40,
-    I_16,
-]
-
-# Types to be skipped for escorts
-CAP_CAPABLE = ESCORT_CAPABLE + [
-    L_39ZA,
-]
-
-
-# Used for CAS (Close air support) and BAI (Battlefield Interdiction)
-CAS_CAPABLE = [
-    A_10C_2,
-    A_10C,
-    Hercules,
-    Su_34,
-    Su_25TM,
-    Su_25T,
-    Su_25,
-    F_15D,
-    F_15E,
-    F_16C_50,
-    F_16I,
-    F_16D_Barak_40,
-    F_16D_Barak_30,
-    F_16D_50,
-    F_16D_50_NS,
-    F_16D_52,
-    F_16D_52_NS,
-    FA_18E,
-    FA_18F,
-    FA_18C_hornet,
-    Tornado_GR4,
-    Tornado_IDS,
-    JAS39Gripen_AG,
-    JF_17,
-    AV8BNA,
-    A_10A,
-    F_16A_MLU,
-    F_16A,
-    B_1B,
-    A_4E_C,
-    F_14B,
-    F_14A_135_GR,
-    AJS37,
-    Su_24M,
-    Su_17M4,
-    Su_33,
-    F_4E,
-    S_3B,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    MiG_29S,
-    MiG_27K,
-    MiG_29A,
-    MiG_21Bis,
-    AH_64D_BLK_II,
-    AH_64D,
-    AH_64A,
-    AH_1W,
-    OH_58D,
-    SA342M,
-    SA342L,
-    Ka_50,
-    Ka_50_3,
-    Mi_28N,
-    Mi_24P,
-    Mi_24V,
-    Mi_8MT,
-    H_6J,
-    MiG_19P,
-    MiG_15bis,
-    M_2000C,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1CT,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    MB_339A,
-    Bronco_OV_10A,
-    UH_1H,
-    A_20G,
-    Ju_88A4,
-    P_47D_40,
-    P_47D_30bl1,
-    P_47D_30,
-    P_51D_30_NA,
-    P_51D,
-    SpitfireLFMkIXCW,
-    SpitfireLFMkIX,
-    MosquitoFBMkVI,
-    I_16,
-    Bf_109K_4,
-    FW_190D9,
-    FW_190A8,
-    WingLoong_I,
-    MQ_9_Reaper,
-    RQ_1A_Predator,
-    VSN_A6A,
-    VSN_F4C,
-    VSN_F4B,
-    VSN_F100,
-    VSN_F105G,
-    VSN_F105D,
-    VSN_F104S_AG,
-    VSN_F104G,
-    VSN_F104C,
-    VSN_F84G,
-]
-
-
-# Aircraft used for SEAD and SEAD Escort tasks. Must be capable of the CAS DCS task.
-SEAD_ESCORT_CAPABLE = [
-    JF_17,
-    F_16C_50,
-    F_16I,
-    F_16D_Barak_40,
-    F_16D_Barak_30,
-    F_16D_50,
-    F_16D_50_NS,
-    F_16D_52,
-    F_16D_52_NS,
-    EA_18G,
-    FA_18E,
-    FA_18F,
-    FA_18C_hornet,
-    Tornado_IDS,
-    Su_25T,
-    Su_25TM,
-    F_4E,
-    A_4E_C,
-    JAS39Gripen_AG,
-    AV8BNA,
-    Su_24M,
-    Su_17M4,
-    Su_34,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    MiG_27K,
-    Tornado_GR4,
-    VSN_F105G,
-    VSN_F100,
-]
-
-
-SEAD_CAPABLE = SEAD_ESCORT_CAPABLE + [
-    F_16A_MLU,
-    F_14B,
-    F_14A_135_GR,
-]
-
-# Aircraft used for DEAD tasks. Must be capable of the CAS DCS task.
-DEAD_CAPABLE = SEAD_CAPABLE + [
-    AJS37,
-    F_16A,
-    F_15E,
-    JAS39Gripen_AG,
-    B_1B,
-    B_52H,
-    Tu_160,
-    Tu_95MS,
-    H_6J,
-    A_20G,
-    Ju_88A4,
-    P_47D_40,
-    P_47D_30bl1,
-    P_47D_30,
-    P_51D_30_NA,
-    P_51D,
-    Bronco_OV_10A,
-    SpitfireLFMkIXCW,
-    SpitfireLFMkIX,
-    MosquitoFBMkVI,
-    Bf_109K_4,
-    FW_190D9,
-    FW_190A8,
-    VSN_A6A,
-    VSN_F105D,
-    VSN_F104S_AG,
-    VSN_F104G,
-    VSN_F104C,
-    VSN_F100,
-    VSN_F84G,
-]
-
-
-# Aircraft used for Strike mission
-STRIKE_CAPABLE = [
-    F_117A,
-    B_1B,
-    B_52H,
-    Tu_160,
-    Tu_95MS,
-    Tu_22M3,
-    H_6J,
-    F_15D,
-    F_15E,
-    AJS37,
-    Tornado_GR4,
-    F_16C_50,
-    F_16I,
-    F_16D_Barak_40,
-    F_16D_Barak_30,
-    F_16D_50,
-    F_16D_50_NS,
-    F_16D_52,
-    F_16D_52_NS,
-    FA_18E,
-    FA_18F,
-    FA_18C_hornet,
-    AV8BNA,
-    JF_17,
-    F_16A_MLU,
-    F_16A,
-    F_14B,
-    F_14A_135_GR,
-    JAS39Gripen_AG,
-    Tornado_IDS,
-    Su_17M4,
-    Su_24M,
-    Su_25TM,
-    Su_25T,
-    Su_25,
-    Su_34,
-    Su_33,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Su_27,
-    MiG_29S,
-    MiG_29G,
-    MiG_29A,
-    F_4E,
-    A_10C_2,
-    A_10C,
-    VSN_F4C,
-    VSN_F4B,
-    S_3B,
-    A_4E_C,
-    Bronco_OV_10A,
-    M_2000C,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1CT,
-    MiG_27K,
-    MiG_21Bis,
-    MiG_15bis,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    MB_339A,
-    B_17G,
-    A_20G,
-    Ju_88A4,
-    P_47D_40,
-    P_47D_30bl1,
-    P_47D_30,
-    P_51D_30_NA,
-    P_51D,
-    SpitfireLFMkIXCW,
-    SpitfireLFMkIX,
-    MosquitoFBMkVI,
-    Bf_109K_4,
-    FW_190D9,
-    FW_190A8,
-    VSN_A6A,
-    VSN_F100,
-    VSN_F104S_AG,
-    VSN_F104G,
-    VSN_F104C,
-    VSN_F105G,
-    VSN_F105D,
-    VSN_F84G,
-]
-
-
-ANTISHIP_CAPABLE = [
-    AJS37,
-    Tu_142,
-    Tu_22M3,
-    H_6J,
-    FA_18E,
-    FA_18F,
-    FA_18C_hornet,
-    JAS39Gripen_AG,
-    F_16A_MLU,
-    F_16A,
-    Su_24M,
-    Su_17M4,
-    JF_17,
-    Su_34,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Tornado_IDS,
-    Tornado_GR4,
-    AV8BNA,
-    S_3B,
-    A_20G,
-    Ju_88A4,
-    MosquitoFBMkVI,
-    C_101CC,
-    SH_60B,
-]
-
-
-# This list does not "inherit" from the strike list because some strike aircraft can
-# only carry guided weapons, and the AI cannot do runway attack with dguided weapons.
-# https://github.com/dcs-liberation/dcs_liberation/issues/1703
-RUNWAY_ATTACK_CAPABLE = [
-    JF_17,
-    Tornado_IDS,
-    M_2000C,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1CT,
-    H_6J,
-    B_1B,
-    B_52H,
-    Tu_22M3,
-    H_6J,
-    F_15E,
-    AJS37,
-    F_16C_50,
-    F_16I,
-    F_16D_Barak_40,
-    F_16D_Barak_30,
-    F_16D_50,
-    F_16D_50_NS,
-    F_16D_52,
-    F_16D_52_NS,
-    FA_18E,
-    FA_18F,
-    FA_18C_hornet,
-    AV8BNA,
-    JF_17,
-    F_16A_MLU,
-    F_16A,
-    F_14B,
-    F_14A_135_GR,
-    JAS39Gripen_AG,
-    Tornado_IDS,
-    Su_17M4,
-    Su_24M,
-    Su_25TM,
-    Su_25T,
-    Su_25,
-    Su_34,
-    Su_33,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Su_27,
-    MiG_29S,
-    MiG_29G,
-    MiG_29A,
-    F_4E,
-    A_10C_2,
-    A_10C,
-    VSN_F4C,
-    VSN_F4B,
-    S_3B,
-    A_4E_C,
-    Bronco_OV_10A,
-    M_2000C,
-    MiG_27K,
-    MiG_21Bis,
-    MiG_15bis,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    MB_339A,
-    B_17G,
-    A_20G,
-    Ju_88A4,
-    P_47D_40,
-    P_47D_30bl1,
-    P_47D_30,
-    P_51D_30_NA,
-    P_51D,
-    SpitfireLFMkIXCW,
-    SpitfireLFMkIX,
-    MosquitoFBMkVI,
-    Bf_109K_4,
-    FW_190D9,
-    FW_190A8,
-    VSN_A6A,
-    VSN_F105G,
-    VSN_F105D,
-    VSN_F104S_AG,
-    VSN_F104G,
-    VSN_F104C,
-    VSN_F100,
-]
-
-# For any aircraft that isn't necessarily directly involved in strike
-# missions in a direct combat sense, but can transport objects and infantry.
-TRANSPORT_CAPABLE = [
-    C_17A,
-    Hercules,
-    C_130,
-    C_47,
-    IL_76MD,
-    An_26B,
-    Yak_40,
-    CH_53E,
-    CH_47D,
-    UH_60L,
-    SH_60B,
-    UH_60A,
-    UH_1H,
-    Mi_8MT,
-    Mi_8MT,
-    Mi_26,
-]
-
-AIR_ASSAULT_CAPABLE = [
-    CH_53E,
-    CH_47D,
-    UH_60L,
-    SH_60B,
-    UH_60A,
-    UH_1H,
-    Mi_8MT,
-    Mi_26,
-    Mi_24P,
-    Mi_24V,
-    Hercules,
-]
-
-DRONES = [MQ_9_Reaper, RQ_1A_Predator, WingLoong_I]
-
-AEWC_CAPABLE = [
-    E_3A,
-    E_2C,
-    A_50,
-    KJ_2000,
-]
-
-# Priority is given to the tankers that can carry the most fuel.
-REFUELING_CAPABALE = [
-    KC_135,
-    KC135MPRS,
-    IL_78M,
-    KC130J,
-    KC130,
-    S_3B_Tanker,
-]
-
-
-def dcs_types_for_task(task: FlightType) -> Sequence[Type[FlyingType]]:
-    cap_missions = (
-        FlightType.BARCAP,
-        FlightType.INTERCEPTION,
-        FlightType.SWEEP,
-        FlightType.TARCAP,
-    )
-    if task in cap_missions:
-        return CAP_CAPABLE
-    elif task == FlightType.ANTISHIP:
-        return ANTISHIP_CAPABLE
-    elif task == FlightType.BAI:
-        return CAS_CAPABLE
-    elif task == FlightType.CAS:
-        return CAS_CAPABLE
-    elif task == FlightType.SEAD:
-        return SEAD_CAPABLE
-    elif task == FlightType.SEAD_ESCORT:
-        return SEAD_ESCORT_CAPABLE
-    elif task == FlightType.DEAD:
-        return DEAD_CAPABLE
-    elif task == FlightType.OCA_AIRCRAFT:
-        return CAS_CAPABLE
-    elif task == FlightType.OCA_RUNWAY:
-        return RUNWAY_ATTACK_CAPABLE
-    elif task == FlightType.STRIKE:
-        return STRIKE_CAPABLE
-    elif task == FlightType.ESCORT:
-        return ESCORT_CAPABLE
-    elif task == FlightType.AEWC:
-        return AEWC_CAPABLE
-    elif task == FlightType.REFUELING:
-        return REFUELING_CAPABALE
-    elif task == FlightType.TRANSPORT:
-        return TRANSPORT_CAPABLE
-    elif task == FlightType.AIR_ASSAULT:
-        return AIR_ASSAULT_CAPABLE
-    else:
-        logging.error(f"Unplannable flight type: {task}")
-        return []
-
-
-def aircraft_for_task(task: FlightType) -> list[AircraftType]:
-    dcs_types = dcs_types_for_task(task)
-    types: list[AircraftType] = []
-    for dcs_type in dcs_types:
-        types.extend(AircraftType.for_dcs_type(dcs_type))
-    return types
-
-
-def tasks_for_aircraft(aircraft: AircraftType) -> list[FlightType]:
-    tasks: list[FlightType] = []
-    for task in FlightType:
-        if task is FlightType.FERRY:
-            # Not a plannable task, so skip it.
-            continue
-        if aircraft in aircraft_for_task(task):
-            tasks.append(task)
-    return tasks

game/ato/flight.py

@@ -1,17 +1,24 @@
 from __future__ import annotations
 
+import random
 import uuid
+from collections.abc import Iterator
 from datetime import datetime, timedelta
 from typing import Any, List, Optional, TYPE_CHECKING
 
 from dcs import Point
 from dcs.planes import C_101CC, C_101EB, Su_33, FA_18C_hornet
 
+from game.dcs.aircrafttype import AircraftType
+from game.theater import ControlPoint, MissionTarget
 from pydcs_extensions.hercules.hercules import Hercules
+from .flightmembers import FlightMembers
 from .flightroster import FlightRoster
 from .flightstate import FlightState, Navigating, Uninitialized
 from .flightstate.killed import Killed
-from .loadouts import Loadout, Weapon
+from .flighttype import FlightType
+from .loadouts import Weapon
+from ..radio.CallsignContainer import CallsignContainer
 from ..radio.RadioFrequencyContainer import RadioFrequencyContainer
 from ..radio.TacanContainer import TacanContainer
 from ..radio.radios import RadioFrequency
@@ -23,16 +30,15 @@ from ..sidc import (
     Status,
     SymbolSet,
 )
-from game.dcs.aircrafttype import AircraftType
 
 if TYPE_CHECKING:
     from game.sim.gameupdateevents import GameUpdateEvents
     from game.sim.simulationresults import SimulationResults
     from game.squadrons import Squadron, Pilot
-    from game.theater import ControlPoint
     from game.transfers import TransferOrder
+    from game.data.weapons import WeaponType
+    from .flightmember import FlightMember
     from .flightplans.flightplan import FlightPlan
-    from .flighttype import FlightType
     from .flightwaypoint import FlightWaypoint
     from .package import Package
     from .starttype import StartType
@@ -40,11 +46,12 @@ if TYPE_CHECKING:
 F18_TGP_PYLON: int = 4
 
 
-class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
+class Flight(
+    SidcDescribable, RadioFrequencyContainer, TacanContainer, CallsignContainer
+):
     def __init__(
         self,
         package: Package,
-        country: str,
         squadron: Squadron,
         count: int,
         flight_type: FlightType,
@@ -55,30 +62,33 @@ class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
         roster: Optional[FlightRoster] = None,
         frequency: Optional[RadioFrequency] = None,
         channel: Optional[TacanChannel] = None,
-        callsign: Optional[str] = None,
+        callsign_tcn: Optional[str] = None,
+        claim_inv: bool = True,
     ) -> None:
         self.id = uuid.uuid4()
         self.package = package
-        self.country = country
         self.coalition = squadron.coalition
         self.squadron = squadron
-        self.squadron.claim_inventory(count)
-        if roster is None:
-            self.roster = FlightRoster(self.squadron, initial_size=count)
-        else:
-            self.roster = roster
-        self.divert = divert
         self.flight_type = flight_type
-        self.loadout = Loadout.default_for(self)
+        if claim_inv:
+            self.squadron.claim_inventory(count)
+        if roster is None:
+            self.roster = FlightMembers(self, initial_size=count)
+        else:
+            self.roster = FlightMembers.from_roster(self, roster)
+        self.divert = divert
+
         self.start_type = start_type
-        self.use_custom_loadout = False
         self.custom_name = custom_name
         self.group_id: int = 0
 
         self.frequency = frequency
         if self.unit_type.dcs_unit_type.tacan:
             self.tacan = channel
-            self.tcn_name = callsign
+            self.tcn_name = callsign_tcn
+
+        self.initialize_fuel()
+        self.use_same_loadout_for_all_members = True
 
         # Only used by transport missions.
         self.cargo = cargo
@@ -105,11 +115,35 @@ class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
         is_f18 = self.squadron.aircraft.dcs_unit_type.id == FA_18C_hornet.id
         on_land = not self.squadron.location.is_fleet
         if on_land and is_f18 and self.coalition.game.settings.atflir_autoswap:
-            self.loadout.pylons[F18_TGP_PYLON] = Weapon.with_clsid(
-                str(
-                    FA_18C_hornet.Pylon4.AN_AAQ_28_LITENING___Targeting_Pod_[1]["clsid"]
+            for fm in self.roster.members:
+                fm.loadout.pylons[F18_TGP_PYLON] = Weapon.with_clsid(
+                    str(
+                        FA_18C_hornet.Pylon4.AN_AAQ_28_LITENING___Targeting_Pod[1][
+                            "clsid"
+                        ]
+                    )
                 )
-            )
+
+        # altitude offset for planes
+        offset_factor = self.coalition.game.settings.max_plane_altitude_offset
+        offset_factor = random.randint(0, offset_factor)
+        self.plane_altitude_offset = 1000 * offset_factor * random.choice([-1, 1])
+
+    @property
+    def available_callsigns(self) -> List[str]:
+        callsigns = set()
+        dcs_unit = self.squadron.aircraft.dcs_unit_type
+        category = dcs_unit.category
+        category = "Air" if category == "Interceptor" else category
+        for name in self.squadron.coalition.faction.country.callsign[category]:
+            callsigns.add(name)
+        if hasattr(dcs_unit, "callnames"):
+            country_name = self.squadron.coalition.faction.country.name
+            for c in dcs_unit.callnames:
+                if "Combined Joint Task Forces" in country_name or c == country_name:
+                    for name in dcs_unit.callnames[c]:
+                        callsigns.add(name)
+        return sorted(callsigns)
 
     @property
     def flight_plan(self) -> FlightPlan[Any]:
@@ -132,7 +166,11 @@ class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
 
     def __setstate__(self, state: dict[str, Any]) -> None:
         state["state"] = Uninitialized(self, state["squadron"].settings)
+        if "use_same_loadout_for_all_members" not in state:
+            state["use_same_loadout_for_all_members"] = True
         self.__dict__.update(state)
+        if isinstance(self.roster, FlightRoster):
+            self.roster = FlightMembers.from_roster(self, self.roster)
 
     @property
     def blue(self) -> bool:
@@ -170,22 +208,29 @@ class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
     def unit_type(self) -> AircraftType:
         return self.squadron.aircraft
 
+    @property
+    def is_lha(self) -> bool:
+        return self.unit_type.lha_capable
+
     @property
     def is_helo(self) -> bool:
-        return self.unit_type.dcs_unit_type.helicopter
+        return self.unit_type.helicopter
 
     @property
     def is_hercules(self) -> bool:
         return self.unit_type == AircraftType.named("C-130J-30 Super Hercules")
 
-    @property
-    def from_cp(self) -> ControlPoint:
-        return self.departure
-
     @property
     def points(self) -> List[FlightWaypoint]:
         return self.flight_plan.waypoints[1:]
 
+    @property
+    def custom_targets(self) -> List[MissionTarget]:
+        return [
+            MissionTarget(wpt.name, wpt.position)
+            for wpt in self.flight_plan.layout.custom_waypoints
+        ]
+
     def position(self) -> Point:
         return self.state.estimate_position()
 
@@ -200,23 +245,42 @@ class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
     def missing_pilots(self) -> int:
         return self.roster.missing_pilots
 
+    def iter_members(self) -> Iterator[FlightMember]:
+        yield from self.roster.members
+
+    def set_flight_type(self, var: FlightType) -> None:
+        self.flight_type = var
+
+        # Update _flight_plan_builder so that the builder class remains relevant
+        # to the flight type
+        from .flightplans.flightplanbuildertypes import FlightPlanBuilderTypes
+
+        self._flight_plan_builder = FlightPlanBuilderTypes.for_flight(self)(self)
+
     def return_pilots_and_aircraft(self) -> None:
         self.roster.clear()
         self.squadron.claim_inventory(-self.count)
 
-    def max_takeoff_fuel(self) -> Optional[float]:
-        # Special case so Su 33 and C101 can take off
+    def initialize_fuel(self) -> None:
         unit_type = self.unit_type.dcs_unit_type
+        self.fuel = unit_type.fuel_max
+        # Special cases where we want less fuel for takeoff
         if unit_type == Su_33:
             if self.flight_type.is_air_to_air:
-                return Su_33.fuel_max / 2.2
+                self.fuel = Su_33.fuel_max / 2.2
             else:
-                return Su_33.fuel_max * 0.8
+                self.fuel = Su_33.fuel_max * 0.8
         elif unit_type in {C_101EB, C_101CC}:
-            return unit_type.fuel_max * 0.5
+            self.fuel = unit_type.fuel_max * 0.5
         elif unit_type == Hercules:
-            return unit_type.fuel_max * 0.75
-        return None
+            self.fuel = unit_type.fuel_max * 0.75
+        elif self.departure.cptype.name in ["FARP", "FOB"] and not self.is_helo:
+            self.fuel = unit_type.fuel_max * 0.75
+
+    def any_member_has_weapon_of_type(self, weapon_type: WeaponType) -> bool:
+        return any(
+            m.loadout.has_weapon_of_type(weapon_type) for m in self.iter_members()
+        )
 
     def __repr__(self) -> str:
         return self.__str__()
@@ -277,18 +341,17 @@ class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
             Killed(self.state.estimate_position(), self, self.squadron.settings)
         )
         events.update_flight(self)
-        for pilot in self.roster.pilots:
+        for pilot in self.roster.iter_pilots():
             if pilot is not None:
                 results.kill_pilot(self, pilot)
 
-    def recreate_flight_plan(self) -> None:
-        self._flight_plan_builder.regenerate()
+    def recreate_flight_plan(self, dump_debug_info: bool = False) -> None:
+        self._flight_plan_builder.regenerate(dump_debug_info)
 
     @staticmethod
     def clone_flight(flight: Flight) -> Flight:
         return Flight(
             flight.package,
-            flight.country,
             flight.squadron,
             flight.count,
             flight.flight_type,

game/ato/flightmember.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from game.ato.loadouts import Loadout
+from game.lasercodes import LaserCode
+
+if TYPE_CHECKING:
+    from game.squadrons import Pilot
+
+
+class FlightMember:
+    def __init__(self, pilot: Pilot | None, loadout: Loadout) -> None:
+        self.pilot = pilot
+        self.loadout = loadout
+        self.use_custom_loadout = False
+        self.tgp_laser_code: LaserCode | None = None
+        self.weapon_laser_code: LaserCode | None = None
+        self.properties: dict[str, bool | float | int] = {}
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        if "tgp_laser_code" not in state:
+            state["tgp_laser_code"] = None
+        if "weapon_laser_code" not in state:
+            state["weapon_laser_code"] = None
+        self.__dict__.update(state)
+
+    def assign_tgp_laser_code(self, code: LaserCode) -> None:
+        if self.tgp_laser_code is not None:
+            raise RuntimeError(
+                f"{self.pilot} already has already been assigned laser code "
+                f"{self.tgp_laser_code}"
+            )
+        self.tgp_laser_code = code
+
+    def release_tgp_laser_code(self) -> None:
+        if self.tgp_laser_code is None:
+            raise RuntimeError(f"{self.pilot} has no assigned laser code")
+
+        if self.weapon_laser_code == self.tgp_laser_code:
+            self.weapon_laser_code = None
+        self.tgp_laser_code.release()
+        self.tgp_laser_code = None
+
+    @property
+    def is_player(self) -> bool:
+        if self.pilot is None:
+            return False
+        return self.pilot.player

game/ato/flightmembers.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Optional, TYPE_CHECKING
+
+from .flightmember import FlightMember
+from .flightroster import FlightRoster
+from .iflightroster import IFlightRoster
+from .loadouts import Loadout
+from ..data.weapons import Weapon
+
+if TYPE_CHECKING:
+    from game.squadrons import Pilot, Squadron
+    from .flight import Flight
+
+
+class FlightMembers(IFlightRoster):
+    def __init__(self, flight: Flight, initial_size: int = 0) -> None:
+        self.flight = flight
+        self.members: list[FlightMember] = []
+        self.resize(initial_size)
+
+    @property
+    def squadron(self) -> Squadron:
+        return self.flight.squadron
+
+    @staticmethod
+    def from_roster(flight: Flight, roster: FlightRoster) -> FlightMembers:
+        members = FlightMembers(flight)
+        loadout = Loadout.default_for(flight)
+        if flight.squadron.aircraft.variant_id == "F-15I Ra'am":
+            loadout.pylons[16] = Weapon.with_clsid("{IDF_MODS_PROJECT_F-15I_Raam_Dome}")
+        members.members = [FlightMember(p, loadout) for p in roster.pilots]
+        return members
+
+    def iter_pilots(self) -> Iterator[Pilot | None]:
+        yield from (m.pilot for m in self.members)
+
+    def pilot_at(self, idx: int) -> Pilot | None:
+        return self.members[idx].pilot
+
+    @property
+    def max_size(self) -> int:
+        return len(self.members)
+
+    @property
+    def player_count(self) -> int:
+        return len([m for m in self.members if m.is_player])
+
+    @property
+    def missing_pilots(self) -> int:
+        return len([m for m in self.members if m.pilot is None])
+
+    def resize(self, new_size: int) -> None:
+        if self.max_size > new_size:
+            for member in self.members[new_size:]:
+                if (pilot := member.pilot) is not None:
+                    self.flight.squadron.return_pilot(pilot)
+                if (code := member.tgp_laser_code) is not None:
+                    code.release()
+            self.members = self.members[:new_size]
+            return
+        if self.max_size:
+            loadout = self.members[0].loadout.clone()
+        else:
+            loadout = Loadout.default_for(self.flight)
+        if self.flight.squadron.aircraft.variant_id == "F-15I Ra'am":
+            loadout.pylons[16] = Weapon.with_clsid("{IDF_MODS_PROJECT_F-15I_Raam_Dome}")
+        for _ in range(new_size - self.max_size):
+            member = FlightMember(self.flight.squadron.claim_available_pilot(), loadout)
+            member.use_custom_loadout = loadout.is_custom
+            self.members.append(member)
+
+    def set_pilot(self, index: int, pilot: Optional[Pilot]) -> None:
+        if pilot is not None:
+            self.flight.squadron.claim_pilot(pilot)
+        if (current_pilot := self.pilot_at(index)) is not None:
+            self.flight.squadron.return_pilot(current_pilot)
+        self.members[index].pilot = pilot
+
+    def clear(self) -> None:
+        self.flight.squadron.return_pilots(
+            [p for p in self.iter_pilots() if p is not None]
+        )
+        for member in self.members:
+            if (code := member.tgp_laser_code) is not None:
+                code.release()
+
+    def use_same_loadout_for_all_members(self) -> None:
+        if not self.members:
+            return
+        loadout = self.members[0].loadout
+        for member in self.members[1:]:
+            # Do not clone the loadout, we want any changes in the UI to be mirrored
+            # across all flight members.
+            member.loadout = loadout
+
+    def use_distinct_loadouts_for_each_member(self) -> None:
+        for member in self.members:
+            member.loadout = member.loadout.clone()

game/ato/flightplans/aewc.py

@@ -6,7 +6,7 @@ from typing import Type
 from game.ato.flightplans.ibuilder import IBuilder
 from game.ato.flightplans.patrolling import PatrollingFlightPlan, PatrollingLayout
 from game.ato.flightplans.waypointbuilder import WaypointBuilder
-from game.utils import Distance, Heading, Speed, feet, knots, meters, nautical_miles
+from game.utils import Distance, Heading, Speed, knots, meters, nautical_miles
 
 
 class AewcFlightPlan(PatrollingFlightPlan[PatrollingLayout]):
@@ -48,7 +48,9 @@ class Builder(IBuilder[AewcFlightPlan, PatrollingLayout]):
         orbit_heading = heading_to_threat_boundary
 
         # Station 80nm outside the threat zone.
-        threat_buffer = nautical_miles(80)
+        threat_buffer = nautical_miles(
+            self.coalition.game.settings.aewc_threat_buffer_min_distance
+        )
         if self.threat_zones.threatened(location.position):
             orbit_distance = distance_to_threat + threat_buffer
         else:
@@ -66,12 +68,9 @@ class Builder(IBuilder[AewcFlightPlan, PatrollingLayout]):
             orbit_heading.left.degrees, racetrack_half_distance
         )
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        builder = WaypointBuilder(self.flight)
 
-        if self.flight.unit_type.patrol_altitude is not None:
-            altitude = self.flight.unit_type.patrol_altitude
-        else:
-            altitude = feet(25000)
+        altitude = builder.get_patrol_altitude
 
         racetrack = builder.race_track(racetrack_start, racetrack_end, altitude)
 
@@ -88,7 +87,8 @@ class Builder(IBuilder[AewcFlightPlan, PatrollingLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> AewcFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AewcFlightPlan:
         return AewcFlightPlan(self.flight, self.layout())

game/ato/flightplans/airassault.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
 
+import random
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime
 from typing import Iterator, TYPE_CHECKING, Type
 
-from ._common_ctld import generate_random_ctld_point
-from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
 from game.theater.controlpoint import ControlPointType
 from game.theater.missiontarget import MissionTarget
 from game.utils import Distance, feet, meters
-from .ibuilder import IBuilder
+from ._common_ctld import generate_random_ctld_point
+from .formationattack import (
+    FormationAttackLayout,
+    FormationAttackBuilder,
+    FormationAttackFlightPlan,
+)
 from .planningerror import PlanningError
 from .uizonedisplay import UiZone, UiZoneDisplay
 from .waypointbuilder import WaypointBuilder
@@ -21,52 +25,64 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
-class AirAssaultLayout(StandardLayout):
+@dataclass
+class AirAssaultLayout(FormationAttackLayout):
     # The pickup point is optional because we don't always need to load the cargo. When
     # departing from a carrier, LHA, or off-map spawn, the cargo is pre-loaded.
-    pickup: FlightWaypoint | None
-    nav_to_ingress: list[FlightWaypoint]
-    ingress: FlightWaypoint
-    drop_off: FlightWaypoint | None
+    pickup: FlightWaypoint | None = None
+    drop_off: FlightWaypoint | None = None
     # This is an implementation detail used by CTLD. The aircraft will not go to this
     # waypoint. It is used by CTLD as the destination for unloaded troops.
-    target: FlightWaypoint
-    nav_to_home: list[FlightWaypoint]
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         if self.pickup is not None:
             yield self.pickup
-        yield from self.nav_to_ingress
+        yield from self.nav_to
+        yield self.join
         yield self.ingress
         if self.drop_off is not None:
             yield self.drop_off
-        yield self.target
-        yield from self.nav_to_home
+        yield self.targets[0]
+        yield from self.nav_from
         yield self.arrival
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
-class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout], UiZoneDisplay):
+class AirAssaultFlightPlan(FormationAttackFlightPlan, UiZoneDisplay):
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
 
+    @property
+    def is_airassault(self) -> bool:
+        return True
+
     @property
     def tot_waypoint(self) -> FlightWaypoint:
         if self.flight.is_helo and self.layout.drop_off is not None:
             return self.layout.drop_off
-        return self.layout.target
+        return self.layout.targets[0]
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
-        if waypoint == self.tot_waypoint:
+    @property
+    def ingress_time(self) -> datetime:
+        tot = self.tot
+        travel_time = self.travel_time_between_waypoints(
+            self.layout.ingress, self.tot_waypoint
+        )
+        return tot - travel_time
+
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
+        if waypoint is self.tot_waypoint:
             return self.tot
+        elif waypoint is self.layout.ingress:
+            return self.ingress_time
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         return None
 
     @property
@@ -74,17 +90,21 @@ class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout], UiZoneDisplay):
         return meters(2500)
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.package.time_over_target
 
     def ui_zone(self) -> UiZone:
         return UiZone(
-            [self.layout.target.position],
+            [self.layout.targets[0].position],
             self.ctld_target_zone_radius,
         )
 
 
-class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
+class Builder(FormationAttackBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
     def layout(self) -> AirAssaultLayout:
         if not self.flight.is_helo and not self.flight.is_hercules:
             raise PlanningError(
@@ -92,10 +112,10 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
             )
         assert self.package.waypoints is not None
 
-        altitude = feet(1500) if self.flight.is_helo else self.doctrine.ingress_altitude
-        altitude_is_agl = self.flight.is_helo
+        builder = WaypointBuilder(self.flight)
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        altitude = builder.get_cruise_altitude
+        altitude_is_agl = self.flight.is_helo
 
         if self.flight.is_hercules or self.flight.departure.cptype in [
             ControlPointType.AIRCRAFT_CARRIER_GROUP,
@@ -113,37 +133,46 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
                     self._generate_ctld_pickup(),
                 )
             )
+            pickup.alt = altitude
             pickup_position = pickup.position
+
+        ingress = builder.ingress(
+            FlightWaypointType.INGRESS_AIR_ASSAULT,
+            self.package.waypoints.ingress,
+            self.package.target,
+        )
+
         assault_area = builder.assault_area(self.package.target)
-        heading = self.package.target.position.heading_between_point(pickup_position)
         if self.flight.is_hercules:
             assault_area.only_for_player = False
             assault_area.alt = feet(1000)
 
-        # TODO: define CTLD dropoff zones in campaign miz?
-        drop_off_zone = MissionTarget(
-            "Dropoff zone",
-            self.package.target.position.point_from_heading(heading, 1200),
-        )
+        tgt = self.package.target
+        if isinstance(tgt, CTLD) and tgt.ctld_zones:
+            top3 = sorted(
+                tgt.ctld_zones, key=lambda x: ingress.position.distance_to_point(x[0])
+            )[:3]
+            pos, dist = random.choice(top3)
+            drop_pos = pos.random_point_within(dist)
+        else:
+            heading = tgt.position.heading_between_point(ingress.position)
+            drop_pos = tgt.position.point_from_heading(heading, 1200)
+        drop_off_zone = MissionTarget("Dropoff zone", drop_pos)
         dz = builder.dropoff_zone(drop_off_zone) if self.flight.is_helo else None
 
         return AirAssaultLayout(
             departure=builder.takeoff(self.flight.departure),
             pickup=pickup,
-            nav_to_ingress=builder.nav_path(
+            nav_to=builder.nav_path(
                 pickup_position,
                 self.package.waypoints.ingress,
                 altitude,
                 altitude_is_agl,
             ),
-            ingress=builder.ingress(
-                FlightWaypointType.INGRESS_AIR_ASSAULT,
-                self.package.waypoints.ingress,
-                self.package.target,
-            ),
+            ingress=ingress,
             drop_off=dz,
-            target=assault_area,
-            nav_to_home=builder.nav_path(
+            targets=[assault_area],
+            nav_from=builder.nav_path(
                 drop_off_zone.position,
                 self.flight.arrival.position,
                 altitude,
@@ -152,9 +181,14 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            hold=None,
+            join=builder.join(ingress.position),
+            split=builder.split(self.flight.arrival.position),
+            refuel=None,
+            custom_waypoints=list(),
         )
 
-    def build(self) -> AirAssaultFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AirAssaultFlightPlan:
         return AirAssaultFlightPlan(self.flight, self.layout())
 
     def _generate_ctld_pickup(self) -> Point:

game/ato/flightplans/airlift.py

@@ -1,17 +1,20 @@
 from __future__ import annotations
 
+import random
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime
+from typing import Optional
 from typing import TYPE_CHECKING, Type
 
-from ._common_ctld import generate_random_ctld_point
 from game.theater.missiontarget import MissionTarget
-from game.utils import feet
+from game.utils import Distance
+from ._common_ctld import generate_random_ctld_point
 from .ibuilder import IBuilder
 from .planningerror import PlanningError
 from .standard import StandardFlightPlan, StandardLayout
 from .waypointbuilder import WaypointBuilder
+from ..flightwaypointtype import FlightWaypointType
 from ...theater.interfaces.CTLD import CTLD
 
 if TYPE_CHECKING:
@@ -19,16 +22,19 @@ if TYPE_CHECKING:
     from dcs import Point
 
 
-@dataclass(frozen=True)
+@dataclass
 class AirliftLayout(StandardLayout):
-    nav_to_pickup: list[FlightWaypoint]
+    pickup_ascent: FlightWaypoint | None
+    pickup_descent: FlightWaypoint | None
     # There will not be a pickup waypoint when the pickup airfield is the departure
     # airfield for cargo planes, as the cargo is pre-loaded. Helicopters will still pick
     # up the cargo near the airfield.
     pickup: FlightWaypoint | None
     # pickup_zone will be used for player flights to create the CTLD stuff
     ctld_pickup_zone: FlightWaypoint | None
+    drop_off_ascent: FlightWaypoint | None
     nav_to_drop_off: list[FlightWaypoint]
+    drop_off_descent: FlightWaypoint | None
     # There will not be a drop-off waypoint when the drop-off airfield and the arrival
     # airfield is the same for a cargo plane, as planes will land to unload and we don't
     # want a double landing. Helicopters will still drop their cargo near the airfield
@@ -36,25 +42,57 @@ class AirliftLayout(StandardLayout):
     drop_off: FlightWaypoint | None
     # drop_off_zone will be used for player flights to create the CTLD stuff
     ctld_drop_off_zone: FlightWaypoint | None
-    nav_to_home: list[FlightWaypoint]
+    return_ascent: FlightWaypoint
+    return_descent: FlightWaypoint
+
+    def add_waypoint(
+        self, wpt: FlightWaypoint, next_wpt: Optional[FlightWaypoint]
+    ) -> bool:
+        new_wpt = self.get_midpoint(wpt, next_wpt)
+        if wpt.waypoint_type in [
+            FlightWaypointType.PICKUP_ZONE,
+            FlightWaypointType.CARGO_STOP,
+        ]:
+            self.nav_to_drop_off.insert(0, new_wpt)
+            return True
+        return super().add_waypoint(wpt, next_wpt)
+
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if waypoint in self.nav_to_drop_off:
+            self.nav_to_drop_off.remove(waypoint)
+            return True
+        elif super().delete_waypoint(waypoint):
+            return True
+        return False
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield from self.nav_to_pickup
+        if self.pickup_ascent is not None:
+            yield self.pickup_ascent
+        yield from self.nav_to
+        if self.pickup_descent is not None:
+            yield self.pickup_descent
         if self.pickup is not None:
             yield self.pickup
         if self.ctld_pickup_zone is not None:
             yield self.ctld_pickup_zone
+        if self.drop_off_ascent is not None:
+            yield self.drop_off_ascent
         yield from self.nav_to_drop_off
+        if self.drop_off_descent is not None:
+            yield self.drop_off_descent
         if self.drop_off is not None:
             yield self.drop_off
+        yield self.return_ascent
         if self.ctld_drop_off_zone is not None:
             yield self.ctld_drop_off_zone
-        yield from self.nav_to_home
+        yield from self.nav_from
+        yield self.return_descent
         yield self.arrival
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 class AirliftFlightPlan(StandardFlightPlan[AirliftLayout]):
@@ -70,16 +108,20 @@ class AirliftFlightPlan(StandardFlightPlan[AirliftLayout]):
         # drop-off waypoint.
         return self.layout.drop_off or self.layout.arrival
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         # TOT planning isn't really useful for transports. They're behind the front
         # lines so no need to wait for escorts or for other missions to complete.
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         return None
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.package.time_over_target
 
 
@@ -91,20 +133,52 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
                 "Cannot plan transport mission for flight with no cargo."
             )
 
-        altitude = feet(1500)
-        altitude_is_agl = True
+        builder = WaypointBuilder(self.flight)
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        altitude = builder.get_cruise_altitude
+        altitude_is_agl = self.flight.is_helo
 
+        pickup_ascent = None
+        pickup_descent = None
         pickup = None
+        drop_off_ascent = None
+        drop_off_descent = None
         drop_off = None
         pickup_zone = None
         drop_off_zone = None
 
         if cargo.origin != self.flight.departure:
             pickup = builder.cargo_stop(cargo.origin)
+            pickup_ascent = self._create_ascent_or_descent(
+                builder,
+                self.flight.departure.position,
+                cargo.origin.position,
+                altitude,
+                altitude_is_agl,
+            )
+            pickup_descent = self._create_ascent_or_descent(
+                builder,
+                cargo.origin.position,
+                self.flight.departure.position,
+                altitude,
+                altitude_is_agl,
+            )
         if cargo.next_stop != self.flight.arrival:
             drop_off = builder.cargo_stop(cargo.next_stop)
+            drop_off_ascent = self._create_ascent_or_descent(
+                builder,
+                cargo.origin.position,
+                cargo.next_stop.position,
+                altitude,
+                altitude_is_agl,
+            )
+            drop_off_descent = self._create_ascent_or_descent(
+                builder,
+                cargo.next_stop.position,
+                cargo.origin.position,
+                altitude,
+                altitude_is_agl,
+            )
 
         if self.flight.is_helo:
             # Create CTLD Zones for Helo flights
@@ -125,31 +199,57 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
             altitude_is_agl,
         )
 
+        return_ascent = self._create_ascent_or_descent(
+            builder,
+            cargo.next_stop.position
+            if cargo.next_stop != self.flight.arrival
+            else cargo.origin.position,
+            self.flight.arrival.position,
+            altitude,
+            altitude_is_agl,
+        )
+        return_descent = self._create_ascent_or_descent(
+            builder,
+            self.flight.arrival.position,
+            cargo.next_stop.position
+            if cargo.next_stop != self.flight.arrival
+            else cargo.origin.position,
+            altitude,
+            altitude_is_agl,
+        )
+
         return AirliftLayout(
             departure=builder.takeoff(self.flight.departure),
-            nav_to_pickup=nav_to_pickup,
+            pickup_ascent=pickup_ascent,
+            nav_to=nav_to_pickup,
+            pickup_descent=pickup_descent,
             pickup=pickup,
             ctld_pickup_zone=pickup_zone,
+            drop_off_ascent=drop_off_ascent,
             nav_to_drop_off=builder.nav_path(
                 cargo.origin.position,
                 cargo.next_stop.position,
                 altitude,
                 altitude_is_agl,
             ),
+            drop_off_descent=drop_off_descent,
             drop_off=drop_off,
             ctld_drop_off_zone=drop_off_zone,
-            nav_to_home=builder.nav_path(
+            return_ascent=return_ascent,
+            nav_from=builder.nav_path(
                 cargo.origin.position,
                 self.flight.arrival.position,
                 altitude,
                 altitude_is_agl,
             ),
+            return_descent=return_descent,
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> AirliftFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AirliftFlightPlan:
         return AirliftFlightPlan(self.flight, self.layout())
 
     def _generate_ctld_pickup(self) -> Point:
@@ -163,3 +263,18 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
         if cargo and cargo.transport and isinstance(cargo.transport.destination, CTLD):
             return generate_random_ctld_point(cargo.transport.destination)
         raise RuntimeError("Could not generate CTLD dropoff")
+
+    @staticmethod
+    def _create_ascent_or_descent(
+        builder: WaypointBuilder,
+        start: Point,
+        end: Point,
+        alt: Distance,
+        agl: bool,
+    ) -> FlightWaypoint:
+        distance = start.distance_to_point(end)
+        rdistance = 1000 if agl else min(distance / 10, 20000)
+        heading = round(start.heading_between_point(end))
+        rheading = random.randint(heading - 30, heading + 30) % 360
+        pos = start.point_from_heading(float(rheading), rdistance)
+        return builder.nav(pos, alt, agl)

game/ato/flightplans/antiship.py

@@ -35,11 +35,11 @@ class Builder(FormationAttackBuilder[AntiShipFlightPlan, FormationAttackLayout])
         else:
             raise InvalidObjectiveLocation(self.flight.flight_type, location)
 
-        return self._build(FlightWaypointType.INGRESS_BAI, targets)
+        return self._build(FlightWaypointType.INGRESS_ANTI_SHIP, targets)
 
     @staticmethod
     def anti_ship_targets_for_tgo(tgo: NavalGroundObject) -> list[StrikeTarget]:
         return [StrikeTarget(f"{g.group_name} at {tgo.name}", g) for g in tgo.groups]
 
-    def build(self) -> AntiShipFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AntiShipFlightPlan:
         return AntiShipFlightPlan(self.flight, self.layout())

game/ato/flightplans/bai.py

@@ -39,5 +39,5 @@ class Builder(FormationAttackBuilder[BaiFlightPlan, FormationAttackLayout]):
 
         return self._build(FlightWaypointType.INGRESS_BAI, targets)
 
-    def build(self) -> BaiFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> BaiFlightPlan:
         return BaiFlightPlan(self.flight, self.layout())

game/ato/flightplans/barcap.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-import random
 from datetime import timedelta
 from typing import Type
 
 from game.theater import FrontLine
-from game.utils import Distance, Speed, feet
+from game.utils import Distance, Speed
 from .capbuilder import CapBuilder
 from .invalidobjectivelocation import InvalidObjectiveLocation
 from .patrolling import PatrollingFlightPlan, PatrollingLayout
@@ -41,14 +40,9 @@ class Builder(CapBuilder[BarCapFlightPlan, PatrollingLayout]):
 
         start_pos, end_pos = self.cap_racetrack_for_objective(location, barcap=True)
 
-        preferred_alt = self.flight.unit_type.preferred_patrol_altitude
-        randomized_alt = preferred_alt + feet(random.randint(-2, 1) * 1000)
-        patrol_alt = max(
-            self.doctrine.min_patrol_altitude,
-            min(self.doctrine.max_patrol_altitude, randomized_alt),
-        )
+        builder = WaypointBuilder(self.flight)
+        patrol_alt = builder.get_patrol_altitude
 
-        builder = WaypointBuilder(self.flight, self.coalition)
         start, end = builder.race_track(start_pos, end_pos, patrol_alt)
 
         return PatrollingLayout(
@@ -64,7 +58,8 @@ class Builder(CapBuilder[BarCapFlightPlan, PatrollingLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> BarCapFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> BarCapFlightPlan:
         return BarCapFlightPlan(self.flight, self.layout())

game/ato/flightplans/capbuilder.py

@@ -60,7 +60,9 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             # distance from the nearest enemy airbase, but since they are by
             # definition in enemy territory they can't avoid the threat zone
             # without being useless.
-            min_distance_from_enemy = nautical_miles(20)
+            min_distance_from_enemy = nautical_miles(
+                self.coalition.game.settings.tarcap_threat_buffer_min_distance
+            )
             distance_to_airfield = meters(
                 closest_airfield.position.distance_to_point(
                     self.package.target.position

game/ato/flightplans/cas.py

@@ -6,33 +6,38 @@ from datetime import timedelta
 from typing import TYPE_CHECKING, Type
 
 from game.theater import FrontLine
-from game.utils import Distance, Speed, kph, meters
+from game.utils import Distance, Speed, kph, dcs_to_shapely_point
+from game.utils import nautical_miles
 from .ibuilder import IBuilder
 from .invalidobjectivelocation import InvalidObjectiveLocation
 from .patrolling import PatrollingFlightPlan, PatrollingLayout
 from .uizonedisplay import UiZone, UiZoneDisplay
 from .waypointbuilder import WaypointBuilder
 from ..flightwaypointtype import FlightWaypointType
+from ...flightplan.ipsolver import IpSolver
+from ...persistency import waypoint_debug_directory
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class CasLayout(PatrollingLayout):
-    target: FlightWaypoint
+    ingress: FlightWaypoint
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to
+        if self.ingress:
+            yield self.ingress
         yield self.patrol_start
-        yield self.target
         yield self.patrol_end
         yield from self.nav_from
         yield self.arrival
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
@@ -53,12 +58,13 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
 
     @property
     def engagement_distance(self) -> Distance:
-        max_length = self.flight.coalition.game.settings.max_frontline_length * 1000
-        return meters(max_length) / 2
+        return nautical_miles(
+            self.flight.coalition.game.settings.cas_engagement_range_distance
+        )
 
     @property
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
-        return {self.layout.patrol_start, self.layout.target, self.layout.patrol_end}
+        return {self.layout.ingress, self.layout.patrol_start, self.layout.patrol_end}
 
     def request_escort_at(self) -> FlightWaypoint | None:
         return self.layout.patrol_start
@@ -67,14 +73,17 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
         return self.layout.patrol_end
 
     def ui_zone(self) -> UiZone:
+        midpoint = (
+            self.layout.patrol_start.position + self.layout.patrol_end.position
+        ) / 2
         return UiZone(
-            [self.layout.target.position],
+            [midpoint],
             self.engagement_distance,
         )
 
 
 class Builder(IBuilder[CasFlightPlan, CasLayout]):
-    def layout(self) -> CasLayout:
+    def layout(self, dump_debug_info: bool) -> CasLayout:
         location = self.package.target
 
         if not isinstance(location, FrontLine):
@@ -84,49 +93,79 @@ class Builder(IBuilder[CasFlightPlan, CasLayout]):
             FrontLineConflictDescription,
         )
 
-        bounds = FrontLineConflictDescription.frontline_bounds(
-            location, self.theater, self.coalition.game.settings
-        )
-        ingress = bounds.left_position
-        center = bounds.center
-        egress = bounds.right_position
+        bounds = FrontLineConflictDescription.frontline_bounds(location, self.theater)
+        patrol_start = bounds.left_position
+        patrol_end = bounds.right_position
 
-        ingress_distance = ingress.distance_to_point(self.flight.departure.position)
-        egress_distance = egress.distance_to_point(self.flight.departure.position)
-        if egress_distance < ingress_distance:
-            ingress, egress = egress, ingress
+        start_distance = patrol_start.distance_to_point(self.flight.departure.position)
+        end_distance = patrol_end.distance_to_point(self.flight.departure.position)
+        if end_distance < start_distance:
+            patrol_start, patrol_end = patrol_end, patrol_start
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        builder = WaypointBuilder(self.flight)
 
         is_helo = self.flight.unit_type.dcs_unit_type.helicopter
-        ingress_egress_altitude = (
-            self.doctrine.ingress_altitude if not is_helo else meters(50)
+        ingress_egress_altitude = builder.get_combat_altitude
+        use_agl_patrol_altitude = is_helo
+
+        ip_solver = IpSolver(
+            dcs_to_shapely_point(self.flight.departure.position),
+            dcs_to_shapely_point(patrol_start),
+            self.doctrine,
+            self.threat_zones.all,
         )
-        use_agl_ingress_egress = is_helo
+        ip_solver.set_debug_properties(
+            waypoint_debug_directory() / "IP", self.theater.terrain
+        )
+        ingress_point_shapely = ip_solver.solve()
+        if dump_debug_info:
+            ip_solver.dump_debug_info()
+
+        ingress_point = patrol_start.new_in_same_map(
+            ingress_point_shapely.x, ingress_point_shapely.y
+        )
+
+        patrol_start_waypoint = builder.nav(
+            patrol_start, ingress_egress_altitude, use_agl_patrol_altitude
+        )
+        patrol_start_waypoint.name = "FLOT START"
+        patrol_start_waypoint.pretty_name = "FLOT start"
+        patrol_start_waypoint.description = "FLOT boundary"
+
+        patrol_end_waypoint = builder.nav(
+            patrol_end, ingress_egress_altitude, use_agl_patrol_altitude
+        )
+        patrol_end_waypoint.name = "FLOT END"
+        patrol_end_waypoint.pretty_name = "FLOT end"
+        patrol_end_waypoint.description = "FLOT boundary"
+
+        ingress = builder.ingress(
+            FlightWaypointType.INGRESS_CAS, ingress_point, location
+        )
+        ingress.description = f"Ingress to provide CAS at {location}"
 
         return CasLayout(
             departure=builder.takeoff(self.flight.departure),
             nav_to=builder.nav_path(
                 self.flight.departure.position,
-                ingress,
+                ingress_point,
                 ingress_egress_altitude,
-                use_agl_ingress_egress,
+                use_agl_patrol_altitude,
             ),
             nav_from=builder.nav_path(
-                egress,
+                patrol_end,
                 self.flight.arrival.position,
                 ingress_egress_altitude,
-                use_agl_ingress_egress,
+                use_agl_patrol_altitude,
             ),
-            patrol_start=builder.ingress(
-                FlightWaypointType.INGRESS_CAS, ingress, location
-            ),
-            target=builder.cas(center),
-            patrol_end=builder.egress(egress, location),
+            ingress=ingress,
+            patrol_start=patrol_start_waypoint,
+            patrol_end=patrol_end_waypoint,
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> CasFlightPlan:
-        return CasFlightPlan(self.flight, self.layout())
+    def build(self, dump_debug_info: bool = False) -> CasFlightPlan:
+        return CasFlightPlan(self.flight, self.layout(dump_debug_info))

game/ato/flightplans/custom.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime
 from typing import TYPE_CHECKING, Type
 
 from .flightplan import FlightPlan, Layout
@@ -15,10 +15,8 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class CustomLayout(Layout):
-    custom_waypoints: list[FlightWaypoint]
-
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.custom_waypoints
@@ -29,6 +27,10 @@ class CustomFlightPlan(FlightPlan[CustomLayout]):
     def builder_type() -> Type[Builder]:
         return Builder
 
+    @property
+    def is_custom(self) -> bool:
+        return True
+
     @property
     def tot_waypoint(self) -> FlightWaypoint:
         target_types = (
@@ -42,16 +44,20 @@ class CustomFlightPlan(FlightPlan[CustomLayout]):
                 return waypoint
         return self.layout.departure
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.tot_waypoint:
-            return self.package.time_over_target
+            return self.tot
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         return None
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.package.time_over_target
 
 
@@ -65,8 +71,8 @@ class Builder(IBuilder[CustomFlightPlan, CustomLayout]):
         self.waypoints = waypoints
 
     def layout(self) -> CustomLayout:
-        builder = WaypointBuilder(self.flight, self.coalition)
+        builder = WaypointBuilder(self.flight)
         return CustomLayout(builder.takeoff(self.flight.departure), self.waypoints)
 
-    def build(self) -> CustomFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> CustomFlightPlan:
         return CustomFlightPlan(self.flight, self.layout())

game/ato/flightplans/dead.py

@@ -37,5 +37,5 @@ class Builder(FormationAttackBuilder[DeadFlightPlan, FormationAttackLayout]):
 
         return self._build(FlightWaypointType.INGRESS_DEAD)
 
-    def build(self) -> DeadFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> DeadFlightPlan:
         return DeadFlightPlan(self.flight, self.layout())

game/ato/flightplans/escort.py

@@ -2,12 +2,15 @@ from __future__ import annotations
 
 from typing import Type
 
+from .airassault import AirAssaultLayout
+from .airlift import AirliftLayout
 from .formationattack import (
     FormationAttackBuilder,
     FormationAttackFlightPlan,
     FormationAttackLayout,
 )
 from .waypointbuilder import WaypointBuilder
+from .. import FlightType
 
 
 class EscortFlightPlan(FormationAttackFlightPlan):
@@ -20,41 +23,81 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
     def layout(self) -> FormationAttackLayout:
         assert self.package.waypoints is not None
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        builder = WaypointBuilder(self.flight)
         ingress, target = builder.escort(
             self.package.waypoints.ingress, self.package.target
         )
         ingress.only_for_player = True
         target.only_for_player = True
-        hold = builder.hold(self._hold_point())
-        join = builder.join(self.package.waypoints.join)
-        split = builder.split(self.package.waypoints.split)
-        refuel = builder.refuel(self.package.waypoints.refuel)
+        hold = None
+        if not self.flight.is_helo:
+            hold = builder.hold(self._hold_point())
+
+        join_pos = (
+            self.package.waypoints.ingress
+            if self.flight.is_helo
+            else self.package.waypoints.join
+        )
+        join = builder.join(join_pos)
+
+        split = builder.split(self._get_split())
+
+        is_helo = builder.flight.is_helo
         initial = builder.escort_hold(
-            self.package.waypoints.initial, self.doctrine.ingress_altitude
+            target.position if is_helo else self.package.waypoints.initial,
+        )
+
+        pf = self.package.primary_flight
+        if pf and pf.flight_type in [FlightType.AIR_ASSAULT, FlightType.TRANSPORT]:
+            layout = pf.flight_plan.layout
+            assert isinstance(layout, AirAssaultLayout) or isinstance(
+                layout, AirliftLayout
+            )
+            if isinstance(layout, AirliftLayout):
+                ascent = layout.pickup_ascent or layout.drop_off_ascent
+                assert ascent is not None
+                join = builder.join(ascent.position)
+                if layout.pickup and layout.drop_off_ascent:
+                    join = builder.join(layout.drop_off_ascent.position)
+            elif layout.pickup:
+                join = builder.join(layout.pickup.position)
+            split = builder.split(layout.arrival.position)
+            if layout.drop_off:
+                initial = builder.escort_hold(
+                    layout.drop_off.position,
+                )
+
+        refuel = self._build_refuel(builder)
+
+        departure = builder.takeoff(self.flight.departure)
+        nav_to = builder.nav_path(
+            hold.position if hold else departure.position,
+            join.position,
+            builder.get_cruise_altitude,
+        )
+
+        nav_from = builder.nav_path(
+            refuel.position if refuel else split.position,
+            self.flight.arrival.position,
+            builder.get_cruise_altitude,
         )
 
         return FormationAttackLayout(
-            departure=builder.takeoff(self.flight.departure),
+            departure=departure,
             hold=hold,
-            nav_to=builder.nav_path(
-                hold.position, join.position, self.doctrine.ingress_altitude
-            ),
+            nav_to=nav_to,
             join=join,
             ingress=ingress,
             initial=initial,
             targets=[target],
             split=split,
             refuel=refuel,
-            nav_from=builder.nav_path(
-                refuel.position,
-                self.flight.arrival.position,
-                self.doctrine.ingress_altitude,
-            ),
+            nav_from=nav_from,
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> EscortFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> EscortFlightPlan:
         return EscortFlightPlan(self.flight, self.layout())

game/ato/flightplans/ferry.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime
 from typing import TYPE_CHECKING, Type
 
 from game.utils import feet
@@ -15,17 +15,16 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class FerryLayout(StandardLayout):
-    nav_to_destination: list[FlightWaypoint]
-
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield from self.nav_to_destination
+        yield from self.nav_to
         yield self.arrival
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 class FerryFlightPlan(StandardFlightPlan[FerryLayout]):
@@ -37,16 +36,20 @@ class FerryFlightPlan(StandardFlightPlan[FerryLayout]):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.arrival
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         # TOT planning isn't really useful for ferries. They're behind the front
         # lines so no need to wait for escorts or for other missions to complete.
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         return None
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.package.time_over_target
 
 
@@ -58,17 +61,17 @@ class Builder(IBuilder[FerryFlightPlan, FerryLayout]):
                 f"{self.flight.departure}"
             )
 
-        altitude_is_agl = self.flight.unit_type.dcs_unit_type.helicopter
+        builder = WaypointBuilder(self.flight)
+        altitude_is_agl = self.flight.is_helo
         altitude = (
-            feet(1500)
+            feet(self.coalition.game.settings.heli_cruise_alt_agl)
             if altitude_is_agl
-            else self.flight.unit_type.preferred_patrol_altitude
+            else builder.get_patrol_altitude
         )
 
-        builder = WaypointBuilder(self.flight, self.coalition)
         return FerryLayout(
             departure=builder.takeoff(self.flight.departure),
-            nav_to_destination=builder.nav_path(
+            nav_to=builder.nav_path(
                 self.flight.departure.position,
                 self.flight.arrival.position,
                 altitude,
@@ -77,7 +80,9 @@ class Builder(IBuilder[FerryFlightPlan, FerryLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            nav_from=[],
+            custom_waypoints=list(),
         )
 
-    def build(self) -> FerryFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> FerryFlightPlan:
         return FerryFlightPlan(self.flight, self.layout())

game/ato/flightplans/flightplan.py

@@ -8,11 +8,10 @@ generating the waypoints for the mission.
 from __future__ import annotations
 
 import math
-from abc import ABC
+from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
-from functools import cached_property
+from datetime import datetime, timedelta
 from typing import Any, Generic, TYPE_CHECKING, TypeGuard, TypeVar
 
 from game.typeguard import self_type_guard
@@ -20,10 +19,9 @@ from game.utils import Distance, Speed, meters
 from .planningerror import PlanningError
 from ..flightwaypointtype import FlightWaypointType
 from ..starttype import StartType
-from ..traveltime import GroundSpeed, TravelTime
+from ..traveltime import GroundSpeed
 
 if TYPE_CHECKING:
-    from game.dcs.aircrafttype import FuelConsumption
     from game.theater import ControlPoint
     from ..flight import Flight
     from ..flightwaypoint import FlightWaypoint
@@ -32,24 +30,20 @@ if TYPE_CHECKING:
     from .loiter import LoiterFlightPlan
     from .patrolling import PatrollingFlightPlan
 
-INGRESS_TYPES = {
-    FlightWaypointType.INGRESS_CAS,
-    FlightWaypointType.INGRESS_ESCORT,
-    FlightWaypointType.INGRESS_SEAD,
-    FlightWaypointType.INGRESS_STRIKE,
-    FlightWaypointType.INGRESS_DEAD,
-}
 
-
-@dataclass(frozen=True)
+@dataclass
 class Layout(ABC):
     departure: FlightWaypoint
+    custom_waypoints: list[FlightWaypoint]
 
     @property
     def waypoints(self) -> list[FlightWaypoint]:
         """A list of all waypoints in the flight plan, in order."""
         return list(self.iter_waypoints())
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         """Iterates over all waypoints in the flight plan, in order."""
         raise NotImplementedError
@@ -62,6 +56,12 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def __init__(self, flight: Flight, layout: LayoutT) -> None:
         self.flight = flight
         self.layout = layout
+        self.tot_offset = self.default_tot_offset()
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        if "tot_offset" not in state:
+            state["tot_offset"] = self.default_tot_offset()
+        self.__dict__.update(state)
 
     @property
     def package(self) -> Package:
@@ -72,15 +72,6 @@ class FlightPlan(ABC, Generic[LayoutT]):
         """A list of all waypoints in the flight plan, in order."""
         return list(self.iter_waypoints())
 
-    def get_index_of_wpt_by_type(self, wpt_type: FlightWaypointType) -> int:
-        index = 0
-        for wpt in self.waypoints:
-            if wpt and not wpt.only_for_player:
-                index += 1
-                if wpt.waypoint_type == wpt_type:
-                    return index
-        return -1
-
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         """Iterates over all waypoints in the flight plan, in order."""
         yield from self.layout.iter_waypoints()
@@ -114,6 +105,19 @@ class FlightPlan(ABC, Generic[LayoutT]):
             #
             # Plus, it's a loiter point so there's no reason to hurry.
             factor = 0.75
+        elif (
+            self.flight.is_helo
+            and (
+                a.waypoint_type == FlightWaypointType.JOIN
+                or "INGRESS" in a.waypoint_type.name
+                or a.waypoint_type == FlightWaypointType.CUSTOM
+            )
+            and self.package.primary_flight
+            and not self.package.primary_flight.flight_plan.is_airassault
+        ):
+            # Helicopter flights should be slowed down between JOIN & INGRESS
+            # to allow the escort to keep up while engaging targets along the way.
+            factor = 0.50
         # TODO: Adjust if AGL.
         # We don't have an exact heightmap, but we should probably be performing
         # *some* adjustment for NTTR since the minimum altitude of the map is
@@ -158,42 +162,9 @@ class FlightPlan(ABC, Generic[LayoutT]):
         raise NotImplementedError
 
     @property
-    def tot(self) -> timedelta:
+    def tot(self) -> datetime:
         return self.package.time_over_target + self.tot_offset
 
-    @cached_property
-    def bingo_fuel(self) -> int:
-        """Bingo fuel value for the FlightPlan"""
-        if (fuel := self.flight.unit_type.fuel_consumption) is not None:
-            return self._bingo_estimate(fuel)
-        return self._legacy_bingo_estimate()
-
-    def _bingo_estimate(self, fuel: FuelConsumption) -> int:
-        distance_to_arrival = self.max_distance_from(self.flight.arrival)
-        fuel_consumed = fuel.cruise * distance_to_arrival.nautical_miles
-        bingo = fuel_consumed + fuel.min_safe
-        return math.ceil(bingo / 100) * 100
-
-    def _legacy_bingo_estimate(self) -> int:
-        distance_to_arrival = self.max_distance_from(self.flight.arrival)
-
-        bingo = 1000.0  # Minimum Emergency Fuel
-        bingo += 500  # Visual Traffic
-        bingo += 15 * distance_to_arrival.nautical_miles
-
-        # TODO: Per aircraft tweaks.
-
-        if self.flight.divert is not None:
-            max_divert_distance = self.max_distance_from(self.flight.divert)
-            bingo += 10 * max_divert_distance.nautical_miles
-
-        return round(bingo / 100) * 100
-
-    @cached_property
-    def joker_fuel(self) -> int:
-        """Joker fuel value for the FlightPlan"""
-        return self.bingo_fuel + 1000
-
     def max_distance_from(self, cp: ControlPoint) -> Distance:
         """Returns the farthest waypoint of the flight plan from a ControlPoint.
         :arg cp The ControlPoint to measure distance from.
@@ -204,8 +175,7 @@ class FlightPlan(ABC, Generic[LayoutT]):
             [meters(cp.position.distance_to_point(w.position)) for w in self.waypoints]
         )
 
-    @property
-    def tot_offset(self) -> timedelta:
+    def default_tot_offset(self) -> timedelta:
         """This flight's offset from the package's TOT.
 
         Positive values represent later TOTs. An offset of -2 minutes is used
@@ -223,20 +193,37 @@ class FlightPlan(ABC, Generic[LayoutT]):
             )
 
         for previous_waypoint, waypoint in self.edges(until=destination):
-            total += self.travel_time_between_waypoints(previous_waypoint, waypoint)
-        return total
+            total += self.total_time_between_waypoints(previous_waypoint, waypoint)
+
+        # Trim microseconds. Our simulation tick rate is 1 second, so anything that
+        # takes 100.1 or 100.9 seconds will take 100 seconds. DCS doesn't handle
+        # sub-second resolution for tasks anyway, nor are they interesting from a
+        # mission planning perspective, so there's little value to keeping them in the
+        # model.
+        return timedelta(seconds=math.floor(total.total_seconds()))
+
+    def total_time_between_waypoints(
+        self, a: FlightWaypoint, b: FlightWaypoint
+    ) -> timedelta:
+        """Returns the total time spent between a and b.
+
+        The total time between waypoints differs from the travel time in that it may
+        include additional time for actions such as loitering.
+        """
+        return self.travel_time_between_waypoints(a, b)
 
     def travel_time_between_waypoints(
         self, a: FlightWaypoint, b: FlightWaypoint
     ) -> timedelta:
-        return TravelTime.between_points(
-            a.position, b.position, self.speed_between_waypoints(a, b)
-        )
+        error_factor = 1.05
+        speed = self.speed_between_waypoints(a, b)
+        distance = meters(a.position.distance_to_point(b.position))
+        return timedelta(hours=distance.nautical_miles / speed.knots * error_factor)
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         raise NotImplementedError
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         raise NotImplementedError
 
     def request_escort_at(self) -> FlightWaypoint | None:
@@ -259,34 +246,24 @@ class FlightPlan(ABC, Generic[LayoutT]):
             if waypoint == end:
                 return
 
-    def takeoff_time(self) -> timedelta:
+    def takeoff_time(self) -> datetime:
         return self.tot - self._travel_time_to_waypoint(self.tot_waypoint)
 
-    def startup_time(self) -> timedelta:
-        start_time = (
-            self.takeoff_time() - self.estimate_startup() - self.estimate_ground_ops()
+    def minimum_duration_from_start_to_tot(self) -> timedelta:
+        return (
+            self._travel_time_to_waypoint(self.tot_waypoint)
+            + self.estimate_startup()
+            + self.estimate_ground_ops()
+            + self.estimate_takeoff_time()
         )
 
-        # In case FP math has given us some barely below zero time, round to
-        # zero.
-        if math.isclose(start_time.total_seconds(), 0):
-            start_time = timedelta()
-
-        # Trim microseconds. DCS doesn't handle sub-second resolution for tasks,
-        # and they're not interesting from a mission planning perspective so we
-        # don't want them in the UI.
-        #
-        # Round down so *barely* above zero start times are just zero.
-        start_time = timedelta(seconds=math.floor(start_time.total_seconds()))
-
-        # Feature request #1309: Carrier planes should start at +1s
-        # This is a workaround to a DCS problem: some AI planes spawn on
-        # the 'sixpack' when start_time is zero and cause a deadlock.
-        # Workaround: force the start_time to 1 second for these planes.
-        if self.flight.from_cp.is_fleet and start_time.total_seconds() == 0:
-            start_time = timedelta(seconds=1)
-
-        return start_time
+    def startup_time(self) -> datetime:
+        return (
+            self.takeoff_time()
+            - self.estimate_startup()
+            - self.estimate_ground_ops()
+            - self.estimate_takeoff_time()
+        )
 
     def estimate_startup(self) -> timedelta:
         if self.flight.start_type is StartType.COLD:
@@ -300,13 +277,32 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def estimate_ground_ops(self) -> timedelta:
         if self.flight.start_type in {StartType.RUNWAY, StartType.IN_FLIGHT}:
             return timedelta()
-        if self.flight.from_cp.is_fleet:
+        if self.flight.departure.is_fleet or self.flight.departure.is_fob:
             return timedelta(minutes=2)
         else:
             return timedelta(minutes=8)
 
+    def estimate_takeoff_time(self) -> timedelta:
+        if self.flight.departure.is_offmap:
+            return timedelta()
+        return timedelta(seconds=30)
+
     @property
-    def mission_departure_time(self) -> timedelta:
+    def is_airassault(self) -> bool:
+        return False
+
+    @property
+    @abstractmethod
+    def mission_begin_on_station_time(self) -> datetime | None:
+        """The time that the mission is first on-station."""
+        ...
+
+    @property
+    def is_custom(self) -> bool:
+        return False
+
+    @property
+    def mission_departure_time(self) -> datetime:
         """The time that the mission is complete and the flight RTBs."""
         raise NotImplementedError
 

game/ato/flightplans/flightplanbuildertypes.py

@@ -19,6 +19,7 @@ from .ocarunway import OcaRunwayFlightPlan
 from .packagerefueling import PackageRefuelingFlightPlan
 from .planningerror import PlanningError
 from .sead import SeadFlightPlan
+from .seadsweep import SeadSweepFlightPlan
 from .strike import StrikeFlightPlan
 from .sweep import SweepFlightPlan
 from .tarcap import TarCapFlightPlan
@@ -51,6 +52,7 @@ class FlightPlanBuilderTypes:
             FlightType.OCA_RUNWAY: OcaRunwayFlightPlan.builder_type(),
             FlightType.SEAD: SeadFlightPlan.builder_type(),
             FlightType.SEAD_ESCORT: EscortFlightPlan.builder_type(),
+            FlightType.SEAD_SWEEP: SeadSweepFlightPlan.builder_type(),
             FlightType.STRIKE: StrikeFlightPlan.builder_type(),
             FlightType.SWEEP: SweepFlightPlan.builder_type(),
             FlightType.TARCAP: TarCapFlightPlan.builder_type(),

game/ato/flightplans/formation.py

@@ -2,27 +2,32 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from functools import cached_property
-from typing import Any, TYPE_CHECKING, TypeGuard
+from typing import Any, TYPE_CHECKING, TypeGuard, Optional
 
 from game.typeguard import self_type_guard
 from game.utils import Speed
 from .flightplan import FlightPlan
 from .loiter import LoiterFlightPlan, LoiterLayout
-from ..traveltime import GroundSpeed, TravelTime
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class FormationLayout(LoiterLayout, ABC):
-    nav_to: list[FlightWaypoint]
     join: FlightWaypoint
     split: FlightWaypoint
-    refuel: FlightWaypoint
-    nav_from: list[FlightWaypoint]
+    refuel: Optional[FlightWaypoint]
+
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if waypoint == self.refuel:
+            self.refuel = None
+            return True
+        elif super().delete_waypoint(waypoint):
+            return True
+        return False
 
 
 class FormationFlightPlan(LoiterFlightPlan, ABC):
@@ -59,10 +64,7 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
         return min(speeds)
 
     def speed_between_waypoints(self, a: FlightWaypoint, b: FlightWaypoint) -> Speed:
-        if b in self.package_speed_waypoints:
-            # Should be impossible, as any package with at least one
-            # FormationFlightPlan flight needs a formation speed.
-            assert self.package.formation_speed is not None
+        if self.package.formation_speed and b in self.package_speed_waypoints:
             return self.package.formation_speed
         return super().speed_between_waypoints(a, b)
 
@@ -73,15 +75,15 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
 
     @property
     @abstractmethod
-    def join_time(self) -> timedelta:
+    def join_time(self) -> datetime:
         ...
 
     @property
     @abstractmethod
-    def split_time(self) -> timedelta:
+    def split_time(self) -> datetime:
         ...
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.join:
             return self.join_time
         elif waypoint == self.layout.split:
@@ -89,15 +91,23 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
         return None
 
     @property
-    def push_time(self) -> timedelta:
-        return self.join_time - TravelTime.between_points(
-            self.layout.hold.position,
-            self.layout.join.position,
-            GroundSpeed.for_flight(self.flight, self.layout.hold.alt),
+    def push_time(self) -> datetime:
+        hold2join_time = (
+            self.travel_time_between_waypoints(
+                self.layout.hold,
+                self.layout.join,
+            )
+            if self.layout.hold
+            else timedelta(0)
         )
+        return self.join_time - hold2join_time
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.split_time
 
     @self_type_guard

game/ato/flightplans/formationattack.py

@@ -3,14 +3,15 @@ from __future__ import annotations
 from abc import ABC
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
-from typing import TYPE_CHECKING, TypeVar, Optional
+from datetime import datetime, timedelta
+from typing import Optional
+from typing import TYPE_CHECKING, TypeVar
 
 from dcs import Point
 
 from game.flightplan import HoldZoneGeometry
 from game.theater import MissionTarget
-from game.utils import Speed, meters, Distance
+from game.utils import Speed, meters, nautical_miles
 from .flightplan import FlightPlan
 from .formation import FormationFlightPlan, FormationLayout
 from .ibuilder import IBuilder
@@ -25,10 +26,6 @@ if TYPE_CHECKING:
 
 
 class FormationAttackFlightPlan(FormationFlightPlan, ABC):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta()
-
     @property
     def package_speed_waypoints(self) -> set[FlightWaypoint]:
         return {
@@ -50,13 +47,6 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.targets[0]
 
-    @property
-    def tot_offset(self) -> timedelta:
-        try:
-            return -self.lead_time
-        except AttributeError:
-            return timedelta()
-
     @property
     def target_area_waypoint(self) -> FlightWaypoint:
         return FlightWaypoint(
@@ -91,18 +81,18 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
         return total
 
     @property
-    def join_time(self) -> timedelta:
-        travel_time = self.travel_time_between_waypoints(
+    def join_time(self) -> datetime:
+        travel_time = self.total_time_between_waypoints(
             self.layout.join, self.layout.ingress
         )
         return self.ingress_time - travel_time
 
     @property
-    def split_time(self) -> timedelta:
-        travel_time_ingress = self.travel_time_between_waypoints(
+    def split_time(self) -> datetime:
+        travel_time_ingress = self.total_time_between_waypoints(
             self.layout.ingress, self.target_area_waypoint
         )
-        travel_time_egress = self.travel_time_between_waypoints(
+        travel_time_egress = self.total_time_between_waypoints(
             self.target_area_waypoint, self.layout.split
         )
         minutes_at_target = 0.75 * len(self.layout.targets)
@@ -115,32 +105,46 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
         )
 
     @property
-    def ingress_time(self) -> timedelta:
+    def ingress_time(self) -> datetime:
         tot = self.tot
-        travel_time = self.travel_time_between_waypoints(
+        travel_time = self.total_time_between_waypoints(
             self.layout.ingress, self.target_area_waypoint
         )
         return tot - travel_time
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    @property
+    def initial_time(self) -> datetime:
+        tot = self.tot
+        travel_time = self.travel_time_between_waypoints(
+            self.layout.initial, self.target_area_waypoint
+        )
+        return tot - travel_time
+
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.ingress:
             return self.ingress_time
+        elif waypoint == self.layout.initial:
+            return self.initial_time
         elif waypoint in self.layout.targets:
             return self.tot
         return super().tot_for_waypoint(waypoint)
 
 
-@dataclass(frozen=True)
+@dataclass
 class FormationAttackLayout(FormationLayout):
     ingress: FlightWaypoint
     targets: list[FlightWaypoint]
     initial: Optional[FlightWaypoint] = None
+    lineup: Optional[FlightWaypoint] = None
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield self.hold
+        if self.hold:
+            yield self.hold
         yield from self.nav_to
         yield self.join
+        if self.lineup:
+            yield self.lineup
         yield self.ingress
         if self.initial is not None:
             yield self.initial
@@ -153,6 +157,7 @@ class FormationAttackLayout(FormationLayout):
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 FlightPlanT = TypeVar("FlightPlanT", bound=FlightPlan[FormationAttackLayout])
@@ -166,7 +171,7 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
         targets: list[StrikeTarget] | None = None,
     ) -> FormationAttackLayout:
         assert self.package.waypoints is not None
-        builder = WaypointBuilder(self.flight, self.coalition, targets)
+        builder = WaypointBuilder(self.flight, targets)
 
         target_waypoints: list[FlightWaypoint] = []
         if targets is not None:
@@ -181,36 +186,83 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
                 )
             )
 
-        hold = builder.hold(self._hold_point())
-        join = builder.join(self.package.waypoints.join)
-        split = builder.split(self.package.waypoints.split)
-        refuel = builder.refuel(self.package.waypoints.refuel)
+        hold = None
+        if not self.flight.is_helo:
+            hold = builder.hold(self._hold_point())
+        join_pos = self.package.waypoints.join
+        if self.flight.is_helo:
+            join_pos = self.package.waypoints.ingress
+        join = builder.join(join_pos)
+        split = builder.split(self._get_split())
+        refuel = self._build_refuel(builder)
 
         ingress = builder.ingress(
             ingress_type, self.package.waypoints.ingress, self.package.target
         )
 
+        initial = None
+        if ingress_type == FlightWaypointType.INGRESS_SEAD:
+            initial = builder.sead_search(self.package.target)
+        elif ingress_type == FlightWaypointType.INGRESS_SEAD_SWEEP:
+            initial = builder.sead_sweep(self.package.target)
+
+        lineup = None
+        if self.flight.flight_type == FlightType.STRIKE:
+            hdg = self.package.target.position.heading_between_point(ingress.position)
+            pos = ingress.position.point_from_heading(hdg, nautical_miles(10).meters)
+            lineup = builder.nav(pos, builder.get_combat_altitude)
+
+        is_helo = self.flight.is_helo
+        ingress_egress_altitude = builder.get_combat_altitude
+        use_agl_ingress_egress = is_helo
+
         return FormationAttackLayout(
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
             nav_to=builder.nav_path(
-                hold.position, join.position, self.doctrine.ingress_altitude
+                hold.position if hold else self.flight.departure.position,
+                join.position if join else ingress.position,
+                ingress_egress_altitude,
+                use_agl_ingress_egress,
             ),
             join=join,
+            lineup=lineup,
             ingress=ingress,
+            initial=initial,
             targets=target_waypoints,
             split=split,
             refuel=refuel,
             nav_from=builder.nav_path(
-                refuel.position,
+                refuel.position if refuel else split.position,
                 self.flight.arrival.position,
-                self.doctrine.ingress_altitude,
+                ingress_egress_altitude,
+                use_agl_ingress_egress,
             ),
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
+    def _build_refuel(self, builder: WaypointBuilder) -> Optional[FlightWaypoint]:
+        refuel: Optional[FlightWaypoint] = None
+        can_plan = self.flight.coalition.air_wing.can_auto_plan(FlightType.REFUELING)
+        if not self.flight.is_helo and can_plan and self.package.waypoints:
+            refuel = builder.refuel(self.package.waypoints.refuel)
+        return refuel
+
+    @property
+    def primary_flight_is_air_assault(self) -> bool:
+        if self.flight is self.package.primary_flight:
+            # Can't call self.package.primary_flight.flight_plan here
+            # because the flight-plan wasn't created yet.
+            # Calling the fligh_plan property would result in infinite recursion
+            return self.flight.flight_type == FlightType.AIR_ASSAULT
+        else:
+            assert self.package.primary_flight is not None
+            fp = self.package.primary_flight.flight_plan
+            return fp.is_airassault
+
     @staticmethod
     def target_waypoint(
         flight: Flight, builder: WaypointBuilder, target: StrikeTarget
@@ -219,7 +271,7 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             return builder.bai_group(target)
         elif flight.flight_type == FlightType.DEAD:
             return builder.dead_point(target)
-        elif flight.flight_type == FlightType.SEAD:
+        elif flight.flight_type in {FlightType.SEAD, FlightType.SEAD_SWEEP}:
             return builder.sead_point(target)
         else:
             return builder.strike_point(target)
@@ -246,3 +298,13 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
         return HoldZoneGeometry(
             target, origin, ip, join, self.coalition, self.theater
         ).find_best_hold_point()
+
+    def _get_split(self) -> Point:
+        assert self.package.waypoints is not None
+        assert self.package.primary_flight is not None
+        split_pos = (
+            self.package.primary_flight.arrival.position
+            if self.package.primary_flight.is_helo
+            else self.package.waypoints.split
+        )
+        return split_pos

game/ato/flightplans/ibuilder.py

@@ -25,6 +25,7 @@ class IBuilder(ABC, Generic[FlightPlanT, LayoutT]):
     def __init__(self, flight: Flight) -> None:
         self.flight = flight
         self._flight_plan: FlightPlanT | None = None
+        self.settings = self.flight.coalition.game.settings
 
     def get_or_build(self) -> FlightPlanT:
         if self._flight_plan is None:
@@ -32,10 +33,10 @@ class IBuilder(ABC, Generic[FlightPlanT, LayoutT]):
             assert self._flight_plan is not None
         return self._flight_plan
 
-    def regenerate(self) -> None:
+    def regenerate(self, dump_debug_info: bool = False) -> None:
         try:
-            self._generate_package_waypoints_if_needed()
-            self._flight_plan = self.build()
+            self._generate_package_waypoints_if_needed(dump_debug_info)
+            self._flight_plan = self.build(dump_debug_info)
         except NavMeshError as ex:
             color = "blue" if self.flight.squadron.player else "red"
             raise PlanningError(
@@ -43,10 +44,15 @@ class IBuilder(ABC, Generic[FlightPlanT, LayoutT]):
                 f"{self.flight.departure} to {self.package.target}"
             ) from ex
 
-    def _generate_package_waypoints_if_needed(self) -> None:
-        if self.package.waypoints is None:
+    def _generate_package_waypoints_if_needed(self, dump_debug_info: bool) -> None:
+        # Package waypoints are only valid for offensive missions. Skip this if the
+        # target is friendly.
+        if self.package.target.is_friendly(self.is_player):
+            return
+
+        if self.package.waypoints is None or dump_debug_info:
             self.package.waypoints = PackageWaypoints.create(
-                self.package, self.coalition
+                self.package, self.coalition, dump_debug_info
             )
 
     @property
@@ -54,11 +60,7 @@ class IBuilder(ABC, Generic[FlightPlanT, LayoutT]):
         return self.flight.departure.theater
 
     @abstractmethod
-    def layout(self) -> LayoutT:
-        ...
-
-    @abstractmethod
-    def build(self) -> FlightPlanT:
+    def build(self, dump_debug_info: bool = False) -> FlightPlanT:
         ...
 
     @property

game/ato/flightplans/loiter.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Any, TYPE_CHECKING, TypeGuard
+from typing import Optional
 
 from game.typeguard import self_type_guard
 from .flightplan import FlightPlan
@@ -13,9 +14,9 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class LoiterLayout(StandardLayout, ABC):
-    hold: FlightWaypoint
+    hold: Optional[FlightWaypoint]
 
 
 class LoiterFlightPlan(StandardFlightPlan[Any], ABC):
@@ -25,18 +26,18 @@ class LoiterFlightPlan(StandardFlightPlan[Any], ABC):
 
     @property
     @abstractmethod
-    def push_time(self) -> timedelta:
+    def push_time(self) -> datetime:
         ...
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.hold:
             return self.push_time
         return None
 
-    def travel_time_between_waypoints(
+    def total_time_between_waypoints(
         self, a: FlightWaypoint, b: FlightWaypoint
     ) -> timedelta:
-        travel_time = super().travel_time_between_waypoints(a, b)
+        travel_time = super().total_time_between_waypoints(a, b)
         if a != self.layout.hold:
             return travel_time
         return travel_time + self.hold_duration

game/ato/flightplans/ocaaircraft.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Type
 
-from game.theater import Airfield
+from game.theater import Airfield, Fob
 from .formationattack import (
     FormationAttackBuilder,
     FormationAttackFlightPlan,
@@ -23,7 +23,7 @@ class Builder(FormationAttackBuilder[OcaAircraftFlightPlan, FormationAttackLayou
     def layout(self) -> FormationAttackLayout:
         location = self.package.target
 
-        if not isinstance(location, Airfield):
+        if not isinstance(location, Airfield) and not isinstance(location, Fob):
             logging.exception(
                 f"Invalid Objective Location for OCA/Aircraft flight "
                 f"{self.flight=} at {location=}."
@@ -32,5 +32,5 @@ class Builder(FormationAttackBuilder[OcaAircraftFlightPlan, FormationAttackLayou
 
         return self._build(FlightWaypointType.INGRESS_OCA_AIRCRAFT)
 
-    def build(self) -> OcaAircraftFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> OcaAircraftFlightPlan:
         return OcaAircraftFlightPlan(self.flight, self.layout())

game/ato/flightplans/ocarunway.py

@@ -32,5 +32,5 @@ class Builder(FormationAttackBuilder[OcaRunwayFlightPlan, FormationAttackLayout]
 
         return self._build(FlightWaypointType.INGRESS_OCA_RUNWAY)
 
-    def build(self) -> OcaRunwayFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> OcaRunwayFlightPlan:
         return OcaRunwayFlightPlan(self.flight, self.layout())

game/ato/flightplans/packagerefueling.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Type
 
 from dcs import Point
 
-from game.utils import Distance, Heading, feet, meters
+from game.utils import Distance, Heading, meters
 from .ibuilder import IBuilder
 from .patrolling import PatrollingLayout
 from .refuelingflightplan import RefuelingFlightPlan
@@ -39,7 +39,7 @@ class PackageRefuelingFlightPlan(RefuelingFlightPlan):
         )
 
     @property
-    def patrol_start_time(self) -> timedelta:
+    def patrol_start_time(self) -> datetime:
         altitude = self.flight.unit_type.patrol_altitude
 
         if altitude is None:
@@ -59,10 +59,10 @@ class PackageRefuelingFlightPlan(RefuelingFlightPlan):
             "REFUEL", FlightWaypointType.REFUEL, refuel, altitude
         )
 
-        delay_target_to_split: timedelta = self.travel_time_between_waypoints(
+        delay_target_to_split: timedelta = self.total_time_between_waypoints(
             self.target_area_waypoint(), split_waypoint
         )
-        delay_split_to_refuel: timedelta = self.travel_time_between_waypoints(
+        delay_split_to_refuel: timedelta = self.total_time_between_waypoints(
             split_waypoint, refuel_waypoint
         )
 
@@ -96,13 +96,9 @@ class Builder(IBuilder[PackageRefuelingFlightPlan, PatrollingLayout]):
             home_heading.degrees, racetrack_half_distance
         )
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        builder = WaypointBuilder(self.flight)
 
-        tanker_type = self.flight.unit_type
-        if tanker_type.patrol_altitude is not None:
-            altitude = tanker_type.patrol_altitude
-        else:
-            altitude = feet(21000)
+        altitude = builder.get_patrol_altitude
 
         racetrack = builder.race_track(racetrack_start, racetrack_end, altitude)
 
@@ -119,7 +115,8 @@ class Builder(IBuilder[PackageRefuelingFlightPlan, PatrollingLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> PackageRefuelingFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> PackageRefuelingFlightPlan:
         return PackageRefuelingFlightPlan(self.flight, self.layout())

game/ato/flightplans/patrolling.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Any, TYPE_CHECKING, TypeGuard, TypeVar
 
 from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
@@ -16,12 +16,10 @@ if TYPE_CHECKING:
     from .flightplan import FlightPlan
 
 
-@dataclass(frozen=True)
+@dataclass
 class PatrollingLayout(StandardLayout):
-    nav_to: list[FlightWaypoint]
     patrol_start: FlightWaypoint
     patrol_end: FlightWaypoint
-    nav_from: list[FlightWaypoint]
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
@@ -33,6 +31,7 @@ class PatrollingLayout(StandardLayout):
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 LayoutT = TypeVar("LayoutT", bound=PatrollingLayout)
@@ -61,22 +60,22 @@ class PatrollingFlightPlan(StandardFlightPlan[LayoutT], UiZoneDisplay, ABC):
         """
 
     @property
-    def patrol_start_time(self) -> timedelta:
-        return self.package.time_over_target
+    def patrol_start_time(self) -> datetime:
+        return self.tot
 
     @property
-    def patrol_end_time(self) -> timedelta:
+    def patrol_end_time(self) -> datetime:
         # TODO: This is currently wrong for CAS.
         # CAS missions end when they're winchester or bingo. We need to
         # configure push tasks for the escorts rather than relying on timing.
         return self.patrol_start_time + self.patrol_duration
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.patrol_start:
             return self.patrol_start_time
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.patrol_end:
             return self.patrol_end_time
         return None
@@ -90,7 +89,11 @@ class PatrollingFlightPlan(StandardFlightPlan[LayoutT], UiZoneDisplay, ABC):
         return self.layout.patrol_start
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return self.patrol_start_time
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.patrol_end_time
 
     @self_type_guard

game/ato/flightplans/rtb.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime
 from typing import TYPE_CHECKING, Type
 
 from game.utils import feet
@@ -15,19 +15,19 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class RtbLayout(StandardLayout):
     abort_location: FlightWaypoint
-    nav_to_destination: list[FlightWaypoint]
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield self.abort_location
-        yield from self.nav_to_destination
+        yield from self.nav_to
         yield self.arrival
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 class RtbFlightPlan(StandardFlightPlan[RtbLayout]):
@@ -43,15 +43,19 @@ class RtbFlightPlan(StandardFlightPlan[RtbLayout]):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.abort_location
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         return None
 
     @property
-    def mission_departure_time(self) -> timedelta:
-        return timedelta()
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
+        return self.tot
 
 
 class Builder(IBuilder[RtbFlightPlan, RtbLayout]):
@@ -62,13 +66,13 @@ class Builder(IBuilder[RtbFlightPlan, RtbLayout]):
         current_position = self.flight.state.estimate_position()
         current_altitude, altitude_reference = self.flight.state.estimate_altitude()
 
-        altitude_is_agl = self.flight.unit_type.dcs_unit_type.helicopter
+        builder = WaypointBuilder(self.flight)
+        altitude_is_agl = self.flight.is_helo
         altitude = (
-            feet(1500)
+            feet(self.coalition.game.settings.heli_cruise_alt_agl)
             if altitude_is_agl
-            else self.flight.unit_type.preferred_patrol_altitude
+            else builder.get_patrol_altitude
         )
-        builder = WaypointBuilder(self.flight, self.flight.coalition)
         abort_point = builder.nav(
             current_position, current_altitude, altitude_reference == "RADIO"
         )
@@ -78,7 +82,7 @@ class Builder(IBuilder[RtbFlightPlan, RtbLayout]):
         return RtbLayout(
             departure=builder.takeoff(self.flight.departure),
             abort_location=abort_point,
-            nav_to_destination=builder.nav_path(
+            nav_to=builder.nav_path(
                 current_position,
                 self.flight.arrival.position,
                 altitude,
@@ -87,7 +91,9 @@ class Builder(IBuilder[RtbFlightPlan, RtbLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            nav_from=[],
+            custom_waypoints=list(),
         )
 
-    def build(self) -> RtbFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> RtbFlightPlan:
         return RtbFlightPlan(self.flight, self.layout())

game/ato/flightplans/sead.py

@@ -16,14 +16,13 @@ class SeadFlightPlan(FormationAttackFlightPlan):
     def builder_type() -> Type[Builder]:
         return Builder
 
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=1)
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=1)
 
 
 class Builder(FormationAttackBuilder[SeadFlightPlan, FormationAttackLayout]):
     def layout(self) -> FormationAttackLayout:
         return self._build(FlightWaypointType.INGRESS_SEAD)
 
-    def build(self) -> SeadFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> SeadFlightPlan:
         return SeadFlightPlan(self.flight, self.layout())

game/ato/flightplans/seadsweep.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Type
+
+from .formationattack import (
+    FormationAttackBuilder,
+    FormationAttackFlightPlan,
+    FormationAttackLayout,
+)
+from ..flightwaypointtype import FlightWaypointType
+
+
+class SeadSweepFlightPlan(FormationAttackFlightPlan):
+    @staticmethod
+    def builder_type() -> Type[Builder]:
+        return Builder
+
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=2)
+
+
+class Builder(FormationAttackBuilder[SeadSweepFlightPlan, FormationAttackLayout]):
+    def layout(self) -> FormationAttackLayout:
+        return self._build(FlightWaypointType.INGRESS_SEAD_SWEEP)
+
+    def build(self, dump_debug_info: bool = False) -> SeadSweepFlightPlan:
+        return SeadSweepFlightPlan(self.flight, self.layout())

game/ato/flightplans/standard.py

@@ -1,20 +1,79 @@
 from __future__ import annotations
 
 from abc import ABC
+from copy import deepcopy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, Optional
 
 from game.ato.flightplans.flightplan import FlightPlan, Layout
+from .waypointbuilder import WaypointBuilder
+from ..flightwaypointtype import FlightWaypointType
+from ...utils import feet
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class StandardLayout(Layout, ABC):
     arrival: FlightWaypoint
     divert: FlightWaypoint | None
     bullseye: FlightWaypoint
+    nav_to: list[FlightWaypoint]
+    nav_from: list[FlightWaypoint]
+
+    def add_waypoint(
+        self, wpt: FlightWaypoint, next_wpt: Optional[FlightWaypoint]
+    ) -> bool:
+        new_wpt = self.get_midpoint(wpt, next_wpt)
+        if wpt.waypoint_type in [FlightWaypointType.TAKEOFF, FlightWaypointType.LOITER]:
+            self.nav_to.insert(0, new_wpt)
+            return True
+        elif wpt.waypoint_type in [
+            FlightWaypointType.SPLIT,
+            FlightWaypointType.REFUEL,
+            FlightWaypointType.PATROL,
+            FlightWaypointType.EGRESS,
+        ]:
+            self.nav_from.insert(0, new_wpt)
+            return True
+        elif wpt.waypoint_type is FlightWaypointType.NAV:
+            if wpt in self.nav_to:
+                index = self.nav_to.index(wpt) + 1
+                self.nav_to.insert(index, new_wpt)
+                return True
+            elif wpt in self.nav_from:
+                index = self.nav_from.index(wpt) + 1
+                self.nav_from.insert(index, new_wpt)
+                return True
+        return False
+
+    @staticmethod
+    def get_midpoint(
+        wpt: FlightWaypoint, next_wpt: Optional[FlightWaypoint]
+    ) -> FlightWaypoint:
+        new_pos = deepcopy(wpt.position)
+        next_alt = feet(20000)
+        if next_wpt:
+            new_pos = wpt.position.lerp(next_wpt.position, 0.5)
+            next_alt = next_wpt.alt
+        new_wpt = WaypointBuilder.nav(new_pos, max(wpt.alt, next_alt))
+        return new_wpt
+
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if waypoint is self.divert:
+            self.divert = None
+            return True
+        elif waypoint in self.nav_to:
+            self.nav_to.remove(waypoint)
+            return True
+        elif waypoint in self.nav_from:
+            self.nav_from.remove(waypoint)
+            return True
+        elif waypoint in self.custom_waypoints:
+            self.custom_waypoints.remove(waypoint)
+            return True
+        return False
 
 
 LayoutT = TypeVar("LayoutT", bound=StandardLayout)

game/ato/flightplans/strike.py

@@ -11,6 +11,7 @@ from .formationattack import (
 from .invalidobjectivelocation import InvalidObjectiveLocation
 from .waypointbuilder import StrikeTarget
 from ..flightwaypointtype import FlightWaypointType
+from ...theater.theatergroup import SceneryUnit
 
 
 class StrikeFlightPlan(FormationAttackFlightPlan):
@@ -28,9 +29,12 @@ class Builder(FormationAttackBuilder[StrikeFlightPlan, FormationAttackLayout]):
 
         targets: list[StrikeTarget] = []
         for idx, unit in enumerate(location.strike_targets):
-            targets.append(StrikeTarget(f"{unit.type.id} #{idx}", unit))
+            name = unit.type.id
+            if isinstance(unit, SceneryUnit):
+                name = unit.name
+            targets.append(StrikeTarget(f"{name} #{idx}", unit))
 
         return self._build(FlightWaypointType.INGRESS_STRIKE, targets)
 
-    def build(self) -> StrikeFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> StrikeFlightPlan:
         return StrikeFlightPlan(self.flight, self.layout())

game/ato/flightplans/sweep.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Iterator, TYPE_CHECKING, Type
 
 from dcs import Point
@@ -10,14 +10,13 @@ from game.utils import Heading
 from .ibuilder import IBuilder
 from .loiter import LoiterFlightPlan, LoiterLayout
 from .waypointbuilder import WaypointBuilder
-from ..traveltime import GroundSpeed, TravelTime
 from ...flightplan import HoldZoneGeometry
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class SweepLayout(LoiterLayout):
     nav_to: list[FlightWaypoint]
     sweep_start: FlightWaypoint
@@ -26,7 +25,8 @@ class SweepLayout(LoiterLayout):
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield self.hold
+        if self.hold:
+            yield self.hold
         yield from self.nav_to
         yield self.sweep_start
         yield self.sweep_end
@@ -35,13 +35,10 @@ class SweepLayout(LoiterLayout):
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
 
 
 class SweepFlightPlan(LoiterFlightPlan):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=5)
-
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
@@ -54,43 +51,45 @@ class SweepFlightPlan(LoiterFlightPlan):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.sweep_end
 
-    @property
-    def tot_offset(self) -> timedelta:
-        return -self.lead_time
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=5)
 
     @property
-    def sweep_start_time(self) -> timedelta:
-        travel_time = self.travel_time_between_waypoints(
+    def sweep_start_time(self) -> datetime:
+        travel_time = self.total_time_between_waypoints(
             self.layout.sweep_start, self.layout.sweep_end
         )
         return self.sweep_end_time - travel_time
 
     @property
-    def sweep_end_time(self) -> timedelta:
+    def sweep_end_time(self) -> datetime:
         return self.tot
 
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.sweep_start:
             return self.sweep_start_time
         if waypoint == self.layout.sweep_end:
             return self.sweep_end_time
         return None
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.hold:
             return self.push_time
         return None
 
     @property
-    def push_time(self) -> timedelta:
-        return self.sweep_end_time - TravelTime.between_points(
-            self.layout.hold.position,
-            self.layout.sweep_end.position,
-            GroundSpeed.for_flight(self.flight, self.layout.hold.alt),
+    def push_time(self) -> datetime:
+        return self.sweep_end_time - self.travel_time_between_waypoints(
+            self.layout.hold,
+            self.layout.sweep_end,
         )
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.sweep_end_time
 
 
@@ -105,27 +104,28 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
             heading.degrees, -self.doctrine.sweep_distance.meters
         )
 
-        builder = WaypointBuilder(self.flight, self.coalition)
-        start, end = builder.sweep(start_pos, target, self.doctrine.ingress_altitude)
+        builder = WaypointBuilder(self.flight)
+        altitude = builder.get_patrol_altitude
+
+        start, end = builder.sweep(start_pos, target, altitude)
 
         hold = builder.hold(self._hold_point())
 
         return SweepLayout(
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
-            nav_to=builder.nav_path(
-                hold.position, start.position, self.doctrine.ingress_altitude
-            ),
+            nav_to=builder.nav_path(hold.position, start.position, altitude),
             nav_from=builder.nav_path(
                 end.position,
                 self.flight.arrival.position,
-                self.doctrine.ingress_altitude,
+                altitude,
             ),
             sweep_start=start,
             sweep_end=end,
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
     def _hold_point(self) -> Point:
@@ -138,5 +138,5 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
             target, origin, ip, join, self.coalition, self.theater
         ).find_best_hold_point()
 
-    def build(self) -> SweepFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> SweepFlightPlan:
         return SweepFlightPlan(self.flight, self.layout())

game/ato/flightplans/tarcap.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-import random
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Type
 
-from game.utils import Distance, Speed, feet
+from game.utils import Distance, Speed
 from .capbuilder import CapBuilder
 from .patrolling import PatrollingFlightPlan, PatrollingLayout
 from .waypointbuilder import WaypointBuilder
@@ -15,7 +14,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class TarCapLayout(PatrollingLayout):
     refuel: FlightWaypoint | None
 
@@ -31,13 +30,18 @@ class TarCapLayout(PatrollingLayout):
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
+        yield from self.custom_waypoints
+
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if waypoint == self.refuel:
+            self.refuel = None
+            return True
+        elif super().delete_waypoint(waypoint):
+            return True
+        return False
 
 
 class TarCapFlightPlan(PatrollingFlightPlan[TarCapLayout]):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=2)
-
     @property
     def patrol_duration(self) -> timedelta:
         # Note that this duration only has an effect if there are no
@@ -64,24 +68,23 @@ class TarCapFlightPlan(PatrollingFlightPlan[TarCapLayout]):
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
         return {self.layout.patrol_start, self.layout.patrol_end}
 
-    @property
-    def tot_offset(self) -> timedelta:
-        return -self.lead_time
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=2)
 
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.patrol_end:
             return self.patrol_end_time
         return super().depart_time_for_waypoint(waypoint)
 
     @property
-    def patrol_start_time(self) -> timedelta:
+    def patrol_start_time(self) -> datetime:
         start = self.package.escort_start_time
         if start is not None:
             return start + self.tot_offset
         return self.tot
 
     @property
-    def patrol_end_time(self) -> timedelta:
+    def patrol_end_time(self) -> datetime:
         end = self.package.escort_end_time
         if end is not None:
             return end
@@ -92,14 +95,9 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
     def layout(self) -> TarCapLayout:
         location = self.package.target
 
-        preferred_alt = self.flight.unit_type.preferred_patrol_altitude
-        randomized_alt = preferred_alt + feet(random.randint(-2, 1) * 1000)
-        patrol_alt = max(
-            self.doctrine.min_patrol_altitude,
-            min(self.doctrine.max_patrol_altitude, randomized_alt),
-        )
+        builder = WaypointBuilder(self.flight)
+        patrol_alt = builder.get_patrol_altitude
 
-        builder = WaypointBuilder(self.flight, self.coalition)
         orbit0p, orbit1p = self.cap_racetrack_for_objective(location, barcap=False)
 
         start, end = builder.race_track(orbit0p, orbit1p, patrol_alt)
@@ -125,7 +123,8 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> TarCapFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> TarCapFlightPlan:
         return TarCapFlightPlan(self.flight, self.layout())

game/ato/flightplans/theaterrefueling.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import timedelta
 from typing import Type
 
-from game.utils import Heading, feet, meters, nautical_miles
+from game.utils import Heading, meters, nautical_miles
 from .ibuilder import IBuilder
 from .patrolling import PatrollingLayout
 from .refuelingflightplan import RefuelingFlightPlan
@@ -36,7 +36,9 @@ class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
         orbit_heading = heading_to_threat_boundary
 
         # Station 70nm outside the threat zone.
-        threat_buffer = nautical_miles(70)
+        threat_buffer = nautical_miles(
+            self.coalition.game.settings.tanker_threat_buffer_min_distance
+        )
         if self.threat_zones.threatened(location.position):
             orbit_distance = distance_to_threat + threat_buffer
         else:
@@ -54,13 +56,9 @@ class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
             orbit_heading.left.degrees, racetrack_half_distance
         )
 
-        builder = WaypointBuilder(self.flight, self.coalition)
+        builder = WaypointBuilder(self.flight)
 
-        tanker_type = self.flight.unit_type
-        if tanker_type.patrol_altitude is not None:
-            altitude = tanker_type.patrol_altitude
-        else:
-            altitude = feet(21000)
+        altitude = builder.get_patrol_altitude
 
         racetrack = builder.race_track(racetrack_start, racetrack_end, altitude)
 
@@ -77,7 +75,8 @@ class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
+            custom_waypoints=list(),
         )
 
-    def build(self) -> TheaterRefuelingFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> TheaterRefuelingFlightPlan:
         return TheaterRefuelingFlightPlan(self.flight, self.layout())

game/ato/flightplans/waypointbuilder.py

@@ -10,11 +10,11 @@ from typing import (
     TYPE_CHECKING,
     Tuple,
     Union,
+    Literal,
 )
 
 from dcs.mapping import Point, Vector2
 
-from game.ato.flightplans._common_ctld import generate_random_ctld_point
 from game.ato.flightwaypoint import AltitudeReference, FlightWaypoint
 from game.ato.flightwaypointtype import FlightWaypointType
 from game.theater import (
@@ -24,11 +24,11 @@ from game.theater import (
     TheaterGroundObject,
     TheaterUnit,
 )
-from game.theater.interfaces.CTLD import CTLD
 from game.utils import Distance, meters, nautical_miles, feet
 
+AGL_TRANSITION_ALT = 5000
+
 if TYPE_CHECKING:
-    from game.coalition import Coalition
     from game.transfers import MultiGroupTransport
     from game.theater.theatergroup import TheaterGroup
     from game.ato.flight import Flight
@@ -44,20 +44,43 @@ class WaypointBuilder:
     def __init__(
         self,
         flight: Flight,
-        coalition: Coalition,
         targets: Optional[List[StrikeTarget]] = None,
     ) -> None:
+        coalition = flight.coalition
         self.flight = flight
         self.doctrine = coalition.doctrine
         self.threat_zones = coalition.opponent.threat_zone
         self.navmesh = coalition.nav_mesh
         self.targets = targets
         self._bullseye = coalition.bullseye
+        self.settings = self.flight.coalition.game.settings
 
     @property
     def is_helo(self) -> bool:
         return self.flight.is_helo
 
+    @property
+    def get_patrol_altitude(self) -> Distance:
+        return self.get_altitude(self.flight.unit_type.preferred_patrol_altitude)
+
+    @property
+    def get_cruise_altitude(self) -> Distance:
+        return self.get_altitude(self.flight.unit_type.preferred_cruise_altitude)
+
+    @property
+    def get_combat_altitude(self) -> Distance:
+        return self.get_altitude(self.flight.unit_type.preferred_combat_altitude)
+
+    def get_altitude(self, alt: Distance) -> Distance:
+        randomized_alt = feet(round(alt.feet + self.flight.plane_altitude_offset))
+        altitude = max(
+            self.doctrine.min_combat_altitude,
+            min(self.doctrine.max_combat_altitude, randomized_alt),
+        )
+        return (
+            feet(self.settings.heli_combat_alt_agl) if self.flight.is_helo else altitude
+        )
+
     def takeoff(self, departure: ControlPoint) -> FlightWaypoint:
         """Create takeoff waypoint for the given arrival airfield or carrier.
 
@@ -74,7 +97,7 @@ class WaypointBuilder:
                 "NAV",
                 FlightWaypointType.NAV,
                 position,
-                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
+                self.get_cruise_altitude,
                 description="Enter theater",
                 pretty_name="Enter theater",
             )
@@ -101,7 +124,7 @@ class WaypointBuilder:
                 "NAV",
                 FlightWaypointType.NAV,
                 position,
-                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
+                self.get_cruise_altitude,
                 description="Exit theater",
                 pretty_name="Exit theater",
             )
@@ -127,12 +150,10 @@ class WaypointBuilder:
             return None
 
         position = divert.position
-        altitude_type: AltitudeReference
+        altitude_type: AltitudeReference = "BARO"
         if isinstance(divert, OffMapSpawn):
-            altitude = (
-                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude
-            )
-            altitude_type = "BARO"
+            altitude = self.get_cruise_altitude
+            altitude_type = "RADIO" if self.is_helo else altitude_type
         else:
             altitude = meters(0)
             altitude_type = "RADIO"
@@ -162,14 +183,15 @@ class WaypointBuilder:
 
     def hold(self, position: Point) -> FlightWaypoint:
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.get_combat_altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         return FlightWaypoint(
             "HOLD",
             FlightWaypointType.LOITER,
             position,
-            meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
+            # TODO: dedicated altitude setting for holding
+            self.get_cruise_altitude if self.is_helo else self.get_combat_altitude,
             alt_type,
             description="Wait until push time",
             pretty_name="Hold",
@@ -177,14 +199,14 @@ class WaypointBuilder:
 
     def join(self, position: Point) -> FlightWaypoint:
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.get_cruise_altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         return FlightWaypoint(
             "JOIN",
             FlightWaypointType.JOIN,
             position,
-            meters(80) if self.is_helo else self.doctrine.ingress_altitude,
+            self.get_cruise_altitude,
             alt_type,
             description="Rendezvous with package",
             pretty_name="Join",
@@ -192,14 +214,14 @@ class WaypointBuilder:
 
     def refuel(self, position: Point) -> FlightWaypoint:
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.get_cruise_altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         return FlightWaypoint(
             "REFUEL",
             FlightWaypointType.REFUEL,
             position,
-            meters(80) if self.is_helo else self.doctrine.ingress_altitude,
+            self.get_cruise_altitude,
             alt_type,
             description="Refuel from tanker",
             pretty_name="Refuel",
@@ -207,14 +229,14 @@ class WaypointBuilder:
 
     def split(self, position: Point) -> FlightWaypoint:
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.get_combat_altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         return FlightWaypoint(
             "SPLIT",
             FlightWaypointType.SPLIT,
             position,
-            meters(80) if self.is_helo else self.doctrine.ingress_altitude,
+            self.get_combat_altitude,
             alt_type,
             description="Depart from package",
             pretty_name="Split",
@@ -226,16 +248,26 @@ class WaypointBuilder:
         position: Point,
         objective: MissionTarget,
     ) -> FlightWaypoint:
-        alt = self.doctrine.ingress_altitude
+        alt = self.get_combat_altitude
         alt_type: AltitudeReference = "BARO"
         if self.is_helo or self.flight.is_hercules:
             alt_type = "RADIO"
-            alt = meters(60) if self.is_helo else feet(1000)
+            alt = (
+                feet(self.flight.coalition.game.settings.heli_combat_alt_agl)
+                if self.is_helo
+                else feet(1000)
+            )
+        elif alt.feet <= AGL_TRANSITION_ALT:
+            alt_type = "RADIO"
+
+        heading = objective.position.heading_between_point(position)
 
         return FlightWaypoint(
             "INGRESS",
             ingress_type,
-            position,
+            objective.position.point_from_heading(heading, nautical_miles(5).meters)
+            if self.is_helo
+            else position,
             alt,
             alt_type,
             description=f"INGRESS on {objective.name}",
@@ -245,14 +277,14 @@ class WaypointBuilder:
 
     def egress(self, position: Point, target: MissionTarget) -> FlightWaypoint:
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.get_combat_altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         return FlightWaypoint(
             "EGRESS",
             FlightWaypointType.EGRESS,
             position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
+            self.get_combat_altitude,
             alt_type,
             description=f"EGRESS from {target.name}",
             pretty_name=f"EGRESS from {target.name}",
@@ -290,14 +322,15 @@ class WaypointBuilder:
         return self._target_area(f"STRIKE {target.name}", target)
 
     def sead_area(self, target: MissionTarget) -> FlightWaypoint:
-        # Set flyover with ingress altitude to allow the flight to search and engage
-        # the target group at the ingress alt without suicide dive
+        alt_type: AltitudeReference = "BARO"
+        if self.get_combat_altitude.feet <= AGL_TRANSITION_ALT:
+            alt_type = "RADIO"
+
         return self._target_area(
             f"SEAD on {target.name}",
             target,
-            flyover=True,
-            altitude=self.doctrine.ingress_altitude,
-            alt_type="BARO",
+            altitude=self.get_combat_altitude,
+            alt_type=alt_type,
         )
 
     def dead_area(self, target: MissionTarget) -> FlightWaypoint:
@@ -316,8 +349,8 @@ class WaypointBuilder:
         # plan.
         return self._target_area(f"ASSAULT {target.name}", target)
 
-    @staticmethod
     def _target_area(
+        self,
         name: str,
         location: MissionTarget,
         flyover: bool = False,
@@ -352,7 +385,9 @@ class WaypointBuilder:
             "CAS",
             FlightWaypointType.CAS,
             position,
-            meters(60) if self.is_helo else meters(1000),
+            feet(self.flight.coalition.game.settings.heli_combat_alt_agl)
+            if self.is_helo
+            else meters(1000),
             "RADIO",
             description="Provide CAS",
             pretty_name="CAS",
@@ -366,11 +401,13 @@ class WaypointBuilder:
             position: Position of the waypoint.
             altitude: Altitude of the racetrack.
         """
+        baro: AltitudeReference = "BARO"
         return FlightWaypoint(
             "RACETRACK START",
             FlightWaypointType.PATROL_TRACK,
             position,
             altitude,
+            "RADIO" if altitude.feet <= AGL_TRANSITION_ALT else baro,
             description="Orbit between this point and the next point",
             pretty_name="Race-track start",
         )
@@ -383,11 +420,13 @@ class WaypointBuilder:
             position: Position of the waypoint.
             altitude: Altitude of the racetrack.
         """
+        baro: AltitudeReference = "BARO"
         return FlightWaypoint(
             "RACETRACK END",
             FlightWaypointType.PATROL,
             position,
             altitude,
+            "RADIO" if altitude.feet <= AGL_TRANSITION_ALT else baro,
             description="Orbit between this point and the previous point",
             pretty_name="Race-track end",
         )
@@ -415,30 +454,84 @@ class WaypointBuilder:
             start: Position of the waypoint.
             altitude: Altitude of the racetrack.
         """
-
+        baro: AltitudeReference = "BARO"
         return FlightWaypoint(
             "ORBIT",
             FlightWaypointType.LOITER,
             start,
             altitude,
+            "RADIO" if altitude.feet <= AGL_TRANSITION_ALT else baro,
             description="Anchor and hold at this point",
             pretty_name="Orbit",
         )
 
-    @staticmethod
-    def escort_hold(start: Point, altitude: Distance) -> FlightWaypoint:
+    def sead_search(self, target: MissionTarget) -> FlightWaypoint:
+        hold = self._sead_search_point(target)
+        baro: AltitudeReference = "BARO"
+        return FlightWaypoint(
+            "SEAD Search",
+            FlightWaypointType.NAV,
+            hold,
+            self.get_combat_altitude,
+            "RADIO" if self.get_combat_altitude.feet <= AGL_TRANSITION_ALT else baro,
+            description="Anchor and search from this point",
+            pretty_name="SEAD Search",
+        )
+
+    def sead_sweep(self, target: MissionTarget) -> FlightWaypoint:
+        hold = self._sead_search_point(target)
+        baro: AltitudeReference = "BARO"
+        return FlightWaypoint(
+            "SEAD Sweep",
+            FlightWaypointType.NAV,
+            hold,
+            self.get_combat_altitude,
+            "RADIO" if self.get_combat_altitude.feet <= AGL_TRANSITION_ALT else baro,
+            description="Anchor and search from this point",
+            pretty_name="SEAD Sweep",
+        )
+
+    def _sead_search_point(self, target: MissionTarget) -> Point:
+        """Creates custom waypoint for AI SEAD flights
+            to avoid having them fly all the way to the SAM site.
+        Args:
+            target: Target information.
+        """
+        # Use the threat range as offset distance to avoid flying all the way to the SAM site
+        assert self.flight.package.waypoints
+        ingress = self.flight.package.waypoints.ingress
+        ingress2tgt_dist = ingress.distance_to_point(target.position)
+        threat_range = nautical_miles(
+            self.flight.coalition.game.settings.sead_threat_buffer_min_distance
+        ).meters
+        if target.strike_targets:
+            threat_range = (
+                1.1 * max([x.threat_range for x in target.strike_targets]).meters
+            )
+        hdg = target.position.heading_between_point(ingress)
+        hold = target.position.point_from_heading(
+            hdg, min(threat_range, ingress2tgt_dist * 0.95)
+        )
+        return hold
+
+    def escort_hold(self, start: Point) -> FlightWaypoint:
         """Creates custom waypoint for escort flights that need to hold.
 
         Args:
             start: Position of the waypoint.
-            altitude: Altitude of the holding pattern.
         """
+        altitude = self.get_combat_altitude
+
+        alt_type: Literal["BARO", "RADIO"] = "BARO"
+        if self.is_helo or altitude.feet <= AGL_TRANSITION_ALT:
+            alt_type = "RADIO"
 
         return FlightWaypoint(
             "ESCORT HOLD",
             FlightWaypointType.CUSTOM,
             start,
             altitude,
+            alt_type=alt_type,
             description="Anchor and hold at this point",
             pretty_name="Escort Hold",
         )
@@ -451,11 +544,13 @@ class WaypointBuilder:
             position: Position of the waypoint.
             altitude: Altitude of the sweep in meters.
         """
+        baro: AltitudeReference = "BARO"
         return FlightWaypoint(
             "SWEEP START",
             FlightWaypointType.INGRESS_SWEEP,
             position,
             altitude,
+            "RADIO" if altitude.feet <= AGL_TRANSITION_ALT else baro,
             description="Proceed to the target and engage enemy aircraft",
             pretty_name="Sweep start",
         )
@@ -468,11 +563,13 @@ class WaypointBuilder:
             position: Position of the waypoint.
             altitude: Altitude of the sweep in meters.
         """
+        baro: AltitudeReference = "BARO"
         return FlightWaypoint(
             "SWEEP END",
             FlightWaypointType.EGRESS,
             position,
             altitude,
+            "RADIO" if altitude.feet <= AGL_TRANSITION_ALT else baro,
             description="End of sweep",
             pretty_name="Sweep end",
         )
@@ -501,7 +598,7 @@ class WaypointBuilder:
             target: The mission target.
         """
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.get_combat_altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         # This would preferably be no points at all, and instead the Escort task
@@ -515,7 +612,7 @@ class WaypointBuilder:
             "TARGET",
             FlightWaypointType.TARGET_GROUP_LOC,
             target.position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
+            self.get_combat_altitude,
             alt_type,
             description="Escort the package",
             pretty_name="Target area",
@@ -537,17 +634,19 @@ class WaypointBuilder:
             pretty_name="Pick-up zone",
         )
 
-    @staticmethod
-    def dropoff_zone(drop_off: MissionTarget) -> FlightWaypoint:
+    def dropoff_zone(self, drop_off: MissionTarget) -> FlightWaypoint:
         """Creates a dropoff landing zone waypoint
         This waypoint is used to generate the Trigger Zone used for AirAssault and
         AirLift using the CTLD plugin (see LogisticsGenerator)
         """
+        heli_alt = feet(self.flight.coalition.game.settings.heli_cruise_alt_agl)
+        altitude = heli_alt if self.flight.is_helo else meters(0)
+
         return FlightWaypoint(
             "DROPOFFZONE",
             FlightWaypointType.DROPOFF_ZONE,
             drop_off.position,
-            meters(0),
+            altitude,
             "RADIO",
             description=f"Drop off cargo at {drop_off.name}",
             pretty_name="Drop-off zone",
@@ -558,14 +657,10 @@ class WaypointBuilder:
         """Creates a cargo stop waypoint.
         This waypoint is used by AirLift as a landing and stopover waypoint
         """
-        if isinstance(control_point, CTLD) and control_point.ctld_zones:
-            pos = generate_random_ctld_point(control_point)
-        else:
-            pos = control_point.position
         return FlightWaypoint(
             "CARGOSTOP",
             FlightWaypointType.CARGO_STOP,
-            pos,
+            control_point.position,
             meters(0),
             "RADIO",
             description=f"Stop for cargo at {control_point.name}",
@@ -585,7 +680,7 @@ class WaypointBuilder:
             altitude_is_agl: True for altitude is AGL. False if altitude is MSL.
         """
         alt_type: AltitudeReference = "BARO"
-        if altitude_is_agl:
+        if altitude_is_agl or altitude.feet <= AGL_TRANSITION_ALT:
             alt_type = "RADIO"
 
         return FlightWaypoint(

game/ato/flightroster.py

@@ -1,29 +1,34 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from typing import Optional, TYPE_CHECKING
 
+from game.ato.iflightroster import IFlightRoster
+
 if TYPE_CHECKING:
     from game.squadrons import Squadron, Pilot
 
 
-class FlightRoster:
+class FlightRoster(IFlightRoster):
     def __init__(self, squadron: Squadron, initial_size: int = 0) -> None:
-        self.squadron = squadron
+        self._squadron = squadron
         self.pilots: list[Optional[Pilot]] = []
         self.resize(initial_size)
 
+    @property
+    def squadron(self) -> Squadron:
+        return self._squadron
+
+    def iter_pilots(self) -> Iterator[Pilot | None]:
+        yield from self.pilots
+
+    def pilot_at(self, idx: int) -> Pilot | None:
+        return self.pilots[idx]
+
     @property
     def max_size(self) -> int:
         return len(self.pilots)
 
-    @property
-    def player_count(self) -> int:
-        return len([p for p in self.pilots if p is not None and p.player])
-
-    @property
-    def missing_pilots(self) -> int:
-        return len([p for p in self.pilots if p is None])
-
     def resize(self, new_size: int) -> None:
         if self.max_size > new_size:
             self.squadron.return_pilots(

game/ato/flightstate/flightstate.py

@@ -21,6 +21,39 @@ class FlightState(ABC):
         self.settings = settings
         self.avoid_further_combat = False
 
+    def reinitialize(self, now: datetime) -> None:
+        from game.ato.flightstate import WaitingForStart
+
+        start_time = self.flight.flight_plan.startup_time()
+        if start_time <= now:
+            self._set_active_flight_state(start_time)
+        else:
+            self.flight.set_state(
+                WaitingForStart(self.flight, self.settings, start_time)
+            )
+
+    def _set_active_flight_state(self, now: datetime) -> None:
+        from game.ato.flightstate import StartUp
+        from game.ato.flightstate import Taxi
+        from game.ato.flightstate import Takeoff
+        from game.ato.flightstate import Navigating
+
+        match self.flight.start_type:
+            case StartType.COLD:
+                self.flight.set_state(StartUp(self.flight, self.settings, now))
+            case StartType.WARM:
+                self.flight.set_state(Taxi(self.flight, self.settings, now))
+            case StartType.RUNWAY:
+                self.flight.set_state(Takeoff(self.flight, self.settings, now))
+            case StartType.IN_FLIGHT:
+                self.flight.set_state(
+                    Navigating(self.flight, self.settings, waypoint_index=0)
+                )
+            case _:
+                raise ValueError(
+                    f"Unknown start type {self.flight.start_type} for {self.flight}"
+                )
+
     @property
     def alive(self) -> bool:
         return True
@@ -82,9 +115,7 @@ class FlightState(ABC):
 
     def estimate_fuel(self) -> float:
         """Returns the estimated remaining fuel **in kilograms**."""
-        if (max_takeoff_fuel := self.flight.max_takeoff_fuel()) is not None:
-            return max_takeoff_fuel
-        return self.flight.unit_type.dcs_unit_type.fuel_max
+        return self.flight.fuel
 
     @property
     @abstractmethod

game/ato/flightstate/inflight.py

@@ -26,6 +26,7 @@ class InFlight(FlightState, ABC):
         settings: Settings,
         waypoint_index: int,
         has_aborted: bool = False,
+        elapsed_time: timedelta = timedelta(),
     ) -> None:
         super().__init__(flight, settings)
         waypoints = self.flight.flight_plan.waypoints
@@ -35,7 +36,7 @@ class InFlight(FlightState, ABC):
         # TODO: Error checking for flight plans without landing waypoints.
         self.next_waypoint = waypoints[self.waypoint_index + 1]
         self.total_time_to_next_waypoint = self.travel_time_between_waypoints()
-        self.elapsed_time = timedelta()
+        self.elapsed_time = elapsed_time
         self.current_waypoint_elapsed = False
 
     @property
@@ -51,17 +52,9 @@ class InFlight(FlightState, ABC):
         return index <= self.waypoint_index
 
     def travel_time_between_waypoints(self) -> timedelta:
-        travel_time = self.flight.flight_plan.travel_time_between_waypoints(
+        return self.flight.flight_plan.travel_time_between_waypoints(
             self.current_waypoint, self.next_waypoint
         )
-        if self.current_waypoint.waypoint_type is FlightWaypointType.LOITER:
-            # Loiter time is already built into travel_time_between_waypoints. If we're
-            # at a loiter point but still a regular InFlight (Loiter overrides this
-            # method) that means we're traveling from the loiter point but no longer
-            # loitering.
-            assert self.flight.flight_plan.is_loiter(self.flight.flight_plan)
-            travel_time -= self.flight.flight_plan.hold_duration
-        return travel_time
 
     @abstractmethod
     def estimate_position(self) -> Point:

game/ato/flightstate/navigating.py

@@ -29,6 +29,11 @@ class Navigating(InFlight):
             events.update_flight_position(self.flight, self.estimate_position())
 
     def progress(self) -> float:
+        # if next waypoint is very close, assume we reach it immediately to avoid divide
+        # by zero error
+        if self.total_time_to_next_waypoint.total_seconds() < 1:
+            return 1.0
+
         return (
             self.elapsed_time.total_seconds()
             / self.total_time_to_next_waypoint.total_seconds()

game/ato/flightstate/startup.py

@@ -24,7 +24,7 @@ class StartUp(AtDeparture):
     ) -> None:
         if time < self.completion_time:
             return
-        self.flight.set_state(Taxi(self.flight, self.settings, time))
+        self.flight.set_state(Taxi(self.flight, self.settings, self.completion_time))
 
     @property
     def is_waiting_for_start(self) -> bool:

game/ato/flightstate/takeoff.py

@@ -19,14 +19,19 @@ class Takeoff(AtDeparture):
     def __init__(self, flight: Flight, settings: Settings, now: datetime) -> None:
         super().__init__(flight, settings)
         # TODO: Not accounted for in FlightPlan, can cause discrepancy without loiter.
-        self.completion_time = now + timedelta(seconds=30)
+        self.completion_time = now + flight.flight_plan.estimate_takeoff_time()
 
     def on_game_tick(
         self, events: GameUpdateEvents, time: datetime, duration: timedelta
     ) -> None:
         if time < self.completion_time:
             return
-        self.flight.set_state(Navigating(self.flight, self.settings, waypoint_index=0))
+        rollover = time - self.completion_time
+        self.flight.set_state(
+            Navigating(
+                self.flight, self.settings, waypoint_index=0, elapsed_time=rollover
+            )
+        )
 
     @property
     def is_waiting_for_start(self) -> bool:
@@ -45,7 +50,8 @@ class Takeoff(AtDeparture):
     def should_halt_sim(self) -> bool:
         if (
             self.flight.client_count > 0
-            and self.settings.player_mission_interrupts_sim_at is StartType.RUNWAY
+            and self.settings.player_mission_interrupts_sim_at
+            is [StartType.COLD, StartType.WARM, StartType.RUNWAY]
         ):
             logging.info(
                 f"Interrupting simulation because {self.flight} has players and has "

game/ato/flightstate/taxi.py

@@ -24,7 +24,7 @@ class Taxi(AtDeparture):
     ) -> None:
         if time < self.completion_time:
             return
-        self.flight.set_state(Takeoff(self.flight, self.settings, time))
+        self.flight.set_state(Takeoff(self.flight, self.settings, self.completion_time))
 
     @property
     def is_waiting_for_start(self) -> bool:
@@ -37,7 +37,8 @@ class Taxi(AtDeparture):
     def should_halt_sim(self) -> bool:
         if (
             self.flight.client_count > 0
-            and self.settings.player_mission_interrupts_sim_at is StartType.WARM
+            and self.settings.player_mission_interrupts_sim_at
+            in [StartType.COLD, StartType.WARM]
         ):
             logging.info(
                 f"Interrupting simulation because {self.flight} has players and has "

game/ato/flightstate/uninitialized.py

@@ -20,7 +20,8 @@ class Uninitialized(FlightState):
     def on_game_tick(
         self, events: GameUpdateEvents, time: datetime, duration: timedelta
     ) -> None:
-        raise RuntimeError("Attempted to simulate flight that is not fully initialized")
+        self.reinitialize(time)
+        self.flight.state.on_game_tick(events, time, duration)
 
     @property
     def is_waiting_for_start(self) -> bool:
@@ -35,7 +36,6 @@ class Uninitialized(FlightState):
 
     @property
     def description(self) -> str:
-        delay = self.flight.flight_plan.startup_time()
         if self.flight.start_type is StartType.COLD:
             action = "Starting up"
         elif self.flight.start_type is StartType.WARM:
@@ -46,4 +46,4 @@ class Uninitialized(FlightState):
             action = "In flight"
         else:
             raise ValueError(f"Unhandled StartType: {self.flight.start_type}")
-        return f"{action} in {delay}"
+        return f"{action} at {self.flight.flight_plan.startup_time():%H:%M:%S}"