Update of Campaign Falcon Went over the Mountain.

Added secondary mission types to all air-to-air squadrons for more
flexibility.

.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

.gitattributes

@@ -14,3 +14,79 @@
 *.pyo    binary export-ignore
 *.pyd    binary
 unshipped_data/arcgis_maps/ filter=lfs diff=lfs merge=lfs -text
+
+# https://github.com/alexkaratarakis/gitattributes/blob/master/Common.gitattributes
+# Documents
+*.bibtex   text diff=bibtex
+*.doc      diff=astextplain
+*.DOC      diff=astextplain
+*.docx     diff=astextplain
+*.DOCX     diff=astextplain
+*.dot      diff=astextplain
+*.DOT      diff=astextplain
+*.pdf      diff=astextplain
+*.PDF      diff=astextplain
+*.rtf      diff=astextplain
+*.RTF      diff=astextplain
+*.md       text diff=markdown
+*.mdx      text diff=markdown
+*.tex      text diff=tex
+*.adoc     text
+*.textile  text
+*.mustache text
+*.csv      text
+*.tab      text
+*.tsv      text
+*.txt      text
+*.sql      text
+*.epub     diff=astextplain
+
+# Graphics
+*.png      binary
+*.jpg      binary
+*.jpeg     binary
+*.gif      binary
+*.tif      binary
+*.tiff     binary
+*.ico      binary
+# SVG treated as text by default.
+*.svg      text
+# If you want to treat it as binary,
+# use the following line instead.
+# *.svg    binary
+*.eps      binary
+
+# Scripts
+*.bash     text eol=lf
+*.fish     text eol=lf
+*.sh       text eol=lf
+*.zsh      text eol=lf
+# These are explicitly windows files and should use crlf
+*.bat      text eol=crlf
+*.cmd      text eol=crlf
+*.ps1      text eol=crlf
+
+# Serialisation
+*.json     text
+*.toml     text
+*.xml      text
+*.yaml     text
+*.yml      text
+
+# Archives
+*.7z       binary
+*.gz       binary
+*.tar      binary
+*.tgz      binary
+*.zip      binary
+
+# Text files where line endings should be preserved
+*.patch    -text
+
+#
+# Exclude files from exporting
+#
+
+.gitattributes export-ignore
+.gitignore     export-ignore
+.gitkeep       export-ignore

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -31,12 +31,13 @@ body:
         If the bug was found in a development build, select "Development build"
         and provide a link to the build in the field below.
       options:
-        - 5.2.0
+        - 9.0.0
         - Development build
   - type: textarea
     attributes:
       label: Build information
-      description: The build information from the Help -> Report an issue window.
+      description:
+        The build information from the Help -> Report an issue window.
   - type: textarea
     attributes:
       label: Description
@@ -48,22 +49,27 @@ body:
       required: true
   - type: textarea
     attributes:
-      label: Save game and other files
+      label: Save game and other files (save game required, bugs without saves will be closed)
       description: >
         Attach any files needed to reproduce the bug here. **A save game is
-        required.** We typically cannot help without a save game (the
-        `.liberation` file found in
-        `%USERPROFILE%/Saved Games/DCS/Liberation/Saves`), so most bugs filed
-        without saved games will be closed without investigation.
+        required.** Even if it seems unnecessary to you, this is required.
+        Repro steps that are obvious to you might not be obvious to anyone
+        else, and it is impossible for us to know what default settings or mods
+        may be impacting behavior without a save game. Bugs filed without a
+        save game are very often not reproducible, and those waste scarce
+        developer time. It is **much** easier for you to attach a save game
+        than it is for us to recreate your save state by guessing at what you
+        did. As such, bug reports that do not attach a saved game will be
+        closed without investigation. Attach the `.liberation.zip` file found
+        in `%USERPROFILE%/Saved Games/DCS/Liberation/Saves`.
 
 
         Other useful files to include are:
 
 
-        The Liberation log file. The log file is located at
-        `<Liberation install directory>/logs/liberation.log`. The log often
-        includes data about non-fatal errors that could be the root cause of the
-        problem.
+        The Liberation log file. The log file is located at `<Liberation install
+        directory>/logs/liberation.log`. The log often includes data about
+        non-fatal errors that could be the root cause of the problem.
 
 
         The `liberation_nextturn.miz` or a track file. This should always be
@@ -76,8 +82,12 @@ body:
         investigating any issues with end-of-turn results processing.
 
 
-        You can attach files to the bug by dragging and dropping the file
-        into this text box. GitHub will not allow uploads of all file types, so
+        If reporting an issue that occurred during or after flying the mission
+        in DCS, the DCS log file found in `%USERPROFILE%/Saved Games/DCS/Logs`.
+
+
+        You can attach files to the bug by dragging and dropping the file into
+        this text box. GitHub will not allow uploads of all file types, so
         attach a zip of the files if needed.
     validations:
       required: true

.github/ISSUE_TEMPLATE/new-game-bug.yml

@@ -39,12 +39,13 @@ body:
         If the bug was found in a development build, select "Development build"
         and provide a link to the build in the field below.
       options:
-        - 5.2.0
+        - 9.0.0
         - Development build
   - type: textarea
     attributes:
       label: Build information
-      description: The build information from the Help -> Report an issue window.
+      description:
+        The build information from the Help -> Report an issue window.
   - type: input
     attributes:
       label: Campaign name
@@ -59,8 +60,8 @@ body:
       label: Blue faction
       description: >
         The name of the blue faction you selected. If the bug only occurs with a
-        custom faction (or modifications to a stock faction), upload the
-        faction file as an attachment to the bug description field.
+        custom faction (or modifications to a stock faction), upload the faction
+        file as an attachment to the bug description field.
     validations:
       required: true
   - type: input
@@ -68,8 +69,8 @@ body:
       label: Red faction
       description: >
         The name of the red faction you selected. If the bug only occurs with a
-        custom faction (or modifications to a stock faction), upload the
-        faction file as an attachment to the bug description field.
+        custom faction (or modifications to a stock faction), upload the faction
+        file as an attachment to the bug description field.
     validations:
       required: true
   - type: textarea
@@ -102,11 +103,11 @@ body:
     attributes:
       label: Log file
       description: >
-        Attach the Liberation log file. The log file is located at
-        `<Liberation install directory>/logs/liberation.log`.
+        Attach the Liberation log file. The log file is located at `<Liberation
+        install directory>/logs/liberation.log`.
 
 
-        You can attach files to the bug by dragging and dropping the file
-        into this text box.
+        You can attach files to the bug by dragging and dropping the file into
+        this text box.
     validations:
       required: true

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

@@ -6,7 +6,7 @@ runs:
     - name: Set up Python
       uses: actions/setup-python@v2
       with:
-        python-version: "3.10"
+        python-version: "3.11"
         cache: pip
 
     - name: Install environment
@@ -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

@@ -11,6 +11,7 @@ jobs:
       - uses: actions/setup-python@v2
       - uses: psf/black@stable
         with:
+          version: ~=23.11
           src: "."
           options: "--check"
 

.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

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/psf/black
-    rev: 22.6.0
+    rev: 23.11.0
     hooks:
       - id: black
         language_version: python3

.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

README.md

