Update requirements.txt to latest pydcs version

Bumps
[http-proxy-middleware](https://github.com/chimurai/http-proxy-middleware)
from 2.0.3 to 2.0.9.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/chimurai/http-proxy-middleware/releases">http-proxy-middleware's
releases</a>.</em></p>
<blockquote>
<h2>v2.0.9</h2>
<h2>What's Changed</h2>
<ul>
<li>fix(fixRequestBody): check readableLength by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/1097">chimurai/http-proxy-middleware#1097</a></li>
<li>chore(package): v2.0.9 by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/1099">chimurai/http-proxy-middleware#1099</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.8...v2.0.9">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.8...v2.0.9</a></p>
<h2>v2.0.8</h2>
<h2>What's Changed</h2>
<ul>
<li>fix(fixRequestBody): prevent multiple .write() calls by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/1090">chimurai/http-proxy-middleware#1090</a></li>
<li>fix(fixRequestBody): handle invalid request by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/1091">chimurai/http-proxy-middleware#1091</a></li>
<li>chore(package): v2.0.8 by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/1094">chimurai/http-proxy-middleware#1094</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.7...v2.0.8">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.7...v2.0.8</a></p>
<h2>v2.0.7</h2>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.6...v2.0.7">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.6...v2.0.7</a></p>
<h2>v2.0.7-beta.1</h2>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.7-beta.0...v2.0.7-beta.1">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.7-beta.0...v2.0.7-beta.1</a></p>
<h2>v2.0.7-beta.0</h2>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.6...v2.0.7-beta.0">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.6...v2.0.7-beta.0</a></p>
<h2>v2.0.6</h2>
<h2>What's Changed</h2>
<ul>
<li>fix(proxyReqWs): catch socket errors by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/763">chimurai/http-proxy-middleware#763</a></li>
<li>chore(package): v2.0.6 by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/764">chimurai/http-proxy-middleware#764</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.5...v2.0.6">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.5...v2.0.6</a></p>
<h2>v2.0.5</h2>
<h2>What's Changed</h2>
<ul>
<li>fix(error handler): add default handler to econnreset by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/759">chimurai/http-proxy-middleware#759</a></li>
<li>chore(package): v2.0.5 by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/760">chimurai/http-proxy-middleware#760</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.4...v2.0.5">https://github.com/chimurai/http-proxy-middleware/compare/v2.0.4...v2.0.5</a></p>
<h2>v2.0.4</h2>
<h2>What's Changed</h2>
<ul>
<li>chore(package): bump dev dependencies by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/714">chimurai/http-proxy-middleware#714</a></li>
<li>chore(vscode): add recommended extensions by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/715">chimurai/http-proxy-middleware#715</a></li>
<li>docs(response-interceptor.md): add headers modification example by
<a
href="https://github.com/stefanwright1988"><code>@​stefanwright1988</code></a>
in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/724">chimurai/http-proxy-middleware#724</a></li>
<li>fix(fix-request-body): improve content type check by <a
href="https://github.com/kevinxh"><code>@​kevinxh</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/725">chimurai/http-proxy-middleware#725</a></li>
<li>chore(package): v2.0.4 by <a
href="https://github.com/chimurai"><code>@​chimurai</code></a> in <a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/729">chimurai/http-proxy-middleware#729</a></li>
</ul>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a
href="https://github.com/chimurai/http-proxy-middleware/blob/v2.0.9/CHANGELOG.md">http-proxy-middleware's
changelog</a>.</em></p>
<blockquote>
<h2><a
href="https://github.com/chimurai/http-proxy-middleware/releases/tag/v2.0.9">v2.0.9</a></h2>
<ul>
<li>fix(fixRequestBody): check readableLength</li>
</ul>
<h2><a
href="https://github.com/chimurai/http-proxy-middleware/releases/tag/v2.0.8">v2.0.8</a></h2>
<ul>
<li>fix(fixRequestBody): prevent multiple .write() calls</li>
<li>fix(fixRequestBody): handle invalid request</li>
</ul>
<h2><a
href="https://github.com/chimurai/http-proxy-middleware/releases/tag/v2.0.7">v2.0.7</a></h2>
<ul>
<li>ci(github actions): add publish.yml</li>
<li>fix(filter): handle errors</li>
</ul>
<h2><a
href="https://github.com/chimurai/http-proxy-middleware/releases/tag/v2.0.6">v2.0.6</a></h2>
<ul>
<li>fix(proxyReqWs): catch socket errors (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/763">#763</a>)</li>
</ul>
<h2><a
href="https://github.com/chimurai/http-proxy-middleware/releases/tag/v2.0.5">v2.0.5</a></h2>
<ul>
<li>fix(error handler): add default handler to econnreset (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/759">#759</a>)</li>
</ul>
<h2><a
href="https://github.com/chimurai/http-proxy-middleware/releases/tag/v2.0.4">v2.0.4</a></h2>
<ul>
<li>fix(fix-request-body): improve content type check (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/pull/725">#725</a>)
(<a href="https://github.com/kevinxh">kevinxh</a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="617a7c9da9"><code>617a7c9</code></a>
chore(package): v2.0.9 (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/issues/1099">#1099</a>)</li>
<li><a
href="d22d587648"><code>d22d587</code></a>
fix(fixRequestBody): check readableLength (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/issues/1097">#1097</a>)</li>
<li><a
href="d03d51b54a"><code>d03d51b</code></a>
chore(package): v2.0.8 (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/issues/1094">#1094</a>)</li>
<li><a
href="c50dd06d91"><code>c50dd06</code></a>
fix(fixRequestBody): handle invalid request (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/issues/1091">#1091</a>)</li>
<li><a
href="76a9d8d6dc"><code>76a9d8d</code></a>
fix(fixRequestBody): prevent multiple .write() calls (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/issues/1090">#1090</a>)</li>
<li><a
href="1e92339098"><code>1e92339</code></a>
ci(github-actions): fix npm tag</li>
<li><a
href="90afb7c9a6"><code>90afb7c</code></a>
chore(package): v2.0.7</li>
<li><a
href="0b4274e8cc"><code>0b4274e</code></a>
fix(filter): handle errors</li>
<li><a
href="1bd6dd578b"><code>1bd6dd5</code></a>
ci(github actions): add publish.yml</li>
<li><a
href="c08cb1e13b"><code>c08cb1e</code></a>
chore(package): v2.0.6 (<a
href="https://redirect.github.com/chimurai/http-proxy-middleware/issues/764">#764</a>)</li>
<li>Additional commits viewable in <a
href="https://github.com/chimurai/http-proxy-middleware/compare/v2.0.3...v2.0.9">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=http-proxy-middleware&package-manager=npm_and_yarn&previous-version=2.0.3&new-version=2.0.9)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the
[Security Alerts
page](https://github.com/dcs-liberation/dcs_liberation/network/alerts).

</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -31,7 +31,7 @@ body:
         If the bug was found in a development build, select "Development build"
         and provide a link to the build in the field below.
       options:
-        - 6.1.1
+        - 14.0.0
         - Development build
   - type: textarea
     attributes:
@@ -49,13 +49,19 @@ body:
       required: true
   - type: textarea
     attributes:
-      label: Save game and other files
+      label: Save game and other files (save game required, bugs without saves will be closed)
       description: >
         Attach any files needed to reproduce the bug here. **A save game is
-        required.** We typically cannot help without a save game (the
-        `.liberation` (or `.liberation.zip`, for 7.x) file found in
-        `%USERPROFILE%/Saved Games/DCS/Liberation/Saves`), so most bugs filed
-        without saved games will be closed without investigation.
+        required.** Even if it seems unnecessary to you, this is required.
+        Repro steps that are obvious to you might not be obvious to anyone
+        else, and it is impossible for us to know what default settings or mods
+        may be impacting behavior without a save game. Bugs filed without a
+        save game are very often not reproducible, and those waste scarce
+        developer time. It is **much** easier for you to attach a save game
+        than it is for us to recreate your save state by guessing at what you
+        did. As such, bug reports that do not attach a saved game will be
+        closed without investigation. Attach the `.liberation.zip` file found
+        in `%USERPROFILE%/Saved Games/DCS/Liberation/Saves`.
 
 
         Other useful files to include are:
@@ -73,10 +79,11 @@ body:
 
         The `state.json` file for the most recently completed turn, located at
         `<Liberation install directory>/state.json`. This file is essential for
-        investigating any issues with end-of-turn results processing. **If you
-        include this file, also include `last_turn.liberation`** (unless the
-        save is from 7.x or newer, which includes that information in the save
-        automatically).
+        investigating any issues with end-of-turn results processing.
+
+
+        If reporting an issue that occurred during or after flying the mission
+        in DCS, the DCS log file found in `%USERPROFILE%/Saved Games/DCS/Logs`.
 
 
         You can attach files to the bug by dragging and dropping the file into

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

@@ -39,7 +39,7 @@ body:
         If the bug was found in a development build, select "Development build"
         and provide a link to the build in the field below.
       options:
-        - 6.1.1
+        - 14.0.0
         - Development build
   - type: textarea
     attributes:

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

@@ -4,7 +4,7 @@ runs:
   using: composite
   steps:
     - name: Set up Node
-      uses: actions/setup-node@v2
+      uses: actions/setup-node@v4
       with:
         node-version: "16"
         cache: npm

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

@@ -4,9 +4,9 @@ runs:
   using: composite
   steps:
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
-        python-version: "3.11"
+        python-version: "3.11.4"
         cache: pip
 
     - name: Install environment

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
   build:
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
 
@@ -35,7 +35,7 @@ jobs:
           Compress-Archive -Path .\dist\dcs_liberation\ -DestinationPath
           dist\dcs_liberation.zip
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: dcs_liberation
           path: dist/dcs_liberation.zip

.github/workflows/lint.yml

@@ -7,11 +7,11 @@ jobs:
     name: Black
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
       - uses: psf/black@stable
         with:
-          version: ~=22.12
+          version: ~=24.3.0
           src: "."
           options: "--check"
 
@@ -19,7 +19,7 @@ jobs:
     name: Type checking
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
 

.github/workflows/release.yml

@@ -14,7 +14,7 @@ jobs:
   build:
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
 
@@ -33,7 +33,7 @@ jobs:
         with:
           release: true
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: dcs_liberation
           path: dist/
@@ -42,7 +42,7 @@ jobs:
     needs: [build]
     runs-on: windows-latest
     steps:
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v4.1.7
         with:
           name: dcs_liberation
 

.github/workflows/test.yml

@@ -5,7 +5,7 @@ jobs:
     name: Python tests
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
         with:
           submodules: true
 
@@ -15,7 +15,7 @@ jobs:
       - name: run tests
         run: |
           ./venv/scripts/activate
-          pytest --cov-report=xml tests
+          pytest --cov --cov-report=xml tests
 
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v3
@@ -24,7 +24,7 @@ jobs:
     name: Typescript tests
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Set up JS environment
         uses: ./.github/actions/setup-liberation-js

.gitignore

@@ -9,6 +9,7 @@ venv
 .vscode/settings.json
 dist/**
 /.coverage
+/coverage.xml
 # User-specific stuff
 .idea/
 .env

.pre-commit-config.yaml

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

README.md

@@ -2,12 +2,11 @@
 
 (Github Readme Banner and Splash screen Artwork by Andriy Dankovych, CC BY-SA 4.0)
 
-[![Patreon](https://img.shields.io/badge/patreon-become%20a%20patron-orange?logo=patreon)](https://patreon.com/khopa)
-
 [![Download](https://img.shields.io/github/downloads/dcs-liberation/dcs_liberation/total?label=Download)](https://github.com/dcs-liberation/dcs_liberation/releases)
 
 [![Discord](https://img.shields.io/discord/595702951800995872?label=Discord&logo=discord)](https://discord.gg/bKrtrkJ)
 
+[![codecov](https://codecov.io/gh/dcs-liberation/dcs_liberation/branch/develop/graph/badge.svg?token=EEQ7G76K2L)](https://codecov.io/gh/dcs-liberation/dcs_liberation)
 [![GitHub pull requests](https://img.shields.io/github/issues-pr/dcs-liberation/dcs_liberation)](https://github.com/dcs-liberation/dcs_liberation)
 [![GitHub issues](https://img.shields.io/github/issues/dcs-liberation/dcs_liberation)](https://github.com/dcs-liberation/dcs_liberation/issues)
 ![GitHub stars](https://img.shields.io/github/stars/dcs-liberation/dcs_liberation?style=social)
@@ -16,11 +15,6 @@
 DCS Liberation is a [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) turn based single-player or co-op dynamic campaign. 
 It is an external program that generates full and complex DCS missions and manage a persistent combat environment.
 
-**Note that DCS Liberation does not support the stable release of DCS. We can
-only guarantee compatibility  with either  the open beta or the stable release,
-and more people play the open beta. DCS stable _might_ work sometimes, but it's
-untested, and we will be unable to fix any bugs unique to stable DCS.**
-
 ![Screenshot](https://user-images.githubusercontent.com/315852/120939254-0b4a9f80-c6cc-11eb-82f5-ce3f8d714bfe.png)
 
 ## Downloads

changelog.md

@@ -1,3 +1,214 @@
+# 14.0.0
+
+Saves from 13.x are not compatible with 14.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.13.6818.
+
+## Fixes
+
+* **[UI]** Air Wing and Transfers buttons disabled when no game is loaded as pressing them without a game loaded resulted in a crash.
+
+# 13.0.0
+
+Saves from 12.x are not compatible with 13.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.12.5536.
+* **[Data]** Support for CH-47 Chinook.
+
+## Fixes
+
+* **[Data]** Added/updated CBU weapons data.
+* **[Data]** Added Strike mission type for KA-50 (all playable variants).
+* **[Mission Generation]** Fixed crash when using factions that have Eastern callsign conventions.
+* **[Mission Generation]** Fixed issues when spawning on carriers and FARPs in multiplayer sessions.
+
+
+# 12.0.0
+
+Saves from 11.x are not compatible with 12.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.9.2280.
+* **[Campaign]** Flights are assigned different callsigns appropriate to the faction.
+* **[Campaign]** Removed deprecated settings for generating persistent and invulnerable AWACs and tankers.
+* **[Data]** Added ability to restrict weapons usage for a faction to a different year from the nominal weapon introduction year. Updated faction data to restrict more advanced missiles from Soviet client states during the cold war. Updated Egypt 2000 faction to restrict AIM-120 usage.
+* **[Mission Generation]** Added option to skip combat when fast forwarding, which progresses fast forward as if the combat did not occur. Simplified fast forward settings by consolidating "Fast forward mission to first contact" and "Player missions interrupt fast forward" into a single setting and expanding options for "Auto-resolve combat during fast-forward (WIP)".
+* **[Mods]** F/A-18 E/F/G Super Hornet mod version updated to 2.3.
+
+## Fixes
+
+* **[Data]** Added/updated weapons data for F4E weapons such as AIM-7, AIM-9, AGM-12, AGM-45 and AGM-65.
+* **[Campaign]** Do not allow aircraft from a captured control point to retreat if the captured control point has a damaged runway.
+* **[Campaign]** Do not allow ground units to be transferred to LHAs, CVNs or off map spawns.
+* **[Mission Generation]** Fixed aircraft not spawning correctly on CVNs, LHAs and FARPs.
+
+# 11.1.1
+
+Saves from 11.0.0 are compatible with 11.1.1. See Known Issues section for exceptions.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.5.55918 including Heatblur F-4E and Polychop OH-58D Kiowa Warrior support. 
+
+## Fixes
+
+* **[Campaign]** Fixed double counting of parked aircraft kills when DCS reports multiple kill events.
+* **[Campaign]** Fixed error where frontline units are not re-deployed when multiple control points were captured in one turn or when control points are captured "out of order" using air-assault missions.
+* **[Cheat Menu]** Re-deploy frontline units when using cheats to capture control points, so that cheats behave the same way as capturing a control point in-mission.
+* **[Data]** Added FuSe-65 Early Warning Radar.
+* **[Data]** Updated Peru 1995 and Germany 1944 factions.
+* **[Flight Planning]** Theater refuelling flight plans (those not tied to a particular package) will remain on station for a longer period, specifically the desired mission duration + 30 minutes. By default, this increases the on-station time from 1 hour to 1.5 hours. 
+* **[Mission Generation]** Patched bug where Liberation crashed when aborting a turn when Fighter Sweep missions were planned.
+* **[Radios]** Added radio setup for F-5E, F-86, Mi-8 and Mi-24.
+* **[UI]** Naval control points (carriers, LHAs) can no longer be moved onto land.
+
+## Known Issues
+
+* When loading saves from 11.0, loadouts with AGM-45B (Imp), typically on A-4E-C mod, will have the AGM-45B replaced with an empty pylon due to changes in DCS for this weapon. The AGM-45A is not affected by this issue.
+
+# 11.0.0
+
+Saves from 10.x are not compatible with 11.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.3.51704. 
+* **[Campaign]** Improved tracking of parked aircraft deaths. Parked aircraft are now considered dead once sufficient damage is done, meaning guns, rockets and AGMs are viable weapons for OCA/Aircraft missions. Previously Liberation relied on DCS death tracking which required parked aircraft to be hit with more powerful weapons e.g. 2000lb bombs as they were uncontrolled.
+* **[Campaign]** Track damage to theater ground objects across turns. Damage can accumulate across turns leading to death of the unit. This behavior only applies to SAMs, ships and other units that appear on the Liberation map. Frontline units and buildings are not tracked (yet).
+* **[Mods]** F/A-18 E/F/G Super Hornet mod (v2.2.5) support added.
+
+## Fixes
+
+* **[Mission Generation]** When planning anti-ship missions against carriers or LHAs, target escorts (if present) if the carrier/LHA is sunk.
+* **[UI]** Identify that a carrier or LHA is sunk instead of "damaged".
+
+# 10.0.0
+
+Saves from 9.x are not compatible with 10.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.9.2.49629 Open Beta. (F-15E JDAM and JSOW, F-16 AIM-9P, updated Falklands and Normandy airfields).
+* **[UI]** Improved the description of "runway" state for FARPs, FOBs, carriers, and off-map spawns.
+
+## Fixes
+
+* **[Flight Planning]** Aircraft from even numbered flights will no longer become inaccessible when canceling a draft package.
+* **[UI]** Flight members in the loadout menu are now numbered starting from 1 instead of 0.
+* **[UI]** Flight plan paths are now drawn behind all other map elements, fixing rare cases where they could prevent other UI elements from being clickable.
+
+# 9.0.0
+
+Saves from 8.x are not compatible with 9.0.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS Open Beta 2.9.0.46801.
+* **[Campaign]** Added ferry only control points, which offer campaign designers a way to add squadrons that can be brought in after additional airfields are captured.
+* **[Campaign]** The new squadron rules (size limits, beginning the campaign at full strength) are now the default and required. The old style of unlimited squadron sizes and starting with zero aircraft has been removed.
+* **[Data]** Added support for the ARA Veinticinco de Mayo.
+* **[Data]** Changed display name of the AI-only F-15E Strike Eagle for clarity.
+* **[Flight Planning]** Improved IP selection for targets that are near the center of a threat zone.
+* **[Flight Planning]** Moved CAS ingress point off the front line so that the AI begins their target search earlier.
+* **[Flight Planning]** Loadouts and aircraft properties can now be set per-flight member. Warning: AI flights should not use mixed loadouts.
+* **[Flight Planning]** Laser codes that are pre-assigned to weapons at mission start can now be chosen from a list in the loadout UI. This does not affect the aircraft's TGP, just the weapons. Currently only implemented for the F-15E S4+ and F-16C.
+* **[Mission Generation]** Configured target and initial points for F-15E S4+.
+* **[Mission Generation]** Added a package kneeboard page that shows the radio frequencies, tasks, and laser codes for each member of your package.
+* **[Mission Generation]** Added option to generate AI flights with unlimited fuel (enabled by default).
+* **[Modding]** Factions can now specify the ship type to be used for cargo shipping. The Handy Wind will be used by default, but WW2 factions can pick something more appropriate.
+* **[Modding]** Unit variants can now set a display name separate from their ID.
+* **[Modding]** Updated Community A-4E-C mod version support to 2.2.0 release.
+* **[UI]** An error will be displayed when invalid fast-forward options are selected rather than beginning a never ending simulation.
+* **[UI]** Added cheats for instantly repairing and destroying runways.
+* **[UI]** Improved usability of the flight properties UI. It now shows human-readable names and uses more appropriate UI elements.
+* **[UI]** The map now shows the real front line bounds.
+
+## Fixes
+
+* **[Campaign]** Fixed error when canceling squadron transfer if the current location would be exactly full.
+* **[Data]** Fixed the class of the Samuel Chase so it can't be picked for a AAA or SHORAD site.
+* **[Data]** Allow CH-47D, CH-53E and UH-60A to operate from carriers and LHAs.
+* **[Data]** Added the F-15E's LANTIRN to the list of known targeting pods. Player F-15E flight with TGPs will now be assigned laser codes.
+* **[Flight Planning]** Patrolling flight plans (CAS, CAP, refueling, etc) now handle TOT offsets.
+* **[Loadouts]** Fixed error when loading certain DCS loadouts which contained an empty pylon (notably the Mosquito).
+* **[Mission Generation]** Restored previous AI behavior for anti-ship missions. A DCS update caused only a single aircraft in a flight to attack. The full flight will now attack like they used to.
+* **[Mission Generation]** Fix generation of OCA Runway missions to allow LGBs to be used.
+* **[Mission Generation]** Fixed AI flights flying far too slowly toward NAV points.
+* **[Mission Generation]** Fixed Recovery Tanker mission type intermittently failing due to not being able to find the CVN.
+* **[Mission Generation]** Fixed "division by zero" error on mission generation when a flight has an "In-Flight" start type and starts on top of a mission waypoint.
+* **[Mission Generation]** Fixed flights not being selectable in the mission editor if fast-forward was used and they were generated at a waypoint that had a fixed TOT (such as a BARCAP that was on-station).
+* **[Mission Generation]** Fixed error when planning TARCAPs on the sole remaining enemy airfield.
+* **[Mission Generation]** Fixed allocation range for carrier Link 4 datalink.
+* **[Modding]** Unit variants can now actually override base unit type properties.
+* **[New Game Wizard]** Factions are reset to default after clicking "Back" to Theater Configuration screen.
+* **[Plugins]** Fixed Lua errors in Skynet plugin that would occur whenever one coalition had no IADS nodes.
+* **[UI]** Fixed deleting waypoints in custom flight plans deleting the wrong waypoint.
+* **[UI]** Fixed flight properties UI to support F-15E S4+ laser codes.
+* **[UI]** In unit transfer dialog, only list control points that are reachable from the control point units are being transferred from.
+* **[UI]** Fixed UI bug where altering an "ahead of package" TOT offset would change the offset back to a "behind package" offset.
+* **[UI]** Fixed bug where changing TOT offsets could result in flight startup times that are in the past.
+* **[UI]** Fixed odd spacing of the finance window when there were not enough items to fill the page.
+* **[UI]** Fixed regression where waypoint altitude changes in the waypoint list screen are applied to the wrong waypoint.
+* **[UI]** Fixed regression where waypoint additions in custom flight plans are not reflected until the window is reloaded. 
+
+# 8.1.0
+
+Saves from 8.0.0 are compatible with 8.1.0
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41363, including F-15E support.
+* **[UI]** Flight loadout/properties tab is now scrollable.
+
+## Fixes
+
+* **[Campaign]** Fixed liveries for premade squadrons all being off-by-one.
+* **[UI]** Fixed numbering of waypoints in the map and flight dialog (first waypoint is now 0 rather than 1).
+
+# 8.0.0
+
+Saves from 7.x are not compatible with 8.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41066, including the new Sinai map.
+* **[UI]** Limited size of overfull airbase display and added scrollbar.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Moved air wing and transfer menus to the toolbar to improve UI fit on low resolution displays.
+* **[UI]** Added basic game over dialog.
+
+## Fixes
+
+* **[Campaign]** Fix bug introduced in 7.0 where map strike target deaths are no longer tracked.
+* **[Mission Generation]** Fix crash during mission generation caused by out of date DCS data for the Gazelle.
+* **[Mission Generation]** Fix crash during mission generation when DCS beacon data is inconsistent.
+
+# 7.1.0
+
+Saves from 7.0.0 are compatible with 7.1.0
+
+## Features/Improvements
+
+* **[Engine]** Support for Normandy 2 airfields.
+* **[Factions]** Replaced Patriot STRs "EWRs" with AN/FPS-117 for blue factions 1980 or newer.
+* **[Mission Generation]** Added option to prevent scud and V2 sites from firing at the start of the mission.
+* **[Mission Generation]** Added settings for controlling number of tactical commander, observer, JTAC, and game master slots.
+* **[Mission Planning]** Per-flight TOT offsets can now be set in the flight details UI. This allows individual flights to be scheduled ahead of or behind the rest of the package.
+* **[New Game Wizard]** The air wing configuration dialog will check for and reject overfull airbases before continuing when the new squadron rules are used.
+* **[New Game Wizard]** Closing the air wing configuration dialog will now cancel and return to the new game wizard rather than reverting changes and continuing.
+* **[New Game Wizard]** A warning will be displayed next to the new squadron rules button if the campaign predates the new rules and will likely require user intervention before continuing.
+* **[UI]** Parking capacity of each squadron's base is now shown during air wing configuration to avoid overcrowding bases when beginning the game with full squadrons.
+
+## Fixes
+
+* **[Mission Planning]** BAI is once again plannable against missile sites and coastal defense batteries.
+* **[UI]** Fixed formatting of departure time in flight details dialog.
+
 # 7.0.0
 
 Saves from 6.x are not compatible with 7.0.
@@ -16,6 +227,7 @@ Saves from 6.x are not compatible with 7.0.
 * **[Mission Generation]** Wind speeds no longer follow a uniform distribution. Median wind speeds are now much lower and the standard deviation has been reduced considerably at altitude but increased somewhat at MSL.
 * **[Mission Generation]** Improved task generation for SEAD flights carrying TALDs.
 * **[Mission Generation]** Added task timeout for SEAD flights with TALDs to prevent AI from overflying the target.
+* **[Mission Generation]** Game state will automatically be checkpointed before fast-forwarding the mission, and restored on mission abort. This means that it's now possible to abort a mission and make changes without needing to manually re-load your game.
 * **[Modding]** Updated Community A-4E-C mod version support to 2.1.0 release.
 * **[Modding]** Add support for VSN F-4B and F-4C mod.
 * **[Modding]** Added support for AI C-47 mod.

client/package.json

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

client/src/App.test.tsx

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

client/src/api/_liberationApi.ts

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

client/src/api/backend.ts

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

client/src/api/liberationApi.ts

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

client/src/app/store.ts

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

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

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

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

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

client/src/components/airdefenserangelayer/AirDefenseRangeLayer.tsx

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

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

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

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

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

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

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

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

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

client/src/components/cullingexclusionzones/CullingExclusionZones.tsx

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

client/src/components/flightplan/FlightPlan.tsx

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

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

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

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

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

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

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

client/src/components/frontlineslayer/FrontLinesLayer.tsx

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

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

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

client/src/components/splitlines/SplitLines.test.tsx

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

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

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

client/src/components/supplyroute/SupplyRoute.tsx

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

client/src/components/waypointdebugzones/IpZones.tsx

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

client/src/components/waypointdebugzones/WaypointDebugZonesControls.tsx

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

client/src/components/waypointmarker/WaypointMarker.test.tsx

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

client/src/components/waypointmarker/WaypointMarker.tsx

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

client/src/index.tsx

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

client/src/mergeRefs.test.tsx

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

client/src/mergeRefs.ts

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

client/src/testutils/index.tsx

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

codecov.yaml

@@ -2,7 +2,7 @@ coverage:
   status:
     patch:
       default:
-        informational: false
+        informational: true
     project:
       default:
         informational: true

docs/conf.py

@@ -7,9 +7,9 @@
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = "DCS Liberation"
-copyright = "2023, DCS Liberation Team"
+copyright = "2025, DCS Liberation Team"
 author = "DCS Liberation Team"
-release = "7.0.0"
+release = "14.0.0"
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

game/armedforces/forcegroup.py

@@ -10,19 +10,18 @@ import yaml
 from dcs.unittype import ShipType, StaticType, UnitType as DcsUnitType, VehicleType
 
 from game.data.groups import GroupTask
-from game.data.radar_db import UNITS_WITH_RADAR
 from game.dcs.groundunittype import GroundUnitType
 from game.dcs.helpers import static_type_from_name
 from game.dcs.shipunittype import ShipUnitType
 from game.dcs.unittype import UnitType
+from game.layout import LAYOUTS
+from game.layout.layout import TgoLayout, TgoLayoutUnitGroup
+from game.point_with_heading import PointWithHeading
 from game.theater.theatergroundobject import (
     IadsGroundObject,
     IadsBuildingGroundObject,
     NavalGroundObject,
 )
-from game.layout import LAYOUTS
-from game.layout.layout import TgoLayout, TgoLayoutUnitGroup
-from game.point_with_heading import PointWithHeading
 from game.theater.theatergroup import IadsGroundGroup, IadsRole, TheaterGroup
 from game.utils import escape_string_for_lua
 
@@ -288,7 +287,7 @@ class ForceGroup:
             unit.id = game.next_unit_id()
             # Add unit name escaped so that we do not have scripting issues later
             unit.name = escape_string_for_lua(
-                unit.unit_type.name if unit.unit_type else unit.type.name
+                unit.unit_type.variant_id if unit.unit_type else unit.type.name
             )
             unit.position = PointWithHeading.from_point(
                 ground_object.position + unit.position,

game/ato/closestairfields.py

@@ -1,4 +1,5 @@
 """Objective adjacency lists."""
+
 from __future__ import annotations
 
 from typing import Dict, Iterator, List, Optional, TYPE_CHECKING

game/ato/flight.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
 import uuid
+from collections.abc import Iterator
 from datetime import datetime, timedelta
 from typing import Any, List, Optional, TYPE_CHECKING
 
 from dcs import Point
 from dcs.planes import C_101CC, C_101EB, Su_33
 
+from .flightmembers import FlightMembers
 from .flightroster import FlightRoster
 from .flightstate import FlightState, Navigating, Uninitialized
 from .flightstate.killed import Killed
-from .loadouts import Loadout
 from ..sidc import (
     Entity,
     SidcDescribable,
@@ -20,12 +21,15 @@ from ..sidc import (
 )
 
 if TYPE_CHECKING:
+    from game.callsigns.callsigngenerator import Callsign
     from game.dcs.aircrafttype import AircraftType
     from game.sim.gameupdateevents import GameUpdateEvents
     from game.sim.simulationresults import SimulationResults
     from game.squadrons import Squadron, Pilot
     from game.theater import ControlPoint
     from game.transfers import TransferOrder
+    from game.data.weapons import WeaponType
+    from .flightmember import FlightMember
     from .flightplans.flightplan import FlightPlan
     from .flighttype import FlightType
     from .flightwaypoint import FlightWaypoint
@@ -46,27 +50,29 @@ class Flight(SidcDescribable):
         custom_name: Optional[str] = None,
         cargo: Optional[TransferOrder] = None,
         roster: Optional[FlightRoster] = None,
+        callsign: Optional[Callsign] = None,
     ) -> None:
         self.id = uuid.uuid4()
         self.package = package
         self.country = country
         self.coalition = squadron.coalition
         self.squadron = squadron
+        self.flight_type = flight_type
         self.squadron.claim_inventory(count)
         if roster is None:
-            self.roster = FlightRoster(self.squadron, initial_size=count)
+            self.roster = FlightMembers(self, initial_size=count)
         else:
-            self.roster = roster
+            self.roster = FlightMembers.from_roster(self, roster)
         self.divert = divert
-        self.flight_type = flight_type
-        self.loadout = Loadout.default_for(self)
         self.start_type = start_type
-        self.use_custom_loadout = False
         self.custom_name = custom_name
+        self.use_same_loadout_for_all_members = True
 
         # Only used by transport missions.
         self.cargo = cargo
 
+        self.callsign = callsign
+
         # Flight properties that can be set in the mission editor. This is used for
         # things like HMD selection, ripple quantity, etc. Any values set here will take
         # the place of the defaults defined by DCS.
@@ -95,6 +101,13 @@ class Flight(SidcDescribable):
 
         self._flight_plan_builder = CustomBuilder(self, self.flight_plan.waypoints[1:])
         self.recreate_flight_plan()
+        # We need to clear the existing actions/options when moving the waypoints into
+        # the new flight plan because the actions/options that are currently set will be
+        # the actions of whatever flight plan was previously used.
+        # https://github.com/dcs-liberation/dcs_liberation/issues/3189
+        for waypoint in self.flight_plan.iter_waypoints():
+            waypoint.actions.clear()
+            waypoint.options.clear()
 
     def __getstate__(self) -> dict[str, Any]:
         state = self.__dict__.copy()
@@ -149,10 +162,6 @@ class Flight(SidcDescribable):
     def is_helo(self) -> bool:
         return self.unit_type.dcs_unit_type.helicopter
 
-    @property
-    def from_cp(self) -> ControlPoint:
-        return self.departure
-
     @property
     def points(self) -> List[FlightWaypoint]:
         return self.flight_plan.waypoints[1:]
@@ -171,6 +180,9 @@ class Flight(SidcDescribable):
     def missing_pilots(self) -> int:
         return self.roster.missing_pilots
 
+    def iter_members(self) -> Iterator[FlightMember]:
+        yield from self.roster.members
+
     def set_flight_type(self, var: FlightType) -> None:
         self.flight_type = var
 
@@ -196,6 +208,11 @@ class Flight(SidcDescribable):
             return unit_type.fuel_max * 0.5
         return None
 
+    def any_member_has_weapon_of_type(self, weapon_type: WeaponType) -> bool:
+        return any(
+            m.loadout.has_weapon_of_type(weapon_type) for m in self.iter_members()
+        )
+
     def __repr__(self) -> str:
         if self.custom_name:
             return f"{self.custom_name} {self.count} x {self.unit_type}"
@@ -256,9 +273,9 @@ class Flight(SidcDescribable):
             Killed(self.state.estimate_position(), self, self.squadron.settings)
         )
         events.update_flight(self)
-        for pilot in self.roster.pilots:
+        for pilot in self.roster.iter_pilots():
             if pilot is not None:
                 results.kill_pilot(self, pilot)
 
-    def recreate_flight_plan(self) -> None:
-        self._flight_plan_builder.regenerate()
+    def recreate_flight_plan(self, dump_debug_info: bool = False) -> None:
+        self._flight_plan_builder.regenerate(dump_debug_info)

game/ato/flightmember.py

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

game/ato/flightmembers.py

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

game/ato/flightplans/aewc.py

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

game/ato/flightplans/airassault.py

@@ -88,7 +88,7 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
             raise PlanningError("Air assault is only usable by helicopters")
         assert self.package.waypoints is not None
 
-        altitude = feet(1500) if self.flight.is_helo else self.doctrine.ingress_altitude
+        altitude = self.doctrine.helicopter.air_assault_nav_altitude
         altitude_is_agl = self.flight.is_helo
 
         builder = WaypointBuilder(self.flight, self.coalition)
@@ -152,5 +152,5 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> AirAssaultFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> AirAssaultFlightPlan:
         return AirAssaultFlightPlan(self.flight, self.layout())

game/ato/flightplans/airlift.py

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

game/ato/flightplans/antiship.py

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

game/ato/flightplans/bai.py

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

game/ato/flightplans/barcap.py

@@ -19,7 +19,7 @@ class BarCapFlightPlan(PatrollingFlightPlan[PatrollingLayout]):
 
     @property
     def patrol_duration(self) -> timedelta:
-        return self.flight.coalition.doctrine.cap_duration
+        return self.flight.coalition.doctrine.cap.duration
 
     @property
     def patrol_speed(self) -> Speed:
@@ -29,7 +29,7 @@ class BarCapFlightPlan(PatrollingFlightPlan[PatrollingLayout]):
 
     @property
     def engagement_distance(self) -> Distance:
-        return self.flight.coalition.doctrine.cap_engagement_range
+        return self.flight.coalition.doctrine.cap.engagement_range
 
 
 class Builder(CapBuilder[BarCapFlightPlan, PatrollingLayout]):
@@ -44,8 +44,8 @@ class Builder(CapBuilder[BarCapFlightPlan, PatrollingLayout]):
         preferred_alt = self.flight.unit_type.preferred_patrol_altitude
         randomized_alt = preferred_alt + feet(random.randint(-2, 1) * 1000)
         patrol_alt = max(
-            self.doctrine.min_patrol_altitude,
-            min(self.doctrine.max_patrol_altitude, randomized_alt),
+            self.doctrine.cap.min_patrol_altitude,
+            min(self.doctrine.cap.max_patrol_altitude, randomized_alt),
         )
 
         builder = WaypointBuilder(self.flight, self.coalition)
@@ -66,5 +66,5 @@ class Builder(CapBuilder[BarCapFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> BarCapFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> BarCapFlightPlan:
         return BarCapFlightPlan(self.flight, self.layout())

game/ato/flightplans/capbuilder.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import random
 from abc import ABC
 from typing import Any, TYPE_CHECKING, TypeVar
@@ -26,6 +27,9 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
         self, location: MissionTarget, barcap: bool
     ) -> tuple[Point, Point]:
         closest_cache = ObjectiveDistanceCache.get_closest_airfields(location)
+        closest_friendly_field = (
+            None  # keep track of closest frieldly airfield in case we need it
+        )
         for airfield in closest_cache.operational_airfields:
             # If the mission is a BARCAP of an enemy airfield, find the *next*
             # closest enemy airfield.
@@ -34,8 +38,43 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             if airfield.captured != self.is_player:
                 closest_airfield = airfield
                 break
+            elif closest_friendly_field is None:
+                closest_friendly_field = airfield
         else:
-            raise PlanningError("Could not find any enemy airfields")
+            if barcap:
+                # If planning a BARCAP, we should be able to find at least one enemy
+                # airfield. If we can't, it's an error.
+                raise PlanningError("Could not find any enemy airfields")
+            else:
+                # if we cannot find any friendly or enemy airfields other than the target,
+                # there's nothing we can do
+                if closest_friendly_field is None:
+                    raise PlanningError(
+                        "Could not find any enemy or friendly airfields"
+                    )
+
+                # If planning other race tracks (TARCAPs, currently), the target may be
+                # the only enemy airfield. In this case, set the race track orientation using
+                # a virtual point equi-distant from but opposite to the target from the closest
+                # friendly airfield like below, where F is the closest friendly airfield, T is
+                # the sole enemy airfield and V the virtual point
+                #
+                # F ---- T ----- V
+                #
+                # We need to create this virtual point, rather than using F to make sure
+                # the race track is aligned towards the target.
+                closest_friendly_field_position = copy.deepcopy(
+                    closest_friendly_field.position
+                )
+                closest_airfield = closest_friendly_field
+                closest_airfield.position.x = (
+                    2 * self.package.target.position.x
+                    - closest_friendly_field_position.x
+                )
+                closest_airfield.position.y = (
+                    2 * self.package.target.position.y
+                    - closest_friendly_field_position.y
+                )
 
         heading = Heading.from_degrees(
             location.position.heading_between_point(closest_airfield.position)
@@ -51,10 +90,10 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             # buffer.
             distance_to_no_fly = (
                 meters(position.distance(self.threat_zones.all))
-                - self.doctrine.cap_engagement_range
+                - self.doctrine.cap.engagement_range
                 - nautical_miles(5)
             )
-            max_track_length = self.doctrine.cap_max_track_length
+            max_track_length = self.doctrine.cap.max_track_length
         else:
             # Other race tracks (TARCAPs, currently) just try to keep some
             # distance from the nearest enemy airbase, but since they are by
@@ -69,15 +108,15 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             distance_to_no_fly = distance_to_airfield - min_distance_from_enemy
 
             # TARCAPs fly short racetracks because they need to react faster.
-            max_track_length = self.doctrine.cap_min_track_length + 0.3 * (
-                self.doctrine.cap_max_track_length - self.doctrine.cap_min_track_length
+            max_track_length = self.doctrine.cap.min_track_length + 0.3 * (
+                self.doctrine.cap.max_track_length - self.doctrine.cap.min_track_length
             )
 
         min_cap_distance = min(
-            self.doctrine.cap_min_distance_from_cp, distance_to_no_fly
+            self.doctrine.cap.min_distance_from_cp, distance_to_no_fly
         )
         max_cap_distance = min(
-            self.doctrine.cap_max_distance_from_cp, distance_to_no_fly
+            self.doctrine.cap.max_distance_from_cp, distance_to_no_fly
         )
 
         end = location.position.point_from_heading(
@@ -86,7 +125,7 @@ class CapBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
         )
 
         track_length = random.randint(
-            int(self.doctrine.cap_min_track_length.meters),
+            int(self.doctrine.cap.min_track_length.meters),
             int(max_track_length.meters),
         )
         start = end.point_from_heading(heading.opposite.degrees, track_length)

game/ato/flightplans/cas.py

@@ -6,13 +6,15 @@ from datetime import timedelta
 from typing import TYPE_CHECKING, Type
 
 from game.theater import FrontLine
-from game.utils import Distance, Speed, kph, meters
+from game.utils import Distance, Speed, kph, meters, dcs_to_shapely_point
 from .ibuilder import IBuilder
 from .invalidobjectivelocation import InvalidObjectiveLocation
 from .patrolling import PatrollingFlightPlan, PatrollingLayout
 from .uizonedisplay import UiZone, UiZoneDisplay
 from .waypointbuilder import WaypointBuilder
 from ..flightwaypointtype import FlightWaypointType
+from ...flightplan.ipsolver import IpSolver
+from ...persistence.paths import waypoint_debug_directory
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
@@ -20,13 +22,13 @@ if TYPE_CHECKING:
 
 @dataclass(frozen=True)
 class CasLayout(PatrollingLayout):
-    target: FlightWaypoint
+    ingress: FlightWaypoint
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to
+        yield self.ingress
         yield self.patrol_start
-        yield self.target
         yield self.patrol_end
         yield from self.nav_from
         yield self.arrival
@@ -42,7 +44,7 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
 
     @property
     def patrol_duration(self) -> timedelta:
-        return self.flight.coalition.doctrine.cas_duration
+        return self.flight.coalition.doctrine.cas.duration
 
     @property
     def patrol_speed(self) -> Speed:
@@ -59,23 +61,20 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
 
     @property
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
-        return {self.layout.patrol_start, self.layout.target, self.layout.patrol_end}
-
-    def request_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.patrol_start
-
-    def dismiss_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.patrol_end
+        return {self.layout.ingress, self.layout.patrol_start, self.layout.patrol_end}
 
     def ui_zone(self) -> UiZone:
+        midpoint = (
+            self.layout.patrol_start.position + self.layout.patrol_end.position
+        ) / 2
         return UiZone(
-            [self.layout.target.position],
+            [midpoint],
             self.engagement_distance,
         )
 
 
 class Builder(IBuilder[CasFlightPlan, CasLayout]):
-    def layout(self) -> CasLayout:
+    def layout(self, dump_debug_info: bool) -> CasLayout:
         location = self.package.target
 
         if not isinstance(location, FrontLine):
@@ -86,46 +85,79 @@ class Builder(IBuilder[CasFlightPlan, CasLayout]):
         )
 
         bounds = FrontLineConflictDescription.frontline_bounds(location, self.theater)
-        ingress = bounds.left_position
-        center = bounds.center
-        egress = bounds.right_position
+        patrol_start = bounds.left_position
+        patrol_end = bounds.right_position
 
-        ingress_distance = ingress.distance_to_point(self.flight.departure.position)
-        egress_distance = egress.distance_to_point(self.flight.departure.position)
-        if egress_distance < ingress_distance:
-            ingress, egress = egress, ingress
+        start_distance = patrol_start.distance_to_point(self.flight.departure.position)
+        end_distance = patrol_end.distance_to_point(self.flight.departure.position)
+        if end_distance < start_distance:
+            patrol_start, patrol_end = patrol_end, patrol_start
 
         builder = WaypointBuilder(self.flight, self.coalition)
 
         is_helo = self.flight.unit_type.dcs_unit_type.helicopter
-        ingress_egress_altitude = (
-            self.doctrine.ingress_altitude if not is_helo else meters(50)
+        patrol_altitude = self.doctrine.resolve_combat_altitude(is_helo)
+        use_agl_patrol_altitude = is_helo
+
+        ip_solver = IpSolver(
+            dcs_to_shapely_point(self.flight.departure.position),
+            dcs_to_shapely_point(patrol_start),
+            self.doctrine,
+            self.threat_zones.all,
         )
-        use_agl_ingress_egress = is_helo
+        ip_solver.set_debug_properties(
+            waypoint_debug_directory() / "IP", self.theater.terrain
+        )
+        ingress_point_shapely = ip_solver.solve()
+        if dump_debug_info:
+            ip_solver.dump_debug_info()
+
+        ingress_point = patrol_start.new_in_same_map(
+            ingress_point_shapely.x, ingress_point_shapely.y
+        )
+
+        patrol_start_waypoint = builder.nav(
+            patrol_start, patrol_altitude, use_agl_patrol_altitude
+        )
+        patrol_start_waypoint.name = "FLOT START"
+        patrol_start_waypoint.pretty_name = "FLOT start"
+        patrol_start_waypoint.description = "FLOT boundary"
+        patrol_start_waypoint.wants_escort = True
+
+        patrol_end_waypoint = builder.nav(
+            patrol_end, patrol_altitude, use_agl_patrol_altitude
+        )
+        patrol_end_waypoint.name = "FLOT END"
+        patrol_end_waypoint.pretty_name = "FLOT end"
+        patrol_end_waypoint.description = "FLOT boundary"
+        patrol_end_waypoint.wants_escort = True
+
+        ingress = builder.ingress(
+            FlightWaypointType.INGRESS_CAS, ingress_point, location
+        )
+        ingress.description = f"Ingress to provide CAS at {location}"
 
         return CasLayout(
             departure=builder.takeoff(self.flight.departure),
             nav_to=builder.nav_path(
                 self.flight.departure.position,
-                ingress,
-                ingress_egress_altitude,
-                use_agl_ingress_egress,
+                ingress_point,
+                patrol_altitude,
+                use_agl_patrol_altitude,
             ),
             nav_from=builder.nav_path(
-                egress,
+                patrol_end,
                 self.flight.arrival.position,
-                ingress_egress_altitude,
-                use_agl_ingress_egress,
+                patrol_altitude,
+                use_agl_patrol_altitude,
             ),
-            patrol_start=builder.ingress(
-                FlightWaypointType.INGRESS_CAS, ingress, location
-            ),
-            target=builder.cas(center),
-            patrol_end=builder.egress(egress, location),
+            ingress=ingress,
+            patrol_start=patrol_start_waypoint,
+            patrol_end=patrol_end_waypoint,
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> CasFlightPlan:
-        return CasFlightPlan(self.flight, self.layout())
+    def build(self, dump_debug_info: bool = False) -> CasFlightPlan:
+        return CasFlightPlan(self.flight, self.layout(dump_debug_info))

game/ato/flightplans/custom.py

@@ -72,5 +72,5 @@ class Builder(IBuilder[CustomFlightPlan, CustomLayout]):
         builder = WaypointBuilder(self.flight, self.coalition)
         return CustomLayout(builder.takeoff(self.flight.departure), self.waypoints)
 
-    def build(self) -> CustomFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> CustomFlightPlan:
         return CustomFlightPlan(self.flight, self.layout())

game/ato/flightplans/dead.py

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

game/ato/flightplans/escort.py

@@ -33,7 +33,7 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
             nav_to=builder.nav_path(
-                hold.position, join.position, self.doctrine.ingress_altitude
+                hold.position, join.position, self.doctrine.combat_altitude
             ),
             join=join,
             ingress=ingress,
@@ -43,12 +43,12 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
             nav_from=builder.nav_path(
                 refuel.position,
                 self.flight.arrival.position,
-                self.doctrine.ingress_altitude,
+                self.doctrine.combat_altitude,
             ),
             arrival=builder.land(self.flight.arrival),
             divert=builder.divert(self.flight.divert),
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> EscortFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> EscortFlightPlan:
         return EscortFlightPlan(self.flight, self.layout())

game/ato/flightplans/ferry.py

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

game/ato/flightplans/flightplan.py

@@ -5,6 +5,7 @@ MissionPlanner. Those only plan basic information like the objective, aircraft
 type, and the size of the flight. The FlightPlanBuilder is responsible for
 generating the waypoints for the mission.
 """
+
 from __future__ import annotations
 
 import math
@@ -12,7 +13,6 @@ from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from dataclasses import dataclass
 from datetime import datetime, timedelta
-from functools import cached_property
 from typing import Any, Generic, TYPE_CHECKING, TypeGuard, TypeVar
 
 from game.typeguard import self_type_guard
@@ -20,10 +20,9 @@ from game.utils import Distance, Speed, meters
 from .planningerror import PlanningError
 from ..flightwaypointtype import FlightWaypointType
 from ..starttype import StartType
-from ..traveltime import GroundSpeed, TravelTime
+from ..traveltime import GroundSpeed
 
 if TYPE_CHECKING:
-    from game.dcs.aircrafttype import FuelConsumption
     from game.theater import ControlPoint
     from ..flight import Flight
     from ..flightwaypoint import FlightWaypoint
@@ -32,14 +31,6 @@ if TYPE_CHECKING:
     from .loiter import LoiterFlightPlan
     from .patrolling import PatrollingFlightPlan
 
-INGRESS_TYPES = {
-    FlightWaypointType.INGRESS_CAS,
-    FlightWaypointType.INGRESS_ESCORT,
-    FlightWaypointType.INGRESS_SEAD,
-    FlightWaypointType.INGRESS_STRIKE,
-    FlightWaypointType.INGRESS_DEAD,
-}
-
 
 @dataclass(frozen=True)
 class Layout(ABC):
@@ -62,6 +53,7 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def __init__(self, flight: Flight, layout: LayoutT) -> None:
         self.flight = flight
         self.layout = layout
+        self.tot_offset = self.default_tot_offset()
 
     @property
     def package(self) -> Package:
@@ -152,39 +144,6 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def tot(self) -> datetime:
         return self.package.time_over_target + self.tot_offset
 
-    @cached_property
-    def bingo_fuel(self) -> int:
-        """Bingo fuel value for the FlightPlan"""
-        if (fuel := self.flight.unit_type.fuel_consumption) is not None:
-            return self._bingo_estimate(fuel)
-        return self._legacy_bingo_estimate()
-
-    def _bingo_estimate(self, fuel: FuelConsumption) -> int:
-        distance_to_arrival = self.max_distance_from(self.flight.arrival)
-        fuel_consumed = fuel.cruise * distance_to_arrival.nautical_miles
-        bingo = fuel_consumed + fuel.min_safe
-        return math.ceil(bingo / 100) * 100
-
-    def _legacy_bingo_estimate(self) -> int:
-        distance_to_arrival = self.max_distance_from(self.flight.arrival)
-
-        bingo = 1000.0  # Minimum Emergency Fuel
-        bingo += 500  # Visual Traffic
-        bingo += 15 * distance_to_arrival.nautical_miles
-
-        # TODO: Per aircraft tweaks.
-
-        if self.flight.divert is not None:
-            max_divert_distance = self.max_distance_from(self.flight.divert)
-            bingo += 10 * max_divert_distance.nautical_miles
-
-        return round(bingo / 100) * 100
-
-    @cached_property
-    def joker_fuel(self) -> int:
-        """Joker fuel value for the FlightPlan"""
-        return self.bingo_fuel + 1000
-
     def max_distance_from(self, cp: ControlPoint) -> Distance:
         """Returns the farthest waypoint of the flight plan from a ControlPoint.
         :arg cp The ControlPoint to measure distance from.
@@ -195,8 +154,7 @@ class FlightPlan(ABC, Generic[LayoutT]):
             [meters(cp.position.distance_to_point(w.position)) for w in self.waypoints]
         )
 
-    @property
-    def tot_offset(self) -> timedelta:
+    def default_tot_offset(self) -> timedelta:
         """This flight's offset from the package's TOT.
 
         Positive values represent later TOTs. An offset of -2 minutes is used
@@ -214,7 +172,7 @@ class FlightPlan(ABC, Generic[LayoutT]):
             )
 
         for previous_waypoint, waypoint in self.edges(until=destination):
-            total += self.travel_time_between_waypoints(previous_waypoint, waypoint)
+            total += self.total_time_between_waypoints(previous_waypoint, waypoint)
 
         # Trim microseconds. Our simulation tick rate is 1 second, so anything that
         # takes 100.1 or 100.9 seconds will take 100 seconds. DCS doesn't handle
@@ -223,12 +181,23 @@ class FlightPlan(ABC, Generic[LayoutT]):
         # model.
         return timedelta(seconds=math.floor(total.total_seconds()))
 
+    def total_time_between_waypoints(
+        self, a: FlightWaypoint, b: FlightWaypoint
+    ) -> timedelta:
+        """Returns the total time spent between a and b.
+
+        The total time between waypoints differs from the travel time in that it may
+        include additional time for actions such as loitering.
+        """
+        return self.travel_time_between_waypoints(a, b)
+
     def travel_time_between_waypoints(
         self, a: FlightWaypoint, b: FlightWaypoint
     ) -> timedelta:
-        return TravelTime.between_points(
-            a.position, b.position, self.speed_between_waypoints(a, b)
-        )
+        error_factor = 1.05
+        speed = self.speed_between_waypoints(a, b)
+        distance = meters(a.position.distance_to_point(b.position))
+        return timedelta(hours=distance.nautical_miles / speed.knots * error_factor)
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         raise NotImplementedError
@@ -237,24 +206,21 @@ class FlightPlan(ABC, Generic[LayoutT]):
         raise NotImplementedError
 
     def request_escort_at(self) -> FlightWaypoint | None:
-        return None
+        try:
+            return next(self.escorted_waypoints())
+        except StopIteration:
+            return None
 
     def dismiss_escort_at(self) -> FlightWaypoint | None:
-        return None
+        try:
+            return list(self.escorted_waypoints())[-1]
+        except IndexError:
+            return None
 
     def escorted_waypoints(self) -> Iterator[FlightWaypoint]:
-        begin = self.request_escort_at()
-        end = self.dismiss_escort_at()
-        if begin is None or end is None:
-            return
-        escorting = False
-        for waypoint in self.waypoints:
-            if waypoint == begin:
-                escorting = True
-            if escorting:
+        for waypoint in self.iter_waypoints():
+            if waypoint.wants_escort:
                 yield waypoint
-            if waypoint == end:
-                return
 
     def takeoff_time(self) -> datetime:
         return self.tot - self._travel_time_to_waypoint(self.tot_waypoint)
@@ -283,7 +249,7 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def estimate_ground_ops(self) -> timedelta:
         if self.flight.start_type in {StartType.RUNWAY, StartType.IN_FLIGHT}:
             return timedelta()
-        if self.flight.from_cp.is_fleet:
+        if self.flight.departure.is_fleet:
             return timedelta(minutes=2)
         else:
             return timedelta(minutes=8)
@@ -304,7 +270,9 @@ class FlightPlan(ABC, Generic[LayoutT]):
         raise NotImplementedError
 
     @self_type_guard
-    def is_loiter(self, flight_plan: FlightPlan[Any]) -> TypeGuard[LoiterFlightPlan]:
+    def is_loiter(
+        self, flight_plan: FlightPlan[Any]
+    ) -> TypeGuard[LoiterFlightPlan[Any]]:
         return False
 
     @self_type_guard
@@ -316,5 +284,8 @@ class FlightPlan(ABC, Generic[LayoutT]):
     @self_type_guard
     def is_formation(
         self, flight_plan: FlightPlan[Any]
-    ) -> TypeGuard[FormationFlightPlan]:
+    ) -> TypeGuard[FormationFlightPlan[Any]]:
         return False
+
+    def add_waypoint_actions(self) -> None:
+        pass

game/ato/flightplans/formation.py

@@ -4,13 +4,12 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from functools import cached_property
-from typing import Any, TYPE_CHECKING, TypeGuard
+from typing import Any, TYPE_CHECKING, TypeGuard, TypeVar
 
 from game.typeguard import self_type_guard
 from game.utils import Speed
 from .flightplan import FlightPlan
 from .loiter import LoiterFlightPlan, LoiterLayout
-from ..traveltime import GroundSpeed, TravelTime
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
@@ -25,22 +24,18 @@ class FormationLayout(LoiterLayout, ABC):
     nav_from: list[FlightWaypoint]
 
 
-class FormationFlightPlan(LoiterFlightPlan, ABC):
+LayoutT = TypeVar("LayoutT", bound=FormationLayout)
+
+
+class FormationFlightPlan(LoiterFlightPlan[LayoutT], ABC):
     @property
     @abstractmethod
-    def package_speed_waypoints(self) -> set[FlightWaypoint]:
-        ...
+    def package_speed_waypoints(self) -> set[FlightWaypoint]: ...
 
     @property
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
         return self.package_speed_waypoints
 
-    def request_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.join
-
-    def dismiss_escort_at(self) -> FlightWaypoint | None:
-        return self.layout.split
-
     @cached_property
     def best_flight_formation_speed(self) -> Speed:
         """The best speed this flight is capable at all formation waypoints.
@@ -73,13 +68,11 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
 
     @property
     @abstractmethod
-    def join_time(self) -> datetime:
-        ...
+    def join_time(self) -> datetime: ...
 
     @property
     @abstractmethod
-    def split_time(self) -> datetime:
-        ...
+    def split_time(self) -> datetime: ...
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.join:
@@ -90,10 +83,8 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
 
     @property
     def push_time(self) -> datetime:
-        return self.join_time - TravelTime.between_points(
-            self.layout.hold.position,
-            self.layout.join.position,
-            GroundSpeed.for_flight(self.flight, self.layout.hold.alt),
+        return self.join_time - self.travel_time_between_waypoints(
+            self.layout.hold, self.layout.join
         )
 
     @property
@@ -107,5 +98,5 @@ class FormationFlightPlan(LoiterFlightPlan, ABC):
     @self_type_guard
     def is_formation(
         self, flight_plan: FlightPlan[Any]
-    ) -> TypeGuard[FormationFlightPlan]:
+    ) -> TypeGuard[FormationFlightPlan[Any]]:
         return True

game/ato/flightplans/formationattack.py

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

game/ato/flightplans/ibuilder.py

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

game/ato/flightplans/loiter.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from datetime import datetime, timedelta
-from typing import Any, TYPE_CHECKING, TypeGuard
+from typing import Any, TYPE_CHECKING, TypeGuard, TypeVar
 
+from game.flightplan.waypointactions.hold import Hold
 from game.typeguard import self_type_guard
+from game.utils import Speed
 from .flightplan import FlightPlan
 from .standard import StandardFlightPlan, StandardLayout
 
@@ -18,29 +20,43 @@ class LoiterLayout(StandardLayout, ABC):
     hold: FlightWaypoint
 
 
-class LoiterFlightPlan(StandardFlightPlan[Any], ABC):
+LayoutT = TypeVar("LayoutT", bound=LoiterLayout)
+
+
+class LoiterFlightPlan(StandardFlightPlan[LayoutT], ABC):
     @property
     def hold_duration(self) -> timedelta:
         return timedelta(minutes=5)
 
     @property
     @abstractmethod
-    def push_time(self) -> datetime:
-        ...
+    def push_time(self) -> datetime: ...
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> datetime | None:
         if waypoint == self.layout.hold:
             return self.push_time
         return None
 
-    def travel_time_between_waypoints(
+    def total_time_between_waypoints(
         self, a: FlightWaypoint, b: FlightWaypoint
     ) -> timedelta:
-        travel_time = super().travel_time_between_waypoints(a, b)
+        travel_time = super().total_time_between_waypoints(a, b)
         if a != self.layout.hold:
             return travel_time
         return travel_time + self.hold_duration
 
     @self_type_guard
-    def is_loiter(self, flight_plan: FlightPlan[Any]) -> TypeGuard[LoiterFlightPlan]:
+    def is_loiter(
+        self, flight_plan: FlightPlan[Any]
+    ) -> TypeGuard[LoiterFlightPlan[Any]]:
         return True
+
+    def provide_push_time(self) -> datetime:
+        return self.push_time
+
+    def add_waypoint_actions(self) -> None:
+        hold = self.layout.hold
+        speed = self.flight.unit_type.patrol_speed
+        if speed is None:
+            speed = Speed.from_mach(0.6, hold.alt)
+        hold.add_action(Hold(self.provide_push_time, hold.alt, speed))

game/ato/flightplans/ocaaircraft.py

@@ -32,5 +32,5 @@ class Builder(FormationAttackBuilder[OcaAircraftFlightPlan, FormationAttackLayou
 
         return self._build(FlightWaypointType.INGRESS_OCA_AIRCRAFT)
 
-    def build(self) -> OcaAircraftFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> OcaAircraftFlightPlan:
         return OcaAircraftFlightPlan(self.flight, self.layout())

game/ato/flightplans/ocarunway.py

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

game/ato/flightplans/packagerefueling.py

@@ -59,10 +59,10 @@ class PackageRefuelingFlightPlan(RefuelingFlightPlan):
             "REFUEL", FlightWaypointType.REFUEL, refuel, altitude
         )
 
-        delay_target_to_split: timedelta = self.travel_time_between_waypoints(
+        delay_target_to_split: timedelta = self.total_time_between_waypoints(
             self.target_area_waypoint(), split_waypoint
         )
-        delay_split_to_refuel: timedelta = self.travel_time_between_waypoints(
+        delay_split_to_refuel: timedelta = self.total_time_between_waypoints(
             split_waypoint, refuel_waypoint
         )
 
@@ -121,5 +121,5 @@ class Builder(IBuilder[PackageRefuelingFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> PackageRefuelingFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> PackageRefuelingFlightPlan:
         return PackageRefuelingFlightPlan(self.flight, self.layout())

game/ato/flightplans/patrolling.py

@@ -62,7 +62,7 @@ class PatrollingFlightPlan(StandardFlightPlan[LayoutT], UiZoneDisplay, ABC):
 
     @property
     def patrol_start_time(self) -> datetime:
-        return self.package.time_over_target
+        return self.tot
 
     @property
     def patrol_end_time(self) -> datetime:

game/ato/flightplans/rtb.py

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

game/ato/flightplans/sead.py

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

game/ato/flightplans/shiprecoverytanker.py

@@ -65,7 +65,6 @@ class RecoveryTankerFlightPlan(StandardFlightPlan[RecoveryTankerLayout]):
 
 class Builder(IBuilder[RecoveryTankerFlightPlan, RecoveryTankerLayout]):
     def layout(self) -> RecoveryTankerLayout:
-
         builder = WaypointBuilder(self.flight, self.coalition)
 
         # TODO: Propagate the ship position to the Tanker's TOT,
@@ -91,5 +90,5 @@ class Builder(IBuilder[RecoveryTankerFlightPlan, RecoveryTankerLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> RecoveryTankerFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> RecoveryTankerFlightPlan:
         return RecoveryTankerFlightPlan(self.flight, self.layout())

game/ato/flightplans/strike.py

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

game/ato/flightplans/sweep.py

@@ -5,13 +5,15 @@ from datetime import datetime, timedelta
 from typing import Iterator, TYPE_CHECKING, Type
 
 from dcs import Point
+from dcs.task import Targets
 
-from game.utils import Heading
+from game.flightplan import HoldZoneGeometry
+from game.flightplan.waypointactions.engagetargets import EngageTargets
+from game.flightplan.waypointoptions.formation import Formation
+from game.utils import Heading, nautical_miles
 from .ibuilder import IBuilder
 from .loiter import LoiterFlightPlan, LoiterLayout
 from .waypointbuilder import WaypointBuilder
-from ..traveltime import GroundSpeed, TravelTime
-from ...flightplan import HoldZoneGeometry
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
@@ -37,11 +39,7 @@ class SweepLayout(LoiterLayout):
         yield self.bullseye
 
 
-class SweepFlightPlan(LoiterFlightPlan):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=5)
-
+class SweepFlightPlan(LoiterFlightPlan[SweepLayout]):
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
@@ -54,13 +52,12 @@ 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) -> datetime:
-        travel_time = self.travel_time_between_waypoints(
+        travel_time = self.total_time_between_waypoints(
             self.layout.sweep_start, self.layout.sweep_end
         )
         return self.sweep_end_time - travel_time
@@ -83,10 +80,8 @@ class SweepFlightPlan(LoiterFlightPlan):
 
     @property
     def push_time(self) -> datetime:
-        return self.sweep_end_time - TravelTime.between_points(
-            self.layout.hold.position,
-            self.layout.sweep_end.position,
-            GroundSpeed.for_flight(self.flight, self.layout.hold.alt),
+        return self.sweep_end_time - self.travel_time_between_waypoints(
+            self.layout.hold, self.layout.sweep_end
         )
 
     @property
@@ -97,6 +92,19 @@ class SweepFlightPlan(LoiterFlightPlan):
     def mission_departure_time(self) -> datetime:
         return self.sweep_end_time
 
+    def add_waypoint_actions(self) -> None:
+        super().add_waypoint_actions()
+        self.layout.sweep_start.set_option(Formation.LINE_ABREAST_OPEN)
+        self.layout.sweep_start.add_action(
+            EngageTargets(
+                nautical_miles(50),
+                [
+                    Targets.All.Air.Planes.Fighters,
+                    Targets.All.Air.Planes.MultiroleFighters,
+                ],
+            )
+        )
+
 
 class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
     def layout(self) -> SweepLayout:
@@ -106,11 +114,11 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
             self.package.waypoints.join.heading_between_point(target)
         )
         start_pos = target.point_from_heading(
-            heading.degrees, -self.doctrine.sweep_distance.meters
+            heading.degrees, -self.doctrine.sweep.distance.meters
         )
 
         builder = WaypointBuilder(self.flight, self.coalition)
-        start, end = builder.sweep(start_pos, target, self.doctrine.ingress_altitude)
+        start, end = builder.sweep(start_pos, target, self.doctrine.combat_altitude)
 
         hold = builder.hold(self._hold_point())
 
@@ -118,12 +126,12 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
             nav_to=builder.nav_path(
-                hold.position, start.position, self.doctrine.ingress_altitude
+                hold.position, start.position, self.doctrine.combat_altitude
             ),
             nav_from=builder.nav_path(
                 end.position,
                 self.flight.arrival.position,
-                self.doctrine.ingress_altitude,
+                self.doctrine.combat_altitude,
             ),
             sweep_start=start,
             sweep_end=end,
@@ -142,5 +150,5 @@ class Builder(IBuilder[SweepFlightPlan, SweepLayout]):
             target, origin, ip, join, self.coalition, self.theater
         ).find_best_hold_point()
 
-    def build(self) -> SweepFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> SweepFlightPlan:
         return SweepFlightPlan(self.flight, self.layout())

game/ato/flightplans/tarcap.py

@@ -34,17 +34,13 @@ 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
         # flights in the package that have requested escort. If the package
         # requests an escort the CAP self.flight will remain on station for the
         # duration of the escorted mission, or until it is winchester/bingo.
-        return self.flight.coalition.doctrine.cap_duration
+        return self.flight.coalition.doctrine.cap.duration
 
     @property
     def patrol_speed(self) -> Speed:
@@ -54,7 +50,7 @@ class TarCapFlightPlan(PatrollingFlightPlan[TarCapLayout]):
 
     @property
     def engagement_distance(self) -> Distance:
-        return self.flight.coalition.doctrine.cap_engagement_range
+        return self.flight.coalition.doctrine.cap.engagement_range
 
     @staticmethod
     def builder_type() -> Type[Builder]:
@@ -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) -> datetime | None:
         if waypoint == self.layout.patrol_end:
@@ -95,8 +90,8 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
         preferred_alt = self.flight.unit_type.preferred_patrol_altitude
         randomized_alt = preferred_alt + feet(random.randint(-2, 1) * 1000)
         patrol_alt = max(
-            self.doctrine.min_patrol_altitude,
-            min(self.doctrine.max_patrol_altitude, randomized_alt),
+            self.doctrine.cap.min_patrol_altitude,
+            min(self.doctrine.cap.max_patrol_altitude, randomized_alt),
         )
 
         builder = WaypointBuilder(self.flight, self.coalition)
@@ -127,5 +122,5 @@ class Builder(CapBuilder[TarCapFlightPlan, TarCapLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> TarCapFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> TarCapFlightPlan:
         return TarCapFlightPlan(self.flight, self.layout())

game/ato/flightplans/theaterrefueling.py

@@ -17,7 +17,13 @@ class TheaterRefuelingFlightPlan(RefuelingFlightPlan):
 
     @property
     def patrol_duration(self) -> timedelta:
-        return timedelta(hours=1)
+        # Add 30 minutes to desired_player_mission_duration as TOTs for flights
+        # can sit up to this time. This extension means the tanker remains on
+        # station for the flights' return.
+        return (
+            self.flight.coalition.game.settings.desired_player_mission_duration
+            + timedelta(minutes=30)
+        )
 
 
 class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
@@ -79,5 +85,5 @@ class Builder(IBuilder[TheaterRefuelingFlightPlan, PatrollingLayout]):
             bullseye=builder.bullseye(),
         )
 
-    def build(self) -> TheaterRefuelingFlightPlan:
+    def build(self, dump_debug_info: bool = False) -> TheaterRefuelingFlightPlan:
         return TheaterRefuelingFlightPlan(self.flight, self.layout())

game/ato/flightplans/uizonedisplay.py

@@ -14,5 +14,4 @@ class UiZone:
 
 class UiZoneDisplay(abc.ABC):
     @abc.abstractmethod
-    def ui_zone(self) -> UiZone:
-        ...
+    def ui_zone(self) -> UiZone: ...

game/ato/flightplans/waypointbuilder.py

@@ -72,7 +72,7 @@ class WaypointBuilder:
                 "NAV",
                 FlightWaypointType.NAV,
                 position,
-                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
+                self.doctrine.resolve_rendezvous_altitude(self.is_helo),
                 description="Enter theater",
                 pretty_name="Enter theater",
             )
@@ -99,7 +99,7 @@ class WaypointBuilder:
                 "NAV",
                 FlightWaypointType.NAV,
                 position,
-                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
+                self.doctrine.resolve_rendezvous_altitude(self.is_helo),
                 description="Exit theater",
                 pretty_name="Exit theater",
             )
@@ -127,10 +127,7 @@ 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 = self.doctrine.resolve_rendezvous_altitude(self.is_helo)
             altitude_type = "BARO"
         else:
             altitude = meters(0)
@@ -168,7 +165,7 @@ class WaypointBuilder:
             "HOLD",
             FlightWaypointType.LOITER,
             position,
-            meters(500) if self.is_helo else self.doctrine.rendezvous_altitude,
+            self.doctrine.resolve_rendezvous_altitude(self.is_helo),
             alt_type,
             description="Wait until push time",
             pretty_name="Hold",
@@ -183,7 +180,7 @@ class WaypointBuilder:
             "JOIN",
             FlightWaypointType.JOIN,
             position,
-            meters(80) if self.is_helo else self.doctrine.ingress_altitude,
+            self.doctrine.resolve_combat_altitude(self.is_helo),
             alt_type,
             description="Rendezvous with package",
             pretty_name="Join",
@@ -198,7 +195,7 @@ class WaypointBuilder:
             "REFUEL",
             FlightWaypointType.REFUEL,
             position,
-            meters(80) if self.is_helo else self.doctrine.ingress_altitude,
+            self.doctrine.resolve_combat_altitude(self.is_helo),
             alt_type,
             description="Refuel from tanker",
             pretty_name="Refuel",
@@ -226,7 +223,7 @@ class WaypointBuilder:
             "SPLIT",
             FlightWaypointType.SPLIT,
             position,
-            meters(80) if self.is_helo else self.doctrine.ingress_altitude,
+            self.doctrine.resolve_combat_altitude(self.is_helo),
             alt_type,
             description="Depart from package",
             pretty_name="Split",
@@ -246,28 +243,13 @@ class WaypointBuilder:
             "INGRESS",
             ingress_type,
             position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
+            self.doctrine.resolve_combat_altitude(self.is_helo),
             alt_type,
             description=f"INGRESS on {objective.name}",
             pretty_name=f"INGRESS on {objective.name}",
             targets=objective.strike_targets,
         )
 
-    def egress(self, position: Point, target: MissionTarget) -> FlightWaypoint:
-        alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
-            alt_type = "RADIO"
-
-        return FlightWaypoint(
-            "EGRESS",
-            FlightWaypointType.EGRESS,
-            position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
-            alt_type,
-            description=f"EGRESS from {target.name}",
-            pretty_name=f"EGRESS from {target.name}",
-        )
-
     def bai_group(self, target: StrikeTarget) -> FlightWaypoint:
         return self._target_point(target, f"ATTACK {target.name}")
 
@@ -306,7 +288,7 @@ class WaypointBuilder:
             f"SEAD on {target.name}",
             target,
             flyover=True,
-            altitude=self.doctrine.ingress_altitude,
+            altitude=self.doctrine.combat_altitude,
             alt_type="BARO",
         )
 
@@ -357,17 +339,6 @@ class WaypointBuilder:
             waypoint.only_for_player = True
         return waypoint
 
-    def cas(self, position: Point) -> FlightWaypoint:
-        return FlightWaypoint(
-            "CAS",
-            FlightWaypointType.CAS,
-            position,
-            meters(60) if self.is_helo else meters(1000),
-            "RADIO",
-            description="Provide CAS",
-            pretty_name="CAS",
-        )
-
     @staticmethod
     def race_track_start(position: Point, altitude: Distance) -> FlightWaypoint:
         """Creates a racetrack start waypoint.
@@ -507,7 +478,7 @@ class WaypointBuilder:
             "TARGET",
             FlightWaypointType.TARGET_GROUP_LOC,
             target.position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
+            self.doctrine.resolve_combat_altitude(self.is_helo),
             alt_type,
             description="Escort the package",
             pretty_name="Target area",

game/ato/flightroster.py

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

game/ato/flightstate/actionstate.py

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

game/ato/flightstate/flightstate.py

@@ -57,14 +57,12 @@ class FlightState(ABC):
 
     @property
     @abstractmethod
-    def cancelable(self) -> bool:
-        ...
+    def cancelable(self) -> bool: ...
 
     @abstractmethod
     def on_game_tick(
         self, events: GameUpdateEvents, time: datetime, duration: timedelta
-    ) -> None:
-        ...
+    ) -> None: ...
 
     @property
     def in_flight(self) -> bool:
@@ -95,17 +93,14 @@ class FlightState(ABC):
 
     @property
     @abstractmethod
-    def is_waiting_for_start(self) -> bool:
-        ...
+    def is_waiting_for_start(self) -> bool: ...
 
     @abstractmethod
-    def estimate_position(self) -> Point:
-        ...
+    def estimate_position(self) -> Point: ...
 
     @property
     @abstractmethod
-    def spawn_type(self) -> StartType:
-        ...
+    def spawn_type(self) -> StartType: ...
 
     def a2a_commit_region(self) -> Optional[ThreatPoly]:
         return None

game/ato/flightstate/inflight.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from collections import deque
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING
 
 from dcs import Point
 
 from game.ato.flightstate import Completed
+from game.ato.flightstate.actionstate import ActionState
 from game.ato.flightstate.flightstate import FlightState
 from game.ato.flightwaypoint import FlightWaypoint
 from game.ato.flightwaypointtype import FlightWaypointType
@@ -37,6 +39,15 @@ class InFlight(FlightState, ABC):
         self.total_time_to_next_waypoint = self.travel_time_between_waypoints()
         self.elapsed_time = timedelta()
         self.current_waypoint_elapsed = False
+        self.pending_actions: deque[ActionState] = deque(
+            ActionState(a) for a in self.current_waypoint.actions
+        )
+
+    @property
+    def current_action(self) -> ActionState | None:
+        if self.pending_actions:
+            return self.pending_actions[0]
+        return None
 
     @property
     def cancelable(self) -> bool:
@@ -51,29 +62,18 @@ class InFlight(FlightState, ABC):
         return index <= self.waypoint_index
 
     def travel_time_between_waypoints(self) -> timedelta:
-        travel_time = self.flight.flight_plan.travel_time_between_waypoints(
+        return self.flight.flight_plan.travel_time_between_waypoints(
             self.current_waypoint, self.next_waypoint
         )
-        if self.current_waypoint.waypoint_type is FlightWaypointType.LOITER:
-            # Loiter time is already built into travel_time_between_waypoints. If we're
-            # at a loiter point but still a regular InFlight (Loiter overrides this
-            # method) that means we're traveling from the loiter point but no longer
-            # loitering.
-            assert self.flight.flight_plan.is_loiter(self.flight.flight_plan)
-            travel_time -= self.flight.flight_plan.hold_duration
-        return travel_time
 
     @abstractmethod
-    def estimate_position(self) -> Point:
-        ...
+    def estimate_position(self) -> Point: ...
 
     @abstractmethod
-    def estimate_altitude(self) -> tuple[Distance, str]:
-        ...
+    def estimate_altitude(self) -> tuple[Distance, str]: ...
 
     @abstractmethod
-    def estimate_speed(self) -> Speed:
-        ...
+    def estimate_speed(self) -> Speed: ...
 
     def estimate_fuel_at_current_waypoint(self) -> float:
         initial_fuel = super().estimate_fuel()
@@ -88,7 +88,6 @@ class InFlight(FlightState, ABC):
         return initial_fuel
 
     def next_waypoint_state(self) -> FlightState:
-        from .loiter import Loiter
         from .racetrack import RaceTrack
         from .navigating import Navigating
 
@@ -97,8 +96,6 @@ class InFlight(FlightState, ABC):
             return Completed(self.flight, self.settings)
         if self.next_waypoint.waypoint_type is FlightWaypointType.PATROL_TRACK:
             return RaceTrack(self.flight, self.settings, new_index)
-        if self.next_waypoint.waypoint_type is FlightWaypointType.LOITER:
-            return Loiter(self.flight, self.settings, new_index)
         return Navigating(self.flight, self.settings, new_index)
 
     def advance_to_next_waypoint(self) -> FlightState:
@@ -110,6 +107,13 @@ class InFlight(FlightState, ABC):
     def on_game_tick(
         self, events: GameUpdateEvents, time: datetime, duration: timedelta
     ) -> None:
+        while (action := self.current_action) is not None:
+            duration = action.on_game_tick(time, duration)
+            if action.is_finished():
+                self.pending_actions.popleft()
+            if duration <= timedelta():
+                return
+
         self.elapsed_time += duration
         if self.elapsed_time > self.total_time_to_next_waypoint:
             new_state = self.advance_to_next_waypoint()
@@ -160,11 +164,3 @@ class InFlight(FlightState, ABC):
     @property
     def spawn_type(self) -> StartType:
         return StartType.IN_FLIGHT
-
-    @property
-    def description(self) -> str:
-        if self.has_aborted:
-            abort = "(Aborted) "
-        else:
-            abort = ""
-        return f"{abort}Flying to {self.next_waypoint.name}"

game/ato/flightstate/loiter.py

@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-from datetime import timedelta
-from typing import TYPE_CHECKING
-
-from dcs import Point
-
-from game.ato.flightstate import FlightState, InFlight
-from game.ato.flightstate.navigating import Navigating
-from game.utils import Distance, Speed
-
-if TYPE_CHECKING:
-    from game.ato.flight import Flight
-    from game.settings import Settings
-
-
-class Loiter(InFlight):
-    def __init__(self, flight: Flight, settings: Settings, waypoint_index: int) -> None:
-        assert flight.flight_plan.is_loiter(flight.flight_plan)
-        self.hold_duration = flight.flight_plan.hold_duration
-        super().__init__(flight, settings, waypoint_index)
-
-    def estimate_position(self) -> Point:
-        return self.current_waypoint.position
-
-    def estimate_altitude(self) -> tuple[Distance, str]:
-        return self.current_waypoint.alt, self.current_waypoint.alt_type
-
-    def estimate_speed(self) -> Speed:
-        return self.flight.unit_type.preferred_patrol_speed(self.estimate_altitude()[0])
-
-    def estimate_fuel(self) -> float:
-        # TODO: Estimate loiter consumption per minute?
-        return self.estimate_fuel_at_current_waypoint()
-
-    def next_waypoint_state(self) -> FlightState:
-        # Do not automatically advance to the next waypoint. Just proceed from the
-        # current one with the normal flying state.
-        return Navigating(self.flight, self.settings, self.waypoint_index)
-
-    def travel_time_between_waypoints(self) -> timedelta:
-        return self.hold_duration
-
-    @property
-    def description(self) -> str:
-        return f"Loitering for {self.hold_duration - self.elapsed_time}"

game/ato/flightstate/navigating.py

@@ -29,6 +29,11 @@ class Navigating(InFlight):
             events.update_flight_position(self.flight, self.estimate_position())
 
     def progress(self) -> float:
+        # if next waypoint is very close, assume we reach it immediately to avoid divide
+        # by zero error
+        if self.total_time_to_next_waypoint.total_seconds() < 1:
+            return 1.0
+
         return (
             self.elapsed_time.total_seconds()
             / self.total_time_to_next_waypoint.total_seconds()
@@ -80,3 +85,14 @@ class Navigating(InFlight):
     @property
     def spawn_type(self) -> StartType:
         return StartType.IN_FLIGHT
+
+    @property
+    def description(self) -> str:
+        if (action := self.current_action) is not None:
+            return action.describe()
+
+        if self.has_aborted:
+            abort = "(Aborted) "
+        else:
+            abort = ""
+        return f"{abort}Flying to {self.next_waypoint.name}"

game/ato/flightstate/startup.py

@@ -8,6 +8,9 @@ from .atdeparture import AtDeparture
 from .taxi import Taxi
 from ..starttype import StartType
 
+from game.settings.settings import FastForwardStopCondition
+
+
 if TYPE_CHECKING:
     from game.ato.flight import Flight
     from game.settings import Settings
@@ -37,7 +40,8 @@ class StartUp(AtDeparture):
     def should_halt_sim(self) -> bool:
         if (
             self.flight.client_count > 0
-            and self.settings.player_mission_interrupts_sim_at is StartType.COLD
+            and self.settings.fast_forward_stop_condition
+            == FastForwardStopCondition.PLAYER_STARTUP
         ):
             logging.info(
                 f"Interrupting simulation because {self.flight} has players and has "

game/ato/flightstate/takeoff.py

@@ -9,6 +9,8 @@ from .navigating import Navigating
 from ..starttype import StartType
 from ...utils import LBS_TO_KG
 
+from game.settings.settings import FastForwardStopCondition
+
 if TYPE_CHECKING:
     from game.ato.flight import Flight
     from game.settings import Settings
@@ -45,7 +47,8 @@ class Takeoff(AtDeparture):
     def should_halt_sim(self) -> bool:
         if (
             self.flight.client_count > 0
-            and self.settings.player_mission_interrupts_sim_at is StartType.RUNWAY
+            and self.settings.fast_forward_stop_condition
+            == FastForwardStopCondition.PLAYER_TAKEOFF
         ):
             logging.info(
                 f"Interrupting simulation because {self.flight} has players and has "

game/ato/flightstate/taxi.py

@@ -8,6 +8,8 @@ from .atdeparture import AtDeparture
 from .takeoff import Takeoff
 from ..starttype import StartType
 
+from game.settings.settings import FastForwardStopCondition
+
 if TYPE_CHECKING:
     from game.ato.flight import Flight
     from game.settings import Settings
@@ -37,7 +39,8 @@ class Taxi(AtDeparture):
     def should_halt_sim(self) -> bool:
         if (
             self.flight.client_count > 0
-            and self.settings.player_mission_interrupts_sim_at is StartType.WARM
+            and self.settings.fast_forward_stop_condition
+            == FastForwardStopCondition.PLAYER_TAXI
         ):
             logging.info(
                 f"Interrupting simulation because {self.flight} has players and has "

game/ato/flightwaypoint.py

@@ -7,6 +7,8 @@ from typing import Literal, TYPE_CHECKING
 from dcs import Point
 
 from game.ato.flightwaypointtype import FlightWaypointType
+from game.flightplan.waypointactions.waypointaction import WaypointAction
+from game.flightplan.waypointoptions.waypointoption import WaypointOption
 from game.theater.theatergroup import TheaterUnit
 from game.utils import Distance, meters
 
@@ -39,6 +41,11 @@ class FlightWaypoint:
     # The minimum amount of fuel remaining at this waypoint in pounds.
     min_fuel: float | None = None
 
+    wants_escort: bool = False
+
+    actions: list[WaypointAction] = field(default_factory=list)
+    options: dict[str, WaypointOption] = field(default_factory=dict)
+
     # These are set very late by the air conflict generator (part of mission
     # generation). We do it late so that we don't need to propagate changes
     # to waypoint times whenever the player alters the package TOT or the
@@ -46,6 +53,12 @@ class FlightWaypoint:
     tot: datetime | None = None
     departure_time: datetime | None = None
 
+    def add_action(self, action: WaypointAction) -> None:
+        self.actions.append(action)
+
+    def set_option(self, option: WaypointOption) -> None:
+        self.options[option.id()] = option
+
     @property
     def x(self) -> float:
         return self.position.x

game/ato/flightwaypointtype.py

@@ -25,7 +25,7 @@ class FlightWaypointType(IntEnum):
     INGRESS_STRIKE = 5  # Ingress strike (For generator, means that this should have bombing on next TARGET_POINT points)
     INGRESS_SEAD = 6  # Ingress sead (For generator, means that this should attack groups on TARGET_GROUP_LOC points)
     INGRESS_CAS = 7  # Ingress cas (should start CAS task)
-    CAS = 8  # Should do CAS there
+    CAS = 8  # Unused.
     EGRESS = 9  # Should stop attack
     DESCENT_POINT = 10  # Should start descending to pattern alt
     LANDING_POINT = 11  # Should land there
@@ -50,3 +50,4 @@ class FlightWaypointType(IntEnum):
     CARGO_STOP = 30  # Stopover landing point using the LandingReFuAr waypoint type
     INGRESS_AIR_ASSAULT = 31
     RECOVERY_TANKER = 32
+    INGRESS_ANTI_SHIP = 33

game/ato/iflightroster.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Optional, TYPE_CHECKING, Iterator
+
+if TYPE_CHECKING:
+    from game.squadrons import Pilot
+
+
+class IFlightRoster(ABC):
+    @abstractmethod
+    def iter_pilots(self) -> Iterator[Pilot | None]: ...
+
+    @abstractmethod
+    def pilot_at(self, idx: int) -> Pilot | None: ...
+
+    @property
+    @abstractmethod
+    def max_size(self) -> int: ...
+
+    @abstractmethod
+    def resize(self, new_size: int) -> None: ...
+
+    @abstractmethod
+    def set_pilot(self, index: int, pilot: Optional[Pilot]) -> None: ...
+
+    @abstractmethod
+    def clear(self) -> None: ...

game/ato/loadouts.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
+import copy
 import datetime
 import logging
 from collections.abc import Iterable
-from typing import Iterator, Mapping, Optional, TYPE_CHECKING, Type
+from typing import Iterator, Mapping, Optional, TYPE_CHECKING, Type, Any
 
 from dcs.unittype import FlyingType
 
 from game.data.weapons import Pylon, Weapon, WeaponType
 from game.dcs.aircrafttype import AircraftType
+from game.factions.faction import Faction
+
 from .flighttype import FlightType
 
 if TYPE_CHECKING:
@@ -35,6 +38,11 @@ class Loadout:
     def derive_custom(self, name: str) -> Loadout:
         return Loadout(name, self.pylons, self.date, is_custom=True)
 
+    def clone(self) -> Loadout:
+        return Loadout(
+            self.name, dict(self.pylons), copy.deepcopy(self.date), self.is_custom
+        )
+
     def has_weapon_of_type(self, weapon_type: WeaponType) -> bool:
         for weapon in self.pylons.values():
             if weapon is not None and weapon.weapon_group.type is weapon_type:
@@ -46,6 +54,7 @@ class Loadout:
         weapon: Weapon,
         pylon: Pylon,
         date: datetime.date,
+        faction: Faction,
         skip_types: Optional[Iterable[WeaponType]] = None,
     ) -> Optional[Weapon]:
         if skip_types is None:
@@ -53,14 +62,16 @@ class Loadout:
         for fallback in weapon.fallbacks:
             if not pylon.can_equip(fallback):
                 continue
-            if not fallback.available_on(date):
+            if not fallback.available_on(date, faction):
                 continue
             if fallback.weapon_group.type in skip_types:
                 continue
             return fallback
         return None
 
-    def degrade_for_date(self, unit_type: AircraftType, date: datetime.date) -> Loadout:
+    def degrade_for_date(
+        self, unit_type: AircraftType, date: datetime.date, faction: Faction
+    ) -> Loadout:
         if self.date is not None and self.date <= date:
             return Loadout(self.name, self.pylons, self.date, self.is_custom)
 
@@ -69,9 +80,9 @@ class Loadout:
             if weapon is None:
                 del new_pylons[pylon_number]
                 continue
-            if not weapon.available_on(date):
+            if not weapon.available_on(date, faction):
                 pylon = Pylon.for_aircraft(unit_type, pylon_number)
-                fallback = self._fallback_for(weapon, pylon, date)
+                fallback = self._fallback_for(weapon, pylon, date, faction)
                 if fallback is None:
                     del new_pylons[pylon_number]
                 else:
@@ -83,11 +94,11 @@ class Loadout:
         # If the loadout was chosen explicitly by the user, assume they know what
         # they're doing. They may be coordinating buddy-lase.
         if not loadout.is_custom:
-            loadout.replace_lgbs_if_no_tgp(unit_type, date)
+            loadout.replace_lgbs_if_no_tgp(unit_type, date, faction)
         return loadout
 
     def replace_lgbs_if_no_tgp(
-        self, unit_type: AircraftType, date: datetime.date
+        self, unit_type: AircraftType, date: datetime.date, faction: Faction
     ) -> None:
         if self.has_weapon_of_type(WeaponType.TGP):
             return
@@ -100,7 +111,7 @@ class Loadout:
             if weapon is not None and weapon.weapon_group.type is WeaponType.LGB:
                 pylon = Pylon.for_aircraft(unit_type, pylon_number)
                 fallback = self._fallback_for(
-                    weapon, pylon, date, skip_types={WeaponType.LGB}
+                    weapon, pylon, date, faction, skip_types={WeaponType.LGB}
                 )
                 if fallback is None:
                     del new_pylons[pylon_number]
@@ -108,6 +119,24 @@ class Loadout:
                     new_pylons[pylon_number] = fallback
         self.pylons = new_pylons
 
+    @classmethod
+    def convert_dcs_loadout_to_pylon_map(
+        cls, pylons: dict[int, dict[str, Any]]
+    ) -> dict[int, Weapon | None]:
+        return {
+            p["num"]: Weapon.with_clsid(p["CLSID"])
+            for p in pylons.values()
+            # When unloading incompatible pylons (for example, some of the
+            # Mosquito's pylons cannot be loaded when other pylons are carrying
+            # rockets), DCS sometimes equips the empty string rather than
+            # unsetting the pylon. An unset pylon and the empty string appear to
+            # have identical behavior, and it's annoying to deal with weapons
+            # that pydcs doesn't know about, so just clear those pylons rather
+            # than explicitly handling "".
+            # https://github.com/dcs-liberation/dcs_liberation/issues/3171
+            if p["CLSID"] != ""
+        }
+
     @classmethod
     def iter_for(cls, flight: Flight) -> Iterator[Loadout]:
         return cls.iter_for_aircraft(flight.unit_type)
@@ -125,14 +154,15 @@ class Loadout:
         payloads = aircraft.dcs_unit_type.load_payloads()
         for payload in payloads.values():
             name = payload["name"]
-            pylons = payload["pylons"]
             try:
-                pylon_assignments = {
-                    p["num"]: Weapon.with_clsid(p["CLSID"]) for p in pylons.values()
-                }
+                pylon_assignments = cls.convert_dcs_loadout_to_pylon_map(
+                    payload["pylons"]
+                )
             except KeyError:
                 logging.exception(
-                    "Ignoring %s loadout with invalid weapons: %s", aircraft.name, name
+                    "Ignoring %s loadout with invalid weapons: %s",
+                    aircraft.variant_id,
+                    name,
                 )
                 continue
 
@@ -204,7 +234,25 @@ class Loadout:
             payload = dcs_unit_type.loadout_by_name(name)
             if payload is not None:
                 try:
-                    pylons = {i: Weapon.with_clsid(d["clsid"]) for i, d in payload}
+                    # Pydcs returns the data in a different format for loadout_by_name()
+                    # than it does for load_payloads(), for some reason. Convert this
+                    # result to match the other so that we can reuse
+                    # convert_dcs_loadout_to_pylon_map.
+                    #
+                    # loadout_by_name() returns a list of pairs, with the first item
+                    # being the pylon index and the second being a dict with a single
+                    # clsid key.
+                    #
+                    # Each element of load_payloads() pylons is a dict of dicts with
+                    # both the CLSID key (yes, different case from the other API!) and a
+                    # num key for the pylon index. The outer dict is a mapping for a lua
+                    # table, so its keys are just indexes.
+                    pylons = cls.convert_dcs_loadout_to_pylon_map(
+                        {
+                            i: {"num": n, "CLSID": p["clsid"]}
+                            for i, (n, p) in enumerate(payload)
+                        }
+                    )
                 except KeyError:
                     logging.exception(
                         "Ignoring %s loadout with invalid weapons: %s",

game/ato/packagewaypoints.py

@@ -6,8 +6,11 @@ from typing import TYPE_CHECKING
 from dcs import Point
 
 from game.ato.flightplans.waypointbuilder import WaypointBuilder
-from game.flightplan import IpZoneGeometry, JoinZoneGeometry
+from game.flightplan import JoinZoneGeometry
+from game.flightplan.ipsolver import IpSolver
 from game.flightplan.refuelzonegeometry import RefuelZoneGeometry
+from game.persistence.paths import waypoint_debug_directory
+from game.utils import dcs_to_shapely_point
 
 if TYPE_CHECKING:
     from game.ato import Package
@@ -22,15 +25,28 @@ class PackageWaypoints:
     refuel: Point
 
     @staticmethod
-    def create(package: Package, coalition: Coalition) -> PackageWaypoints:
+    def create(
+        package: Package, coalition: Coalition, dump_debug_info: bool
+    ) -> PackageWaypoints:
         origin = package.departure_closest_to_target()
 
         # Start by picking the best IP for the attack.
-        ingress_point = IpZoneGeometry(
-            package.target.position,
-            origin.position,
-            coalition,
-        ).find_best_ip()
+        ip_solver = IpSolver(
+            dcs_to_shapely_point(origin.position),
+            dcs_to_shapely_point(package.target.position),
+            coalition.doctrine,
+            coalition.opponent.threat_zone.all,
+        )
+        ip_solver.set_debug_properties(
+            waypoint_debug_directory() / "IP", coalition.game.theater.terrain
+        )
+        ingress_point_shapely = ip_solver.solve()
+        if dump_debug_info:
+            ip_solver.dump_debug_info()
+
+        ingress_point = origin.position.new_in_same_map(
+            ingress_point_shapely.x, ingress_point_shapely.y
+        )
 
         join_point = JoinZoneGeometry(
             package.target.position,

game/ato/task.py

@@ -1,14 +0,0 @@
-from dataclasses import dataclass
-
-from game.ato import FlightType
-
-
-@dataclass(frozen=True)
-class Task:
-    """The main task of a flight or package."""
-
-    #: The type of task.
-    task_type: FlightType
-
-    #: The location of the objective.
-    location: str

game/ato/traveltime.py

@@ -1,17 +1,9 @@
 from __future__ import annotations
 
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import TYPE_CHECKING
 
-from dcs.mapping import Point
-
-from game.utils import (
-    Distance,
-    SPEED_OF_SOUND_AT_SEA_LEVEL,
-    Speed,
-    mach,
-    meters,
-)
+from game.utils import Distance, SPEED_OF_SOUND_AT_SEA_LEVEL, Speed, mach
 
 if TYPE_CHECKING:
     from .flight import Flight
@@ -26,6 +18,9 @@ class GroundSpeed:
         # on fuel, but mission speed will be fast enough to keep the flight
         # safer.
 
+        if flight.squadron.aircraft.cruise_speed is not None:
+            return mach(flight.squadron.aircraft.cruise_speed.mach(), altitude)
+
         # DCS's max speed is in kph at 0 MSL.
         max_speed = flight.unit_type.max_speed
         if max_speed > SPEED_OF_SOUND_AT_SEA_LEVEL:
@@ -42,14 +37,6 @@ class GroundSpeed:
         return mach(cruise_mach, altitude)
 
 
-class TravelTime:
-    @staticmethod
-    def between_points(a: Point, b: Point, speed: Speed) -> timedelta:
-        error_factor = 1.05
-        distance = meters(a.distance_to_point(b))
-        return timedelta(hours=distance.nautical_miles / speed.knots * error_factor)
-
-
 # TODO: Most if not all of this should move into FlightPlan.
 class TotEstimator:
     def __init__(self, package: Package) -> None:

game/callsigns/callsign.py

@@ -1,4 +1,5 @@
 """Support for working with DCS group callsigns."""
+
 import logging
 import re
 from typing import Any

game/callsigns/callsigngenerator.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+from abc import ABC
+from dataclasses import dataclass
+from enum import StrEnum
+
+from collections import deque
+from typing import Any, List, Optional
+
+from dcs.country import Country
+from dcs.countries import countries_by_name
+
+from game.ato.flight import Flight
+from game.ato.flighttype import FlightType
+
+
+MAX_GROUP_ID = 99
+
+
+class CallsignCategory(StrEnum):
+    AIR = "Air"
+    TANKERS = "Tankers"
+    AWACS = "AWACS"
+    GROUND_UNITS = "GroundUnits"
+    HELIPADS = "Helipad"
+    GRASS_AIRFIELDS = "GrassAirfield"
+
+
+@dataclass(frozen=True)
+class Callsign:
+    name: Optional[
+        str
+    ]  # Callsign name e.g. "Enfield" for western callsigns. None for eastern callsigns.
+    group_id: int  # ID of the group e.g. 2 in Enfield-2-3 for western callsigns. First two digits of eastern callsigns.
+    unit_id: int  # ID of the unit e.g. 3 in Enfield-2-3 for western callsigns. Last digit of eastern callsigns.
+
+    def __post_init__(self) -> None:
+        if self.group_id < 1 or self.group_id > MAX_GROUP_ID:
+            raise ValueError(
+                f"Invalid group ID {self.group_id}. Group IDs have to be between 1 and {MAX_GROUP_ID}."
+            )
+        if self.unit_id < 1 or self.unit_id > 9:
+            raise ValueError(
+                f"Invalid unit ID {self.unit_id}. Unit IDs have to be between 1 and 9."
+            )
+
+    def __str__(self) -> str:
+        if self.name is not None:
+            return f"{self.name}{self.group_id}{self.unit_id}"
+        else:
+            return str(self.group_id * 10 + self.unit_id)
+
+    def lead_callsign(self) -> Callsign:
+        return Callsign(self.name, self.group_id, 1)
+
+    def unit_callsign(self, unit_id: int) -> Callsign:
+        return Callsign(self.name, self.group_id, unit_id)
+
+    def group_name(self) -> str:
+        if self.name is not None:
+            return f"{self.name}-{self.group_id}"
+        else:
+            return str(self.lead_callsign())
+
+    def pydcs_dict(self, country: str) -> dict[Any, Any]:
+        country_obj = countries_by_name[country]()
+        for category in CallsignCategory:
+            if category in country_obj.callsign:
+                for index, name in enumerate(country_obj.callsign[category]):
+                    if name == self.name:
+                        return {
+                            "name": str(self),
+                            1: index + 1,
+                            2: self.group_id,
+                            3: self.unit_id,
+                        }
+        raise ValueError(f"Could not find callsign {name} in {country}.")
+
+
+class WesternGroupIdRegistry:
+
+    def __init__(self, country: Country, max_group_id: int = MAX_GROUP_ID):
+        self._names: dict[str, deque[int]] = {}
+        for category in CallsignCategory:
+            if category in country.callsign:
+                for name in country.callsign[category]:
+                    self._names[name] = deque()
+        self._max_group_id = max_group_id
+        self.reset()
+
+    def reset(self) -> None:
+        for name in self._names:
+            self._names[name] = deque()
+            for i in range(
+                self._max_group_id, 0, -1
+            ):  # Put group IDs on FIFO queue so 1 gets popped first
+                self._names[name].appendleft(i)
+
+    def alloc_group_id(self, name: str) -> int:
+        return self._names[name].popleft()
+
+    def release_group_id(self, callsign: Callsign) -> None:
+        if callsign.name is None:
+            raise ValueError("Releasing eastern callsign")
+        self._names[callsign.name].appendleft(callsign.group_id)
+
+
+class EasternGroupIdRegistry:
+
+    def __init__(self, max_group_id: int = MAX_GROUP_ID):
+        self._max_group_id = max_group_id
+        self._queue: deque[int] = deque()
+        self.reset()
+
+    def reset(self) -> None:
+        self._queue = deque()
+        for i in range(
+            self._max_group_id, 0, -1
+        ):  # Put group IDs on FIFO queue so 1 gets popped first
+            self._queue.appendleft(i)
+
+    def alloc_group_id(self) -> int:
+        return self._queue.popleft()
+
+    def release_group_id(self, callsign: Callsign) -> None:
+        self._queue.appendleft(callsign.group_id)
+
+
+class RoundRobinNameAllocator:
+
+    def __init__(self, names: List[str]):
+        self.names = names
+        self._index = 0
+
+    def allocate(self) -> str:
+        this_index = self._index
+        if this_index == len(self.names) - 1:
+            self._index = 0
+        else:
+            self._index += 1
+        return self.names[this_index]
+
+
+class FlightTypeNameAllocator:
+    def __init__(self, names: List[str]):
+        self.names = names
+
+    def allocate(self, flight: Flight) -> str:
+        index = self.FLIGHT_TYPE_LOOKUP.get(flight.flight_type, 0)
+        return self.names[index]
+
+    FLIGHT_TYPE_LOOKUP: dict[FlightType, int] = {
+        FlightType.TARCAP: 1,
+        FlightType.BARCAP: 1,
+        FlightType.INTERCEPTION: 1,
+        FlightType.SWEEP: 1,
+        FlightType.CAS: 2,
+        FlightType.ANTISHIP: 2,
+        FlightType.BAI: 2,
+        FlightType.STRIKE: 3,
+        FlightType.OCA_RUNWAY: 3,
+        FlightType.OCA_AIRCRAFT: 3,
+        FlightType.SEAD: 4,
+        FlightType.DEAD: 4,
+        FlightType.ESCORT: 5,
+        FlightType.AIR_ASSAULT: 6,
+        FlightType.TRANSPORT: 7,
+        FlightType.FERRY: 7,
+    }
+
+
+class WesternFlightCallsignGenerator:
+    """Generate western callsign for lead unit in a group"""
+
+    def __init__(self, country: str) -> None:
+        self._country = countries_by_name[country]()
+        self._group_id_registry = WesternGroupIdRegistry(self._country)
+        self._awacs_name_allocator = None
+        self._tankers_name_allocator = None
+
+        if CallsignCategory.AWACS in self._country.callsign:
+            self._awacs_name_allocator = RoundRobinNameAllocator(
+                self._country.callsign[CallsignCategory.AWACS]
+            )
+        if CallsignCategory.TANKERS in self._country.callsign:
+            self._tankers_name_allocator = RoundRobinNameAllocator(
+                self._country.callsign[CallsignCategory.TANKERS]
+            )
+        self._air_name_allocator = FlightTypeNameAllocator(
+            self._country.callsign[CallsignCategory.AIR]
+        )
+
+    def reset(self) -> None:
+        self._group_id_registry.reset()
+
+    def alloc_callsign(self, flight: Flight) -> Callsign:
+        if flight.flight_type == FlightType.AEWC:
+            if self._awacs_name_allocator is None:
+                raise ValueError(f"{self._country.name} does not have AWACs callsigns")
+            name = self._awacs_name_allocator.allocate()
+        elif flight.flight_type == FlightType.REFUELING:
+            if self._tankers_name_allocator is None:
+                raise ValueError(f"{self._country.name} does not have tanker callsigns")
+            name = self._tankers_name_allocator.allocate()
+        else:
+            name = self._air_name_allocator.allocate(flight)
+        group_id = self._group_id_registry.alloc_group_id(name)
+        return Callsign(name, group_id, 1)
+
+    def release_callsign(self, callsign: Callsign) -> None:
+        self._group_id_registry.release_group_id(callsign)
+
+
+class EasternFlightCallsignGenerator:
+    """Generate eastern callsign for lead unit in a group"""
+
+    def __init__(self) -> None:
+        self._group_id_registry = EasternGroupIdRegistry()
+
+    def reset(self) -> None:
+        self._group_id_registry.reset()
+
+    def alloc_callsign(self, flight: Flight) -> Callsign:
+        group_id = self._group_id_registry.alloc_group_id()
+        return Callsign(None, group_id, 1)
+
+    def release_callsign(self, callsign: Callsign) -> None:
+        self._group_id_registry.release_group_id(callsign)
+
+
+class FlightCallsignGenerator:
+
+    def __init__(self, country: str):
+        self._use_western_callsigns = countries_by_name[country]().use_western_callsigns
+        self._generators: dict[
+            bool, WesternFlightCallsignGenerator | EasternFlightCallsignGenerator
+        ] = {}
+        if self._use_western_callsigns:
+            self._generators[self._use_western_callsigns] = (
+                WesternFlightCallsignGenerator(country)
+            )
+        else:
+            self._generators[self._use_western_callsigns] = (
+                EasternFlightCallsignGenerator()
+            )
+
+    def reset(self) -> None:
+        self._generators[self._use_western_callsigns].reset()
+
+    def alloc_callsign(self, flight: Flight) -> Callsign:
+        return self._generators[self._use_western_callsigns].alloc_callsign(flight)
+
+    def release_callsign(self, callsign: Callsign) -> None:
+        self._generators[self._use_western_callsigns].release_callsign(callsign)