Changelog updates for v1.2.1 hotfix

The Python-4 overwrites the AIM-9X, causing issues...

.coveragerc

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

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -3,7 +3,7 @@ name: Bug report
 description: >
   Use for any bug that happens after campaign generation. If the New Game wizard
   failed, use the "New Game wizard failed" template instead.
-labels: bug
+labels: ["Bug", "Priority Medium"]
 body:
   - type: markdown
     attributes:
@@ -31,7 +31,7 @@ body:
         If the bug was found in a test/development build, select "Test build" or "Development build"
         and provide a link to the applicable build in the field below.
       options:
-        - 1.0.0
+        - v1.1
         - Test build
         - Development build
   - type: input

.github/ISSUE_TEMPLATE/campaign_update.md

@@ -2,19 +2,19 @@
 name: Campaign update submission
 about: Submit an update to a campaign you maintain.
 title: 'Update for <campaign name>'
-labels: campaign-update-submission
+labels: Campaign Update Submission
 assignees: ''
 
 ---
 
 This form should only be used for submitted updated miz/json files for campaigns
-distributed with Liberation. If you are _requesting_ an update to a campaign, see
-https://github.com/dcs-liberation/dcs_liberation/wiki/Campaign-maintenance. If the
+distributed with Retribution. If you are _requesting_ an update to a campaign, see
+https://github.com/dcs-retribution/dcs-retribution/wiki/Campaign-maintenance. If the
 campaign has an owner, it will be updated before release. If it does not, you can
 volunteer to own it.
 
 If you are not the owner of the campaign listed on
-https://github.com/dcs-liberation/dcs_liberation/wiki/Campaign-maintenance, please start
+https://github.com/dcs-retribution/dcs-retribution/wiki/Campaign-maintenance, please start
 there.
 
 Otherwise, delete everything above the line below and fill out the following form. Note:

.github/ISSUE_TEMPLATE/code_architecture.yml

@@ -0,0 +1,17 @@
+---
+name: Code Architecture
+description: >
+  Suggest a refactor, or other issues related to the codebase.
+labels:  ["Refactor", "Python", "Priority Low"]
+body:
+  - type: markdown
+    attributes:
+      value: >
+        Before filing, please search the issues to see if the problem has already been reported.
+  - type: textarea
+    attributes:
+      label: Describe your proposal.
+      description: >
+        Indicate where the issue lies and briefly explain how you plan to tackle it.
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,12 +1,12 @@
 blank_issues_enabled: false
 contact_links:
   - name: FAQ
-    url: https://discord.gg/PXHA6AXw
+    url: https://discord.gg/b4x34Bg4We
     about: Check to see if your issue is in the FAQ.
   - name: Manual
-    url: https://github.com/dcs-liberation/dcs_liberation/wiki/
+    url: https://github.com/dcs-retribution/dcs-retribution/wiki/
   - name: Feature blocking DCS AI bugs
-    url: https://github.com/dcs-liberation/dcs_liberation#dcs-bugs
+    url: https://github.com/dcs-retribution/dcs-retribution#dcs-bugs
     about: >
       A list of known DCS bugs that prevent us from improving AI behavior. Check
       the list before filing AI bugs here to see if it's something we know about

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,21 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: enhancement
-assignees: ''
-
----
-
-Before filing, please search the issue tracker to see if this feature has already been requested.
-
-If requesting a DCS AI feature, check If reporting a DCS AI bug, check https://github.com/dcs-liberation/dcs_liberation#dcs-bugs.
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,31 @@
+---
+name: Feature Request
+description: >
+  Suggest an idea for this project.
+labels: ["Enhancement", "Priority Medium"]
+body:
+  - type: markdown
+    attributes:
+      value: >
+        Before filing, please search the issue tracker to see if this feature has already been requested.
+        If requesting a DCS AI feature, check If reporting a DCS AI bug, 
+        check https://github.com/dcs-retribution/dcs-retribution#dcs-bugs.
+  - type: textarea
+    attributes:
+      label: Is your feature request related to a problem? Please describe.
+      description: >
+        A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the solution you'd like
+      description: >
+        A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: >
+        Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/mod_support.md

@@ -1,8 +1,8 @@
 ---
 name: Mod support request
-about: Request Liberation support for new mods, or updates to existing mods 
+about: Request Retribution support for new mods, or updates to existing mods 
 title: Add/update <mod name>
-labels: mod support
+labels: Mod Request
 assignees: ''
 
 ---

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

@@ -3,7 +3,7 @@ name: New Game wizard failed
 description: >
   Use for bugs that prevent the "New Game" wizard from completing successfully.
   If the wizard completes without issue, use the normal bug report template.
-labels: bug
+labels: ["Bug", "Priority High"]
 body:
   - type: markdown
     attributes:

.github/workflows/build.yml

@@ -25,6 +25,7 @@ jobs:
       - name: Set build number
         run: |
           [IO.File]::WriteAllLines($pwd.path + "\resources\buildnumber", $env:GITHUB_RUN_NUMBER)
+          [IO.File]::WriteAllLines($pwd.path + "\resources\gitsha", $env:GITHUB_SHA)
 
       - name: Build app
         uses: ./.github/actions/build-app
@@ -42,11 +43,21 @@ jobs:
       - name: Send status to Discord
         uses: stegzilla/discord-notify@v2
         with:
-          webhook_url: ${{ secrets.discord_webhook_betas }} # required
+          webhook_url: ${{ secrets.discord_webhook_betas }}
           title: "Build #${{ github.run_number }} available!"
-          message: "**Download link:\n** 
-          https://github.com/dcs-retribution/dcs-retribution/actions/runs/${{ github.run_id }}"
+          message: "**Branch:** ${{ github.ref_name }}\n**Download link:\n** https://github.com/dcs-retribution/dcs-retribution/actions/runs/${{ github.run_id }}"
           include_image: true
           avatar_url: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
           username: GitHub Build Notifier
-        if: success() # or failure() or success()
+        if: startsWith(github.ref_name, 'test')
+
+      - name: Send status to Discord
+        uses: stegzilla/discord-notify@v2
+        with:
+          webhook_url: ${{ secrets.discord_webhook_alphas }}
+          title: "Build #${{ github.run_number }} available!"
+          message: "**Branch:** ${{ github.ref_name }}\n**Download link:\n** https://github.com/dcs-retribution/dcs-retribution/actions/runs/${{ github.run_id }}"
+          include_image: true
+          avatar_url: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
+          username: GitHub Build Notifier
+        if: github.ref_name == 'dev'

.github/workflows/test.yml

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

.gitignore

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

.readthedocs.yaml

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

CONTRIBUTING.md

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

README.md