@@ -8,13 +8,19 @@
 
 [![Discord](https://img.shields.io/discord/595702951800995872?label=Discord&logo=discord)](https://discord.gg/bKrtrkJ)
 
+[![codecov](https://codecov.io/gh/dcs-liberation/dcs_liberation/branch/develop/graph/badge.svg?token=EEQ7G76K2L)](https://codecov.io/gh/dcs-liberation/dcs_liberation)
 [![GitHub pull requests](https://img.shields.io/github/issues-pr/dcs-liberation/dcs_liberation)](https://github.com/dcs-liberation/dcs_liberation)
 [![GitHub issues](https://img.shields.io/github/issues/dcs-liberation/dcs_liberation)](https://github.com/dcs-liberation/dcs_liberation/issues)
 ![GitHub stars](https://img.shields.io/github/stars/dcs-liberation/dcs_liberation?style=social)
 
 ## About DCS Liberation
 DCS Liberation is a [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) turn based single-player or co-op dynamic campaign. 
-It is an external program that generates full and complex DCS missions and manage a persistent combat environment.  
+It is an external program that generates full and complex DCS missions and manage a persistent combat environment.
+
+**Note that DCS Liberation does not support the stable release of DCS. We can
+only guarantee compatibility  with either  the open beta or the stable release,
+and more people play the open beta. DCS stable _might_ work sometimes, but it's
+untested, and we will be unable to fix any bugs unique to stable DCS.**
 
 ![Screenshot](https://user-images.githubusercontent.com/315852/120939254-0b4a9f80-c6cc-11eb-82f5-ce3f8d714bfe.png)
 
@@ -29,7 +35,6 @@ To download preview builds of the next version of DCS Liberation, see https://gi
 These DCS bugs prevent us from improving AI behavior. Please upvote them! (But please
 _don't_ spam them with comments):
 
-* [Hold points do not work in DCS 2.8](https://forum.dcs.world/topic/311458-humvee-ground-unit-holdstop-conditiontime-more-bug-28-mission-editor/)
 * [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/)
 

changelog.md

@@ -1,3 +1,209 @@
+# 10.0.0
+
+Saves from 9.x are not compatible with 10.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.2.49629 Open Beta. (F-15E JDAM and JSOW, F-16 AIM-9P, updated Falklands and Normandy airfields).
+* **[UI]** Improved the description of "runway" state for FARPs, FOBs, carriers, and off-map spawns.
+
+## Fixes
+
+* **[Flight Planning]** Aircraft from even numbered flights will no longer become inaccessible when canceling a draft package.
+* **[UI]** Flight members in the loadout menu are now numbered starting from 1 instead of 0.
+* **[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.
+
+# 9.0.0
+
+Saves from 8.x are not compatible with 9.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS Open Beta 2.9.0.46801.
+* **[Campaign]** Added ferry only control points, which offer campaign designers a way to add squadrons that can be brought in after additional airfields are captured.
+* **[Campaign]** The new squadron rules (size limits, beginning the campaign at full strength) are now the default and required. The old style of unlimited squadron sizes and starting with zero aircraft has been removed.
+* **[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+.
+* **[Mission Generation]** Added a package kneeboard page that shows the radio frequencies, tasks, and laser codes for each member of your package.
+* **[Mission Generation]** Added option to generate AI flights with unlimited fuel (enabled by default).
+* **[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.
+* **[Modding]** Updated Community A-4E-C mod version support to 2.2.0 release.
+* **[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.
+* **[Loadouts]** Fixed error when loading certain DCS loadouts which contained an empty pylon (notably the Mosquito).
+* **[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 Recovery Tanker mission type intermittently failing due to not being able to find the CVN.
+* **[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.
+* **[Mission Generation]** Fixed flights not being selectable in the mission editor if fast-forward was used and they were generated at a waypoint that had a fixed TOT (such as a BARCAP that was on-station).
+* **[Mission Generation]** Fixed error when planning TARCAPs on the sole remaining enemy airfield.
+* **[Mission Generation]** Fixed allocation range for carrier Link 4 datalink.
+* **[Modding]** Unit variants can now actually override base unit type properties.
+* **[New Game Wizard]** Factions are reset to default after clicking "Back" to Theater Configuration screen.
+* **[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]** In unit transfer dialog, only list control points that are reachable from the control point units are being transferred from.
+* **[UI]** Fixed UI bug where altering an "ahead of package" TOT offset would change the offset back to a "behind package" offset.
+* **[UI]** Fixed bug where changing TOT offsets could result in flight startup times that are in the past.
+* **[UI]** Fixed odd spacing of the finance window when there were not enough items to fill the page.
+* **[UI]** Fixed regression where waypoint altitude changes in the waypoint list screen are applied to the wrong waypoint.
+* **[UI]** Fixed regression where waypoint additions in custom flight plans are not reflected until the window is reloaded. 
+
+# 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
+
+* **[Engine]** Support for Normandy 2 airfields.
+* **[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 Generation]** Added settings for controlling number of tactical commander, observer, JTAC, and game master slots.
+* **[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.
+* **[New Game Wizard]** The air wing configuration dialog will check for and reject overfull airbases before continuing when the new squadron rules are used.
+* **[New Game Wizard]** Closing the air wing configuration dialog will now cancel and return to the new game wizard rather than reverting changes and continuing.
+* **[New Game Wizard]** A warning will be displayed next to the new squadron rules button if the campaign predates the new rules and will likely require user intervention before continuing.
+* **[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.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.5.40170.
+* **[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]** 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.
+* **[Mission Generation]** Game state will automatically be checkpointed before fast-forwarding the mission, and restored on mission abort. This means that it's now possible to abort a mission and make changes without needing to manually re-load your game.
+* **[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]** Added support for AI C-47 mod.
+* **[Modding]** Custom factions can now be defined in YAML as well as JSON. JSON support may be removed in the future if having both formats causes confusion.
+* **[Modding]** Campaigns which require custom factions can now define those factions directly in the campaign YAML. See Operation Aliied Sword for an example.
+* **[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]** 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]** 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.
+* **[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
+
+* **[Data]** Fixed unit ID for the KS-19 AAA. KS-19 would not previously generate correctly in missions. A new game is required for this fix to take effect.
+* **[Flight Planning]** Automatic flight planning will no longer accidentally plan a recovery tanker instead of a theater refueling package. This fixes a potential crash during mission generation when opfor plans a refueling task at a sunk carrier. You'll need to skip the current turn to force opfor to replan their flights to get the fix.
+* **[Mission Generation]** Using heliports (airports without any runways) will no longer cause mission generation to fail.
+* **[Mission Generation]** Prevent helicopters from spawning into collisions at FARPs when more than one flight uses the same FARP.
+
+# 6.1.0
+
+Saves from 6.0.0 are compatible with 6.1.0
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.1.34437, including Blackshark 3.
+* **[Factions]** Defaulted bluefor modern to use Georgian and Ukrainian liveries for Russian aircraft.
+* **[Factions]** Added Peru.
+* **[Flight Planning]** AEW&C and Refueling flights are now plannable on LHA carriers.
+* **[Flight Planning]** Refueling flights planned on aircraft carriers will act as a recovery tanker for the carrier.
+* **[Loadouts]** Adjusted F-15E loadouts.
+* **[Mission Generation]** The previous turn will now be saved as last_turn.liberation when submitting mission results. This is often essential for debugging bug reports. **Include this file in the bug report whenever it is available.**
+* **[Modding]** Added support for the HMS Ariadne, Achilles, and Castle class.
+* **[Modding]** Added HMS Invincible to the game data as a helicopter carrier.
+
+## Fixes
+
+* **[Flight Planning]** Fixes CAS flights not having landing waypoints.
+* **[Mission Generation]** Airbase and FOB capture is no longer blocked by grounded aircraft / helicopters.
+* **[Squadrons]** Fixed the livery for the VF-33 F-14A squadron.
+* **[Theaters]** Fixed Channel campaigns not having data for land/sea/obstacle boundaries, causing front lines to extend into forests and water. Requires a new campaign to get the fix.
+* **[UI]** Fixed an issue where manual submit of mission results did not end the mission correctly.
+
 # 6.0.0
 
 Saves from 5.x are not compatible with 6.0.
@@ -16,6 +222,7 @@ Saves from 5.x are not compatible with 6.0.
 * **[Mission Generation]** Added performance option to not cull IADS when culling would affect how mission is played at target area.
 * **[Mission Generation]** Reworked the ground object generation which now uses a new layout system
 * **[Mission Generation]** Added information about the modulation (AM/FM) of the assigned frequencies to the kneeboard and assign AM modulation instead of FM for JTAC.
+* **[Mission Generation]** Added ice halos.
 * **[Mission Generation]** Adjusted wind speeds. Wind speeds at high altitude are generally higher now.
 * **[Mission Generation]** Added turbulence. Higher in Summer and Winter, also higher at day time than at nighttime.
 * **[Modding]** Updated UH-60L mod version support to 1.3.1

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,16 +62,26 @@
   },
   "devDependencies": {
     "@rtk-query/codegen-openapi": "^1.0.0",
-    "@trivago/prettier-plugin-sort-imports": "^3.3.0",
+    "@trivago/prettier-plugin-sort-imports": "^4.2.1",
     "@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",
+    "jest-transform-stub": "^2.0.0",
     "license-checker": "^25.0.1",
+    "msw": "^1.2.2",
     "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)$": "jest-transform-stub"
+    }
   }
 }

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[][];
@@ -497,7 +478,6 @@ export const {
   useSetControlPointDestinationMutation,
   useClearControlPointDestinationMutation,
   useGetDebugHoldZonesQuery,
-  useGetDebugIpZonesQuery,
   useGetDebugJoinZonesQuery,
   useListFlightsQuery,
   useGetFlightByIdQuery,

client/src/api/backend.ts

@@ -4,7 +4,10 @@ const backendAddr =
   new URL(window.location.toString()).searchParams.get("server") ??
   "[::1]:16880";
 
-export const HTTP_URL = `http://${backendAddr}/`;
+// MSW can't handle IPv6 URLs...
+// https://github.com/mswjs/msw/issues/1388
+export const HTTP_URL =
+  process.env.NODE_ENV === "test" ? "" : `http://${backendAddr}/`;
 
 export const backend = axios.create({
   baseURL: HTTP_URL,

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,146 @@
+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: "",
+            },
+          },
+        },
+      },
+    });
+    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: "",
+            },
+          },
+        },
+      },
+    });
+    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: "",
+            },
+          },
+        },
+      },
+    });
+    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,41 @@ 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?.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/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/splitlines/SplitLines.test.tsx

@@ -0,0 +1,16 @@
+import SplitLines from "./SplitLines";
+import { screen } from "@testing-library/dom";
+import { render } from "@testing-library/react";
+
+describe("SplitLines", () => {
+  it("joins items with line break tags", () => {
+    render(
+      <div data-testid={"container"}>
+        <SplitLines items={["foo", "bar", "baz"]} />
+      </div>
+    );
+
+    const container = screen.getByTestId("container");
+    expect(container).toContainHTML("foo<br />bar<br />baz<br />");
+  });
+});

client/src/components/supplyroute/SupplyRoute.test.tsx

@@ -0,0 +1,159 @@
+import { renderWithProviders } from "../../testutils";
+import SupplyRoute, { RouteColor } from "./SupplyRoute";
+import { screen } from "@testing-library/react";
+import { PropsWithChildren } from "react";
+
+const mockPolyline = jest.fn();
+jest.mock("react-leaflet", () => ({
+  Polyline: (props: PropsWithChildren<any>) => {
+    mockPolyline(props);
+    return <>{props.children}</>;
+  },
+  Tooltip: (props: PropsWithChildren<any>) => {
+    return <p data-testid="tooltip">{props.children}</p>;
+  },
+}));
+
+describe("SupplyRoute", () => {
+  it("is red when inactive and owned by opfor", () => {
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: [],
+          front_active: false,
+          is_sea: false,
+          blue: false,
+          active_transports: [],
+        }}
+      />
+    );
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        color: RouteColor.Red,
+      })
+    );
+  });
+
+  it("is blue when inactive and owned by bluefor", () => {
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: [],
+          front_active: false,
+          is_sea: false,
+          blue: true,
+          active_transports: [],
+        }}
+      />
+    );
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        color: RouteColor.Blue,
+      })
+    );
+  });
+
+  it("is orange when contested", () => {
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: [],
+          front_active: true,
+          is_sea: false,
+          blue: false,
+          active_transports: [],
+        }}
+      />
+    );
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        color: RouteColor.Contested,
+      })
+    );
+  });
+
+  it("is highlighted when the route has active transports", () => {
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: [],
+          front_active: false,
+          is_sea: false,
+          blue: false,
+          active_transports: ["foo"],
+        }}
+      />
+    );
+    expect(mockPolyline).toHaveBeenCalledTimes(2);
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        color: RouteColor.Highlight,
+      })
+    );
+  });
+
+  it("is drawn in the right place", () => {
+    const points = [
+      { lat: 0, lng: 0 },
+      { lat: 1, lng: 1 },
+    ];
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: points,
+          front_active: false,
+          is_sea: false,
+          blue: false,
+          active_transports: ["foo"],
+        }}
+      />
+    );
+    expect(mockPolyline).toHaveBeenCalledTimes(2);
+    expect(mockPolyline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        positions: points,
+      })
+    );
+  });
+
+  it("has a tooltip describing an inactive supply route", () => {
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: [],
+          front_active: false,
+          is_sea: false,
+          blue: false,
+          active_transports: [],
+        }}
+      />
+    );
+
+    const tooltip = screen.getByTestId("tooltip");
+    expect(tooltip).toHaveTextContent("This supply route is inactive.");
+  });
+
+  it("has a tooltip describing active supply routes", () => {
+    renderWithProviders(
+      <SupplyRoute
+        route={{
+          id: "",
+          points: [],
+          front_active: false,
+          is_sea: false,
+          blue: false,
+          active_transports: ["foo", "bar"],
+        }}
+      />
+    );
+
+    const tooltip = screen.getByTestId("tooltip");
+    expect(tooltip).toContainHTML("foo<br />bar");
+  });
+});

