Fine-tuning some typing issues

Co-Authored-By: M Chimiste <37678080+M-Chimiste@users.noreply.github.com>

.coveragerc

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

.github/ISSUE_TEMPLATE/bug-report.yml

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

.github/ISSUE_TEMPLATE/campaign_update.md

@@ -2,7 +2,7 @@
 name: Campaign update submission
 about: Submit an update to a campaign you maintain.
 title: 'Update for <campaign name>'
-labels: campaign-update-submission
+labels: Campaign Update Submission
 assignees: ''
 
 ---

.github/ISSUE_TEMPLATE/code_architecture.yml

@@ -2,7 +2,7 @@
 name: Code Architecture
 description: >
   Suggest a refactor, or other issues related to the codebase.
-labels:  ["refactor", "python"]
+labels:  ["Refactor", "Python", "Priority Low"]
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -2,7 +2,7 @@
 name: Feature Request
 description: >
   Suggest an idea for this project.
-labels: enhancement
+labels: ["Enhancement", "Priority Medium"]
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/mod_support.md

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

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

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

.github/workflows/build.yml

@@ -49,4 +49,15 @@ jobs:
           include_image: true
           avatar_url: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
           username: GitHub Build Notifier
-        if: startsWith(github.ref_name, 'test')
+        if: startsWith(github.ref_name, 'test')
+
+      - name: Send status to Discord
+        uses: stegzilla/discord-notify@v2
+        with:
+          webhook_url: ${{ secrets.discord_webhook_alphas }}
+          title: "Build #${{ github.run_number }} available!"
+          message: "**Branch:** ${{ github.ref_name }}\n**Download link:\n** https://github.com/dcs-retribution/dcs-retribution/actions/runs/${{ github.run_id }}"
+          include_image: true
+          avatar_url: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
+          username: GitHub Build Notifier
+        if: github.ref_name == 'dev'

.github/workflows/test.yml

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

.gitignore

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

.readthedocs.yaml

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

CONTRIBUTING.md

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

README.md

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

changelog.md

@@ -1,4 +1,132 @@
-# Retribution 1.0.0
+# Retribution v1.2.0
+
+## Features/Improvements
+* **[Preset Groups]** Add SA-2 with ZSU-23/57
+* **[Campaign Design]** Ability to define almost all possible settings in the campaign's yaml file.
+* **[Campaign Design]** Ability to add roadbases and/or ground spawns to campaigns.
+* **[Campaign Design]** Ability to define SCENERY REMOVE OBJECTS ZONE triggers with the roadbase objects in campaign miz. This might not work reliably in multiplayer due to DCS issues. FARPs can be used to remove scenery objects in multiplayer.
+* **[Options]** Implemented an option in settings to disable the above SCENERY REMOVE OBJECTS ZONE triggers.
+* **[Campaign Management]** Improved squadron retreat logic at longer ranges.
+* **[Options]** Ability to load & save your settings.
+* **[Options]** Added a separate Doctrine page in settings with the following new options:
+  * Minimum number of aircraft for autoplanner to plan OCA packages against 
+  * Airbase threat range (nmi)
+  * SEAD Sweep threat buffer distance (nmi)
+  * SEAD Escort/Sweep threat buffer distance (nmi)
+  * TARCAP threat buffer distance (nmi)
+  * AEW&C threat buffer distance (nmi)
+  * Theater tanker threat buffer distance (nmi)
+* **[Options]** Improved the option to configure OPFOR autoplanner aggressiveness. The AI might now take even more risks and plan missions against defended targets.
+* Added three new options in Settings:
+  * Autoplanner plans refueling flights for Strike packages
+  * Autoplanner plans refueling flights for OCA packages
+  * Autoplanner plans refueling flights for DEAD packages
+* **[UI]** Added fuel selector in flight's edit window.
+* **[Plugins]** Expose Splash Damage's "game_messages" option and set its default to false.
+* **[Mission Generation]** Improved AI SEAD capabilities, allowing for mixed loadouts using Decoys, ARMs & ASMs.
+* **[Modding]** Support for A-7E Corsair II (presumed latest available version)
+* **[Squadrons]** Added many new squadron's by Adecarcer
+* **[Plugins]** Updated 'expl_table' in Splash Damage script.
+* **[Mission Generation]** Also save kneeboards in txt-format, found under "kneeboards" within Retribution's installation folder after pressing take-off.
+* **[Modding]** Support for SW mod v2.55
+* **[Modding]** Support for Spanish & Australian Naval Assets v3.2.0 by desdemicabina
+* **[Modding]** Support for Iron Dome v1.2 by IDF Mods Project
+* **[New Game Wizard]** Re-organized generator options & show the regular settings menu instead of the limited "Difficulty & Automation" page.
+* **[Campaign Management]** Ability to operate harriers from FOBs/FARPs for <ins>__human pilots only__</ins>. Please note that the autoplanner won't generate flights for harriers at FOBs/FARPs, which means you need to plan your missions manually.
+* **[Mission Planning]** Allow NAV/REFUEL/DIVERT waypoints to be deleted without degrading to a custom flight-plan, also warning the user before actually degrading the flight-plan.
+* **[Campaign Generation]** Split "full-strength start" from "squadron aircraft limits" option.
+* **[Mission Generation]** General improvement w.r.t. DCS tasking, including a check for incompatible tasking.
+* **[Mission Generation]** OCA-Runway flights will remain at altitude when using guided bombs.
+* **[UX]** Added error message to indicate save-compatibility issues + fix to avoid total crash upon loading of last save.
+* **[UI]** Improved parking space information in air wing configuration dialog.
+* **[Squadrons]** Warning messages when opening up a squadron through the air wing dialog, indicating squadrons that potentially won't fit w.r.t. parking space.
+* **[Squadrons Transfers]** Determine number of available parking slots more accurately w.r.t. squadron transfers, taking aircraft dimensions into account which should prevent forced air-starts.
+* **[UX]** Allow usage of CTRL/SHIFT modifiers in ground unit transfer window.
+* **[Campaign Design]** Ability to define "spawn-routes" for convoys, allowing them to start from the road without having to edit the mission
+* **[Plugins]** Added "DCS Dismount" plugin.
+* **[Plugins]** Added "EWR Jammer" plugin (only for humans, may change in the future).
+* **[Campaign]** New campaign (Operation Desert Sabre) by Chimiste
+* **[Plugins]** Updated CTLD to latest released version
+* **[Options]** Renamed Maximum frontline length -> Maximum frontline width.
+* **[Squadrons]** Add livery selector in Squadron Dialog, allowing you to change the livery during the campaign.
+* **[New Game Wizard]** Automatically invert factions when 'Invert Map' is selected.
+* **[Flight Plans]** Added "SEAD Sweep" flight plan, which basically reintroduces the legacy "SEAD Escort" flight plan where the flight will engage whatever it can find without actually escorting the primary flight.
+* **[Flight Plans]** Added SEAD capability to F-16A MLU and SEAD Escort & SEAD to F-16A. 
+* **[Mission Generation]** Spawn unused helicopters or LHA-capable aircraft at helipads at FOBs
+* **[Modding]** Support for F-15I Ra'am v1.0 by IDF Mods Project
+
+## Fixes
+* **[New Game Wizard]** Settings would not persist when going back to a previous page (obsolete due to overhaul).
+* **[Mission Generation]** Unused aircraft are no longer claimed, fixing a bug where these aircraft would no longer be available after aborting the mission.
+* **[Mission Generation]** Fixed (potential) bug in helipad assignments at FOBs/FARPs.
+* **[Mission Generation]** Fix AI immediately returning to base when forced to air-start due to insufficient parking space.
+* **[Modding]** Fixed a bug where F-16Ds were not correctly removed from the faction when the F-16I/F-16D mod was not selected
+* **[UI]** Fixed F-16A MLU icon and banner.
+
+# Retribution v1.1.1  (hotfix)
+
+## Features/Improvements
+* **[Modding]** Support for IDF Mod Project F-16I Sufa & F-16D v3.6 mod
+* **[Modding]** Support for JAS-39 Gripen v1.8.5-beta mod
+
+## Fixes
+* **[Plugins]** Fix bug where changes to plugin options doesn't do anything.
+* **[Campaign Management]** Fix bug in procurement when no squadrons are present.
+* **[Layouts]** Fix edge-case bug layout's group size.
+* **[Campaign Design]** Preset groups assigned to specific TGOs not working as intended.
+
+# Retribution v1.1.0
+
+## Features/Improvements
+* **[Mission Generation]** Given a CAS flight was planned, delay ground force attack until first CAS flight is on station
+* **[Mission Generation]** Add option to switch ATFLIR to LITENING automatically for ground based F/A-18C flights
+* **[Mission Generation]** Add option to configure OPFOR autoplanner aggressiveness and have the AI take risks and plan missions against defended targets
+* **[Mission Generation]** Add option to configure the desired tanker on-station time in settings
+* **[Mission Generation]** Reserve GUARD frequency on VHF/UHF
+* **[Mission Generation]** Randomization in radio frequency allocation
+* **[Mission Generation]** Configurable number of Combined Arms slots
+* **[Mission Generation]** Enable spectating & F11 free camera when the "Allow external views" option is selected
+* **[Cheat Menu]** Option to instantly transfer squadrons across bases.
+* **[Modding]** Support for IDF Mod Project F-16I Sufa & F-16D v3.2 mod
+* **[Modding]** Support for F/A-18E/F/G mod version 2.1
+* **[Modding]** Support for Swedish Military Assets for DCS by Currenthill Version 1.10
+* **[UI]** Add selectable units in faction overview during campaign generation.
+* **[UI]** Add button to rename pilots in Air Wing's Squadron dialog.
+* **[UI]** Add clone buttons for flights & packages.
+* **[UI]** Editing of flight's custom name.
+* **[UI]** Introduce custom names for packages (purely for organizational purposes).
+* **[UI]** Configurable UHF frequency (225-400MHz) for Packages, Carriers, LHAs, FOBs & FARPs.
+* **[UI]** Configurable Intra-Flight frequency for Flights.
+* **[UI]** Configurable TACAN for Carriers, LHAs & Tankers.
+* **[UI]** Configurable ICLS for capable Carriers & LHAs.
+* **[UI]** Configurable LINK4 for Carriers.
+* **[Kneeboard]** Show package information in Support page
+* **[Kneeboard]** Show extra weather information on 'Mission info' page
+* **[Kneeboard]** Show BRC in 'RWY' column for aircraft carriers on 'Mission info' page
+* **[Campaign Design]** Ability to define designated CTLD zones for Control Points (Airbases & FOBs/FARPs)
+* **[Campaign Design]** Ability to define preset groups for specific TGOs, given the preset group is accessible for the faction and the task matches.
+* **[Campaign Management]** Additional options for automated budget management.
+* **[Campaign Management]** New options to allow more control of randomized flight sizes (applicable for BARCAP/CAS/OCA/ANTI-SHIP).
+* **[Plugins]** Updated Splash Damage script to v2.0 by RotorOps.
+* **[Mission Generation]** Improvements to DEAD & STRIKE flights, allowing AI to handle a larger variety of weapons.
+* **[Campaign]** New campaign (1968 Yankee Station) by Adecarcer
+
+## Fixes
+* **[UI]** Removed deprecated options
+* **[UI]** Add missing icon & banner for C130 Hercules mod
+* **[Mission Generation]** Avoid aircraft from being assigned to helicopter parking spots, resulting into air starts that usually crash.
+* **[Mission Generation]** Use stacking algorithm to create vertical separation between flights spawning mid-mission over their departure, usually resulting into mid-air collisions.
+* **[Mission Generation]** Fixed all callsigns being "Enfield 1-1" on dedicated servers.
+* **[Mission Generation]** Fixed AI ferry flights for helicopters when transferring to a FOB/FARP.
+* **[Mission Generation]** Fixed 'Uninitialized flight' exception when adding flights after aborted take-off.
+* **[Modding]** Fixed conflicts caused by HDS units
+* **[UX]** Gracefully handle corrupted preferences file.
+* **[Mission Generation]** Aircraft not using decoys during SEAD.
+
+# Retribution v1.0.1 (hotfix)
+* **[Mission Generation]** Fix serialization issue when STRIKE flight has no escorts
+
+# Retribution v1.0.0
 
 ## Features/Improvements
 * **[Engine]** Support for DCS v2.8.1.34437.