@@ -12,42 +12,48 @@
 [![GitHub issues](https://img.shields.io/github/issues/dcs-retribution/dcs-retribution)](https://github.com/dcs-retribution/dcs-retribution/issues)
 ![GitHub stars](https://img.shields.io/github/stars/dcs-retribution/dcs-retribution?style=social)
 
-## About DCS Retribution
-DCS Retribution was forked from [DCS Liberation](https://github.com/dcs-retribution/dcs-retribution),
+## About DCS Retribution 
+(Last update: 2023-05-20)
+
+DCS Retribution was forked from [DCS Liberation](https://github.com/dcs-liberation/dcs_liberation),
 which is a [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) turn based single-player or co-op dynamic campaign. 
 It is an external program that generates full and complex DCS missions and manage a persistent combat environment.
 
 ![Screenshot](https://user-images.githubusercontent.com/315852/120939254-0b4a9f80-c6cc-11eb-82f5-ce3f8d714bfe.png)
 
-DCS Retribution will rely heavily on Liberation in the near future,
-and possibly in a more distant future as well since Retribution will attempt
-to stay backwards compatible for as long as possible. Therefore,
+DCS Retribution is still relying on Liberation for certain updates,
+and will possibly stay that way in a more distant future. Therefore,
 the patreon link will keep pointing to [Khopa's](https://github.com/Khopa) account until further notice.
+However, we are no longer backwards compatible with Liberation, and will no longer attempt to do so.
 
-Currently, Retribution supports the following new features:
- * A livery selector in the air wing configuration dialog
- * Fixed mod support (still unfixed in Liberation)
- * Support for campaigns with quad-point triggers
- * Support for the F-15D 'Baz' mod
- * Support for the Su-30 mod
- * Elementary end-game mechanics
- * Variation in flight-size for BAI/ANTISHIP/DEAD/STRIKE main flight (randomize 2/3/4-ships)
- * More performance options
- * Various bug-fixes (including a fix for the zombie carrier)
+Instead, we are focussing on keeping our campaigns forward compatible so that you as a user
+can continue on whatever campaign you had going on.
+Please keep in mind that once you save a campaign that was started
+in a previous (save-compatibility breaking) build, your save file
+will have been migrated and thus no longer compatible with the previous build.
+Therefore, we recommend backing up your saves and perhaps organizing them by version/build number.
+
+For a more complete overview of our features, check the
+[changelog](https://github.com/dcs-retribution/dcs-retribution/blob/main/changelog.md).
 
 ## Downloads
 
 Latest release is available here : https://github.com/dcs-retribution/dcs-retribution/releases
 
-To download preview builds of the next version of DCS Retribution, see https://github.com/dcs-retribution/dcs-retribution/wiki/Preview-builds.
+To download preview builds of the next version of DCS Retribution, see https://github.com/dcs-retribution/dcs-retribution/wiki/Betas.
 
 ## DCS bugs
 
-These DCS bugs prevent us from improving AI behavior. Please upvote them! (But please
-_don't_ spam them with comments):
+~~These DCS bugs prevent us from improving AI behavior. Please upvote them! (But please
+_don't_ spam them with comments):~~
 
-* [A2A and SEAD escorts don't escort](https://forums.eagle.ru/topic/251798-options-for-alternate-ai-escort-behavior/?tab=comments#comment-4668033)
-* [DEAD can't use mixed loadouts effectively](https://forums.eagle.ru/topic/271941-ai-rtbs-after-firing-decoys-despite-full-load-of-bombs/)
+* ~~[A2A and SEAD escorts don't escort](https://forums.eagle.ru/topic/251798-options-for-alternate-ai-escort-behavior/?tab=comments#comment-4668033)~~
+* ~~[DEAD can't use mixed loadouts effectively](https://forums.eagle.ru/topic/271941-ai-rtbs-after-firing-decoys-despite-full-load-of-bombs/)~~
+
+While DCS bugs are still a thing, we don't quite agree with the ones stated above.
+We believe to have addressed these, although some quirks still exist.
+For example, SEAD Escorts tend to be a little picky with what they engage,
+especially with older SAM systems.
 
 ## Bugs and feature requests
 
@@ -62,7 +68,7 @@ Our plans for future releases can be found on our
 [Projects page](https://github.com/dcs-retribution/dcs-retribution/projects).
 Each planned release has a Project, and the page for that project has columns for to do,
 in progress, and done. Items in the Done column are in the
-[preview build](https://github.com/dcs-retribution/dcs-retribution/wiki/Preview-builds)
+[preview build](https://github.com/dcs-retribution/dcs-retribution/wiki/Betas)
 for that release. Items in the To do column are planned to be added to that release.
 
 ## Resources
@@ -70,7 +76,7 @@ for that release. Items in the To do column are planned to be added to that rele
 Tutorials, contributors and developer's guides are available in the project's
 [Wiki](https://github.com/dcs-retribution/dcs-retribution/wiki/)
 
-(These need to be written again, meanwhile you can refer to
+(Some historical information is also availabe on
 [Liberation's Wiki](https://github.com/dcs-liberation/dcs_liberation/wiki/))
 
 ## Special Thanks

changelog.md

@@ -1,57 +1,345 @@
-# Retribution 1.0.0
+# Retribution v1.2.1 (hotfix)
+
+## Fixes
+* **[Flight Plans]** SEAD Sweep not being auto-planned
+* **[Modding]** Python-4 no longer overwrites AIM-9X
+* **[Modding]** Restore original amount of pylons to F-16C when "ejecting" sufa mod
+
+# Retribution v1.2.0
 
 ## Features/Improvements
+* **[Preset Groups]** Add SA-2 with ZSU-23/57
+* **[Campaign Design]** Ability to define almost all possible settings in the campaign's yaml file.
+* **[Campaign Design]** Ability to add roadbases and/or ground spawns to campaigns.
+* **[Campaign Design]** Ability to define SCENERY REMOVE OBJECTS ZONE triggers with the roadbase objects in campaign miz. This might not work reliably in multiplayer due to DCS issues. FARPs can be used to remove scenery objects in multiplayer.
+* **[Options]** Implemented an option in settings to disable the above SCENERY REMOVE OBJECTS ZONE triggers.
+* **[Campaign Management]** Improved squadron retreat logic at longer ranges.
+* **[Options]** Ability to load & save your settings.
+* **[Options]** Added a separate Doctrine page in settings with the following new options:
+  * Minimum number of aircraft for autoplanner to plan OCA packages against 
+  * Airbase threat range (nmi)
+  * SEAD Sweep threat buffer distance (nmi)
+  * SEAD Escort/Sweep threat buffer distance (nmi)
+  * TARCAP threat buffer distance (nmi)
+  * AEW&C threat buffer distance (nmi)
+  * Theater tanker threat buffer distance (nmi)
+* **[Options]** Improved the option to configure OPFOR autoplanner aggressiveness. The AI might now take even more risks and plan missions against defended targets.
+* Added three new options in Settings:
+  * Autoplanner plans refueling flights for Strike packages
+  * Autoplanner plans refueling flights for OCA packages
+  * Autoplanner plans refueling flights for DEAD packages
+* **[UI]** Added fuel selector in flight's edit window.
+* **[Plugins]** Expose Splash Damage's "game_messages" option and set its default to false.
+* **[Mission Generation]** Improved AI SEAD capabilities, allowing for mixed loadouts using Decoys, ARMs & ASMs.
+* **[Modding]** Support for A-7E Corsair II (presumed latest available version)
+* **[Squadrons]** Added many new squadron's by Adecarcer
+* **[Plugins]** Updated 'expl_table' in Splash Damage script.
+* **[Mission Generation]** Also save kneeboards in txt-format, found under "kneeboards" within Retribution's installation folder after pressing take-off.
+* **[Modding]** Support for SW mod v2.55
+* **[Modding]** Support for Spanish & Australian Naval Assets v3.2.0 by desdemicabina
+* **[Modding]** Support for Iron Dome v1.2 by IDF Mods Project
+* **[New Game Wizard]** Re-organized generator options & show the regular settings menu instead of the limited "Difficulty & Automation" page.
+* **[Campaign Management]** Ability to operate harriers from FOBs/FARPs for <ins>__human pilots only__</ins>. Please note that the autoplanner won't generate flights for harriers at FOBs/FARPs, which means you need to plan your missions manually.
+* **[Mission Planning]** Allow NAV/REFUEL/DIVERT waypoints to be deleted without degrading to a custom flight-plan, also warning the user before actually degrading the flight-plan.
+* **[Campaign Generation]** Split "full-strength start" from "squadron aircraft limits" option.
+* **[Mission Generation]** General improvement w.r.t. DCS tasking, including a check for incompatible tasking.
+* **[Mission Generation]** OCA-Runway flights will remain at altitude when using guided bombs.
+* **[UX]** Added error message to indicate save-compatibility issues + fix to avoid total crash upon loading of last save.
+* **[UI]** Improved parking space information in air wing configuration dialog.
+* **[Squadrons]** Warning messages when opening up a squadron through the air wing dialog, indicating squadrons that potentially won't fit w.r.t. parking space.
+* **[Squadrons Transfers]** Determine number of available parking slots more accurately w.r.t. squadron transfers, taking aircraft dimensions into account which should prevent forced air-starts.
+* **[UX]** Allow usage of CTRL/SHIFT modifiers in ground unit transfer window.
+* **[Campaign Design]** Ability to define "spawn-routes" for convoys, allowing them to start from the road without having to edit the mission
+* **[Plugins]** Added "DCS Dismount" plugin.
+* **[Plugins]** Added "EWR Jammer" plugin (only for humans, may change in the future).
+* **[Campaign]** New campaign (Operation Desert Sabre) by Chimiste
+* **[Plugins]** Updated CTLD to latest released version
+* **[Options]** Renamed Maximum frontline length -> Maximum frontline width.
+* **[Squadrons]** Add livery selector in Squadron Dialog, allowing you to change the livery during the campaign.
+* **[New Game Wizard]** Automatically invert factions when 'Invert Map' is selected.
+* **[Flight Plans]** Added "SEAD Sweep" flight plan, which basically reintroduces the legacy "SEAD Escort" flight plan where the flight will engage whatever it can find without actually escorting the primary flight.
+* **[Flight Plans]** Added SEAD capability to F-16A MLU and SEAD Escort & SEAD to F-16A. 
+* **[Mission Generation]** Spawn unused helicopters or LHA-capable aircraft at helipads at FOBs
+* **[Modding]** Support for F-15I Ra'am v1.0 by IDF Mods Project
+
+## Fixes
+* **[New Game Wizard]** Settings would not persist when going back to a previous page (obsolete due to overhaul).
+* **[Mission Generation]** Unused aircraft are no longer claimed, fixing a bug where these aircraft would no longer be available after aborting the mission.
+* **[Mission Generation]** Fixed (potential) bug in helipad assignments at FOBs/FARPs.
+* **[Mission Generation]** Fix AI immediately returning to base when forced to air-start due to insufficient parking space.
+* **[Modding]** Fixed a bug where F-16Ds were not correctly removed from the faction when the F-16I/F-16D mod was not selected
+* **[UI]** Fixed F-16A MLU icon and banner.
+
+# Retribution v1.1.1  (hotfix)
+
+## Features/Improvements
+* **[Modding]** Support for IDF Mod Project F-16I Sufa & F-16D v3.6 mod
+* **[Modding]** Support for JAS-39 Gripen v1.8.5-beta mod
+
+## Fixes
+* **[Plugins]** Fix bug where changes to plugin options doesn't do anything.
+* **[Campaign Management]** Fix bug in procurement when no squadrons are present.
+* **[Layouts]** Fix edge-case bug layout's group size.
+* **[Campaign Design]** Preset groups assigned to specific TGOs not working as intended.
+
+# Retribution v1.1.0
+
+## Features/Improvements
+* **[Mission Generation]** Given a CAS flight was planned, delay ground force attack until first CAS flight is on station
+* **[Mission Generation]** Add option to switch ATFLIR to LITENING automatically for ground based F/A-18C flights
+* **[Mission Generation]** Add option to configure OPFOR autoplanner aggressiveness and have the AI take risks and plan missions against defended targets
+* **[Mission Generation]** Add option to configure the desired tanker on-station time in settings
+* **[Mission Generation]** Reserve GUARD frequency on VHF/UHF
+* **[Mission Generation]** Randomization in radio frequency allocation
+* **[Mission Generation]** Configurable number of Combined Arms slots
+* **[Mission Generation]** Enable spectating & F11 free camera when the "Allow external views" option is selected
+* **[Cheat Menu]** Option to instantly transfer squadrons across bases.
+* **[Modding]** Support for IDF Mod Project F-16I Sufa & F-16D v3.2 mod
+* **[Modding]** Support for F/A-18E/F/G mod version 2.1
+* **[Modding]** Support for Swedish Military Assets for DCS by Currenthill Version 1.10
+* **[UI]** Add selectable units in faction overview during campaign generation.
+* **[UI]** Add button to rename pilots in Air Wing's Squadron dialog.
+* **[UI]** Add clone buttons for flights & packages.
+* **[UI]** Editing of flight's custom name.
+* **[UI]** Introduce custom names for packages (purely for organizational purposes).
+* **[UI]** Configurable UHF frequency (225-400MHz) for Packages, Carriers, LHAs, FOBs & FARPs.
+* **[UI]** Configurable Intra-Flight frequency for Flights.
+* **[UI]** Configurable TACAN for Carriers, LHAs & Tankers.
+* **[UI]** Configurable ICLS for capable Carriers & LHAs.
+* **[UI]** Configurable LINK4 for Carriers.
+* **[Kneeboard]** Show package information in Support page
+* **[Kneeboard]** Show extra weather information on 'Mission info' page
+* **[Kneeboard]** Show BRC in 'RWY' column for aircraft carriers on 'Mission info' page
+* **[Campaign Design]** Ability to define designated CTLD zones for Control Points (Airbases & FOBs/FARPs)
+* **[Campaign Design]** Ability to define preset groups for specific TGOs, given the preset group is accessible for the faction and the task matches.
+* **[Campaign Management]** Additional options for automated budget management.
+* **[Campaign Management]** New options to allow more control of randomized flight sizes (applicable for BARCAP/CAS/OCA/ANTI-SHIP).
+* **[Plugins]** Updated Splash Damage script to v2.0 by RotorOps.
+* **[Mission Generation]** Improvements to DEAD & STRIKE flights, allowing AI to handle a larger variety of weapons.
+* **[Campaign]** New campaign (1968 Yankee Station) by Adecarcer
+
+## Fixes
+* **[UI]** Removed deprecated options
+* **[UI]** Add missing icon & banner for C130 Hercules mod
+* **[Mission Generation]** Avoid aircraft from being assigned to helicopter parking spots, resulting into air starts that usually crash.
+* **[Mission Generation]** Use stacking algorithm to create vertical separation between flights spawning mid-mission over their departure, usually resulting into mid-air collisions.
+* **[Mission Generation]** Fixed all callsigns being "Enfield 1-1" on dedicated servers.
+* **[Mission Generation]** Fixed AI ferry flights for helicopters when transferring to a FOB/FARP.
+* **[Mission Generation]** Fixed 'Uninitialized flight' exception when adding flights after aborted take-off.
+* **[Modding]** Fixed conflicts caused by HDS units
+* **[UX]** Gracefully handle corrupted preferences file.
+* **[Mission Generation]** Aircraft not using decoys during SEAD.
+
+# Retribution v1.0.1 (hotfix)
+* **[Mission Generation]** Fix serialization issue when STRIKE flight has no escorts
+
+# Retribution v1.0.0
+
+## Features/Improvements
+* **[Engine]** Support for DCS v2.8.1.34437.
+* **[Briefing]** Add tanker info to mission briefing
+* **[Campaign]** Add 5 new campaigns by Oscar Juliet from WRL
+* **[Campaign]** Add ability to define livery overrides also for ground/naval units
+* **[Data]** Added data to support C-47 Skytrain.
+* **[Data]** Added data to support F-16A MLU.
+* **[Data]** Added data to support KS-19 & SON-9, including support for "AAA Site" layout.
 * **[Mission Generation]** Add option to configure the maximum front-line length in settings
-* **[Mission Generation]** Variable flight-size (2/3/4-ship) for BAI/ANTISHIP/DEAD/STRIKE (main) missions
+* **[Mission Generation]** Use Escort & SEAD tasks for Escort & SEAD Escort flights
+* **[Mission Generation]** Variable flight-size (2/3/4-ship) for 
+BAI/ANTISHIP/DEAD/STRIKE/BARCAP/CAS/OCA/AIR-ASSAULT (main) missions
+* **[Mission Generation]** Add option to only generate night missions
 * **[Modding]** Support for F-15D 'Baz' mod version 1.0
 * **[Modding]** Support for Su-30 mod version 2.01B
+* **[Modding]** Support for A-6A Intruder version 2.7.5.01
+* **[Modding]** Support for F-4B Phantom II mod version v2.7.10.02, patch 2022.10.02
+* **[Modding]** Support for F-100 Super Sabre mod versions v2.7.18.01 & 2.7.18.30765 and patch 20.10.22
+* **[Modding]** Support for F-105 mod version 2.7.12.23x
+* **[Modding]** Support IDF Mod Project F-16I Sufa & F-16D v2.2 mod
+* **[Modding]** Support for F-84G mod version 2.5.7.01
+* **[Modding]** Updated F-104 mod version support to 2.7.11.222.01
+* **[Modding]** Updated Community A-4E-C mod version support to 2.1.0 release.
 * **[UI]** Add livery selector to Air Wing Configurator's squadrons.
 * **[Performance]** Added performance option: Maximum front-line unit supply per control point.
 * **[Performance]** Added performance option: Disable convoys.
 * **[Performance]** Added performance option: Front-line troops prefer roads.
-* **[Data]** Added data to support C-47 Skytrain.
+* **[Performance]** Added performance option: Disable idle aircraft at airfields.
+* **[Squadrons]** Squadron pilot limits enabled by default.
+* **[UI]** Add livery selector to Air Wing Configurator's squadrons.
+
+## Fixes
+
+* **[Mission Generation]** Fixed issue where aircraft carriers would return after being killed.
+* **[Mission Generation]** Kneeboard STRIKE coordinates would sometimes get clipped when not fitting.
+* **[UI]** Fix exception when trying to add a waypoints to a flightplan.
 
 
 # Liberation:
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41363, including F-15E support.
+
+## Fixes
+
+# 8.0.0
+
+Saves from 7.x are not compatible with 8.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41066, including the new Sinai map.
+* **[UI]** Limited size of overfull airbase display and added scrollbar.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Moved air wing and transfer menus to the toolbar to improve UI fit on low resolution displays.
+* **[UI]** Added basic game over dialog.
+
+## Fixes
+
+* **[Campaign]** Fix bug introduced in 7.0 where map strike target deaths are no longer tracked.
+* **[Mission Generation]** Fix crash during mission generation caused by out of date DCS data for the Gazelle.
+* **[Mission Generation]** Fix crash during mission generation when DCS beacon data is inconsistent.
+
+# 7.1.0
+
+Saves from 7.0.0 are compatible with 7.1.0
+
+## Features/Improvements
+
+* **[Factions]** Replaced Patriot STRs "EWRs" with AN/FPS-117 for blue factions 1980 or newer.
+* **[Mission Generation]** Added option to prevent scud and V2 sites from firing at the start of the mission.
+* **[Mission Planning]** Per-flight TOT offsets can now be set in the flight details UI. This allows individual flights to be scheduled ahead of or behind the rest of the package.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Parking capacity of each squadron's base is now shown during air wing configuration to avoid overcrowding bases when beginning the game with full squadrons.
+
+## Fixes
+
+* **[Mission Planning]** BAI is once again plannable against missile sites and coastal defense batteries.
+* **[UI]** Fixed formatting of departure time in flight details dialog.
+
+# 7.0.0
+
+Saves from 6.x are not compatible with 7.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.3.37556.
+* **[Engine]** Saved games are now a zip file of save assets for easier bug reporting. The new extension is .liberation.zip. Drag and drop that file into bug reports.
+* **[Campaign]** Added options to limit squadron sizes and to begin all squadrons at maximum strength. Maximum squadron size is defined during air wing configuration with default values provided by the campaign.
+* **[Campaign]** Added handling for more DCS death events. This probably does not catch any deaths that weren't previously tracked, but it should record them sooner, which will improve results for game crashes or other early exits.
+* **[Campaign AI]** The campaign AI now prefers fulfilling missions with squadrons which have a matching primary task. Previously distance from target held a stronger influence than task preference. Primary tasks for squadrons are set by campaign designers but are user-configurable.
+* **[Flight Planning]** Package TOT and composition can be modified after advancing time in Liberation.
+* **[Mission Generation]** Units on the front line are now hidden on MFDs.
+* **[Mission Generation]** Preset radio channels will now be configured for both A-10C modules.
+* **[Mission Generation]** The A-10C II now uses separate radios for inter- and intra-flight comms (similar to other modern aircraft).
+* **[Mission Generation]** Wind speeds no longer follow a uniform distribution. Median wind speeds are now much lower and the standard deviation has been reduced considerably at altitude but increased somewhat at MSL.
+* **[Mission Generation]** Improved task generation for SEAD flights carrying TALDs.
+* **[Mission Generation]** Added task timeout for SEAD flights with TALDs to prevent AI from overflying the target.
+* **[Modding]** Updated Community A-4E-C mod version support to 2.1.0 release.
+* **[Modding]** Add support for VSN F-4B and F-4C mod.
+* **[Modding]** Aircraft task capabilities and preferred aircraft for each task are now moddable in the aircraft unit yaml files. Each aircraft has a weight per task. Higher weights are given higher preference.
+* **[Modding]** The `mission_types` field in squadron files has been removed. Squadron task capability is now determined by airframe, and the auto-assignable list has always been overridden by the campaign settings.
+* **[Modding]** Wind speed generation inputs are now moddable. See https://dcs-liberation.rtfd.io/en/latest/modding/weather.html.
+* **[New Game Wizard]** Choices for some options will be remembered for the next new game. Not all settings will be preserved, as many are campaign dependent.
+* **[New Game Wizard]** Lua plugins can now be set while creating a new game.
+* **[New Game Wizard]** Squadrons can be directly replaced with a preset during air wing configuration rather than needing to remove and create a new squadron.
+* **[New Game Wizard]** Squadron liveries can now be selected during air wing configuration.
+* **[Squadrons]** Squadron-specific mission capability lists no longer restrict players from assigning missions outside the squadron's preferences.
+* **[New Game Wizard]** Squadrons can be directly replaced with a preset during air wing configuration rather than needing to remove and create a new squadron.
+* **[UI]** The orientation of objects like SAMs, EWRs, garrisons, and ships can now be manually adjusted.
+
+## Fixes
+
+* **[Campaign]** Fixed a longstanding bug where oversized airlifts could corrupt a save with empty convoys.
+* **[Campaign]** Aircraft with built-in TGPs but without an external pod will no longer degrade automatic loadouts to iron bombs.
+* **[Engine]** Fixed crash in startup caused by a corrupted Liberation preferences file.
+* **[Flight Planning]** AEW&C missions are now plannable over FOBs and LHAs.
+* **[Flight Planning]** BAI is no longer plannable against buildings.
+* **[Modding]** Fixed an issue where Falklands campaigns created or edited with new versions of DCS could not be loaded.
+* **[Modding]** Fixed decoding of campaign yaml files to use UTF-8 rather than the system locale's default. It's now possible to use "Bf 109 K-4 Kurfürst" as a preferred aircraft type.
+* **[Mission Generation]** Planes will no longer spawn in helipads that are not also designated for fixed wing parking.
+* **[Mission Generation]** Potentially an issue where ground war planning game state could become corrupted, preventing mission generation.
+* **[Mission Generation]** Refueling tasks will now only be created for flights that have a tanker in their package.
+* **[Mission Generation]** Fixed missing Tanker task on recovery tanker missions.
+* **[UI]** Fixed error when resetting air wing configuration during game setup.
+* **[UI]** Fixed flight plan recreation when changing mission type with "Recreate as" flight options.
+* **[UI]** Fixed failure to launch UI when Liberation persistent preferences file was corrupt.
+
+
+# 6.1.1
+
+## Fixes
+
+* **[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.
+
+# 6.1.0
+
+Saves from 6.0.0 are compatible with 6.1.0
+
+## Features/Improvements
+
+* **[Factions]** Defaulted bluefor modern to use Georgian and Ukrainian liveries for Russian aircraft.
+* **[Factions]** Added Peru.
+* **[Modding]** Added support for the HMS Ariadne, Achilles, and Castle class.
+
+## Fixes
+
+* **[Flight Planning]** Fixes CAS flights not having landing waypoints.
+* **[Squadrons]** Fixed the livery for the VF-33 F-14A squadron.
+* **[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.
 
 ## Features/Improvements
 
-* **[Engine]** Support for DCS 2.7.18.30348.
-* **[Mission Generation]** Added an option to fast-forward mission generation until the point of first contact (WIP).
-* **[Mission Generation]** Added performance option to not cull IADS when culling would effect 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.
+* **[Engine]** Support for DCS 2.8.0.33006.
 * **[Factions]** Updated the Faction file structure. Older custom faction files will not work correctly and have to be updated to the new structure.
-* **[Flight Planning]**  Added preset formations for different flight types at hold, join, ingress, and split waypoints.  Air to Air flights will tend toward line-abreast and spread-four formations.  Air to ground flights will tend towards trail formation.
-* **[Flight Planning]** Added the ability to plan tankers for recovery on package flights.  AI does not plan.
+* **[Flight Planning]** Added preset formations for different flight types at hold, join, ingress, and split waypoints. Air to Air flights will tend toward line-abreast and spread-four formations. Air to ground flights will tend towards trail formation.
+* **[Flight Planning]** Added the ability to plan tankers for recovery on package flights. This mission type will not be planned automatically.
 * **[Flight Planning]** Air to Ground flights now have ECM enabled on lock at the join point, and SEAD/DEAD also have ECM enabled on detection and lock at ingress.
 * **[Flight Planning]** AWACS flightplan changed from orbit to a racetrack to reduce data link disconnects which were caused by blind spots as a result of the bank angle. 
-* **[Flight Planning]**  Added a new helo mission type: AirAssault which can be used to load and transport infantry troops from a pickup zone or a carrier to an enemy CP to capture it.
-* **[Flight Planning]**  Improved the Airlift mission type so that it now can be enforced within the unit transfer dialog and implemented CTLD support. This allows user to spawn sling loadable crates at the pickup location and fly transport flights.
+* **[Flight Planning]** Added a new helo mission type: AirAssault which can be used to load and transport infantry troops from a pickup zone or a carrier to an enemy CP to capture it.
+* **[Flight Planning]** Improved the Airlift mission type so that it now can be enforced within the unit transfer dialog and implemented CTLD support. This allows user to spawn sling loadable crates at the pickup location and fly transport flights.
+* **[Mission Generation]** Added an option to fast-forward mission generation until the point of first contact (WIP).
+* **[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
 * **[Modding]** Updated the High Digit SAMs implementation and added the HQ-2 as well as the upgraded SA-2 and SA-3 Launchers from the mod. Threat range circles will now also be displayed correctly.
 * **[Modding]** Theater information such as climate properties is now moddable.
+* **[Modding]** Allow campaign designers to define default values for the economy settings (starting budget and multiplier).
+* **[Modding]** Campaigns can now optionally define their start time by including a time in the `recommended_start_date` field. There is not currently a way to override the start time in the UI.
+* **[Plugins]** Allow full support of the SkynetIADS plugin with all advanced features (connection nodes, power sources, command centers) if campaign supports it.
+* **[Plugins]** Added support for the CTLD script by ciribob with many possible customization options and updated the JTAC Autolase to the CTLD included script.
 * **[UI]** Added options to the loadout editor for setting properties such as HMD choice.
 * **[UI]** Added separate images for the different carrier types.
 * **[UI]** Add Accept/Reset buttons to Air Wing Configurator screen.
-* **[Campaign]** Allow campaign designers to define default values for the economy settings (starting budget and multiplier).
-* **[Plugins]** Allow full support of the SkynetIADS plugin with all advanced features (connection nodes, power sources, command centers) if campaign supports it.
-* **[Plugins]** Added support for the CTLD script by ciribob with many possible customization options and updated the JTAC Autolase to the CTLD included script.
 
 ## Fixes
 
+* **[Engine]** Fixed issue that prevented some weapon types like torpedoes from being recognized.
+* **[Flight Planning]** Fixed a miscalculation of waypoint TOTs that would require time travel.
+* **[Loadouts]** Improved the range of the F-16 CAS loadout by adding bags.
+* **[Mission Generation]** AAA ground units now spawn correctly at the frontline
 * **[Mission Generation]** Fixed SA-13 incorrectly created as SA-8 Loading Unit which will not be spawned in the generated mission.
+* **[Mission Generation]** Fixed adding additional mission types for a squadron causing error messages when the mission type is not supported by the aircraft type by default
+* **[Mission Generation]** Fixed an issue where SEAD/DEAD/BAI flights fired all missiles / bombs against a single unit in a group instead of targeting the whole group.
 * **[Mission Generation]** Fixed an issue which generated the helipads at FARPs incorrectly and placed the helicopters within each other.
 * **[Mission Generation]** Fixed an issue with SEAD missions flown by the AI when using the Skynet Plugin and anti-radiation missiles (ARM). The AI now correctly engages the SAM when it comes alive instead of diving into it.
-* **[Mission Generation]** Fixed an issue where SEAD/DEAD/BAI flights fired all missiles / bombs against a single unit in a group instead of targeting the whole group.
-* **[Mission Generation]** Fixed adding additional mission types for a squadron causing error messages when the mission type is not supported by the aircraft type by default
-* **[Mission Generation]** AAA ground units now spawn correctly at the frontline
-* **[UI]** Fixed and issue where the liberation main exe was still running after application close.
+* **[Mission Generation]** Fixed generation issue that would cause AI helicopters to get stuck after taking off from a FARP.
+* **[Mission Generation]** Fixed mission scripting error caused by control points with apostrophes in their names, such as Tha'lah.
+* **[Modding]** Campaigns that used quad zones for scenery targets will no longer load. Only circular zones were ever supported, but an implementation quirk allowed them to load in a way that would misbehave. A "No white triggerzones found" message during campaign generation is the sign of a broken campaign.
+* **[Modding]** Loadouts with invalid weapons (typically new DCS weapons not yet available in Liberation) will be ignored rather than causing an error.
+* **[Squadrons]** Fixed issue in air wing configuration that would allow squadrons to be created with no home base if no base was available.
+* **[Squadrons]** Helicopter squadrons can no longer be assigned to FOBs that are not FARPs.
+* **[UI]** Add vanilla theme weather and time of day icons
 * **[UI]** Disable player slots for non-flyable aircraft.
-
+* **[UI]** Fixed and issue where the liberation main exe was still running after application close.
 
 # 5.2.0
 

client/README.md

@@ -1,6 +1,6 @@
-# DCS Liberation Client
+# DCS Retribution Client
 
-This is a React app for the front-end of DCS Liberation. It is a work in
+This is a React app for the front-end of DCS Retribution. It is a work in
 progress that just barely implements the map. This is not useful for players
 yet.
 

client/package.json

@@ -69,9 +69,19 @@
     "electron": "^21.1.0",
     "electron-is-dev": "^2.0.0",
     "generate-license-file": "^2.0.0",
+    "identity-obj-proxy": "^3.0.0",
     "license-checker": "^25.0.1",
+    "nth-check": "^2.0.1",
     "react-scripts": "5.0.1",
     "ts-node": "^10.9.1",
     "wait-on": "^6.0.1"
+  },
+  "jest": {
+    "transformIgnorePatterns": [
+      "node_modules/(?!(@?react-leaflet|axios)/)"
+    ],
+    "moduleNameMapper": {
+      ".+\\.(css|styl|less|sass|scss|png|jpg|ttf|woff|woff2)$": "identity-obj-proxy"
+    }
   }
 }

client/src/App.test.tsx

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

client/src/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/controlpoints/ControlPoint.tsx

@@ -1,270 +1,15 @@
-import backend from "../../api/backend";
 import { ControlPoint as ControlPointModel } from "../../api/liberationApi";
-import {
-  useClearControlPointDestinationMutation,
-  useSetControlPointDestinationMutation,
-} from "../../api/liberationApi";
-import {
-  Icon,
-  LatLng,
-  Point,
-  Marker as LMarker,
-  Polyline as LPolyline,
-  LatLngLiteral,
-} from "leaflet";
-import { Symbol as MilSymbol } from "milsymbol";
-import {
-  MutableRefObject,
-  useCallback,
-  useEffect,
-  useRef,
-  useState,
-} from "react";
-import ReactDOMServer from "react-dom/server";
-import { Marker, Polyline, Tooltip } from "react-leaflet";
-
-function iconForControlPoint(cp: ControlPointModel) {
-  const symbol = new MilSymbol(cp.sidc, {
-    size: 24,
-    colorMode: "Dark",
-  });
-
-  return new Icon({
-    iconUrl: symbol.toDataURL(),
-    iconAnchor: new Point(symbol.getAnchor().x, symbol.getAnchor().y),
-  });
-}
-
-function openInfoDialog(controlPoint: ControlPointModel) {
-  backend.post(`/qt/info/control-point/${controlPoint.id}`);
-}
-
-function openNewPackageDialog(controlPoint: ControlPointModel) {
-  backend.post(`/qt/create-package/control-point/${controlPoint.id}`);
-}
+import { MobileControlPoint } from "./MobileControlPoint";
+import { StaticControlPoint } from "./StaticControlPoint";
 
 interface ControlPointProps {
   controlPoint: ControlPointModel;
 }
 
-function LocationTooltipText(props: ControlPointProps) {
-  return <h3 style={{ margin: 0 }}>{props.controlPoint.name}</h3>;
-}
-
-function metersToNauticalMiles(meters: number) {
-  return meters * 0.000539957;
-}
-
-function formatLatLng(latLng: LatLng) {
-  const lat = latLng.lat.toFixed(2);
-  const lng = latLng.lng.toFixed(2);
-  const ns = latLng.lat >= 0 ? "N" : "S";
-  const ew = latLng.lng >= 0 ? "E" : "W";
-  return `${lat}&deg;${ns} ${lng}&deg;${ew}`;
-}
-
-function destinationTooltipText(
-  cp: ControlPointModel,
-  destinationish: LatLngLiteral,
-  inRange: boolean
-) {
-  const destination = new LatLng(destinationish.lat, destinationish.lng);
-  const distance = metersToNauticalMiles(
-    destination.distanceTo(cp.position)
-  ).toFixed(1);
-  if (!inRange) {
-    return `Out of range (${distance}nm away)`;
-  }
-  const dest = formatLatLng(destination);
-  return `${cp.name} moving ${distance}nm to ${dest} next turn`;
-}
-
-function PrimaryMarker(props: ControlPointProps) {
-  // We can't use normal state to update the marker tooltip or the line points
-  // because if we set any state in the drag event it will re-render the
-  // component and interrupt dragging. Instead, keep refs to the objects and
-  // mutate them directly.
-  //
-  // For the same reason, the path is owned by this component, because updating
-  // sibling state would be messy. Lifting the state into the parent would still
-  // cause this component to redraw.
-  const marker: MutableRefObject<LMarker | undefined> = useRef();
-  const pathLine: MutableRefObject<LPolyline | undefined> = useRef();
-
-  const [hasDestination, setHasDestination] = useState<boolean>(
-    props.controlPoint.destination != null
-  );
-  const [pathDestination, setPathDestination] = useState<LatLngLiteral>(
-    props.controlPoint.destination
-      ? props.controlPoint.destination
-      : props.controlPoint.position
-  );
-  const [position, setPosition] = useState<LatLngLiteral>(
-    props.controlPoint.destination
-      ? props.controlPoint.destination
-      : props.controlPoint.position
-  );
-
-  const setDestination = useCallback((destination: LatLng) => {
-    setPathDestination(destination);
-    setPosition(destination);
-    setHasDestination(true);
-  }, []);
-
-  const resetDestination = useCallback(() => {
-    setPathDestination(props.controlPoint.position);
-    setPosition(props.controlPoint.position);
-    setHasDestination(false);
-  }, [props.controlPoint.position]);
-
-  const [putDestination, { isLoading }] =
-    useSetControlPointDestinationMutation();
-  const [cancelTravel] = useClearControlPointDestinationMutation();
-
-  useEffect(() => {
-    marker.current?.setTooltipContent(
-      props.controlPoint.destination
-        ? destinationTooltipText(
-            props.controlPoint,
-            props.controlPoint.destination,
-            true
-          )
-        : ReactDOMServer.renderToString(
-            <LocationTooltipText controlPoint={props.controlPoint} />
-          )
-    );
-  });
-
-  return (
-    <>
-      <Marker
-        position={position}
-        icon={iconForControlPoint(props.controlPoint)}
-        draggable={props.controlPoint.mobile && !isLoading}
-        autoPan
-        // We might draw other markers on top of the CP. The tooltips from the
-        // other markers are helpful so we want to keep them, but make sure the CP
-        // is always the clickable thing.
-        zIndexOffset={1000}
-        opacity={props.controlPoint.destination ? 0.5 : 1}
-        ref={(ref) => {
-          if (ref != null) {
-            marker.current = ref;
-          }
-        }}
-        eventHandlers={{
-          click: () => {
-            if (!hasDestination) {
-              openInfoDialog(props.controlPoint);
-            }
-          },
-          contextmenu: () => {
-            if (props.controlPoint.destination) {
-              cancelTravel({ cpId: props.controlPoint.id }).then(() => {
-                resetDestination();
-              });
-            } else {
-              openNewPackageDialog(props.controlPoint);
-            }
-          },
-          drag: (event) => {
-            const destination = event.target.getLatLng();
-            backend
-              .get(
-                `/control-points/${props.controlPoint.id}/destination-in-range?lat=${destination.lat}&lng=${destination.lng}`
-              )
-              .then((inRange) => {
-                marker.current?.setTooltipContent(
-                  destinationTooltipText(
-                    props.controlPoint,
-                    destination,
-                    inRange.data
-                  )
-                );
-              });
-            pathLine.current?.setLatLngs([
-              props.controlPoint.position,
-              destination,
-            ]);
-          },
-          dragend: async (event) => {
-            const currentPosition = new LatLng(
-              pathDestination.lat,
-              pathDestination.lng
-            );
-            const destination = event.target.getLatLng();
-            setDestination(destination);
-            try {
-              await putDestination({
-                cpId: props.controlPoint.id,
-                body: { lat: destination.lat, lng: destination.lng },
-              }).unwrap();
-            } catch (error) {
-              console.error("setDestination failed", error);
-              setDestination(currentPosition);
-            }
-          },
-        }}
-      >
-        <Tooltip />
-      </Marker>
-      <Polyline
-        positions={[props.controlPoint.position, pathDestination]}
-        weight={1}
-        color="#80BA80"
-        interactive
-        ref={(ref) => {
-          if (ref != null) {
-            pathLine.current = ref;
-          }
-        }}
-      />
-    </>
-  );
-}
-
-interface SecondaryMarkerProps {
-  controlPoint: ControlPointModel;
-  destination: LatLngLiteral | undefined;
-}
-
-function SecondaryMarker(props: SecondaryMarkerProps) {
-  if (!props.destination) {
-    return <></>;
-  }
-
-  return (
-    <Marker
-      position={props.controlPoint.position}
-      icon={iconForControlPoint(props.controlPoint)}
-      // We might draw other markers on top of the CP. The tooltips from the
-      // other markers are helpful so we want to keep them, but make sure the CP
-      // is always the clickable thing.
-      zIndexOffset={1000}
-      eventHandlers={{
-        click: () => {
-          openInfoDialog(props.controlPoint);
-        },
-        contextmenu: () => {
-          openNewPackageDialog(props.controlPoint);
-        },
-      }}
-    >
-      <Tooltip>
-        <LocationTooltipText {...props} />
-      </Tooltip>
-    </Marker>
-  );
-}
-
 export default function ControlPoint(props: ControlPointProps) {
-  return (
-    <>
-      <PrimaryMarker {...props} />
-      <SecondaryMarker
-        controlPoint={props.controlPoint}
-        destination={props.controlPoint.destination}
-      />
-    </>
-  );
+  if (props.controlPoint.mobile) {
+    return <MobileControlPoint {...props} />;
+  } else {
+    return <StaticControlPoint {...props} />;
+  }
 }

client/src/components/controlpoints/EventHandlers.ts

@@ -0,0 +1,22 @@
+import { ControlPoint } from "../../api/_liberationApi";
+import backend from "../../api/backend";
+
+function openInfoDialog(controlPoint: ControlPoint) {
+  backend.post(`/qt/info/control-point/${controlPoint.id}`);
+}
+
+function openNewPackageDialog(controlPoint: ControlPoint) {
+  backend.post(`/qt/create-package/control-point/${controlPoint.id}`);
+}
+
+export const makeLocationMarkerEventHandlers = (controlPoint: ControlPoint) => {
+  return {
+    click: () => {
+      openInfoDialog(controlPoint);
+    },
+
+    contextmenu: () => {
+      openNewPackageDialog(controlPoint);
+    },
+  };
+};

client/src/components/controlpoints/Icons.tsx

@@ -0,0 +1,15 @@
+import { ControlPoint } from "../../api/_liberationApi";
+import { Icon, Point } from "leaflet";
+import { Symbol } from "milsymbol";
+
+export const iconForControlPoint = (cp: ControlPoint) => {
+  const symbol = new Symbol(cp.sidc, {
+    size: 24,
+    colorMode: "Dark",
+  });
+
+  return new Icon({
+    iconUrl: symbol.toDataURL(),
+    iconAnchor: new Point(symbol.getAnchor().x, symbol.getAnchor().y),
+  });
+};

client/src/components/controlpoints/LocationTooltipText.tsx

@@ -0,0 +1,9 @@
+interface LocationTooltipTextProps {
+  name: string;
+}
+
+export const LocationTooltipText = (props: LocationTooltipTextProps) => {
+  return <h3 style={{ margin: 0 }}>{props.name}</h3>;
+};
+
+export default LocationTooltipText;

client/src/components/controlpoints/MobileControlPoint.tsx

@@ -0,0 +1,228 @@
+import { ControlPoint } from "../../api/_liberationApi";
+import backend from "../../api/backend";
+import {
+  useClearControlPointDestinationMutation,
+  useSetControlPointDestinationMutation,
+} from "../../api/liberationApi";
+import { makeLocationMarkerEventHandlers } from "./EventHandlers";
+import { iconForControlPoint } from "./Icons";
+import LocationTooltipText from "./LocationTooltipText";
+import { MovementPath, MovementPathHandle } from "./MovementPath";
+import { StaticControlPoint } from "./StaticControlPoint";
+import { LatLng, Marker as LMarker, LatLngLiteral } from "leaflet";
+import { useCallback, useEffect, useRef, useState } from "react";
+import ReactDOMServer from "react-dom/server";
+import { Marker, Tooltip } from "react-leaflet";
+
+function metersToNauticalMiles(meters: number) {
+  return meters * 0.000539957;
+}
+
+function formatLatLng(latLng: LatLng) {
+  const lat = latLng.lat.toFixed(2);
+  const lng = latLng.lng.toFixed(2);
+  const ns = latLng.lat >= 0 ? "N" : "S";
+  const ew = latLng.lng >= 0 ? "E" : "W";
+  return `${lat}°${ns} ${lng}°${ew}`;
+}
+
+function destinationTooltipText(
+  cp: ControlPoint,
+  destinationish: LatLngLiteral,
+  inRange: boolean
+) {
+  const destination = new LatLng(destinationish.lat, destinationish.lng);
+  const distance = metersToNauticalMiles(
+    destination.distanceTo(cp.position)
+  ).toFixed(1);
+  if (!inRange) {
+    return `Out of range (${distance}nm away)`;
+  }
+  const dest = formatLatLng(destination);
+  return `${cp.name} moving ${distance}nm to ${dest} next turn`;
+}
+
+interface PrimaryMarkerProps {
+  controlPoint: ControlPoint;
+}
+
+/**
+ * The primary control point marker. For non-mobile control points, this has
+ * fairly simple behavior: it's a marker in a fixed location that can manage
+ * units and can have missions planned against it.
+ *
+ * For mobile control points, this is a draggable marker. If the control point
+ * has a destination (either because it was dragged after render, or because it
+ * had a destination in the game that was loaded), the unit management and
+ * mission planning behaviors are delegated to SecondaryMarker, and the primary
+ * marker becomes only a destination marker. It can be dragged to change the
+ * destination, and can be right clicked to cancel movement.
+ */
+function PrimaryMarker(props: PrimaryMarkerProps) {
+  // We can't use normal state to update the marker tooltip or the line points
+  // because if we set any state in the drag event it will re-render this
+  // component and all children, interrupting dragging. Instead, keep refs to
+  // the objects and mutate them directly.
+  //
+  // For the same reason, the path is owned by this component, because updating
+  // sibling state would be messy. Lifting the state into the parent would still
+  // cause this component to redraw.
+  const markerRef = useRef<LMarker | null>(null);
+  const pathRef = useRef<MovementPathHandle | null>(null);
+
+  const [hasDestination, setHasDestination] = useState<boolean>(
+    props.controlPoint.destination != null
+  );
+  const [position, setPosition] = useState<LatLngLiteral>(
+    props.controlPoint.destination
+      ? props.controlPoint.destination
+      : props.controlPoint.position
+  );
+
+  const setDestination = useCallback((destination: LatLng) => {
+    setPosition(destination);
+    setHasDestination(true);
+  }, []);
+
+  const resetDestination = useCallback(() => {
+    setPosition(props.controlPoint.position);
+    setHasDestination(false);
+  }, [props]);
+
+  const [putDestination, { isLoading }] =
+    useSetControlPointDestinationMutation();
+  const [cancelTravel] = useClearControlPointDestinationMutation();
+
+  useEffect(() => {
+    markerRef.current?.setTooltipContent(
+      props.controlPoint.destination
+        ? destinationTooltipText(
+            props.controlPoint,
+            props.controlPoint.destination,
+            true
+          )
+        : ReactDOMServer.renderToString(
+            <LocationTooltipText name={props.controlPoint.name} />
+          )
+    );
+  });
+
+  const locationClickHandlers = makeLocationMarkerEventHandlers(
+    props.controlPoint
+  );
+
+  return (
+    <>
+      <Marker
+        position={position}
+        icon={iconForControlPoint(props.controlPoint)}
+        draggable={!isLoading}
+        autoPan
+        // We might draw other markers on top of the CP. The tooltips from the
+        // other markers are helpful so we want to keep them, but make sure the CP
+        // is always the clickable thing.
+        zIndexOffset={1000}
+        opacity={props.controlPoint.destination ? 0.5 : 1}
+        ref={(ref) => {
+          if (ref != null) {
+            markerRef.current = ref;
+          }
+        }}
+        eventHandlers={{
+          click: () => {
+            if (!hasDestination) {
+              locationClickHandlers.click();
+            }
+          },
+          contextmenu: () => {
+            if (props.controlPoint.destination) {
+              cancelTravel({ cpId: props.controlPoint.id }).then(() => {
+                resetDestination();
+              });
+            } else {
+              locationClickHandlers.contextmenu();
+            }
+          },
+          drag: (event) => {
+            const destination = event.target.getLatLng();
+            backend
+              .get(
+                `/control-points/${props.controlPoint.id}/destination-in-range?lat=${destination.lat}&lng=${destination.lng}`
+              )
+              .then((inRange) => {
+                markerRef.current?.setTooltipContent(
+                  destinationTooltipText(
+                    props.controlPoint,
+                    destination,
+                    inRange.data
+                  )
+                );
+              });
+            pathRef.current?.setDestination(destination);
+          },
+          dragend: async (event) => {
+            const currentPosition = new LatLng(position.lat, position.lng);
+            const destination = event.target.getLatLng();
+            setDestination(destination);
+            try {
+              await putDestination({
+                cpId: props.controlPoint.id,
+                body: { lat: destination.lat, lng: destination.lng },
+              }).unwrap();
+            } catch (error) {
+              console.error("setDestination failed", error);
+              setDestination(currentPosition);
+            }
+          },
+        }}
+      >
+        <Tooltip />
+      </Marker>
+      <MovementPath
+        source={props.controlPoint.position}
+        destination={position}
+        ref={pathRef}
+      />
+    </>
+  );
+}
+
+interface SecondaryMarkerProps {
+  controlPoint: ControlPoint;
+  destination: LatLngLiteral | undefined;
+}
+
+/**
+ * The secondary marker for a control point. The secondary marker will only be
+ * shown when the control point has a destination set. For mobile control
+ * points, the primary marker is draggable, and the secondary marker will be
+ * shown at the current location iff the control point has been dragged. The
+ * secondary marker is also the marker that has the normal control point
+ * interaction options (mission planning and unit management).
+ */
+function SecondaryMarker(props: SecondaryMarkerProps) {
+  if (!props.destination) {
+    return <></>;
+  }
+
+  return <StaticControlPoint controlPoint={props.controlPoint} />;
+}
+
+interface MobileControlPointProps {
+  controlPoint: ControlPoint;
+}
+
+export const MobileControlPoint = (props: MobileControlPointProps) => {
+  return (
+    <>
+      <PrimaryMarker
+        controlPoint={props.controlPoint}
+        key={props.controlPoint.destination ? 0 : 1}
+      />
+      <SecondaryMarker
+        controlPoint={props.controlPoint}
+        destination={props.controlPoint.destination}
+      />
+    </>
+  );
+};

client/src/components/controlpoints/MovementPath.tsx

@@ -0,0 +1,35 @@
+import { LatLngLiteral, Polyline as LPolyline } from "leaflet";
+import { forwardRef, useImperativeHandle, useRef } from "react";
+import { Polyline } from "react-leaflet";
+
+interface MovementPathProps {
+  source: LatLngLiteral;
+  destination: LatLngLiteral;
+}
+
+export interface MovementPathHandle {
+  setDestination: (destination: LatLngLiteral) => void;
+}
+
+export const MovementPath = forwardRef<MovementPathHandle, MovementPathProps>(
+  (props: MovementPathProps, ref) => {
+    const lineRef = useRef<LPolyline | null>(null);
+    useImperativeHandle(
+      ref,
+      () => ({
+        setDestination: (destination: LatLngLiteral) => {
+          lineRef.current?.setLatLngs([props.source, destination]);
+        },
+      }),
+      [props]
+    );
+    return (
+      <Polyline
+        positions={[props.source, props.destination]}
+        weight={1}
+        color="#80BA80"
+        ref={lineRef}
+      />
+    );
+  }
+);

client/src/components/controlpoints/StaticControlPoint.tsx

@@ -0,0 +1,27 @@
+import { ControlPoint } from "../../api/_liberationApi";
+import { makeLocationMarkerEventHandlers } from "./EventHandlers";
+import { iconForControlPoint } from "./Icons";
+import LocationTooltipText from "./LocationTooltipText";
+import { Marker, Tooltip } from "react-leaflet";
+
+interface StaticControlPointProps {
+  controlPoint: ControlPoint;
+}
+
+export const StaticControlPoint = (props: StaticControlPointProps) => {
+  return (
+    <Marker
+      position={props.controlPoint.position}
+      icon={iconForControlPoint(props.controlPoint)}
+      // We might draw other markers on top of the CP. The tooltips from the
+      // other markers are helpful so we want to keep them, but make sure the CP
+      // is always the clickable thing.
+      zIndexOffset={1000}
+      eventHandlers={makeLocationMarkerEventHandlers(props.controlPoint)}
+    >
+      <Tooltip>
+        <LocationTooltipText name={props.controlPoint.name} />
+      </Tooltip>
+    </Marker>
+  );
+};

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

@@ -0,0 +1,405 @@
+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,
+          },
+        },
+      });
+      expect(mockPolyline).toHaveBeenCalledTimes(2);
+      expect(mockLayerGroup).toBeCalledTimes(1);
+    });
+    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/index.tsx

@@ -1,21 +1,23 @@
 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";
 import React from "react";
-import ReactDOM from "react-dom";
+import ReactDOM from "react-dom/client";
 import { Provider } from "react-redux";
 
-ReactDOM.render(
+const root = ReactDOM.createRoot(
+  document.getElementById("root") as HTMLElement
+);
+root.render(
   <React.StrictMode>
-    <Provider store={store}>
+    <Provider store={setupStore()}>
       <SocketProvider>
         <App />
       </SocketProvider>
     </Provider>
-  </React.StrictMode>,
-  document.getElementById("root")
+  </React.StrictMode>
 );
 
 // If you want your app to work offline and load faster, you can change

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 = "7.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/__init__.py

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

game/armedforces/armedforces.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import random
 from typing import TYPE_CHECKING, Iterator, Optional
-from game.data.groups import GroupTask
+
 from game.armedforces.forcegroup import ForceGroup
+from game.data.groups import GroupTask
 from game.layout import LAYOUTS
 from game.profiling import logged_duration
 

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
 

game/ato/ai_flight_planner_db.py

@@ -1,648 +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,
-    C_47,
-    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,
-    MQ_9_Reaper,
-    M_2000C,
-    MiG_15bis,
-    MiG_19P,
-    MiG_21Bis,
-    MiG_23MLD,
-    MiG_25PD,
-    MiG_27K,
-    MiG_29A,
-    MiG_29G,
-    MiG_29S,
-    MiG_31,
-    Mirage_2000_5,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1C_200,
-    Mirage_F1CT,
-    MosquitoFBMkVI,
-    P_47D_30,
-    P_47D_30bl1,
-    P_47D_40,
-    P_51D,
-    P_51D_30_NA,
-    RQ_1A_Predator,
-    S_3B,
-    S_3B_Tanker,
-    SpitfireLFMkIX,
-    SpitfireLFMkIXCW,
-    Su_17M4,
-    Su_24M,
-    Su_25,
-    Su_25T,
-    Su_25TM,
-    Su_27,
-    Su_30,
-    Su_33,
-    Su_34,
-    Tornado_GR4,
-    Tornado_IDS,
-    Tu_142,
-    Tu_160,
-    Tu_22M3,
-    Tu_95MS,
-    WingLoong_I,
-    Yak_40,
-)
-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.f15d.f15d import F_15D
-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.su30.su30 import Su_30MKA, Su_30MKI, Su_30MKM, Su_30SM
-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_15D,
-    F_14B,
-    F_14A_135_GR,
-    Su_33,
-    J_11A,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    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_15D,
-    F_15E,
-    F_16C_50,
-    FA_18C_hornet,
-    Tornado_GR4,
-    Tornado_IDS,
-    JAS39Gripen_AG,
-    JF_17,
-    AV8BNA,
-    A_10A,
-    B_1B,
-    A_4E_C,
-    F_14B,
-    F_14A_135_GR,
-    AJS37,
-    Su_24M,
-    Su_17M4,
-    Su_33,
-    F_4E,
-    S_3B,
-    Su_30,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    MiG_29S,
-    MiG_27K,
-    MiG_29A,
-    MiG_21Bis,
-    AH_64D_BLK_II,
-    AH_64D,
-    AH_64A,
-    AH_1W,
-    OH_58D,
-    SA342M,
-    SA342L,
-    Ka_50,
-    Mi_28N,
-    Mi_24P,
-    Mi_24V,
-    Mi_8MT,
-    H_6J,
-    MiG_19P,
-    MiG_15bis,
-    M_2000C,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1CT,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    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,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    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,
-    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_15D,
-    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_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Su_27,
-    MiG_29S,
-    MiG_29G,
-    MiG_29A,
-    F_4E,
-    A_10C_2,
-    A_10C,
-    S_3B,
-    A_4E_C,
-    M_2000C,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1CT,
-    MiG_27K,
-    MiG_21Bis,
-    MiG_15bis,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    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,
-    Su_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Tornado_IDS,
-    Tornado_GR4,
-    AV8BNA,
-    S_3B,
-    A_20G,
-    Ju_88A4,
-    MosquitoFBMkVI,
-    C_101CC,
-    SH_60B,
-]
-
-
-# This list does not "inherit" from the strike list because some strike aircraft can
-# only carry guided weapons, and the AI cannot do runway attack with dguided weapons.
-# https://github.com/dcs-liberation/dcs_liberation/issues/1703
-RUNWAY_ATTACK_CAPABLE = [
-    JF_17,
-    Tornado_IDS,
-    M_2000C,
-    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_30MKA,
-    Su_30MKI,
-    Su_30MKM,
-    Su_30SM,
-    Su_27,
-    MiG_29S,
-    MiG_29G,
-    MiG_29A,
-    F_4E,
-    A_10C_2,
-    A_10C,
-    S_3B,
-    A_4E_C,
-    M_2000C,
-    Mirage_F1B,
-    Mirage_F1BE,
-    Mirage_F1CE,
-    Mirage_F1EE,
-    Mirage_F1EQ,
-    Mirage_F1M_CE,
-    Mirage_F1M_EE,
-    Mirage_F1CT,
-    MiG_27K,
-    MiG_21Bis,
-    MiG_15bis,
-    F_5E_3,
-    F_86F_Sabre,
-    C_101CC,
-    L_39ZA,
-    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,
-    C_47,
-    IL_76MD,
-    An_26B,
-    Yak_40,
-    CH_53E,
-    CH_47D,
-    UH_60L,
-    SH_60B,
-    UH_60A,
-    UH_1H,
-    Mi_8MT,
-    Mi_8MT,
-    Mi_26,
-]
-
-AIR_ASSAULT_CAPABLE = [
-    CH_53E,
-    CH_47D,
-    UH_60L,
-    SH_60B,
-    UH_60A,
-    UH_1H,
-    Mi_8MT,
-    Mi_26,
-    Mi_24P,
-    Mi_24V,
-    Hercules,
-    C_47,
-]
-
-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

@@ -5,12 +5,18 @@ 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 dcs.planes import C_101CC, C_101EB, Su_33, FA_18C_hornet
 
+from game.dcs.aircrafttype import AircraftType
+from pydcs_extensions.hercules.hercules import Hercules
 from .flightroster import FlightRoster
 from .flightstate import FlightState, Navigating, Uninitialized
 from .flightstate.killed import Killed
-from .loadouts import Loadout
+from .loadouts import Loadout, Weapon
+from ..radio.RadioFrequencyContainer import RadioFrequencyContainer
+from ..radio.TacanContainer import TacanContainer
+from ..radio.radios import RadioFrequency
+from ..radio.tacan import TacanChannel
 from ..sidc import (
     Entity,
     SidcDescribable,
@@ -20,7 +26,6 @@ from ..sidc import (
 )
 
 if TYPE_CHECKING:
-    from game.dcs.aircrafttype import AircraftType
     from game.sim.gameupdateevents import GameUpdateEvents
     from game.sim.simulationresults import SimulationResults
     from game.squadrons import Squadron, Pilot
@@ -32,12 +37,13 @@ if TYPE_CHECKING:
     from .package import Package
     from .starttype import StartType
 
+F18_TGP_PYLON: int = 4
 
-class Flight(SidcDescribable):
+
+class Flight(SidcDescribable, RadioFrequencyContainer, TacanContainer):
     def __init__(
         self,
         package: Package,
-        country: str,
         squadron: Squadron,
         count: int,
         flight_type: FlightType,
@@ -46,13 +52,17 @@ class Flight(SidcDescribable):
         custom_name: Optional[str] = None,
         cargo: Optional[TransferOrder] = None,
         roster: Optional[FlightRoster] = None,
+        frequency: Optional[RadioFrequency] = None,
+        channel: Optional[TacanChannel] = None,
+        callsign: Optional[str] = None,
+        claim_inv: bool = True,
     ) -> None:
         self.id = uuid.uuid4()
         self.package = package
-        self.country = country
         self.coalition = squadron.coalition
         self.squadron = squadron
-        self.squadron.claim_inventory(count)
+        if claim_inv:
+            self.squadron.claim_inventory(count)
         if roster is None:
             self.roster = FlightRoster(self.squadron, initial_size=count)
         else:
@@ -60,9 +70,21 @@ class Flight(SidcDescribable):
         self.divert = divert
         self.flight_type = flight_type
         self.loadout = Loadout.default_for(self)
+        if self.squadron.aircraft.name == "F-15I Ra'am":
+            self.loadout.pylons[16] = Weapon.with_clsid(
+                "{IDF_MODS_PROJECT_F-15I_Raam_Dome}"
+            )
         self.start_type = start_type
         self.use_custom_loadout = False
         self.custom_name = custom_name
+        self.group_id: int = 0
+
+        self.frequency = frequency
+        if self.unit_type.dcs_unit_type.tacan:
+            self.tacan = channel
+            self.tcn_name = callsign
+
+        self.initialize_fuel()
 
         # Only used by transport missions.
         self.cargo = cargo
@@ -86,10 +108,25 @@ class Flight(SidcDescribable):
 
         self._flight_plan_builder = FlightPlanBuilderTypes.for_flight(self)(self)
 
+        is_f18 = self.squadron.aircraft.dcs_unit_type.id == FA_18C_hornet.id
+        on_land = not self.squadron.location.is_fleet
+        if on_land and is_f18 and self.coalition.game.settings.atflir_autoswap:
+            self.loadout.pylons[F18_TGP_PYLON] = Weapon.with_clsid(
+                str(
+                    FA_18C_hornet.Pylon4.AN_AAQ_28_LITENING___Targeting_Pod_[1]["clsid"]
+                )
+            )
+
     @property
     def flight_plan(self) -> FlightPlan[Any]:
         return self._flight_plan_builder.get_or_build()
 
+    def degrade_to_custom_flight_plan(self) -> None:
+        from .flightplans.custom import Builder as CustomBuilder
+
+        self._flight_plan_builder = CustomBuilder(self, self.flight_plan.waypoints[1:])
+        self.recreate_flight_plan()
+
     def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
         # Avoid persisting the flight state since that's not (currently) used outside
@@ -139,9 +176,17 @@ class Flight(SidcDescribable):
     def unit_type(self) -> AircraftType:
         return self.squadron.aircraft
 
+    @property
+    def is_lha(self) -> bool:
+        return self.unit_type.lha_capable
+
     @property
     def is_helo(self) -> bool:
-        return self.unit_type.dcs_unit_type.helicopter
+        return self.unit_type.helicopter
+
+    @property
+    def is_hercules(self) -> bool:
+        return self.unit_type == AircraftType.named("C-130J-30 Super Hercules")
 
     @property
     def from_cp(self) -> ControlPoint:
@@ -165,31 +210,43 @@ class Flight(SidcDescribable):
     def missing_pilots(self) -> int:
         return self.roster.missing_pilots
 
+    def set_flight_type(self, var: FlightType) -> None:
+        self.flight_type = var
+
+        # Update _flight_plan_builder so that the builder class remains relevant
+        # to the flight type
+        from .flightplans.flightplanbuildertypes import FlightPlanBuilderTypes
+
+        self._flight_plan_builder = FlightPlanBuilderTypes.for_flight(self)(self)
+
     def return_pilots_and_aircraft(self) -> None:
         self.roster.clear()
         self.squadron.claim_inventory(-self.count)
 
-    def max_takeoff_fuel(self) -> Optional[float]:
-        # Special case so Su 33 and C101 can take off
+    def initialize_fuel(self) -> None:
         unit_type = self.unit_type.dcs_unit_type
+        self.fuel = unit_type.fuel_max
+        # Special cases where we want less fuel for takeoff
         if unit_type == Su_33:
             if self.flight_type.is_air_to_air:
-                return Su_33.fuel_max / 2.2
+                self.fuel = Su_33.fuel_max / 2.2
             else:
-                return Su_33.fuel_max * 0.8
+                self.fuel = Su_33.fuel_max * 0.8
         elif unit_type in {C_101EB, C_101CC}:
-            return unit_type.fuel_max * 0.5
-        return None
+            self.fuel = unit_type.fuel_max * 0.5
+        elif unit_type == Hercules:
+            self.fuel = unit_type.fuel_max * 0.75
+        elif self.departure.cptype.name in ["FARP", "FOB"] and not self.is_helo:
+            self.fuel = unit_type.fuel_max * 0.75
 
     def __repr__(self) -> str:
-        if self.custom_name:
-            return f"{self.custom_name} {self.count} x {self.unit_type}"
-        return f"[{self.flight_type}] {self.count} x {self.unit_type}"
+        return self.__str__()
 
     def __str__(self) -> str:
+        string = f"[{self.flight_type}] {self.count} x {self.unit_type}"
         if self.custom_name:
-            return f"{self.custom_name} {self.count} x {self.unit_type}"
-        return f"[{self.flight_type}] {self.count} x {self.unit_type}"
+            return f"{self.custom_name} - {string}"
+        return string
 
     def abort(self) -> None:
         from .flightplans.rtb import RtbFlightPlan
@@ -247,3 +304,14 @@ class Flight(SidcDescribable):
 
     def recreate_flight_plan(self) -> None:
         self._flight_plan_builder.regenerate()
+
+    @staticmethod
+    def clone_flight(flight: Flight) -> Flight:
+        return Flight(
+            flight.package,
+            flight.squadron,
+            flight.count,
+            flight.flight_type,
+            flight.start_type,
+            flight.divert,
+        )

game/ato/flightplans/_common_ctld.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import random
+from typing import Union, TYPE_CHECKING, Tuple
+
+from game.theater.interfaces.CTLD import CTLD
+from game.theater import ControlPoint
+
+if TYPE_CHECKING:
+    from dcs import Point
+
+
+def generate_random_ctld_point(cp: Union[ControlPoint, CTLD]) -> Point:
+    if isinstance(cp, CTLD) and cp.ctld_zones:
+        zone: Tuple[Point, float] = random.choice(cp.ctld_zones)
+        pos, radius = zone
+        return pos.random_point_within(radius)
+    elif isinstance(cp, CTLD) and isinstance(cp, ControlPoint):
+        return cp.position.random_point_within(2000, 200)
+    raise RuntimeError("Could not generate CTLD point")

game/ato/flightplans/aewc.py

@@ -48,7 +48,9 @@ class Builder(IBuilder[AewcFlightPlan, PatrollingLayout]):
         orbit_heading = heading_to_threat_boundary
 
         # Station 80nm outside the threat zone.
-        threat_buffer = nautical_miles(80)
+        threat_buffer = nautical_miles(
+            self.flight.coalition.game.settings.aewc_threat_buffer_min_distance
+        )
         if self.threat_zones.threatened(location.position):
             orbit_distance = distance_to_threat + threat_buffer
         else:

game/ato/flightplans/airassault.py

@@ -4,29 +4,44 @@ from dataclasses import dataclass
 from datetime import timedelta
 from typing import Iterator, TYPE_CHECKING, Type
 
-from game.ato.flightplans.airlift import AirliftLayout
-from game.ato.flightplans.standard import StandardFlightPlan
+from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
 from game.theater.controlpoint import ControlPointType
 from game.theater.missiontarget import MissionTarget
 from game.utils import Distance, feet, meters
+from ._common_ctld import generate_random_ctld_point
 from .ibuilder import IBuilder
+from .planningerror import PlanningError
+from .uizonedisplay import UiZone, UiZoneDisplay
 from .waypointbuilder import WaypointBuilder
+from ..flightwaypoint import FlightWaypointType
+from ...theater.interfaces.CTLD import CTLD
 
 if TYPE_CHECKING:
+    from dcs import Point
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
-class AirAssaultLayout(AirliftLayout):
+@dataclass
+class AirAssaultLayout(StandardLayout):
+    # The pickup point is optional because we don't always need to load the cargo. When
+    # departing from a carrier, LHA, or off-map spawn, the cargo is pre-loaded.
+    pickup: FlightWaypoint | None
+    nav_to_ingress: list[FlightWaypoint]
+    ingress: FlightWaypoint
+    drop_off: FlightWaypoint | None
+    # This is an implementation detail used by CTLD. The aircraft will not go to this
+    # waypoint. It is used by CTLD as the destination for unloaded troops.
     target: FlightWaypoint
+    nav_to_home: list[FlightWaypoint]
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield from self.nav_to_pickup
-        if self.pickup:
+        if self.pickup is not None:
             yield self.pickup
-        yield from self.nav_to_drop_off
-        yield self.drop_off
+        yield from self.nav_to_ingress
+        yield self.ingress
+        if self.drop_off is not None:
+            yield self.drop_off
         yield self.target
         yield from self.nav_to_home
         yield self.arrival
@@ -35,14 +50,16 @@ class AirAssaultLayout(AirliftLayout):
         yield self.bullseye
 
 
-class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout]):
+class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout], UiZoneDisplay):
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
 
     @property
     def tot_waypoint(self) -> FlightWaypoint:
-        return self.layout.drop_off
+        if self.flight.is_helo and self.layout.drop_off is not None:
+            return self.layout.drop_off
+        return self.layout.target
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.tot_waypoint:
@@ -53,65 +70,78 @@ class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout]):
         return None
 
     @property
-    def engagement_distance(self) -> Distance:
-        # The radius of the WaypointZone created at the target location
+    def ctld_target_zone_radius(self) -> Distance:
         return meters(2500)
 
     @property
     def mission_departure_time(self) -> timedelta:
         return self.package.time_over_target
 
+    def ui_zone(self) -> UiZone:
+        return UiZone(
+            [self.layout.target.position],
+            self.ctld_target_zone_radius,
+        )
+
 
 class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
     def layout(self) -> AirAssaultLayout:
+        if not self.flight.is_helo and not self.flight.is_hercules:
+            raise PlanningError(
+                "Air assault is only usable by helicopters and Anubis' C-130 mod"
+            )
+        assert self.package.waypoints is not None
 
         altitude = feet(1500) if self.flight.is_helo else self.doctrine.ingress_altitude
         altitude_is_agl = self.flight.is_helo
 
         builder = WaypointBuilder(self.flight, self.coalition)
 
-        if not self.flight.is_helo or self.flight.departure.cptype in [
+        if self.flight.is_hercules or self.flight.departure.cptype in [
             ControlPointType.AIRCRAFT_CARRIER_GROUP,
             ControlPointType.LHA_GROUP,
             ControlPointType.OFF_MAP,
         ]:
-            # Non-Helo flights or Off_Map will be preloaded
+            # Off_Map spawns will be preloaded
             # Carrier operations load the logistics directly from the carrier
             pickup = None
             pickup_position = self.flight.departure.position
         else:
-            # Create a special pickup zone for Helos from Airbase / FOB
-            pickup = builder.pickup(
+            pickup = builder.pickup_zone(
                 MissionTarget(
                     "Pickup Zone",
-                    self.flight.departure.position.random_point_within(1200, 600),
+                    self._generate_ctld_pickup(),
                 )
             )
             pickup_position = pickup.position
         assault_area = builder.assault_area(self.package.target)
         heading = self.package.target.position.heading_between_point(pickup_position)
+        if self.flight.is_hercules:
+            assault_area.only_for_player = False
+            assault_area.alt = feet(1000)
+
+        # TODO: define CTLD dropoff zones in campaign miz?
         drop_off_zone = MissionTarget(
             "Dropoff zone",
             self.package.target.position.point_from_heading(heading, 1200),
         )
+        dz = builder.dropoff_zone(drop_off_zone) if self.flight.is_helo else None
 
         return AirAssaultLayout(
             departure=builder.takeoff(self.flight.departure),
-            nav_to_pickup=builder.nav_path(
-                self.flight.departure.position,
-                pickup_position,
-                altitude,
-                altitude_is_agl,
-            ),
             pickup=pickup,
-            nav_to_drop_off=builder.nav_path(
+            nav_to_ingress=builder.nav_path(
                 pickup_position,
-                drop_off_zone.position,
+                self.package.waypoints.ingress,
                 altitude,
                 altitude_is_agl,
             ),
-            drop_off=builder.drop_off(drop_off_zone),
-            stopover=None,
+            ingress=builder.ingress(
+                FlightWaypointType.INGRESS_AIR_ASSAULT,
+                self.package.waypoints.ingress,
+                self.package.target,
+            ),
+            drop_off=dz,
             target=assault_area,
             nav_to_home=builder.nav_path(
                 drop_off_zone.position,
@@ -126,3 +156,7 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
 
     def build(self) -> AirAssaultFlightPlan:
         return AirAssaultFlightPlan(self.flight, self.layout())
+
+    def _generate_ctld_pickup(self) -> Point:
+        assert isinstance(self.flight.departure, CTLD)
+        return generate_random_ctld_point(self.flight.departure)

game/ato/flightplans/airlift.py

@@ -7,33 +7,63 @@ from typing import TYPE_CHECKING, Type
 
 from game.theater.missiontarget import MissionTarget
 from game.utils import feet
+from ._common_ctld import generate_random_ctld_point
 from .ibuilder import IBuilder
 from .planningerror import PlanningError
 from .standard import StandardFlightPlan, StandardLayout
 from .waypointbuilder import WaypointBuilder
+from ...theater.interfaces.CTLD import CTLD
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
+    from dcs import Point
 
 
-@dataclass(frozen=True)
+@dataclass
 class AirliftLayout(StandardLayout):
     nav_to_pickup: list[FlightWaypoint]
+    # There will not be a pickup waypoint when the pickup airfield is the departure
+    # airfield for cargo planes, as the cargo is pre-loaded. Helicopters will still pick
+    # up the cargo near the airfield.
     pickup: FlightWaypoint | None
+    # pickup_zone will be used for player flights to create the CTLD stuff
+    ctld_pickup_zone: FlightWaypoint | None
     nav_to_drop_off: list[FlightWaypoint]
-    drop_off: FlightWaypoint
-    stopover: FlightWaypoint | None
+    # There will not be a drop-off waypoint when the drop-off airfield and the arrival
+    # airfield is the same for a cargo plane, as planes will land to unload and we don't
+    # want a double landing. Helicopters will still drop their cargo near the airfield
+    # before landing.
+    drop_off: FlightWaypoint | None
+    # drop_off_zone will be used for player flights to create the CTLD stuff
+    ctld_drop_off_zone: FlightWaypoint | None
     nav_to_home: list[FlightWaypoint]
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if super().delete_waypoint(waypoint):
+            return True
+        if waypoint in self.nav_to_pickup:
+            self.nav_to_pickup.remove(waypoint)
+            return True
+        elif waypoint in self.nav_to_drop_off:
+            self.nav_to_drop_off.remove(waypoint)
+            return True
+        elif waypoint in self.nav_to_home:
+            self.nav_to_home.remove(waypoint)
+            return True
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to_pickup
         if self.pickup is not None:
             yield self.pickup
+        if self.ctld_pickup_zone is not None:
+            yield self.ctld_pickup_zone
         yield from self.nav_to_drop_off
-        yield self.drop_off
-        if self.stopover is not None:
-            yield self.stopover
+        if self.drop_off is not None:
+            yield self.drop_off
+        if self.ctld_drop_off_zone is not None:
+            yield self.ctld_drop_off_zone
         yield from self.nav_to_home
         yield self.arrival
         if self.divert is not None:
@@ -48,7 +78,11 @@ class AirliftFlightPlan(StandardFlightPlan[AirliftLayout]):
 
     @property
     def tot_waypoint(self) -> FlightWaypoint:
-        return self.layout.drop_off
+        # The TOT is the time that the cargo will be dropped off. If the drop-off
+        # location is the arrival airfield and this is not a helicopter flight, there
+        # will not be a separate drop-off waypoint; the arrival landing waypoint is the
+        # drop-off waypoint.
+        return self.layout.drop_off or self.layout.arrival
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         # TOT planning isn't really useful for transports. They're behind the front
@@ -77,31 +111,26 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
         builder = WaypointBuilder(self.flight, self.coalition)
 
         pickup = None
-        stopover = None
+        drop_off = None
+        pickup_zone = None
+        drop_off_zone = None
+
+        if cargo.origin != self.flight.departure:
+            pickup = builder.cargo_stop(cargo.origin)
+        if cargo.next_stop != self.flight.arrival:
+            drop_off = builder.cargo_stop(cargo.next_stop)
+
         if self.flight.is_helo:
-            # Create a pickupzone where the cargo will be spawned
-            pickup_zone = MissionTarget(
-                "Pickup Zone", cargo.origin.position.random_point_within(1000, 200)
+            # Create CTLD Zones for Helo flights
+            pickup_zone = builder.pickup_zone(
+                MissionTarget("Pickup Zone", self._generate_ctld_pickup())
             )
-            pickup = builder.pickup(pickup_zone)
-            # If The cargo is at the departure controlpoint, the pickup waypoint should
-            # only be created for client flights
-            pickup.only_for_player = cargo.origin == self.flight.departure
-
-            # Create a dropoff zone where the cargo should be dropped
-            drop_off_zone = MissionTarget(
-                "Dropoff zone",
-                cargo.next_stop.position.random_point_within(1000, 200),
+            drop_off_zone = builder.dropoff_zone(
+                MissionTarget("Dropoff zone", self._generate_ctld_dropoff())
             )
-            drop_off = builder.drop_off(drop_off_zone)
-
-            # Add an additional stopover point so that the flight can refuel
-            stopover = builder.stopover(cargo.next_stop)
-        else:
-            # Fixed Wing will get stopover points for pickup and dropoff
-            if cargo.origin != self.flight.departure:
-                pickup = builder.stopover(cargo.origin, "PICKUP")
-            drop_off = builder.stopover(cargo.next_stop, "DROP OFF")
+            # Show the zone waypoints only to the player
+            pickup_zone.only_for_player = True
+            drop_off_zone.only_for_player = True
 
         nav_to_pickup = builder.nav_path(
             self.flight.departure.position,
@@ -110,20 +139,11 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
             altitude_is_agl,
         )
 
-        if self.flight.client_count > 0:
-            # Normal Landing Waypoint
-            arrival = builder.land(self.flight.arrival)
-        else:
-            # The AI Needs another Stopover point to actually fly back to the original
-            # base. Otherwise the Cargo drop will be the new Landing Waypoint and the
-            # AI will end its mission there instead of flying back.
-            # https://forum.dcs.world/topic/211775-landing-to-refuel-and-rearm-the-landingrefuar-waypoint/
-            arrival = builder.stopover(self.flight.arrival, "LANDING")
-
         return AirliftLayout(
             departure=builder.takeoff(self.flight.departure),
             nav_to_pickup=nav_to_pickup,
             pickup=pickup,
+            ctld_pickup_zone=pickup_zone,
             nav_to_drop_off=builder.nav_path(
                 cargo.origin.position,
                 cargo.next_stop.position,
@@ -131,17 +151,29 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
                 altitude_is_agl,
             ),
             drop_off=drop_off,
-            stopover=stopover,
+            ctld_drop_off_zone=drop_off_zone,
             nav_to_home=builder.nav_path(
                 cargo.origin.position,
                 self.flight.arrival.position,
                 altitude,
                 altitude_is_agl,
             ),
-            arrival=arrival,
+            arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
         )
 
     def build(self) -> AirliftFlightPlan:
         return AirliftFlightPlan(self.flight, self.layout())
+
+    def _generate_ctld_pickup(self) -> Point:
+        cargo = self.flight.cargo
+        if cargo and cargo.origin and isinstance(cargo.origin, CTLD):
+            return generate_random_ctld_point(cargo.origin)
+        raise RuntimeError("Could not generate CTLD pickup")
+
+    def _generate_ctld_dropoff(self) -> Point:
+        cargo = self.flight.cargo
+        if cargo and cargo.transport and isinstance(cargo.transport.destination, CTLD):
+            return generate_random_ctld_point(cargo.transport.destination)
+        raise RuntimeError("Could not generate CTLD dropoff")

game/ato/flightplans/antiship.py

@@ -35,7 +35,7 @@ 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]:

game/ato/flightplans/capbuilder.py

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

game/ato/flightplans/cas.py

@@ -10,6 +10,7 @@ from game.utils import Distance, Speed, kph, meters
 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
 
@@ -17,7 +18,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class CasLayout(PatrollingLayout):
     target: FlightWaypoint
 
@@ -28,13 +29,13 @@ class CasLayout(PatrollingLayout):
         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
 
 
-class CasFlightPlan(PatrollingFlightPlan[CasLayout]):
+class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
@@ -52,7 +53,7 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout]):
 
     @property
     def engagement_distance(self) -> Distance:
-        max_length = self.flight.coalition.game.settings.max_frontline_length * 1000
+        max_length = self.flight.coalition.game.settings.max_frontline_width * 1000
         return meters(max_length) / 2
 
     @property
@@ -65,6 +66,12 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout]):
     def dismiss_escort_at(self) -> FlightWaypoint | None:
         return self.layout.patrol_end
 
+    def ui_zone(self) -> UiZone:
+        return UiZone(
+            [self.layout.target.position],
+            self.engagement_distance,
+        )
+
 
 class Builder(IBuilder[CasFlightPlan, CasLayout]):
     def layout(self) -> CasLayout:

game/ato/flightplans/custom.py

@@ -8,13 +8,14 @@ from typing import TYPE_CHECKING, Type
 from .flightplan import FlightPlan, Layout
 from .ibuilder import IBuilder
 from .waypointbuilder import WaypointBuilder
+from .. import Flight
 from ..flightwaypointtype import FlightWaypointType
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class CustomLayout(Layout):
     custom_waypoints: list[FlightWaypoint]
 
@@ -43,7 +44,7 @@ class CustomFlightPlan(FlightPlan[CustomLayout]):
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.tot_waypoint:
-            return self.package.time_over_target
+            return self.package.time_over_target + self.tot_offset
         return None
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
@@ -55,9 +56,17 @@ class CustomFlightPlan(FlightPlan[CustomLayout]):
 
 
 class Builder(IBuilder[CustomFlightPlan, CustomLayout]):
+    def __init__(
+        self, flight: Flight, waypoints: list[FlightWaypoint] | None = None
+    ) -> None:
+        super().__init__(flight)
+        if waypoints is None:
+            waypoints = []
+        self.waypoints = waypoints
+
     def layout(self) -> CustomLayout:
         builder = WaypointBuilder(self.flight, self.coalition)
-        return CustomLayout(builder.takeoff(self.flight.departure), [])
+        return CustomLayout(builder.takeoff(self.flight.departure), self.waypoints)
 
     def build(self) -> CustomFlightPlan:
         return CustomFlightPlan(self.flight, self.layout())

game/ato/flightplans/escort.py

@@ -24,12 +24,15 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
         ingress, target = builder.escort(
             self.package.waypoints.ingress, self.package.target
         )
+        ingress.only_for_player = True
+        target.only_for_player = True
         hold = builder.hold(self._hold_point())
         join = builder.join(self.package.waypoints.join)
         split = builder.split(self.package.waypoints.split)
-        refuel = None
-        if self.package.waypoints.refuel is not None:
-            refuel = builder.refuel(self.package.waypoints.refuel)
+        refuel = builder.refuel(self.package.waypoints.refuel)
+        initial = builder.escort_hold(
+            self.package.waypoints.initial, self.doctrine.ingress_altitude
+        )
 
         return FormationAttackLayout(
             departure=builder.takeoff(self.flight.departure),
@@ -39,11 +42,12 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
             ),
             join=join,
             ingress=ingress,
+            initial=initial,
             targets=[target],
             split=split,
             refuel=refuel,
             nav_from=builder.nav_path(
-                split.position,
+                refuel.position,
                 self.flight.arrival.position,
                 self.doctrine.ingress_altitude,
             ),

game/ato/flightplans/ferry.py

@@ -15,10 +15,18 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class FerryLayout(StandardLayout):
     nav_to_destination: list[FlightWaypoint]
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if super().delete_waypoint(waypoint):
+            return True
+        if waypoint in self.nav_to_destination:
+            self.nav_to_destination.remove(waypoint)
+            return True
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to_destination

game/ato/flightplans/flightplan.py

@@ -41,7 +41,7 @@ INGRESS_TYPES = {
 }
 
 
-@dataclass(frozen=True)
+@dataclass
 class Layout(ABC):
     departure: FlightWaypoint
 
@@ -50,6 +50,9 @@ class Layout(ABC):
         """A list of all waypoints in the flight plan, in order."""
         return list(self.iter_waypoints())
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         """Iterates over all waypoints in the flight plan, in order."""
         raise NotImplementedError
@@ -62,6 +65,12 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def __init__(self, flight: Flight, layout: LayoutT) -> None:
         self.flight = flight
         self.layout = layout
+        self.tot_offset = self.default_tot_offset()
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        if "tot_offset" not in state:
+            state["tot_offset"] = self.default_tot_offset()
+        self.__dict__.update(state)
 
     @property
     def package(self) -> Package:
@@ -72,6 +81,15 @@ class FlightPlan(ABC, Generic[LayoutT]):
         """A list of all waypoints in the flight plan, in order."""
         return list(self.iter_waypoints())
 
+    def get_index_of_wpt_by_type(self, wpt_type: FlightWaypointType) -> int:
+        index = 0
+        for wpt in self.waypoints:
+            if wpt and not wpt.only_for_player:
+                index += 1
+                if wpt.waypoint_type == wpt_type:
+                    return index
+        return -1
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         """Iterates over all waypoints in the flight plan, in order."""
         yield from self.layout.iter_waypoints()
@@ -195,8 +213,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

game/ato/flightplans/flightplanbuildertypes.py

@@ -19,6 +19,7 @@ from .ocarunway import OcaRunwayFlightPlan
 from .packagerefueling import PackageRefuelingFlightPlan
 from .planningerror import PlanningError
 from .sead import SeadFlightPlan
+from .seadsweep import SeadSweepFlightPlan
 from .strike import StrikeFlightPlan
 from .sweep import SweepFlightPlan
 from .tarcap import TarCapFlightPlan
@@ -26,12 +27,13 @@ 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]]:
+        from game.theater import FrontLine
+
         if flight.flight_type is FlightType.REFUELING:
             if flight.package.target.is_friendly(flight.squadron.player) or isinstance(
                 flight.package.target, FrontLine
@@ -50,6 +52,7 @@ class FlightPlanBuilderTypes:
             FlightType.OCA_RUNWAY: OcaRunwayFlightPlan.builder_type(),
             FlightType.SEAD: SeadFlightPlan.builder_type(),
             FlightType.SEAD_ESCORT: EscortFlightPlan.builder_type(),
+            FlightType.SEAD_SWEEP: SeadSweepFlightPlan.builder_type(),
             FlightType.STRIKE: StrikeFlightPlan.builder_type(),
             FlightType.SWEEP: SweepFlightPlan.builder_type(),
             FlightType.TARCAP: TarCapFlightPlan.builder_type(),

game/ato/flightplans/formation.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from datetime import timedelta
 from functools import cached_property
-from typing import Any, TYPE_CHECKING, TypeGuard
+from typing import Any, TYPE_CHECKING, TypeGuard, Optional
 
 from game.typeguard import self_type_guard
 from game.utils import Speed
@@ -16,14 +16,28 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class FormationLayout(LoiterLayout, ABC):
     nav_to: list[FlightWaypoint]
-    join: FlightWaypoint
+    join: Optional[FlightWaypoint]
     split: FlightWaypoint
-    refuel: FlightWaypoint
+    refuel: Optional[FlightWaypoint]
     nav_from: list[FlightWaypoint]
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if super().delete_waypoint(waypoint):
+            return True
+        if waypoint in self.nav_to:
+            self.nav_to.remove(waypoint)
+            return True
+        elif waypoint in self.nav_from:
+            self.nav_from.remove(waypoint)
+            return True
+        elif waypoint == self.refuel:
+            self.refuel = None
+            return True
+        return False
+
 
 class FormationFlightPlan(LoiterFlightPlan, ABC):
     @property
@@ -59,10 +73,7 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
         return min(speeds)
 
     def speed_between_waypoints(self, a: FlightWaypoint, b: FlightWaypoint) -> Speed:
-        if b in self.package_speed_waypoints:
-            # Should be impossible, as any package with at least one
-            # FormationFlightPlan flight needs a formation speed.
-            assert self.package.formation_speed is not None
+        if self.package.formation_speed and b in self.package_speed_waypoints:
             return self.package.formation_speed
         return super().speed_between_waypoints(a, b)
 
@@ -83,9 +94,9 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.join:
-            return self.join_time
+            return self.join_time + self.tot_offset
         elif waypoint == self.layout.split:
-            return self.split_time
+            return self.split_time + self.tot_offset
         return None
 
     @property

game/ato/flightplans/formationattack.py

@@ -4,7 +4,7 @@ from abc import ABC
 from collections.abc import Iterator
 from dataclasses import dataclass
 from datetime import timedelta
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, Optional
 
 from dcs import Point
 
@@ -25,10 +25,6 @@ if TYPE_CHECKING:
 
 
 class FormationAttackFlightPlan(FormationFlightPlan, ABC):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta()
-
     @property
     def package_speed_waypoints(self) -> set[FlightWaypoint]:
         return {
@@ -50,13 +46,6 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.targets[0]
 
-    @property
-    def tot_offset(self) -> timedelta:
-        try:
-            return -self.lead_time
-        except AttributeError:
-            return timedelta()
-
     @property
     def target_area_waypoint(self) -> FlightWaypoint:
         return FlightWaypoint(
@@ -122,25 +111,40 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
         )
         return tot - travel_time
 
+    @property
+    def initial_time(self) -> timedelta:
+        tot = self.tot
+        travel_time = self.travel_time_between_waypoints(
+            self.layout.initial, self.target_area_waypoint
+        )
+        return tot - travel_time
+
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.ingress:
             return self.ingress_time
+        elif waypoint == self.layout.initial:
+            return self.initial_time
         elif waypoint in self.layout.targets:
             return self.tot
         return super().tot_for_waypoint(waypoint)
 
 
-@dataclass(frozen=True)
+@dataclass
 class FormationAttackLayout(FormationLayout):
     ingress: FlightWaypoint
     targets: list[FlightWaypoint]
+    initial: Optional[FlightWaypoint] = None
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield self.hold
+        if self.hold:
+            yield self.hold
         yield from self.nav_to
-        yield self.join
+        if self.join:
+            yield self.join
         yield self.ingress
+        if self.initial is not None:
+            yield self.initial
         yield from self.targets
         yield self.split
         if self.refuel is not None:
@@ -178,28 +182,46 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
                 )
             )
 
-        hold = builder.hold(self._hold_point())
-        join = builder.join(self.package.waypoints.join)
+        hold = None
+        join = None
+        if (
+            self.flight is self.package.primary_flight
+            or self.package.primary_flight
+            and isinstance(
+                self.package.primary_flight.flight_plan, FormationAttackFlightPlan
+            )
+        ):
+            hold = builder.hold(self._hold_point())
+            join = builder.join(self.package.waypoints.join)
         split = builder.split(self.package.waypoints.split)
-        refuel = None
-        if self.package.waypoints.refuel is not None:
-            refuel = builder.refuel(self.package.waypoints.refuel)
+        refuel = builder.refuel(self.package.waypoints.refuel)
+
+        ingress = builder.ingress(
+            ingress_type, self.package.waypoints.ingress, self.package.target
+        )
+
+        initial = None
+        if ingress_type == FlightWaypointType.INGRESS_SEAD:
+            initial = builder.sead_search(self.package.target)
+        elif ingress_type == FlightWaypointType.INGRESS_SEAD_SWEEP:
+            initial = builder.sead_sweep(self.package.target)
 
         return FormationAttackLayout(
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
             nav_to=builder.nav_path(
-                hold.position, join.position, self.doctrine.ingress_altitude
+                hold.position if hold else self.flight.departure.position,
+                join.position if join else ingress.position,
+                self.doctrine.ingress_altitude,
             ),
             join=join,
-            ingress=builder.ingress(
-                ingress_type, self.package.waypoints.ingress, self.package.target
-            ),
+            ingress=ingress,
+            initial=initial,
             targets=target_waypoints,
             split=split,
             refuel=refuel,
             nav_from=builder.nav_path(
-                split.position,
+                refuel.position,
                 self.flight.arrival.position,
                 self.doctrine.ingress_altitude,
             ),
@@ -216,7 +238,7 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             return builder.bai_group(target)
         elif flight.flight_type == FlightType.DEAD:
             return builder.dead_point(target)
-        elif flight.flight_type == FlightType.SEAD:
+        elif flight.flight_type in {FlightType.SEAD, FlightType.SEAD_SWEEP}:
             return builder.sead_point(target)
         else:
             return builder.strike_point(target)

game/ato/flightplans/loiter.py

@@ -3,7 +3,7 @@ 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 typing import Any, TYPE_CHECKING, TypeGuard, Optional
 
 from game.typeguard import self_type_guard
 from .flightplan import FlightPlan
@@ -13,9 +13,9 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class LoiterLayout(StandardLayout, ABC):
-    hold: FlightWaypoint
+    hold: Optional[FlightWaypoint]
 
 
 class LoiterFlightPlan(StandardFlightPlan[Any], ABC):
@@ -30,7 +30,7 @@ class LoiterFlightPlan(StandardFlightPlan[Any], ABC):
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.hold:
-            return self.push_time
+            return self.push_time + self.tot_offset
         return None
 
     def travel_time_between_waypoints(

game/ato/flightplans/ocaaircraft.py

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

game/ato/flightplans/patrolling.py

@@ -9,19 +9,31 @@ from typing import Any, TYPE_CHECKING, TypeGuard, TypeVar
 from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
 from game.typeguard import self_type_guard
 from game.utils import Distance, Speed
+from .uizonedisplay import UiZone, UiZoneDisplay
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
     from .flightplan import FlightPlan
 
 
-@dataclass(frozen=True)
+@dataclass
 class PatrollingLayout(StandardLayout):
     nav_to: list[FlightWaypoint]
     patrol_start: FlightWaypoint
     patrol_end: FlightWaypoint
     nav_from: list[FlightWaypoint]
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if super().delete_waypoint(waypoint):
+            return True
+        if waypoint in self.nav_to:
+            self.nav_to.remove(waypoint)
+            return True
+        elif waypoint in self.nav_from:
+            self.nav_from.remove(waypoint)
+            return True
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to
@@ -37,7 +49,7 @@ class PatrollingLayout(StandardLayout):
 LayoutT = TypeVar("LayoutT", bound=PatrollingLayout)
 
 
-class PatrollingFlightPlan(StandardFlightPlan[LayoutT], ABC):
+class PatrollingFlightPlan(StandardFlightPlan[LayoutT], UiZoneDisplay, ABC):
     @property
     @abstractmethod
     def patrol_duration(self) -> timedelta:
@@ -61,7 +73,7 @@ class PatrollingFlightPlan(StandardFlightPlan[LayoutT], ABC):
 
     @property
     def patrol_start_time(self) -> timedelta:
-        return self.package.time_over_target
+        return self.package.time_over_target + self.tot_offset
 
     @property
     def patrol_end_time(self) -> timedelta:
@@ -97,3 +109,9 @@ class PatrollingFlightPlan(StandardFlightPlan[LayoutT], ABC):
         self, flight_plan: FlightPlan[Any]
     ) -> TypeGuard[PatrollingFlightPlan[Any]]:
         return True
+
+    def ui_zone(self) -> UiZone:
+        return UiZone(
+            [self.layout.patrol_start.position, self.layout.patrol_end.position],
+            self.engagement_distance,
+        )

game/ato/flightplans/rtb.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class RtbLayout(StandardLayout):
     abort_location: FlightWaypoint
     nav_to_destination: list[FlightWaypoint]

game/ato/flightplans/sead.py

@@ -16,9 +16,8 @@ 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]):

game/ato/flightplans/seadsweep.py

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

game/ato/flightplans/standard.py

@@ -10,12 +10,18 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class StandardLayout(Layout, ABC):
     arrival: FlightWaypoint
     divert: FlightWaypoint | None
     bullseye: FlightWaypoint
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if waypoint is self.divert:
+            self.divert = None
+            return True
+        return False
+
 
 LayoutT = TypeVar("LayoutT", bound=StandardLayout)
 

game/ato/flightplans/sweep.py

@@ -17,22 +17,20 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class SweepLayout(LoiterLayout):
     nav_to: list[FlightWaypoint]
     sweep_start: FlightWaypoint
     sweep_end: FlightWaypoint
-    refuel: FlightWaypoint | None
     nav_from: list[FlightWaypoint]
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield self.hold
+        if self.hold:
+            yield self.hold
         yield from self.nav_to
         yield self.sweep_start
         yield self.sweep_end
-        if self.refuel is not None:
-            yield self.refuel
         yield from self.nav_from
         yield self.arrival
         if self.divert is not None:
@@ -41,10 +39,6 @@ class SweepLayout(LoiterLayout):
 
 
 class SweepFlightPlan(LoiterFlightPlan):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=5)
-
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
@@ -57,9 +51,8 @@ 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:
@@ -74,14 +67,14 @@ class SweepFlightPlan(LoiterFlightPlan):
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.sweep_start:
-            return self.sweep_start_time
+            return self.sweep_start_time + self.tot_offset
         if waypoint == self.layout.sweep_end:
-            return self.sweep_end_time
+            return self.sweep_end_time + self.tot_offset
         return None
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.hold:
-            return self.push_time
+            return self.push_time + self.tot_offset
         return None
 
     @property
@@ -92,6 +85,7 @@ class SweepFlightPlan(LoiterFlightPlan):
             GroundSpeed.for_flight(self.flight, self.layout.hold.alt),
         )
 
+    @property
     def mission_departure_time(self) -> timedelta:
         return self.sweep_end_time
 
@@ -112,11 +106,6 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
 
         hold = builder.hold(self._hold_point())
 
-        refuel = None
-
-        if self.package.waypoints is not None:
-            refuel = builder.refuel(self.package.waypoints.refuel)
-
         return SweepLayout(
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
@@ -130,7 +119,6 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
             ),
             sweep_start=start,
             sweep_end=end,
-            refuel=refuel,
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),

game/ato/flightplans/tarcap.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class TarCapLayout(PatrollingLayout):
     refuel: FlightWaypoint | None
 
@@ -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,9 +60,8 @@ 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:
         if waypoint == self.layout.patrol_end:
@@ -105,9 +100,11 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
         start, end = builder.race_track(orbit0p, orbit1p, patrol_alt)
 
         refuel = None
+        nav_from_origin = orbit1p
 
         if self.package.waypoints is not None:
             refuel = builder.refuel(self.package.waypoints.refuel)
+            nav_from_origin = refuel.position
 
         return TarCapLayout(
             departure=builder.takeoff(self.flight.departure),
@@ -115,7 +112,7 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
                 self.flight.departure.position, orbit0p, patrol_alt
             ),
             nav_from=builder.nav_path(
-                orbit1p, self.flight.arrival.position, patrol_alt
+                nav_from_origin, self.flight.arrival.position, patrol_alt
             ),
             patrol_start=start,
             patrol_end=end,

game/ato/flightplans/theaterrefueling.py

@@ -17,7 +17,7 @@ class TheaterRefuelingFlightPlan(RefuelingFlightPlan):
 
     @property
     def patrol_duration(self) -> timedelta:
-        return timedelta(hours=1)
+        return self.flight.coalition.game.settings.desired_tanker_on_station_time
 
 
 class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
@@ -36,7 +36,9 @@ class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
         orbit_heading = heading_to_threat_boundary
 
         # Station 70nm outside the threat zone.
-        threat_buffer = nautical_miles(70)
+        threat_buffer = nautical_miles(
+            self.flight.coalition.game.settings.tanker_threat_buffer_min_distance
+        )
         if self.threat_zones.threatened(location.position):
             orbit_distance = distance_to_threat + threat_buffer
         else:

game/ato/flightplans/uizonedisplay.py

@@ -0,0 +1,18 @@
+import abc
+from dataclasses import dataclass
+
+from dcs import Point
+
+from game.utils import Distance
+
+
+@dataclass(frozen=True)
+class UiZone:
+    points: list[Point]
+    radius: Distance
+
+
+class UiZoneDisplay(abc.ABC):
+    @abc.abstractmethod
+    def ui_zone(self) -> UiZone:
+        ...

game/ato/flightplans/waypointbuilder.py

@@ -14,6 +14,7 @@ from typing import (
 
 from dcs.mapping import Point, Vector2
 
+from game.ato.flightplans._common_ctld import generate_random_ctld_point
 from game.ato.flightwaypoint import AltitudeReference, FlightWaypoint
 from game.ato.flightwaypointtype import FlightWaypointType
 from game.theater import (
@@ -23,7 +24,8 @@ from game.theater import (
     TheaterGroundObject,
     TheaterUnit,
 )
-from game.utils import Distance, meters, nautical_miles
+from game.theater.interfaces.CTLD import CTLD
+from game.utils import Distance, meters, nautical_miles, feet
 
 if TYPE_CHECKING:
     from game.coalition import Coalition
@@ -127,10 +129,9 @@ class WaypointBuilder:
         position = divert.position
         altitude_type: AltitudeReference
         if isinstance(divert, OffMapSpawn):
-            if self.is_helo:
-                altitude = meters(500)
-            else:
-                altitude = self.doctrine.rendezvous_altitude
+            altitude = (
+                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude
+            )
             altitude_type = "BARO"
         else:
             altitude = meters(0)
@@ -225,15 +226,17 @@ class WaypointBuilder:
         position: Point,
         objective: MissionTarget,
     ) -> FlightWaypoint:
+        alt = self.doctrine.ingress_altitude
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.flight.is_hercules:
             alt_type = "RADIO"
+            alt = meters(60) if self.is_helo else feet(1000)
 
         return FlightWaypoint(
             "INGRESS",
             ingress_type,
             position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
+            alt,
             alt_type,
             description=f"INGRESS on {objective.name}",
             pretty_name=f"INGRESS on {objective.name}",
@@ -287,12 +290,9 @@ class WaypointBuilder:
         return self._target_area(f"STRIKE {target.name}", target)
 
     def sead_area(self, target: MissionTarget) -> FlightWaypoint:
-        # Set flyover with ingress altitude to allow the flight to search and engage
-        # the target group at the ingress alt without suicide dive
         return self._target_area(
             f"SEAD on {target.name}",
             target,
-            flyover=True,
             altitude=self.doctrine.ingress_altitude,
             alt_type="BARO",
         )
@@ -304,10 +304,17 @@ class WaypointBuilder:
         return self._target_area(f"ATTACK {target.name}", target, flyover=True)
 
     def assault_area(self, target: MissionTarget) -> FlightWaypoint:
+        """A destination waypoint used by air-assault ground troops.
+
+        This waypoint is an implementation detail for CTLD and should not be followed by
+        aircraft.
+        """
+        # TODO: Add a property that can hide this waypoint from the player's flight
+        # plan.
         return self._target_area(f"ASSAULT {target.name}", target)
 
-    @staticmethod
     def _target_area(
+        self,
         name: str,
         location: MissionTarget,
         flyover: bool = False,
@@ -415,6 +422,73 @@ class WaypointBuilder:
             pretty_name="Orbit",
         )
 
+    def sead_search(self, target: MissionTarget) -> FlightWaypoint:
+        hold = self._sead_search_point(target)
+
+        return FlightWaypoint(
+            "SEAD Search",
+            FlightWaypointType.NAV,
+            hold,
+            self.doctrine.ingress_altitude,
+            alt_type="BARO",
+            description="Anchor and search from this point",
+            pretty_name="SEAD Search",
+        )
+
+    def sead_sweep(self, target: MissionTarget) -> FlightWaypoint:
+        hold = self._sead_search_point(target)
+
+        return FlightWaypoint(
+            "SEAD Sweep",
+            FlightWaypointType.NAV,
+            hold,
+            self.doctrine.ingress_altitude,
+            alt_type="BARO",
+            description="Anchor and search from this point",
+            pretty_name="SEAD Sweep",
+        )
+
+    def _sead_search_point(self, target: MissionTarget) -> Point:
+        """Creates custom waypoint for AI SEAD flights
+            to avoid having them fly all the way to the SAM site.
+        Args:
+            target: Target information.
+        """
+        # Use the threat range as offset distance to avoid flying all the way to the SAM site
+        assert self.flight.package.waypoints
+        ingress = self.flight.package.waypoints.ingress
+        ingress2tgt_dist = ingress.distance_to_point(target.position)
+        threat_range = nautical_miles(
+            self.flight.coalition.game.settings.sead_threat_buffer_min_distance
+        ).meters
+        if target.strike_targets:
+            threat_range = (
+                1.1 * max([x.threat_range for x in target.strike_targets]).meters
+            )
+        hdg = target.position.heading_between_point(ingress)
+        hold = target.position.point_from_heading(
+            hdg, min(threat_range, ingress2tgt_dist * 0.95)
+        )
+        return hold
+
+    @staticmethod
+    def escort_hold(start: Point, altitude: Distance) -> FlightWaypoint:
+        """Creates custom waypoint for escort flights that need to hold.
+
+        Args:
+            start: Position of the waypoint.
+            altitude: Altitude of the holding pattern.
+        """
+
+        return FlightWaypoint(
+            "ESCORT HOLD",
+            FlightWaypointType.CUSTOM,
+            start,
+            altitude,
+            description="Anchor and hold at this point",
+            pretty_name="Escort Hold",
+        )
+
     @staticmethod
     def sweep_start(position: Point, altitude: Distance) -> FlightWaypoint:
         """Creates a sweep start waypoint.
@@ -494,58 +568,54 @@ class WaypointBuilder:
         )
 
     @staticmethod
-    def stopover(stopover: ControlPoint, name: str = "STOPOVER") -> FlightWaypoint:
-        """Creates a stopover waypoint.
-
-        Args:
-            control_point: Pick up location.
+    def pickup_zone(pick_up: MissionTarget) -> FlightWaypoint:
+        """Creates a pickup landing zone waypoint
+        This waypoint is used to generate the Trigger Zone used for AirAssault and
+        AirLift using the CTLD plugin (see LogisticsGenerator)
         """
         return FlightWaypoint(
-            name,
-            FlightWaypointType.STOPOVER,
-            stopover.position,
-            meters(0),
-            "RADIO",
-            description=f"Stopover at {stopover}",
-            pretty_name="Stopover location",
-            control_point=stopover,
-        )
-
-    @staticmethod
-    def pickup(pick_up: MissionTarget) -> FlightWaypoint:
-        """Creates a cargo pickup waypoint.
-
-        Args:
-            control_point: Pick up location.
-        """
-        control_point = pick_up if isinstance(pick_up, ControlPoint) else None
-        return FlightWaypoint(
-            "PICKUP",
-            FlightWaypointType.PICKUP,
+            "PICKUPZONE",
+            FlightWaypointType.PICKUP_ZONE,
             pick_up.position,
             meters(0),
             "RADIO",
             description=f"Pick up cargo from {pick_up.name}",
-            pretty_name="Pick up location",
-            control_point=control_point,
+            pretty_name="Pick-up zone",
         )
 
     @staticmethod
-    def drop_off(drop_off: MissionTarget) -> FlightWaypoint:
-        """Creates a cargo drop-off waypoint.
-
-        Args:
-            control_point: Drop-off location.
+    def dropoff_zone(drop_off: MissionTarget) -> FlightWaypoint:
+        """Creates a dropoff landing zone waypoint
+        This waypoint is used to generate the Trigger Zone used for AirAssault and
+        AirLift using the CTLD plugin (see LogisticsGenerator)
         """
-        control_point = drop_off if isinstance(drop_off, ControlPoint) else None
         return FlightWaypoint(
-            "DROP OFF",
-            FlightWaypointType.DROP_OFF,
+            "DROPOFFZONE",
+            FlightWaypointType.DROPOFF_ZONE,
             drop_off.position,
             meters(0),
             "RADIO",
             description=f"Drop off cargo at {drop_off.name}",
-            pretty_name="Drop off location",
+            pretty_name="Drop-off zone",
+        )
+
+    @staticmethod
+    def cargo_stop(control_point: ControlPoint) -> FlightWaypoint:
+        """Creates a cargo stop waypoint.
+        This waypoint is used by AirLift as a landing and stopover waypoint
+        """
+        if isinstance(control_point, CTLD) and control_point.ctld_zones:
+            pos = generate_random_ctld_point(control_point)
+        else:
+            pos = control_point.position
+        return FlightWaypoint(
+            "CARGOSTOP",
+            FlightWaypointType.CARGO_STOP,
+            pos,
+            meters(0),
+            "RADIO",
+            description=f"Stop for cargo at {control_point.name}",
+            pretty_name="Cargo stop",
             control_point=control_point,
         )
 

game/ato/flightstate/flightstate.py

@@ -82,9 +82,7 @@ class FlightState(ABC):
 
     def estimate_fuel(self) -> float:
         """Returns the estimated remaining fuel **in kilograms**."""
-        if (max_takeoff_fuel := self.flight.max_takeoff_fuel()) is not None:
-            return max_takeoff_fuel
-        return self.flight.unit_type.dcs_unit_type.fuel_max
+        return self.flight.fuel
 
     @property
     @abstractmethod

game/ato/flightstate/inflight.py

@@ -137,6 +137,7 @@ class InFlight(FlightState, ABC):
             FlightWaypointType.INGRESS_OCA_RUNWAY,
             FlightWaypointType.INGRESS_SEAD,
             FlightWaypointType.INGRESS_STRIKE,
+            FlightWaypointType.INGRESS_AIR_ASSAULT,
         }
         return self.current_waypoint.waypoint_type in contact_types
 

game/ato/flightstate/navigating.py

@@ -40,6 +40,11 @@ class Navigating(InFlight):
         )
 
     def estimate_altitude(self) -> tuple[Distance, str]:
+        # This does not behave well when one of the waypoints is AGL and the other is
+        # MSL. We can't really avoid that problem though. We don't know where the ground
+        # is, so conversions between them are impossible, and we do need to use AGL
+        # altitudes for takeoff and landing waypoints (even if we had the runway
+        # elevation, we don't have elevation for FARPs).
         return (
             meters(
                 lerp(

game/ato/flighttype.py

@@ -24,8 +24,8 @@ class FlightType(Enum):
     * Implementations of MissionTarget.mission_types: A mission type can only be planned
       against compatible targets. The mission_types method of each target class defines
       which missions may target it.
-    * ai_flight_planner_db.py: Add the new mission type to aircraft_for_task that
-      returns the list of compatible aircraft in order of preference.
+    * resources/units/aircraft/*.yaml: Assign aircraft weight for the new task type in
+      the `tasks` dict for all capable aircraft.
 
     You may also need to update:
 
@@ -57,6 +57,7 @@ class FlightType(Enum):
     REFUELING = "Refueling"
     FERRY = "Ferry"
     AIR_ASSAULT = "Air Assault"
+    SEAD_SWEEP = "SEAD Sweep"  # Reintroduce legacy "engage-whatever-you-can-find" SEAD
 
     def __str__(self) -> str:
         return self.value
@@ -91,6 +92,7 @@ class FlightType(Enum):
             FlightType.OCA_AIRCRAFT,
             FlightType.SEAD_ESCORT,
             FlightType.AIR_ASSAULT,
+            FlightType.SEAD_SWEEP,
         }
 
     @property
@@ -110,6 +112,7 @@ class FlightType(Enum):
             FlightType.REFUELING: AirEntity.TANKER,
             FlightType.SEAD: AirEntity.SUPPRESSION_OF_ENEMY_AIR_DEFENCE,
             FlightType.SEAD_ESCORT: AirEntity.SUPPRESSION_OF_ENEMY_AIR_DEFENCE,
+            FlightType.SEAD_SWEEP: AirEntity.SUPPRESSION_OF_ENEMY_AIR_DEFENCE,
             FlightType.STRIKE: AirEntity.ATTACK_STRIKE,
             FlightType.SWEEP: AirEntity.FIGHTER,
             FlightType.TARCAP: AirEntity.FIGHTER,

game/ato/flightwaypoint.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
 from dataclasses import dataclass, field
 from datetime import timedelta
 from typing import Literal, TYPE_CHECKING
@@ -12,8 +11,7 @@ from game.theater.theatergroup import TheaterUnit
 from game.utils import Distance, meters
 
 if TYPE_CHECKING:
-    from game.theater import ControlPoint, MissionTarget
-
+    from game.theater import ControlPoint
 
 AltitudeReference = Literal["BARO", "RADIO"]
 
@@ -32,7 +30,7 @@ class FlightWaypoint:
     # having three names. A short and long form is enough.
     description: str = ""
 
-    targets: Sequence[MissionTarget | TheaterUnit] = field(default_factory=list)
+    targets: list[TheaterUnit] = field(default_factory=list)
     obj_name: str = ""
     pretty_name: str = ""
     only_for_player: bool = False

game/ato/flightwaypointtype.py

@@ -43,8 +43,11 @@ class FlightWaypointType(IntEnum):
     DIVERT = 23
     INGRESS_OCA_RUNWAY = 24
     INGRESS_OCA_AIRCRAFT = 25
-    PICKUP = 26
-    DROP_OFF = 27
+    PICKUP_ZONE = 26  # Pickup Zone for cargo or troops
+    DROPOFF_ZONE = 27  # Dropoff Zone for cargo or troops
     BULLSEYE = 28
     REFUEL = 29  # Should look for nearby tanker to refuel from.
-    STOPOVER = 30  # Stopover landing point using the LandingReFuAr waypoint type
+    CARGO_STOP = 30  # Stopover landing point using the LandingReFuAr waypoint type
+    INGRESS_AIR_ASSAULT = 31
+    INGRESS_ANTI_SHIP = 32
+    INGRESS_SEAD_SWEEP = 33

game/ato/loadouts.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import datetime
 import logging
 from collections.abc import Iterable
-from typing import Iterator, Mapping, Optional, TYPE_CHECKING, Type, Dict, Any
+from typing import Iterator, Optional, TYPE_CHECKING, Type, Dict
 
 from dcs.unittype import FlyingType
 
@@ -19,14 +19,14 @@ class Loadout:
     def __init__(
         self,
         name: str,
-        pylons: Mapping[int, Optional[Weapon]],
+        pylons: Dict[int, Optional[Weapon]],
         date: Optional[datetime.date],
         is_custom: bool = False,
     ) -> None:
         self.name = name
         # We clear unused pylon entries on initialization, but UI actions can still
         # cause a pylon to be emptied, so make the optional type explicit.
-        self.pylons: Mapping[int, Optional[Weapon]] = {
+        self.pylons: Dict[int, Optional[Weapon]] = {
             k: v for k, v in pylons.items() if v is not None
         }
         self.date = date
@@ -92,6 +92,9 @@ class Loadout:
         if self.has_weapon_of_type(WeaponType.TGP):
             return
 
+        if unit_type.has_built_in_target_pod:
+            return
+
         new_pylons = dict(self.pylons)
         for pylon_number, weapon in self.pylons.items():
             if weapon is not None and weapon.weapon_group.type is WeaponType.LGB:
@@ -151,10 +154,22 @@ class Loadout:
         # names, so those have been included here too. The priority goes from first to
         # last - the first element in the tuple will be tried first, then the second,
         # etc.
-        loadout_names = {t: [f"Liberation {t.value}"] for t in FlightType}
+        loadout_names = {
+            t: [f"Retribution {t.value}", f"Liberation {t.value}"] for t in FlightType
+        }
         legacy_names = {
-            FlightType.TARCAP: ("CAP HEAVY", "CAP", "Liberation BARCAP"),
-            FlightType.BARCAP: ("CAP HEAVY", "CAP", "Liberation TARCAP"),
+            FlightType.TARCAP: (
+                "CAP HEAVY",
+                "CAP",
+                "Retribution BARCAP",
+                "Liberation BARCAP",
+            ),
+            FlightType.BARCAP: (
+                "CAP HEAVY",
+                "CAP",
+                "Retribution TARCAP",
+                "Liberation TARCAP",
+            ),
             FlightType.CAS: ("CAS MAVERICK F", "CAS"),
             FlightType.STRIKE: ("STRIKE",),
             FlightType.ANTISHIP: ("ANTISHIP",),
@@ -169,6 +184,9 @@ class Loadout:
         # A SEAD escort typically does not need a different loadout than a regular
         # SEAD flight, so fall back to SEAD if needed.
         loadout_names[FlightType.SEAD_ESCORT].extend(loadout_names[FlightType.SEAD])
+        loadout_names[FlightType.SEAD_SWEEP].extend(
+            loadout_names[FlightType.SEAD_ESCORT]
+        )
         # Sweep and escort can fall back to TARCAP.
         loadout_names[FlightType.ESCORT].extend(loadout_names[FlightType.TARCAP])
         loadout_names[FlightType.SWEEP].extend(loadout_names[FlightType.TARCAP])

game/ato/package.py

@@ -13,19 +13,28 @@ from .flightplans.formation import FormationFlightPlan
 from .flighttype import FlightType
 from .packagewaypoints import PackageWaypoints
 from .traveltime import TotEstimator
+from ..radio.RadioFrequencyContainer import RadioFrequencyContainer
+from ..radio.radios import RadioFrequency
 
 if TYPE_CHECKING:
     from game.theater import ControlPoint, MissionTarget
 
 
-class Package:
+class Package(RadioFrequencyContainer):
     """A mission package."""
 
     def __init__(
-        self, target: MissionTarget, db: Database[Flight], auto_asap: bool = False
+        self,
+        target: MissionTarget,
+        db: Database[Flight],
+        auto_asap: bool = False,
+        custom_name: str | None = None,
+        frequency: RadioFrequency | None = None,
     ) -> None:
         self.target = target
         self._db = db
+        self.frequency = frequency
+        self.custom_name = custom_name
 
         # True if the package ToT should be reset to ASAP whenever the player makes a
         # change. This is really a UI property rather than a game property, but we want
@@ -129,6 +138,16 @@ class Package:
         if not self.flights:
             self.waypoints = None
 
+    @property
+    def primary_flight(self) -> Optional[Flight]:
+        task = self.primary_task
+        if not task:
+            return None
+        primaries = [x for x in self.flights if x.flight_type == task]
+        if len(primaries) > 0:
+            return primaries[0]
+        return None
+
     @property
     def primary_task(self) -> Optional[FlightType]:
         if not self.flights:
@@ -157,6 +176,7 @@ class Package:
             FlightType.TRANSPORT,
             FlightType.AIR_ASSAULT,
             FlightType.SEAD,
+            FlightType.SEAD_SWEEP,
             FlightType.TARCAP,
             FlightType.BARCAP,
             FlightType.AEWC,
@@ -204,3 +224,12 @@ class Package:
                 if flight.departure == airfield:
                     return airfield
         raise RuntimeError("Could not find any airfield assigned to this package")
+
+    @staticmethod
+    def clone_package(package: Package) -> Package:
+        clone = Package(package.target, package._db, package.auto_asap)
+        clone.time_over_target = package.time_over_target
+        for f in package.flights:
+            cf = Flight.clone_flight(f)
+            clone.add_flight(cf)
+        return clone