client/src/components/supplyroute/SupplyRoute.tsx

@@ -4,6 +4,13 @@ import { Polyline as LPolyline } from "leaflet";
 import { useEffect, useRef } from "react";
 import { Polyline, Tooltip } from "react-leaflet";
 
+export enum RouteColor {
+  Blue = "#2d3e50",
+  Contested = "#c85050",
+  Highlight = "#ffffff",
+  Red = "#8c1414",
+}
+
 interface SupplyRouteProps {
   route: SupplyRouteModel;
 }
@@ -26,18 +33,22 @@ function ActiveSupplyRouteHighlight(props: SupplyRouteProps) {
   }
 
   return (
-    <Polyline positions={props.route.points} color={"#ffffff"} weight={2} />
+    <Polyline
+      positions={props.route.points}
+      color={RouteColor.Highlight}
+      weight={2}
+    />
   );
 }
 
 function colorFor(route: SupplyRouteModel) {
   if (route.front_active) {
-    return "#c85050";
+    return RouteColor.Contested;
   }
   if (route.blue) {
-    return "#2d3e50";
+    return RouteColor.Blue;
   }
-  return "#8c1414";
+  return RouteColor.Red;
 }
 
 export default function SupplyRoute(props: SupplyRouteProps) {

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/components/waypointmarker/WaypointMarker.test.tsx

@@ -0,0 +1,277 @@
+import { HTTP_URL } from "../../api/backend";
+import { renderWithProviders } from "../../testutils";
+import WaypointMarker, { TOOLTIP_ZOOM_LEVEL } from "./WaypointMarker";
+import { Map, Marker } from "leaflet";
+import { rest, MockedRequest, matchRequestUrl } from "msw";
+import { setupServer } from "msw/node";
+import React from "react";
+import { MapContainer } from "react-leaflet";
+
+// https://mswjs.io/docs/extensions/life-cycle-events#asserting-request-payload
+const waitForRequest = (method: string, url: string) => {
+  let requestId = "";
+
+  return new Promise<MockedRequest>((resolve, reject) => {
+    server.events.on("request:start", (req) => {
+      const matchesMethod = req.method.toLowerCase() === method.toLowerCase();
+      const matchesUrl = matchRequestUrl(req.url, url).matches;
+
+      if (matchesMethod && matchesUrl) {
+        requestId = req.id;
+      }
+    });
+
+    server.events.on("request:match", (req) => {
+      if (req.id === requestId) {
+        resolve(req);
+      }
+    });
+
+    server.events.on("request:unhandled", (req) => {
+      if (req.id === requestId) {
+        reject(
+          new Error(`The ${req.method} ${req.url.href} request was unhandled.`)
+        );
+      }
+    });
+  });
+};
+
+const server = setupServer(
+  rest.post(
+    `${HTTP_URL}/waypoints/:flightId/:waypointIdx/position`,
+    (req, res, ctx) => {
+      if (req.params.flightId === "") {
+        return res(ctx.status(500));
+      }
+      if (req.params.waypointIdx === "0") {
+        return res(ctx.status(403));
+      }
+      return res(ctx.status(204));
+    }
+  )
+);
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("WaypointMarker", () => {
+  it("is placed in the correct location", () => {
+    const waypoint = {
+      name: "",
+      position: { lat: 0, lng: 0 },
+      altitude_ft: 0,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "",
+    };
+    const marker = React.createRef<Marker>();
+    renderWithProviders(
+      <MapContainer>
+        <WaypointMarker
+          number={0}
+          waypoint={waypoint}
+          flight={{
+            id: "",
+            blue: true,
+            sidc: "",
+            waypoints: [waypoint],
+          }}
+          ref={marker}
+        />
+      </MapContainer>
+    );
+    expect(marker.current?.getLatLng()).toEqual({ lat: 0, lng: 0 });
+  });
+
+  it("tooltip is hidden when zoomed out", () => {
+    const waypoint = {
+      name: "",
+      position: { lat: 0, lng: 0 },
+      altitude_ft: 0,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "",
+    };
+    const map = React.createRef<Map>();
+    const marker = React.createRef<Marker>();
+    renderWithProviders(
+      <MapContainer zoom={0} ref={map}>
+        <WaypointMarker
+          number={0}
+          waypoint={waypoint}
+          flight={{
+            id: "",
+            blue: true,
+            sidc: "",
+            waypoints: [waypoint],
+          }}
+          ref={marker}
+        />
+      </MapContainer>
+    );
+    map.current?.setView({ lat: 0, lng: 0 }, TOOLTIP_ZOOM_LEVEL - 1);
+    expect(marker.current?.getTooltip()?.isOpen()).toBeFalsy();
+  });
+
+  it("tooltip is shown when zoomed in", () => {
+    const waypoint = {
+      name: "",
+      position: { lat: 0, lng: 0 },
+      altitude_ft: 0,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "",
+    };
+    const map = React.createRef<Map>();
+    const marker = React.createRef<Marker>();
+    renderWithProviders(
+      <MapContainer ref={map}>
+        <WaypointMarker
+          number={0}
+          waypoint={waypoint}
+          flight={{
+            id: "",
+            blue: true,
+            sidc: "",
+            waypoints: [waypoint],
+          }}
+          ref={marker}
+        />
+      </MapContainer>
+    );
+    map.current?.setView({ lat: 0, lng: 0 }, TOOLTIP_ZOOM_LEVEL);
+    expect(marker.current?.getTooltip()?.isOpen()).toBeTruthy();
+  });
+
+  it("tooltip has correct contents", () => {
+    const waypoint = {
+      name: "",
+      position: { lat: 0, lng: 0 },
+      altitude_ft: 25000,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "09:00:00",
+    };
+    const map = React.createRef<Map>();
+    const marker = React.createRef<Marker>();
+    renderWithProviders(
+      <MapContainer ref={map}>
+        <WaypointMarker
+          number={0}
+          waypoint={waypoint}
+          flight={{
+            id: "",
+            blue: true,
+            sidc: "",
+            waypoints: [waypoint],
+          }}
+          ref={marker}
+        />
+      </MapContainer>
+    );
+    expect(marker.current?.getTooltip()?.getContent()).toEqual(
+      "0 <br />25000 ft MSL<br />09:00:00"
+    );
+  });
+
+  it("resets the tooltip while dragging", () => {
+    const waypoint = {
+      name: "",
+      position: { lat: 0, lng: 0 },
+      altitude_ft: 25000,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "09:00:00",
+    };
+    const marker = React.createRef<Marker>();
+    renderWithProviders(
+      <MapContainer>
+        <WaypointMarker
+          number={0}
+          waypoint={waypoint}
+          flight={{
+            id: "",
+            blue: true,
+            sidc: "",
+            waypoints: [waypoint],
+          }}
+          ref={marker}
+        />
+      </MapContainer>
+    );
+    marker.current?.fireEvent("dragstart");
+    expect(marker.current?.getTooltip()?.getContent()).toEqual(
+      "Waiting to recompute TOT..."
+    );
+  });
+
+  it("sends the new position to the backend on dragend", async () => {
+    const departure = {
+      name: "",
+      position: { lat: 0, lng: 0 },
+      altitude_ft: 25000,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "09:00:00",
+    };
+    const waypoint = {
+      name: "",
+      position: { lat: 1, lng: 1 },
+      altitude_ft: 25000,
+      altitude_reference: "MSL",
+      is_movable: false,
+      should_mark: false,
+      include_in_path: true,
+      timing: "09:00:00",
+    };
+    const flight = {
+      id: "1234",
+      blue: true,
+      sidc: "",
+      waypoints: [departure, waypoint],
+    };
+    const marker = React.createRef<Marker>();
+
+    // There is no observable UI change from moving a waypoint, just a message
+    // to the backend to record the frontend change. The real backend will then
+    // push an updated game state which will update redux, but that's not part
+    // of this component's behavior.
+    const pendingRequest = waitForRequest(
+      "POST",
+      `${HTTP_URL}/waypoints/1234/1/position`
+    );
+
+    renderWithProviders(
+      <MapContainer>
+        <WaypointMarker number={0} waypoint={departure} flight={flight} />
+        <WaypointMarker
+          number={1}
+          waypoint={waypoint}
+          flight={flight}
+          ref={marker}
+        />
+      </MapContainer>
+    );
+
+    marker.current?.fireEvent("dragstart");
+    marker.current?.fireEvent("dragend", { target: marker.current });
+
+    const request = await pendingRequest;
+    const response = await request.json();
+    expect(response).toEqual({ lat: 1, lng: 1 });
+  });
+});

client/src/components/waypointmarker/WaypointMarker.tsx

@@ -3,13 +3,23 @@ import {
   Waypoint,
   useSetWaypointPositionMutation,
 } from "../../api/liberationApi";
+import mergeRefs from "../../mergeRefs";
 import { Icon } from "leaflet";
 import { Marker as LMarker } from "leaflet";
 import icon from "leaflet/dist/images/marker-icon.png";
 import iconShadow from "leaflet/dist/images/marker-shadow.png";
-import { MutableRefObject, useCallback, useEffect, useRef } from "react";
+import {
+  ForwardedRef,
+  MutableRefObject,
+  forwardRef,
+  useCallback,
+  useEffect,
+  useRef,
+} from "react";
 import { Marker, Tooltip, useMap, useMapEvent } from "react-leaflet";
 
+export const TOOLTIP_ZOOM_LEVEL = 9;
+
 const WAYPOINT_ICON = new Icon({
   iconUrl: icon,
   shadowUrl: iconShadow,
@@ -22,84 +32,84 @@ interface WaypointMarkerProps {
   flight: Flight;
 }
 
-const WaypointMarker = (props: WaypointMarkerProps) => {
-  // Most props of react-leaflet types are immutable and components will not
-  // update to account for changes, so we can't simply use the `permanent`
-  // property of the tooltip to control tooltip visibility based on the zoom
-  // level.
-  //
-  // On top of that, listening for zoom changes and opening/closing is not
-  // sufficient because clicking anywhere will close any opened tooltips (even
-  // if they are permanent; once openTooltip has been called that seems to no
-  // longer have any effect).
-  //
-  // Instead, listen for zoom changes and rebind the tooltip when the zoom level
-  // changes.
-  const map = useMap();
-  const marker: MutableRefObject<LMarker | undefined> = useRef();
+const WaypointMarker = forwardRef(
+  (props: WaypointMarkerProps, ref: ForwardedRef<LMarker>) => {
+    // Most props of react-leaflet types are immutable and components will not
+    // update to account for changes, so we can't simply use the `permanent`
+    // property of the tooltip to control tooltip visibility based on the zoom
+    // level.
+    //
+    // On top of that, listening for zoom changes and opening/closing is not
+    // sufficient because clicking anywhere will close any opened tooltips (even
+    // if they are permanent; once openTooltip has been called that seems to no
+    // longer have any effect).
+    //
+    // Instead, listen for zoom changes and rebind the tooltip when the zoom level
+    // changes.
+    const map = useMap();
+    const marker: MutableRefObject<LMarker | null> = useRef(null);
 
-  const [putDestination] = useSetWaypointPositionMutation();
+    const [putDestination] = useSetWaypointPositionMutation();
 
-  const rebindTooltip = useCallback(() => {
-    if (marker.current === undefined) {
-      return;
-    }
+    const rebindTooltip = useCallback(() => {
+      if (marker.current === null) {
+        return;
+      }
 
-    const tooltip = marker.current.getTooltip();
-    if (tooltip === undefined) {
-      return;
-    }
+      const tooltip = marker.current.getTooltip();
+      if (tooltip === undefined) {
+        return;
+      }
 
-    const permanent = map.getZoom() >= 9;
-    marker.current
-      .unbindTooltip()
-      .bindTooltip(tooltip, { permanent: permanent });
-  }, [map]);
-  useMapEvent("zoomend", rebindTooltip);
+      const permanent = map.getZoom() >= TOOLTIP_ZOOM_LEVEL;
+      marker.current
+        .unbindTooltip()
+        .bindTooltip(tooltip, { permanent: permanent });
+    }, [map]);
+    useMapEvent("zoomend", rebindTooltip);
+
+    useEffect(() => {
+      const waypoint = props.waypoint;
+      marker.current?.setTooltipContent(
+        `${props.number} ${waypoint.name}<br />` +
+          `${waypoint.altitude_ft.toFixed()} ft ${
+            waypoint.altitude_reference
+          }<br />` +
+          waypoint.timing
+      );
+    });
 
-  useEffect(() => {
     const waypoint = props.waypoint;
-    marker.current?.setTooltipContent(
-      `${props.number} ${waypoint.name}<br />` +
-        `${waypoint.altitude_ft.toFixed()} ft ${waypoint.altitude_reference}<br />` +
-        waypoint.timing
+    return (
+      <Marker
+        position={waypoint.position}
+        icon={WAYPOINT_ICON}
+        draggable
+        eventHandlers={{
+          dragstart: (e) => {
+            const m: LMarker = e.target;
+            m.setTooltipContent("Waiting to recompute TOT...");
+          },
+          dragend: async (e) => {
+            const m: LMarker = e.target;
+            const destination = m.getLatLng();
+            try {
+              await putDestination({
+                flightId: props.flight.id,
+                waypointIdx: props.number,
+                leafletPoint: { lat: destination.lat, lng: destination.lng },
+              });
+            } catch (e) {
+              console.error("Failed to set waypoint position", e);
+            }
+          },
+        }}
+        ref={mergeRefs(ref, marker)}
+      >
+        <Tooltip position={waypoint.position} />
+      </Marker>
     );
-  });
-
-  const waypoint = props.waypoint;
-  return (
-    <Marker
-      position={waypoint.position}
-      icon={WAYPOINT_ICON}
-      draggable
-      eventHandlers={{
-        dragstart: (e) => {
-          const m: LMarker = e.target;
-          m.setTooltipContent("Waiting to recompute TOT...");
-        },
-        dragend: async (e) => {
-          const m: LMarker = e.target;
-          const destination = m.getLatLng();
-          try {
-            await putDestination({
-              flightId: props.flight.id,
-              waypointIdx: props.number,
-              leafletPoint: { lat: destination.lat, lng: destination.lng },
-            });
-          } catch (e) {
-            console.error("Failed to set waypoint position", e);
-          }
-        },
-      }}
-      ref={(ref) => {
-        if (ref != null) {
-          marker.current = ref;
-        }
-      }}
-    >
-      <Tooltip position={waypoint.position} />
-    </Marker>
-  );
-};
+  }
+);
 
 export default WaypointMarker;

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/mergeRefs.test.tsx

@@ -0,0 +1,17 @@
+import mergeRefs from "./mergeRefs";
+
+describe("mergeRefs", () => {
+  it("merges all kinds of refs", () => {
+    const referent = "foobar";
+    const ref = { current: null };
+    var callbackResult = null;
+    const callbackRef = (node: string | null) => {
+      if (node != null) {
+        callbackResult = node;
+      }
+    };
+    mergeRefs(ref, callbackRef)(referent);
+    expect(callbackResult).toEqual("foobar");
+    expect(ref.current).toEqual("foobar");
+  });
+});

client/src/mergeRefs.ts

@@ -0,0 +1,16 @@
+import { ForwardedRef } from "react";
+
+const mergeRefs = <T extends any>(...refs: ForwardedRef<T>[]) => {
+  return (node: T) => {
+    for (const ref of refs) {
+      if (ref == null) {
+      } else if (typeof ref === "function") {
+        ref(node);
+      } else {
+        ref.current = node;
+      }
+    }
+  };
+};
+
+export default mergeRefs;

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 Liberation"
+copyright = "2023, DCS Liberation Team"
+author = "DCS Liberation Team"
+release = "10.0.0"
+
+# -- 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

@@ -10,19 +10,18 @@ import yaml
 from dcs.unittype import ShipType, StaticType, UnitType as DcsUnitType, VehicleType
 
 from game.data.groups import GroupTask
-from game.data.radar_db import UNITS_WITH_RADAR
 from game.dcs.groundunittype import GroundUnitType
 from game.dcs.helpers import static_type_from_name
 from game.dcs.shipunittype import ShipUnitType
 from game.dcs.unittype import UnitType
+from game.layout import LAYOUTS
+from game.layout.layout import TgoLayout, TgoLayoutUnitGroup
+from game.point_with_heading import PointWithHeading
 from game.theater.theatergroundobject import (
     IadsGroundObject,
     IadsBuildingGroundObject,
     NavalGroundObject,
 )
-from game.layout import LAYOUTS
-from game.layout.layout import TgoLayout, TgoLayoutUnitGroup
-from game.point_with_heading import PointWithHeading
 from game.theater.theatergroup import IadsGroundGroup, IadsRole, TheaterGroup
 from game.utils import escape_string_for_lua
 
@@ -288,7 +287,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/ai_flight_planner_db.py

@@ -1,627 +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,
-    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,
-    E_2C,
-    E_3A,
-    FA_18C_hornet,
-    FW_190A8,
-    FW_190D9,
-    F_117A,
-    F_14A_135_GR,
-    F_14B,
-    F_15C,
-    F_15E,
-    F_16A,
-    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,
-    MB_339A,
-    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_F1CT,
-    Mirage_F1C_200,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    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,
-)
-from dcs.unittype import FlyingType
-
-from game.dcs.aircrafttype import AircraftType
-from pydcs_extensions.a4ec.a4ec import A_4E_C
-from pydcs_extensions.f104.f104 import VSN_F104G, VSN_F104S, VSN_F104S_AG
-from pydcs_extensions.f22a.f22a import F_22A
-from pydcs_extensions.hercules.hercules import Hercules
-from pydcs_extensions.jas39.jas39 import JAS39Gripen, JAS39Gripen_AG
-from pydcs_extensions.ov10a.ov10a import Bronco_OV_10A
-from pydcs_extensions.su57.su57 import Su_57
-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
-CAP_CAPABLE = [
-    Su_57,
-    F_22A,
-    F_15C,
-    F_14B,
-    F_14A_135_GR,
-    Su_33,
-    J_11A,
-    Su_30,
-    Su_27,
-    MiG_29S,
-    F_16C_50,
-    FA_18C_hornet,
-    JF_17,
-    JAS39Gripen,
-    F_16A,
-    F_4E,
-    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,
-    MiG_19P,
-    A_4E_C,
-    F_86F_Sabre,
-    MiG_15bis,
-    C_101CC,
-    L_39ZA,
-    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,
-]
-
-
-# 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_15E,
-    F_16C_50,
-    FA_18C_hornet,
-    Tornado_GR4,
-    Tornado_IDS,
-    JAS39Gripen_AG,
-    JF_17,
-    AV8BNA,
-    A_10A,
-    B_1B,
-    A_4E_C,
-    Bronco_OV_10A,
-    F_14B,
-    F_14A_135_GR,
-    AJS37,
-    Su_24M,
-    Su_17M4,
-    Su_33,
-    F_4E,
-    S_3B,
-    Su_30,
-    MiG_29S,
-    MiG_27K,
-    MiG_29A,
-    MiG_21Bis,
-    AH_64D_BLK_II,
-    AH_64D,
-    AH_64A,
-    AH_1W,
-    OH_58D,
-    SA342M,
-    SA342L,
-    Ka_50,
-    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,
-    MB_339A,
-    C_101CC,
-    L_39ZA,
-    UH_1H,
-    VSN_F104S_AG,
-    VSN_F104G,
-    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,
-]
-
-
-# Aircraft used for SEAD and SEAD Escort tasks. Must be capable of the CAS DCS task.
-SEAD_CAPABLE = [
-    JF_17,
-    F_16C_50,
-    FA_18C_hornet,
-    Tornado_IDS,
-    Su_25T,
-    Su_25TM,
-    F_4E,
-    A_4E_C,
-    F_14B,
-    F_14A_135_GR,
-    JAS39Gripen_AG,
-    AV8BNA,
-    Su_24M,
-    Su_17M4,
-    Su_34,
-    Su_30,
-    MiG_27K,
-    Tornado_GR4,
-]
-
-
-# Aircraft used for DEAD tasks. Must be capable of the CAS DCS task.
-DEAD_CAPABLE = SEAD_CAPABLE + [
-    AJS37,
-    F_14B,
-    F_14A_135_GR,
-    JAS39Gripen_AG,
-    B_1B,
-    B_52H,
-    Tu_160,
-    Tu_95MS,
-    H_6J,
-    A_20G,
-    Ju_88A4,
-    VSN_F104S_AG,
-    VSN_F104G,
-    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,
-]
-
-
-# Aircraft used for Strike mission
-STRIKE_CAPABLE = [
-    F_117A,
-    B_1B,
-    B_52H,
-    Tu_160,
-    Tu_95MS,
-    Tu_22M3,
-    H_6J,
-    F_15E,
-    AJS37,
-    Tornado_GR4,
-    F_16C_50,
-    FA_18C_hornet,
-    AV8BNA,
-    JF_17,
-    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_27,
-    MiG_29S,
-    MiG_29G,
-    MiG_29A,
-    F_4E,
-    A_10C_2,
-    A_10C,
-    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,
-    MB_339A,
-    C_101CC,
-    L_39ZA,
-    B_17G,
-    A_20G,
-    Ju_88A4,
-    VSN_F104S_AG,
-    VSN_F104G,
-    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,
-]
-
-
-ANTISHIP_CAPABLE = [
-    AJS37,
-    Tu_142,
-    Tu_22M3,
-    H_6J,
-    FA_18C_hornet,
-    JAS39Gripen_AG,
-    Su_24M,
-    Su_17M4,
-    JF_17,
-    Su_34,
-    Su_30,
-    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,
-    Su_34,
-    Su_30,
-    Tornado_IDS,
-    M_2000C,
-    H_6J,
-    B_1B,
-    B_52H,
-    Tu_22M3,
-    H_6J,
-    F_15E,
-    AJS37,
-    F_16C_50,
-    FA_18C_hornet,
-    AV8BNA,
-    JF_17,
-    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_27,
-    MiG_29S,
-    MiG_29G,
-    MiG_29A,
-    F_4E,
-    A_10C_2,
-    A_10C,
-    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,
-    MB_339A,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    B_17G,
-    A_20G,
-    Ju_88A4,
-    VSN_F104S_AG,
-    VSN_F104G,
-    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,
-]
-
-# 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,
-    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_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 CAP_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,16 +1,17 @@
 from __future__ import annotations
 
 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
 
+from .flightmembers import FlightMembers
 from .flightroster import FlightRoster
 from .flightstate import FlightState, Navigating, Uninitialized
 from .flightstate.killed import Killed
-from .loadouts import Loadout
 from ..sidc import (
     Entity,
     SidcDescribable,
@@ -26,6 +27,8 @@ if TYPE_CHECKING:
     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
@@ -52,17 +55,16 @@ class Flight(SidcDescribable):
         self.country = country
         self.coalition = squadron.coalition
         self.squadron = squadron
+        self.flight_type = flight_type
         self.squadron.claim_inventory(count)
         if roster is None:
-            self.roster = FlightRoster(self.squadron, initial_size=count)
+            self.roster = FlightMembers(self, initial_size=count)
         else:
-            self.roster = roster
+            self.roster = FlightMembers.from_roster(self, roster)
         self.divert = divert
-        self.flight_type = flight_type
-        self.loadout = Loadout.default_for(self)
         self.start_type = start_type
-        self.use_custom_loadout = False
         self.custom_name = custom_name
+        self.use_same_loadout_for_all_members = True
 
         # Only used by transport missions.
         self.cargo = cargo
@@ -95,6 +97,13 @@ class Flight(SidcDescribable):
 
         self._flight_plan_builder = CustomBuilder(self, self.flight_plan.waypoints[1:])
         self.recreate_flight_plan()
+        # We need to clear the existing actions/options when moving the waypoints into
+        # the new flight plan because the actions/options that are currently set will be
+        # the actions of whatever flight plan was previously used.
+        # https://github.com/dcs-liberation/dcs_liberation/issues/3189
+        for waypoint in self.flight_plan.iter_waypoints():
+            waypoint.actions.clear()
+            waypoint.options.clear()
 
     def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
@@ -149,10 +158,6 @@ class Flight(SidcDescribable):
     def is_helo(self) -> bool:
         return self.unit_type.dcs_unit_type.helicopter
 
-    @property
-    def from_cp(self) -> ControlPoint:
-        return self.departure
-
     @property
     def points(self) -> List[FlightWaypoint]:
         return self.flight_plan.waypoints[1:]
@@ -171,6 +176,18 @@ class Flight(SidcDescribable):
     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)
@@ -187,6 +204,11 @@ class Flight(SidcDescribable):
             return unit_type.fuel_max * 0.5
         return None
 
+    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:
         if self.custom_name:
             return f"{self.custom_name} {self.count} x {self.unit_type}"
@@ -247,9 +269,9 @@ class Flight(SidcDescribable):
             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)

game/ato/flightmember.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+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 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,91 @@
+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
+
+if TYPE_CHECKING:
+    from game.squadrons import Pilot
+    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)
+
+    @staticmethod
+    def from_roster(flight: Flight, roster: FlightRoster) -> FlightMembers:
+        members = FlightMembers(flight)
+        loadout = Loadout.default_for(flight)
+        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)
+        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