@@ -37,15 +165,106 @@ BAI/ANTISHIP/DEAD/STRIKE/BARCAP/CAS/OCA/AIR-ASSAULT (main) missions
 * **[Mission Generation]** Kneeboard STRIKE coordinates would sometimes get clipped when not fitting.
 * **[UI]** Fix exception when trying to add a waypoints to a flightplan.
 
+
 # Liberation:
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41363, including F-15E support.
+
+## Fixes
+
+# 8.0.0
+
+Saves from 7.x are not compatible with 8.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.8.6.41066, including the new Sinai map.
+* **[UI]** Limited size of overfull airbase display and added scrollbar.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Moved air wing and transfer menus to the toolbar to improve UI fit on low resolution displays.
+* **[UI]** Added basic game over dialog.
+
+## Fixes
+
+* **[Campaign]** Fix bug introduced in 7.0 where map strike target deaths are no longer tracked.
+* **[Mission Generation]** Fix crash during mission generation caused by out of date DCS data for the Gazelle.
+* **[Mission Generation]** Fix crash during mission generation when DCS beacon data is inconsistent.
+
+# 7.1.0
+
+Saves from 7.0.0 are compatible with 7.1.0
+
+## Features/Improvements
+
+* **[Factions]** Replaced Patriot STRs "EWRs" with AN/FPS-117 for blue factions 1980 or newer.
+* **[Mission Generation]** Added option to prevent scud and V2 sites from firing at the start of the mission.
+* **[Mission Planning]** Per-flight TOT offsets can now be set in the flight details UI. This allows individual flights to be scheduled ahead of or behind the rest of the package.
+* **[UI]** Waypoint altitudes can be edited in Waypoints tab of Edit Flight window.
+* **[UI]** Parking capacity of each squadron's base is now shown during air wing configuration to avoid overcrowding bases when beginning the game with full squadrons.
+
+## Fixes
+
+* **[Mission Planning]** BAI is once again plannable against missile sites and coastal defense batteries.
+* **[UI]** Fixed formatting of departure time in flight details dialog.
+
 # 7.0.0
 
 Saves from 6.x are not compatible with 7.0.
 
 ## Features/Improvements
 
+* **[Engine]** Support for DCS 2.8.3.37556.
+* **[Engine]** Saved games are now a zip file of save assets for easier bug reporting. The new extension is .liberation.zip. Drag and drop that file into bug reports.
+* **[Campaign]** Added options to limit squadron sizes and to begin all squadrons at maximum strength. Maximum squadron size is defined during air wing configuration with default values provided by the campaign.
+* **[Campaign]** Added handling for more DCS death events. This probably does not catch any deaths that weren't previously tracked, but it should record them sooner, which will improve results for game crashes or other early exits.
+* **[Campaign AI]** The campaign AI now prefers fulfilling missions with squadrons which have a matching primary task. Previously distance from target held a stronger influence than task preference. Primary tasks for squadrons are set by campaign designers but are user-configurable.
+* **[Flight Planning]** Package TOT and composition can be modified after advancing time in Liberation.
+* **[Mission Generation]** Units on the front line are now hidden on MFDs.
+* **[Mission Generation]** Preset radio channels will now be configured for both A-10C modules.
+* **[Mission Generation]** The A-10C II now uses separate radios for inter- and intra-flight comms (similar to other modern aircraft).
+* **[Mission Generation]** Wind speeds no longer follow a uniform distribution. Median wind speeds are now much lower and the standard deviation has been reduced considerably at altitude but increased somewhat at MSL.
+* **[Mission Generation]** Improved task generation for SEAD flights carrying TALDs.
+* **[Mission Generation]** Added task timeout for SEAD flights with TALDs to prevent AI from overflying the target.
+* **[Modding]** Updated Community A-4E-C mod version support to 2.1.0 release.
+* **[Modding]** Add support for VSN F-4B and F-4C mod.
+* **[Modding]** Aircraft task capabilities and preferred aircraft for each task are now moddable in the aircraft unit yaml files. Each aircraft has a weight per task. Higher weights are given higher preference.
+* **[Modding]** The `mission_types` field in squadron files has been removed. Squadron task capability is now determined by airframe, and the auto-assignable list has always been overridden by the campaign settings.
+* **[Modding]** Wind speed generation inputs are now moddable. See https://dcs-liberation.rtfd.io/en/latest/modding/weather.html.
+* **[New Game Wizard]** Choices for some options will be remembered for the next new game. Not all settings will be preserved, as many are campaign dependent.
+* **[New Game Wizard]** Lua plugins can now be set while creating a new game.
+* **[New Game Wizard]** Squadrons can be directly replaced with a preset during air wing configuration rather than needing to remove and create a new squadron.
+* **[New Game Wizard]** Squadron liveries can now be selected during air wing configuration.
+* **[Squadrons]** Squadron-specific mission capability lists no longer restrict players from assigning missions outside the squadron's preferences.
+* **[New Game Wizard]** Squadrons can be directly replaced with a preset during air wing configuration rather than needing to remove and create a new squadron.
+* **[UI]** The orientation of objects like SAMs, EWRs, garrisons, and ships can now be manually adjusted.
+
 ## Fixes
 
+* **[Campaign]** Fixed a longstanding bug where oversized airlifts could corrupt a save with empty convoys.
+* **[Campaign]** Aircraft with built-in TGPs but without an external pod will no longer degrade automatic loadouts to iron bombs.
+* **[Engine]** Fixed crash in startup caused by a corrupted Liberation preferences file.
+* **[Flight Planning]** AEW&C missions are now plannable over FOBs and LHAs.
+* **[Flight Planning]** BAI is no longer plannable against buildings.
+* **[Modding]** Fixed an issue where Falklands campaigns created or edited with new versions of DCS could not be loaded.
+* **[Modding]** Fixed decoding of campaign yaml files to use UTF-8 rather than the system locale's default. It's now possible to use "Bf 109 K-4 Kurfürst" as a preferred aircraft type.
+* **[Mission Generation]** Planes will no longer spawn in helipads that are not also designated for fixed wing parking.
+* **[Mission Generation]** Potentially an issue where ground war planning game state could become corrupted, preventing mission generation.
+* **[Mission Generation]** Refueling tasks will now only be created for flights that have a tanker in their package.
+* **[Mission Generation]** Fixed missing Tanker task on recovery tanker missions.
+* **[UI]** Fixed error when resetting air wing configuration during game setup.
+* **[UI]** Fixed flight plan recreation when changing mission type with "Recreate as" flight options.
+* **[UI]** Fixed failure to launch UI when Liberation persistent preferences file was corrupt.
+
+
+# 6.1.1
+
+## Fixes
+
+* **[Data]** Fixed unit ID for the KS-19 AAA. KS-19 would not previously generate correctly in missions. A new game is required for this fix to take effect.
+* **[Flight Planning]** Automatic flight planning will no longer accidentally plan a recovery tanker instead of a theater refueling package. This fixes a potential crash during mission generation when opfor plans a refueling task at a sunk carrier. You'll need to skip the current turn to force opfor to replan their flights to get the fix.
+* **[Mission Generation]** Using heliports (airports without any runways) will no longer cause mission generation to fail.
+
 # 6.1.0
 
 Saves from 6.0.0 are compatible with 6.1.0

client/README.md

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

client/package.json

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

client/src/App.test.tsx

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

client/src/app/store.ts

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

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

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

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

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

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

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

client/src/components/airdefenserangelayer/AirDefenseRangeLayer.tsx

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

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

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

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

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

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

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

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

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