@@ -90,5 +90,5 @@ class Builder(IBuilder[AewcFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    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,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime
 from typing import Iterator, TYPE_CHECKING, Type
 
 from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
@@ -55,12 +55,12 @@ class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout], UiZoneDisplay):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.drop_off
 
-    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.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
@@ -68,7 +68,11 @@ 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:
@@ -148,5 +152,5 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> AirAssaultFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AirAssaultFlightPlan:
         return AirAssaultFlightPlan(self.flight, self.layout())

game/ato/flightplans/airlift.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.theater.missiontarget import MissionTarget
@@ -67,16 +67,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
 
 
@@ -151,5 +155,5 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> AirliftFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AirliftFlightPlan:
         return AirliftFlightPlan(self.flight, self.layout())

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

@@ -66,5 +66,5 @@ class Builder(CapBuilder[BarCapFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> BarCapFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> BarCapFlightPlan:
         return BarCapFlightPlan(self.flight, self.layout())

game/ato/flightplans/capbuilder.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import random
 from abc import ABC
 from typing import Any, TYPE_CHECKING, TypeVar
@@ -26,6 +27,9 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
         self, location: MissionTarget, barcap: bool
     ) -> tuple[Point, Point]:
         closest_cache = ObjectiveDistanceCache.get_closest_airfields(location)
+        closest_friendly_field = (
+            None  # keep track of closest frieldly airfield in case we need it
+        )
         for airfield in closest_cache.operational_airfields:
             # If the mission is a BARCAP of an enemy airfield, find the *next*
             # closest enemy airfield.
@@ -34,8 +38,43 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             if airfield.captured != self.is_player:
                 closest_airfield = airfield
                 break
+            elif closest_friendly_field is None:
+                closest_friendly_field = airfield
         else:
-            raise PlanningError("Could not find any enemy airfields")
+            if barcap:
+                # If planning a BARCAP, we should be able to find at least one enemy
+                # airfield. If we can't, it's an error.
+                raise PlanningError("Could not find any enemy airfields")
+            else:
+                # if we cannot find any friendly or enemy airfields other than the target,
+                # there's nothing we can do
+                if closest_friendly_field is None:
+                    raise PlanningError(
+                        "Could not find any enemy or friendly airfields"
+                    )
+
+                # If planning other race tracks (TARCAPs, currently), the target may be
+                # the only enemy airfield. In this case, set the race track orientation using
+                # a virtual point equi-distant from but opposite to the target from the closest
+                # friendly airfield like below, where F is the closest friendly airfield, T is
+                # the sole enemy airfield and V the virtual point
+                #
+                # F ---- T ----- V
+                #
+                # We need to create this virtual point, rather than using F to make sure
+                # the race track is aligned towards the target.
+                closest_friendly_field_position = copy.deepcopy(
+                    closest_friendly_field.position
+                )
+                closest_airfield = closest_friendly_field
+                closest_airfield.position.x = (
+                    2 * self.package.target.position.x
+                    - closest_friendly_field_position.x
+                )
+                closest_airfield.position.y = (
+                    2 * self.package.target.position.y
+                    - closest_friendly_field_position.y
+                )
 
         heading = Heading.from_degrees(
             location.position.heading_between_point(closest_airfield.position)

game/ato/flightplans/cas.py

@@ -6,13 +6,15 @@ 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, meters, dcs_to_shapely_point
 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 ...persistence.paths import waypoint_debug_directory
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
@@ -20,16 +22,16 @@ if TYPE_CHECKING:
 
 @dataclass(frozen=True)
 class CasLayout(PatrollingLayout):
-    target: FlightWaypoint
+    ingress: FlightWaypoint
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to
+        yield self.ingress
         yield self.patrol_start
-        yield self.target
         yield self.patrol_end
         yield from self.nav_from
-        yield self.departure
+        yield self.arrival
         if self.divert is not None:
             yield self.divert
         yield self.bullseye
@@ -59,23 +61,20 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
 
     @property
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
-        return {self.layout.patrol_start, self.layout.target, self.layout.patrol_end}
-
-    def request_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.patrol_start
-
-    def dismiss_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.patrol_end
+        return {self.layout.ingress, self.layout.patrol_start, 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):
@@ -86,46 +85,79 @@ class Builder(IBuilder[CasFlightPlan, CasLayout]):
         )
 
         bounds = FrontLineConflictDescription.frontline_bounds(location, self.theater)
-        ingress = bounds.left_position
-        center = bounds.center
-        egress = bounds.right_position
+        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)
 
         is_helo = self.flight.unit_type.dcs_unit_type.helicopter
-        ingress_egress_altitude = (
-            self.doctrine.ingress_altitude if not is_helo else meters(50)
+        patrol_altitude = self.doctrine.ingress_altitude if not is_helo else meters(50)
+        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, patrol_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_start_waypoint.wants_escort = True
+
+        patrol_end_waypoint = builder.nav(
+            patrol_end, patrol_altitude, use_agl_patrol_altitude
+        )
+        patrol_end_waypoint.name = "FLOT END"
+        patrol_end_waypoint.pretty_name = "FLOT end"
+        patrol_end_waypoint.description = "FLOT boundary"
+        patrol_end_waypoint.wants_escort = True
+
+        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_egress_altitude,
-                use_agl_ingress_egress,
+                ingress_point,
+                patrol_altitude,
+                use_agl_patrol_altitude,
             ),
             nav_from=builder.nav_path(
-                egress,
+                patrol_end,
                 self.flight.arrival.position,
-                ingress_egress_altitude,
-                use_agl_ingress_egress,
+                patrol_altitude,
+                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(),
         )
 
-    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
@@ -42,16 +42,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 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
 
 
@@ -68,5 +72,5 @@ class Builder(IBuilder[CustomFlightPlan, CustomLayout]):
         builder = WaypointBuilder(self.flight, self.coalition)
         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