client/src/components/cullingexclusionzones/CullingExclusionZones.tsx

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

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

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

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

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

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

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

client/src/components/frontlineslayer/FrontLinesLayer.tsx

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

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

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

client/src/index.tsx

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

client/src/testutils/index.tsx

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

codecov.yaml

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

docs/Makefile

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

docs/conf.py

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

docs/dev/design/index.rst

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

docs/dev/index.rst

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

docs/game/index.rst

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

docs/index.rst

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

docs/make.bat

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

docs/modding/index.rst

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

docs/modding/layouts.rst

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

docs/modding/weather.rst

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

docs/requirements.txt

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

game/ato/ai_flight_planner_db.py

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

game/ato/flight.py

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

game/ato/flightplans/_common_ctld.py

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

game/ato/flightplans/aewc.py

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

game/ato/flightplans/airassault.py

@@ -8,24 +8,27 @@ from game.ato.flightplans.standard import StandardFlightPlan, StandardLayout
 from game.theater.controlpoint import ControlPointType
 from game.theater.missiontarget import MissionTarget
 from game.utils import Distance, feet, meters
+from ._common_ctld import generate_random_ctld_point
 from .ibuilder import IBuilder
 from .planningerror import PlanningError
 from .uizonedisplay import UiZone, UiZoneDisplay
 from .waypointbuilder import WaypointBuilder
 from ..flightwaypoint import FlightWaypointType
+from ...theater.interfaces.CTLD import CTLD
 
 if TYPE_CHECKING:
+    from dcs import Point
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class AirAssaultLayout(StandardLayout):
     # The pickup point is optional because we don't always need to load the cargo. When
     # departing from a carrier, LHA, or off-map spawn, the cargo is pre-loaded.
     pickup: FlightWaypoint | None
     nav_to_ingress: list[FlightWaypoint]
     ingress: FlightWaypoint
-    drop_off: FlightWaypoint
+    drop_off: FlightWaypoint | None
     # This is an implementation detail used by CTLD. The aircraft will not go to this
     # waypoint. It is used by CTLD as the destination for unloaded troops.
     target: FlightWaypoint
@@ -37,7 +40,8 @@ class AirAssaultLayout(StandardLayout):
             yield self.pickup
         yield from self.nav_to_ingress
         yield self.ingress
-        yield self.drop_off
+        if self.drop_off is not None:
+            yield self.drop_off
         yield self.target
         yield from self.nav_to_home
         yield self.arrival
@@ -53,7 +57,9 @@ class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout], UiZoneDisplay):
 
     @property
     def tot_waypoint(self) -> FlightWaypoint:
-        return self.layout.drop_off
+        if self.flight.is_helo and self.layout.drop_off is not None:
+            return self.layout.drop_off
+        return self.layout.target
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.tot_waypoint:
@@ -80,8 +86,10 @@ class AirAssaultFlightPlan(StandardFlightPlan[AirAssaultLayout], UiZoneDisplay):
 
 class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
     def layout(self) -> AirAssaultLayout:
-        if not self.flight.is_helo:
-            raise PlanningError("Air assault is only usable by helicopters")
+        if not self.flight.is_helo and not self.flight.is_hercules:
+            raise PlanningError(
+                "Air assault is only usable by helicopters and Anubis' C-130 mod"
+            )
         assert self.package.waypoints is not None
 
         altitude = feet(1500) if self.flight.is_helo else self.doctrine.ingress_altitude
@@ -89,7 +97,7 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
 
         builder = WaypointBuilder(self.flight, self.coalition)
 