@@ -50,5 +50,5 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
             bullseye=builder.bullseye(),
         )
 
-    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
@@ -37,16 +37,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
 
 
@@ -79,5 +83,5 @@ class Builder(IBuilder[FerryFlightPlan, FerryLayout]):
             bullseye=builder.bullseye(),
         )
 
-    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,14 +30,6 @@ 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)
 class Layout(ABC):
@@ -62,6 +52,7 @@ 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()
 
     @property
     def package(self) -> Package:
@@ -149,42 +140,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.
@@ -195,8 +153,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
@@ -214,70 +171,70 @@ 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:
-        return None
+        try:
+            return next(self.escorted_waypoints())
+        except StopIteration:
+            return None
 
     def dismiss_escort_at(self) -> FlightWaypoint | None:
-        return None
+        try:
+            return list(self.escorted_waypoints())[-1]
+        except IndexError:
+            return None
 
     def escorted_waypoints(self) -> Iterator[FlightWaypoint]:
-        begin = self.request_escort_at()
-        end = self.dismiss_escort_at()
-        if begin is None or end is None:
-            return
-        escorting = False
-        for waypoint in self.waypoints:
-            if waypoint == begin:
-                escorting = True
-            if escorting:
+        for waypoint in self.iter_waypoints():
+            if waypoint.wants_escort:
                 yield waypoint
-            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()
         )
 
-        # 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()
+        )
 
     def estimate_startup(self) -> timedelta:
         if self.flight.start_type is StartType.COLD:
@@ -291,18 +248,30 @@ 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:
             return timedelta(minutes=2)
         else:
             return timedelta(minutes=8)
 
     @property
-    def mission_departure_time(self) -> timedelta:
+    @abstractmethod
+    def mission_begin_on_station_time(self) -> datetime | None:
+        """The time that the mission is first on-station.
+
+        Not all mission types will have a time when they can be considered on-station.
+        Missions that patrol or loiter (CAPs, CAS, refueling, AEW&C, etc) will have this
+        defined, but strike-like missions will not.
+        """
+
+    @property
+    def mission_departure_time(self) -> datetime:
         """The time that the mission is complete and the flight RTBs."""
         raise NotImplementedError
 
     @self_type_guard
-    def is_loiter(self, flight_plan: FlightPlan[Any]) -> TypeGuard[LoiterFlightPlan]:
+    def is_loiter(
+        self, flight_plan: FlightPlan[Any]
+    ) -> TypeGuard[LoiterFlightPlan[Any]]:
         return False
 
     @self_type_guard
@@ -314,5 +283,8 @@ class FlightPlan(ABC, Generic[LayoutT]):
     @self_type_guard
     def is_formation(
         self, flight_plan: FlightPlan[Any]
-    ) -> TypeGuard[FormationFlightPlan]:
+    ) -> TypeGuard[FormationFlightPlan[Any]]:
         return False
+
+    def add_waypoint_actions(self) -> None:
+        pass

game/ato/flightplans/flightplanbuildertypes.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from typing import Any, TYPE_CHECKING, Type
 
 from game.ato import FlightType
+from game.theater.controlpoint import NavalControlPoint
+from game.theater.frontline import FrontLine
 from .aewc import AewcFlightPlan
 from .airassault import AirAssaultFlightPlan
 from .airlift import AirliftFlightPlan
@@ -19,6 +21,7 @@ from .ocarunway import OcaRunwayFlightPlan
 from .packagerefueling import PackageRefuelingFlightPlan
 from .planningerror import PlanningError
 from .sead import SeadFlightPlan
+from .shiprecoverytanker import RecoveryTankerFlightPlan
 from .strike import StrikeFlightPlan
 from .sweep import SweepFlightPlan
 from .tarcap import TarCapFlightPlan
@@ -26,15 +29,19 @@ from .theaterrefueling import TheaterRefuelingFlightPlan
 
 if TYPE_CHECKING:
     from game.ato import Flight
-    from game.theater import FrontLine
 
 
 class FlightPlanBuilderTypes:
     @staticmethod
     def for_flight(flight: Flight) -> Type[IBuilder[Any, Any]]:
         if flight.flight_type is FlightType.REFUELING:
-            if flight.package.target.is_friendly(flight.squadron.player) or isinstance(
-                flight.package.target, FrontLine
+            target = flight.package.target
+            if target.is_friendly(flight.squadron.player) and isinstance(
+                target, NavalControlPoint
+            ):
+                return RecoveryTankerFlightPlan.builder_type()
+            if target.is_friendly(flight.squadron.player) or isinstance(
+                target, FrontLine
             ):
                 return TheaterRefuelingFlightPlan.builder_type()
             return PackageRefuelingFlightPlan.builder_type()

game/ato/flightplans/formation.py

@@ -2,15 +2,14 @@ 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, TypeVar
 
 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
@@ -25,7 +24,10 @@ class FormationLayout(LoiterLayout, ABC):
     nav_from: list[FlightWaypoint]
 
 
-class FormationFlightPlan(LoiterFlightPlan, ABC):
+LayoutT = TypeVar("LayoutT", bound=FormationLayout)
+
+
+class FormationFlightPlan(LoiterFlightPlan[LayoutT], ABC):
     @property
     @abstractmethod
     def package_speed_waypoints(self) -> set[FlightWaypoint]:
@@ -35,12 +37,6 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
         return self.package_speed_waypoints
 
-    def request_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.join
-
-    def dismiss_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.split
-
     @cached_property
     def best_flight_formation_speed(self) -> Speed:
         """The best speed this flight is capable at all formation waypoints.
@@ -73,15 +69,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,19 +85,21 @@ 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:
+        return self.join_time - self.travel_time_between_waypoints(
+            self.layout.hold, self.layout.join
         )
 
     @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
     def is_formation(
         self, flight_plan: FlightPlan[Any]
-    ) -> TypeGuard[FormationFlightPlan]:
+    ) -> TypeGuard[FormationFlightPlan[Any]]:
         return True

game/ato/flightplans/formationattack.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from abc import ABC
 from collections.abc import Iterator
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, TypeVar
 
 from dcs import Point
@@ -14,7 +14,6 @@ from game.utils import Speed, meters
 from .flightplan import FlightPlan
 from .formation import FormationFlightPlan, FormationLayout
 from .ibuilder import IBuilder
-from .planningerror import PlanningError
 from .waypointbuilder import StrikeTarget, WaypointBuilder
 from .. import FlightType
 from ..flightwaypoint import FlightWaypoint
@@ -24,112 +23,6 @@ if TYPE_CHECKING:
     from ..flight import Flight
 
 
-class FormationAttackFlightPlan(FormationFlightPlan, ABC):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta()
-
-    @property
-    def package_speed_waypoints(self) -> set[FlightWaypoint]:
-        return {
-            self.layout.ingress,
-            self.layout.split,
-        } | set(self.layout.targets)
-
-    def speed_between_waypoints(self, a: FlightWaypoint, b: FlightWaypoint) -> Speed:
-        # FlightWaypoint is only comparable by identity, so adding
-        # target_area_waypoint to package_speed_waypoints is useless.
-        if b.waypoint_type == FlightWaypointType.TARGET_GROUP_LOC:
-            # Should be impossible, as any package with at least one
-            # FormationFlightPlan flight needs a formation speed.
-            assert self.package.formation_speed is not None
-            return self.package.formation_speed
-        return super().speed_between_waypoints(a, b)
-
-    @property
-    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(
-            "TARGET AREA",
-            FlightWaypointType.TARGET_GROUP_LOC,
-            self.package.target.position,
-            meters(0),
-            "RADIO",
-        )
-
-    @property
-    def travel_time_to_target(self) -> timedelta:
-        """The estimated time between the first waypoint and the target."""
-        destination = self.tot_waypoint
-        total = timedelta()
-        for previous_waypoint, waypoint in self.edges():
-            if waypoint == self.tot_waypoint:
-                # For anything strike-like the TOT waypoint is the *flight's*
-                # mission target, but to synchronize with the rest of the
-                # package we need to use the travel time to the same position as
-                # the others.
-                total += self.travel_time_between_waypoints(
-                    previous_waypoint, self.target_area_waypoint
-                )
-                break
-            total += self.travel_time_between_waypoints(previous_waypoint, waypoint)
-        else:
-            raise PlanningError(
-                f"Did not find destination waypoint {destination} in "
-                f"waypoints for {self.flight}"
-            )
-        return total
-
-    @property
-    def join_time(self) -> timedelta:
-        travel_time = self.travel_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(
-            self.layout.ingress, self.target_area_waypoint
-        )
-        travel_time_egress = self.travel_time_between_waypoints(
-            self.target_area_waypoint, self.layout.split
-        )
-        minutes_at_target = 0.75 * len(self.layout.targets)
-        timedelta_at_target = timedelta(minutes=minutes_at_target)
-        return (
-            self.ingress_time
-            + travel_time_ingress
-            + timedelta_at_target
-            + travel_time_egress
-        )
-
-    @property
-    def ingress_time(self) -> timedelta:
-        tot = self.tot
-        travel_time = self.travel_time_between_waypoints(
-            self.layout.ingress, self.target_area_waypoint
-        )
-        return tot - travel_time
-
-    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
-        if waypoint == self.layout.ingress:
-            return self.ingress_time
-        elif waypoint in self.layout.targets:
-            return self.tot
-        return super().tot_for_waypoint(waypoint)
-
-
 @dataclass(frozen=True)
 class FormationAttackLayout(FormationLayout):
     ingress: FlightWaypoint
@@ -152,6 +45,78 @@ class FormationAttackLayout(FormationLayout):
         yield self.bullseye
 
 
+class FormationAttackFlightPlan(FormationFlightPlan[FormationAttackLayout], ABC):
+    @property
+    def package_speed_waypoints(self) -> set[FlightWaypoint]:
+        return {
+            self.layout.ingress,
+            self.layout.split,
+        } | set(self.layout.targets)
+
+    def speed_between_waypoints(self, a: FlightWaypoint, b: FlightWaypoint) -> Speed:
+        # FlightWaypoint is only comparable by identity, so adding
+        # target_area_waypoint to package_speed_waypoints is useless.
+        if b.waypoint_type == FlightWaypointType.TARGET_GROUP_LOC:
+            # Should be impossible, as any package with at least one
+            # FormationFlightPlan flight needs a formation speed.
+            assert self.package.formation_speed is not None
+            return self.package.formation_speed
+        return super().speed_between_waypoints(a, b)
+
+    @property
+    def tot_waypoint(self) -> FlightWaypoint:
+        return self.layout.targets[0]
+
+    @property
+    def target_area_waypoint(self) -> FlightWaypoint:
+        return FlightWaypoint(
+            "TARGET AREA",
+            FlightWaypointType.TARGET_GROUP_LOC,
+            self.package.target.position,
+            meters(0),
+            "RADIO",
+        )
+
+    @property
+    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) -> datetime:
+        travel_time_ingress = self.total_time_between_waypoints(
+            self.layout.ingress, self.target_area_waypoint
+        )
+        travel_time_egress = self.total_time_between_waypoints(
+            self.target_area_waypoint, self.layout.split
+        )
+        minutes_at_target = 0.75 * len(self.layout.targets)
+        timedelta_at_target = timedelta(minutes=minutes_at_target)
+        return (
+            self.ingress_time
+            + travel_time_ingress
+            + timedelta_at_target
+            + travel_time_egress
+        )
+
+    @property
+    def ingress_time(self) -> datetime:
+        tot = self.tot
+        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) -> datetime | None:
+        if waypoint == self.layout.ingress:
+            return self.ingress_time
+        elif waypoint in self.layout.targets:
+            return self.tot
+        return super().tot_for_waypoint(waypoint)
+
+
 FlightPlanT = TypeVar("FlightPlanT", bound=FlightPlan[FormationAttackLayout])
 LayoutT = TypeVar("LayoutT", bound=FormationAttackLayout)
 
@@ -180,7 +145,18 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
 
         hold = builder.hold(self._hold_point())
         join = builder.join(self.package.waypoints.join)
+        join.wants_escort = True
+
+        ingress = builder.ingress(
+            ingress_type, self.package.waypoints.ingress, self.package.target
+        )
+        ingress.wants_escort = True
+
+        for target_waypoint in target_waypoints:
+            target_waypoint.wants_escort = True
+
         split = builder.split(self.package.waypoints.split)
+        split.wants_escort = True
         refuel = builder.refuel(self.package.waypoints.refuel)
 
         return FormationAttackLayout(
@@ -190,9 +166,7 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
                 hold.position, join.position, self.doctrine.ingress_altitude
             ),
             join=join,
-            ingress=builder.ingress(
-                ingress_type, self.package.waypoints.ingress, self.package.target
-            ),
+            ingress=ingress,
             targets=target_waypoints,
             split=split,
             refuel=refuel,

game/ato/flightplans/ibuilder.py

@@ -32,10 +32,11 @@ 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)
+            self._flight_plan.add_waypoint_actions()
         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,10 +2,12 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from datetime import timedelta
-from typing import Any, TYPE_CHECKING, TypeGuard
+from datetime import datetime, timedelta
+from typing import Any, TYPE_CHECKING, TypeGuard, TypeVar
 
+from game.flightplan.waypointactions.hold import Hold
 from game.typeguard import self_type_guard
+from game.utils import Speed
 from .flightplan import FlightPlan
 from .standard import StandardFlightPlan, StandardLayout
 
@@ -18,29 +20,44 @@ class LoiterLayout(StandardLayout, ABC):
     hold: FlightWaypoint
 
 
-class LoiterFlightPlan(StandardFlightPlan[Any], ABC):
+LayoutT = TypeVar("LayoutT", bound=LoiterLayout)
+
+
+class LoiterFlightPlan(StandardFlightPlan[LayoutT], ABC):
     @property
     def hold_duration(self) -> timedelta:
         return timedelta(minutes=5)
 
     @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
 
     @self_type_guard
-    def is_loiter(self, flight_plan: FlightPlan[Any]) -> TypeGuard[LoiterFlightPlan]:
+    def is_loiter(
+        self, flight_plan: FlightPlan[Any]
+    ) -> TypeGuard[LoiterFlightPlan[Any]]:
         return True
+
+    def provide_push_time(self) -> datetime:
+        return self.push_time
+
+    def add_waypoint_actions(self) -> None:
+        hold = self.layout.hold
+        speed = self.flight.unit_type.patrol_speed
+        if speed is None:
+            speed = Speed.from_mach(0.6, hold.alt)
+        hold.add_action(Hold(self.provide_push_time, hold.alt, speed))

game/ato/flightplans/ocaaircraft.py

@@ -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,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import timedelta
+from datetime import datetime, timedelta
 from typing import Type
 
 from dcs import Point
@@ -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
         )
 
@@ -121,5 +121,5 @@ class Builder(IBuilder[PackageRefuelingFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    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
@@ -61,22 +61,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 +90,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:
+        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
@@ -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]):
@@ -89,5 +93,5 @@ class Builder(IBuilder[RtbFlightPlan, RtbLayout]):
             bullseye=builder.bullseye(),
         )
 
-    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/shiprecoverytanker.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Iterator, Type
+
+from game.ato.flightplans.ibuilder import IBuilder
+from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
+from game.ato.flightplans.waypointbuilder import WaypointBuilder
+from game.ato.flightwaypoint import FlightWaypoint
+
+
+@dataclass(frozen=True)
+class RecoveryTankerLayout(StandardLayout):
+    nav_to: list[FlightWaypoint]
+    recovery_ship: FlightWaypoint
+    nav_from: list[FlightWaypoint]
+
+    def iter_waypoints(self) -> Iterator[FlightWaypoint]:
+        yield self.departure
+        yield from self.nav_to
+        yield self.recovery_ship
+        yield from self.nav_from
+        yield self.arrival
+        if self.divert is not None:
+            yield self.divert
+        yield self.bullseye
+
+
+class RecoveryTankerFlightPlan(StandardFlightPlan[RecoveryTankerLayout]):
+    @staticmethod
+    def builder_type() -> Type[Builder]:
+        return Builder
+
+    @property
+    def tot_waypoint(self) -> FlightWaypoint:
+        return self.layout.recovery_ship
+
+    @property
+    def mission_begin_on_station_time(self) -> datetime:
+        return self.package.time_over_target
+
+    @property
+    def mission_departure_time(self) -> datetime:
+        return self.patrol_end_time
+
+    @property
+    def patrol_start_time(self) -> datetime:
+        return self.package.time_over_target
+
+    @property
+    def patrol_end_time(self) -> datetime:
+        return self.tot + timedelta(hours=2)
+
+    def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
+        if waypoint == self.tot_waypoint:
+            return self.tot
+        return None
+
+    def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
+        if waypoint == self.tot_waypoint:
+            return self.mission_departure_time
+        return None
+
+
+class Builder(IBuilder[RecoveryTankerFlightPlan, RecoveryTankerLayout]):
+    def layout(self) -> RecoveryTankerLayout:
+        builder = WaypointBuilder(self.flight, self.coalition)
+
+        # TODO: Propagate the ship position to the Tanker's TOT,
+        # so that we minimize the tanker's need to catch up to the carrier.
+        recovery_ship = self.package.target.position
+        recovery_tanker = builder.recovery_tanker(recovery_ship)
+
+        # We don't have per aircraft cruise altitudes, so just reuse patrol altitude?
+        tanker_type = self.flight.unit_type
+        nav_cruise_altitude = tanker_type.preferred_patrol_altitude
+
+        return RecoveryTankerLayout(
+            departure=builder.takeoff(self.flight.departure),
+            nav_to=builder.nav_path(
+                self.flight.departure.position, recovery_ship, nav_cruise_altitude
+            ),
+            nav_from=builder.nav_path(
+                recovery_ship, self.flight.arrival.position, nav_cruise_altitude
+            ),
+            recovery_ship=recovery_tanker,
+            arrival=builder.land(self.flight.arrival),
+            divert=builder.divert(self.flight.divert),
+            bullseye=builder.bullseye(),
+        )
+
+    def build(self, dump_debug_info: bool = False) -> RecoveryTankerFlightPlan:
+        return RecoveryTankerFlightPlan(self.flight, self.layout())

game/ato/flightplans/strike.py

@@ -32,5 +32,5 @@ class Builder(FormationAttackBuilder[StrikeFlightPlan, FormationAttackLayout]):
 
         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,17 +1,19 @@
 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
+from dcs.task import Targets
 
-from game.utils import Heading
+from game.flightplan import HoldZoneGeometry
+from game.flightplan.waypointactions.engagetargets import EngageTargets
+from game.flightplan.waypointoptions.formation import Formation
+from game.utils import Heading, nautical_miles
 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
@@ -37,11 +39,7 @@ class SweepLayout(LoiterLayout):
         yield self.bullseye
 
 
-class SweepFlightPlan(LoiterFlightPlan):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=5)
-
+class SweepFlightPlan(LoiterFlightPlan[SweepLayout]):
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
@@ -54,44 +52,59 @@ 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
         )
 
-    def mission_departure_time(self) -> timedelta:
+    @property
+    def mission_begin_on_station_time(self) -> datetime | None:
+        return None
+
+    @property
+    def mission_departure_time(self) -> datetime:
         return self.sweep_end_time
 
+    def add_waypoint_actions(self) -> None:
+        super().add_waypoint_actions()
+        self.layout.sweep_start.set_option(Formation.LINE_ABREAST_OPEN)
+        self.layout.sweep_start.add_action(
+            EngageTargets(
+                nautical_miles(50),
+                [
+                    Targets.All.Air.Planes.Fighters,
+                    Targets.All.Air.Planes.MultiroleFighters,
+                ],
+            )
+        )
+
 
 class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
     def layout(self) -> SweepLayout:
@@ -137,5 +150,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

@@ -3,7 +3,7 @@ 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
@@ -34,10 +34,6 @@ class TarCapLayout(PatrollingLayout):
 
 
 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 +60,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
@@ -127,5 +122,5 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> TarCapFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> TarCapFlightPlan:
         return TarCapFlightPlan(self.flight, self.layout())

game/ato/flightplans/theaterrefueling.py

@@ -79,5 +79,5 @@ class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> TheaterRefuelingFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> TheaterRefuelingFlightPlan:
         return TheaterRefuelingFlightPlan(self.flight, self.layout())

game/ato/flightplans/waypointbuilder.py

@@ -23,7 +23,7 @@ from game.theater import (
     TheaterGroundObject,
     TheaterUnit,
 )
-from game.utils import Distance, meters, nautical_miles
+from game.utils import Distance, feet, meters, nautical_miles
 
 if TYPE_CHECKING:
     from game.coalition import Coalition
@@ -168,6 +168,9 @@ class WaypointBuilder:
             "HOLD",
             FlightWaypointType.LOITER,
             position,
+            # Bug: DCS only accepts MSL altitudes for the orbit task and 500 meters is
+            # below the ground for most if not all of NTTR (and lots of places in other
+            # maps).
             meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
             alt_type,
             description="Wait until push time",
@@ -204,6 +207,19 @@ class WaypointBuilder:
             pretty_name="Refuel",
         )
 
+    def recovery_tanker(self, position: Point) -> FlightWaypoint:
+        alt_type: AltitudeReference = "BARO"
+
+        return FlightWaypoint(
+            "RECOVERY",
+            FlightWaypointType.RECOVERY_TANKER,
+            position,
+            feet(6000),
+            alt_type,
+            description="Recovery tanker for aircraft carriers",
+            pretty_name="Recovery",
+        )
+
     def split(self, position: Point) -> FlightWaypoint:
         alt_type: AltitudeReference = "BARO"
         if self.is_helo:
@@ -240,21 +256,6 @@ class WaypointBuilder:
             targets=objective.strike_targets,
         )
 
-    def egress(self, position: Point, target: MissionTarget) -> FlightWaypoint:
-        alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
-            alt_type = "RADIO"
-
-        return FlightWaypoint(
-            "EGRESS",
-            FlightWaypointType.EGRESS,
-            position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
-            alt_type,
-            description=f"EGRESS from {target.name}",
-            pretty_name=f"EGRESS from {target.name}",
-        )
-
     def bai_group(self, target: StrikeTarget) -> FlightWaypoint:
         return self._target_point(target, f"ATTACK {target.name}")
 
@@ -344,17 +345,6 @@ class WaypointBuilder:
             waypoint.only_for_player = True
         return waypoint
 
-    def cas(self, position: Point) -> FlightWaypoint:
-        return FlightWaypoint(
-            "CAS",
-            FlightWaypointType.CAS,
-            position,
-            meters(60) if self.is_helo else meters(1000),
-            "RADIO",
-            description="Provide CAS",
-            pretty_name="CAS",
-        )
-
     @staticmethod
     def race_track_start(position: Point, altitude: Distance) -> FlightWaypoint:
         """Creates a racetrack start waypoint.

game/ato/flightroster.py

@@ -1,29 +1,30 @@
 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.pilots: list[Optional[Pilot]] = []
         self.resize(initial_size)
 
+    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/actionstate.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from game.flightplan.waypointactions.waypointaction import WaypointAction
+
+
+class ActionState:
+    def __init__(self, action: WaypointAction) -> None:
+        self.action = action
+        self._finished = False
+
+    def describe(self) -> str:
+        return self.action.describe()
+
+    def finish(self) -> None:
+        self._finished = True
+
+    def is_finished(self) -> bool:
+        return self._finished
+
+    def on_game_tick(self, time: datetime, duration: timedelta) -> timedelta:
+        return self.action.update_state(self, time, duration)