-        if self.flight.departure.cptype in [
+        if self.flight.is_hercules or self.flight.departure.cptype in [
             ControlPointType.AIRCRAFT_CARRIER_GROUP,
             ControlPointType.LHA_GROUP,
             ControlPointType.OFF_MAP,
@@ -99,27 +107,25 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
             pickup = None
             pickup_position = self.flight.departure.position
         else:
-            # TODO The calculation of the Pickup LZ is currently randomized. This
-            # leads to the problem that we can not gurantee that the LZ is clear of
-            # obstacles. This has to be improved in the future so that the Mission can
-            # be autoplanned. In the current state the User has to check the created
-            # Waypoints for the Pickup and Dropoff LZs are free of obstacles.
-            # Create a special pickup zone for Helos from Airbase / FOB
             pickup = builder.pickup_zone(
                 MissionTarget(
                     "Pickup Zone",
-                    self.flight.departure.position.random_point_within(1200, 600),
+                    self._generate_ctld_pickup(),
                 )
             )
             pickup_position = pickup.position
         assault_area = builder.assault_area(self.package.target)
         heading = self.package.target.position.heading_between_point(pickup_position)
+        if self.flight.is_hercules:
+            assault_area.only_for_player = False
+            assault_area.alt = feet(1000)
 
-        # TODO we can not gurantee a safe LZ for DropOff. See comment above.
+        # TODO: define CTLD dropoff zones in campaign miz?
         drop_off_zone = MissionTarget(
             "Dropoff zone",
             self.package.target.position.point_from_heading(heading, 1200),
         )
+        dz = builder.dropoff_zone(drop_off_zone) if self.flight.is_helo else None
 
         return AirAssaultLayout(
             departure=builder.takeoff(self.flight.departure),
@@ -135,7 +141,7 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
                 self.package.waypoints.ingress,
                 self.package.target,
             ),
-            drop_off=builder.dropoff_zone(drop_off_zone),
+            drop_off=dz,
             target=assault_area,
             nav_to_home=builder.nav_path(
                 drop_off_zone.position,
@@ -150,3 +156,7 @@ class Builder(IBuilder[AirAssaultFlightPlan, AirAssaultLayout]):
 
     def build(self) -> AirAssaultFlightPlan:
         return AirAssaultFlightPlan(self.flight, self.layout())
+
+    def _generate_ctld_pickup(self) -> Point:
+        assert isinstance(self.flight.departure, CTLD)
+        return generate_random_ctld_point(self.flight.departure)

game/ato/flightplans/airlift.py

@@ -7,16 +7,19 @@ from typing import TYPE_CHECKING, Type
 
 from game.theater.missiontarget import MissionTarget
 from game.utils import feet
+from ._common_ctld import generate_random_ctld_point
 from .ibuilder import IBuilder
 from .planningerror import PlanningError
 from .standard import StandardFlightPlan, StandardLayout
 from .waypointbuilder import WaypointBuilder
+from ...theater.interfaces.CTLD import CTLD
 
 if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
+    from dcs import Point
 
 
-@dataclass(frozen=True)
+@dataclass
 class AirliftLayout(StandardLayout):
     nav_to_pickup: list[FlightWaypoint]
     # There will not be a pickup waypoint when the pickup airfield is the departure
@@ -35,6 +38,20 @@ class AirliftLayout(StandardLayout):
     ctld_drop_off_zone: FlightWaypoint | None
     nav_to_home: list[FlightWaypoint]
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if super().delete_waypoint(waypoint):
+            return True
+        if waypoint in self.nav_to_pickup:
+            self.nav_to_pickup.remove(waypoint)
+            return True
+        elif waypoint in self.nav_to_drop_off:
+            self.nav_to_drop_off.remove(waypoint)
+            return True
+        elif waypoint in self.nav_to_home:
+            self.nav_to_home.remove(waypoint)
+            return True
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to_pickup
@@ -106,15 +123,10 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
         if self.flight.is_helo:
             # Create CTLD Zones for Helo flights
             pickup_zone = builder.pickup_zone(
-                MissionTarget(
-                    "Pickup Zone", cargo.origin.position.random_point_within(1000, 200)
-                )
+                MissionTarget("Pickup Zone", self._generate_ctld_pickup())
             )
             drop_off_zone = builder.dropoff_zone(
-                MissionTarget(
-                    "Dropoff zone",
-                    cargo.next_stop.position.random_point_within(1000, 200),
-                )
+                MissionTarget("Dropoff zone", self._generate_ctld_dropoff())
             )
             # Show the zone waypoints only to the player
             pickup_zone.only_for_player = True
@@ -153,3 +165,15 @@ class Builder(IBuilder[AirliftFlightPlan, AirliftLayout]):
 
     def build(self) -> AirliftFlightPlan:
         return AirliftFlightPlan(self.flight, self.layout())
+
+    def _generate_ctld_pickup(self) -> Point:
+        cargo = self.flight.cargo
+        if cargo and cargo.origin and isinstance(cargo.origin, CTLD):
+            return generate_random_ctld_point(cargo.origin)
+        raise RuntimeError("Could not generate CTLD pickup")
+
+    def _generate_ctld_dropoff(self) -> Point:
+        cargo = self.flight.cargo
+        if cargo and cargo.transport and isinstance(cargo.transport.destination, CTLD):
+            return generate_random_ctld_point(cargo.transport.destination)
+        raise RuntimeError("Could not generate CTLD dropoff")

game/ato/flightplans/antiship.py

@@ -35,7 +35,7 @@ class Builder(FormationAttackBuilder[AntiShipFlightPlan, FormationAttackLayout])
         else:
             raise InvalidObjectiveLocation(self.flight.flight_type, location)
 
-        return self._build(FlightWaypointType.INGRESS_BAI, targets)
+        return self._build(FlightWaypointType.INGRESS_ANTI_SHIP, targets)
 
     @staticmethod
     def anti_ship_targets_for_tgo(tgo: NavalGroundObject) -> list[StrikeTarget]:

game/ato/flightplans/capbuilder.py

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

game/ato/flightplans/cas.py

@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class CasLayout(PatrollingLayout):
     target: FlightWaypoint
 
@@ -53,7 +53,7 @@ class CasFlightPlan(PatrollingFlightPlan[CasLayout], UiZoneDisplay):
 
     @property
     def engagement_distance(self) -> Distance:
-        max_length = self.flight.coalition.game.settings.max_frontline_length * 1000
+        max_length = self.flight.coalition.game.settings.max_frontline_width * 1000
         return meters(max_length) / 2
 
     @property

game/ato/flightplans/custom.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class CustomLayout(Layout):
     custom_waypoints: list[FlightWaypoint]
 
@@ -44,7 +44,7 @@ class CustomFlightPlan(FlightPlan[CustomLayout]):
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.tot_waypoint:
-            return self.package.time_over_target
+            return self.package.time_over_target + self.tot_offset
         return None
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:

game/ato/flightplans/escort.py

@@ -8,8 +8,6 @@ from .formationattack import (
     FormationAttackLayout,
 )
 from .waypointbuilder import WaypointBuilder
-from .. import FlightType
-from ...utils import Distance
 
 
 class EscortFlightPlan(FormationAttackFlightPlan):
@@ -32,11 +30,9 @@ class Builder(FormationAttackBuilder[EscortFlightPlan, FormationAttackLayout]):
         join = builder.join(self.package.waypoints.join)
         split = builder.split(self.package.waypoints.split)
         refuel = builder.refuel(self.package.waypoints.refuel)
-        initial = None
-        if self.package.primary_task == FlightType.STRIKE:
-            initial = builder.escort_hold(
-                self.package.waypoints.initial, Distance.from_feet(20000)
-            )
+        initial = builder.escort_hold(
+            self.package.waypoints.initial, self.doctrine.ingress_altitude
+        )
 
         return FormationAttackLayout(
             departure=builder.takeoff(self.flight.departure),

game/ato/flightplans/ferry.py

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

game/ato/flightplans/flightplan.py

@@ -41,7 +41,7 @@ INGRESS_TYPES = {
 }
 
 
-@dataclass(frozen=True)
+@dataclass
 class Layout(ABC):
     departure: FlightWaypoint
 
@@ -50,6 +50,9 @@ class Layout(ABC):
         """A list of all waypoints in the flight plan, in order."""
         return list(self.iter_waypoints())
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         """Iterates over all waypoints in the flight plan, in order."""
         raise NotImplementedError
@@ -62,6 +65,12 @@ class FlightPlan(ABC, Generic[LayoutT]):
     def __init__(self, flight: Flight, layout: LayoutT) -> None:
         self.flight = flight
         self.layout = layout
+        self.tot_offset = self.default_tot_offset()
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        if "tot_offset" not in state:
+            state["tot_offset"] = self.default_tot_offset()
+        self.__dict__.update(state)
 
     @property
     def package(self) -> Package:
@@ -72,6 +81,15 @@ class FlightPlan(ABC, Generic[LayoutT]):
         """A list of all waypoints in the flight plan, in order."""
         return list(self.iter_waypoints())
 
+    def get_index_of_wpt_by_type(self, wpt_type: FlightWaypointType) -> int:
+        index = 0
+        for wpt in self.waypoints:
+            if wpt and not wpt.only_for_player:
+                index += 1
+                if wpt.waypoint_type == wpt_type:
+                    return index
+        return -1
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         """Iterates over all waypoints in the flight plan, in order."""
         yield from self.layout.iter_waypoints()
@@ -195,8 +213,7 @@ class FlightPlan(ABC, Generic[LayoutT]):
             [meters(cp.position.distance_to_point(w.position)) for w in self.waypoints]
         )
 
-    @property
-    def tot_offset(self) -> timedelta:
+    def default_tot_offset(self) -> timedelta:
         """This flight's offset from the package's TOT.
 
         Positive values represent later TOTs. An offset of -2 minutes is used

game/ato/flightplans/flightplanbuildertypes.py

@@ -19,6 +19,7 @@ from .ocarunway import OcaRunwayFlightPlan
 from .packagerefueling import PackageRefuelingFlightPlan
 from .planningerror import PlanningError
 from .sead import SeadFlightPlan
+from .seadsweep import SeadSweepFlightPlan
 from .strike import StrikeFlightPlan
 from .sweep import SweepFlightPlan
 from .tarcap import TarCapFlightPlan
@@ -26,12 +27,13 @@ from .theaterrefueling import TheaterRefuelingFlightPlan
 
 if TYPE_CHECKING:
     from game.ato import Flight
-    from game.theater import FrontLine
 
 
 class FlightPlanBuilderTypes:
     @staticmethod
     def for_flight(flight: Flight) -> Type[IBuilder[Any, Any]]:
+        from game.theater import FrontLine
+
         if flight.flight_type is FlightType.REFUELING:
             if flight.package.target.is_friendly(flight.squadron.player) or isinstance(
                 flight.package.target, FrontLine
@@ -50,6 +52,7 @@ class FlightPlanBuilderTypes:
             FlightType.OCA_RUNWAY: OcaRunwayFlightPlan.builder_type(),
             FlightType.SEAD: SeadFlightPlan.builder_type(),
             FlightType.SEAD_ESCORT: EscortFlightPlan.builder_type(),
+            FlightType.SEAD_SWEEP: SeadSweepFlightPlan.builder_type(),
             FlightType.STRIKE: StrikeFlightPlan.builder_type(),
             FlightType.SWEEP: SweepFlightPlan.builder_type(),
             FlightType.TARCAP: TarCapFlightPlan.builder_type(),

game/ato/flightplans/formation.py

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

game/ato/flightplans/formationattack.py

@@ -10,7 +10,7 @@ from dcs import Point
 
 from game.flightplan import HoldZoneGeometry
 from game.theater import MissionTarget
-from game.utils import Speed, meters, Distance
+from game.utils import Speed, meters
 from .flightplan import FlightPlan
 from .formation import FormationFlightPlan, FormationLayout
 from .ibuilder import IBuilder
@@ -25,10 +25,6 @@ if TYPE_CHECKING:
 
 
 class FormationAttackFlightPlan(FormationFlightPlan, ABC):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta()
-
     @property
     def package_speed_waypoints(self) -> set[FlightWaypoint]:
         return {
@@ -50,13 +46,6 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.targets[0]
 
-    @property
-    def tot_offset(self) -> timedelta:
-        try:
-            return -self.lead_time
-        except AttributeError:
-            return timedelta()
-
     @property
     def target_area_waypoint(self) -> FlightWaypoint:
         return FlightWaypoint(
@@ -122,15 +111,25 @@ class FormationAttackFlightPlan(FormationFlightPlan, ABC):
         )
         return tot - travel_time
 
+    @property
+    def initial_time(self) -> timedelta:
+        tot = self.tot
+        travel_time = self.travel_time_between_waypoints(
+            self.layout.initial, self.target_area_waypoint
+        )
+        return tot - travel_time
+
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.ingress:
             return self.ingress_time
+        elif waypoint == self.layout.initial:
+            return self.initial_time
         elif waypoint in self.layout.targets:
             return self.tot
         return super().tot_for_waypoint(waypoint)
 
 
-@dataclass(frozen=True)
+@dataclass
 class FormationAttackLayout(FormationLayout):
     ingress: FlightWaypoint
     targets: list[FlightWaypoint]
@@ -138,9 +137,11 @@ class FormationAttackLayout(FormationLayout):
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield self.hold
+        if self.hold:
+            yield self.hold
         yield from self.nav_to
-        yield self.join
+        if self.join:
+            yield self.join
         yield self.ingress
         if self.initial is not None:
             yield self.initial
@@ -181,8 +182,17 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
                 )
             )
 
-        hold = builder.hold(self._hold_point())
-        join = builder.join(self.package.waypoints.join)
+        hold = None
+        join = None
+        if (
+            self.flight is self.package.primary_flight
+            or self.package.primary_flight
+            and isinstance(
+                self.package.primary_flight.flight_plan, FormationAttackFlightPlan
+            )
+        ):
+            hold = builder.hold(self._hold_point())
+            join = builder.join(self.package.waypoints.join)
         split = builder.split(self.package.waypoints.split)
         refuel = builder.refuel(self.package.waypoints.refuel)
 
@@ -190,14 +200,23 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             ingress_type, self.package.waypoints.ingress, self.package.target
         )
 
+        initial = None
+        if ingress_type == FlightWaypointType.INGRESS_SEAD:
+            initial = builder.sead_search(self.package.target)
+        elif ingress_type == FlightWaypointType.INGRESS_SEAD_SWEEP:
+            initial = builder.sead_sweep(self.package.target)
+
         return FormationAttackLayout(
             departure=builder.takeoff(self.flight.departure),
             hold=hold,
             nav_to=builder.nav_path(
-                hold.position, join.position, self.doctrine.ingress_altitude
+                hold.position if hold else self.flight.departure.position,
+                join.position if join else ingress.position,
+                self.doctrine.ingress_altitude,
             ),
             join=join,
             ingress=ingress,
+            initial=initial,
             targets=target_waypoints,
             split=split,
             refuel=refuel,
@@ -219,7 +238,7 @@ class FormationAttackBuilder(IBuilder[FlightPlanT, LayoutT], ABC):
             return builder.bai_group(target)
         elif flight.flight_type == FlightType.DEAD:
             return builder.dead_point(target)
-        elif flight.flight_type == FlightType.SEAD:
+        elif flight.flight_type in {FlightType.SEAD, FlightType.SEAD_SWEEP}:
             return builder.sead_point(target)
         else:
             return builder.strike_point(target)

game/ato/flightplans/loiter.py

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

game/ato/flightplans/ocaaircraft.py

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

game/ato/flightplans/patrolling.py

@@ -16,13 +16,24 @@ if TYPE_CHECKING:
     from .flightplan import FlightPlan
 
 
-@dataclass(frozen=True)
+@dataclass
 class PatrollingLayout(StandardLayout):
     nav_to: list[FlightWaypoint]
     patrol_start: FlightWaypoint
     patrol_end: FlightWaypoint
     nav_from: list[FlightWaypoint]
 
+    def delete_waypoint(self, waypoint: FlightWaypoint) -> bool:
+        if super().delete_waypoint(waypoint):
+            return True
+        if waypoint in self.nav_to:
+            self.nav_to.remove(waypoint)
+            return True
+        elif waypoint in self.nav_from:
+            self.nav_from.remove(waypoint)
+            return True
+        return False
+
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
         yield from self.nav_to
@@ -62,7 +73,7 @@ class PatrollingFlightPlan(StandardFlightPlan[LayoutT], UiZoneDisplay, ABC):
 
     @property
     def patrol_start_time(self) -> timedelta:
-        return self.package.time_over_target
+        return self.package.time_over_target + self.tot_offset
 
     @property
     def patrol_end_time(self) -> timedelta:

game/ato/flightplans/rtb.py

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

game/ato/flightplans/sead.py

@@ -16,9 +16,8 @@ class SeadFlightPlan(FormationAttackFlightPlan):
     def builder_type() -> Type[Builder]:
         return Builder
 
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=1)
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=1)
 
 
 class Builder(FormationAttackBuilder[SeadFlightPlan, FormationAttackLayout]):

game/ato/flightplans/seadsweep.py

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

game/ato/flightplans/standard.py

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

game/ato/flightplans/sweep.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class SweepLayout(LoiterLayout):
     nav_to: list[FlightWaypoint]
     sweep_start: FlightWaypoint
@@ -26,7 +26,8 @@ class SweepLayout(LoiterLayout):
 
     def iter_waypoints(self) -> Iterator[FlightWaypoint]:
         yield self.departure
-        yield self.hold
+        if self.hold:
+            yield self.hold
         yield from self.nav_to
         yield self.sweep_start
         yield self.sweep_end
@@ -38,10 +39,6 @@ class SweepLayout(LoiterLayout):
 
 
 class SweepFlightPlan(LoiterFlightPlan):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=5)
-
     @staticmethod
     def builder_type() -> Type[Builder]:
         return Builder
@@ -54,9 +51,8 @@ class SweepFlightPlan(LoiterFlightPlan):
     def tot_waypoint(self) -> FlightWaypoint:
         return self.layout.sweep_end
 
-    @property
-    def tot_offset(self) -> timedelta:
-        return -self.lead_time
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=5)
 
     @property
     def sweep_start_time(self) -> timedelta:
@@ -71,14 +67,14 @@ class SweepFlightPlan(LoiterFlightPlan):
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.sweep_start:
-            return self.sweep_start_time
+            return self.sweep_start_time + self.tot_offset
         if waypoint == self.layout.sweep_end:
-            return self.sweep_end_time
+            return self.sweep_end_time + self.tot_offset
         return None
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.hold:
-            return self.push_time
+            return self.push_time + self.tot_offset
         return None
 
     @property

game/ato/flightplans/tarcap.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from ..flightwaypoint import FlightWaypoint
 
 
-@dataclass(frozen=True)
+@dataclass
 class TarCapLayout(PatrollingLayout):
     refuel: FlightWaypoint | None
 
@@ -34,10 +34,6 @@ class TarCapLayout(PatrollingLayout):
 
 
 class TarCapFlightPlan(PatrollingFlightPlan[TarCapLayout]):
-    @property
-    def lead_time(self) -> timedelta:
-        return timedelta(minutes=2)
-
     @property
     def patrol_duration(self) -> timedelta:
         # Note that this duration only has an effect if there are no
@@ -64,9 +60,8 @@ class TarCapFlightPlan(PatrollingFlightPlan[TarCapLayout]):
     def combat_speed_waypoints(self) -> set[FlightWaypoint]:
         return {self.layout.patrol_start, self.layout.patrol_end}
 
-    @property
-    def tot_offset(self) -> timedelta:
-        return -self.lead_time
+    def default_tot_offset(self) -> timedelta:
+        return -timedelta(minutes=2)
 
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint) -> timedelta | None:
         if waypoint == self.layout.patrol_end:

game/ato/flightplans/theaterrefueling.py

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

game/ato/flightplans/waypointbuilder.py

@@ -14,6 +14,7 @@ from typing import (
 
 from dcs.mapping import Point, Vector2
 
+from game.ato.flightplans._common_ctld import generate_random_ctld_point
 from game.ato.flightwaypoint import AltitudeReference, FlightWaypoint
 from game.ato.flightwaypointtype import FlightWaypointType
 from game.theater import (
@@ -23,7 +24,8 @@ from game.theater import (
     TheaterGroundObject,
     TheaterUnit,
 )
-from game.utils import Distance, meters, nautical_miles
+from game.theater.interfaces.CTLD import CTLD
+from game.utils import Distance, meters, nautical_miles, feet
 
 if TYPE_CHECKING:
     from game.coalition import Coalition
@@ -127,10 +129,9 @@ class WaypointBuilder:
         position = divert.position
         altitude_type: AltitudeReference
         if isinstance(divert, OffMapSpawn):
-            if self.is_helo:
-                altitude = meters(500)
-            else:
-                altitude = self.doctrine.rendezvous_altitude
+            altitude = (
+                meters(500) if self.is_helo else self.doctrine.rendezvous_altitude
+            )
             altitude_type = "BARO"
         else:
             altitude = meters(0)
@@ -225,15 +226,17 @@ class WaypointBuilder:
         position: Point,
         objective: MissionTarget,
     ) -> FlightWaypoint:
+        alt = self.doctrine.ingress_altitude
         alt_type: AltitudeReference = "BARO"
-        if self.is_helo:
+        if self.is_helo or self.flight.is_hercules:
             alt_type = "RADIO"
+            alt = meters(60) if self.is_helo else feet(1000)
 
         return FlightWaypoint(
             "INGRESS",
             ingress_type,
             position,
-            meters(60) if self.is_helo else self.doctrine.ingress_altitude,
+            alt,
             alt_type,
             description=f"INGRESS on {objective.name}",
             pretty_name=f"INGRESS on {objective.name}",
@@ -287,12 +290,9 @@ class WaypointBuilder:
         return self._target_area(f"STRIKE {target.name}", target)
 
     def sead_area(self, target: MissionTarget) -> FlightWaypoint:
-        # Set flyover with ingress altitude to allow the flight to search and engage
-        # the target group at the ingress alt without suicide dive
         return self._target_area(
             f"SEAD on {target.name}",
             target,
-            flyover=True,
             altitude=self.doctrine.ingress_altitude,
             alt_type="BARO",
         )
@@ -313,8 +313,8 @@ class WaypointBuilder:
         # plan.
         return self._target_area(f"ASSAULT {target.name}", target)
 
-    @staticmethod
     def _target_area(
+        self,
         name: str,
         location: MissionTarget,
         flyover: bool = False,
@@ -422,6 +422,55 @@ class WaypointBuilder:
             pretty_name="Orbit",
         )
 
+    def sead_search(self, target: MissionTarget) -> FlightWaypoint:
+        hold = self._sead_search_point(target)
+
+        return FlightWaypoint(
+            "SEAD Search",
+            FlightWaypointType.NAV,
+            hold,
+            self.doctrine.ingress_altitude,
+            alt_type="BARO",
+            description="Anchor and search from this point",
+            pretty_name="SEAD Search",
+        )
+
+    def sead_sweep(self, target: MissionTarget) -> FlightWaypoint:
+        hold = self._sead_search_point(target)
+
+        return FlightWaypoint(
+            "SEAD Sweep",
+            FlightWaypointType.NAV,
+            hold,
+            self.doctrine.ingress_altitude,
+            alt_type="BARO",
+            description="Anchor and search from this point",
+            pretty_name="SEAD Sweep",
+        )
+
+    def _sead_search_point(self, target: MissionTarget) -> Point:
+        """Creates custom waypoint for AI SEAD flights
+            to avoid having them fly all the way to the SAM site.
+        Args:
+            target: Target information.
+        """
+        # Use the threat range as offset distance to avoid flying all the way to the SAM site
+        assert self.flight.package.waypoints
+        ingress = self.flight.package.waypoints.ingress
+        ingress2tgt_dist = ingress.distance_to_point(target.position)
+        threat_range = nautical_miles(
+            self.flight.coalition.game.settings.sead_threat_buffer_min_distance
+        ).meters
+        if target.strike_targets:
+            threat_range = (
+                1.1 * max([x.threat_range for x in target.strike_targets]).meters
+            )
+        hdg = target.position.heading_between_point(ingress)
+        hold = target.position.point_from_heading(
+            hdg, min(threat_range, ingress2tgt_dist * 0.95)
+        )
+        return hold
+
     @staticmethod
     def escort_hold(start: Point, altitude: Distance) -> FlightWaypoint:
         """Creates custom waypoint for escort flights that need to hold.
@@ -555,10 +604,14 @@ class WaypointBuilder:
         """Creates a cargo stop waypoint.
         This waypoint is used by AirLift as a landing and stopover waypoint
         """
+        if isinstance(control_point, CTLD) and control_point.ctld_zones:
+            pos = generate_random_ctld_point(control_point)
+        else:
+            pos = control_point.position
         return FlightWaypoint(
             "CARGOSTOP",
             FlightWaypointType.CARGO_STOP,
-            control_point.position,
+            pos,
             meters(0),
             "RADIO",
             description=f"Stop for cargo at {control_point.name}",

game/ato/flightstate/flightstate.py

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

game/ato/flighttype.py

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

game/ato/flightwaypointtype.py

@@ -49,3 +49,5 @@ class FlightWaypointType(IntEnum):
     REFUEL = 29  # Should look for nearby tanker to refuel from.
     CARGO_STOP = 30  # Stopover landing point using the LandingReFuAr waypoint type
     INGRESS_AIR_ASSAULT = 31
+    INGRESS_ANTI_SHIP = 32
+    INGRESS_SEAD_SWEEP = 33

game/ato/loadouts.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import datetime
 import logging
 from collections.abc import Iterable
-from typing import Iterator, Mapping, Optional, TYPE_CHECKING, Type, Dict
+from typing import Iterator, Optional, TYPE_CHECKING, Type, Dict
 
 from dcs.unittype import FlyingType
 
@@ -19,14 +19,14 @@ class Loadout:
     def __init__(
         self,
         name: str,
-        pylons: Mapping[int, Optional[Weapon]],
+        pylons: Dict[int, Optional[Weapon]],
         date: Optional[datetime.date],
         is_custom: bool = False,
     ) -> None:
         self.name = name
         # We clear unused pylon entries on initialization, but UI actions can still
         # cause a pylon to be emptied, so make the optional type explicit.
-        self.pylons: Mapping[int, Optional[Weapon]] = {
+        self.pylons: Dict[int, Optional[Weapon]] = {
             k: v for k, v in pylons.items() if v is not None
         }
         self.date = date
@@ -92,6 +92,9 @@ class Loadout:
         if self.has_weapon_of_type(WeaponType.TGP):
             return
 
+        if unit_type.has_built_in_target_pod:
+            return
+
         new_pylons = dict(self.pylons)
         for pylon_number, weapon in self.pylons.items():
             if weapon is not None and weapon.weapon_group.type is WeaponType.LGB:
@@ -181,6 +184,9 @@ class Loadout:
         # A SEAD escort typically does not need a different loadout than a regular
         # SEAD flight, so fall back to SEAD if needed.
         loadout_names[FlightType.SEAD_ESCORT].extend(loadout_names[FlightType.SEAD])
+        loadout_names[FlightType.SEAD_SWEEP].extend(
+            loadout_names[FlightType.SEAD_ESCORT]
+        )
         # Sweep and escort can fall back to TARCAP.
         loadout_names[FlightType.ESCORT].extend(loadout_names[FlightType.TARCAP])
         loadout_names[FlightType.SWEEP].extend(loadout_names[FlightType.TARCAP])

game/ato/package.py

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

game/callsigns.py

@@ -15,7 +15,7 @@ def callsign_for_support_unit(group: FlyingGroup[Any]) -> str:
     try:
         return f"Flight {int(raw_callsign)}"
     except ValueError:
-        return raw_callsign.rstrip("1234567890")
+        return f"{raw_callsign[:-2]} {raw_callsign[-2]}"
 
 
 def create_group_callsign_from_unit(lead: FlyingUnit) -> str:

game/campaignloader/campaign.py

@@ -19,6 +19,7 @@ from game.theater.iadsnetwork.iadsnetwork import IadsNetwork
 from game.theater.theaterloader import TheaterLoader
 from game.version import CAMPAIGN_FORMAT_VERSION
 from .campaignairwingconfig import CampaignAirWingConfig
+from .campaigngroundconfig import TgoConfig
 from .mizcampaignloader import MizCampaignLoader
 
 PERF_FRIENDLY = 0
@@ -32,6 +33,7 @@ DEFAULT_BUDGET = 2000
 class Campaign:
     name: str
     menu_thumbnail_dcs_relative_path: Path
+    fallback_icon_path: Path
     authors: str
     description: str
 
@@ -54,10 +56,11 @@ class Campaign:
     data: Dict[str, Any]
     path: Path
     advanced_iads: bool
+    settings: Dict[str, Any]
 
     @classmethod
     def from_file(cls, path: Path) -> Campaign:
-        with path.open() as campaign_file:
+        with path.open(encoding="utf-8") as campaign_file:
             data = yaml.safe_load(campaign_file)
 
         sanitized_theater = data["theater"].replace(" ", "")
@@ -90,6 +93,7 @@ class Campaign:
         return cls(
             data["name"],
             TheaterLoader(data["theater"].lower()).menu_thumbnail_dcs_relative_path,
+            TheaterLoader(data["theater"].lower()).icon_path,
             data.get("authors", "???"),
             data.get("description", ""),
             (version.major, version.minor),
@@ -105,6 +109,7 @@ class Campaign:
             data,
             path,
             data.get("advanced_iads", False),
+            data.get("settings", {}),
         )
 
     def load_theater(self, advanced_iads: bool) -> ConflictTheater:
@@ -135,6 +140,13 @@ class Campaign:
             return CampaignAirWingConfig({})
         return CampaignAirWingConfig.from_campaign_data(squadron_data, theater)
 
+    def load_ground_forces_config(self) -> TgoConfig:
+        ground_forces = self.data.get("ground_forces", {})
+        if not ground_forces:
+            logging.warning(f"Campaign {self.name} does not define any ground_forces")
+            return TgoConfig({})
+        return TgoConfig.from_campaign_data(ground_forces)
+
     @property
     def is_out_of_date(self) -> bool:
         """Returns True if this campaign is not up to date with the latest format.
@@ -171,7 +183,7 @@ class Campaign:
     @classmethod
     def iter_campaign_defs(cls) -> Iterator[Path]:
         yield from cls.iter_campaigns_in_dir(
-            Path(persistency.base_path()) / "Liberation/Campaigns"
+            persistency.base_path() / "Retribution/Campaigns"
         )
         yield from cls.iter_campaigns_in_dir(Path("resources/campaigns"))
 

game/campaignloader/campaignairwingconfig.py

@@ -11,11 +11,15 @@ if TYPE_CHECKING:
     from game.theater import ConflictTheater
 
 
+DEFAULT_SQUADRON_SIZE = 12
+
+
 @dataclass(frozen=True)
 class SquadronConfig:
     primary: FlightType
     secondary: list[FlightType]
     aircraft: list[str]
+    max_size: int
 
     name: Optional[str]
     nickname: Optional[str]
@@ -35,10 +39,18 @@ class SquadronConfig:
         else:
             secondary = [FlightType(s) for s in secondary_raw]
 
+        max_size = data.get("size", DEFAULT_SQUADRON_SIZE)
+        if max_size is None:
+            raise RuntimeError(
+                "Squadron's size is defined in campaign but is missing a value:\n"
+                f"{data}"
+            )
+
         return SquadronConfig(
             FlightType(data["primary"]),
             secondary,
             data.get("aircraft", []),
+            max_size,
             data.get("name", None),
             data.get("nickname", None),
             data.get("female_pilot_percentage", None),

game/campaignloader/campaigngroundconfig.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Iterator, Optional
+
+from game.armedforces.forcegroup import ForceGroup
+
+
+@dataclass(frozen=True)
+class TgoConfig:
+    by_original_name: dict[str, ForceGroup]
+
+    def __iter__(self) -> Iterator[str]:
+        return self.by_original_name.__iter__()
+
+    def __getitem__(self, name: str) -> Optional[ForceGroup]:
+        return self.by_original_name.get(name)
+
+    @classmethod
+    def from_campaign_data(cls, data: dict[str, str]) -> TgoConfig:
+        by_original_name: dict[str, ForceGroup] = defaultdict()
+        for tgo_name, force_group in data.items():
+            by_original_name[tgo_name] = ForceGroup.from_preset_group(force_group)
+        return TgoConfig(by_original_name)

game/campaignloader/defaultsquadronassigner.py

@@ -29,7 +29,6 @@ class DefaultSquadronAssigner:
             self.coalition.player
         ):
             for squadron_config in self.config.by_location[control_point]:
-
                 squadron_def = self.override_squadron_defaults(
                     self.find_squadron_for(squadron_config, control_point),
                     squadron_config,
@@ -43,7 +42,12 @@ class DefaultSquadronAssigner:
                     continue
 
                 squadron = Squadron.create_from(
-                    squadron_def, control_point, self.coalition, self.game
+                    squadron_def,
+                    squadron_config.primary,
+                    squadron_config.max_size,
+                    control_point,
+                    self.coalition,
+                    self.game,
                 )
                 squadron.set_auto_assignable_mission_types(
                     squadron_config.auto_assignable
@@ -53,7 +57,6 @@ class DefaultSquadronAssigner:
     def find_squadron_for(
         self, config: SquadronConfig, control_point: ControlPoint
     ) -> Optional[SquadronDef]:
-
         for preferred_aircraft in config.aircraft:
             squadron_def = self.find_preferred_squadron(
                 preferred_aircraft, config.primary, control_point
@@ -88,14 +91,19 @@ class DefaultSquadronAssigner:
         try:
             aircraft = AircraftType.named(preferred_aircraft)
         except KeyError:
-            # No aircraft with this name.
+            logging.warning(
+                "%s is neither a compatible squadron or a known aircraft type, "
+                "ignoring",
+                preferred_aircraft,
+            )
             return None
 
         if aircraft not in self.coalition.faction.aircrafts:
             return None
 
+        lo = self.coalition.faction.liveries_overrides
         squadron_def = self.find_squadron_for_airframe(aircraft, task, control_point)
-        if squadron_def is not None:
+        if squadron_def is not None and lo.get(aircraft) is None:
             return squadron_def
 
         # No premade squadron available for this aircraft that meets the requirements,
@@ -111,7 +119,7 @@ class DefaultSquadronAssigner:
     ) -> bool:
         if ignore_base_preference:
             return control_point.can_operate(squadron.aircraft)
-        return squadron.operates_from(control_point) and task in squadron.mission_types
+        return squadron.operates_from(control_point) and squadron.capable_of(task)
 
     def find_squadron_for_airframe(
         self, aircraft: AircraftType, task: FlightType, control_point: ControlPoint
@@ -153,7 +161,6 @@ class DefaultSquadronAssigner:
     def override_squadron_defaults(
         squadron_def: Optional[SquadronDef], config: SquadronConfig
     ) -> Optional[SquadronDef]:
-
         if squadron_def is None:
             return None
 

game/campaignloader/mizcampaignloader.py

@@ -3,19 +3,20 @@ from __future__ import annotations
 import itertools
 from functools import cached_property
 from pathlib import Path
-from typing import Iterator, List, TYPE_CHECKING, Tuple
+from typing import Iterator, List, TYPE_CHECKING, Tuple, Optional
 from uuid import UUID
 
 from dcs import Mission
 from dcs.countries import CombinedJointTaskForcesBlue, CombinedJointTaskForcesRed
 from dcs.country import Country
-from dcs.planes import F_15C
+from dcs.planes import F_15C, A_10A, AJS37
 from dcs.ships import HandyWind, LHA_Tarawa, Stennis, USS_Arleigh_Burke_IIa
 from dcs.statics import Fortification, Warehouse
 from dcs.terrain import Airport
 from dcs.unitgroup import PlaneGroup, ShipGroup, StaticGroup, VehicleGroup
 from dcs.vehicles import AirDefence, Armor, MissilesSS, Unarmed
 
+from game.point_with_heading import PointWithHeading
 from game.positioned import Positioned
 from game.profiling import logged_duration
 from game.scenery_group import SceneryGroup
@@ -28,10 +29,11 @@ from game.theater.controlpoint import (
     OffMapSpawn,
 )
 from game.theater.presetlocation import PresetLocation
-from game.utils import Distance, meters
+from game.utils import Distance, meters, feet, Heading
 
 if TYPE_CHECKING:
     from game.theater.conflicttheater import ConflictTheater
+    from dcs import Point
 
 
 class MizCampaignLoader:
@@ -39,14 +41,17 @@ class MizCampaignLoader:
     RED_COUNTRY = CombinedJointTaskForcesRed()
 
     OFF_MAP_UNIT_TYPE = F_15C.id
+    GROUND_SPAWN_UNIT_TYPE = A_10A.id
+    GROUND_SPAWN_ROADBASE_UNIT_TYPE = AJS37.id
 
     CV_UNIT_TYPE = Stennis.id
     LHA_UNIT_TYPE = LHA_Tarawa.id
     FRONT_LINE_UNIT_TYPE = Armor.M_113.id
     SHIPPING_LANE_UNIT_TYPE = HandyWind.id
+    CP_CONVOY_SPAWN_TYPE = Armor.M1043_HMMWV_Armament.id
 
     FOB_UNIT_TYPE = Unarmed.SKP_11.id
-    FARP_HELIPADS_TYPE = ["Invisible FARP", "SINGLE_HELIPAD"]
+    FARP_HELIPADS_TYPE = ["Invisible FARP", "SINGLE_HELIPAD", "FARP"]
 
     OFFSHORE_STRIKE_TARGET_UNIT_TYPE = Fortification.Oil_platform.id
     SHIP_UNIT_TYPE = USS_Arleigh_Burke_IIa.id
@@ -94,6 +99,8 @@ class MizCampaignLoader:
 
     STRIKE_TARGET_UNIT_TYPE = Fortification.Tech_combine.id
 
+    GROUND_SPAWN_WAYPOINT_DISTANCE = 1000
+
     def __init__(self, miz: Path, theater: ConflictTheater) -> None:
         self.theater = theater
         self.mission = Mission()
@@ -107,8 +114,12 @@ class MizCampaignLoader:
         if self.mission.country(self.RED_COUNTRY.name) is None:
             self.mission.coalition["red"].add_country(self.RED_COUNTRY)
 
-    def control_point_from_airport(self, airport: Airport) -> ControlPoint:
-        cp = Airfield(airport, self.theater, starts_blue=airport.is_blue())
+    def control_point_from_airport(
+        self, airport: Airport, ctld_zones: List[Tuple[Point, float]]
+    ) -> ControlPoint:
+        cp = Airfield(
+            airport, self.theater, starts_blue=airport.is_blue(), ctld_zones=ctld_zones
+        )
 
         # Use the unlimited aircraft option to determine if an airfield should
         # be owned by the player when the campaign is "inverted".
@@ -218,6 +229,18 @@ class MizCampaignLoader:
             if group.units[0].type in self.FARP_HELIPADS_TYPE:
                 yield group
 
+    @property
+    def ground_spawns_roadbase(self) -> Iterator[PlaneGroup]:
+        for group in itertools.chain(self.blue.plane_group, self.red.plane_group):
+            if group.units[0].type == self.GROUND_SPAWN_ROADBASE_UNIT_TYPE:
+                yield group
+
+    @property
+    def ground_spawns(self) -> Iterator[PlaneGroup]:
+        for group in itertools.chain(self.blue.plane_group, self.red.plane_group):
+            if group.units[0].type == self.GROUND_SPAWN_UNIT_TYPE:
+                yield group
+
     @property
     def factories(self) -> Iterator[StaticGroup]:
         for group in self.blue.static_group:
@@ -245,7 +268,8 @@ class MizCampaignLoader:
         control_points = {}
         for airport in self.mission.terrain.airport_list():
             if airport.is_blue() or airport.is_red():
-                control_point = self.control_point_from_airport(airport)
+                ctld_zones = self.get_ctld_zones(airport.name)
+                control_point = self.control_point_from_airport(airport, ctld_zones)
                 control_points[control_point.id] = control_point
 
         for blue in (False, True):
@@ -268,8 +292,13 @@ class MizCampaignLoader:
                 control_point.captured_invert = ship.late_activation
                 control_points[control_point.id] = control_point
             for fob in self.fobs(blue):
+                ctld_zones = self.get_ctld_zones(fob.name)
                 control_point = Fob(
-                    str(fob.name), fob.position, self.theater, starts_blue=blue
+                    str(fob.name),
+                    fob.position,
+                    self.theater,
+                    starts_blue=blue,
+                    ctld_zones=ctld_zones,
                 )
                 control_point.captured_invert = fob.late_activation
                 control_points[control_point.id] = control_point
@@ -306,6 +335,81 @@ class MizCampaignLoader:
             if group.units[0].type in self.POWER_SOURCE_UNIT_TYPE:
                 yield group
 
+    @property
+    def cp_convoy_spawns(self) -> Iterator[VehicleGroup]:
+        for group in self.country(blue=True).vehicle_group:
+            if group.units[0].type == self.CP_CONVOY_SPAWN_TYPE:
+                yield group
+
+    def _construct_cp_spawnpoints(self, start: Point) -> Tuple[Point, ...]:
+        closest = self._find_closest_cp_spawn(start)
+        if closest:
+            return self._interpolate_points(closest, start)
+        return tuple()
+
+    @staticmethod
+    def _interpolate_points(closest: VehicleGroup, start: Point) -> Tuple[Point, ...]:
+        points = [start]
+        waypoints = points + [wpt.position for wpt in closest.points]
+        last = waypoints[0]
+        meters100ft = feet(100).meters
+        residual = 0.0
+        for wpt in waypoints[1:]:
+            dist = wpt.distance_to_point(last)
+            fraction = meters100ft / dist  # 100ft separation
+            interpol_count = int((dist + residual) / meters100ft - 1)
+            offset = (meters100ft - residual) / dist
+            if offset <= 1:
+                points.append(last.lerp(wpt, offset))
+            if offset + fraction <= 1:
+                for i in range(1, interpol_count + 1):
+                    points.append(last.lerp(wpt, i * fraction + offset))
+            residual = (residual + dist - meters100ft * interpol_count) % meters100ft
+            last = wpt
+        return tuple(points)
+
+    def _find_closest_cp_spawn(self, start: Point) -> Optional[VehicleGroup]:
+        closest: Optional[VehicleGroup] = None
+        for spawn in self.cp_convoy_spawns:
+            if closest is None:
+                closest = spawn
+                continue
+            dist = start.distance_to_point(closest.position)
+            if start.distance_to_point(spawn.position) < dist:
+                closest = spawn
+        return closest
+
+    @staticmethod
+    def _add_helipad(helipads: list[PointWithHeading], static: StaticGroup) -> None:
+        helipads.append(
+            PointWithHeading.from_point(
+                static.position, Heading.from_degrees(static.units[0].heading)
+            )
+        )
+
+    def _add_ground_spawn(
+        self,
+        ground_spawns: list[tuple[PointWithHeading, Point]],
+        plane_group: PlaneGroup,
+    ) -> None:
+        if len(plane_group.points) >= 2:
+            first_waypoint = plane_group.points[1].position
+        else:
+            first_waypoint = plane_group.position.point_from_heading(
+                plane_group.units[0].heading,
+                self.GROUND_SPAWN_WAYPOINT_DISTANCE,
+            )
+
+        ground_spawns.append(
+            (
+                PointWithHeading.from_point(
+                    plane_group.position,
+                    Heading.from_degrees(plane_group.units[0].heading),
+                ),
+                first_waypoint,
+            )
+        )
+
     def add_supply_routes(self) -> None:
         for group in self.front_line_path_groups:
             # The unit will have its first waypoint at the source CP and the final
@@ -323,9 +427,14 @@ class MizCampaignLoader:
                     f"No control point near the final waypoint of {group.name}"
                 )
 
-            self.control_points[origin.id].create_convoy_route(destination, waypoints)
+            o_spawns = self._construct_cp_spawnpoints(waypoints[0])
+            d_spawns = self._construct_cp_spawnpoints(waypoints[-1])
+
+            self.control_points[origin.id].create_convoy_route(
+                destination, waypoints, o_spawns
+            )
             self.control_points[destination.id].create_convoy_route(
-                origin, list(reversed(waypoints))
+                origin, list(reversed(waypoints)), d_spawns
             )
 
     def add_shipping_lanes(self) -> None:
@@ -414,7 +523,20 @@ class MizCampaignLoader:
 
         for static in self.helipads:
             closest, distance = self.objective_info(static)
-            closest.helipads.append(PresetLocation.from_group(static))
+            if static.units[0].type == "SINGLE_HELIPAD":
+                self._add_helipad(closest.helipads, static)
+            elif static.units[0].type == "FARP":
+                self._add_helipad(closest.helipads_quad, static)
+            else:
+                self._add_helipad(closest.helipads_invisible, static)
+
+        for plane_group in self.ground_spawns_roadbase:
+            closest, distance = self.objective_info(plane_group)
+            self._add_ground_spawn(closest.ground_spawns_roadbase, plane_group)
+
+        for plane_group in self.ground_spawns:
+            closest, distance = self.objective_info(plane_group)
+            self._add_ground_spawn(closest.ground_spawns, plane_group)
 
         for static in self.factories:
             closest, distance = self.objective_info(static)
@@ -460,3 +582,9 @@ class MizCampaignLoader:
         self.add_preset_locations()
         self.add_supply_routes()
         self.add_shipping_lanes()
+
+    def get_ctld_zones(self, prefix: str) -> List[Tuple[Point, float]]:
+        zones = [t for t in self.mission.triggers.zones() if prefix + " CTLD" in t.name]
+        for z in zones:
+            self.mission.triggers.zones().remove(z)
+        return [(z.position, z.radius) for z in zones]

game/campaignloader/squadrondefgenerator.py

@@ -4,7 +4,6 @@ import itertools
 import random
 from typing import Optional, TYPE_CHECKING
 
-from game.ato.ai_flight_planner_db import aircraft_for_task, tasks_for_aircraft
 from game.ato.flighttype import FlightType
 from game.dcs.aircrafttype import AircraftType
 from game.squadrons.operatingbases import OperatingBases
@@ -25,7 +24,7 @@ class SquadronDefGenerator:
         self, task: FlightType, control_point: ControlPoint
     ) -> Optional[SquadronDef]:
         aircraft_choice: Optional[AircraftType] = None
-        for aircraft in aircraft_for_task(task):
+        for aircraft in AircraftType.priority_list_for_task(task):
             if aircraft not in self.faction.aircrafts:
                 continue
             if not control_point.can_operate(aircraft):
@@ -48,7 +47,7 @@ class SquadronDefGenerator:
             role="Flying Squadron",
             aircraft=aircraft,
             livery=None,
-            mission_types=tuple(tasks_for_aircraft(aircraft)),
+            auto_assignable_mission_types=set(aircraft.iter_task_capabilities()),
             operating_bases=OperatingBases.default_for_aircraft(aircraft),
             female_pilot_percentage=6,
             pilot_pool=[],

game/coalition.py

@@ -70,14 +70,6 @@ class Coalition:
             return 2
         return 1
 
-    @property
-    def country_name(self) -> str:
-        return self.faction.country
-
-    @property
-    def country_shortname(self) -> str:
-        return self.faction.country_shortname
-
     @property
     def opponent(self) -> Coalition:
         assert self._opponent is not None
@@ -161,14 +153,14 @@ class Coalition:
         # is handled correctly.
         self.transfers.perform_transfers()
 
-    def preinit_turn_0(self) -> None:
+    def preinit_turn_0(self, squadrons_start_full: bool) -> None:
         """Runs final Coalition initialization.
 
         Final initialization occurs before Game.initialize_turn runs for turn 0.
         """
-        self.air_wing.populate_for_turn_0()
+        self.air_wing.populate_for_turn_0(squadrons_start_full)
 
-    def initialize_turn(self) -> None:
+    def initialize_turn(self, is_turn_0: bool) -> None:
         """Processes coalition-specific turn initialization.
 
         For more information on turn initialization in general, see the documentation
@@ -187,7 +179,8 @@ class Coalition:
         with logged_duration("Transport planning"):
             self.transfers.plan_transports()
 
-        self.plan_missions()
+        if not is_turn_0 or not self.game.settings.enable_squadron_aircraft_limits:
+            self.plan_missions()
         self.plan_procurement()
 
     def refund_outstanding_orders(self) -> None:

game/commander/objectivefinder.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import math
 import operator
 from collections.abc import Iterable, Iterator
+from random import randint
 from typing import TYPE_CHECKING, TypeVar
 
 from game.ato.closestairfields import ClosestAirfields, ObjectiveDistanceCache
@@ -13,6 +14,7 @@ from game.theater import (
     FrontLine,
     MissionTarget,
     OffMapSpawn,
+    ParkingType,
 )
 from game.theater.theatergroundobject import (
     BuildingGroundObject,
@@ -32,10 +34,6 @@ MissionTargetType = TypeVar("MissionTargetType", bound=MissionTarget)
 class ObjectiveFinder:
     """Identifies potential objectives for the mission planner."""
 
-    # TODO: Merge into doctrine.
-    AIRFIELD_THREAT_RANGE = nautical_miles(150)
-    SAM_THREAT_RANGE = nautical_miles(100)
-
     def __init__(self, game: Game, is_player: bool) -> None:
         self.game = game
         self.is_player = is_player
@@ -150,9 +148,18 @@ class ObjectiveFinder:
                 # Off-map spawn locations don't need protection.
                 continue
             airfields_in_proximity = self.closest_airfields_to(cp)
+            airbase_threat_range = self.game.settings.airbase_threat_range
+            if (
+                not self.is_player
+                and randint(1, 100)
+                > self.game.settings.opfor_autoplanner_aggressiveness
+            ):
+                # Chance that the airfield threat range will be evaluated as zero,
+                # causing the OPFOR autoplanner to plan offensively
+                airbase_threat_range = 0
             airfields_in_threat_range = (
                 airfields_in_proximity.operational_airfields_within(
-                    self.AIRFIELD_THREAT_RANGE
+                    nautical_miles(airbase_threat_range)
                 )
             )
             for airfield in airfields_in_threat_range:
@@ -161,11 +168,21 @@ class ObjectiveFinder:
                     break
 
     def oca_targets(self, min_aircraft: int) -> Iterator[ControlPoint]:
+        parking_type = ParkingType()
+        parking_type.include_rotary_wing = True
+        parking_type.include_fixed_wing = True
+        parking_type.include_fixed_wing_stol = True
+
         airfields = []
         for control_point in self.enemy_control_points():
-            if not isinstance(control_point, Airfield):
+            if not isinstance(control_point, Airfield) and not isinstance(
+                control_point, Fob
+            ):
                 continue
-            if control_point.allocated_aircraft().total_present >= min_aircraft:
+            if (
+                control_point.allocated_aircraft(parking_type).total_present
+                >= min_aircraft
+            ):
                 airfields.append(control_point)
         return self._targets_by_range(airfields)
 

game/commander/packagebuilder.py

@@ -26,13 +26,11 @@ class PackageBuilder:
         air_wing: AirWing,
         flight_db: Database[Flight],
         is_player: bool,
-        package_country: str,
         start_type: StartType,
         asap: bool,
     ) -> None:
         self.closest_airfields = closest_airfields
         self.is_player = is_player
-        self.package_country = package_country
         self.package = Package(location, flight_db, auto_asap=asap)
         self.air_wing = air_wing
         self.start_type = start_type
@@ -56,7 +54,6 @@ class PackageBuilder:
 
         flight = Flight(
             self.package,
-            self.package_country,
             squadron,
             plan.num_aircraft,
             plan.task,

game/commander/packagefulfiller.py

@@ -141,7 +141,6 @@ class PackageFulfiller:
             self.air_wing,
             self.flight_db,
             self.is_player,
-            self.coalition.country_name,
             self.default_start_type,
             mission.asap,
         )

game/commander/tasks/packageplanningtask.py

@@ -5,6 +5,7 @@ import operator
 from abc import abstractmethod
 from dataclasses import dataclass, field
 from enum import IntEnum, auto, unique
+import random
 from typing import Generic, Iterator, Optional, TYPE_CHECKING, TypeVar, Union
 
 from game.ato.flighttype import FlightType
@@ -170,7 +171,24 @@ class PackagePlanningTask(TheaterCommanderTask, Generic[MissionTargetT]):
 
         if not ignore_iads:
             for iads_threat in self.iter_iads_threats(state):
-                threatened = True
+                # Only consider blue faction flights threatened.
+                # Red might still plan missions into hostile territory,
+                # depending on the aggressiveness setting.
+                if (
+                    state.context.coalition.player
+                    or random.randint(1, 100)
+                    > state.context.coalition.game.settings.opfor_autoplanner_aggressiveness
+                ):
+                    threatened = True
                 if iads_threat not in state.threatening_air_defenses:
                     state.threatening_air_defenses.append(iads_threat)
         return not threatened
+
+    def get_flight_size(self) -> int:
+        settings = self.target.coalition.game.settings
+        weights = [
+            settings.fpa_2ship_weight,
+            settings.fpa_3ship_weight,
+            settings.fpa_4ship_weight,
+        ]
+        return random.choices([2, 3, 4], weights, k=1)[0]

game/commander/tasks/primitive/antiship.py

@@ -23,5 +23,6 @@ class PlanAntiShip(PackagePlanningTask[NavalGroundObject]):
         state.eliminate_ship(self.target)
 
     def propose_flights(self) -> None:
-        self.propose_flight(FlightType.ANTISHIP, randint(2, 4))
+        size = self.get_flight_size()
+        self.propose_flight(FlightType.ANTISHIP, size)
         self.propose_flight(FlightType.ESCORT, 2, EscortType.AirToAir)

game/commander/tasks/primitive/antishipping.py

@@ -22,5 +22,6 @@ class PlanAntiShipping(PackagePlanningTask[CargoShip]):
         state.enemy_shipping.remove(self.target)
 
     def propose_flights(self) -> None:
-        self.propose_flight(FlightType.ANTISHIP, randint(2, 4))
+        size = self.get_flight_size()
+        self.propose_flight(FlightType.ANTISHIP, size)
         self.propose_common_escorts()

game/commander/tasks/primitive/barcap.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import random
 from dataclasses import dataclass
 from random import randint
 
@@ -22,7 +23,8 @@ class PlanBarcap(PackagePlanningTask[ControlPoint]):
         state.barcaps_needed[self.target] -= 1
 
     def propose_flights(self) -> None:
-        self.propose_flight(FlightType.BARCAP, randint(2, 4))
+        size = self.get_flight_size()
+        self.propose_flight(FlightType.BARCAP, size)
 
     @property
     def purchase_multiplier(self) -> int:

game/commander/tasks/primitive/cas.py

@@ -30,5 +30,6 @@ class PlanCas(PackagePlanningTask[FrontLine]):
         state.vulnerable_front_lines.remove(self.target)
 
     def propose_flights(self) -> None:
-        self.propose_flight(FlightType.CAS, randint(2, 4))
+        size = self.get_flight_size()
+        self.propose_flight(FlightType.CAS, size)
         self.propose_flight(FlightType.TARCAP, 2)