More Python 3.9 compat.

(cherry picked from commit 1c31cffe4b)

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Black
+a47bef1f1336fd264d0b175f4421758339a30acb

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+Before filing, please search the issue tracker to see if the issue has already been reported.
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Additional information**
+
+We will usually need more information for debugging. Include as much of the following as you are able:
+
+- DCS Liberation save file (the `.liberation` file you save from the DCS Liberation window). By default these are located in your DCS saved games directory (`%USERPROFILE%/Saved Games/DCS`).
+- The generated mission file (the `.miz` file that you load in DCS to play the turn). By default these are located in your missions directory (`%USERPROFILE%/Saved Games/DCS/Missions`).
+- A tacview track file, especially when demonstrating an issue with AI behavior. By default these are located in your Tacview tracks directory (`%USERPROFILE%/Documents/Tacview`).
+- The state.json file from the finished mission when the problem is related to results processing. By default these are located in your Liberation install directory.
+
+**Version information (please complete the following information):**
+ - DCS Liberation [e.g. 2.3.1]:
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/workflows/black.yml

@@ -0,0 +1,13 @@
+name: Lint
+
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+      - uses: psf/black@stable
+        with:
+          args: ". --check"

.github/workflows/build.yml

@@ -0,0 +1,53 @@
+name: Build
+
+on: [push, pull_request]
+
+jobs:
+
+  build:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+
+    - name: Install environment
+      run: |
+        python -m venv ./venv
+
+    - name: Install dependencies
+      run: |
+        ./venv/scripts/activate
+        python -m pip install -r requirements.txt
+        # For some reason the shiboken2.abi3.dll is not found properly, so I copy it instead
+        Copy-Item .\venv\Lib\site-packages\shiboken2\shiboken2.abi3.dll .\venv\Lib\site-packages\PySide2\ -Force
+
+    - name: mypy game
+      run: |
+        ./venv/scripts/activate
+        mypy game
+
+    - name: mypy gen
+      run: |
+        ./venv/scripts/activate
+        mypy gen
+      
+    - name: update build number
+      run: |
+        [IO.File]::WriteAllLines($pwd.path + "\resources\buildnumber", $env:GITHUB_RUN_NUMBER)
+
+    - name: Build binaries
+      run: |
+        ./venv/scripts/activate
+        $env:PYTHONPATH=".;./pydcs"
+        pyinstaller pyinstaller.spec
+
+    - uses: actions/upload-artifact@v2
+      with:
+        name: dcs_liberation
+        path: dist/

.github/workflows/release.yml

@@ -0,0 +1,108 @@
+name: Release Pipeline
+
+on:
+  push:
+    tags: [ '*' ]
+
+jobs:
+  
+  build:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+
+    - name: Install environment
+      run: |
+        python -m venv ./venv
+
+    - name: Install dependencies
+      run: |
+        ./venv/scripts/activate
+        python -m pip install -r requirements.txt
+        # For some reason the shiboken2.abi3.dll is not found properly, so I copy it instead
+        Copy-Item .\venv\Lib\site-packages\shiboken2\shiboken2.abi3.dll .\venv\Lib\site-packages\PySide2\ -Force
+
+    - name: Finalize version
+      run: |
+        New-Item -ItemType file resources\final
+
+    - name: mypy game
+      run: |
+        ./venv/scripts/activate
+        mypy game
+
+    - name: mypy gen
+      run: |
+        ./venv/scripts/activate
+        mypy gen
+
+    - name: Build binaries
+      run: |
+        ./venv/scripts/activate
+        $env:PYTHONPATH=".;./pydcs"
+        pyinstaller pyinstaller.spec
+
+    - name: Create Installer
+      env:
+        TAG_NAME: ${{ github.ref }}
+      run: |
+        Copy-Item .\changelog.md .\dist
+
+    - uses: actions/upload-artifact@v2
+      with:
+        name: dcs_liberation
+        path: dist/
+
+  release:
+    needs: [ build ]
+    runs-on: windows-latest
+    steps:
+    - uses: actions/download-artifact@v2
+      with:
+        name: dcs_liberation
+
+    - name: "Get Version"
+      id: version        
+      env:
+        TAG_NAME: ${{ github.ref }}
+      run: |
+        Get-ChildItem -Recurse -Depth 1
+        $version = ($env:TAG_NAME -split "/") | Select-Object -Last 1
+        $prerelease = ("2.1.1-alpha3" -match '[^\.\d]').ToString().ToLower()
+        Write-Host $version
+        Write-Host $prerelease
+        Write-Output "::set-output name=number::$version"
+        Write-Output "::set-output name=prerelease::$prerelease"
+        $changelog = Get-Content .\changelog.md
+        $last_change = ($changelog | Select-String -Pattern "^#\s" | Select-Object -Skip 1 -First 1).LineNumber - 2
+        ($changelog | Select-Object -First $last_change) -join "`n" | Out-File .\releasenotes.md
+        Compress-Archive -Path .\dcs_liberation -DestinationPath "dcs_liberation.$version.zip" -Compression Optimal
+    
+    - uses: actions/create-release@v1
+      id: create_release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: ${{ github.ref }}
+        body_path: releasenotes.md
+        draft: false
+        prerelease: ${{ steps.version.outputs.prerelease }}
+
+
+    - uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./dcs_liberation.${{ steps.version.outputs.number }}.zip
+        asset_name: dcs_liberation.${{ steps.version.outputs.number }}.zip
+        asset_content_type: application/zip
+      

.gitignore

@@ -1,12 +1,24 @@
 *.pyc
 __pycache__
-build/*
+build/**
+resources/payloads/*.lua
+venv
 logs.txt
 .DS_Store
+.vscode/settings.json
+dist/**
+a.py
+resources/tools/a.miz
 # User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/dictionaries
-.idea/**/shelf
-.idea/misc.xml
-.idea/*.iml
+.idea/
+.env
+
+/kneeboards
+/liberation_preferences.json
+/state.json
+
+logs/
+
+qt_ui/logs/liberation.log
+
+*.psd

.gitmodules

@@ -1,3 +1,4 @@
-[submodule "submodules/dcs"]
-	path = submodules/dcs
+[submodule "pydcs"]
+	path = pydcs
 	url = https://github.com/pydcs/dcs
+	branch = master

.idea/inspectionProfiles/Project_Default.xml

@@ -1,10 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
-      <option name="processCode" value="true" />
-      <option name="processLiterals" value="true" />
-      <option name="processComments" value="true" />
-    </inspection_tool>
-  </profile>
-</component>

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/dcs_pmcliberation.iml" filepath="$PROJECT_DIR$/.idea/dcs_pmcliberation.iml" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GitSharedSettings">
-    <option name="FORCE_PUSH_PROHIBITED_PATTERNS">
-      <list />
-    </option>
-  </component>
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

.pre-commit-config.yaml

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

.vscode/launch.json

@@ -0,0 +1,30 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python: Main",
+      "type": "python",
+      "request": "launch",
+      "program": "qt_ui\\main.py",
+      "console": "integratedTerminal",
+      "env": {
+        "PYTHONPATH": ".;./pydcs"
+      },
+      "preLaunchTask": "Prepare Environment"
+    },
+    {
+      "name": "Python: Make Release",
+      "type": "python",
+      "request": "launch",
+      "program": "resources\\tools\\mkrelease.py",
+      "console": "integratedTerminal",
+      "env": {
+        "PYTHONPATH": ".;./pydcs"
+      },
+      "preLaunchTask": "Prepare Environment"
+    }
+  ]
+}

.vscode/tasks.json

@@ -0,0 +1,35 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Prepare Environment",
+      "type": "shell",
+      "isBackground":  false,
+      "problemMatcher": [],
+      "command": "powershell",
+      "args": [
+        "-Command",
+        "& {if (-not (Test-Path ${workspaceFolder}\\venv)) { python -m venv ${workspaceFolder}\\venv; . ${workspaceFolder}\\venv\\scripts\\activate.ps1; pip install -r requirements.txt; Copy-Item ${workspaceFolder}\\venv\\Lib\\site-packages\\shiboken2\\shiboken2.abi3.dll ${workspaceFolder}\\venv\\Lib\\site-packages\\PySide2 } }",
+      ],
+      "group": "build",
+      "options": {
+        "env": {
+          "PYTHONPATH": ".;./pydcs"
+        }
+      },
+      "presentation": {
+        "echo": true,
+        "reveal": "never",
+        "focus": false,
+        "panel": "shared",
+        "showReuseMessage": true,
+        "clear": false
+      },
+      "runOptions": {
+        "runOn": "folderOpen"
+      }
+    }
+  ]
+}

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at khopa.studio@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+First, note that we have a code of conduct, please follow it in all your interactions with the project.
+
+## Contributing as a non-developer
+ 
+* Report bugs by opening issues here on Github.
+* Help others users on Discord by answering their questions.
+* Raise awareness about the project, by making a video and/or a tutorial.
+
+Should you report a bug, please use the search bar at the top of the page to see if it has already been reported.
+Note that you may need to remove the filter for open bugs if it's something we've recently fixed.
+
+## Making content for Liberation
+
+You can create new campaigns : See [campaign creation wiki](https://github.com/Khopa/dcs_liberation/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. 
+
+## Develop new features
+
+If you want to develop a new feature, we recommend you first open an issue describing the new feature and discuss it with us on Discord before starting development.
+However, feel free to work on any existing issue.
+
+## Pull requests
+
+Please submit your pull requests on the **develop** branch. We expect a description of its content, and when applicable, a reference to the issue(s) it is resolving.

LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

README.md

@@ -1,8 +1,50 @@
-[DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player liberation dynamic campaign. 
+![Logo](https://i.imgur.com/c2k18E1.png)
 
-[Installation instructions/Manual](https://github.com/shdwp/dcs_liberation/wiki)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg?logo=paypal)](https://www.paypal.com/paypalme/KhopaDCSL)
+[![Patreon](https://img.shields.io/badge/patreon-become%20a%20patron-orange?logo=patreon)](https://patreon.com/khopa)
 
-Inspired by *ARMA Liberation* mission.
+[![Download](https://img.shields.io/github/downloads/khopa/dcs_liberation/total?label=Download)](https://github.com/Khopa/dcs_liberation/releases)
 
-Uses [pydcs](http://github.com/pydcs/dcs) for mission generation.
+[![Discord](https://img.shields.io/discord/595702951800995872?label=Discord&logo=discord)](https://discord.gg/bKrtrkJ)
 
+[![GitHub pull requests](https://img.shields.io/github/issues-pr/khopa/dcs_liberation)](https://github.com/Khopa/dcs_liberation)
+[![GitHub issues](https://img.shields.io/github/issues/khopa/dcs_liberation)](https://github.com/Khopa/dcs_liberation/issues)
+![GitHub stars](https://img.shields.io/github/stars/khopa/dcs_liberation?style=social)
+
+## About DCS Liberation
+DCS Liberation is a [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) turn based single-player or co-op dynamic campaign. 
+It is an external program that generates full and complex DCS missions and manage a persistent combat environment.  
+
+![Logo](https://i.imgur.com/4hq0rLq.png)
+
+## Downloads
+
+Latest release is available here : https://github.com/Khopa/dcs_liberation/releases
+
+To download preview builds of the next version of DCS Liberation, see https://github.com/Khopa/dcs_liberation/wiki/Preview-builds.
+
+## Bugs and feature requests
+
+If you need to report a bug or want to suggest a new feature, you can do this on our [bug tracker](https://github.com/Khopa/dcs_liberation/issues). In either case, please use the search bar at the top of the page to see if it has already been reported. Note that you may need to remove the filter for open bugs if it's something we've recently fixed.
+
+## Roadmap
+
+Our plans for future releases can be found on our [Projects page](https://github.com/Khopa/dcs_liberation/projects). Each planned release has a Project, and the page for that project has columns for to do, in progress, and done. Items in the Done column are in the [preview build](https://github.com/Khopa/dcs_liberation/wiki/Preview-builds) for that release. Items in the To do column are planned to be added to that release.
+
+## Resources
+
+Tutorials, contributors and developer's guides are available in the project's [Wiki](https://github.com/Khopa/dcs_liberation/wiki/)
+
+## Special Thanks
+
+First, a big thanks to shdwp, for starting the original DCS Liberation project. 
+
+Then, DCS Liberation uses [pydcs](http://github.com/pydcs/dcs) for mission generation, and nothing would be possible without this.
+It also uses the popular [Mist](https://github.com/mrSkortch/MissionScriptingTools) lua framework for mission scripting.
+
+Excellent lua scripts DCS Liberation uses as plugins:
+
+* For the JTAC feature, DCS Liberation embeds Ciribob's JTAC Autolase [script](https://github.com/ciribob/DCS-JTACAutoLaze).
+* Walder's [Skynet-IADS](https://github.com/walder/Skynet-IADS) is used for Integrated Air Defense System.
+
+Please also show some support to these projects ! 

__init__.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-import os
-import dcs
-
-import theater.caucasus
-import theater.persiangulf
-import theater.nevada
-
-import ui.window
-import ui.mainmenu
-import ui.newgamemenu
-import ui.corruptedsavemenu
-
-from game.game import Game
-from theater import start_generator
-from userdata import persistency
-
-dcs.planes.FlyingType.payload_dirs.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "resources\\payloads"))
-
-
-def proceed_to_main_menu(game: Game):
-    m = ui.mainmenu.MainMenu(w, None, game)
-    m.display()
-
-
-w = ui.window.Window()
-try:
-    game = persistency.restore_game()
-    if not game:
-        new_game_menu = None  # type: NewGameMenu
-
-        def start_new_game(player_name: str, enemy_name: str, terrain: str, sams: bool, midgame: bool, multiplier: float):
-            if terrain == "persiangulf":
-                conflicttheater = theater.persiangulf.PersianGulfTheater()
-            elif terrain == "nevada":
-                conflicttheater = theater.nevada.NevadaTheater()
-            else:
-                conflicttheater = theater.caucasus.CaucasusTheater()
-
-            if midgame:
-                for i in range(0, int(len(conflicttheater.controlpoints) / 2)):
-                    conflicttheater.controlpoints[i].captured = True
-
-            start_generator.generate_initial(conflicttheater, enemy_name, sams, multiplier)
-            game = Game(player_name=player_name,
-                        enemy_name=enemy_name,
-                        theater=conflicttheater)
-            game.budget = int(game.budget * multiplier)
-            game.settings.multiplier = multiplier
-            game.settings.sams = sams
-
-            if midgame:
-                game.budget = game.budget * 4 * len(list(conflicttheater.conflicts()))
-
-            proceed_to_main_menu(game)
-
-        new_game_menu = ui.newgamemenu.NewGameMenu(w, start_new_game)
-        new_game_menu.display()
-    else:
-        proceed_to_main_menu(game)
-except Exception as e:
-    ui.corruptedsavemenu.CorruptedSaveMenu(w).display()
-
-w.run()
-

changelog.md

@@ -0,0 +1,599 @@
+# 2.5.1
+
+## Features/Improvements
+
+* **[UI]** Engagement ranges are now displayed by default.
+* **[UI]** Engagement range display generalized to work for all patrolling flight plans (BARCAP, TARCAP, and CAS).
+* **[Flight Planner]** Front lines no longer project threat zones to avoid pushing BARCAPs back so much. TARCAPs will be forcibly planned but strike packages will not route around front lines even if it is reasonable to do so.
+
+## Fixes
+
+* **[Campaigns]** EWRs associated with a base will now only be generated near the base.
+* **[Flight Planner]** Fixed error when generating AEW&C flight plans in campaigns with no front lines.
+
+# 2.5.0
+
+Saves from 2.4 are not compatible with 2.5.
+
+## Features/Improvements
+
+* **[Engine]** DCS 2.7 Support
+* **[UI]** Improved FOB menu, added a custom banner, and do not display aircraft recruitment menu
+* **[Flight Planner]** Added AEW&C missions. (by siKruger)
+* **[Kneeboard]** Added dark kneeboard option (by GvonH)
+* **[Campaigns]** Multiple EWR sites may now be generated, and EWR sites may be generated outside bases (by SnappyComebacks)
+* **[Mission Generation]** Cloudy and rainy (but not thunderstorm) weather will use the cloud presets from DCS 2.7.
+* **[Plugins]** Added LotATC export plugin (by drsoran)
+* **[Plugins]** Added Splash Damage Plugin (by Wheelijoe)
+* **[Loadouts]** Replaced Litening with ATFLIR for all default F/A-18C loadouts.
+
+## Fixes
+
+* **[Flight Planner]** Front lines now project threat zones, so TARCAP/escorts will not be pruned for flights near the front. Packages may also route around the front line when practical.
+* **[Flight Planner]** Fixed error when planning BAI at SAMs with dead subgroups.
+* **[Flight Planner]** Mig-19 was not allowed for CAS roles fixed
+* **[Flight Planner]** Increased size of navigation planning area to avoid plannign failures with distant waypoints.
+* **[Flight Planner]** Fixed UI refresh when unchecking the "default loadout" box in the loadout editor.
+* **[Objective names]** Fixed typos in objective name : ARMADILLLO -> ARMADILLO (by SnappyComebacks)
+* **[Payloads]** F-86 Sabre was missing a custom payload
+* **[Payloads]** Added GAR-8 period restrictions (by Mustang-25)
+* **[Campaign]** Date now progresses.
+* **[Campaign]** Added game over message when a coalition runs out of functioning airbases.
+* **[Mission Generation]** Fixed "invalid face handle" error in kneeboard generation that occurred on some machines.
+
+## Regressions
+
+* **[Mod Support]** Stopped support for 2.5.5 Rafale Mode, and removed factions that were using it
+* **[Mod Support]** Su-57 mod support might be out of date
+
+# 2.4.3
+
+## Features/Improvements
+
+* **[New Game Wizard]** Added the possibility to setup custom start date
+
+## Fixes
+
+* **[Mods]** Updated C-130J mod data to version 6.4
+* **[Mods]** Updated F-22A mod to latest version
+
+# 2.4.2
+
+## Features/Improvements
+
+* **[Factions]** Introduction dates and fallback weapons added for US, Russian, UK, and French weapons. Huge thanks to @TheCandianVendingMachine for the massive amount of data entry!
+* **[Campaigns]** Added 1995 start dates.
+
+## Fixes
+
+* **[Economy]** Pending ground unit purchases will also be transferred when a connected base is captured.
+* **[UI]** Fixed rounding of budget in recruitment menu.
+
+# 2.4.1
+
+## Fixes
+
+* **[Units]** Fixed syntax error with the SH-60B payload file.
+* **[Culling]** Missile sites generate reasonably sized non-cull zones rather than 100km ones.
+* **[UI]** Budget display is also now rounded to 2 decimal places.
+* **[UI]** Fixed some areas where the old, non-pretty name was displayed to users.
+
+# 2.4.0
+
+Saves from 2.3 are not compatible with 2.4.
+
+## Highlights
+
+* Improved flight plan generation to avoid loitering in or traveling through threatened areas when practical.
+* Improved AI aircraft purchasing behavior.
+* Era-restricted weapons (work in progress).
+* Tons of UI polish.
+* Rebalanced economy to keep opfor competitive over the course of the game.
+
+## Features/Improvements
+
+* **[Flight Planner]** Air-to-air and SEAD escorts will no longer be automatically planned for packages that are not in range of threats.
+* **[Flight Planner]** Non-custom flight plans will now navigate around threat areas en route to the target area when practical.
+* **[Flight Planner]** Flight plans along front lines now ensure that the race track start is closer to the departure airfield than the race track end.
+* **[Campaign AI]** Auto-purchase now prefers airfields that are not within range of the enemy.
+* **[Campaign AI]** Auto-purchase now prefers the best aircraft for the task, but will attempt to maintain some variety.
+* **[Campaign AI]** Opfor now sells off odd aircraft since they're unlikely to be used.
+* **[Campaign AI]** Multiple rounds of CAP will be planned (roughly 90 minutes of coverage). Default starting budget has increased to account for the increased need for aircraft.
+* **[Mission Generator]** Multiple groups are created for complex SAM sites (SAMs with additional point defense or SHORADS), improving Skynet behavior.
+* **[Mission Generator]** Default start type can now be chosen in the settings. This replaces the non-functional "AI Parking Start" option. **Selecting any type other than cold will break OCA/Aircraft missions.**
+* **[Cheat Menu]** Added ability to toggle base capture and frontline advance/retreat cheats.
+* **[Skynet]** Updated to 2.0.1.
+* **[Skynet]** Point defenses are now configured to remain on to protect the site they accompany.
+* **[Hercules]** Updated the Hercules Cargo list file.
+* **[Balance]** Opfor now gains income using the same rules as the player, significantly increasing their income relative to the player for most campaigns.
+* **[Balance]** Units now retreat from captured bases when able. Units with no retreat path will be captured and sold.
+* **[Economy]** FOBs generate only $10M per turn (previously $20M like airbases).
+* **[Economy]** Carriers and off-map spawns generate no income (previously $20M like airbases).
+* **[Economy]** Sales of aircraft and ground vehicles can now be cancelled before the next turn begins.
+* **[UI]** Multi-SAM objectives now show threat and detection rings per group.
+* **[UI]** New icon for AA sites with no active threat.
+* **[UI]** Unit names are now prettier and more accurate, and can now be set per-country for added historical flavour.
+* **[UI]** Default loadout is now shown for flights with no custom loadout selected.
+* **[UI]** Aircraft for a new flight are now only selectable if they match the task type for that flight.
+* **[UI]** WIP - There is now a unit info button for each unit in the recruitment list, that should help newer players learn what each unit does.
+* **[UI]** Docs for time-on-target and creating new theaters/factions/loadouts are now linked in the UI at the appropriate places.
+* **[UI]** ASAP is now a checkbox rather than a button. Enabling this will disable the TOT selector but changes to the package structure will automatically re-ASAP the package.
+* **[UI]** Arrival airfield is now shown in the flight list if it differs from the departure airfield.
+* **[UI]** Start type can now be selected when creating a flight.
+* **[UI]** Arrival and divert airfields can be edited after the flight is created.
+* **[Factions]** Added option for date-based loadout restriction. Active radar homing missiles are handled, patches welcome for the other thousand weapons.
+* **[Factions]** Added Poland 2010 faction.
+* **[Factions]** Added Greece 2005 faction.
+* **[Factions]** Added Iran 1988 faction.
+* **[Units]** Support for E-2 Hawkeye, SH-60B Seahawk, S-3B Viking (thanks to awinterquest) and SpGH Dana - these are now being used by appropriate factions.
+* **[Culling]** Missile sites are no longer culled.
+* **[Campaigns]** Added campaign "Black Sea Lite" by Starfire
+* **[Campaigns]** Added campaign "Exercise Vegas Nerve" by Starfire 
+* **[New game Wizard]** The theater page is now the first page of the campaign wizard, recommended factions will be selected automatically on the faction selection page
+* **[New game Wizard]** Added information text about the selected campaign performance.
+* **[Mod Support]** Added support for High Digit SAMs mod 1.4.0
+* **[Mod Support]** Added SAMs sites generator : KS19Generator, SA10BGenerator, SA12Generator, SA17Generator, SA20Generator, SA20BGenerator, SA23Generator    
+
+## Fixes
+
+* **[Hercules]** Updated the default Hercules radio frequency.
+* **[Economy]** Pending unit orders at captured bases will be refunded.
+* **[UI]** Carrier group SAM threat rings now move with the carrier.
+* **[UI]** Base intel menu no longer compresses text, and is now scrollable.
+* **[UI]** Edit Flight window is now dynamically sized to adapt to the width of waypoint names, so they no longer get truncated.
+* **[UI]** Budget income display is now rounded to 2 decimal places.
+* **[UI]** Fixed incorrect income per turn displayed for strike target tooltip.
+* **[Factions]** USA with C-130 faction now links to the required mod.
+* **[Campaign]** Fixed issue where destroyed buildings would sometimes not count as destroyed and thus respawn.
+* **[Campaign]** Fixed issue where destroyed runways were not registered.
+* **[Units]** J-11A is no longer spawned with empty loadout.
+* **[Units]** F-14B is no longer spawned with empty loadout for fighter sweep tasks.
+* **[Units]** Pyotr Velikiy cruiser has been removed for now as it's nearly unkillable.
+* **[Units]** Submarines have been removed for now as they aren't wholly functional.
+* **[Units]** Fixed "FACTION ERROR : Unable to find OliverHazardPerryGroupGenerator in pydcs" error at startup.
+* **[Mission Generator]** Fixed a bug where units set to Aggressive stance sometimes did not move.
+* **[Mission Generator]** Flyover points for OCA/Aircraft missions are now generated correctly.
+* **[Flight Planner]** Fixed not being able to create custom waypoints for buildings.
+* **[Flight Planner]** Strike missions will no longer be automatically planned against SAMs.
+* **[Flight Planner]** Strike missions will no longer be automatically planned against FOB structures.
+
+# 2.3.4
+
+## Fixes:
+[Mission Generator] Mission generator would crash when generating fire missions for destroyed SCUD sites - fixed
+
+# 2.3.3
+
+## Features/Improvements
+* **[Campaigns]** Reworked Golan Heights campaign on Syria, (Added FOB and preset locations for SAMS)
+* **[Campaigns]** Added a lite version of the Golan Heights campaign
+* **[Campaigns]** Reworked Syrian Civil War campaign (Added FOB and preset locations for SAMS)
+* **[Campaigns]** Reworked Emirates campaign
+* **[Campaigns]** AA units added to frontlines and updated all factions to include some frontline AA units.
+* **[Mission Generator]** Infantry will only be generated for APC and IFV groups
+* **[Mission Generator]** Infantry squads size is not randomized anymore
+* **[Mission Generator]** Infantry squads can have a mortar. 
+* **[Mission Generator]** SCUD missiles sites will now fire on enemy controls points in range when possible
+* **[Factions]** Updated Nato Desert Storm to include F-14A
+* **[Factions]** Updated Iraq 1991 factions to include Zsu-57 and Mig-29A
+* **[Factions]** Germany 1944, added Stug III and Stug IV
+* **[Factions]** Added factions Insurgents (Hard) with better and more weapons
+* **[Plugins]** [The EWRS plugin](https://github.com/Bob7heBuilder/EWRS) is now included.
+* **[UI]** Added enemy intelligence summary and details window.
+
+## Fixes:
+* **[Factions]** AI would never buy artillery units for the frontline - fixed
+* **[Factions]** Removed the F-111 unit from the NATO desert storm faction. (Recruiting it would cause crashes in DCS, since it is not a valid unit)
+* **[Campaign]** Automatic redeployment of ground units would sometimes fail - fixed
+* **[Mission Generator]** Artillery groups would retreat in the wrong direction - fixed
+* **[Units]** Fixed SPG_Stryker_M1128_MGS not being in db
+* **[UI]** Fixed and added many missing ground units icons
+* **[UI]** Ship groups could be replaced by SAM sites in the UI, which would lead to broken mission being generated - fixed 
+* **[New Game Wizard]** Removed the "mid game" campaign generator option which is currently broken
+* **[Mission Generator]** Empty navy groups will no longer be generated
+* **[Mission Generator]** Fixed BAI, SEAD, and DEAD flights ocassionally being assigned the wrong targets.
+* **[Flight Planner]** Fixed not being able to plan packages against opfor carriers
+* **[UI]** Repaired SAMs no longer show as dead.
+* **[UI]** Fixed not being able to manage a disbanded site after disbanding and closing the base menu.
+
+# 2.3.2
+
+## Features/Improvements
+* **[Units]** Support for newly added BTR-82A, T-72B3
+* **[Units]** Added ZSU-57 AAA sites
+* **[Culling]** BARCAP missions no longer create culling exclusion zones.
+* **[Flight Planner]** Improved TOT planning. Negative start times no longer occur with TARCAPs and hold times no longer affect planning for flight plans without hold points.
+* **[Factions]** Added Iraq 1991 faction (thanks again to Hawkmoon!)
+
+## Fixes:
+* **[Mission Generator]** Fix mission generation error when there are too many radio frequency to setup for the Mig-21
+* **[Mission Generator]** Fix ground units not moving forward
+* **[Mission Generator]** Fixed assigned radio channels overlapping with beacons.
+* **[Flight Planner]** Fix creation of custom waypoints.
+* **[Campaigns]** Fixed many cases of SAMs spawning on the runways/taxiways in Syria Full.
+
+# 2.3.1
+
+## Features/Improvements
+* **[UX]** Added a warning message when the player is attempting to buy more planes at an already full airbase. 
+* **[Campaigns]** Migrated Syria full map to new format. (Thanks to Hawkmoon)
+* **[Faction]** Added NATO desert Storm faction (Thanks to Hawkmoon)
+
+## Fixes:
+* **[AI]** CAP flights will engage enemies again.
+* **[Campaigns]** Fixed a missing path on the Caucasus Full Map campaign
+
+# 2.3.0
+
+## Features/Improvements
+* **[Campaign Map]** Overhauled the campaign model
+* **[Campaign Map]** Possible to add FOB as control points
+* **[Campaign Map]** Added off-map spawn locations
+* **[Campaign AI]** Overhauled AI recruiting behaviour
+* **[Campaign AI]** Added AI procurement for Blue
+* **[Campaign]** New Campaign: "Black Sea"
+* **[Mission Planner]** Possible to move carrier and tarawa on the campaign map
+* **[Mission Generator]** Infantry squads on frontline can have manpads
+* **[Mission Generator]** Unused aircraft now spawned to allow for OCA strikes
+* **[Mission Generator]** Opfor now obeys parking limits
+* **[Mission Generator]** Support for Anubis C-130 Hercules mod
+* **[Flight Planner]** Added fighter sweep missions.
+* **[Flight Planner]** Added BAI missions.
+* **[Flight Planner]** Added anti-ship missions.
+* **[Flight Planner]** Differentiated BARCAP and TARCAP. TARCAP is now for hostile areas and will arrive before the package.
+* **[Flight Planner]** Added OCA missions
+* **[Flight Planner]** Added Alternate/divert airfields
+* **[Culling]** Added possibility to include/exclude carriers from culling zones
+* **[QOL]** On liberation startup, your latest save game is loaded automatically
+* **[Units]** Reduced starting fuel load for C101
+* **[UI]** Inform the user of the weather
+* **[UI]** Added toolbar buttons to change map display settings
+* **[Game]** Added new Economy options for adjusting income multipliers and starting budgets.
+
+## Fixes :
+* **[Map]** Missiles sites now have a proper icon and will not re-use the SAM sites icon
+* **[Mission Generator]** Ground unit waypoints improperly set to "On Road" - fixed
+* **[Mission Generator]** Target waypoints not at ground level - fixed
+* **[Mission Generator]** Selected skill not applied to Helicopters - fixed
+* **[Mission Generator]** Ground units do not always spawn - fixed
+* **[Kneeboard]** Briefing waypoints off by one - fixed
+* **[Game]** Destroyed buildings still granting budget - fixed
+
+# 2.2.1
+
+## Features/Improvements
+* **[Factions]** Added factions : Georgia 2008, USN 1985, France 2005 Frenchpack by HerrTom
+* **[Factions]** Added map Persian Gulf full by Plob
+* **[Flight Planner]** Player flights with start delays under ten minutes will spawn immediately.
+* **[UI]** Mission start screen now informs players about delayed flights.
+* **[Units]** Added support for F-14A-135-GR
+* **[Modding]** Possible to setup liveries overrides in factions definition files
+
+## Fixes :
+* **[Flight Planner]** Hold, join, and split points are planned cautiously near enemy airfields. Ascend/descend points are no longer planned.
+* **[Flight Planner]** Custom waypoints are usable again. Not that in most cases custom flight plans will revert to the 2.1 flight planning behavior.
+* **[Flight Planner]** Fixed UI bug that made it possible to create empty flights which would throw an error.
+* **[Flight Planner]** Player flights from carriers will now be delayed correctly according to the player's settings.
+* **[Misc]** Spitfire variant with clipped wings was not seen as flyable by DCS Liberation (hence could not be setup as client/player slot)
+* **[Misc]** Updated Syria terrain parking slots database, the out-of-date database could end up generating aircraft in wrong slots (We are still experiencing issues with somes airbases, such as Khalkhalah though)
+
+# 2.2.0
+
+## Features/Improvements :
+* **[Campaign Generator]** Added early warning radar generation
+* **[Campaign Generator]** Added scud launcher sites
+* **[Cheat Menu]** Added ability to capture base from mission planner
+* **[Cheat Menu]** Added ability to show red ATO
+* **[Factions]** Added WW2 factions that do not depend on WW2 asset pack
+* **[Factions]** Cold War / Middle eastern factions will use Flak sites
+* **[Flight Planner]** Flight planner overhaul, with package and TOT system
+* **[Flight Planner]** Pick runways and ascent/descent based on headwind
+* **[Map]** Added polygon debug mode display
+* **[Map]** Highlight the selected flight path on the map
+* **[Map]** Improved SAM display settings
+* **[Map]** Improved flight plan display settings
+* **[Map]** Caucasus and The Channel map use a new system to generate SAM and strike target location to reduce probability of targets generated in the middle of a forests
+* **[Misc]** Flexible Dedicated Hosting Options for Mission Files via environment variables
+* **[Moddability]** Custom campaigns can be designed through json files
+* **[Moddability]** LUA plugins can now be injected into Liberation missions.
+* **[Moddability]** Optional Skynet IADS lua plugin now included
+* **[New Game]** Starting budget can be freely selected
+* **[New Game]** Exanded information for faction and campaign selection in the new game wizard
+* **[UI]** Add double and right click actions to many UI elements.
+* **[UI]** Add polygon drawing mode for map background
+* **[UI]** Added a warning if you press takeoff with no player enabled flights
+* **[UI]** Packages and flights now visible in the main window sidebar
+* **[Units/Factions]** Added bombers to some coalitions
+* **[Units/Factions]** Added support for SU-57 mod by Cubanace
+* **[Units]** Added Freya EWR sites to german WW2 factions
+* **[Units]** Added support for many bombers (B-52H, B-1B, Tu-22, Tu-142)
+* **[Units]** Added support for new P-47 variants
+
+## Fixes :
+* **[Campaign Generator]** Big airbases could end up without any airbase defense.
+* **[Campaign generator]** Ship group and offshore buildings should not be generated on land anymore
+* **[Flight Planner]** Fix waypoint alitudes for helicopters
+* **[Flight Planner]** Fixed CAS aircraft wandering away from frontline
+* **[Maps]** Incirlik airbase was missing exclusions zones, so SAMS could end up being generated on the runway
+* **[Mission Generator]** Fixed player/client confusion when a flight had only one player slot.
+* **[Radios]** Fix A-10C radio
+* **[UI]** Many missing unit icons were added
+* **[UI]** Missing TER weapons in custom payload now selectable.
+
+# 2.1.5
+
+## Features/Improvements :
+* **[Units/Factions]** Enabled EPLRS for ground units that supports it (so they appear on A-10C II TAD and Helmet)
+
+## Fixes :
+* **[UI]** Fixed an issue that prevent saving after aborting a mission
+* **[Mission Generator]** Fixed aircraft landing point type being wrong
+
+# 2.1.4
+
+## Fixes :
+* **[UI]** Fixed an issue that prevented generating the mission (take off button no working) on old savegames.
+
+## Features/Improvements :
+* **[Units/Factions]** Added A-10C_2 to USA 2005 and Bluefor modern factions
+* **[UI]** Limit number of aircraft that can be bought to the number of available parking slots.
+* **[Mission Generator]** Use inline loading of the JSON.lua library, and save to either %LIBERATION_EXPORT_DIR%, or to DCS working directory
+
+## Changes :
+* **[Units/Factions]** Bluefor generic factions will now use the new "Combined Joint Task Forces Blue" country in the generated mission instead of "USA"
+
+## Fixes :
+* **[UI]** Fixed icon for Viggen
+* **[UI]** Added icons for some ground units
+* **[Misc]** Fixed issue with Chinese characters in pydcs preventing generating the mission. (Take Off button not working) (thanks to spark135246)
+* **[Misc]** Fixed an error causing with ATC frequency preventing generating the mission. (Take Off button not working) (thanks to danalbert)
+
+# 2.1.2
+
+## Fixes :
+* **[Mission Generator]** Fix mission generation issues with radio frequencies (Thanks to contributors davidp57 and danalbert)
+* **[Mission Generator]** AI should now properly plan flights for Tornados
+
+# 2.1.1
+
+## Features/Improvements :
+* **[Other]** Added an installer option (thanks to contributor parithon)
+* **[Kneeboards]** Generate mission kneeboards for player flights. Kneeboards include
+  airfield/carrier information (ATC frequencies, ILS, TACAN, and runway
+  assignments), assigned radio channels, waypoint lists, and AWACS/JTAC/tanker
+  information. (Thanks to contributor danalbert)
+* **[Radios]** Allocate separate intra-flight channels for most aircraft to reduce global
+  chatter. (Thanks to contributor danalbert)
+* **[Radios]** Configure radio channel presets for most aircraft. Currently supported are:
+  * AJS37
+  * AV-8B
+  * F-14B
+  * F-16C
+  * F/A-18C
+  * JF-17
+  * M-2000C (Thanks to contributor danalbert)
+* **[Base Menu]** Added possibility to repair destroyed SAM and base defenses units for the player (Click on a SAM site to fix it)
+* **[Base Menu]** Added possibility to buy/sell/replace SAM units
+* **[Map]** Added recon images for buildings on strike targets, click on a Strike target to get detailled informations
+* **[Units/Factions]** Added F-16C to USA 1990
+* **[Units/Factions]** Added MQ-9 Reaper as CAS unit for USA 2005
+* **[Units/Factions]** Added Mig-21, Mig-23, SA-342L to Syria 2011
+* **[Cheat Menu]** Added buttons to remove money
+
+## Fixed issues :
+* **[UI/UX]** Spelling issues (Thanks to contributor steveveepee)
+* **[Campaign Generator]** LHA was placed on land in Syrian Civil War campaign
+* **[Campaign Generator]** Fixed inverted configuration for Syria full map
+* **[Campaign Generator]** Syria "Inherent Resolve" campaign, added Incirlik Air Base
+* **[Mission Generator]** AH-1W was not used by AI to generate CAS mission by default
+* **[Mission Generator]** Fixed F-16C targeting pod not being added to payload
+* **[Mission Generator]** AH-64A and AH-64D payloads fix. 
+* **[Units/Factions]** China will use KJ-2000 as awacs instead of A-50
+
+# 2.1.0
+
+## Features/Improvements :
+
+* **[Campaign Generator]** Added Syria map
+* **[Campaign Generator]** Added 5 campaigns for the Syria map
+* **[Campaign Generator]** Added 2 small scale campaign for Persian Gulf map
+* **[Units/Factions]** Added factions for Syria map : Syria 2011, Arab Armies 1982, 1973, 1968, 1948, Israel 1982, 1973, 1948
+* **[Base Menu]** Budget is visible in recruitment menu. (Thanks to Github contributor root0fall)
+* **[Misc]** Added error message in mission when the state file can not be written
+* **[Units/Factions]** China, Pakistan, UAE will now use the new WingLoong drone as JTAC instead of the MQ-9 Reaper
+* **[Units/Factions]** Minor changes to Syria 2011 and Turkey 2005 factions
+* **[UI]** Version number is shown in about dialog
+
+## Fixed issues :
+
+* **[Mission Generator]** Caucasus terrain improvement on exclusions zone (added forests between Vaziani and Beslan to exclusion zones)
+* **[Mission Generator]** The first unit of every base defenses group could not be controlled with Combined Arms.
+* **[Mission Generator]** Reduced generated helicopter altitude for CAS missions
+* **[Mission Generator]** F-16C default CAS payload was asymmetric, fixed.
+* **[Mission Generator]** AH-1W couldn't be bought, and added default payloads.
+* **[UI/UX]** Fixed Mi-28N missing thumbnail
+* **[UI/UX]** Fixed list of flights not refreshing when changing the mission departure (T+).
+
+# 2.0.11
+
+## Features/Improvements :
+
+* **[Units/Factions]** Added Mig-31, Su-30, Mi-24V, Mi-28N to Russia 2010 faction.
+* **[Units/Factions]** Added F-15E to USA 2005 and USA 1990 factions.
+* **[Mission Generator]** Added a parameter to choose whether the JTACs should use smoke markers or not
+
+## Fixed issues : 
+
+* **[Units/Factions]** Fixed big performance issue in new release UI that occurred only when running the .exe
+* **[Units/Factions]** Fixed mission generation not working with Libya faction
+* **[Units/Factions]** Fixed OH-58D not being used by AI
+* **[Units/Factions]** Typo in UK 1990 name (fixed by bwRavencl)
+* **[Units/Factions]** Fixed Tanker Tacan channel not being the same as the briefing one. (Sorry)
+* **[Mission Generator]** Neutral airbases services will now be disabled. (Not possible to refuel or re-arm there)
+* **[Mission Generator]** AI will be configured to limit afterburner usage
+* **[Mission Generator]** JTAC will not use laser codes above 1688 anymore
+* **[Mission Generator]** JTAC units were misconfigured and would not be invisible/immortal. 
+* **[Mission Generator]** Increased JTAC status message duration to 25s, so you have more time to enter coordinates;
+* **[Mission Generator]** Destroyed units carcass will not appear on airfields to avoid having a destroyed vehicle blocking a runway or taxiway.
+
+
+# 2.0.10
+
+## Features/Improvements :
+* **[Misc]** Now possible to save game in a different file, and to open DCS Liberation savegame files. (You are not restricted to a single save file anymore)
+* **[UI/UX]** New dark UI Theme and default theme improvement by Deus
+* **[UI/UX]** New "satellite" map backgrounds
+* **[UX]** Base menu is opened with a single mouse click
+* **[Units/Factions/Mods]** Added Community A-4E-C support for faction Bluefor Cold War
+* **[Units/Factions/Mods]** Added MB-339PAN support for faction Bluefor Cold War  
+* **[Units/Factions/Mods]** Added Rafale AI mod support
+* **[Units/Factions/Mods]** Added faction "France Modded" with units from frenchpack v3.5 mod
+* **[Units/Factions/Mods]** Added faction "Insurgent modded" with Insurgent units from frenchpack v3.5 mod (Toyota truck)
+* **[Units/Factions/Mods]** Added factions Canada 2005, Australia 2005, Japan 2005, USA Aggressors, PMC
+* **[New Game Wizard]** Added the list of required mods for modded factions.
+* **[New Game Wizard]** No more RED vs BLUE opposing faction restrictions.
+* **[New Game Wizard]** New campaign generation settings added : No aircraft carrier, no lha, no navy, invert map starting positions.
+* **[Mission Generator]** Artillery units will start firing mission after a random delay. It should reduces lag spikes induced by artillery strikes by spreading them out.
+* **[Mission Generator]** Ground units will retreat after taking too much casualties. Artillery units will retreat if engaged.
+* **[Mission Generator]** The briefing will now contain the carrier ATC frequency
+* **[Mission Generator]** The briefing contains a small situation update.
+* **[Mission Generator]** Previously destroyed units are visible in the mission. (And added a performance settings to disable this behaviour)
+* **[Mission Generator]*c* Basic JTAC on Frontlines
+* **[Campaign Generator]** Added Tarawa in caucasus campaigns
+* **[Campaign Generator]** Tuned the various existing campaign parameters
+* **[Campaign Generator]** Added small campaign : "Russia" on Caucasus Theater 
+
+## Fixed issues :
+* **[Mission Generator]** Carrier will sail into the wind, not in the same direction
+* **[Mission Generator]** Carrier cold start was not working (flight was starting warm even when cold was selected)
+* **[Mission Generator]** Carrier group ships are more spread out
+* **[Mission Generator]** Fixed wrong radio frequency for german WW2 warbirds
+* **[Mission Generator]** Fixed FW-190A8 spawning with bomb rack for CAP missions
+* **[Mission Generator]** Fixed A-20G spawning with no payload
+* **[Mission Generator]** Fixed Su-33 spawning too heavy to take off from carrier
+* **[Mission Generator]** Fixed Harrier AV-8B spawning too heavy to take off from tarawa
+* **[Mission Generator]** Base defense units were not controllable with Combined Arms
+* **[Mission Generator]** Tanker speed was too low
+* **[Mission Generator]** Tanker TACAN settings were wrong
+* **[Mission Generator]** AI aircraft should start datalink ON (EPLRS)
+* **[Mission Generator]** Base defense units should not spawn on runway and or taxyway. (The chance for this to happen should now be really really low)
+* **[Mission Generator]** Fixed all flights starting "In flight" after playing a few missions (parking slot reset issue)
+* **[Mission Script/Performance]** Mission lua script will not listen to weapons fired event anymore and register every fired weapons. This should improve performance especially in WW2 scenarios or when rocket artillery is firing. 
+* **[Campaign Generator]** Carrier name will now not appear for faction who do not have carriers
+* **[Campaign Generator]** SA-10 sites will now have a tracking radar.
+* **[Units/Factions]** Remove JF-17 from USA 2005 faction
+* **[Units/Factions]** Remove AJS-37 from Russia 2010
+* **[Units/Factions]** Removed Oliver Hazard Perry from cold war factions (too powerful sam system for the era)
+* **[Bug]** On the persian gulf full map campaign, the two carriers were sharing the same id, this was causing a lot of bugs
+* **[Performance]** Tuned the culling setting so that you cannot run into situation where no friendly or enemy AI flights are generated
+* **[Other]** Application doesn't gracefully exit.
+* **[Other]** Other minor fixes, and multiples factions small changes
+
+# 2.0 RC 9
+
+## Features/Improvements :
+* **[UI/UX]** New icons from contributor Deus
+
+## Fixed issues :
+* **[Mission Generator]** Carrier TACAN was wrongfully set up as an A/A TACAN
+* **[Campaign Generator]** Fixed issue with Russian navy group generator causing a random crash on campaign creation.
+
+# 2.0 RC 8
+
+## Fixed issues :
+* **[Mission Generator]** Frequency for P-47D-30 changed to 124Mhz (Generated mission with 251Mhz would not work)
+* **[Mission Generator]** Reduced the maximum number of uboat per generated group
+* **[Mission Generator]** Fixed an issue with the WW2 LST groups (superposed units).
+* **[UI]** Fixed issue with the zoom
+
+# 2.0 RC 7
+
+## Features/Improvements :
+
+* **[Units/Factions]** Added P-47D-30 for factions allies_1944
+* **[Units/Factions]** Added factions : Bluefor Coldwar, Germany 1944 Easy
+
+* **[Campaign/Map]** Added a campaign in the Channel map
+* **[Campaign/Map]** Changed the Normandy campaign map
+* **[Campaign/Map]** Added new campaign Normandy Small
+
+* **[Mission Generator]** AI Flight generator has been reworked
+* **[Mission Generator]** Add PP points for JF-17 on STRIKE missions
+* **[Mission Generator]** Add ST point for F-14B on STRIKE missions
+* **[Mission Generator]** Flights with client slots will never be delayed
+* **[Mission Generator]** AI units can start from parking (With a new setting in Settings Window to disable it)
+* **[Mission Generator]** Tacan for carrier will only be in Mode X from now
+* **[Mission Generator]** RTB waypoints for autogenerated flights
+
+* **[Flight Planner]** Added CAS mission generator
+* **[Flight Planner]** Added CAP mission generator
+* **[Flight Planner]** Added SEAD mission generator
+* **[Flight Planner]** Added STRIKE mission generator
+* **[Flight Planner]** Added buttons to add autogenerated waypoints (ASCEND, DESCEND, RTB)
+* **[Flight Planner]** Improved waypoint list
+* **[Flight Planner]** WW2 factions uses different parameters for flight planning.
+
+* **[Settings]** Added settings to disallow external views
+* **[Settings]** Added settings to choose F10 Map mode (All, Allies only, Player only, Fog of War, Map Only)
+* **[Settings]** Added settings to choose whether to auto-generate objective marks on the F10 map
+
+* **[Info Panel]** Added information about destroyed buildings in info panel
+* **[Info Panel]** Added information about destroyed units at SAM site in info panel
+* **[Debriefing]** Added information about units destroyed outside the frontline in the debriefing window
+* **[Debriefing]** Added destroyed buildings in the debriefing window
+
+* **[Map]** Tooltip now contains the list of building for Strike targets on the map
+* **[Map]** Added "Oil derrick" building
+* **[Map]** Added "ww2 bunker" building (WW2)
+* **[Map]** Added "ally camp" building (WW2)
+* **[Map]** Added "V1 Site" (WW2)
+
+* **[Misc]** Made it possible to setup DCS Saved Games directory and DCS installation directory manually at first start
+* **[Misc]** Added culling performance settings 
+
+## Fixed issues :
+
+* **[Units/Factions]** Replaced S3-B Tanker by KC130 for most factions (More fuel)
+* **[Units/Factions]** WW2 factions will not have offshore oil station and other modern buildings generated. No more third-reich operated offshore stations will spawn on normandy's coast. 
+* **[Units/Factions]** Aircraft carrier will try to move in the wind direction
+* **[Units/Factions]** Missing icons added for some aircraft
+
+* **[Mission Generator]** When playing as RED the activation trigger would not be properly generated
+* **[Mission Generator]** FW-190A8 is now properly considered as a flyable aircraft
+* **[Mission Generator]** Changed "strike" payload for Su-24M that was ineffective
+* **[Mission Generator]** Changed "strike" payload for JF-17 to use LS-6 bombs instead of GBU
+* **[Mission Generator]** Change power station template. (Buildings could end up superposed).
+
+* **[Maps/Campaign]** Now using Vasiani airbase instead of Soganlung airport in Caucasus campaigns (more parking slot)
+* **[Info Panel]** Message displayed on base capture event stated that the enemy captured an airbase, while it was the player who captured it.
+* **[Map View]** Graphical glitch on map when one building of an objective was destroyed, but not the others 
+* **[Mission Planner]** The list of flights was not updated on departure time change. 
+
+
+# 2.0 RC 6
+
+Saves file from RC5 are not compatible with the new version. 
+Sorry :(
+
+## Features/Improvements :
+* **[Units/Factions]** Supercarrier support (You have to go to settings to enable it, if you have the supercarrier module)
+* **[Units/Factions]** Added 'Modern Bluefor' factions, containing all most popular DCS flyable units
+* **[Units/Factions]** Factions US 2005 / 1990 will now sometimes have Arleigh Burke class ships instead of Perry as carrier escorts 
+* **[Units/Factions]** Added support for newest WW2 Units
+* **[Campaign logic]** When a base is captured, refill the "base defenses" group with units for the new owner.
+* **[Mission Generator]** Carrier ICLS channel will now be configured (check your briefing)
+* **[Mission Generator]** SAM units will spawn on RED Alarm state
+* **[Mission Generator]** AI Flight planner now creates its own STRIKE flights
+* **[Mission Generator]** AI units assigned to Strike flight will now actually engage the buildings they have been assigned.
+* **[Mission Generator]** Added performance settings to allow disabling : smoke, artillery strike, moving units, infantry, SAM Red alert mode.
+* **[Mission Generator]** Using Late Activation & Trigger in attempt to improve performance & reduce stutter (Previously they were spawned through 'ETA' feature)
+* **[UX]** : Improved flight selection behaviour in the Mission Planning Window
+ 
+## Fixed issues :
+* **[Mission Generator]** Payloads were not correctly assigned in the release version. 
+* **[Mission Generator]** Game generation does not work when "no night mission" settings was selected and the current time was "day"
+* **[Mission Generator]** Game generation does not work when the player selected faction has no AWACS
+* **[Mission Generator]** Planned flights will spawn even if their home base has been captured or is being contested by enemy ground units. 
+* **[Campaign Generator]** Base defenses would not be generated on Normandy map and in some rare cases on others maps as well
+* **[Mission Planning]** CAS waypoints created from the "Predefined waypoint selector" would not be at the exact location of the frontline
+* **[Naming]** CAP mission flown from airbase are not named BARCAP anymore (CAP from carrier is still named BARCAP)

dcs

@@ -1 +0,0 @@
-submodules/dcs/dcs

game/__init__.py

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

game/data/aaa_db.py

@@ -0,0 +1,22 @@
+from dcs.vehicles import AirDefence
+
+AAA_UNITS = [
+    AirDefence.SPAAA_Gepard,
+    AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
+    AirDefence.SPAAA_Vulcan_M163,
+    AirDefence.AAA_ZU_23_Closed_Emplacement,
+    AirDefence.AAA_ZU_23_Emplacement,
+    AirDefence.SPAAA_ZU_23_2_Mounted_Ural_375,
+    AirDefence.AAA_ZU_23_Closed_Emplacement_Insurgent,
+    AirDefence.SPAAA_ZU_23_2_Insurgent_Mounted_Ural_375,
+    AirDefence.AAA_ZU_23_Insurgent,
+    AirDefence.AAA_8_8cm_Flak_18,
+    AirDefence.AAA_Flak_38_20mm,
+    AirDefence.AAA_8_8cm_Flak_36,
+    AirDefence.AAA_8_8cm_Flak_37,
+    AirDefence.AAA_Flak_Vierling_38_Quad_20mm,
+    AirDefence.AAA_SP_Kdo_G_40,
+    AirDefence.AAA_8_8cm_Flak_41,
+    AirDefence.AAA_40mm_Bofors,
+    AirDefence.AAA_S_60_57mm,
+]

game/data/building_data.py

@@ -0,0 +1,70 @@
+import inspect
+import dcs
+
+DEFAULT_AVAILABLE_BUILDINGS = [
+    "fuel",
+    "ammo",
+    "comms",
+    "oil",
+    "ware",
+    "farp",
+    "fob",
+    "power",
+    "factory",
+    "derrick",
+]
+
+WW2_FREE = ["fuel", "factory", "ware", "fob"]
+WW2_GERMANY_BUILDINGS = [
+    "fuel",
+    "factory",
+    "ww2bunker",
+    "ww2bunker",
+    "ww2bunker",
+    "allycamp",
+    "allycamp",
+    "fob",
+]
+WW2_ALLIES_BUILDINGS = [
+    "fuel",
+    "factory",
+    "allycamp",
+    "allycamp",
+    "allycamp",
+    "allycamp",
+    "allycamp",
+    "fob",
+]
+
+FORTIFICATION_BUILDINGS = [
+    "Siegfried Line",
+    "Concertina wire",
+    "Concertina Wire",
+    "Czech hedgehogs 1",
+    "Czech hedgehogs 2",
+    "Dragonteeth 1",
+    "Dragonteeth 2",
+    "Dragonteeth 3",
+    "Dragonteeth 4",
+    "Dragonteeth 5",
+    "Haystack 1",
+    "Haystack 2",
+    "Haystack 3",
+    "Haystack 4",
+    "Hemmkurvenvenhindernis",
+    "Log posts 1",
+    "Log posts 2",
+    "Log posts 3",
+    "Log ramps 1",
+    "Log ramps 2",
+    "Log ramps 3",
+    "Belgian Gate",
+    "Container white",
+]
+
+FORTIFICATION_UNITS = [
+    c for c in vars(dcs.vehicles.Fortification).values() if inspect.isclass(c)
+]
+FORTIFICATION_UNITS_ID = [
+    c.id for c in vars(dcs.vehicles.Fortification).values() if inspect.isclass(c)
+]

game/data/cap_capabilities_db.py

@@ -0,0 +1,51 @@
+from dcs.planes import (
+    Bf_109K_4,
+    C_101CC,
+    FW_190A8,
+    FW_190D9,
+    F_5E_3,
+    F_86F_Sabre,
+    I_16,
+    L_39ZA,
+    MiG_15bis,
+    MiG_19P,
+    MiG_21Bis,
+    P_47D_30,
+    P_47D_30bl1,
+    P_47D_40,
+    P_51D,
+    P_51D_30_NA,
+    SpitfireLFMkIX,
+    SpitfireLFMkIXCW,
+)
+
+from pydcs_extensions.a4ec.a4ec import A_4E_C
+
+"""
+This list contains the aircraft that do not use the guns as the last resort weapons, but as a main weapon
+They'll RTB when they don't have gun ammo left
+"""
+GUNFIGHTERS = [
+    # Cold War
+    MiG_15bis,
+    MiG_19P,
+    MiG_21Bis,
+    F_86F_Sabre,
+    A_4E_C,
+    F_5E_3,
+    # Trainers
+    C_101CC,
+    L_39ZA,
+    # WW2
+    P_51D_30_NA,
+    P_51D,
+    P_47D_30,
+    P_47D_30bl1,
+    P_47D_40,
+    SpitfireLFMkIXCW,
+    SpitfireLFMkIX,
+    Bf_109K_4,
+    FW_190D9,
+    FW_190A8,
+    I_16,
+]

game/data/doctrine.py

@@ -0,0 +1,133 @@
+from dataclasses import dataclass
+from datetime import timedelta
+
+from game.utils import Distance, feet, nautical_miles
+
+
+@dataclass(frozen=True)
+class Doctrine:
+    cas: bool
+    cap: bool
+    sead: bool
+    strike: bool
+    antiship: bool
+
+    rendezvous_altitude: Distance
+    hold_distance: Distance
+    push_distance: Distance
+    join_distance: Distance
+    split_distance: Distance
+    ingress_egress_distance: Distance
+    ingress_altitude: Distance
+    egress_altitude: Distance
+
+    min_patrol_altitude: Distance
+    max_patrol_altitude: Distance
+    pattern_altitude: Distance
+
+    #: The duration that CAP flights will remain on-station.
+    cap_duration: timedelta
+
+    #: The minimum length of the CAP race track.
+    cap_min_track_length: Distance
+
+    #: The maximum length of the CAP race track.
+    cap_max_track_length: Distance
+
+    #: The minimum distance between the defended position and the *end* of the
+    #: CAP race track.
+    cap_min_distance_from_cp: Distance
+
+    #: The maximum distance between the defended position and the *end* of the
+    #: CAP race track.
+    cap_max_distance_from_cp: Distance
+
+    #: The engagement range of CAP flights. Any enemy aircraft within this range
+    #: of the CAP's current position will be engaged by the CAP.
+    cap_engagement_range: Distance
+
+    cas_duration: timedelta
+
+    sweep_distance: Distance
+
+
+MODERN_DOCTRINE = Doctrine(
+    cap=True,
+    cas=True,
+    sead=True,
+    strike=True,
+    antiship=True,
+    rendezvous_altitude=feet(25000),
+    hold_distance=nautical_miles(15),
+    push_distance=nautical_miles(20),
+    join_distance=nautical_miles(20),
+    split_distance=nautical_miles(20),
+    ingress_egress_distance=nautical_miles(45),
+    ingress_altitude=feet(20000),
+    egress_altitude=feet(20000),
+    min_patrol_altitude=feet(15000),
+    max_patrol_altitude=feet(33000),
+    pattern_altitude=feet(5000),
+    cap_duration=timedelta(minutes=30),
+    cap_min_track_length=nautical_miles(15),
+    cap_max_track_length=nautical_miles(40),
+    cap_min_distance_from_cp=nautical_miles(10),
+    cap_max_distance_from_cp=nautical_miles(40),
+    cap_engagement_range=nautical_miles(50),
+    cas_duration=timedelta(minutes=30),
+    sweep_distance=nautical_miles(60),
+)
+
+COLDWAR_DOCTRINE = Doctrine(
+    cap=True,
+    cas=True,
+    sead=True,
+    strike=True,
+    antiship=True,
+    rendezvous_altitude=feet(22000),
+    hold_distance=nautical_miles(10),
+    push_distance=nautical_miles(10),
+    join_distance=nautical_miles(10),
+    split_distance=nautical_miles(10),
+    ingress_egress_distance=nautical_miles(30),
+    ingress_altitude=feet(18000),
+    egress_altitude=feet(18000),
+    min_patrol_altitude=feet(10000),
+    max_patrol_altitude=feet(24000),
+    pattern_altitude=feet(5000),
+    cap_duration=timedelta(minutes=30),
+    cap_min_track_length=nautical_miles(12),
+    cap_max_track_length=nautical_miles(24),
+    cap_min_distance_from_cp=nautical_miles(8),
+    cap_max_distance_from_cp=nautical_miles(25),
+    cap_engagement_range=nautical_miles(35),
+    cas_duration=timedelta(minutes=30),
+    sweep_distance=nautical_miles(40),
+)
+
+WWII_DOCTRINE = Doctrine(
+    cap=True,
+    cas=True,
+    sead=False,
+    strike=True,
+    antiship=True,
+    hold_distance=nautical_miles(5),
+    push_distance=nautical_miles(5),
+    join_distance=nautical_miles(5),
+    split_distance=nautical_miles(5),
+    rendezvous_altitude=feet(10000),
+    ingress_egress_distance=nautical_miles(7),
+    ingress_altitude=feet(8000),
+    egress_altitude=feet(8000),
+    min_patrol_altitude=feet(4000),
+    max_patrol_altitude=feet(15000),
+    pattern_altitude=feet(5000),
+    cap_duration=timedelta(minutes=30),
+    cap_min_track_length=nautical_miles(8),
+    cap_max_track_length=nautical_miles(18),
+    cap_min_distance_from_cp=nautical_miles(0),
+    cap_max_distance_from_cp=nautical_miles(5),
+    cap_engagement_range=nautical_miles(20),
+    cas_duration=timedelta(minutes=30),
+    sweep_distance=nautical_miles(10),
+)

game/data/radar_db.py

@@ -0,0 +1,72 @@
+from dcs.ships import (
+    Battlecruiser_1144_2_Pyotr_Velikiy,
+    Cruiser_1164_Moskva,
+    CVN_70_Carl_Vinson,
+    CVN_71_Theodore_Roosevelt,
+    CVN_72_Abraham_Lincoln,
+    CVN_73_George_Washington,
+    CVN_74_John_C__Stennis,
+    CV_1143_5_Admiral_Kuznetsov,
+    CV_1143_5_Admiral_Kuznetsov_2017,
+    Frigate_11540_Neustrashimy,
+    Corvette_1124_4_Grisha,
+    Frigate_1135M_Rezky,
+    Corvette_1241_1_Molniya,
+    LHA_1_Tarawa,
+    FFG_Oliver_Hazzard_Perry,
+    CG_Ticonderoga,
+    Type_052B_Destroyer,
+    Type_052C_Destroyer,
+    Type_054A_Frigate,
+    DDG_Arleigh_Burke_IIa,
+)
+from dcs.vehicles import AirDefence
+
+UNITS_WITH_RADAR = [
+    # Radars
+    AirDefence.SAM_SA_15_Tor_Gauntlet,
+    AirDefence.SAM_SA_11_Buk_Gadfly_C2,
+    AirDefence.SAM_Patriot_CR__AMG_AN_MRC_137,
+    AirDefence.SAM_Patriot_ECS,
+    AirDefence.SPAAA_Gepard,
+    AirDefence.SPAAA_Vulcan_M163,
+    AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
+    AirDefence.EWR_1L13,
+    AirDefence.SAM_SA_6_Kub_Long_Track_STR,
+    AirDefence.SAM_SA_10_S_300_Grumble_Flap_Lid_TR,
+    AirDefence.SAM_SA_10_S_300_Grumble_Clam_Shell_SR,
+    AirDefence.EWR_55G6,
+    AirDefence.SAM_SA_10_S_300_Grumble_Big_Bird_SR,
+    AirDefence.SAM_SA_11_Buk_Gadfly_Snow_Drift_SR,
+    AirDefence.MCC_SR_Sborka_Dog_Ear_SR,
+    AirDefence.SAM_Hawk_TR__AN_MPQ_46,
+    AirDefence.SAM_Hawk_SR__AN_MPQ_50,
+    AirDefence.SAM_Patriot_STR,
+    AirDefence.SAM_Hawk_CWAR_AN_MPQ_55,
+    AirDefence.SAM_P19_Flat_Face_SR__SA_2_3,
+    AirDefence.SAM_Roland_EWR,
+    AirDefence.SAM_SA_3_S_125_Low_Blow_TR,
+    AirDefence.SAM_SA_2_S_75_Fan_Song_TR,
+    AirDefence.HQ_7_Self_Propelled_STR,
+    # Ships
+    CVN_70_Carl_Vinson,
+    FFG_Oliver_Hazzard_Perry,
+    CG_Ticonderoga,
+    Corvette_1124_4_Grisha,
+    CV_1143_5_Admiral_Kuznetsov,
+    Corvette_1241_1_Molniya,
+    Cruiser_1164_Moskva,
+    Frigate_11540_Neustrashimy,
+    Battlecruiser_1144_2_Pyotr_Velikiy,
+    Frigate_1135M_Rezky,
+    CV_1143_5_Admiral_Kuznetsov_2017,
+    CVN_74_John_C__Stennis,
+    CVN_71_Theodore_Roosevelt,
+    CVN_72_Abraham_Lincoln,
+    CVN_73_George_Washington,
+    DDG_Arleigh_Burke_IIa,
+    LHA_1_Tarawa,
+    Type_052B_Destroyer,
+    Type_054A_Frigate,
+    Type_052C_Destroyer,
+]

game/debriefing.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import itertools
+import json
+import logging
+import os
+import threading
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Type,
+    TYPE_CHECKING,
+)
+
+from dcs.unittype import FlyingType, UnitType
+
+from game import db
+from game.theater import Airfield, ControlPoint
+from game.unitmap import Building, FrontLineUnit, GroundObjectUnit, UnitMap
+from gen.flights.flight import Flight
+
+if TYPE_CHECKING:
+    from game import Game
+
+DEBRIEFING_LOG_EXTENSION = "log"
+
+
+@dataclass(frozen=True)
+class AirLosses:
+    player: List[Flight]
+    enemy: List[Flight]
+
+    @property
+    def losses(self) -> Iterator[Flight]:
+        return itertools.chain(self.player, self.enemy)
+
+    def by_type(self, player: bool) -> Dict[Type[FlyingType], int]:
+        losses_by_type: Dict[Type[FlyingType], int] = defaultdict(int)
+        losses = self.player if player else self.enemy
+        for loss in losses:
+            losses_by_type[loss.unit_type] += 1
+        return losses_by_type
+
+    def surviving_flight_members(self, flight: Flight) -> int:
+        losses = 0
+        for loss in self.losses:
+            if loss == flight:
+                losses += 1
+        return flight.count - losses
+
+
+@dataclass
+class GroundLosses:
+    player_front_line: List[FrontLineUnit] = field(default_factory=list)
+    enemy_front_line: List[FrontLineUnit] = field(default_factory=list)
+
+    player_ground_objects: List[GroundObjectUnit] = field(default_factory=list)
+    enemy_ground_objects: List[GroundObjectUnit] = field(default_factory=list)
+
+    player_buildings: List[Building] = field(default_factory=list)
+    enemy_buildings: List[Building] = field(default_factory=list)
+
+    player_airfields: List[Airfield] = field(default_factory=list)
+    enemy_airfields: List[Airfield] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class StateData:
+    #: True if the mission ended. If False, the mission exited abnormally.
+    mission_ended: bool
+
+    #: Names of aircraft units that were killed during the mission.
+    killed_aircraft: List[str]
+
+    #: Names of vehicle (and ship) units that were killed during the mission.
+    killed_ground_units: List[str]
+
+    #: Names of static units that were destroyed during the mission.
+    destroyed_statics: List[str]
+
+    #: Mangled names of bases that were captured during the mission.
+    base_capture_events: List[str]
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> StateData:
+        return cls(
+            mission_ended=data["mission_ended"],
+            killed_aircraft=data["killed_aircrafts"],
+            # Airfields emit a new "dead" event every time a bomb is dropped on
+            # them when they've already dead. Dedup.
+            killed_ground_units=list(set(data["killed_ground_units"])),
+            destroyed_statics=data["destroyed_objects_positions"],
+            base_capture_events=data["base_capture_events"],
+        )
+
+
+class Debriefing:
+    def __init__(
+        self, state_data: Dict[str, Any], game: Game, unit_map: UnitMap
+    ) -> None:
+        self.state_data = StateData.from_json(state_data)
+        self.unit_map = unit_map
+
+        self.player_country = game.player_country
+        self.enemy_country = game.enemy_country
+        self.player_country_id = db.country_id_from_name(game.player_country)
+        self.enemy_country_id = db.country_id_from_name(game.enemy_country)
+
+        self.air_losses = self.dead_aircraft()
+        self.ground_losses = self.dead_ground_units()
+
+    @property
+    def front_line_losses(self) -> Iterator[FrontLineUnit]:
+        yield from self.ground_losses.player_front_line
+        yield from self.ground_losses.enemy_front_line
+
+    @property
+    def ground_object_losses(self) -> Iterator[GroundObjectUnit]:
+        yield from self.ground_losses.player_ground_objects
+        yield from self.ground_losses.enemy_ground_objects
+
+    @property
+    def building_losses(self) -> Iterator[Building]:
+        yield from self.ground_losses.player_buildings
+        yield from self.ground_losses.enemy_buildings
+
+    @property
+    def damaged_runways(self) -> Iterator[Airfield]:
+        yield from self.ground_losses.player_airfields
+        yield from self.ground_losses.enemy_airfields
+
+    def casualty_count(self, control_point: ControlPoint) -> int:
+        return len([x for x in self.front_line_losses if x.origin == control_point])
+
+    def front_line_losses_by_type(self, player: bool) -> Dict[Type[UnitType], int]:
+        losses_by_type: Dict[Type[UnitType], int] = defaultdict(int)
+        if player:
+            losses = self.ground_losses.player_front_line
+        else:
+            losses = self.ground_losses.enemy_front_line
+        for loss in losses:
+            losses_by_type[loss.unit_type] += 1
+        return losses_by_type
+
+    def building_losses_by_type(self, player: bool) -> Dict[str, int]:
+        losses_by_type: Dict[str, int] = defaultdict(int)
+        if player:
+            losses = self.ground_losses.player_buildings
+        else:
+            losses = self.ground_losses.enemy_buildings
+        for loss in losses:
+            if loss.ground_object.control_point.captured != player:
+                continue
+
+            losses_by_type[loss.ground_object.dcs_identifier] += 1
+        return losses_by_type
+
+    def dead_aircraft(self) -> AirLosses:
+        player_losses = []
+        enemy_losses = []
+        for unit_name in self.state_data.killed_aircraft:
+            flight = self.unit_map.flight(unit_name)
+            if flight is None:
+                logging.error(f"Could not find Flight matching {unit_name}")
+                continue
+            if flight.departure.captured:
+                player_losses.append(flight)
+            else:
+                enemy_losses.append(flight)
+        return AirLosses(player_losses, enemy_losses)
+
+    def dead_ground_units(self) -> GroundLosses:
+        losses = GroundLosses()
+        for unit_name in self.state_data.killed_ground_units:
+            front_line_unit = self.unit_map.front_line_unit(unit_name)
+            if front_line_unit is not None:
+                if front_line_unit.origin.captured:
+                    losses.player_front_line.append(front_line_unit)
+                else:
+                    losses.enemy_front_line.append(front_line_unit)
+                continue
+
+            ground_object_unit = self.unit_map.ground_object_unit(unit_name)
+            if ground_object_unit is not None:
+                if ground_object_unit.ground_object.control_point.captured:
+                    losses.player_ground_objects.append(ground_object_unit)
+                else:
+                    losses.enemy_ground_objects.append(ground_object_unit)
+                continue
+
+            building = self.unit_map.building_or_fortification(unit_name)
+            # Try appending object to the name, because we do this for building statics.
+            if building is None:
+                building = self.unit_map.building_or_fortification(
+                    f"{unit_name} object"
+                )
+            if building is not None:
+                if building.ground_object.control_point.captured:
+                    losses.player_buildings.append(building)
+                else:
+                    losses.enemy_buildings.append(building)
+                continue
+
+            airfield = self.unit_map.airfield(unit_name)
+            if airfield is not None:
+                if airfield.captured:
+                    losses.player_airfields.append(airfield)
+                else:
+                    losses.enemy_airfields.append(airfield)
+                continue
+
+            # Only logging as debug because we don't currently track infantry
+            # deaths, so we expect to see quite a few unclaimed dead ground
+            # units. We should start tracking those and covert this to a
+            # warning.
+            logging.debug(
+                f"Death of untracked ground unit {unit_name} will "
+                "have no effect. This may be normal behavior."
+            )
+
+        return losses
+
+    @property
+    def base_capture_events(self):
+        """Keeps only the last instance of a base capture event for each base ID."""
+        reversed_captures = list(reversed(self.state_data.base_capture_events))
+        last_base_cap_indexes = []
+        for idx, base in enumerate(i.split("||")[0] for i in reversed_captures):
+            if base not in [x[1] for x in last_base_cap_indexes]:
+                last_base_cap_indexes.append((idx, base))
+        return [reversed_captures[idx[0]] for idx in last_base_cap_indexes]
+
+
+class PollDebriefingFileThread(threading.Thread):
+    """Thread class with a stop() method. The thread itself has to check
+    regularly for the stopped() condition."""
+
+    def __init__(
+        self, callback: Callable[[Debriefing], None], game: Game, unit_map: UnitMap
+    ) -> None:
+        super().__init__()
+        self._stop_event = threading.Event()
+        self.callback = callback
+        self.game = game
+        self.unit_map = unit_map
+
+    def stop(self):
+        self._stop_event.set()
+
+    def stopped(self):
+        return self._stop_event.is_set()
+
+    def run(self):
+        if os.path.isfile("state.json"):
+            last_modified = os.path.getmtime("state.json")
+        else:
+            last_modified = 0
+        while not self.stopped():
+            if (
+                os.path.isfile("state.json")
+                and os.path.getmtime("state.json") > last_modified
+            ):
+                with open("state.json", "r") as json_file:
+                    json_data = json.load(json_file)
+                    debriefing = Debriefing(json_data, self.game, self.unit_map)
+                    self.callback(debriefing)
+                break
+            time.sleep(5)
+
+
+def wait_for_debriefing(
+    callback: Callable[[Debriefing], None], game: Game, unit_map
+) -> PollDebriefingFileThread:
+    thread = PollDebriefingFileThread(callback, game, unit_map)
+    thread.start()
+    return thread

game/event/__init__.py

@@ -1,8 +1,2 @@
 from .event import *
-from .groundintercept import *
-from .intercept import *
-from .capture import *
-from .navalintercept import *
-from .antiaastrike import *
-from .groundattack import *
-from .infantrytransport import *
+from .frontlineattack import *

game/event/airwar.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from .event import Event
+
+if TYPE_CHECKING:
+    from game.theater import ConflictTheater
+
+
+class AirWarEvent(Event):
+    """Event handler for the air battle"""
+
+    def __str__(self):
+        return "AirWar"

game/event/antiaastrike.py

@@ -1,86 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-
-from game import *
-from game.event import *
-from game.operation.antiaastrike import AntiAAStrikeOperation
-from userdata.debriefing import Debriefing
-
-
-class AntiAAStrikeEvent(Event):
-    TARGET_AMOUNT_MAX = 2
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_TARGETS_HIT_PERCENTAGE = 0.5
-
-    targets = None  # type: db.ArmorDict
-
-    def __str__(self):
-        return "Anti-AA strike from {} at {}".format(self.from_cp, self.to_cp)
-
-    def is_successfull(self, debriefing: Debriefing):
-        total_targets = sum(self.targets.values())
-        destroyed_targets = 0
-        for unit, count in debriefing.destroyed_units[self.defender_name].items():
-            if unit in self.targets:
-                destroyed_targets += count
-
-        if self.from_cp.captured:
-            return math.ceil(float(destroyed_targets) / total_targets) >= self.SUCCESS_TARGETS_HIT_PERCENTAGE
-        else:
-            return math.ceil(float(destroyed_targets) / total_targets) < self.SUCCESS_TARGETS_HIT_PERCENTAGE
-
-    def commit(self, debriefing: Debriefing):
-        super(AntiAAStrikeEvent, self).commit(debriefing)
-
-        if self.from_cp.captured:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(+self.STRENGTH_INFLUENCE)
-        else:
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-0.1)
-
-    def player_attacking(self, strikegroup: db.PlaneDict, clients: db.PlaneDict):
-        self.targets = self.to_cp.base.assemble_aa(count=self.to_cp.base.total_aa)
-
-        op = AntiAAStrikeOperation(game=self.game,
-                                   attacker_name=self.attacker_name,
-                                   defender_name=self.defender_name,
-                                   attacker_clients=clients,
-                                   defender_clients={},
-                                   from_cp=self.from_cp,
-                                   to_cp=self.to_cp)
-        op.setup(target=self.targets,
-                 strikegroup=strikegroup,
-                 interceptors={})
-
-        self.operation = op
-
-    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        self.targets = self.to_cp.base.assemble_aa()
-
-        op = AntiAAStrikeOperation(
-            self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            attacker_clients={},
-            defender_clients=clients,
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        strikegroup = self.from_cp.base.scramble_cas(self.game.settings.multiplier)
-        op.setup(target=self.targets,
-                 strikegroup=strikegroup,
-                 interceptors=interceptors)
-
-        self.operation = op

game/event/capture.py

@@ -1,89 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-
-from game import db
-from game.operation.capture import CaptureOperation
-from userdata.debriefing import Debriefing
-
-from .event import Event
-
-
-class CaptureEvent(Event):
-    silent = True
-    BONUS_BASE = 15
-    STRENGTH_RECOVERY = 0.35
-
-    def __str__(self):
-        return "Attack from {} to {}".format(self.from_cp, self.to_cp)
-
-    def is_successfull(self, debriefing: Debriefing):
-        alive_attackers = sum([v for k, v in debriefing.alive_units[self.attacker_name].items() if db.unit_task(k) == PinpointStrike])
-        alive_defenders = sum([v for k, v in debriefing.alive_units[self.defender_name].items() if db.unit_task(k) == PinpointStrike])
-        attackers_success = alive_attackers >= alive_defenders
-        if self.from_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def commit(self, debriefing: Debriefing):
-        super(CaptureEvent, self).commit(debriefing)
-        if self.is_successfull(debriefing):
-            if self.from_cp.captured:
-                self.to_cp.captured = True
-                self.to_cp.base.filter_units(db.UNIT_BY_COUNTRY[self.attacker_name])
-
-            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
-        else:
-            if not self.from_cp.captured:
-                self.to_cp.captured = False
-            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.captured = False
-
-    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        cas = self.from_cp.base.scramble_cas(self.game.settings.multiplier)
-        escort = self.from_cp.base.scramble_sweep(self.game.settings.multiplier)
-        attackers = self.from_cp.base.armor
-
-        op = CaptureOperation(game=self.game,
-                              attacker_name=self.attacker_name,
-                              defender_name=self.defender_name,
-                              attacker_clients={},
-                              defender_clients=clients,
-                              from_cp=self.from_cp,
-                              to_cp=self.to_cp)
-
-        op.setup(cas=cas,
-                 escort=escort,
-                 attack=attackers,
-                 intercept=interceptors,
-                 defense=self.to_cp.base.armor,
-                 aa=self.to_cp.base.aa)
-
-        self.operation = op
-
-    def player_attacking(self, cas: db.PlaneDict, escort: db.PlaneDict, armor: db.ArmorDict, clients: db.PlaneDict):
-        op = CaptureOperation(game=self.game,
-                              attacker_name=self.attacker_name,
-                              defender_name=self.defender_name,
-                              attacker_clients=clients,
-                              defender_clients={},
-                              from_cp=self.from_cp,
-                              to_cp=self.to_cp)
-
-        defenders = self.to_cp.base.scramble_sweep(self.game.settings.multiplier)
-        defenders.update(self.to_cp.base.scramble_cas(self.game.settings.multiplier))
-
-        op.setup(cas=cas,
-                 escort=escort,
-                 attack=armor,
-                 intercept=defenders,
-                 defense=self.to_cp.base.armor,
-                 aa=self.to_cp.base.assemble_aa())
-
-        self.operation = op
-

game/event/event.py

@@ -1,101 +1,480 @@
-from dcs.unittype import UnitType
+from __future__ import annotations
 
-from game import *
-from theater import *
-from gen.environmentgen import EnvironmentSettings
+import logging
+import math
+from typing import Dict, Iterator, List, TYPE_CHECKING, Tuple, Type
 
-from userdata.debriefing import Debriefing
-from userdata import persistency
+from dcs.mapping import Point
+from dcs.task import Task
+from dcs.unittype import UnitType, VehicleType
 
-DIFFICULTY_LOG_BASE = 1.1
+from game import persistency
+from game.debriefing import AirLosses, Debriefing
+from game.infos.information import Information
+from game.operation.operation import Operation
+from game.theater import ControlPoint
+from gen import AirTaskingOrder
+from gen.ground_forces.combat_stance import CombatStance
+from ..db import PRICES
+from ..unitmap import UnitMap
+
+if TYPE_CHECKING:
+    from ..game import Game
+
+
+MINOR_DEFEAT_INFLUENCE = 0.1
+DEFEAT_INFLUENCE = 0.3
+STRONG_DEFEAT_INFLUENCE = 0.5
 
 
 class Event:
     silent = False
     informational = False
-    is_awacs_enabled = False
-    operation = None  # type: Operation
-    difficulty = 1  # type: int
-    game = None  # type: Game
-    environment_settings = None  # type: EnvironmentSettings
-    BONUS_BASE = 5
 
-    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
+    game = None  # type: Game
+    location = None  # type: Point
+    from_cp = None  # type: ControlPoint
+    to_cp = None  # type: ControlPoint
+    difficulty = 1  # type: int
+
+    def __init__(
+        self,
+        game,
+        from_cp: ControlPoint,
+        target_cp: ControlPoint,
+        location: Point,
+        attacker_name: str,
+        defender_name: str,
+    ):
+        self.game = game
+        self.from_cp = from_cp
+        self.to_cp = target_cp
+        self.location = location
         self.attacker_name = attacker_name
         self.defender_name = defender_name
-        self.to_cp = to_cp
-        self.from_cp = from_cp
-        self.game = game
 
     @property
     def is_player_attacking(self) -> bool:
-        return self.attacker_name == self.game.player
+        return self.attacker_name == self.game.player_name
 
     @property
-    def enemy_cp(self) -> ControlPoint:
-        if self.attacker_name == self.game.player:
-            return self.to_cp
-        else:
-            return self.from_cp
+    def tasks(self) -> List[Type[Task]]:
+        return []
 
-    @property
-    def threat_description(self) -> str:
-        return ""
+    def generate(self) -> UnitMap:
+        Operation.prepare(self.game)
+        unit_map = Operation.generate()
+        Operation.current_mission.save(
+            persistency.mission_path_for("liberation_nextturn.miz")
+        )
+        return unit_map
 
-    def bonus(self) -> int:
-        return int(math.log(self.to_cp.importance + 1, DIFFICULTY_LOG_BASE) * self.BONUS_BASE)
+    @staticmethod
+    def _transfer_aircraft(
+        ato: AirTaskingOrder, losses: AirLosses, for_player: bool
+    ) -> None:
+        for package in ato.packages:
+            for flight in package.flights:
+                # No need to transfer to the same location.
+                if flight.departure == flight.arrival:
+                    continue
 
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return self.operation.is_successfull(debriefing)
+                # Don't transfer to bases that were captured. Note that if the
+                # airfield was back-filling transfers it may overflow. We could
+                # attempt to be smarter in the future by performing transfers in
+                # order up a graph to prevent transfers to full airports and
+                # send overflow off-map, but overflow is fine for now.
+                if flight.arrival.captured != for_player:
+                    logging.info(
+                        f"Not transferring {flight} because {flight.arrival} "
+                        "was captured"
+                    )
+                    continue
 
-    def generate(self):
-        self.operation.is_awacs_enabled = self.is_awacs_enabled
+                transfer_count = losses.surviving_flight_members(flight)
+                if transfer_count < 0:
+                    logging.error(
+                        f"{flight} had {flight.count} aircraft but "
+                        f"{transfer_count} losses were recorded."
+                    )
+                    continue
 
-        self.operation.prepare(self.game.theater.terrain, is_quick=False)
-        self.operation.generate()
-        self.operation.mission.save(persistency.mission_path_for("liberation_nextturn.miz"))
-        self.environment_settings = self.operation.environment_settings
+                aircraft = flight.unit_type
+                available = flight.departure.base.total_units_of_type(aircraft)
+                if available < transfer_count:
+                    logging.error(
+                        f"Found killed {aircraft} from {flight.departure} but "
+                        f"that airbase has only {available} available."
+                    )
+                    continue
 
-    def generate_quick(self):
-        self.operation.is_awacs_enabled = self.is_awacs_enabled
-        self.operation.environment_settings = self.environment_settings
+                flight.departure.base.aircraft[aircraft] -= transfer_count
+                if aircraft not in flight.arrival.base.aircraft:
+                    # TODO: Should use defaultdict.
+                    flight.arrival.base.aircraft[aircraft] = 0
+                flight.arrival.base.aircraft[aircraft] += transfer_count
 
-        self.operation.prepare(self.game.theater.terrain, is_quick=True)
-        self.operation.generate()
-        self.operation.mission.save(persistency.mission_path_for("liberation_nextturn_quick.miz"))
+    def complete_aircraft_transfers(self, debriefing: Debriefing) -> None:
+        self._transfer_aircraft(
+            self.game.blue_ato, debriefing.air_losses, for_player=True
+        )
+        self._transfer_aircraft(
+            self.game.red_ato, debriefing.air_losses, for_player=False
+        )
+
+    @staticmethod
+    def commit_air_losses(debriefing: Debriefing) -> None:
+        for loss in debriefing.air_losses.losses:
+            aircraft = loss.unit_type
+            cp = loss.departure
+            available = cp.base.total_units_of_type(aircraft)
+            if available <= 0:
+                logging.error(
+                    f"Found killed {aircraft} from {cp} but that airbase has "
+                    "none available."
+                )
+                continue
+
+            logging.info(f"{aircraft} destroyed from {cp}")
+            cp.base.aircraft[aircraft] -= 1
+
+    @staticmethod
+    def commit_front_line_losses(debriefing: Debriefing) -> None:
+        for loss in debriefing.front_line_losses:
+            unit_type = loss.unit_type
+            control_point = loss.origin
+            available = control_point.base.total_units_of_type(unit_type)
+            if available <= 0:
+                logging.error(
+                    f"Found killed {unit_type} from {control_point} but that "
+                    "airbase has none available."
+                )
+                continue
+
+            logging.info(f"{unit_type} destroyed from {control_point}")
+            control_point.base.armor[unit_type] -= 1
+
+    @staticmethod
+    def commit_ground_object_losses(debriefing: Debriefing) -> None:
+        for loss in debriefing.ground_object_losses:
+            # TODO: This should be stored in the TGO, not in the pydcs Group.
+            if not hasattr(loss.group, "units_losts"):
+                loss.group.units_losts = []
+
+            loss.group.units.remove(loss.unit)
+            loss.group.units_losts.append(loss.unit)
+
+    def commit_building_losses(self, debriefing: Debriefing) -> None:
+        for loss in debriefing.building_losses:
+            loss.ground_object.kill()
+            self.game.informations.append(
+                Information(
+                    "Building destroyed",
+                    f"{loss.ground_object.dcs_identifier} has been destroyed at "
+                    f"location {loss.ground_object.obj_name}",
+                    self.game.turn,
+                )
+            )
+
+    @staticmethod
+    def commit_damaged_runways(debriefing: Debriefing) -> None:
+        for damaged_runway in debriefing.damaged_runways:
+            damaged_runway.damage_runway()
 
     def commit(self, debriefing: Debriefing):
-        for country, losses in debriefing.destroyed_units.items():
-            if country == self.attacker_name:
-                cp = self.from_cp
-            else:
-                cp = self.to_cp
+        logging.info("Committing mission results")
 
-            cp.base.commit_losses(losses)
+        self.commit_air_losses(debriefing)
+        self.commit_front_line_losses(debriefing)
+        self.commit_ground_object_losses(debriefing)
+        self.commit_building_losses(debriefing)
+        self.commit_damaged_runways(debriefing)
 
-    def skip(self):
-        pass
+        # ------------------------------
+        # Captured bases
+        # if self.game.player_country in db.BLUEFOR_FACTIONS:
+        coalition = 2  # Value in DCS mission event for BLUE
+        # else:
+        #    coalition = 1 # Value in DCS mission event for RED
+
+        for captured in debriefing.base_capture_events:
+            try:
+                id = int(captured.split("||")[0])
+                new_owner_coalition = int(captured.split("||")[1])
+
+                captured_cps = []
+                for cp in self.game.theater.controlpoints:
+                    if cp.id == id:
+
+                        if cp.captured and new_owner_coalition != coalition:
+                            for_player = False
+                            info = Information(
+                                cp.name + " lost !",
+                                "The ennemy took control of "
+                                + cp.name
+                                + "\nShame on us !",
+                                self.game.turn,
+                            )
+                            self.game.informations.append(info)
+                            captured_cps.append(cp)
+                        elif not (cp.captured) and new_owner_coalition == coalition:
+                            for_player = True
+                            info = Information(
+                                cp.name + " captured !",
+                                "We took control of " + cp.name + "! Great job !",
+                                self.game.turn,
+                            )
+                            self.game.informations.append(info)
+                            captured_cps.append(cp)
+                        else:
+                            continue
+
+                        cp.capture(self.game, for_player)
+
+                for cp in captured_cps:
+                    logging.info("Will run redeploy for " + cp.name)
+                    self.redeploy_units(cp)
+            except Exception:
+                logging.exception(f"Could not process base capture {captured}")
+
+        self.complete_aircraft_transfers(debriefing)
+
+        # Destroyed units carcass
+        # -------------------------
+        for destroyed_unit in debriefing.state_data.destroyed_statics:
+            self.game.add_destroyed_units(destroyed_unit)
+
+        # -----------------------------------
+        # Compute damage to bases
+        for cp in self.game.theater.player_points():
+            enemy_cps = [e for e in cp.connected_points if not e.captured]
+            for enemy_cp in enemy_cps:
+                print(
+                    "Compute frontline progression for : "
+                    + cp.name
+                    + " to "
+                    + enemy_cp.name
+                )
+
+                delta = 0.0
+                player_won = True
+                ally_casualties = debriefing.casualty_count(cp)
+                enemy_casualties = debriefing.casualty_count(enemy_cp)
+                ally_units_alive = cp.base.total_armor
+                enemy_units_alive = enemy_cp.base.total_armor
+
+                print(ally_units_alive)
+                print(enemy_units_alive)
+                print(ally_casualties)
+                print(enemy_casualties)
+
+                ratio = (1.0 + enemy_casualties) / (1.0 + ally_casualties)
+
+                player_aggresive = cp.stances[enemy_cp.id] in [
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.ELIMINATION,
+                    CombatStance.BREAKTHROUGH,
+                ]
+
+                if ally_units_alive == 0:
+                    player_won = False
+                    delta = STRONG_DEFEAT_INFLUENCE
+                elif enemy_units_alive == 0:
+                    player_won = True
+                    delta = STRONG_DEFEAT_INFLUENCE
+                elif cp.stances[enemy_cp.id] == CombatStance.RETREAT:
+                    player_won = False
+                    delta = STRONG_DEFEAT_INFLUENCE
+                else:
+                    if enemy_casualties > ally_casualties:
+                        player_won = True
+                        if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
+                            delta = STRONG_DEFEAT_INFLUENCE
+                        else:
+                            if ratio > 3:
+                                delta = STRONG_DEFEAT_INFLUENCE
+                            elif ratio < 1.5:
+                                delta = MINOR_DEFEAT_INFLUENCE
+                            else:
+                                delta = DEFEAT_INFLUENCE
+                    elif ally_casualties > enemy_casualties:
+
+                        if (
+                            ally_units_alive > 2 * enemy_units_alive
+                            and player_aggresive
+                        ):
+                            # Even with casualties if the enemy is overwhelmed, they are going to lose ground
+                            player_won = True
+                            delta = MINOR_DEFEAT_INFLUENCE
+                        elif (
+                            ally_units_alive > 3 * enemy_units_alive
+                            and player_aggresive
+                        ):
+                            player_won = True
+                            delta = STRONG_DEFEAT_INFLUENCE
+                        else:
+                            # But is the enemy is not outnumbered, we lose
+                            player_won = False
+                            if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
+                                delta = STRONG_DEFEAT_INFLUENCE
+                            else:
+                                delta = STRONG_DEFEAT_INFLUENCE
+
+                    # No progress with defensive strategies
+                    if player_won and cp.stances[enemy_cp.id] in [
+                        CombatStance.DEFENSIVE,
+                        CombatStance.AMBUSH,
+                    ]:
+                        print("Defensive stance, progress is limited")
+                        delta = MINOR_DEFEAT_INFLUENCE
+
+                if player_won:
+                    print(cp.name + " won !  factor > " + str(delta))
+                    cp.base.affect_strength(delta)
+                    enemy_cp.base.affect_strength(-delta)
+                    info = Information(
+                        "Frontline Report",
+                        "Our ground forces from "
+                        + cp.name
+                        + " are making progress toward "
+                        + enemy_cp.name,
+                        self.game.turn,
+                    )
+                    self.game.informations.append(info)
+                else:
+                    print(cp.name + " lost !  factor > " + str(delta))
+                    enemy_cp.base.affect_strength(delta)
+                    cp.base.affect_strength(-delta)
+                    info = Information(
+                        "Frontline Report",
+                        "Our ground forces from "
+                        + cp.name
+                        + " are losing ground against the enemy forces from "
+                        + enemy_cp.name,
+                        self.game.turn,
+                    )
+                    self.game.informations.append(info)
+
+    def redeploy_units(self, cp: ControlPoint) -> None:
+        """ "
+        Auto redeploy units to newly captured base
+        """
+
+        ally_connected_cps = [
+            ocp for ocp in cp.connected_points if cp.captured == ocp.captured
+        ]
+        enemy_connected_cps = [
+            ocp for ocp in cp.connected_points if cp.captured != ocp.captured
+        ]
+
+        # If the newly captured cp does not have enemy connected cp,
+        # then it is not necessary to redeploy frontline units there.
+        if len(enemy_connected_cps) == 0:
+            return
+
+        # From each ally cp, send reinforcements
+        for ally_cp in ally_connected_cps:
+            self.redeploy_between(cp, ally_cp)
+
+    def redeploy_between(self, destination: ControlPoint, source: ControlPoint) -> None:
+        total_units_redeployed = 0
+        moved_units = {}
+
+        if source.has_active_frontline or not destination.captured:
+            # If there are still active front lines to defend at the
+            # transferring CP we should not transfer all units.
+            #
+            # Opfor also does not transfer all of their units.
+            # TODO: Balance the CPs rather than moving half from everywhere.
+            move_factor = 0.5
+        else:
+            # Otherwise we can move everything.
+            move_factor = 1
+
+        for frontline_unit, count in source.base.armor.items():
+            moved_units[frontline_unit] = int(count * move_factor)
+            total_units_redeployed = total_units_redeployed + int(count * move_factor)
+
+        destination.base.commision_units(moved_units)
+        source.base.commit_losses(moved_units)
+
+        # Also transfer pending deliveries.
+        for unit_type, count in source.pending_unit_deliveries.units.items():
+            if not issubclass(unit_type, VehicleType):
+                continue
+            if count <= 0:
+                # Don't transfer *sales*...
+                continue
+            move_count = int(count * move_factor)
+            source.pending_unit_deliveries.sell({unit_type: move_count})
+            destination.pending_unit_deliveries.order({unit_type: move_count})
+            total_units_redeployed += move_count
+
+        if total_units_redeployed > 0:
+            text = (
+                f"{total_units_redeployed}  units have been redeployed from "
+                f"{source.name} to {destination.name}"
+            )
+            info = Information("Units redeployed", text, self.game.turn)
+            self.game.informations.append(info)
+            logging.info(text)
 
 
-class UnitsDeliveryEvent(Event):
-    informational = True
-    units = None  # type: typing.Dict[UnitType, int]
+class UnitsDeliveryEvent:
+    def __init__(self, control_point: ControlPoint) -> None:
+        self.to_cp = control_point
+        self.units: Dict[Type[UnitType], int] = {}
 
-    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
-        super(UnitsDeliveryEvent, self).__init__(attacker_name=attacker_name,
-                                                 defender_name=defender_name,
-                                                 from_cp=from_cp,
-                                                 to_cp=to_cp,
-                                                 game=game)
-
-        self.units = {}
-
-    def __str__(self):
+    def __str__(self) -> str:
         return "Pending delivery to {}".format(self.to_cp)
 
-    def deliver(self, units: typing.Dict[UnitType, int]):
+    def order(self, units: Dict[Type[UnitType], int]) -> None:
         for k, v in units.items():
             self.units[k] = self.units.get(k, 0) + v
 
-    def skip(self):
-        self.to_cp.base.commision_units(self.units)
+    def sell(self, units: Dict[Type[UnitType], int]) -> None:
+        for k, v in units.items():
+            self.units[k] = self.units.get(k, 0) - v
+
+    def consume_each_order(self) -> Iterator[Tuple[Type[UnitType], int]]:
+        while self.units:
+            yield self.units.popitem()
+
+    def refund_all(self, game: Game) -> None:
+        for unit_type, count in self.consume_each_order():
+            try:
+                price = PRICES[unit_type]
+            except KeyError:
+                logging.error(f"Could not refund {unit_type.id}, price unknown")
+                continue
+
+            logging.info(f"Refunding {count} {unit_type.id} at {self.to_cp.name}")
+            game.adjust_budget(price * count, player=self.to_cp.captured)
+
+    def available_next_turn(self, unit_type: Type[UnitType]) -> int:
+        pending_units = self.units.get(unit_type)
+        if pending_units is None:
+            pending_units = 0
+        current_units = self.to_cp.base.total_units_of_type(unit_type)
+        return pending_units + current_units
+
+    def process(self, game: Game) -> None:
+        bought_units: Dict[Type[UnitType], int] = {}
+        sold_units: Dict[Type[UnitType], int] = {}
+        for unit_type, count in self.units.items():
+            coalition = "Ally" if self.to_cp.captured else "Enemy"
+            aircraft = unit_type.id
+            name = self.to_cp.name
+            if count >= 0:
+                bought_units[unit_type] = count
+                game.message(
+                    f"{coalition} reinforcements: {aircraft} x {count} at {name}"
+                )
+            else:
+                sold_units[unit_type] = -count
+                game.message(f"{coalition} sold: {aircraft} x {-count} at {name}")
+        self.to_cp.base.commision_units(bought_units)
+        self.to_cp.base.commit_losses(sold_units)
+        self.units = {}
+        bought_units = {}
+        sold_units = {}

game/event/frontlineattack.py

@@ -0,0 +1,12 @@
+from .event import Event
+
+
+class FrontlineAttackEvent(Event):
+    """
+    An event centered on a FrontLine Conflict.
+    Currently the same as its parent, but here for legacy compatibility as well as to allow for
+    future unique Event handling
+    """
+
+    def __str__(self):
+        return "Frontline attack"

game/event/groundattack.py

@@ -1,40 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-
-from game import *
-from game.event import *
-from game.event.groundintercept import GroundInterceptEvent
-from game.operation.groundattack import GroundAttackOperation
-
-
-class GroundAttackEvent(GroundInterceptEvent):
-    def __str__(self):
-        return "Destroy insurgents at {}".format(self.to_cp)
-
-    @property
-    def threat_description(self):
-        return ""
-
-    def player_defending(self, strikegroup: db.PlaneDict, clients: db.PlaneDict):
-        suitable_unittypes = db.find_unittype(Reconnaissance, self.attacker_name)
-        random.shuffle(suitable_unittypes)
-        unittypes = suitable_unittypes[:self.TARGET_VARIETY]
-        typecount = max(math.floor(self.difficulty * self.TARGET_AMOUNT_FACTOR), 1)
-        self.targets = {unittype: typecount for unittype in unittypes}
-
-        op = GroundAttackOperation(game=self.game,
-                                   attacker_name=self.attacker_name,
-                                   defender_name=self.defender_name,
-                                   attacker_clients={},
-                                   defender_clients=clients,
-                                   from_cp=self.from_cp,
-                                   to_cp=self.to_cp)
-        op.setup(target=self.targets,
-                 strikegroup=strikegroup)
-
-        self.operation = op
-
-    def player_attacking(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        assert False

game/event/groundintercept.py

@@ -1,106 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-from dcs.vehicles import AirDefence
-
-from game import *
-from game.event import *
-from game.operation.groundintercept import GroundInterceptOperation
-from userdata.debriefing import Debriefing
-
-
-class GroundInterceptEvent(Event):
-    TARGET_AMOUNT_FACTOR = 2
-    TARGET_VARIETY = 2
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_TARGETS_HIT_PERCENTAGE = 0.5
-
-    targets = None  # type: db.ArmorDict
-
-    @property
-    def threat_description(self):
-        if not self.game.is_player_attack(self):
-            return "{} aicraft".format(self.from_cp.base.scramble_count(self.game.settings.multiplier, CAS))
-        else:
-            return super(GroundInterceptEvent, self).threat_description
-
-    def __str__(self):
-        return "Fontline CAS from {} at {}".format(self.from_cp, self.to_cp)
-
-    def is_successfull(self, debriefing: Debriefing):
-        total_targets = sum(self.targets.values())
-        destroyed_targets = 0
-        for unit, count in debriefing.destroyed_units[self.defender_name].items():
-            if unit in self.targets:
-                destroyed_targets += count
-
-        if self.from_cp.captured:
-            return float(destroyed_targets) / total_targets >= self.SUCCESS_TARGETS_HIT_PERCENTAGE
-        else:
-            return float(destroyed_targets) / total_targets < self.SUCCESS_TARGETS_HIT_PERCENTAGE
-
-    def commit(self, debriefing: Debriefing):
-        super(GroundInterceptEvent, self).commit(debriefing)
-
-        if self.from_cp.captured:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(+self.STRENGTH_INFLUENCE)
-        else:
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-0.1)
-
-    def player_attacking(self, strikegroup: db.PlaneDict, clients: db.PlaneDict):
-        suitable_unittypes = db.find_unittype(PinpointStrike, self.defender_name)
-        random.shuffle(suitable_unittypes)
-        unittypes = suitable_unittypes[:self.TARGET_VARIETY]
-        typecount = max(math.floor(self.difficulty * self.TARGET_AMOUNT_FACTOR), 1)
-        self.targets = {unittype: typecount for unittype in unittypes}
-
-        defense_aa_unit = random.choice(self.game.commision_unit_types(self.to_cp, AirDefence))
-        self.targets[defense_aa_unit] = 1
-
-        op = GroundInterceptOperation(game=self.game,
-                                      attacker_name=self.attacker_name,
-                                      defender_name=self.defender_name,
-                                      attacker_clients=clients,
-                                      defender_clients={},
-                                      from_cp=self.from_cp,
-                                      to_cp=self.to_cp)
-        op.setup(target=self.targets,
-                 strikegroup=strikegroup,
-                 interceptors={})
-
-        self.operation = op
-
-    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        suitable_unittypes = db.find_unittype(PinpointStrike, self.defender_name)
-        random.shuffle(suitable_unittypes)
-        unittypes = suitable_unittypes[:self.TARGET_VARIETY]
-        typecount = max(math.floor(self.difficulty * self.TARGET_AMOUNT_FACTOR), 1)
-        self.targets = {unittype: typecount for unittype in unittypes}
-
-        op = GroundInterceptOperation(
-            self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            attacker_clients={},
-            defender_clients=clients,
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        strikegroup = self.from_cp.base.scramble_cas(self.game.settings.multiplier)
-        op.setup(target=self.targets,
-                 strikegroup=strikegroup,
-                 interceptors=interceptors)
-
-        self.operation = op

game/event/infantrytransport.py

@@ -1,47 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-from dcs.vehicles import *
-
-from game import db
-from game.operation.infantrytransport import InfantryTransportOperation
-from theater.conflicttheater import *
-from userdata.debriefing import Debriefing
-
-from .event import Event
-
-
-class InfantryTransportEvent(Event):
-    STRENGTH_INFLUENCE = 0.3
-
-    def __str__(self):
-        return "Frontline transport troops to {}".format(self.to_cp)
-
-    def is_successfull(self, debriefing: Debriefing):
-        return True
-
-    def commit(self, debriefing: Debriefing):
-        super(InfantryTransportEvent, self).commit(debriefing)
-
-        if self.is_successfull(debriefing):
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, transport: db.HeliDict, clients: db.HeliDict):
-        op = InfantryTransportOperation(
-            game=self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            attacker_clients=clients,
-            defender_clients={},
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        air_defense = db.find_unittype(AirDefence, self.defender_name)[0]
-        op.setup(transport=transport,
-                 aa={air_defense: 2})
-
-        self.operation = op

game/event/intercept.py

@@ -1,100 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-from dcs.vehicles import *
-
-from game import db
-from game.operation.intercept import InterceptOperation
-from theater.conflicttheater import *
-from userdata.debriefing import Debriefing
-
-from .event import Event
-
-
-class InterceptEvent(Event):
-    STRENGTH_INFLUENCE = 0.3
-    GLOBAL_STRENGTH_INFLUENCE = 0.3
-    AIRDEFENSE_COUNT = 3
-
-    transport_unit = None  # type: FlyingType
-
-    def __str__(self):
-        return "Intercept from {} at {}".format(self.from_cp, self.to_cp)
-
-    @property
-    def threat_description(self):
-        return "{} aircraft".format(self.enemy_cp.base.scramble_count(self.game.settings.multiplier, CAP))
-
-    def is_successfull(self, debriefing: Debriefing):
-        units_destroyed = debriefing.destroyed_units[self.defender_name].get(self.transport_unit, 0)
-        if self.from_cp.captured:
-            return units_destroyed > 0
-        else:
-            return units_destroyed == 0
-
-    def commit(self, debriefing: Debriefing):
-        super(InterceptEvent, self).commit(debriefing)
-
-        if self.attacker_name == self.game.player:
-            if self.is_successfull(debriefing):
-                for _, cp in self.game.theater.conflicts(True):
-                    cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            # enemy attacking
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        escort = self.to_cp.base.scramble_sweep(self.game.settings.multiplier)
-
-        self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
-        assert self.transport_unit is not None
-
-        airdefense_unit = db.find_unittype(AirDefence, self.defender_name)[-1]
-        op = InterceptOperation(game=self.game,
-                                attacker_name=self.attacker_name,
-                                defender_name=self.defender_name,
-                                attacker_clients=clients,
-                                defender_clients={},
-                                from_cp=self.from_cp,
-                                to_cp=self.to_cp)
-
-        op.setup(escort=escort,
-                 transport={self.transport_unit: 1},
-                 airdefense={airdefense_unit: self.AIRDEFENSE_COUNT},
-                 interceptors=interceptors)
-
-        self.operation = op
-
-    def player_defending(self, escort: db.PlaneDict, clients: db.PlaneDict):
-        # TODO: even not quick mission is too quick
-        interceptors = self.from_cp.base.scramble_interceptors(self.game.settings.multiplier)
-
-        self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
-        assert self.transport_unit is not None
-
-        op = InterceptOperation(game=self.game,
-                                attacker_name=self.attacker_name,
-                                defender_name=self.defender_name,
-                                attacker_clients={},
-                                defender_clients=clients,
-                                from_cp=self.from_cp,
-                                to_cp=self.to_cp)
-
-        op.setup(escort=escort,
-                 transport={self.transport_unit: 1},
-                 interceptors=interceptors,
-                 airdefense={})
-
-        self.operation = op
-
-

game/event/navalintercept.py

@@ -1,108 +0,0 @@
-import typing
-import math
-import random
-
-from dcs.task import *
-from dcs.vehicles import *
-
-from game import db
-from game.operation.navalintercept import NavalInterceptionOperation
-from userdata.debriefing import Debriefing
-
-from .event import Event
-
-
-class NavalInterceptEvent(Event):
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_RATE = 0.5
-
-    targets = None  # type: db.ShipDict
-
-    def _targets_count(self) -> int:
-        from gen.conflictgen import IMPORTANCE_LOW, IMPORTANCE_HIGH
-        factor = (self.to_cp.importance - IMPORTANCE_LOW) * 10
-        return max(int(factor), 1)
-
-    def __str__(self) -> str:
-        return "Naval intercept at {}".format(self.to_cp)
-
-    @property
-    def threat_description(self):
-        s = "{} ship(s)".format(self._targets_count())
-        if not self.from_cp.captured:
-            s += ", {} aircraft".format(self.from_cp.base.scramble_count(self.game.settings.multiplier))
-        return s
-
-    def is_successfull(self, debriefing: Debriefing):
-        total_targets = sum(self.targets.values())
-        destroyed_targets = 0
-        for unit, count in debriefing.destroyed_units[self.defender_name].items():
-            if unit in self.targets:
-                destroyed_targets += count
-
-        if self.from_cp.captured:
-            return math.ceil(float(destroyed_targets) / total_targets) > self.SUCCESS_RATE
-        else:
-            return math.ceil(float(destroyed_targets) / total_targets) < self.SUCCESS_RATE
-
-    def commit(self, debriefing: Debriefing):
-        super(NavalInterceptEvent, self).commit(debriefing)
-
-        if self.attacker_name == self.game.player:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            # enemy attacking
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, strikegroup: db.PlaneDict, clients: db.PlaneDict):
-        self.targets = {
-            random.choice(db.find_unittype(CargoTransportation, self.defender_name)): self._targets_count(),
-        }
-
-        op = NavalInterceptionOperation(
-            self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            attacker_clients=clients,
-            defender_clients={},
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        op.setup(strikegroup=strikegroup,
-                 interceptors={},
-                 targets=self.targets)
-
-        self.operation = op
-
-    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        self.targets = {
-            random.choice(db.find_unittype(CargoTransportation, self.defender_name)): self._targets_count(),
-        }
-
-        op = NavalInterceptionOperation(
-            self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            attacker_clients={},
-            defender_clients=clients,
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        strikegroup = self.from_cp.base.scramble_cas(self.game.settings.multiplier)
-        op.setup(strikegroup=strikegroup,
-                 interceptors=interceptors,
-                 targets=self.targets)
-
-        self.operation = op

game/factions/faction.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Type, List, Any, cast
+
+import dcs
+from dcs.countries import country_dict
+from dcs.planes import plane_map
+from dcs.unittype import FlyingType, ShipType, VehicleType, UnitType
+from dcs.vehicles import Armor, Unarmed, Infantry, Artillery, AirDefence
+
+from game.data.building_data import (
+    WW2_ALLIES_BUILDINGS,
+    DEFAULT_AVAILABLE_BUILDINGS,
+    WW2_GERMANY_BUILDINGS,
+    WW2_FREE,
+)
+from game.data.doctrine import (
+    Doctrine,
+    MODERN_DOCTRINE,
+    COLDWAR_DOCTRINE,
+    WWII_DOCTRINE,
+)
+from pydcs_extensions.mod_units import MODDED_VEHICLES, MODDED_AIRPLANES
+
+
+@dataclass
+class Faction:
+
+    # Country used by this faction
+    country: str = field(default="")
+
+    # Nice name of the faction
+    name: str = field(default="")
+
+    # List of faction file authors
+    authors: str = field(default="")
+
+    # A description of the faction
+    description: str = field(default="")
+
+    # Available aircraft
+    aircrafts: List[Type[FlyingType]] = field(default_factory=list)
+
+    # Available awacs aircraft
+    awacs: List[Type[FlyingType]] = field(default_factory=list)
+
+    # Available tanker aircraft
+    tankers: List[Type[FlyingType]] = field(default_factory=list)
+
+    # Available frontline units
+    frontline_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Available artillery units
+    artillery_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Infantry units used
+    infantry_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Logistics units used
+    logistics_units: List[Type[VehicleType]] = field(default_factory=list)
+
+    # Possible SAMS site generators for this faction
+    air_defenses: List[str] = field(default_factory=list)
+
+    # Possible EWR generators for this faction.
+    ewrs: List[str] = field(default_factory=list)
+
+    # Possible Missile site generators for this faction
+    missiles: List[str] = field(default_factory=list)
+
+    # Possible costal site generators for this faction
+    coastal_defenses: List[str] = field(default_factory=list)
+
+    # Required mods or asset packs
+    requirements: Dict[str, str] = field(default_factory=dict)
+
+    # possible aircraft carrier units
+    aircraft_carrier: List[Type[UnitType]] = field(default_factory=list)
+
+    # possible helicopter carrier units
+    helicopter_carrier: List[Type[UnitType]] = field(default_factory=list)
+
+    # Possible carrier names
+    carrier_names: List[str] = field(default_factory=list)
+
+    # Possible helicopter carrier names
+    helicopter_carrier_names: List[str] = field(default_factory=list)
+
+    # Navy group generators
+    navy_generators: List[str] = field(default_factory=list)
+
+    # Available destroyers
+    destroyers: List[Type[ShipType]] = field(default_factory=list)
+
+    # Available cruisers
+    cruisers: List[Type[ShipType]] = field(default_factory=list)
+
+    # How many navy group should we try to generate per CP on startup for this faction
+    navy_group_count: int = field(default=1)
+
+    # How many missiles group should we try to generate per CP on startup for this faction
+    missiles_group_count: int = field(default=1)
+
+    # How many coastal group should we try to generate per CP on startup for this faction
+    coastal_group_count: int = field(default=1)
+
+    # Whether this faction has JTAC access
+    has_jtac: bool = field(default=False)
+
+    # Unit to use as JTAC for this faction
+    jtac_unit: Optional[Type[FlyingType]] = field(default=None)
+
+    # doctrine
+    doctrine: Doctrine = field(default=MODERN_DOCTRINE)
+
+    # List of available buildings for this faction
+    building_set: List[str] = field(default_factory=list)
+
+    # List of default livery overrides
+    liveries_overrides: Dict[Type[UnitType], List[str]] = field(default_factory=dict)
+
+    #: Set to True if the faction should force the "Unrestricted satnav" option
+    #: for the mission. This option enables GPS for capable aircraft regardless
+    #: of the time period or operator. For example, the CJTF "countries" don't
+    #: appear to have GPS capability, so they need this.
+    #:
+    #: Note that this option cannot be set per-side. If either faction needs it,
+    #: both will use it.
+    unrestricted_satnav: bool = False
+
+    @classmethod
+    def from_json(cls: Type[Faction], json: Dict[str, Any]) -> Faction:
+
+        faction = Faction()
+
+        faction.country = json.get("country", "/")
+        if faction.country not in [c.name for c in country_dict.values()]:
+            raise AssertionError(
+                'Faction\'s country ("{}") is not a valid DCS country ID'.format(
+                    faction.country
+                )
+            )
+
+        faction.name = json.get("name", "")
+        if not faction.name:
+            raise AssertionError("Faction has no valid name")
+
+        faction.authors = json.get("authors", "")
+        faction.description = json.get("description", "")
+
+        faction.aircrafts = load_all_aircraft(json.get("aircrafts", []))
+        faction.awacs = load_all_aircraft(json.get("awacs", []))
+        faction.tankers = load_all_aircraft(json.get("tankers", []))
+
+        faction.frontline_units = load_all_vehicles(json.get("frontline_units", []))
+        faction.artillery_units = load_all_vehicles(json.get("artillery_units", []))
+        faction.infantry_units = load_all_vehicles(json.get("infantry_units", []))
+        faction.logistics_units = load_all_vehicles(json.get("logistics_units", []))
+
+        faction.ewrs = json.get("ewrs", [])
+
+        faction.air_defenses = json.get("air_defenses", [])
+        # Compatibility for older factions. All air defenses now belong to a
+        # single group and the generator decides what belongs where.
+        faction.air_defenses.extend(json.get("sams", []))
+        faction.air_defenses.extend(json.get("shorads", []))
+
+        faction.missiles = json.get("missiles", [])
+        faction.coastal_defenses = json.get("coastal_defenses", [])
+        faction.requirements = json.get("requirements", {})
+
+        faction.carrier_names = json.get("carrier_names", [])
+        faction.helicopter_carrier_names = json.get("helicopter_carrier_names", [])
+        faction.navy_generators = json.get("navy_generators", [])
+        faction.aircraft_carrier = load_all_ships(json.get("aircraft_carrier", []))
+        faction.helicopter_carrier = load_all_ships(json.get("helicopter_carrier", []))
+        faction.destroyers = load_all_ships(json.get("destroyers", []))
+        faction.cruisers = load_all_ships(json.get("cruisers", []))
+        faction.has_jtac = json.get("has_jtac", False)
+        jtac_name = json.get("jtac_unit", None)
+        if jtac_name is not None:
+            faction.jtac_unit = load_aircraft(jtac_name)
+        else:
+            faction.jtac_unit = None
+        faction.navy_group_count = int(json.get("navy_group_count", 1))
+        faction.missiles_group_count = int(json.get("missiles_group_count", 0))
+        faction.coastal_group_count = int(json.get("coastal_group_count", 0))
+
+        # Load doctrine
+        doctrine = json.get("doctrine", "modern")
+        if doctrine == "modern":
+            faction.doctrine = MODERN_DOCTRINE
+        elif doctrine == "coldwar":
+            faction.doctrine = COLDWAR_DOCTRINE
+        elif doctrine == "ww2":
+            faction.doctrine = WWII_DOCTRINE
+        else:
+            faction.doctrine = MODERN_DOCTRINE
+
+        # Load the building set
+        building_set = json.get("building_set", "default")
+        if building_set == "default":
+            faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
+        elif building_set == "ww2free":
+            faction.building_set = WW2_FREE
+        elif building_set == "ww2ally":
+            faction.building_set = WW2_ALLIES_BUILDINGS
+        elif building_set == "ww2germany":
+            faction.building_set = WW2_GERMANY_BUILDINGS
+        else:
+            faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
+
+        # Load liveries override
+        faction.liveries_overrides = {}
+        liveries_overrides = json.get("liveries_overrides", {})
+        for k, v in liveries_overrides.items():
+            k = load_aircraft(k)
+            if k is not None:
+                faction.liveries_overrides[k] = [s.lower() for s in v]
+
+        faction.unrestricted_satnav = json.get("unrestricted_satnav", False)
+
+        return faction
+
+    @property
+    def units(self) -> List[Type[UnitType]]:
+        return (
+            self.infantry_units
+            + self.aircrafts
+            + self.awacs
+            + self.artillery_units
+            + self.frontline_units
+            + self.tankers
+            + self.logistics_units
+        )
+
+
+def unit_loader(unit: str, class_repository: List[Any]) -> Optional[Type[UnitType]]:
+    """
+    Find unit by name
+    :param unit: Unit name as string
+    :param class_repository: Repository of classes (Either a module, a class, or a list of classes)
+    :return: The unit as a PyDCS type
+    """
+    if unit is None:
+        return None
+    elif unit in plane_map.keys():
+        return plane_map[unit]
+    else:
+        for mother_class in class_repository:
+            if getattr(mother_class, unit, None) is not None:
+                return getattr(mother_class, unit)
+            if type(mother_class) is list:
+                for m in mother_class:
+                    if m.__name__ == unit:
+                        return m
+        logging.error(f"FACTION ERROR : Unable to find {unit} in pydcs")
+        return None
+
+
+def load_aircraft(name: str) -> Optional[Type[FlyingType]]:
+    return cast(
+        Optional[FlyingType],
+        unit_loader(name, [dcs.planes, dcs.helicopters, MODDED_AIRPLANES]),
+    )
+
+
+def load_all_aircraft(data) -> List[Type[FlyingType]]:
+    items = []
+    for name in data:
+        item = load_aircraft(name)
+        if item is not None:
+            items.append(item)
+    return items
+
+
+def load_vehicle(name: str) -> Optional[Type[VehicleType]]:
+    return cast(
+        Optional[FlyingType],
+        unit_loader(
+            name, [Infantry, Unarmed, Armor, AirDefence, Artillery, MODDED_VEHICLES]
+        ),
+    )
+
+
+def load_all_vehicles(data) -> List[Type[VehicleType]]:
+    items = []
+    for name in data:
+        item = load_vehicle(name)
+        if item is not None:
+            items.append(item)
+    return items
+
+
+def load_ship(name: str) -> Optional[Type[ShipType]]:
+    return cast(Optional[FlyingType], unit_loader(name, [dcs.ships]))
+
+
+def load_all_ships(data) -> List[Type[ShipType]]:
+    items = []
+    for name in data:
+        item = load_ship(name)
+        if item is not None:
+            items.append(item)
+    return items

game/factions/faction_loader.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import json
+import logging
+from pathlib import Path
+from typing import Dict, Iterator, Optional, Type
+
+from game.factions.faction import Faction
+
+FACTION_DIRECTORY = Path("./resources/factions/")
+
+
+class FactionLoader:
+    def __init__(self) -> None:
+        self._factions: Optional[Dict[str, Faction]] = None
+
+    @property
+    def factions(self) -> Dict[str, Faction]:
+        self.initialize()
+        assert self._factions is not None
+        return self._factions
+
+    def initialize(self) -> None:
+        if self._factions is None:
+            self._factions = self.load_factions()
+
+    @classmethod
+    def load_factions(cls: Type[FactionLoader]) -> Dict[str, Faction]:
+        files = [f for f in FACTION_DIRECTORY.glob("*.json") if f.is_file()]
+        factions = {}
+
+        for f in files:
+            try:
+                with f.open("r", encoding="utf-8") as fdata:
+                    data = json.load(fdata)
+                    factions[data["name"]] = Faction.from_json(data)
+                    logging.info("Loaded faction : " + str(f))
+            except Exception:
+                logging.exception(f"Unable to load faction : {f}")
+
+        return factions
+
+    def __getitem__(self, name: str) -> Faction:
+        return self.factions[name]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.factions.keys())

game/game.py

@@ -1,16 +1,41 @@
-import typing
+import itertools
+import logging
 import random
-import math
+import sys
+from datetime import date, datetime, timedelta
+from enum import Enum
+from typing import Any, Dict, List
 
-from dcs.task import *
-from dcs.vehicles import *
+from dcs.action import Coalition
+from dcs.mapping import Point
+from dcs.task import CAP, CAS, PinpointStrike
+from dcs.vehicles import AirDefence
 
-from userdata.debriefing import Debriefing
-from theater import *
-
-from . import db
+from game import db
+from game.inventory import GlobalAircraftInventory
+from game.models.game_stats import GameStats
+from game.plugins import LuaPluginManager
+from gen.ato import AirTaskingOrder
+from gen.conflictgen import Conflict
+from gen.flights.ai_flight_planner import CoalitionMissionPlanner
+from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.flights.flight import FlightType
+from gen.ground_forces.ai_ground_planner import GroundPlanner
+from . import persistency
+from .debriefing import Debriefing
+from .event.event import Event, UnitsDeliveryEvent
+from .event.frontlineattack import FrontlineAttackEvent
+from .factions.faction import Faction
+from .income import Income
+from .infos.information import Information
+from .navmesh import NavMesh
+from .procurement import ProcurementAi
 from .settings import Settings
-from .event import *
+from .theater import ConflictTheater, ControlPoint, TheaterGroundObject
+from game.theater.theatergroundobject import MissileSiteGroundObject
+from .threatzones import ThreatZones
+from .unitmap import UnitMap
+from .weather import Conditions, TimeOfDay
 
 COMMISION_UNIT_VARIETY = 4
 COMMISION_LIMITS_SCALE = 1.5
@@ -18,42 +43,20 @@ COMMISION_LIMITS_FACTORS = {
     PinpointStrike: 10,
     CAS: 5,
     CAP: 8,
-    AirDefence: 1,
+    AirDefence: 8,
 }
 
 COMMISION_AMOUNTS_SCALE = 1.5
 COMMISION_AMOUNTS_FACTORS = {
-    PinpointStrike: 2,
+    PinpointStrike: 3,
     CAS: 1,
     CAP: 2,
-    AirDefence: 0.3,
+    AirDefence: 0.8,
 }
 
-PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE = 25
+PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE = 30
 PLAYER_INTERCEPT_GLOBAL_PROBABILITY_LOG = 2
-
-"""
-Various events probabilities. First key is player probabilty, second is enemy probability.
-For the enemy events, only 1 event of each type could be generated for a turn.
-
-Events:
-* CaptureEvent - capture base
-* InterceptEvent - air intercept
-* GroundInterceptEvent - frontline CAS
-* GroundAttackEvent - destroy insurgents
-* NavalInterceptEvent - naval intercept
-* AntiAAStrikeEvent - anti-AA strike
-* InfantryTransportEvent - helicopter infantry transport
-"""
-EVENT_PROBABILITIES = {
-    CaptureEvent: [100, 10],
-    InterceptEvent: [25, 10],
-    GroundInterceptEvent: [25, 10],
-    GroundAttackEvent: [0, 10],
-    NavalInterceptEvent: [25, 10],
-    AntiAAStrikeEvent: [25, 10],
-    InfantryTransportEvent: [25, 0],
-}
+PLAYER_BASEATTACK_THRESHOLD = 0.4
 
 # amount of strength player bases recover for the turn
 PLAYER_BASE_STRENGTH_RECOVERY = 0.2
@@ -64,170 +67,485 @@ ENEMY_BASE_STRENGTH_RECOVERY = 0.05
 # cost of AWACS for single operation
 AWACS_BUDGET_COST = 4
 
-# Initial budget value
-PLAYER_BUDGET_INITIAL = 120
-# Base post-turn bonus value
-PLAYER_BUDGET_BASE = 10
 # Bonus multiplier logarithm base
 PLAYER_BUDGET_IMPORTANCE_LOG = 2
 
 
+class TurnState(Enum):
+    WIN = 0
+    LOSS = 1
+    CONTINUE = 2
+
+
 class Game:
-    settings = None  # type: Settings
-    budget = PLAYER_BUDGET_INITIAL
-    events = None  # type: typing.List[Event]
-    pending_transfers = None  # type: typing.Dict[]
-    ignored_cps = None  # type: typing.Collection[ControlPoint]
-
-    def __init__(self, player_name: str, enemy_name: str, theater: ConflictTheater):
-        self.settings = Settings()
-        self.events = []
+    def __init__(
+        self,
+        player_name: str,
+        enemy_name: str,
+        theater: ConflictTheater,
+        start_date: datetime,
+        settings: Settings,
+        player_budget: float,
+        enemy_budget: float,
+    ) -> None:
+        self.settings = settings
+        self.events: List[Event] = []
         self.theater = theater
-        self.player = player_name
-        self.enemy = enemy_name
+        self.player_name = player_name
+        self.player_country = db.FACTIONS[player_name].country
+        self.enemy_name = enemy_name
+        self.enemy_country = db.FACTIONS[enemy_name].country
+        self.turn = 0
+        # NB: This is the *start* date. It is never updated.
+        self.date = date(start_date.year, start_date.month, start_date.day)
+        self.game_stats = GameStats()
+        self.game_stats.update(self)
+        self.ground_planners: Dict[int, GroundPlanner] = {}
+        self.informations = []
+        self.informations.append(Information("Game Start", "-" * 40, 0))
+        # Culling Zones are for areas around points of interest that contain things we may not wish to cull.
+        self.__culling_zones: List[Point] = []
+        # Culling Points are for individual theater ground objects that we don't wish to cull.
+        self.__culling_points: List[Point] = []
+        self.__destroyed_units: List[str] = []
+        self.savepath = ""
+        self.budget = player_budget
+        self.enemy_budget = enemy_budget
+        self.current_unit_id = 0
+        self.current_group_id = 0
 
-    def _roll(self, prob, mult):
-        return random.randint(1, 100) <= prob * mult
+        self.conditions = self.generate_conditions()
 
-    def _generate_globalinterceptions(self):
-        global_count = len([x for x in self.theater.player_points() if x.is_global])
-        for from_cp in [x for x in self.theater.player_points() if x.is_global]:
-            probability_base = max(PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE / global_count, 1)
-            probability = probability_base * math.log(len(self.theater.player_points()) + 1, PLAYER_INTERCEPT_GLOBAL_PROBABILITY_LOG)
-            if self._roll(probability, from_cp.base.strength):
-                to_cp = random.choice([x for x in self.theater.enemy_points() if x not in self.theater.conflicts()])
-                self.events.append(InterceptEvent(attacker_name=self.player,
-                                                  defender_name=self.enemy,
-                                                  from_cp=from_cp,
-                                                  to_cp=to_cp,
-                                                  game=self))
-                break
+        self.blue_ato = AirTaskingOrder()
+        self.red_ato = AirTaskingOrder()
 
-    def _generate_events(self):
-        enemy_cap_generated = False
-        enemy_generated_types = []
+        self.aircraft_inventory = GlobalAircraftInventory(self.theater.controlpoints)
 
-        for player_cp, enemy_cp in self.theater.conflicts(True):
-            if player_cp.is_global or enemy_cp.is_global:
-                continue
+        self.sanitize_sides()
 
-            for event_class, (player_probability, enemy_probability) in EVENT_PROBABILITIES.items():
-                if self._roll(player_probability, player_cp.base.strength):
-                    if event_class == NavalInterceptEvent and enemy_cp.radials == LAND:
-                        pass
-                    else:
-                        self.events.append(event_class(self.player, self.enemy, player_cp, enemy_cp, self))
-                elif self._roll(enemy_probability, enemy_cp.base.strength):
-                    if event_class in enemy_generated_types:
-                        continue
+        self.on_load()
 
-                    if player_cp in self.ignored_cps:
-                        continue
+        # Turn 0 procurement. We don't actually have any missions to plan, but
+        # the planner will tell us what it would like to plan so we can use that
+        # to drive purchase decisions.
+        blue_planner = CoalitionMissionPlanner(self, is_player=True)
+        blue_planner.plan_missions()
 
-                    if enemy_cp.base.total_planes == 0:
-                        continue
+        red_planner = CoalitionMissionPlanner(self, is_player=False)
+        red_planner.plan_missions()
 
-                    if event_class == NavalInterceptEvent:
-                        if player_cp.radials == LAND:
-                            continue
-                    elif event_class == CaptureEvent:
-                        if enemy_cap_generated:
-                            continue
-                        if enemy_cp.base.total_armor == 0:
-                            continue
-                        enemy_cap_generated = True
-                    elif event_class == AntiAAStrikeEvent:
-                        if player_cp.base.total_aa == 0:
-                            continue
+        self.plan_procurement(blue_planner, red_planner)
 
-                    enemy_generated_types.append(event_class)
-                    self.events.append(event_class(self.enemy, self.player, enemy_cp, player_cp, self))
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+        # Avoid persisting any volatile types that can be deterministically
+        # recomputed on load for the sake of save compatibility.
+        del state["blue_threat_zone"]
+        del state["red_threat_zone"]
+        del state["blue_navmesh"]
+        del state["red_navmesh"]
+        return state
 
-    def commision_unit_types(self, cp: ControlPoint, for_task: Task) -> typing.Collection[UnitType]:
-        importance_factor = (cp.importance - IMPORTANCE_LOW) / (IMPORTANCE_HIGH - IMPORTANCE_LOW)
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        # Regenerate any state that was not persisted.
+        self.on_load()
 
-        if for_task == AirDefence and not self.settings.sams:
-            return [x for x in db.find_unittype(AirDefence, self.enemy) if x not in db.SAM_BAN]
-        else:
-            return db.choose_units(for_task, importance_factor, COMMISION_UNIT_VARIETY, self.enemy)
+    def generate_conditions(self) -> Conditions:
+        return Conditions.generate(
+            self.theater, self.current_day, self.current_turn_time_of_day, self.settings
+        )
 
-    def _commision_units(self, cp: ControlPoint):
-        for for_task in [PinpointStrike, CAS, CAP, AirDefence]:
-            limit = COMMISION_LIMITS_FACTORS[for_task] * math.pow(cp.importance, COMMISION_LIMITS_SCALE) * self.settings.multiplier
-            missing_units = limit - cp.base.total_units(for_task)
-            if missing_units > 0:
-                awarded_points = COMMISION_AMOUNTS_FACTORS[for_task] * math.pow(cp.importance, COMMISION_AMOUNTS_SCALE) * self.settings.multiplier
-                points_to_spend = cp.base.append_commision_points(for_task, awarded_points)
-                if points_to_spend > 0:
-                    unittypes = self.commision_unit_types(cp, for_task)
-                    d = {random.choice(unittypes): points_to_spend}
-                    print("Commision {}: {}".format(cp, d))
-                    cp.base.commision_units(d)
+    def sanitize_sides(self):
+        """
+        Make sure the opposing factions are using different countries
+        :return:
+        """
+        if self.player_country == self.enemy_country:
+            if self.player_country == "USA":
+                self.enemy_country = "USAF Aggressors"
+            elif self.player_country == "Russia":
+                self.enemy_country = "USSR"
+            else:
+                self.enemy_country = "Russia"
 
     @property
-    def budget_reward_amount(self):
-        if len(self.theater.player_points()) > 0:
-            total_importance = sum([x.importance * x.base.strength for x in self.theater.player_points()])
-            return math.ceil(math.log(total_importance + 1, PLAYER_BUDGET_IMPORTANCE_LOG) * PLAYER_BUDGET_BASE * self.settings.multiplier)
+    def player_faction(self) -> Faction:
+        return db.FACTIONS[self.player_name]
+
+    @property
+    def enemy_faction(self) -> Faction:
+        return db.FACTIONS[self.enemy_name]
+
+    def faction_for(self, player: bool) -> Faction:
+        if player:
+            return self.player_faction
+        return self.enemy_faction
+
+    def _roll(self, prob, mult):
+        if self.settings.version == "dev":
+            # always generate all events for dev
+            return 100
         else:
-            return 0
+            return random.randint(1, 100) <= prob * mult
 
-    def _budget_player(self):
-        self.budget += self.budget_reward_amount
+    def _generate_player_event(self, event_class, player_cp, enemy_cp):
+        self.events.append(
+            event_class(
+                self,
+                player_cp,
+                enemy_cp,
+                enemy_cp.position,
+                self.player_name,
+                self.enemy_name,
+            )
+        )
 
-    def awacs_expense_commit(self):
-        self.budget -= AWACS_BUDGET_COST
+    def _generate_events(self):
+        for front_line in self.theater.conflicts(True):
+            self._generate_player_event(
+                FrontlineAttackEvent,
+                front_line.control_point_a,
+                front_line.control_point_b,
+            )
 
-    def units_delivery_event(self, to_cp: ControlPoint) -> UnitsDeliveryEvent:
-        event = UnitsDeliveryEvent(attacker_name=self.player,
-                                   defender_name=self.player,
-                                   from_cp=to_cp,
-                                   to_cp=to_cp,
-                                   game=self)
-        self.events.append(event)
-        return event
+    def adjust_budget(self, amount: float, player: bool) -> None:
+        if player:
+            self.budget += amount
+        else:
+            self.enemy_budget += amount
 
-    def units_delivery_remove(self, event: Event):
-        if event in self.events:
-            self.events.remove(event)
+    def process_player_income(self):
+        self.budget += Income(self, player=True).total
 
-    def initiate_event(self, event: Event):
-        assert event in self.events
+    def process_enemy_income(self):
+        # TODO: Clean up save compat.
+        if not hasattr(self, "enemy_budget"):
+            self.enemy_budget = 0
+        self.enemy_budget += Income(self, player=False).total
 
-        event.generate()
-        event.generate_quick()
+    def initiate_event(self, event: Event) -> UnitMap:
+        # assert event in self.events
+        logging.info("Generating {} (regular)".format(event))
+        return event.generate()
 
     def finish_event(self, event: Event, debriefing: Debriefing):
+        logging.info("Finishing event {}".format(event))
         event.commit(debriefing)
-        if event.is_successfull(debriefing):
-            self.budget += event.bonus()
 
         if event in self.events:
             self.events.remove(event)
         else:
-            print("finish_event: event not in the events!")
+            logging.info("finish_event: event not in the events!")
 
-    def is_player_attack(self, event: Event):
-        return event.attacker_name == self.player
+    def is_player_attack(self, event):
+        if isinstance(event, Event):
+            return (
+                event
+                and event.attacker_name
+                and event.attacker_name == self.player_name
+            )
+        else:
+            raise RuntimeError(f"{event} was passed when an Event type was expected")
 
-    def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint]=None):
-        for event in self.events:
-            event.skip()
+    def on_load(self) -> None:
+        LuaPluginManager.load_settings(self.settings)
+        ObjectiveDistanceCache.set_theater(self.theater)
+        self.compute_conflicts_position()
+        self.compute_threat_zones()
 
-        if not no_action:
-            self._budget_player()
+    def pass_turn(self, no_action: bool = False) -> None:
+        logging.info("Pass turn")
+        self.informations.append(
+            Information("End of turn #" + str(self.turn), "-" * 40, 0)
+        )
+        self.turn += 1
 
-            for cp in self.theater.enemy_points():
-                self._commision_units(cp)
+        for control_point in self.theater.controlpoints:
+            control_point.process_turn(self)
 
+        self.process_enemy_income()
+
+        self.process_player_income()
+
+        if not no_action and self.turn > 1:
             for cp in self.theater.player_points():
                 cp.base.affect_strength(+PLAYER_BASE_STRENGTH_RECOVERY)
+        else:
+            for cp in self.theater.player_points():
+                if not cp.is_carrier and not cp.is_lha:
+                    cp.base.affect_strength(-PLAYER_BASE_STRENGTH_RECOVERY)
 
-        self.ignored_cps = []
-        if ignored_cps:
-            self.ignored_cps = ignored_cps
+        self.conditions = self.generate_conditions()
 
-        self.events = []  # type: typing.List[Event]
+        self.initialize_turn()
+
+        # Autosave progress
+        persistency.autosave(self)
+
+    def check_win_loss(self):
+        player_airbases = {
+            cp for cp in self.theater.player_points() if cp.runway_is_operational()
+        }
+        if not player_airbases:
+            return TurnState.LOSS
+
+        enemy_airbases = {
+            cp for cp in self.theater.enemy_points() if cp.runway_is_operational()
+        }
+        if not enemy_airbases:
+            return TurnState.WIN
+
+        return TurnState.CONTINUE
+
+    def initialize_turn(self) -> None:
+        self.events = []
         self._generate_events()
-        self._generate_globalinterceptions()
 
+        # Update statistics
+        self.game_stats.update(self)
+
+        self.aircraft_inventory.reset()
+        for cp in self.theater.controlpoints:
+            self.aircraft_inventory.set_from_control_point(cp)
+
+        # Check for win or loss condition
+        turn_state = self.check_win_loss()
+        if turn_state in (TurnState.LOSS, TurnState.WIN):
+            return self.process_win_loss(turn_state)
+
+        # Plan flights & combat for next turn
+        self.compute_conflicts_position()
+        self.compute_threat_zones()
+        self.ground_planners = {}
+        self.blue_ato.clear()
+        self.red_ato.clear()
+
+        blue_planner = CoalitionMissionPlanner(self, is_player=True)
+        blue_planner.plan_missions()
+
+        red_planner = CoalitionMissionPlanner(self, is_player=False)
+        red_planner.plan_missions()
+
+        for cp in self.theater.controlpoints:
+            if cp.has_frontline:
+                gplanner = GroundPlanner(cp, self)
+                gplanner.plan_groundwar()
+                self.ground_planners[cp.id] = gplanner
+
+        self.plan_procurement(blue_planner, red_planner)
+
+    def plan_procurement(
+        self,
+        blue_planner: CoalitionMissionPlanner,
+        red_planner: CoalitionMissionPlanner,
+    ) -> None:
+        # The first turn needs to buy a *lot* of aircraft to fill CAPs, so it
+        # gets much more of the budget that turn. Otherwise budget (after
+        # repairs) is split evenly between air and ground. For the default
+        # starting budget of 2000 this gives 600 to ground forces and 1400 to
+        # aircraft.
+        ground_portion = 0.3 if self.turn == 0 else 0.5
+        self.budget = ProcurementAi(
+            self,
+            for_player=True,
+            faction=self.player_faction,
+            manage_runways=self.settings.automate_runway_repair,
+            manage_front_line=self.settings.automate_front_line_reinforcements,
+            manage_aircraft=self.settings.automate_aircraft_reinforcements,
+            front_line_budget_share=ground_portion,
+        ).spend_budget(self.budget, blue_planner.procurement_requests)
+
+        self.enemy_budget = ProcurementAi(
+            self,
+            for_player=False,
+            faction=self.enemy_faction,
+            manage_runways=True,
+            manage_front_line=True,
+            manage_aircraft=True,
+            front_line_budget_share=ground_portion,
+        ).spend_budget(self.enemy_budget, red_planner.procurement_requests)
+
+    def message(self, text: str) -> None:
+        self.informations.append(Information(text, turn=self.turn))
+
+    @property
+    def current_turn_time_of_day(self) -> TimeOfDay:
+        return list(TimeOfDay)[self.turn % 4]
+
+    @property
+    def current_day(self) -> date:
+        return self.date + timedelta(days=self.turn // 4)
+
+    def next_unit_id(self):
+        """
+        Next unit id for pre-generated units
+        """
+        self.current_unit_id += 1
+        return self.current_unit_id
+
+    def next_group_id(self):
+        """
+        Next unit id for pre-generated units
+        """
+        self.current_group_id += 1
+        return self.current_group_id
+
+    def compute_threat_zones(self) -> None:
+        self.blue_threat_zone = ThreatZones.for_faction(self, player=True)
+        self.red_threat_zone = ThreatZones.for_faction(self, player=False)
+        self.blue_navmesh = NavMesh.from_threat_zones(
+            self.red_threat_zone, self.theater
+        )
+        self.red_navmesh = NavMesh.from_threat_zones(
+            self.blue_threat_zone, self.theater
+        )
+
+    def threat_zone_for(self, player: bool) -> ThreatZones:
+        if player:
+            return self.blue_threat_zone
+        return self.red_threat_zone
+
+    def navmesh_for(self, player: bool) -> NavMesh:
+        if player:
+            return self.blue_navmesh
+        return self.red_navmesh
+
+    def compute_conflicts_position(self):
+        """
+        Compute the current conflict center position(s), mainly used for culling calculation
+        :return: List of points of interests
+        """
+        zones = []
+        points = []
+
+        # By default, use the existing frontline conflict position
+        for front_line in self.theater.conflicts():
+            position = Conflict.frontline_position(
+                front_line.control_point_a, front_line.control_point_b, self.theater
+            )
+            zones.append(position[0])
+            zones.append(front_line.control_point_a.position)
+            zones.append(front_line.control_point_b.position)
+
+        for cp in self.theater.controlpoints:
+            # Don't cull missile sites - their range is long enough to make them
+            # easily culled despite being a threat.
+            for tgo in cp.ground_objects:
+                if isinstance(tgo, MissileSiteGroundObject):
+                    points.append(tgo.position)
+            # If do_not_cull_carrier is enabled, add carriers as culling point
+            if self.settings.perf_do_not_cull_carrier:
+                if cp.is_carrier or cp.is_lha:
+                    zones.append(cp.position)
+
+        # If there is no conflict take the center point between the two nearest opposing bases
+        if len(zones) == 0:
+            cpoint = None
+            min_distance = sys.maxsize
+            for cp in self.theater.player_points():
+                for cp2 in self.theater.enemy_points():
+                    d = cp.position.distance_to_point(cp2.position)
+                    if d < min_distance:
+                        min_distance = d
+                        cpoint = Point(
+                            (cp.position.x + cp2.position.x) / 2,
+                            (cp.position.y + cp2.position.y) / 2,
+                        )
+                        zones.append(cp.position)
+                        zones.append(cp2.position)
+                        break
+                if cpoint is not None:
+                    break
+            if cpoint is not None:
+                zones.append(cpoint)
+
+        packages = itertools.chain(self.blue_ato.packages, self.red_ato.packages)
+        for package in packages:
+            if package.primary_task is FlightType.BARCAP:
+                # BARCAPs will be planned at most locations on smaller theaters,
+                # rendering culling fairly useless. BARCAP packages don't really
+                # need the ground detail since they're defensive. SAMs nearby
+                # are only interesting if there are enemies in the area, and if
+                # there are they won't be culled because of the enemy's mission.
+                continue
+            zones.append(package.target.position)
+
+        # Else 0,0, since we need a default value
+        # (in this case this means the whole map is owned by the same player, so it is not an issue)
+        if len(zones) == 0:
+            zones.append(Point(0, 0))
+
+        self.__culling_zones = zones
+        self.__culling_points = points
+
+    def add_destroyed_units(self, data):
+        pos = Point(data["x"], data["z"])
+        if self.theater.is_on_land(pos):
+            self.__destroyed_units.append(data)
+
+    def get_destroyed_units(self):
+        return self.__destroyed_units
+
+    def position_culled(self, pos):
+        """
+        Check if unit can be generated at given position depending on culling performance settings
+        :param pos: Position you are tryng to spawn stuff at
+        :return: True if units can not be added at given position
+        """
+        if self.settings.perf_culling == False:
+            return False
+        else:
+            for z in self.__culling_zones:
+                if (
+                    z.distance_to_point(pos)
+                    < self.settings.perf_culling_distance * 1000
+                ):
+                    return False
+            for p in self.__culling_points:
+                if p.distance_to_point(pos) < 2500:
+                    return False
+            return True
+
+    def get_culling_zones(self):
+        """
+        Check culling points
+        :return: List of culling zones
+        """
+        return self.__culling_zones
+
+    def get_culling_points(self):
+        """
+        Check culling points
+        :return: List of culling points
+        """
+        return self.__culling_points
+
+    # 1 = red, 2 = blue
+    def get_player_coalition_id(self):
+        return 2
+
+    def get_enemy_coalition_id(self):
+        return 1
+
+    def get_player_coalition(self):
+        return Coalition.Blue
+
+    def get_enemy_coalition(self):
+        return Coalition.Red
+
+    def get_player_color(self):
+        return "blue"
+
+    def get_enemy_color(self):
+        return "red"
+
+    def process_win_loss(self, turn_state: TurnState):
+        if turn_state is TurnState.WIN:
+            return self.message(
+                "Congratulations, you are victorious!  Start a new campaign to continue."
+            )
+        elif turn_state is TurnState.LOSS:
+            return self.message(
+                "Game Over, you lose. Start a new campaign to continue."
+            )

game/income.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from game.db import REWARDS
+
+if TYPE_CHECKING:
+    from game import Game
+
+
+@dataclass(frozen=True)
+class BuildingIncome:
+    name: str
+    category: str
+    number: int
+    income_per_building: int
+
+    @property
+    def income(self) -> int:
+        return self.number * self.income_per_building
+
+
+class Income:
+    def __init__(self, game: Game, player: bool) -> None:
+        if player:
+            self.multiplier = game.settings.player_income_multiplier
+        else:
+            self.multiplier = game.settings.enemy_income_multiplier
+        self.control_points = []
+        self.buildings = []
+
+        names = set()
+        for cp in game.theater.control_points_for(player):
+            if cp.income_per_turn:
+                self.control_points.append(cp)
+            for tgo in cp.ground_objects:
+                names.add(tgo.obj_name)
+
+        for name in names:
+            count = 0
+            tgos = game.theater.find_ground_objects_by_obj_name(name)
+            category = tgos[0].category
+            if category not in REWARDS:
+                continue
+            for tgo in tgos:
+                if not tgo.is_dead:
+                    count += 1
+            self.buildings.append(
+                BuildingIncome(name, category, count, REWARDS[category])
+            )
+
+        self.from_bases = sum(cp.income_per_turn for cp in self.control_points)
+        self.total_buildings = sum(b.income for b in self.buildings)
+        self.total = (self.total_buildings + self.from_bases) * self.multiplier

game/infos/information.py

@@ -0,0 +1,19 @@
+import datetime
+
+
+class Information:
+    def __init__(self, title="", text="", turn=0):
+        self.title = title
+        self.text = text
+        self.turn = turn
+        self.timestamp = datetime.datetime.now()
+
+    def __str__(self):
+        return "[{}][{}] {} {}".format(
+            self.timestamp.strftime("%Y-%m-%d %H:%M:%S")
+            if self.timestamp is not None
+            else "",
+            self.turn,
+            self.title,
+            self.text,
+        )

game/inventory.py

@@ -0,0 +1,130 @@
+"""Inventory management APIs."""
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Dict, Iterable, Iterator, Set, Tuple, TYPE_CHECKING, Type
+
+from dcs.unittype import FlyingType
+
+from gen.flights.flight import Flight
+
+if TYPE_CHECKING:
+    from game.theater import ControlPoint
+
+
+class ControlPointAircraftInventory:
+    """Aircraft inventory for a single control point."""
+
+    def __init__(self, control_point: ControlPoint) -> None:
+        self.control_point = control_point
+        self.inventory: Dict[Type[FlyingType], int] = defaultdict(int)
+
+    def add_aircraft(self, aircraft: Type[FlyingType], count: int) -> None:
+        """Adds aircraft to the inventory.
+
+        Args:
+            aircraft: The type of aircraft to add.
+            count: The number of aircraft to add.
+        """
+        self.inventory[aircraft] += count
+
+    def remove_aircraft(self, aircraft: Type[FlyingType], count: int) -> None:
+        """Removes aircraft from the inventory.
+
+        Args:
+            aircraft: The type of aircraft to remove.
+            count: The number of aircraft to remove.
+
+        Raises:
+            ValueError: The control point cannot fulfill the requested number of
+            aircraft.
+        """
+        available = self.inventory[aircraft]
+        if available < count:
+            raise ValueError(
+                f"Cannot remove {count} {aircraft.id} from "
+                f"{self.control_point.name}. Only have {available}."
+            )
+        self.inventory[aircraft] -= count
+
+    def available(self, aircraft: Type[FlyingType]) -> int:
+        """Returns the number of available aircraft of the given type.
+
+        Args:
+            aircraft: The type of aircraft to query.
+        """
+        try:
+            return self.inventory[aircraft]
+        except KeyError:
+            return 0
+
+    @property
+    def types_available(self) -> Iterator[Type[FlyingType]]:
+        """Iterates over all available aircraft types."""
+        for aircraft, count in self.inventory.items():
+            if count > 0:
+                yield aircraft
+
+    @property
+    def all_aircraft(self) -> Iterator[Tuple[Type[FlyingType], int]]:
+        """Iterates over all available aircraft types, including amounts."""
+        for aircraft, count in self.inventory.items():
+            if count > 0:
+                yield aircraft, count
+
+    def clear(self) -> None:
+        """Clears all aircraft from the inventory."""
+        self.inventory.clear()
+
+
+class GlobalAircraftInventory:
+    """Game-wide aircraft inventory."""
+
+    def __init__(self, control_points: Iterable[ControlPoint]) -> None:
+        self.inventories: Dict[ControlPoint, ControlPointAircraftInventory] = {
+            cp: ControlPointAircraftInventory(cp) for cp in control_points
+        }
+
+    def reset(self) -> None:
+        """Clears all control points and their inventories."""
+        for inventory in self.inventories.values():
+            inventory.clear()
+
+    def set_from_control_point(self, control_point: ControlPoint) -> None:
+        """Set the control point's aircraft inventory.
+
+        If the inventory for the given control point has already been set for
+        the turn, it will be overwritten.
+        """
+        inventory = self.inventories[control_point]
+        for aircraft, count in control_point.base.aircraft.items():
+            inventory.add_aircraft(aircraft, count)
+
+    def for_control_point(
+        self, control_point: ControlPoint
+    ) -> ControlPointAircraftInventory:
+        """Returns the inventory specific to the given control point."""
+        return self.inventories[control_point]
+
+    @property
+    def available_types_for_player(self) -> Iterator[Type[FlyingType]]:
+        """Iterates over all aircraft types available to the player."""
+        seen: Set[Type[FlyingType]] = set()
+        for control_point, inventory in self.inventories.items():
+            if control_point.captured:
+                for aircraft in inventory.types_available:
+                    if not control_point.can_operate(aircraft):
+                        continue
+                    if aircraft not in seen:
+                        seen.add(aircraft)
+                        yield aircraft
+
+    def claim_for_flight(self, flight: Flight) -> None:
+        """Removes aircraft from the inventory for the given flight."""
+        inventory = self.for_control_point(flight.from_cp)
+        inventory.remove_aircraft(flight.unit_type, flight.count)
+
+    def return_from_flight(self, flight: Flight) -> None:
+        """Returns a flight's aircraft to the inventory."""
+        inventory = self.for_control_point(flight.from_cp)
+        inventory.add_aircraft(flight.unit_type, flight.count)

game/models/destroyed_units.py

@@ -0,0 +1,13 @@
+class DestroyedUnit:
+    """
+    Store info about a destroyed unit
+    """
+
+    x: int
+    y: int
+    name: str
+
+    def __init__(self, x, y, name):
+        self.x = x
+        self.y = y
+        self.name = name

game/models/frontline_data.py

@@ -0,0 +1,13 @@
+from game.theater import ControlPoint
+
+
+class FrontlineData:
+    """
+    This Data structure will store information about an existing frontline
+    """
+
+    def __init__(self, from_cp: ControlPoint, to_cp: ControlPoint):
+        self.to_cp = to_cp
+        self.from_cp = from_cp
+        self.enemy_units_position = []
+        self.blue_units_position = []

game/models/game_stats.py

@@ -0,0 +1,56 @@
+from typing import List
+
+
+class FactionTurnMetadata:
+    """
+    Store metadata about a faction
+    """
+
+    aircraft_count: int = 0
+    vehicles_count: int = 0
+    sam_count: int = 0
+
+    def __init__(self):
+        self.aircraft_count = 0
+        self.vehicles_count = 0
+        self.sam_count = 0
+
+
+class GameTurnMetadata:
+    """
+    Store metadata about a game turn
+    """
+
+    allied_units: FactionTurnMetadata
+    enemy_units: FactionTurnMetadata
+
+    def __init__(self):
+        self.allied_units = FactionTurnMetadata()
+        self.enemy_units = FactionTurnMetadata()
+
+
+class GameStats:
+    """
+    Store statistics for the current game
+    """
+
+    def __init__(self):
+        self.data_per_turn: List[GameTurnMetadata] = []
+
+    def update(self, game):
+        """
+        Save data for current turn
+        :param game: Game we want to save the data about
+        """
+
+        turn_data = GameTurnMetadata()
+
+        for cp in game.theater.controlpoints:
+            if cp.captured:
+                turn_data.allied_units.aircraft_count += sum(cp.base.aircraft.values())
+                turn_data.allied_units.vehicles_count += sum(cp.base.armor.values())
+            else:
+                turn_data.enemy_units.aircraft_count += sum(cp.base.aircraft.values())
+                turn_data.enemy_units.vehicles_count += sum(cp.base.armor.values())
+
+        self.data_per_turn.append(turn_data)

game/navmesh.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import heapq
+import math
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Tuple, Union
+
+from dcs.mapping import Point
+from shapely.geometry import (
+    LineString,
+    MultiPolygon,
+    Point as ShapelyPoint,
+    Polygon,
+    box,
+)
+from shapely.ops import nearest_points, triangulate
+
+from game.theater import ConflictTheater
+from game.threatzones import ThreatZones
+from game.utils import nautical_miles
+
+
+class NavMeshError(RuntimeError):
+    pass
+
+
+class NavMeshPoly:
+    def __init__(self, ident: int, poly: Polygon, threatened: bool) -> None:
+        self.ident = ident
+        self.poly = poly
+        self.threatened = threatened
+        self.neighbors: Dict[NavMeshPoly, Union[LineString, ShapelyPoint]] = {}
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NavMeshPoly):
+            return False
+        return self.ident == other.ident
+
+    def __hash__(self) -> int:
+        return self.ident
+
+
+@dataclass(frozen=True)
+class NavPoint:
+    point: ShapelyPoint
+    poly: NavMeshPoly
+
+    @property
+    def world_point(self) -> Point:
+        return Point(self.point.x, self.point.y)
+
+    def __hash__(self) -> int:
+        return hash(self.poly.ident)
+
+    def __eq__(self, other: object) -> bool:
+        if id(self) == id(other):
+            return True
+
+        if not isinstance(other, NavPoint):
+            return False
+
+        if not self.point.almost_equals(other.point):
+            return False
+
+        return self.poly == other.poly
+
+    def __str__(self) -> str:
+        return f"{self.point} in {self.poly.ident}"
+
+
+@dataclass(frozen=True, order=True)
+class FrontierNode:
+    cost: float
+    point: NavPoint = field(compare=False)
+
+
+class NavFrontier:
+    def __init__(self) -> None:
+        self.nodes: List[FrontierNode] = []
+
+    def push(self, poly: NavPoint, cost: float) -> None:
+        heapq.heappush(self.nodes, FrontierNode(cost, poly))
+
+    def pop(self) -> Optional[NavPoint]:
+        try:
+            return heapq.heappop(self.nodes).point
+        except IndexError:
+            return None
+
+
+class NavMesh:
+    def __init__(self, polys: List[NavMeshPoly]) -> None:
+        self.polys = polys
+
+    def localize(self, point: Point) -> Optional[NavMeshPoly]:
+        # This is a naive implementation but it's O(n). Runs at about 10k
+        # lookups a second on a 5950X. Flights usually have 5-10 waypoints, so
+        # that's 1k-2k flights before we lose a full second to localization as a
+        # part of flight plan creation.
+        #
+        # Can improve the algorithm later if needed, but that seems unnecessary
+        # currently.
+        p = ShapelyPoint(point.x, point.y)
+        for navpoly in self.polys:
+            if navpoly.poly.contains(p):
+                return navpoly
+        return None
+
+    @staticmethod
+    def travel_cost(a: NavPoint, b: NavPoint) -> float:
+        modifier = 1.0
+        if a.poly.threatened:
+            modifier = 3.0
+        return a.point.distance(b.point) * modifier
+
+    def travel_heuristic(self, a: NavPoint, b: NavPoint) -> float:
+        return self.travel_cost(a, b)
+
+    @staticmethod
+    def reconstruct_path(
+        came_from: Dict[NavPoint, Optional[NavPoint]],
+        origin: NavPoint,
+        destination: NavPoint,
+    ) -> List[Point]:
+        current = destination
+        path: List[Point] = []
+        while current != origin:
+            path.append(current.world_point)
+            previous = came_from[current]
+            if previous is None:
+                raise NavMeshError(
+                    f"Could not reconstruct path to {destination} from {origin}"
+                )
+            current = previous
+        path.append(origin.world_point)
+        path.reverse()
+        return path
+
+    @staticmethod
+    def dcs_to_shapely_point(point: Point) -> ShapelyPoint:
+        return ShapelyPoint(point.x, point.y)
+
+    def shortest_path(self, origin: Point, destination: Point) -> List[Point]:
+        origin_poly = self.localize(origin)
+        if origin_poly is None:
+            raise NavMeshError(f"Origin point {origin} is outside the navmesh")
+        destination_poly = self.localize(destination)
+        if destination_poly is None:
+            raise NavMeshError(
+                f"Destination point {destination} is outside the navmesh"
+            )
+
+        return self._shortest_path(
+            NavPoint(self.dcs_to_shapely_point(origin), origin_poly),
+            NavPoint(self.dcs_to_shapely_point(destination), destination_poly),
+        )
+
+    def _shortest_path(self, origin: NavPoint, destination: NavPoint) -> List[Point]:
+        # Adapted from
+        # https://www.redblobgames.com/pathfinding/a-star/implementation.py.
+        frontier = NavFrontier()
+        frontier.push(origin, 0.0)
+        came_from: Dict[NavPoint, Optional[NavPoint]] = {origin: None}
+
+        best_known: Dict[NavPoint, float] = defaultdict(lambda: math.inf)
+        best_known[origin] = 0.0
+
+        while (current := frontier.pop()) is not None:
+            if current == destination:
+                break
+
+            if current.poly == destination.poly:
+                # Made it to the correct nav poly. Add the leg from the border
+                # to the target.
+                cost = best_known[current] + self.travel_cost(current, destination)
+                if cost < best_known[destination]:
+                    best_known[destination] = cost
+                    estimated = cost
+                    frontier.push(destination, estimated)
+                    came_from[destination] = current
+
+            for neighbor, boundary in current.poly.neighbors.items():
+                previous = came_from[current]
+                if previous is not None and previous.poly == neighbor:
+                    # Don't backtrack.
+                    continue
+                if previous is None and current != origin:
+                    raise RuntimeError
+                _, neighbor_point = nearest_points(current.point, boundary)
+                neighbor_nav = NavPoint(neighbor_point, neighbor)
+                cost = best_known[current] + self.travel_cost(current, neighbor_nav)
+                if cost < best_known[neighbor_nav]:
+                    best_known[neighbor_nav] = cost
+                    estimated = cost + self.travel_heuristic(neighbor_nav, destination)
+                    frontier.push(neighbor_nav, estimated)
+                    came_from[neighbor_nav] = current
+
+        return self.reconstruct_path(came_from, origin, destination)
+
+    @staticmethod
+    def map_bounds(theater: ConflictTheater) -> Polygon:
+        points = []
+        for cp in theater.controlpoints:
+            points.append(ShapelyPoint(cp.position.x, cp.position.y))
+            for tgo in cp.ground_objects:
+                points.append(ShapelyPoint(tgo.position.x, tgo.position.y))
+        # Needs to be a large enough boundary beyond the known points so that
+        # threatened airbases at the map edges have room to retreat from the
+        # threat without running off the navmesh.
+        return box(*LineString(points).bounds).buffer(
+            nautical_miles(200).meters, resolution=1
+        )
+
+    @staticmethod
+    def create_navpolys(
+        polys: List[Polygon], threat_zones: ThreatZones
+    ) -> List[NavMeshPoly]:
+        return [
+            NavMeshPoly(i, p, threat_zones.threatened(p)) for i, p in enumerate(polys)
+        ]
+
+    @staticmethod
+    def associate_neighbors(polys: List[NavMeshPoly]) -> None:
+        # Maps (rounded) points to polygons that have a vertex at that point.
+        # The points are rounded to the nearest int so we can use them as dict
+        # keys. This allows us to perform approximate neighbor lookups more
+        # efficiently than comparing each poly to every other poly by finding
+        # approximate neighbors before checking if the polys actually touch.
+        points_map: Dict[Tuple[int, int], Set[NavMeshPoly]] = defaultdict(set)
+
+        for navpoly in polys:
+            # The coordinates of the polygon's boundary are a sequence of
+            # coordinates that define the polygon. The first point is repeated
+            # at the end, so skip the last vertex.
+            for x, y in navpoly.poly.boundary.coords[:-1]:
+                point = (int(x), int(y))
+                neighbors = {}
+                for potential_neighbor in points_map[point]:
+                    intersection = navpoly.poly.intersection(potential_neighbor.poly)
+                    if not intersection.is_empty:
+                        potential_neighbor.neighbors[navpoly] = intersection
+                        neighbors[potential_neighbor] = intersection
+                navpoly.neighbors.update(neighbors)
+                points_map[point].add(navpoly)
+
+    @classmethod
+    def from_threat_zones(
+        cls, threat_zones: ThreatZones, theater: ConflictTheater
+    ) -> NavMesh:
+        # Simplify the threat poly to reduce the number of nav zones. Increase
+        # the size of the zone and then simplify it with the buffer size as the
+        # error margin. This will create a simpler poly around the threat zone.
+        buffer = nautical_miles(10).meters
+        threat_poly = threat_zones.all.buffer(buffer).simplify(buffer)
+
+        # Threat zones can be disconnected. Create a list of threat zones.
+        if isinstance(threat_poly, MultiPolygon):
+            polys = list(threat_poly.geoms)
+        else:
+            polys = [threat_poly]
+
+        # Subtract the threat zones from the whole-map poly to build a navmesh
+        # for the *safe* areas. Navigation within threatened regions is always
+        # a straight line to the target or out of the threatened region.
+        bounds = cls.map_bounds(theater)
+        for poly in polys:
+            bounds = bounds.difference(poly)
+
+        # Triangulate the safe-region to build the navmesh.
+        navpolys = cls.create_navpolys(triangulate(bounds), threat_zones)
+        cls.associate_neighbors(navpolys)
+        return cls(navpolys)

game/operation/antiaastrike.py

@@ -1,53 +0,0 @@
-from dcs.terrain import Terrain
-
-from game import db
-from gen.armor import *
-from gen.aircraft import *
-from gen.aaa import *
-from gen.shipgen import *
-from gen.triggergen import *
-from gen.awacsgen import *
-from gen.visualgen import *
-from gen.conflictgen import Conflict
-
-from .operation import Operation
-
-
-class AntiAAStrikeOperation(Operation):
-    strikegroup = None  # type: db.PlaneDict
-    interceptors = None  # type: db.PlaneDict
-    target = None  # type: db.ArmorDict
-
-    def setup(self,
-              target: db.ArmorDict,
-              strikegroup: db.PlaneDict,
-              interceptors: db.PlaneDict):
-        self.strikegroup = strikegroup
-        self.interceptors = interceptors
-        self.target = target
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(AntiAAStrikeOperation, self).prepare(terrain, is_quick)
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
-
-        conflict = Conflict.ground_base_attack(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_cas_strikegroup(self.strikegroup, clients=self.attacker_clients, at=self.attackers_starting_position)
-
-        if self.interceptors:
-            self.airgen.generate_defense(self.interceptors, clients=self.defender_clients, at=self.defenders_starting_position)
-
-        self.armorgen.generate({}, self.target)
-        super(AntiAAStrikeOperation, self).generate()

game/operation/capture.py

@@ -1,67 +0,0 @@
-from game import db
-
-from gen.conflictgen import Conflict
-from gen.armor import *
-from gen.aircraft import *
-from gen.aaa import *
-from gen.shipgen import *
-from gen.triggergen import *
-from gen.awacsgen import *
-from gen.visualgen import *
-
-from .operation import Operation
-
-
-class CaptureOperation(Operation):
-    cas = None  # type: db.PlaneDict
-    escort = None  # type: db.PlaneDict
-    intercept = None  # type: db.PlaneDict
-    attack = None  # type: db.ArmorDict
-    defense = None  # type: db.ArmorDict
-    aa = None  # type: db.AirDefenseDict
-
-    trigger_radius = TRIGGER_RADIUS_SMALL
-
-    def setup(self,
-              cas: db.PlaneDict,
-              escort: db.PlaneDict,
-              attack: db.ArmorDict,
-              intercept: db.PlaneDict,
-              defense: db.ArmorDict,
-              aa: db.AirDefenseDict):
-        self.cas = cas
-        self.escort = escort
-        self.intercept = intercept
-        self.attack = attack
-        self.defense = defense
-        self.aa = aa
-
-    def prepare(self, terrain: dcs.terrain.Terrain, is_quick: bool):
-        super(CaptureOperation, self).prepare(terrain, is_quick)
-
-        self.defenders_starting_position = None
-        if self.game.player == self.defender_name:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.capture_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.armorgen.generate(self.attack, self.defense)
-        self.aagen.generate(self.aa)
-
-        self.airgen.generate_defense(self.intercept, clients=self.defender_clients, at=self.defenders_starting_position)
-
-        self.airgen.generate_cas_strikegroup(self.cas, clients=self.attacker_clients, at=self.attackers_starting_position)
-        self.airgen.generate_strikegroup_escort(self.escort, clients=self.attacker_clients, at=self.attackers_starting_position)
-
-        self.visualgen.generate_target_smokes(self.to_cp)
-        super(CaptureOperation, self).generate()
-

game/operation/groundattack.py

@@ -1,44 +0,0 @@
-from dcs.terrain import Terrain
-
-from game import db
-from gen.armor import *
-from gen.aircraft import *
-from gen.aaa import *
-from gen.shipgen import *
-from gen.triggergen import *
-from gen.awacsgen import *
-from gen.visualgen import *
-from gen.conflictgen import Conflict
-
-from .operation import Operation
-
-
-class GroundAttackOperation(Operation):
-    strikegroup = None  # type: db.PlaneDict
-    target = None  # type: db.ArmorDict
-
-    def setup(self,
-              target: db.ArmorDict,
-              strikegroup: db.PlaneDict):
-        self.strikegroup = strikegroup
-        self.target = target
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(GroundAttackOperation, self).prepare(terrain, is_quick)
-
-        conflict = Conflict.ground_attack_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_defense(self.strikegroup, self.defender_clients, self.defenders_starting_position)
-        self.armorgen.generate(self.target, {})
-
-        super(GroundAttackOperation, self).generate()

game/operation/groundintercept.py

@@ -1,53 +0,0 @@
-from dcs.terrain import Terrain
-
-from game import db
-from gen.armor import *
-from gen.aircraft import *
-from gen.aaa import *
-from gen.shipgen import *
-from gen.triggergen import *
-from gen.awacsgen import *
-from gen.visualgen import *
-from gen.conflictgen import Conflict
-
-from .operation import Operation
-
-
-class GroundInterceptOperation(Operation):
-    strikegroup = None  # type: db.PlaneDict
-    interceptors = None  # type: db.PlaneDict
-    target = None  # type: db.ArmorDict
-
-    def setup(self,
-              target: db.ArmorDict,
-              strikegroup: db.PlaneDict,
-              interceptors: db.PlaneDict):
-        self.strikegroup = strikegroup
-        self.interceptors = interceptors
-        self.target = target
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(GroundInterceptOperation, self).prepare(terrain, is_quick)
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
-
-        conflict = Conflict.ground_intercept_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_cas_strikegroup(self.strikegroup, clients=self.attacker_clients, at=self.attackers_starting_position)
-
-        if self.interceptors:
-            self.airgen.generate_defense(self.interceptors, clients=self.defender_clients, at=self.defenders_starting_position)
-
-        self.armorgen.generate({}, self.target)
-        super(GroundInterceptOperation, self).generate()

game/operation/infantrytransport.py

@@ -1,56 +0,0 @@
-from dcs.terrain import Terrain
-
-from game import db
-from gen.armor import *
-from gen.aircraft import *
-from gen.aaa import *
-from gen.shipgen import *
-from gen.triggergen import *
-from gen.awacsgen import *
-from gen.visualgen import *
-from gen.conflictgen import Conflict
-
-from .operation import Operation
-
-
-class InfantryTransportOperation(Operation):
-    transport = None  # type: db.HeliDict
-    aa = None  # type: db.AirDefenseDict
-
-    def setup(self, transport: db.HeliDict, aa: db.AirDefenseDict):
-        self.transport = transport
-        self.aa = aa
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(InfantryTransportOperation, self).prepare(terrain, is_quick)
-
-        conflict = Conflict.transport_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_passenger_transport(
-            helis=self.transport,
-            clients=self.attacker_clients,
-            at=self.attackers_starting_position
-        )
-
-        self.armorgen.generate_passengers(count=6)
-        self.aagen.generate_at_defenders_location(self.aa)
-
-        self.visualgen.generate_transportation_marker(self.conflict.ground_attackers_location)
-        self.visualgen.generate_transportation_destination(self.conflict.position)
-
-        # TODO: horrible, horrible hack
-        # this will disable vehicle activation triggers,
-        # which aren't needed on this type of missions
-        self.is_quick = True
-        super(InfantryTransportOperation, self).generate()
-        self.is_quick = False

game/operation/intercept.py

@@ -1,52 +0,0 @@
-from dcs.terrain import Terrain
-
-from gen import *
-from .operation import Operation
-
-
-class InterceptOperation(Operation):
-    escort = None  # type: db.PlaneDict
-    transport = None  # type: db.PlaneDict
-    interceptors = None  # type: db.PlaneDict
-    airdefense = None  # type: db.AirDefenseDict
-
-    trigger_radius = TRIGGER_RADIUS_LARGE
-
-    def setup(self,
-              escort: db.PlaneDict,
-              transport: db.PlaneDict,
-              airdefense: db.AirDefenseDict,
-              interceptors: db.PlaneDict):
-        self.escort = escort
-        self.transport = transport
-        self.airdefense = airdefense
-        self.interceptors = interceptors
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(InterceptOperation, self).prepare(terrain, is_quick)
-        self.defenders_starting_position = None
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.intercept_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_transport(self.transport, self.to_cp.at)
-        self.airgen.generate_transport_escort(self.escort, clients=self.defender_clients)
-
-        if self.from_cp.is_global:
-            super(InterceptOperation, self).generate()
-            self.airgen.generate_interception(self.interceptors, clients=self.attacker_clients, at=self.attackers_starting_position)
-        else:
-            self.airgen.generate_interception(self.interceptors, clients=self.attacker_clients, at=self.attackers_starting_position)
-            super(InterceptOperation, self).generate()
-

game/operation/navalintercept.py

@@ -1,53 +0,0 @@
-from dcs.terrain import Terrain
-
-from gen import *
-from .operation import Operation
-
-
-class NavalInterceptionOperation(Operation):
-    strikegroup = None  # type: db.PlaneDict
-    interceptors = None  # type: db.PlaneDict
-    targets = None  # type: db.ShipDict
-    trigger_radius = TRIGGER_RADIUS_LARGE
-
-    def setup(self,
-              strikegroup: db.PlaneDict,
-              interceptors: db.PlaneDict,
-              targets: db.ShipDict):
-        self.strikegroup = strikegroup
-        self.interceptors = interceptors
-        self.targets = targets
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(NavalInterceptionOperation, self).prepare(terrain, is_quick)
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.naval_intercept_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(self.mission, conflict)
-
-    def generate(self):
-        super(NavalInterceptionOperation, self).generate()
-
-        target_groups = self.shipgen.generate_cargo(units=self.targets)
-
-        self.airgen.generate_ship_strikegroup(
-            attackers=self.strikegroup,
-            clients=self.attacker_clients,
-            target_groups=target_groups,
-            at=self.attackers_starting_position
-        )
-
-        if self.interceptors:
-            self.airgen.generate_defense(
-                defenders=self.interceptors,
-                clients=self.defender_clients,
-                at=self.defenders_starting_position
-            )

game/operation/operation.py

@@ -1,103 +1,652 @@
-from dcs.terrain import Terrain
+from __future__ import annotations
+from game.theater.theatergroundobject import TheaterGroundObject
 
-from userdata.debriefing import *
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable, List, Optional, Set
 
-from theater import *
-from gen import *
+from dcs import Mission
+from dcs.action import DoScript, DoScriptFile
+from dcs.coalition import Coalition
+from dcs.countries import country_dict
+from dcs.lua.parse import loads
+from dcs.mapping import Point
+from dcs.translation import String
+from dcs.triggers import TriggerStart
+from game.plugins import LuaPluginManager
+from gen import Conflict, FlightType, VisualGenerator
+from gen.aircraft import AIRCRAFT_DATA, AircraftConflictGenerator, FlightData
+from gen.airfields import AIRFIELD_DATA
+from gen.airsupportgen import AirSupport, AirSupportConflictGenerator
+from gen.armor import GroundConflictGenerator, JtacInfo
+from gen.beacons import load_beacons_for_terrain
+from gen.briefinggen import BriefingGenerator, MissionInfoGenerator
+from gen.environmentgen import EnvironmentGenerator
+from gen.forcedoptionsgen import ForcedOptionsGenerator
+from gen.groundobjectsgen import GroundObjectsGenerator
+from gen.kneeboard import KneeboardGenerator
+from gen.naming import namegen
+from gen.radios import RadioFrequency, RadioRegistry
+from gen.tacan import TacanRegistry
+from gen.triggergen import TRIGGER_RADIUS_MEDIUM, TriggersGenerator
+
+from .. import db
+from ..theater import Airfield
+from ..unitmap import UnitMap
+
+if TYPE_CHECKING:
+    from game import Game
 
 
 class Operation:
-    attackers_starting_position = None  # type: db.StartingPosition
-    defenders_starting_position = None  # type: db.StartingPosition
-    mission = None  # type: dcs.Mission
-    conflict = None  # type: Conflict
-    armorgen = None  # type: ArmorConflictGenerator
-    airgen = None  # type: AircraftConflictGenerator
-    aagen = None  # type: AAConflictGenerator
-    extra_aagen = None  # type: ExtraAAConflictGenerator
-    shipgen = None  # type: ShipGenerator
-    triggersgen = None  # type: TriggersGenerator
-    awacsgen = None  # type: AWACSConflictGenerator
-    visualgen = None  # type: VisualGenerator
-    envgen = None  # type: EnvironmentGenerator
+    """Static class for managing the final Mission generation"""
 
+    current_mission = None  # type: Mission
+    airgen = None  # type: AircraftConflictGenerator
+    triggersgen = None  # type: TriggersGenerator
+    airsupportgen = None  # type: AirSupportConflictGenerator
+    visualgen = None  # type: VisualGenerator
+    groundobjectgen = None  # type: GroundObjectsGenerator
+    briefinggen = None  # type: BriefingGenerator
+    forcedoptionsgen = None  # type: ForcedOptionsGenerator
+    radio_registry: Optional[RadioRegistry] = None
+    tacan_registry: Optional[TacanRegistry] = None
+    game = None  # type: Game
     environment_settings = None
     trigger_radius = TRIGGER_RADIUS_MEDIUM
     is_quick = None
-    is_awacs_enabled = False
+    player_awacs_enabled = True
+    #  TODO: #436 Generate Air Support for red
+    enemy_awacs_enabled = True
+    ca_slots = 1
+    unit_map: UnitMap
+    jtacs: List[JtacInfo] = []
+    plugin_scripts: List[str] = []
 
-    def __init__(self,
-                 game,
-                 attacker_name: str,
-                 defender_name: str,
-                 attacker_clients: db.PlaneDict,
-                 defender_clients: db.PlaneDict,
-                 from_cp: ControlPoint,
-                 to_cp: ControlPoint = None):
-        self.game = game
-        self.attacker_name = attacker_name
-        self.defender_name = defender_name
-        self.attacker_clients = attacker_clients
-        self.defender_clients = defender_clients
-        self.from_cp = from_cp
-        self.to_cp = to_cp
-        self.is_quick = False
+    @classmethod
+    def prepare(cls, game: Game):
+        with open("resources/default_options.lua", "r") as f:
+            options_dict = loads(f.read())["options"]
+        cls._set_mission(Mission(game.theater.terrain))
+        cls.game = game
+        cls._setup_mission_coalitions()
+        cls.current_mission.options.load_from_dict(options_dict)
 
-    def initialize(self, mission: Mission, conflict: Conflict):
-        self.mission = mission
-        self.conflict = conflict
+    @classmethod
+    def conflicts(cls) -> Iterable[Conflict]:
+        assert cls.game
+        for frontline in cls.game.theater.conflicts():
+            yield Conflict(
+                cls.game.theater,
+                frontline.control_point_a,
+                frontline.control_point_b,
+                cls.game.player_name,
+                cls.game.enemy_name,
+                cls.game.player_country,
+                cls.game.enemy_country,
+                frontline.position,
+            )
 
-        self.armorgen = ArmorConflictGenerator(mission, conflict)
-        self.airgen = AircraftConflictGenerator(mission, conflict, self.game.settings)
-        self.aagen = AAConflictGenerator(mission, conflict)
-        self.shipgen = ShipGenerator(mission, conflict)
-        self.awacsgen = AWACSConflictGenerator(mission, conflict, self.game)
-        self.triggersgen = TriggersGenerator(mission, conflict, self.game)
-        self.visualgen = VisualGenerator(mission, conflict, self.game)
-        self.envgen = EnviromentGenerator(mission, conflict, self.game)
+    @classmethod
+    def air_conflict(cls) -> Conflict:
+        assert cls.game
+        player_cp, enemy_cp = cls.game.theater.closest_opposing_control_points()
+        mid_point = player_cp.position.point_from_heading(
+            player_cp.position.heading_between_point(enemy_cp.position),
+            player_cp.position.distance_to_point(enemy_cp.position) / 2,
+        )
+        return Conflict(
+            cls.game.theater,
+            player_cp,
+            enemy_cp,
+            cls.game.player_name,
+            cls.game.enemy_name,
+            cls.game.player_country,
+            cls.game.enemy_country,
+            mid_point,
+        )
 
-        player_name = self.from_cp.captured and self.attacker_name or self.defender_name
-        enemy_name = self.from_cp.captured and self.defender_name or self.attacker_name
-        self.extra_aagen = ExtraAAConflictGenerator(mission, conflict, self.game, player_name, enemy_name)
+    @classmethod
+    def _set_mission(cls, mission: Mission) -> None:
+        cls.current_mission = mission
 
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        self.mission = dcs.Mission(terrain)
-        self.is_quick = is_quick
+    @classmethod
+    def _setup_mission_coalitions(cls):
+        cls.current_mission.coalition["blue"] = Coalition("blue")
+        cls.current_mission.coalition["red"] = Coalition("red")
 
-        if is_quick:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
+        p_country = cls.game.player_country
+        e_country = cls.game.enemy_country
+        cls.current_mission.coalition["blue"].add_country(
+            country_dict[db.country_id_from_name(p_country)]()
+        )
+        cls.current_mission.coalition["red"].add_country(
+            country_dict[db.country_id_from_name(e_country)]()
+        )
+
+    @classmethod
+    def inject_lua_trigger(cls, contents: str, comment: str) -> None:
+        trigger = TriggerStart(comment=comment)
+        trigger.add_action(DoScript(String(contents)))
+        cls.current_mission.triggerrules.triggers.append(trigger)
+
+    @classmethod
+    def bypass_plugin_script(cls, mnemonic: str) -> None:
+        cls.plugin_scripts.append(mnemonic)
+
+    @classmethod
+    def inject_plugin_script(
+        cls, plugin_mnemonic: str, script: str, script_mnemonic: str
+    ) -> None:
+        if script_mnemonic in cls.plugin_scripts:
+            logging.debug(f"Skipping already loaded {script} for {plugin_mnemonic}")
         else:
-            self.attackers_starting_position = self.from_cp.at
-            self.defenders_starting_position = self.to_cp.at
+            cls.plugin_scripts.append(script_mnemonic)
 
-    def generate(self):
-        self.visualgen.generate()
+            plugin_path = Path("./resources/plugins", plugin_mnemonic)
 
-        if self.is_awacs_enabled:
-            self.awacsgen.generate()
+            script_path = Path(plugin_path, script)
+            if not script_path.exists():
+                logging.error(f"Cannot find {script_path} for plugin {plugin_mnemonic}")
+                return
 
-        self.extra_aagen.generate()
-        self.triggersgen.generate(self.is_quick, self.trigger_radius)
+            trigger = TriggerStart(comment=f"Load {script_mnemonic}")
+            filename = script_path.resolve()
+            fileref = cls.current_mission.map_resource.add_resource_file(filename)
+            trigger.add_action(DoScriptFile(fileref))
+            cls.current_mission.triggerrules.triggers.append(trigger)
 
-        if self.environment_settings is None:
-            self.environment_settings = self.envgen.generate()
-        else:
-            self.envgen.load(self.environment_settings)
+    @classmethod
+    def notify_info_generators(
+        cls,
+        groundobjectgen: GroundObjectsGenerator,
+        airsupportgen: AirSupportConflictGenerator,
+        jtacs: List[JtacInfo],
+        airgen: AircraftConflictGenerator,
+    ):
+        """Generates subscribed MissionInfoGenerator objects (currently kneeboards and briefings)"""
 
-        for global_cp in self.game.theater.controlpoints:
-            if not global_cp.is_global:
+        gens: List[MissionInfoGenerator] = [
+            KneeboardGenerator(cls.current_mission, cls.game),
+            BriefingGenerator(cls.current_mission, cls.game),
+        ]
+        for gen in gens:
+            for dynamic_runway in groundobjectgen.runways.values():
+                gen.add_dynamic_runway(dynamic_runway)
+
+            for tanker in airsupportgen.air_support.tankers:
+                gen.add_tanker(tanker)
+
+            for aewc in airsupportgen.air_support.awacs:
+                gen.add_awacs(aewc)
+
+            for jtac in jtacs:
+                gen.add_jtac(jtac)
+
+            for flight in airgen.flights:
+                gen.add_flight(flight)
+            gen.generate()
+
+    @classmethod
+    def create_unit_map(cls) -> None:
+        cls.unit_map = UnitMap()
+        for control_point in cls.game.theater.controlpoints:
+            if isinstance(control_point, Airfield):
+                cls.unit_map.add_airfield(control_point)
+
+    @classmethod
+    def create_radio_registries(cls) -> None:
+        unique_map_frequencies: Set[RadioFrequency] = set()
+        cls._create_tacan_registry(unique_map_frequencies)
+        cls._create_radio_registry(unique_map_frequencies)
+
+        assert cls.radio_registry is not None
+        for frequency in unique_map_frequencies:
+            cls.radio_registry.reserve(frequency)
+
+    @classmethod
+    def assign_channels_to_flights(
+        cls, flights: List[FlightData], air_support: AirSupport
+    ) -> None:
+        """Assigns preset radio channels for client flights."""
+        for flight in flights:
+            if not flight.client_units:
+                continue
+            cls.assign_channels_to_flight(flight, air_support)
+
+    @staticmethod
+    def assign_channels_to_flight(flight: FlightData, air_support: AirSupport) -> None:
+        """Assigns preset radio channels for a client flight."""
+        airframe = flight.aircraft_type
+
+        try:
+            aircraft_data = AIRCRAFT_DATA[airframe.id]
+        except KeyError:
+            logging.warning(f"No aircraft data for {airframe.id}")
+            return
+
+        if aircraft_data.channel_allocator is not None:
+            aircraft_data.channel_allocator.assign_channels_for_flight(
+                flight, air_support
+            )
+
+    @classmethod
+    def _create_tacan_registry(
+        cls, unique_map_frequencies: Set[RadioFrequency]
+    ) -> None:
+        """
+        Dedup beacon/radio frequencies, since some maps have some frequencies
+        used multiple times.
+        """
+        cls.tacan_registry = TacanRegistry()
+        beacons = load_beacons_for_terrain(cls.game.theater.terrain.name)
+
+        for beacon in beacons:
+            unique_map_frequencies.add(beacon.frequency)
+            if beacon.is_tacan:
+                if beacon.channel is None:
+                    logging.error(f"TACAN beacon has no channel: {beacon.callsign}")
+                else:
+                    cls.tacan_registry.reserve(beacon.tacan_channel)
+
+    @classmethod
+    def _create_radio_registry(
+        cls, unique_map_frequencies: Set[RadioFrequency]
+    ) -> None:
+        cls.radio_registry = RadioRegistry()
+        for data in AIRFIELD_DATA.values():
+            if data.theater == cls.game.theater.terrain.name and data.atc:
+                unique_map_frequencies.add(data.atc.hf)
+                unique_map_frequencies.add(data.atc.vhf_fm)
+                unique_map_frequencies.add(data.atc.vhf_am)
+                unique_map_frequencies.add(data.atc.uhf)
+                # No need to reserve ILS or TACAN because those are in the
+                # beacon list.
+
+    @classmethod
+    def _generate_ground_units(cls):
+        cls.groundobjectgen = GroundObjectsGenerator(
+            cls.current_mission,
+            cls.game,
+            cls.radio_registry,
+            cls.tacan_registry,
+            cls.unit_map,
+        )
+        cls.groundobjectgen.generate()
+
+    @classmethod
+    def _generate_destroyed_units(cls) -> None:
+        """Add destroyed units to the Mission"""
+        for d in cls.game.get_destroyed_units():
+            try:
+                utype = db.unit_type_from_name(d["type"])
+            except KeyError:
                 continue
 
-            ship = self.shipgen.generate_carrier(type=db.find_unittype(Carriage, self.game.player)[0],
-                                                 country=self.game.player,
-                                                 at=global_cp.at)
+            pos = Point(d["x"], d["z"])
+            if (
+                utype is not None
+                and not cls.game.position_culled(pos)
+                and cls.game.settings.perf_destroyed_units
+            ):
+                cls.current_mission.static_group(
+                    country=cls.current_mission.country(cls.game.player_country),
+                    name="",
+                    _type=utype,
+                    hidden=True,
+                    position=pos,
+                    heading=d["orientation"],
+                    dead=True,
+                )
 
-            if global_cp == self.from_cp and not self.is_quick:
-                self.attackers_starting_position = ship
+    @classmethod
+    def generate(cls) -> UnitMap:
+        """Build the final Mission to be exported"""
+        cls.create_unit_map()
+        cls.create_radio_registries()
+        # Set mission time and weather conditions.
+        EnvironmentGenerator(cls.current_mission, cls.game.conditions).generate()
+        cls._generate_ground_units()
+        cls._generate_destroyed_units()
+        cls._generate_air_units()
+        cls.assign_channels_to_flights(
+            cls.airgen.flights, cls.airsupportgen.air_support
+        )
+        cls._generate_ground_conflicts()
 
-    def units_of(self, country_name: str) -> typing.Collection[UnitType]:
-        return []
+        # Triggers
+        triggersgen = TriggersGenerator(cls.current_mission, cls.game)
+        triggersgen.generate()
 
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return True
+        # Setup combined arms parameters
+        cls.current_mission.groundControl.pilot_can_control_vehicles = cls.ca_slots > 0
+        if cls.game.player_country in [
+            country.name
+            for country in cls.current_mission.coalition["blue"].countries.values()
+        ]:
+            cls.current_mission.groundControl.blue_tactical_commander = cls.ca_slots
+        else:
+            cls.current_mission.groundControl.red_tactical_commander = cls.ca_slots
+
+        # Options
+        forcedoptionsgen = ForcedOptionsGenerator(cls.current_mission, cls.game)
+        forcedoptionsgen.generate()
+
+        # Generate Visuals Smoke Effects
+        visualgen = VisualGenerator(cls.current_mission, cls.game)
+        if cls.game.settings.perf_smoke_gen:
+            visualgen.generate()
+
+        cls.generate_lua(cls.airgen, cls.airsupportgen, cls.jtacs)
+
+        # Inject Plugins Lua Scripts and data
+        cls.plugin_scripts.clear()
+        for plugin in LuaPluginManager.plugins():
+            if plugin.enabled:
+                plugin.inject_scripts(cls)
+                plugin.inject_configuration(cls)
+
+        cls.assign_channels_to_flights(
+            cls.airgen.flights, cls.airsupportgen.air_support
+        )
+        cls.notify_info_generators(
+            cls.groundobjectgen, cls.airsupportgen, cls.jtacs, cls.airgen
+        )
+        cls.reset_naming_ids()
+        return cls.unit_map
+
+    @classmethod
+    def _generate_air_units(cls) -> None:
+        """Generate the air units for the Operation"""
+
+        # Air Support (Tanker & Awacs)
+        assert cls.radio_registry and cls.tacan_registry
+        cls.airsupportgen = AirSupportConflictGenerator(
+            cls.current_mission,
+            cls.air_conflict(),
+            cls.game,
+            cls.radio_registry,
+            cls.tacan_registry,
+        )
+        cls.airsupportgen.generate()
+
+        # Generate Aircraft Activity on the map
+        cls.airgen = AircraftConflictGenerator(
+            cls.current_mission,
+            cls.game.settings,
+            cls.game,
+            cls.radio_registry,
+            cls.unit_map,
+            air_support=cls.airsupportgen.air_support,
+        )
+
+        cls.airgen.clear_parking_slots()
+
+        cls.airgen.generate_flights(
+            cls.current_mission.country(cls.game.player_country),
+            cls.game.blue_ato,
+            cls.groundobjectgen.runways,
+        )
+        cls.airgen.generate_flights(
+            cls.current_mission.country(cls.game.enemy_country),
+            cls.game.red_ato,
+            cls.groundobjectgen.runways,
+        )
+        cls.airgen.spawn_unused_aircraft(
+            cls.current_mission.country(cls.game.player_country),
+            cls.current_mission.country(cls.game.enemy_country),
+        )
+
+    @classmethod
+    def _generate_ground_conflicts(cls) -> None:
+        """For each frontline in the Operation, generate the ground conflicts and JTACs"""
+        for front_line in cls.game.theater.conflicts(True):
+            player_cp = front_line.control_point_a
+            enemy_cp = front_line.control_point_b
+            conflict = Conflict.frontline_cas_conflict(
+                cls.game.player_name,
+                cls.game.enemy_name,
+                cls.current_mission.country(cls.game.player_country),
+                cls.current_mission.country(cls.game.enemy_country),
+                player_cp,
+                enemy_cp,
+                cls.game.theater,
+            )
+            # Generate frontline ops
+            player_gp = cls.game.ground_planners[player_cp.id].units_per_cp[enemy_cp.id]
+            enemy_gp = cls.game.ground_planners[enemy_cp.id].units_per_cp[player_cp.id]
+            ground_conflict_gen = GroundConflictGenerator(
+                cls.current_mission,
+                conflict,
+                cls.game,
+                player_gp,
+                enemy_gp,
+                player_cp.stances[enemy_cp.id],
+                cls.unit_map,
+            )
+            ground_conflict_gen.generate()
+            cls.jtacs.extend(ground_conflict_gen.jtacs)
+
+    @classmethod
+    def reset_naming_ids(cls):
+        namegen.reset_numbers()
+
+    @classmethod
+    def generate_lua(
+        cls,
+        airgen: AircraftConflictGenerator,
+        airsupportgen: AirSupportConflictGenerator,
+        jtacs: List[JtacInfo],
+    ) -> None:
+        #  TODO: Refactor this
+        luaData = {
+            "AircraftCarriers": {},
+            "Tankers": {},
+            "AWACs": {},
+            "JTACs": {},
+            "TargetPoints": {},
+            "RedAA": {},
+            "BlueAA": {},
+        }  # type: ignore
+
+        for tanker in airsupportgen.air_support.tankers:
+            luaData["Tankers"][tanker.callsign] = {
+                "dcsGroupName": tanker.dcsGroupName,
+                "callsign": tanker.callsign,
+                "variant": tanker.variant,
+                "radio": tanker.freq.mhz,
+                "tacan": str(tanker.tacan.number) + tanker.tacan.band.name,
+            }
+
+        if airsupportgen.air_support.awacs:
+            for awacs in airsupportgen.air_support.awacs:
+                luaData["AWACs"][awacs.callsign] = {
+                    "dcsGroupName": awacs.dcsGroupName,
+                    "callsign": awacs.callsign,
+                    "radio": awacs.freq.mhz,
+                }
+
+        for jtac in jtacs:
+            luaData["JTACs"][jtac.callsign] = {
+                "dcsGroupName": jtac.dcsGroupName,
+                "callsign": jtac.callsign,
+                "zone": jtac.region,
+                "dcsUnit": jtac.unit_name,
+                "laserCode": jtac.code,
+            }
+
+        for flight in airgen.flights:
+            if flight.friendly and flight.flight_type in [
+                FlightType.ANTISHIP,
+                FlightType.DEAD,
+                FlightType.SEAD,
+                FlightType.STRIKE,
+            ]:
+                flightType = str(flight.flight_type)
+                flightTarget = flight.package.target
+                if flightTarget:
+                    flightTargetName = None
+                    flightTargetType = None
+                    if isinstance(flightTarget, TheaterGroundObject):
+                        flightTargetName = flightTarget.obj_name
+                        flightTargetType = (
+                            flightType + f" TGT ({flightTarget.category})"
+                        )
+                    elif hasattr(flightTarget, "name"):
+                        flightTargetName = flightTarget.name
+                        flightTargetType = flightType + " TGT (Airbase)"
+                    luaData["TargetPoints"][flightTargetName] = {
+                        "name": flightTargetName,
+                        "type": flightTargetType,
+                        "position": {
+                            "x": flightTarget.position.x,
+                            "y": flightTarget.position.y,
+                        },
+                    }
+
+        for cp in cls.game.theater.controlpoints:
+            for ground_object in cp.ground_objects:
+                if ground_object.might_have_aa and not ground_object.is_dead:
+                    for g in ground_object.groups:
+                        threat_range = ground_object.threat_range(g)
+
+                        if not threat_range:
+                            continue
+
+                        faction = "BlueAA" if cp.captured else "RedAA"
+
+                        luaData[faction][g.name] = {
+                            "name": ground_object.name,
+                            "range": threat_range.meters,
+                            "position": {
+                                "x": ground_object.position.x,
+                                "y": ground_object.position.y,
+                            },
+                        }
+
+        # set a LUA table with data from Liberation that we want to set
+        # at the moment it contains Liberation's install path, and an overridable definition for the JTACAutoLase function
+        # later, we'll add data about the units and points having been generated, in order to facilitate the configuration of the plugin lua scripts
+        state_location = "[[" + os.path.abspath(".") + "]]"
+        lua = (
+            """
+        -- setting configuration table
+        env.info("DCSLiberation|: setting configuration table")
+
+        -- all data in this table is overridable.
+        dcsLiberation = {}
+
+        -- the base location for state.json; if non-existent, it'll be replaced with LIBERATION_EXPORT_DIR, TEMP, or DCS working directory
+        dcsLiberation.installPath="""
+            + state_location
+            + """
+
+        """
+        )
+        # Process the tankers
+        lua += """
+
+        -- list the tankers generated by Liberation
+        dcsLiberation.Tankers = {
+        """
+        for key in luaData["Tankers"]:
+            data = luaData["Tankers"][key]
+            dcsGroupName = data["dcsGroupName"]
+            callsign = data["callsign"]
+            variant = data["variant"]
+            tacan = data["tacan"]
+            radio = data["radio"]
+            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', variant='{variant}', tacan='{tacan}', radio='{radio}' }}, \n"
+            # lua += f"    {{name='{dcsGroupName}', description='{callsign} ({variant})', information='Tacan:{tacan} Radio:{radio}' }}, \n"
+        lua += "}"
+
+        # Process the AWACSes
+        lua += """
+
+        -- list the AWACs generated by Liberation
+        dcsLiberation.AWACs = {
+        """
+        for key in luaData["AWACs"]:
+            data = luaData["AWACs"][key]
+            dcsGroupName = data["dcsGroupName"]
+            callsign = data["callsign"]
+            radio = data["radio"]
+            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', radio='{radio}' }}, \n"
+            # lua += f"    {{name='{dcsGroupName}', description='{callsign} (AWACS)', information='Radio:{radio}' }}, \n"
+        lua += "}"
+
+        # Process the JTACs
+        lua += """
+
+        -- list the JTACs generated by Liberation
+        dcsLiberation.JTACs = {
+        """
+        for key in luaData["JTACs"]:
+            data = luaData["JTACs"][key]
+            dcsGroupName = data["dcsGroupName"]
+            callsign = data["callsign"]
+            zone = data["zone"]
+            laserCode = data["laserCode"]
+            dcsUnit = data["dcsUnit"]
+            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', zone='{zone}', laserCode='{laserCode}', dcsUnit='{dcsUnit}' }}, \n"
+            # lua += f"    {{name='{dcsGroupName}', description='JTAC {callsign} ', information='Laser:{laserCode}', jtac={laserCode} }}, \n"
+        lua += "}"
+
+        # Process the Target Points
+        lua += """
+
+        -- list the target points generated by Liberation
+        dcsLiberation.TargetPoints = {
+        """
+        for key in luaData["TargetPoints"]:
+            data = luaData["TargetPoints"][key]
+            name = data["name"]
+            pointType = data["type"]
+            positionX = data["position"]["x"]
+            positionY = data["position"]["y"]
+            lua += f"    {{name='{name}', pointType='{pointType}', positionX='{positionX}', positionY='{positionY}' }}, \n"
+            # lua += f"    {{name='{pointType} {name}', point{{x={positionX}, z={positionY} }} }}, \n"
+        lua += "}"
+
+        lua += """
+
+        -- list the airbases generated by Liberation
+        -- dcsLiberation.Airbases = {}
+
+        -- list the aircraft carriers generated by Liberation
+        -- dcsLiberation.Carriers = {}
+
+        -- list the Red AA generated by Liberation
+        dcsLiberation.RedAA = {
+        """
+        for key in luaData["RedAA"]:
+            data = luaData["RedAA"][key]
+            name = data["name"]
+            radius = data["range"]
+            positionX = data["position"]["x"]
+            positionY = data["position"]["y"]
+            lua += f"    {{dcsGroupName='{key}', name='{name}', range='{radius}', positionX='{positionX}', positionY='{positionY}' }}, \n"
+        lua += "}"
+
+        lua += """
+
+        -- list the Blue AA generated by Liberation
+        dcsLiberation.BlueAA = {
+        """
+        for key in luaData["BlueAA"]:
+            data = luaData["BlueAA"][key]
+            name = data["name"]
+            radius = data["range"]
+            positionX = data["position"]["x"]
+            positionY = data["position"]["y"]
+            lua += f"    {{dcsGroupName='{key}', name='{name}', range='{radius}', positionX='{positionX}', positionY='{positionY}' }}, \n"
+        lua += "}"
+
+        lua += """
+
+        """
+
+        trigger = TriggerStart(comment="Set DCS Liberation data")
+        trigger.add_action(DoScript(String(lua)))
+        Operation.current_mission.triggerrules.triggers.append(trigger)

game/persistency.py

@@ -0,0 +1,69 @@
+import logging
+import os
+import pickle
+import shutil
+from typing import Optional
+
+_dcs_saved_game_folder: Optional[str] = None
+_file_abs_path = None
+
+
+def setup(user_folder: str):
+    global _dcs_saved_game_folder
+    _dcs_saved_game_folder = user_folder
+    _file_abs_path = os.path.join(base_path(), "default.liberation")
+
+
+def base_path() -> str:
+    global _dcs_saved_game_folder
+    assert _dcs_saved_game_folder
+    return _dcs_saved_game_folder
+
+
+def _temporary_save_file() -> str:
+    return os.path.join(base_path(), "tmpsave.liberation")
+
+
+def _autosave_path() -> str:
+    return os.path.join(base_path(), "autosave.liberation")
+
+
+def mission_path_for(name: str) -> str:
+    return os.path.join(base_path(), "Missions", "{}".format(name))
+
+
+def load_game(path):
+    with open(path, "rb") as f:
+        try:
+            save = pickle.load(f)
+            save.savepath = path
+            return save
+        except Exception:
+            logging.exception("Invalid Save game")
+            return None
+
+
+def save_game(game) -> bool:
+    try:
+        with open(_temporary_save_file(), "wb") as f:
+            pickle.dump(game, f)
+        shutil.copy(_temporary_save_file(), game.savepath)
+        return True
+    except Exception:
+        logging.exception("Could not save game")
+        return False
+
+
+def autosave(game) -> bool:
+    """
+    Autosave to the autosave location
+    :param game: Game to save
+    :return: True if saved succesfully
+    """
+    try:
+        with open(_autosave_path(), "wb") as f:
+            pickle.dump(game, f)
+        return True
+    except Exception:
+        logging.exception("Could not save game")
+        return False

game/plugins/__init__.py

@@ -0,0 +1,2 @@
+from .luaplugin import LuaPlugin
+from .manager import LuaPluginManager

game/plugins/luaplugin.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import json
+import logging
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, TYPE_CHECKING, Type
+
+from game.settings import Settings
+
+if TYPE_CHECKING:
+    from game.operation.operation import Operation
+
+
+class LuaPluginWorkOrder:
+    def __init__(
+        self, parent_mnemonic: str, filename: str, mnemonic: str, disable: bool
+    ) -> None:
+        self.parent_mnemonic = parent_mnemonic
+        self.filename = filename
+        self.mnemonic = mnemonic
+        self.disable = disable
+
+    def work(self, operation: Type[Operation]) -> None:
+        if self.disable:
+            operation.bypass_plugin_script(self.mnemonic)
+        else:
+            operation.inject_plugin_script(
+                self.parent_mnemonic, self.filename, self.mnemonic
+            )
+
+
+class PluginSettings:
+    def __init__(self, identifier: str, enabled_by_default: bool) -> None:
+        self.identifier = identifier
+        self.enabled_by_default = enabled_by_default
+        self.settings = Settings()
+        self.initialize_settings()
+
+    def set_settings(self, settings: Settings):
+        self.settings = settings
+        self.initialize_settings()
+
+    def initialize_settings(self) -> None:
+        # Plugin options are saved in the game's Settings, but it's possible for
+        # plugins to change across loads. If new plugins are added or new
+        # options added to those plugins, initialize the new settings.
+        self.settings.initialize_plugin_option(self.identifier, self.enabled_by_default)
+
+    @property
+    def enabled(self) -> bool:
+        return self.settings.plugin_option(self.identifier)
+
+    def set_enabled(self, enabled: bool) -> None:
+        self.settings.set_plugin_option(self.identifier, enabled)
+
+
+class LuaPluginOption(PluginSettings):
+    def __init__(self, identifier: str, name: str, enabled_by_default: bool) -> None:
+        super().__init__(identifier, enabled_by_default)
+        self.name = name
+
+
+@dataclass(frozen=True)
+class LuaPluginDefinition:
+    identifier: str
+    name: str
+    present_in_ui: bool
+    enabled_by_default: bool
+    options: List[LuaPluginOption]
+    work_orders: List[LuaPluginWorkOrder]
+    config_work_orders: List[LuaPluginWorkOrder]
+
+    @classmethod
+    def from_json(cls, name: str, path: Path) -> LuaPluginDefinition:
+        data = json.loads(path.read_text())
+
+        options = []
+        for option in data.get("specificOptions"):
+            option_id = option["mnemonic"]
+            options.append(
+                LuaPluginOption(
+                    identifier=f"{name}.{option_id}",
+                    name=option.get("nameInUI", name),
+                    enabled_by_default=option.get("defaultValue"),
+                )
+            )
+
+        work_orders = []
+        for work_order in data.get("scriptsWorkOrders"):
+            work_orders.append(
+                LuaPluginWorkOrder(
+                    name,
+                    work_order.get("file"),
+                    work_order["mnemonic"],
+                    work_order.get("disable", False),
+                )
+            )
+        config_work_orders = []
+        for work_order in data.get("configurationWorkOrders"):
+            config_work_orders.append(
+                LuaPluginWorkOrder(
+                    name,
+                    work_order.get("file"),
+                    work_order["mnemonic"],
+                    work_order.get("disable", False),
+                )
+            )
+
+        return cls(
+            identifier=name,
+            name=data["nameInUI"],
+            present_in_ui=not data.get("skipUI", False),
+            enabled_by_default=data.get("defaultValue", False),
+            options=options,
+            work_orders=work_orders,
+            config_work_orders=config_work_orders,
+        )
+
+
+class LuaPlugin(PluginSettings):
+    def __init__(self, definition: LuaPluginDefinition) -> None:
+        self.definition = definition
+        super().__init__(self.definition.identifier, self.definition.enabled_by_default)
+
+    @property
+    def name(self) -> str:
+        return self.definition.name
+
+    @property
+    def show_in_ui(self) -> bool:
+        return self.definition.present_in_ui
+
+    @property
+    def options(self) -> List[LuaPluginOption]:
+        return self.definition.options
+
+    @classmethod
+    def from_json(cls, name: str, path: Path) -> Optional[LuaPlugin]:
+        try:
+            definition = LuaPluginDefinition.from_json(name, path)
+        except KeyError:
+            logging.exception("Required plugin configuration value missing")
+            return None
+
+        return cls(definition)
+
+    def set_settings(self, settings: Settings):
+        super().set_settings(settings)
+        for option in self.definition.options:
+            option.set_settings(self.settings)
+
+    def inject_scripts(self, operation: Type[Operation]) -> None:
+        for work_order in self.definition.work_orders:
+            work_order.work(operation)
+
+    def inject_configuration(self, operation: Type[Operation]) -> None:
+        # inject the plugin options
+        if self.options:
+            option_decls = []
+            for option in self.options:
+                enabled = str(option.enabled).lower()
+                name = option.identifier
+                option_decls.append(f"    dcsLiberation.plugins.{name} = {enabled}")
+
+            joined_options = "\n".join(option_decls)
+
+            lua = textwrap.dedent(
+                f"""\
+                -- {self.identifier} plugin configuration.
+
+                if dcsLiberation then
+                    if not dcsLiberation.plugins then
+                        dcsLiberation.plugins = {{}}
+                    end
+                    dcsLiberation.plugins.{self.identifier} = {{}}
+                    {joined_options}
+                end
+
+            """
+            )
+
+            operation.inject_lua_trigger(lua, f"{self.identifier} plugin configuration")
+
+        for work_order in self.definition.config_work_orders:
+            work_order.work(operation)

game/plugins/manager.py

@@ -0,0 +1,51 @@
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from game.settings import Settings
+from game.plugins.luaplugin import LuaPlugin
+
+
+class LuaPluginManager:
+    _plugins_loaded = False
+    _plugins: Dict[str, LuaPlugin] = {}
+
+    @classmethod
+    def _load_plugins(cls) -> None:
+        plugins_path = Path("resources/plugins")
+
+        path = plugins_path / "plugins.json"
+        if not path.exists():
+            raise RuntimeError(f"{path} does not exist. Cannot continue.")
+
+        logging.info(f"Reading plugins list from {path}")
+
+        data = json.loads(path.read_text())
+        for name in data:
+            plugin_path = plugins_path / name / "plugin.json"
+            if not plugin_path.exists():
+                raise RuntimeError(
+                    f"Invalid plugin configuration: required plugin {name} "
+                    f"does not exist at {plugin_path}"
+                )
+            logging.info(f"Loading plugin {name} from {plugin_path}")
+            plugin = LuaPlugin.from_json(name, plugin_path)
+            if plugin is not None:
+                cls._plugins[name] = plugin
+        cls._plugins_loaded = True
+
+    @classmethod
+    def _get_plugins(cls) -> Dict[str, LuaPlugin]:
+        if not cls._plugins_loaded:
+            cls._load_plugins()
+        return cls._plugins
+
+    @classmethod
+    def plugins(cls) -> List[LuaPlugin]:
+        return list(cls._get_plugins().values())
+
+    @classmethod
+    def load_settings(cls, settings: Settings) -> None:
+        for plugin in cls.plugins():
+            plugin.set_settings(settings)

game/point_with_heading.py

@@ -0,0 +1,15 @@
+from dcs import Point
+
+
+class PointWithHeading(Point):
+    def __init__(self):
+        super(PointWithHeading, self).__init__(0, 0)
+        self.heading = 0
+
+    @staticmethod
+    def from_point(point: Point, heading: int):
+        p = PointWithHeading()
+        p.x = point.x
+        p.y = point.y
+        p.heading = heading
+        return p

game/procurement.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass
+from typing import Iterator, List, Optional, TYPE_CHECKING, Type
+
+from dcs.unittype import FlyingType, VehicleType
+
+from game import db
+from game.factions.faction import Faction
+from game.theater import ControlPoint, MissionTarget
+from game.utils import Distance
+from gen.flights.ai_flight_planner_db import aircraft_for_task
+from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.flights.flight import FlightType
+from gen.ground_forces.ai_ground_planner_db import TYPE_SHORAD
+
+if TYPE_CHECKING:
+    from game import Game
+
+
+@dataclass(frozen=True)
+class AircraftProcurementRequest:
+    near: MissionTarget
+    range: Distance
+    task_capability: FlightType
+    number: int
+
+    def __str__(self) -> str:
+        task = self.task_capability.value
+        distance = self.range.nautical_miles
+        target = self.near.name
+        return f"{self.number} ship {task} within {distance} nm of {target}"
+
+
+class ProcurementAi:
+    def __init__(
+        self,
+        game: Game,
+        for_player: bool,
+        faction: Faction,
+        manage_runways: bool,
+        manage_front_line: bool,
+        manage_aircraft: bool,
+        front_line_budget_share: float,
+    ) -> None:
+        if front_line_budget_share > 1.0:
+            raise ValueError
+
+        self.game = game
+        self.is_player = for_player
+        self.faction = faction
+        self.manage_runways = manage_runways
+        self.manage_front_line = manage_front_line
+        self.manage_aircraft = manage_aircraft
+        self.front_line_budget_share = front_line_budget_share
+        self.threat_zones = self.game.threat_zone_for(not self.is_player)
+
+    def spend_budget(
+        self, budget: float, aircraft_requests: List[AircraftProcurementRequest]
+    ) -> float:
+        if self.manage_runways:
+            budget = self.repair_runways(budget)
+        if self.manage_front_line:
+            armor_budget = math.ceil(budget * self.front_line_budget_share)
+            budget -= armor_budget
+            budget += self.reinforce_front_line(armor_budget)
+
+        # Don't sell overstock aircraft until after we've bought runways and
+        # front lines. Any budget we free up should be earmarked for aircraft.
+        if not self.is_player:
+            budget += self.sell_incomplete_squadrons()
+        if self.manage_aircraft:
+            budget = self.purchase_aircraft(budget, aircraft_requests)
+        return budget
+
+    def sell_incomplete_squadrons(self) -> float:
+        # Selling incomplete squadrons gives us more money to spend on the next
+        # turn. This serves as a short term fix for
+        # https://github.com/Khopa/dcs_liberation/issues/41.
+        #
+        # Only incomplete squadrons which are unlikely to get used will be sold
+        # rather than all unused aircraft because the unused aircraft are what
+        # make OCA strikes worthwhile.
+        #
+        # This option is only used by the AI since players cannot cancel sales
+        # (https://github.com/Khopa/dcs_liberation/issues/365).
+        total = 0.0
+        for cp in self.game.theater.control_points_for(self.is_player):
+            inventory = self.game.aircraft_inventory.for_control_point(cp)
+            for aircraft, available in inventory.all_aircraft:
+                # We only ever plan even groups, so the odd aircraft is unlikely
+                # to get used.
+                if available % 2 == 0:
+                    continue
+                inventory.remove_aircraft(aircraft, 1)
+                total += db.PRICES[aircraft]
+        return total
+
+    def repair_runways(self, budget: float) -> float:
+        for control_point in self.owned_points:
+            if budget < db.RUNWAY_REPAIR_COST:
+                break
+            if control_point.runway_can_be_repaired:
+                control_point.begin_runway_repair()
+                budget -= db.RUNWAY_REPAIR_COST
+                if self.is_player:
+                    self.game.message(
+                        "OPFOR has begun repairing the runway at " f"{control_point}"
+                    )
+                else:
+                    self.game.message(
+                        "We have begun repairing the runway at " f"{control_point}"
+                    )
+        return budget
+
+    def random_affordable_ground_unit(
+        self, budget: float, cp: ControlPoint
+    ) -> Optional[Type[VehicleType]]:
+        affordable_units = [
+            u
+            for u in self.faction.frontline_units + self.faction.artillery_units
+            if db.PRICES[u] <= budget
+        ]
+
+        total_number_aa = (
+            cp.base.total_frontline_aa + cp.pending_frontline_aa_deliveries_count
+        )
+        total_non_aa = (
+            cp.base.total_armor + cp.pending_deliveries_count - total_number_aa
+        )
+        max_aa = math.ceil(total_non_aa / 8)
+
+        # Limit the number of AA units the AI will buy
+        if not total_number_aa < max_aa:
+            for unit in [u for u in affordable_units if u in TYPE_SHORAD]:
+                affordable_units.remove(unit)
+
+        if not affordable_units:
+            return None
+        return random.choice(affordable_units)
+
+    def reinforce_front_line(self, budget: float) -> float:
+        if not self.faction.frontline_units and not self.faction.artillery_units:
+            return budget
+
+        while budget > 0:
+            candidates = self.front_line_candidates()
+            if not candidates:
+                break
+
+            cp = random.choice(candidates)
+            unit = self.random_affordable_ground_unit(budget, cp)
+            if unit is None:
+                # Can't afford any more units.
+                break
+
+            budget -= db.PRICES[unit]
+            cp.pending_unit_deliveries.order({unit: 1})
+
+        return budget
+
+    def _affordable_aircraft_of_types(
+        self,
+        types: List[Type[FlyingType]],
+        airbase: ControlPoint,
+        number: int,
+        max_price: float,
+    ) -> Optional[Type[FlyingType]]:
+        best_choice: Optional[Type[FlyingType]] = None
+        for unit in [u for u in self.faction.aircrafts if u in types]:
+            if db.PRICES[unit] * number > max_price:
+                continue
+            if not airbase.can_operate(unit):
+                continue
+
+            # Affordable and compatible. To keep some variety, skip with a 50/50
+            # chance. Might be a good idea to have the chance to skip based on
+            # the price compared to the rest of the choices.
+            best_choice = unit
+            if random.choice([True, False]):
+                break
+        return best_choice
+
+    def affordable_aircraft_for(
+        self, request: AircraftProcurementRequest, airbase: ControlPoint, budget: float
+    ) -> Optional[Type[FlyingType]]:
+        return self._affordable_aircraft_of_types(
+            aircraft_for_task(request.task_capability), airbase, request.number, budget
+        )
+
+    def purchase_aircraft(
+        self, budget: float, aircraft_requests: List[AircraftProcurementRequest]
+    ) -> float:
+        for request in aircraft_requests:
+            for airbase in self.best_airbases_for(request):
+                unit = self.affordable_aircraft_for(request, airbase, budget)
+                if unit is None:
+                    # Can't afford any aircraft capable of performing the
+                    # required mission that can operate from this airbase. We
+                    # might be able to afford aircraft at other airbases though,
+                    # in the case where the airbase we attempted to use is only
+                    # able to operate expensive aircraft.
+                    continue
+
+                budget -= db.PRICES[unit] * request.number
+                airbase.pending_unit_deliveries.order({unit: request.number})
+
+        return budget
+
+    @property
+    def owned_points(self) -> List[ControlPoint]:
+        if self.is_player:
+            return self.game.theater.player_points()
+        else:
+            return self.game.theater.enemy_points()
+
+    def best_airbases_for(
+        self, request: AircraftProcurementRequest
+    ) -> Iterator[ControlPoint]:
+        distance_cache = ObjectiveDistanceCache.get_closest_airfields(request.near)
+        threatened = []
+        for cp in distance_cache.airfields_within(request.range):
+            if not cp.is_friendly(self.is_player):
+                continue
+            if not cp.runway_is_operational():
+                continue
+            if cp.unclaimed_parking(self.game) < request.number:
+                continue
+            if self.threat_zones.threatened(cp.position):
+                threatened.append(cp)
+            yield cp
+        yield from threatened
+
+    def front_line_candidates(self) -> List[ControlPoint]:
+        candidates = []
+
+        # Prefer to buy front line units at active front lines that are not
+        # already overloaded.
+        for cp in self.owned_points:
+            if cp.expected_ground_units_next_turn.total >= 30:
+                # Control point is already sufficiently defended.
+                continue
+            for connected in cp.connected_points:
+                if not connected.is_friendly(to_player=self.is_player):
+                    candidates.append(cp)
+
+        if not candidates:
+            # Otherwise buy reserves, but don't exceed 10 reserve units per CP.
+            # These units do not exist in the world until the CP becomes
+            # connected to an active front line, at which point all these units
+            # will suddenly appear at the gates of the newly captured CP.
+            #
+            # To avoid sudden overwhelming numbers of units we avoid buying
+            # many.
+            #
+            # Also, do not bother buying units at bases that will never connect
+            # to a front line.
+            for cp in self.owned_points:
+                if not cp.can_deploy_ground_units:
+                    continue
+                if cp.expected_ground_units_next_turn.total >= 10:
+                    continue
+                if cp.is_global:
+                    continue
+                candidates.append(cp)
+
+        return candidates

game/settings.py

@@ -1,8 +1,83 @@
+from dataclasses import dataclass, field
+from typing import Dict, Optional
 
+from dcs.forcedoptions import ForcedOptions
+
+
+@dataclass
 class Settings:
-    player_skill = "Good"
-    enemy_skill = "Average"
-    only_player_takeoff = False
-    night_disabled = False
-    multiplier = 1
-    sams = True
+
+    # Difficulty settings
+    player_skill: str = "Good"
+    enemy_skill: str = "Average"
+    enemy_vehicle_skill: str = "Average"
+    map_coalition_visibility: ForcedOptions.Views = ForcedOptions.Views.All
+    labels: str = "Full"
+    only_player_takeoff: bool = True  # Legacy parameter do not use
+    night_disabled: bool = False
+    external_views_allowed: bool = True
+    supercarrier: bool = False
+    generate_marks: bool = True
+    manpads: bool = True
+    version: Optional[str] = None
+    player_income_multiplier: float = 1.0
+    enemy_income_multiplier: float = 1.0
+
+    default_start_type: str = "Cold"
+
+    # Campaign management
+    automate_runway_repair: bool = False
+    automate_front_line_reinforcements: bool = False
+    automate_aircraft_reinforcements: bool = False
+    restrict_weapons_by_date: bool = False
+    disable_legacy_aewc: bool = False
+    generate_dark_kneeboard: bool = False
+
+    # Performance oriented
+    perf_red_alert_state: bool = True
+    perf_smoke_gen: bool = True
+    perf_artillery: bool = True
+    perf_moving_units: bool = True
+    perf_infantry: bool = True
+    perf_destroyed_units: bool = True
+
+    # Performance culling
+    perf_culling: bool = False
+    perf_culling_distance: int = 100
+    perf_do_not_cull_carrier = True
+
+    # LUA Plugins system
+    plugins: Dict[str, bool] = field(default_factory=dict)
+
+    # Cheating
+    show_red_ato: bool = False
+    enable_frontline_cheats: bool = False
+    enable_base_capture_cheat: bool = False
+
+    never_delay_player_flights: bool = False
+
+    @staticmethod
+    def plugin_settings_key(identifier: str) -> str:
+        return f"plugins.{identifier}"
+
+    def initialize_plugin_option(self, identifier: str, default_value: bool) -> None:
+        try:
+            self.plugin_option(identifier)
+        except KeyError:
+            self.set_plugin_option(identifier, default_value)
+
+    def plugin_option(self, identifier: str) -> bool:
+        return self.plugins[self.plugin_settings_key(identifier)]
+
+    def set_plugin_option(self, identifier: str, enabled: bool) -> None:
+        self.plugins[self.plugin_settings_key(identifier)] = enabled
+
+    def __setstate__(self, state) -> None:
+        # __setstate__ is called with the dict of the object being unpickled. We
+        # can provide save compatibility for new settings options (which
+        # normally would not be present in the unpickled object) by creating a
+        # new settings object, updating it with the unpickled state, and
+        # updating our dict with that.
+        new_state = Settings().__dict__
+        new_state.update(state)
+        self.__dict__.update(new_state)

game/theater/__init__.py

@@ -0,0 +1,5 @@
+from .base import *
+from .conflicttheater import *
+from .controlpoint import *
+from .missiontarget import MissionTarget
+from .theatergroundobject import SamGroundObject

game/theater/base.py

@@ -0,0 +1,247 @@
+import itertools
+import logging
+import math
+import typing
+from typing import Dict, Type
+
+from dcs.task import AWACS, CAP, CAS, Embarking, PinpointStrike, Task
+from dcs.unittype import FlyingType, UnitType, VehicleType
+from dcs.vehicles import AirDefence, Armor
+
+from game import db
+from game.db import PRICES
+from gen.ground_forces.ai_ground_planner_db import TYPE_SHORAD
+
+STRENGTH_AA_ASSEMBLE_MIN = 0.2
+PLANES_SCRAMBLE_MIN_BASE = 2
+PLANES_SCRAMBLE_MAX_BASE = 8
+PLANES_SCRAMBLE_FACTOR = 0.3
+
+BASE_MAX_STRENGTH = 1
+BASE_MIN_STRENGTH = 0
+
+
+class Base:
+    def __init__(self):
+        self.aircraft: Dict[Type[FlyingType], int] = {}
+        self.armor: Dict[Type[VehicleType], int] = {}
+        self.aa: Dict[AirDefence, int] = {}
+        self.commision_points: Dict[Type, float] = {}
+        self.strength = 1
+
+    @property
+    def total_aircraft(self) -> int:
+        return sum(self.aircraft.values())
+
+    @property
+    def total_armor(self) -> int:
+        return sum(self.armor.values())
+
+    @property
+    def total_armor_value(self) -> int:
+        total = 0
+        for unit_type, count in self.armor.items():
+            try:
+                total += PRICES[unit_type] * count
+            except KeyError:
+                logging.exception(f"No price found for {unit_type.id}")
+        return total
+
+    @property
+    def total_frontline_aa(self) -> int:
+        return sum([v for k, v in self.armor.items() if k in TYPE_SHORAD])
+
+    @property
+    def total_aa(self) -> int:
+        return sum(self.aa.values())
+
+    def total_units(self, task: Task) -> int:
+        return sum(
+            [
+                c
+                for t, c in itertools.chain(
+                    self.aircraft.items(), self.armor.items(), self.aa.items()
+                )
+                if t in db.UNIT_BY_TASK[task]
+            ]
+        )
+
+    def total_units_of_type(self, unit_type) -> int:
+        return sum(
+            [
+                c
+                for t, c in itertools.chain(
+                    self.aircraft.items(), self.armor.items(), self.aa.items()
+                )
+                if t == unit_type
+            ]
+        )
+
+    @property
+    def all_units(self):
+        return itertools.chain(
+            self.aircraft.items(), self.armor.items(), self.aa.items()
+        )
+
+    def _find_best_unit(
+        self, available_units: Dict[UnitType, int], for_type: Task, count: int
+    ) -> Dict[UnitType, int]:
+        if count <= 0:
+            logging.warning("{}: no units for {}".format(self, for_type))
+            return {}
+
+        sorted_units = [
+            key for key in available_units if key in db.UNIT_BY_TASK[for_type]
+        ]
+        sorted_units.sort(key=lambda x: db.PRICES[x], reverse=True)
+
+        result: Dict[UnitType, int] = {}
+        for unit_type in sorted_units:
+            existing_count = available_units[unit_type]  # type: int
+            if not existing_count:
+                continue
+
+            if count <= 0:
+                break
+
+            result_unit_count = min(count, existing_count)
+            count -= result_unit_count
+
+            assert result_unit_count > 0
+            result[unit_type] = result.get(unit_type, 0) + result_unit_count
+
+        logging.info("{} for {} ({}): {}".format(self, for_type, count, result))
+        return result
+
+    def _find_best_planes(
+        self, for_type: Task, count: int
+    ) -> typing.Dict[FlyingType, int]:
+        return self._find_best_unit(self.aircraft, for_type, count)
+
+    def _find_best_armor(self, for_type: Task, count: int) -> typing.Dict[Armor, int]:
+        return self._find_best_unit(self.armor, for_type, count)
+
+    def append_commision_points(self, for_type, points: float) -> int:
+        self.commision_points[for_type] = (
+            self.commision_points.get(for_type, 0) + points
+        )
+        points = self.commision_points[for_type]
+        if points >= 1:
+            self.commision_points[for_type] = points - math.floor(points)
+            return int(math.floor(points))
+
+        return 0
+
+    def filter_units(self, applicable_units: typing.Collection):
+        self.aircraft = {
+            k: v for k, v in self.aircraft.items() if k in applicable_units
+        }
+        self.armor = {k: v for k, v in self.armor.items() if k in applicable_units}
+
+    def commision_units(self, units: typing.Dict[typing.Any, int]):
+
+        for unit_type, unit_count in units.items():
+            if unit_count <= 0:
+                continue
+
+            for_task = db.unit_task(unit_type)
+
+            target_dict = None
+            if (
+                for_task == AWACS
+                or for_task == CAS
+                or for_task == CAP
+                or for_task == Embarking
+            ):
+                target_dict = self.aircraft
+            elif for_task == PinpointStrike:
+                target_dict = self.armor
+            elif for_task == AirDefence:
+                target_dict = self.aa
+
+            if target_dict is not None:
+                target_dict[unit_type] = target_dict.get(unit_type, 0) + unit_count
+            else:
+                logging.error("Unable to determine target dict for " + str(unit_type))
+
+    def commit_losses(self, units_lost: typing.Dict[typing.Any, int]):
+
+        for unit_type, count in units_lost.items():
+
+            if unit_type in self.aircraft:
+                target_array = self.aircraft
+            elif unit_type in self.armor:
+                target_array = self.armor
+            else:
+                print("Base didn't find event type {}".format(unit_type))
+                continue
+
+            if unit_type not in target_array:
+                print("Base didn't find event type {}".format(unit_type))
+                continue
+
+            target_array[unit_type] = max(target_array[unit_type] - count, 0)
+            if target_array[unit_type] == 0:
+                del target_array[unit_type]
+
+    def affect_strength(self, amount):
+        self.strength += amount
+        if self.strength > BASE_MAX_STRENGTH:
+            self.strength = BASE_MAX_STRENGTH
+        elif self.strength <= 0:
+            self.strength = BASE_MIN_STRENGTH
+
+    def set_strength_to_minimum(self) -> None:
+        self.strength = BASE_MIN_STRENGTH
+
+    def scramble_count(self, multiplier: float, task: Task = None) -> int:
+        if task:
+            count = sum(
+                [v for k, v in self.aircraft.items() if db.unit_task(k) == task]
+            )
+        else:
+            count = self.total_aircraft
+
+        count = int(math.ceil(count * PLANES_SCRAMBLE_FACTOR * self.strength))
+        return min(
+            min(
+                max(count, PLANES_SCRAMBLE_MIN_BASE),
+                int(PLANES_SCRAMBLE_MAX_BASE * multiplier),
+            ),
+            count,
+        )
+
+    def assemble_count(self):
+        return int(self.total_armor * 0.5)
+
+    def assemble_aa_count(self) -> int:
+        # previous logic removed because we always want the full air defense capabilities.
+        return self.total_aa
+
+    def scramble_sweep(self, multiplier: float) -> typing.Dict[FlyingType, int]:
+        return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
+
+    def scramble_last_defense(self):
+        # return as many CAP-capable aircraft as we can since this is the last defense of the base
+        # (but not more than 20 - that's just nuts)
+        return self._find_best_planes(CAP, min(self.total_aircraft, 20))
+
+    def scramble_cas(self, multiplier: float) -> typing.Dict[FlyingType, int]:
+        return self._find_best_planes(CAS, self.scramble_count(multiplier, CAS))
+
+    def scramble_interceptors(self, multiplier: float) -> typing.Dict[FlyingType, int]:
+        return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
+
+    def assemble_attack(self) -> typing.Dict[Armor, int]:
+        return self._find_best_armor(PinpointStrike, self.assemble_count())
+
+    def assemble_defense(self) -> typing.Dict[Armor, int]:
+        count = int(self.total_armor * min(self.strength + 0.5, 1))
+        return self._find_best_armor(PinpointStrike, count)
+
+    def assemble_aa(self, count=None) -> typing.Dict[AirDefence, int]:
+        return self._find_best_unit(
+            self.aa,
+            AirDefence,
+            count and min(count, self.total_aa) or self.assemble_aa_count(),
+        )

game/theater/controlpoint.py

@@ -0,0 +1,973 @@
+from __future__ import annotations
+
+import heapq
+import itertools
+import logging
+import random
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from functools import total_ordering
+from typing import Any, Dict, Iterator, List, Optional, TYPE_CHECKING, Type
+
+from dcs.mapping import Point
+from dcs.ships import (
+    CVN_74_John_C__Stennis,
+    CV_1143_5_Admiral_Kuznetsov,
+    LHA_1_Tarawa,
+    Type_071_Amphibious_Transport_Dock,
+)
+from dcs.terrain.terrain import Airport, ParkingSlot
+from dcs.unittype import FlyingType
+
+from game import db
+from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.ground_forces.ai_ground_planner_db import TYPE_SHORAD
+from gen.ground_forces.combat_stance import CombatStance
+from gen.runways import RunwayAssigner, RunwayData
+from .base import Base
+from .missiontarget import MissionTarget
+from game.point_with_heading import PointWithHeading
+from .theatergroundobject import (
+    BaseDefenseGroundObject,
+    EwrGroundObject,
+    GenericCarrierGroundObject,
+    SamGroundObject,
+    TheaterGroundObject,
+    VehicleGroupGroundObject,
+)
+from ..db import PRICES
+from ..utils import nautical_miles
+from ..weather import Conditions
+
+if TYPE_CHECKING:
+    from game import Game
+    from gen.flights.flight import FlightType
+
+
+class ControlPointType(Enum):
+    #: An airbase with slots for everything.
+    AIRBASE = 0
+    #: A group with a Stennis type carrier (F/A-18, F-14 compatible).
+    AIRCRAFT_CARRIER_GROUP = 1
+    #: A group with a Tarawa carrier (Helicopters & Harrier).
+    LHA_GROUP = 2
+    #: A FARP, with slots for helicopters
+    FARP = 4
+    #: A FOB (ground units only)
+    FOB = 5
+    OFF_MAP = 6
+
+
+class LocationType(Enum):
+    BaseAirDefense = "base air defense"
+    Coastal = "coastal defense"
+    Ewr = "EWR"
+    BaseEwr = "Base EWR"
+    Garrison = "garrison"
+    MissileSite = "missile site"
+    OffshoreStrikeTarget = "offshore strike target"
+    Sam = "SAM"
+    Ship = "ship"
+    Shorad = "SHORAD"
+    StrikeTarget = "strike target"
+
+
+@dataclass
+class PresetLocations:
+    """Defines the preset locations loaded from the campaign mission file."""
+
+    #: Locations used for spawning ground defenses for bases.
+    base_garrisons: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used for spawning air defenses for bases. Used by SAMs, AAA,
+    #: and SHORADs.
+    base_air_defense: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by EWRs.
+    ewrs: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by Base EWRs.
+    base_ewrs: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by non-carrier ships. Carriers and LHAs are not random.
+    ships: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by coastal defenses.
+    coastal_defenses: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by ground based strike objectives.
+    strike_locations: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by offshore strike objectives.
+    offshore_strike_locations: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations used by missile sites like scuds and V-2s.
+    missile_sites: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations of long range SAMs which should always be spawned.
+    required_long_range_sams: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations of medium range SAMs which should always be spawned.
+    required_medium_range_sams: List[PointWithHeading] = field(default_factory=list)
+
+    #: Locations of EWRs which should always be spawned.
+    required_ewrs: List[PointWithHeading] = field(default_factory=list)
+
+    @staticmethod
+    def _random_from(points: List[PointWithHeading]) -> Optional[PointWithHeading]:
+        """Finds, removes, and returns a random position from the given list."""
+        if not points:
+            return None
+        point = random.choice(points)
+        points.remove(point)
+        return point
+
+    def random_for(self, location_type: LocationType) -> Optional[PointWithHeading]:
+        """Returns a position suitable for the given location type.
+
+        The location, if found, will be claimed by the caller and not available
+        to subsequent calls.
+        """
+        if location_type == LocationType.BaseAirDefense:
+            return self._random_from(self.base_air_defense)
+        if location_type == LocationType.Coastal:
+            return self._random_from(self.coastal_defenses)
+        if location_type == LocationType.Ewr:
+            return self._random_from(self.ewrs)
+        if location_type == LocationType.BaseEwr:
+            return self._random_from(self.base_ewrs)
+        if location_type == LocationType.Garrison:
+            return self._random_from(self.base_garrisons)
+        if location_type == LocationType.MissileSite:
+            return self._random_from(self.missile_sites)
+        if location_type == LocationType.OffshoreStrikeTarget:
+            return self._random_from(self.offshore_strike_locations)
+        if location_type == LocationType.Sam:
+            return self._random_from(self.strike_locations)
+        if location_type == LocationType.Ship:
+            return self._random_from(self.ships)
+        if location_type == LocationType.Shorad:
+            return self._random_from(self.base_garrisons)
+        if location_type == LocationType.StrikeTarget:
+            return self._random_from(self.strike_locations)
+        logging.error(f"Unknown location type: {location_type}")
+        return None
+
+
+@dataclass(frozen=True)
+class PendingOccupancy:
+    present: int
+    ordered: int
+    transferring: int
+
+    @property
+    def total(self) -> int:
+        return self.present + self.ordered + self.transferring
+
+
+@dataclass
+class RunwayStatus:
+    damaged: bool = False
+    repair_turns_remaining: Optional[int] = None
+
+    def damage(self) -> None:
+        self.damaged = True
+        # If the runway is already under repair and is damaged again, progress
+        # is reset.
+        self.repair_turns_remaining = None
+
+    def begin_repair(self) -> None:
+        if self.repair_turns_remaining is not None:
+            logging.error("Runway already under repair. Restarting.")
+        self.repair_turns_remaining = 4
+
+    def process_turn(self) -> None:
+        if self.repair_turns_remaining is not None:
+            if self.repair_turns_remaining == 1:
+                self.repair_turns_remaining = None
+                self.damaged = False
+            else:
+                self.repair_turns_remaining -= 1
+
+    @property
+    def needs_repair(self) -> bool:
+        return self.damaged and self.repair_turns_remaining is None
+
+    def __str__(self) -> str:
+        if not self.damaged:
+            return "Runway operational"
+
+        turns_remaining = self.repair_turns_remaining
+        if turns_remaining is None:
+            return "Runway damaged"
+
+        return f"Runway repairing, {turns_remaining} turns remaining"
+
+
+@total_ordering
+class GroundUnitDestination:
+    def __init__(self, control_point: ControlPoint) -> None:
+        self.control_point = control_point
+
+    @property
+    def total_value(self) -> float:
+        return self.control_point.base.total_armor_value
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, GroundUnitDestination):
+            raise TypeError
+
+        return self.total_value == other.total_value
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, GroundUnitDestination):
+            raise TypeError
+
+        return self.total_value < other.total_value
+
+
+class ControlPoint(MissionTarget, ABC):
+
+    position = None  # type: Point
+    name = None  # type: str
+
+    captured = False
+    has_frontline = True
+
+    alt = 0
+
+    # TODO: Only airbases have IDs.
+    # TODO: has_frontline is only reasonable for airbases.
+    # TODO: cptype is obsolete.
+    def __init__(
+        self,
+        cp_id: int,
+        name: str,
+        position: Point,
+        at: db.StartingPosition,
+        size: int,
+        importance: float,
+        has_frontline=True,
+        cptype=ControlPointType.AIRBASE,
+    ):
+        super().__init__(name, position)
+        # TODO: Should be Airbase specific.
+        self.id = cp_id
+        self.full_name = name
+        self.at = at
+        self.connected_objectives: List[TheaterGroundObject] = []
+        self.base_defenses: List[BaseDefenseGroundObject] = []
+        self.preset_locations = PresetLocations()
+        self.helipads: List[PointWithHeading] = []
+
+        # TODO: Should be Airbase specific.
+        self.size = size
+        self.importance = importance
+        self.captured = False
+        self.captured_invert = False
+        # TODO: Should be Airbase specific.
+        self.has_frontline = has_frontline
+        self.connected_points: List[ControlPoint] = []
+        self.base: Base = Base()
+        self.cptype = cptype
+        # TODO: Should be Airbase specific.
+        self.stances: Dict[int, CombatStance] = {}
+        from ..event import UnitsDeliveryEvent
+
+        self.pending_unit_deliveries = UnitsDeliveryEvent(self)
+
+        self.target_position: Optional[Point] = None
+
+    def __repr__(self):
+        return f"<{__class__}: {self.name}>"
+
+    @property
+    def ground_objects(self) -> List[TheaterGroundObject]:
+        return list(itertools.chain(self.connected_objectives, self.base_defenses))
+
+    @property
+    @abstractmethod
+    def heading(self) -> int:
+        ...
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def is_global(self):
+        return not self.connected_points
+
+    @property
+    def is_carrier(self):
+        """
+        :return: Whether this control point is an aircraft carrier
+        """
+        return False
+
+    @property
+    def is_fleet(self):
+        """
+        :return: Whether this control point is a boat (mobile)
+        """
+        return False
+
+    @property
+    def is_lha(self):
+        """
+        :return: Whether this control point is an LHA
+        """
+        return False
+
+    @property
+    def moveable(self) -> bool:
+        """
+        :return: Whether this control point can be moved around
+        """
+        return False
+
+    @property
+    @abstractmethod
+    def can_deploy_ground_units(self) -> bool:
+        ...
+
+    @property
+    @abstractmethod
+    def total_aircraft_parking(self):
+        """
+        :return: The maximum number of aircraft that can be stored in this
+                 control point
+        """
+        ...
+
+    # TODO: Should be Airbase specific.
+    def connect(self, to: ControlPoint) -> None:
+        self.connected_points.append(to)
+        self.stances[to.id] = CombatStance.DEFENSIVE
+
+    @abstractmethod
+    def runway_is_operational(self) -> bool:
+        """
+        Check whether this control point supports taking offs and landings.
+        :return:
+        """
+        ...
+
+    # TODO: Should be naval specific.
+    def get_carrier_group_name(self):
+        """
+        Get the carrier group name if the airbase is a carrier
+        :return: Carrier group name
+        """
+        if self.cptype in [
+            ControlPointType.AIRCRAFT_CARRIER_GROUP,
+            ControlPointType.LHA_GROUP,
+        ]:
+            for g in self.ground_objects:
+                if g.dcs_identifier == "CARRIER":
+                    for group in g.groups:
+                        for u in group.units:
+                            if db.unit_type_from_name(u.type) in [
+                                CVN_74_John_C__Stennis,
+                                CV_1143_5_Admiral_Kuznetsov,
+                            ]:
+                                return group.name
+                elif g.dcs_identifier == "LHA":
+                    for group in g.groups:
+                        for u in group.units:
+                            if db.unit_type_from_name(u.type) in [LHA_1_Tarawa]:
+                                return group.name
+        return None
+
+    # TODO: Should be Airbase specific.
+    def is_connected(self, to) -> bool:
+        return to in self.connected_points
+
+    def find_ground_objects_by_obj_name(self, obj_name):
+        found = []
+        for g in self.ground_objects:
+            if g.obj_name == obj_name:
+                found.append(g)
+        return found
+
+    def is_friendly(self, to_player: bool) -> bool:
+        return self.captured == to_player
+
+    # TODO: Should be Airbase specific.
+    def clear_base_defenses(self) -> None:
+        for base_defense in self.base_defenses:
+            p = PointWithHeading.from_point(base_defense.position, base_defense.heading)
+            if isinstance(base_defense, EwrGroundObject):
+                self.preset_locations.base_ewrs.append(p)
+            elif isinstance(base_defense, SamGroundObject):
+                self.preset_locations.base_air_defense.append(p)
+            elif isinstance(base_defense, VehicleGroupGroundObject):
+                self.preset_locations.base_garrisons.append(p)
+            else:
+                logging.error(
+                    "Could not determine preset location type for "
+                    f"{base_defense}. Assuming garrison type."
+                )
+                self.preset_locations.base_garrisons.append(p)
+        self.base_defenses = []
+
+    def capture_equipment(self, game: Game) -> None:
+        total = self.base.total_armor_value
+        self.base.armor.clear()
+        game.adjust_budget(total, player=not self.captured)
+        game.message(
+            f"{self.name} is not connected to any friendly points. Ground "
+            f"vehicles have been captured and sold for ${total}M."
+        )
+
+    def retreat_ground_units(self, game: Game):
+        # When there are multiple valid destinations, deliver units to whichever
+        # base is least defended first. The closest approximation of unit
+        # strength we have is price
+        destinations = [
+            GroundUnitDestination(cp)
+            for cp in self.connected_points
+            if cp.captured == self.captured
+        ]
+        if not destinations:
+            self.capture_equipment(game)
+            return
+
+        heapq.heapify(destinations)
+        destination = heapq.heappop(destinations)
+        while self.base.armor:
+            unit_type, count = self.base.armor.popitem()
+            for _ in range(count):
+                destination.control_point.base.commision_units({unit_type: 1})
+                destination = heapq.heappushpop(destinations, destination)
+
+    def capture_aircraft(
+        self, game: Game, airframe: Type[FlyingType], count: int
+    ) -> None:
+        try:
+            value = PRICES[airframe] * count
+        except KeyError:
+            logging.exception(f"Unknown price for {airframe.id}")
+            return
+
+        game.adjust_budget(value, player=not self.captured)
+        game.message(
+            f"No valid retreat destination in range of {self.name} for "
+            f"{airframe.id}. {count} aircraft have been captured and sold for "
+            f"${value}M."
+        )
+
+    def aircraft_retreat_destination(
+        self, game: Game, airframe: Type[FlyingType]
+    ) -> Optional[ControlPoint]:
+        closest = ObjectiveDistanceCache.get_closest_airfields(self)
+        # TODO: Should be airframe dependent.
+        max_retreat_distance = nautical_miles(200)
+        # Skip the first airbase because that's the airbase we're retreating
+        # from.
+        airfields = list(closest.airfields_within(max_retreat_distance))[1:]
+        for airbase in airfields:
+            if not airbase.can_operate(airframe):
+                continue
+            if airbase.captured != self.captured:
+                continue
+            if airbase.unclaimed_parking(game) > 0:
+                return airbase
+        return None
+
+    def _retreat_air_units(
+        self, game: Game, airframe: Type[FlyingType], count: int
+    ) -> None:
+        while count:
+            logging.debug(f"Retreating {count} {airframe.id} from {self.name}")
+            destination = self.aircraft_retreat_destination(game, airframe)
+            if destination is None:
+                self.capture_aircraft(game, airframe, count)
+                return
+            parking = destination.unclaimed_parking(game)
+            transfer_amount = min([parking, count])
+            destination.base.commision_units({airframe: transfer_amount})
+            count -= transfer_amount
+
+    def retreat_air_units(self, game: Game) -> None:
+        # TODO: Capture in order of price to retain maximum value?
+        while self.base.aircraft:
+            airframe, count = self.base.aircraft.popitem()
+            self._retreat_air_units(game, airframe, count)
+
+    # TODO: Should be Airbase specific.
+    def capture(self, game: Game, for_player: bool) -> None:
+        self.pending_unit_deliveries.refund_all(game)
+        self.retreat_ground_units(game)
+        self.retreat_air_units(game)
+
+        if for_player:
+            self.captured = True
+        else:
+            self.captured = False
+
+        self.base.set_strength_to_minimum()
+
+        self.clear_base_defenses()
+        from .start_generator import BaseDefenseGenerator
+
+        BaseDefenseGenerator(game, self).generate()
+
+    @abstractmethod
+    def can_operate(self, aircraft: Type[FlyingType]) -> bool:
+        ...
+
+    def aircraft_transferring(self, game: Game) -> int:
+        if self.captured:
+            ato = game.blue_ato
+        else:
+            ato = game.red_ato
+
+        total = 0
+        for package in ato.packages:
+            for flight in package.flights:
+                if flight.departure == flight.arrival:
+                    continue
+                if flight.departure == self:
+                    total -= flight.count
+                elif flight.arrival == self:
+                    total += flight.count
+        return total
+
+    def expected_aircraft_next_turn(self, game: Game) -> PendingOccupancy:
+        on_order = 0
+        for unit_bought in self.pending_unit_deliveries.units:
+            if issubclass(unit_bought, FlyingType):
+                on_order += self.pending_unit_deliveries.units[unit_bought]
+
+        return PendingOccupancy(
+            self.base.total_aircraft, on_order, self.aircraft_transferring(game)
+        )
+
+    def unclaimed_parking(self, game: Game) -> int:
+        return (
+            self.total_aircraft_parking - self.expected_aircraft_next_turn(game).total
+        )
+
+    @abstractmethod
+    def active_runway(
+        self, conditions: Conditions, dynamic_runways: Dict[str, RunwayData]
+    ) -> RunwayData:
+        ...
+
+    @property
+    def parking_slots(self) -> Iterator[ParkingSlot]:
+        yield from []
+
+    @property
+    @abstractmethod
+    def runway_status(self) -> RunwayStatus:
+        ...
+
+    @property
+    def runway_can_be_repaired(self) -> bool:
+        return self.runway_status.needs_repair
+
+    def begin_runway_repair(self) -> None:
+        if not self.runway_can_be_repaired:
+            logging.error(f"Cannot repair runway at {self}")
+            return
+        self.runway_status.begin_repair()
+
+    def process_turn(self, game: Game) -> None:
+        self.pending_unit_deliveries.process(game)
+
+        runway_status = self.runway_status
+        if runway_status is not None:
+            runway_status.process_turn()
+
+        # Process movements for ships control points group
+        if self.target_position is not None:
+            delta = self.target_position - self.position
+            self.position = self.target_position
+            self.target_position = None
+
+            # Move the linked unit groups
+            for ground_object in self.ground_objects:
+                if isinstance(ground_object, GenericCarrierGroundObject):
+                    ground_object.position.x = ground_object.position.x + delta.x
+                    ground_object.position.y = ground_object.position.y + delta.y
+                    for group in ground_object.groups:
+                        for u in group.units:
+                            u.position.x = u.position.x + delta.x
+                            u.position.y = u.position.y + delta.y
+
+    @property
+    def pending_frontline_aa_deliveries_count(self):
+        """
+        Get number of pending frontline aa units
+        """
+        if self.pending_unit_deliveries:
+            return sum(
+                [
+                    v
+                    for k, v in self.pending_unit_deliveries.units.items()
+                    if k in TYPE_SHORAD
+                ]
+            )
+        else:
+            return 0
+
+    @property
+    def pending_deliveries_count(self):
+        """
+        Get number of pending units
+        """
+        if self.pending_unit_deliveries:
+            return sum([v for k, v in self.pending_unit_deliveries.units.items()])
+        else:
+            return 0
+
+    @property
+    def expected_ground_units_next_turn(self) -> PendingOccupancy:
+        on_order = 0
+        for unit_bought in self.pending_unit_deliveries.units:
+            if issubclass(unit_bought, FlyingType):
+                continue
+            if unit_bought in TYPE_SHORAD:
+                continue
+            on_order += self.pending_unit_deliveries.units[unit_bought]
+
+        return PendingOccupancy(
+            self.base.total_armor,
+            on_order,
+            # Ground unit transfers not yet implemented.
+            transferring=0,
+        )
+
+    @property
+    def income_per_turn(self) -> int:
+        return 0
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if self.is_friendly(for_player):
+            yield from [
+                FlightType.AEWC,
+            ]
+        yield from super().mission_types(for_player)
+
+    @property
+    def has_active_frontline(self) -> bool:
+        return any(not c.is_friendly(self.captured) for c in self.connected_points)
+
+
+class Airfield(ControlPoint):
+    def __init__(
+        self, airport: Airport, size: int, importance: float, has_frontline=True
+    ):
+        super().__init__(
+            airport.id,
+            airport.name,
+            airport.position,
+            airport,
+            size,
+            importance,
+            has_frontline,
+            cptype=ControlPointType.AIRBASE,
+        )
+        self.airport = airport
+        self._runway_status = RunwayStatus()
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        # TODO: Allow helicopters.
+        # Need to implement ground spawns so the helos don't use the runway.
+        # TODO: Allow harrier.
+        # Needs ground spawns just like helos do, but also need to be able to
+        # limit takeoff weight to ~20500 lbs or it won't be able to take off.
+        return self.runway_is_operational()
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if self.is_friendly(for_player):
+            yield from [
+                # TODO: FlightType.INTERCEPTION
+                # TODO: FlightType.LOGISTICS
+            ]
+        else:
+            yield from [
+                FlightType.OCA_AIRCRAFT,
+                FlightType.OCA_RUNWAY,
+            ]
+        yield from super().mission_types(for_player)
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return len(self.airport.parking_slots)
+
+    @property
+    def heading(self) -> int:
+        return self.airport.runways[0].heading
+
+    def runway_is_operational(self) -> bool:
+        return not self.runway_status.damaged
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return self._runway_status
+
+    def damage_runway(self) -> None:
+        self.runway_status.damage()
+
+    def active_runway(
+        self, conditions: Conditions, dynamic_runways: Dict[str, RunwayData]
+    ) -> RunwayData:
+        assigner = RunwayAssigner(conditions)
+        return assigner.get_preferred_runway(self.airport)
+
+    @property
+    def parking_slots(self) -> Iterator[ParkingSlot]:
+        yield from self.airport.parking_slots
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return True
+
+    @property
+    def income_per_turn(self) -> int:
+        return 20
+
+
+class NavalControlPoint(ControlPoint, ABC):
+    @property
+    def is_fleet(self) -> bool:
+        return True
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if self.is_friendly(for_player):
+            yield from [
+                # TODO: FlightType.INTERCEPTION
+                # TODO: Buddy tanking for the A-4?
+                # TODO: Rescue chopper?
+                # TODO: Inter-ship logistics?
+            ]
+        else:
+            yield FlightType.ANTISHIP
+        yield from super().mission_types(for_player)
+
+    @property
+    def heading(self) -> int:
+        return 0  # TODO compute heading
+
+    def runway_is_operational(self) -> bool:
+        # Necessary because it's possible for the carrier itself to have sunk
+        # while its escorts are still alive.
+        for g in self.ground_objects:
+            if g.dcs_identifier in ["CARRIER", "LHA"]:
+                for group in g.groups:
+                    for u in group.units:
+                        if db.unit_type_from_name(u.type) in [
+                            CVN_74_John_C__Stennis,
+                            LHA_1_Tarawa,
+                            CV_1143_5_Admiral_Kuznetsov,
+                            Type_071_Amphibious_Transport_Dock,
+                        ]:
+                            return True
+        return False
+
+    def active_runway(
+        self, conditions: Conditions, dynamic_runways: Dict[str, RunwayData]
+    ) -> RunwayData:
+        # TODO: Assign TACAN and ICLS earlier so we don't need this.
+        fallback = RunwayData(self.full_name, runway_heading=0, runway_name="")
+        return dynamic_runways.get(self.name, fallback)
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return RunwayStatus(damaged=not self.runway_is_operational())
+
+    @property
+    def runway_can_be_repaired(self) -> bool:
+        return False
+
+    @property
+    def moveable(self) -> bool:
+        return True
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return False
+
+
+class Carrier(NavalControlPoint):
+    def __init__(self, name: str, at: Point, cp_id: int):
+        import game.theater.conflicttheater
+
+        super().__init__(
+            cp_id,
+            name,
+            at,
+            at,
+            game.theater.conflicttheater.SIZE_SMALL,
+            1,
+            has_frontline=False,
+            cptype=ControlPointType.AIRCRAFT_CARRIER_GROUP,
+        )
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        raise RuntimeError("Carriers cannot be captured")
+
+    @property
+    def is_carrier(self):
+        return True
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return aircraft in db.CARRIER_CAPABLE
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 90
+
+
+class Lha(NavalControlPoint):
+    def __init__(self, name: str, at: Point, cp_id: int):
+        import game.theater.conflicttheater
+
+        super().__init__(
+            cp_id,
+            name,
+            at,
+            at,
+            game.theater.conflicttheater.SIZE_SMALL,
+            1,
+            has_frontline=False,
+            cptype=ControlPointType.LHA_GROUP,
+        )
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        raise RuntimeError("LHAs cannot be captured")
+
+    @property
+    def is_lha(self) -> bool:
+        return True
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return aircraft in db.LHA_CAPABLE
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 20
+
+
+class OffMapSpawn(ControlPoint):
+    def runway_is_operational(self) -> bool:
+        return True
+
+    def __init__(self, cp_id: int, name: str, position: Point):
+        from . import IMPORTANCE_MEDIUM, SIZE_REGULAR
+
+        super().__init__(
+            cp_id,
+            name,
+            position,
+            at=position,
+            size=SIZE_REGULAR,
+            importance=IMPORTANCE_MEDIUM,
+            has_frontline=False,
+            cptype=ControlPointType.OFF_MAP,
+        )
+
+    def capture(self, game: Game, for_player: bool) -> None:
+        raise RuntimeError("Off map control points cannot be captured")
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        yield from []
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 1000
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return True
+
+    @property
+    def heading(self) -> int:
+        return 0
+
+    def active_runway(
+        self, conditions: Conditions, dynamic_runways: Dict[str, RunwayData]
+    ) -> RunwayData:
+        logging.warning("TODO: Off map spawns have no runways.")
+        return RunwayData(self.full_name, runway_heading=0, runway_name="")
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return RunwayStatus()
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return False
+
+
+class Fob(ControlPoint):
+    def __init__(self, name: str, at: Point, cp_id: int):
+        import game.theater.conflicttheater
+
+        super().__init__(
+            cp_id,
+            name,
+            at,
+            at,
+            game.theater.conflicttheater.SIZE_SMALL,
+            1,
+            has_frontline=True,
+            cptype=ControlPointType.FOB,
+        )
+        self.name = name
+
+    def runway_is_operational(self) -> bool:
+        return False
+
+    def active_runway(
+        self, conditions: Conditions, dynamic_runways: Dict[str, RunwayData]
+    ) -> RunwayData:
+        logging.warning("TODO: FOBs have no runways.")
+        return RunwayData(self.full_name, runway_heading=0, runway_name="")
+
+    @property
+    def runway_status(self) -> RunwayStatus:
+        return RunwayStatus()
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if self.is_friendly(for_player):
+            yield from [
+                FlightType.BARCAP,
+                # TODO: FlightType.LOGISTICS
+            ]
+        else:
+            yield from [
+                FlightType.STRIKE,
+                FlightType.SWEEP,
+                FlightType.ESCORT,
+                FlightType.SEAD,
+            ]
+
+    @property
+    def total_aircraft_parking(self) -> int:
+        return 0
+
+    def can_operate(self, aircraft: FlyingType) -> bool:
+        return False
+
+    @property
+    def heading(self) -> int:
+        return 0
+
+    @property
+    def can_deploy_ground_units(self) -> bool:
+        return True
+
+    @property
+    def income_per_turn(self) -> int:
+        return 10

game/theater/landmap.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+import pickle
+from functools import cached_property
+from typing import Optional, Tuple, Union
+import logging
+
+from shapely import geometry
+from shapely.geometry import MultiPolygon, Polygon
+
+
+@dataclass(frozen=True)
+class Landmap:
+    inclusion_zones: MultiPolygon
+    exclusion_zones: MultiPolygon
+    sea_zones: MultiPolygon
+
+    def __post_init__(self):
+        if not self.inclusion_zones.is_valid:
+            raise RuntimeError("Inclusion zones not valid")
+        if not self.exclusion_zones.is_valid:
+            raise RuntimeError("Exclusion zones not valid")
+        if not self.sea_zones.is_valid:
+            raise RuntimeError("Sea zones not valid")
+
+    @cached_property
+    def inclusion_zone_only(self) -> MultiPolygon:
+        return self.inclusion_zones - self.exclusion_zones - self.sea_zones
+
+
+def load_landmap(filename: str) -> Optional[Landmap]:
+    try:
+        with open(filename, "rb") as f:
+            return pickle.load(f)
+    except:
+        logging.exception(f"Failed to load landmap {filename}")
+        return None
+
+
+def poly_contains(x, y, poly: Union[MultiPolygon, Polygon]):
+    return poly.contains(geometry.Point(x, y))
+
+
+def poly_centroid(poly) -> Tuple[float, float]:
+    x_list = [vertex[0] for vertex in poly]
+    y_list = [vertex[1] for vertex in poly]
+    x = sum(x_list) / len(poly)
+    y = sum(y_list) / len(poly)
+    return (x, y)

game/theater/missiontarget.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Iterator, TYPE_CHECKING
+
+from dcs.mapping import Point
+
+if TYPE_CHECKING:
+    from gen.flights.flight import FlightType
+
+
+class MissionTarget:
+    def __init__(self, name: str, position: Point) -> None:
+        """Initializes a mission target.
+
+        Args:
+            name: The name of the mission target.
+            position: The location of the mission target.
+        """
+        self.name = name
+        self.position = position
+
+    def distance_to(self, other: MissionTarget) -> int:
+        """Computes the distance to the given mission target."""
+        return self.position.distance_to_point(other.position)
+
+    def is_friendly(self, to_player: bool) -> bool:
+        """Returns True if the objective is in friendly territory."""
+        raise NotImplementedError
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if self.is_friendly(for_player):
+            yield FlightType.BARCAP
+        else:
+            yield from [
+                FlightType.ESCORT,
+                FlightType.TARCAP,
+                FlightType.SEAD,
+                FlightType.SWEEP,
+                # TODO: FlightType.ELINT,
+                # TODO: FlightType.EWAR,
+                # TODO: FlightType.RECON,
+            ]

game/theater/start_generator.py

@@ -0,0 +1,907 @@
+from __future__ import annotations
+
+import logging
+import pickle
+import random
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Iterable, List, Optional, Set
+
+from dcs.mapping import Point
+from dcs.task import CAP, CAS, PinpointStrike
+from dcs.vehicles import AirDefence
+
+from game import Game, db
+from game.factions.faction import Faction
+from game.theater import Carrier, Lha, LocationType, PointWithHeading
+from game.theater.theatergroundobject import (
+    BuildingGroundObject,
+    CarrierGroundObject,
+    EwrGroundObject,
+    LhaGroundObject,
+    MissileSiteGroundObject,
+    SamGroundObject,
+    ShipGroundObject,
+    VehicleGroupGroundObject,
+    CoastalSiteGroundObject,
+)
+from game.version import VERSION
+from gen import namegen
+from gen.coastal.coastal_group_generator import generate_coastal_group
+from gen.defenses.armor_group_generator import generate_armor_group
+from gen.fleet.ship_group_generator import (
+    generate_carrier_group,
+    generate_lha_group,
+    generate_ship_group,
+)
+from gen.locations.preset_location_finder import MizDataLocationFinder
+from gen.missiles.missiles_group_generator import generate_missile_group
+from gen.sam.airdefensegroupgenerator import AirDefenseRange
+from gen.sam.sam_group_generator import generate_anti_air_group
+from gen.sam.ewr_group_generator import generate_ewr_group
+from . import (
+    ConflictTheater,
+    ControlPoint,
+    ControlPointType,
+    Fob,
+    OffMapSpawn,
+)
+from ..settings import Settings
+
+GroundObjectTemplates = Dict[str, Dict[str, Any]]
+
+UNIT_VARIETY = 6
+UNIT_AMOUNT_FACTOR = 16
+UNIT_COUNT_IMPORTANCE_LOG = 1.3
+
+COUNT_BY_TASK = {
+    PinpointStrike: 12,
+    CAP: 8,
+    CAS: 4,
+    AirDefence: 1,
+}
+
+
+@dataclass(frozen=True)
+class GeneratorSettings:
+    start_date: datetime
+    player_budget: int
+    enemy_budget: int
+    midgame: bool
+    inverted: bool
+    no_carrier: bool
+    no_lha: bool
+    no_player_navy: bool
+    no_enemy_navy: bool
+
+
+class GameGenerator:
+    def __init__(
+        self,
+        player: str,
+        enemy: str,
+        theater: ConflictTheater,
+        settings: Settings,
+        generator_settings: GeneratorSettings,
+    ) -> None:
+        self.player = player
+        self.enemy = enemy
+        self.theater = theater
+        self.settings = settings
+        self.generator_settings = generator_settings
+
+    def generate(self) -> Game:
+        # Reset name generator
+        namegen.reset()
+        self.prepare_theater()
+        game = Game(
+            player_name=self.player,
+            enemy_name=self.enemy,
+            theater=self.theater,
+            start_date=self.generator_settings.start_date,
+            settings=self.settings,
+            player_budget=self.generator_settings.player_budget,
+            enemy_budget=self.generator_settings.enemy_budget,
+        )
+
+        GroundObjectGenerator(game, self.generator_settings).generate()
+        game.settings.version = VERSION
+        return game
+
+    def prepare_theater(self) -> None:
+        to_remove: List[ControlPoint] = []
+        # Auto-capture half the bases if midgame.
+        if self.generator_settings.midgame:
+            control_points = self.theater.controlpoints
+            for control_point in control_points[: len(control_points) // 2]:
+                control_point.captured = True
+
+        # Remove carrier and lha, invert situation if needed
+        for cp in self.theater.controlpoints:
+            if isinstance(cp, Carrier) and self.generator_settings.no_carrier:
+                to_remove.append(cp)
+            elif isinstance(cp, Lha) and self.generator_settings.no_lha:
+                to_remove.append(cp)
+
+            if self.generator_settings.inverted:
+                cp.captured = cp.captured_invert
+
+        # do remove
+        for cp in to_remove:
+            self.theater.controlpoints.remove(cp)
+
+        # TODO: Fix this. This captures all bases for blue.
+        # reapply midgame inverted if needed
+        if self.generator_settings.midgame and self.generator_settings.inverted:
+            for i, cp in enumerate(reversed(self.theater.controlpoints)):
+                if i > len(self.theater.controlpoints):
+                    break
+                else:
+                    cp.captured = True
+
+
+class LocationFinder:
+    def __init__(self, game: Game, control_point: ControlPoint) -> None:
+        self.game = game
+        self.control_point = control_point
+        self.miz_data = MizDataLocationFinder.compute_possible_locations(
+            game.theater.terrain.name, control_point.full_name
+        )
+
+    def location_for(self, location_type: LocationType) -> Optional[PointWithHeading]:
+        position = self.control_point.preset_locations.random_for(location_type)
+        if position is not None:
+            return position
+
+        logging.warning(
+            f"No campaign location for %s Mat %s",
+            location_type.value,
+            self.control_point,
+        )
+        position = self.random_from_miz_data(
+            location_type == LocationType.OffshoreStrikeTarget
+        )
+        if position is not None:
+            return position
+
+        logging.debug(
+            f"No mizdata location for %s at %s", location_type.value, self.control_point
+        )
+        position = self.random_position(location_type)
+        if position is not None:
+            return position
+
+        logging.error(
+            f"Could not find position for %s at %s",
+            location_type.value,
+            self.control_point,
+        )
+        return None
+
+    def random_from_miz_data(self, offshore: bool) -> Optional[PointWithHeading]:
+        if offshore:
+            locations = self.miz_data.offshore_locations
+        else:
+            locations = self.miz_data.ashore_locations
+        if self.miz_data.offshore_locations:
+            preset = random.choice(locations)
+            locations.remove(preset)
+            return PointWithHeading.from_point(preset.position, preset.heading)
+        return None
+
+    def random_position(
+        self, location_type: LocationType
+    ) -> Optional[PointWithHeading]:
+        # TODO: Flesh out preset locations so we never hit this case.
+
+        if location_type == LocationType.Coastal:
+            # No coastal locations generated randomly
+            return None
+
+        logging.warning(
+            "Falling back to random location for %s at %s",
+            location_type.value,
+            self.control_point,
+        )
+
+        is_base_defense = location_type in {
+            LocationType.BaseAirDefense,
+            LocationType.Garrison,
+            LocationType.Shorad,
+        }
+
+        on_land = location_type not in {
+            LocationType.OffshoreStrikeTarget,
+            LocationType.Ship,
+        }
+
+        avoid_others = location_type not in {
+            LocationType.Garrison,
+            LocationType.MissileSite,
+            LocationType.Sam,
+            LocationType.Ship,
+            LocationType.Shorad,
+        }
+
+        if is_base_defense:
+            min_range = 400
+            max_range = 3200
+        elif location_type == LocationType.Ship:
+            min_range = 5000
+            max_range = 40000
+        elif location_type == LocationType.MissileSite:
+            min_range = 2500
+            max_range = 40000
+        else:
+            min_range = 10000
+            max_range = 40000
+
+        position = self._find_random_position(
+            min_range, max_range, on_land, is_base_defense, avoid_others
+        )
+
+        # Retry once, searching a bit further (On some big airbases, 3200 is too
+        # short (Ex : Incirlik)), but searching farther on every base would be
+        # problematic, as some base defense units would end up very far away
+        # from small airfields.
+        if position is None and is_base_defense:
+            position = self._find_random_position(
+                3200, 4800, on_land, is_base_defense, avoid_others
+            )
+        return position
+
+    def _find_random_position(
+        self,
+        min_range: int,
+        max_range: int,
+        on_ground: bool,
+        is_base_defense: bool,
+        avoid_others: bool,
+    ) -> Optional[PointWithHeading]:
+        """
+        Find a valid ground object location
+        :param on_ground: Whether it should be on ground or on sea (True = on
+        ground)
+        :param min_range: Minimal range from point
+        :param max_range: Max range from point
+        :param is_base_defense: True if the location is for base defense.
+        :return:
+        """
+        near = self.control_point.position
+        others = self.control_point.ground_objects
+
+        def is_valid(point: Optional[PointWithHeading]) -> bool:
+            if point is None:
+                return False
+
+            if on_ground and not self.game.theater.is_on_land(point):
+                return False
+            elif not on_ground and not self.game.theater.is_in_sea(point):
+                return False
+
+            if avoid_others:
+                for other in others:
+                    if other.position.distance_to_point(point) < 10000:
+                        return False
+
+            if is_base_defense:
+                # If it's a base defense we don't care how close it is to other
+                # points.
+                return True
+
+            # Else verify that it's not too close to another control point.
+            for control_point in self.game.theater.controlpoints:
+                if control_point != self.control_point:
+                    if control_point.position.distance_to_point(point) < 30000:
+                        return False
+                    for ground_obj in control_point.ground_objects:
+                        if ground_obj.position.distance_to_point(point) < 10000:
+                            return False
+            return True
+
+        for _ in range(300):
+            # Check if on land or sea
+            p = PointWithHeading.from_point(
+                near.random_point_within(max_range, min_range), random.randint(0, 360)
+            )
+            if is_valid(p):
+                return p
+        return None
+
+
+class ControlPointGroundObjectGenerator:
+    def __init__(
+        self,
+        game: Game,
+        generator_settings: GeneratorSettings,
+        control_point: ControlPoint,
+    ) -> None:
+        self.game = game
+        self.generator_settings = generator_settings
+        self.control_point = control_point
+        self.location_finder = LocationFinder(game, control_point)
+
+    @property
+    def faction_name(self) -> str:
+        if self.control_point.captured:
+            return self.game.player_name
+        else:
+            return self.game.enemy_name
+
+    @property
+    def faction(self) -> Faction:
+        return db.FACTIONS[self.faction_name]
+
+    def generate(self) -> bool:
+        self.control_point.connected_objectives = []
+        if self.faction.navy_generators:
+            # Even airbases can generate navies if they are close enough to the
+            # water. This is not controlled by the control point definition, but
+            # rather by whether or not the generator can find a valid position
+            # for the ship.
+            self.generate_navy()
+
+        return True
+
+    def generate_navy(self) -> None:
+        skip_player_navy = self.generator_settings.no_player_navy
+        if self.control_point.captured and skip_player_navy:
+            return
+
+        skip_enemy_navy = self.generator_settings.no_enemy_navy
+        if not self.control_point.captured and skip_enemy_navy:
+            return
+
+        for _ in range(self.faction.navy_group_count):
+            self.generate_ship()
+
+    def generate_ship(self) -> None:
+        point = self.location_finder.location_for(LocationType.OffshoreStrikeTarget)
+        if point is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = ShipGroundObject(
+            namegen.random_objective_name(), group_id, point, self.control_point
+        )
+
+        group = generate_ship_group(self.game, g, self.faction_name)
+        g.groups = []
+        if group is not None:
+            g.groups.append(group)
+            self.control_point.connected_objectives.append(g)
+
+
+class NoOpGroundObjectGenerator(ControlPointGroundObjectGenerator):
+    def generate(self) -> bool:
+        return True
+
+
+class CarrierGroundObjectGenerator(ControlPointGroundObjectGenerator):
+    def generate(self) -> bool:
+        if not super().generate():
+            return False
+
+        carrier_names = self.faction.carrier_names
+        if not carrier_names:
+            logging.info(
+                f"Skipping generation of {self.control_point.name} because "
+                f"{self.faction_name} has no carriers"
+            )
+            return False
+
+        # Create ground object group
+        group_id = self.game.next_group_id()
+        g = CarrierGroundObject(
+            namegen.random_objective_name(), group_id, self.control_point
+        )
+        group = generate_carrier_group(self.faction_name, self.game, g)
+        g.groups = []
+        if group is not None:
+            g.groups.append(group)
+        self.control_point.connected_objectives.append(g)
+        self.control_point.name = random.choice(carrier_names)
+        return True
+
+
+class LhaGroundObjectGenerator(ControlPointGroundObjectGenerator):
+    def generate(self) -> bool:
+        if not super().generate():
+            return False
+
+        lha_names = self.faction.helicopter_carrier_names
+        if not lha_names:
+            logging.info(
+                f"Skipping generation of {self.control_point.name} because "
+                f"{self.faction_name} has no LHAs"
+            )
+            return False
+
+        # Create ground object group
+        group_id = self.game.next_group_id()
+        g = LhaGroundObject(
+            namegen.random_objective_name(), group_id, self.control_point
+        )
+        group = generate_lha_group(self.faction_name, self.game, g)
+        g.groups = []
+        if group is not None:
+            g.groups.append(group)
+        self.control_point.connected_objectives.append(g)
+        self.control_point.name = random.choice(lha_names)
+        return True
+
+
+class BaseDefenseGenerator:
+    def __init__(self, game: Game, control_point: ControlPoint) -> None:
+        self.game = game
+        self.control_point = control_point
+        self.location_finder = LocationFinder(game, control_point)
+
+    @property
+    def faction_name(self) -> str:
+        if self.control_point.captured:
+            return self.game.player_name
+        else:
+            return self.game.enemy_name
+
+    @property
+    def faction(self) -> Faction:
+        return db.FACTIONS[self.faction_name]
+
+    def generate(self) -> None:
+        self.generate_ewr()
+        self.generate_garrison()
+        self.generate_base_defenses()
+
+    def generate_ewr(self) -> None:
+        position = self.location_finder.location_for(LocationType.BaseEwr)
+        if position is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = EwrGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            True,
+        )
+
+        group = generate_ewr_group(self.game, g, self.faction)
+        if group is None:
+            logging.error(f"Could not generate EWR at {self.control_point}")
+            return
+
+        g.groups = [group]
+        self.control_point.base_defenses.append(g)
+
+    def generate_base_defenses(self) -> None:
+        # First group has a 1/2 chance of being a SAM, 1/6 chance of SHORAD,
+        # and a 1/6 chance of a garrison.
+        #
+        # Further groups have a 1/3 chance of being SHORAD and 2/3 chance of
+        # being a garrison.
+        for i in range(random.randint(2, 5)):
+            if i == 0 and random.randint(0, 1) == 0:
+                self.generate_sam()
+            elif random.randint(0, 2) == 1:
+                self.generate_shorad()
+            else:
+                self.generate_garrison()
+
+    def generate_garrison(self) -> None:
+        position = self.location_finder.location_for(LocationType.Garrison)
+        if position is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = VehicleGroupGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            for_airbase=True,
+        )
+
+        group = generate_armor_group(self.faction_name, self.game, g)
+        if group is None:
+            logging.error(f"Could not generate garrison at {self.control_point}")
+            return
+        g.groups.append(group)
+        self.control_point.base_defenses.append(g)
+
+    def generate_sam(self) -> None:
+        position = self.location_finder.location_for(LocationType.BaseAirDefense)
+        if position is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = SamGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            for_airbase=True,
+        )
+
+        groups = generate_anti_air_group(self.game, g, self.faction)
+        if not groups:
+            logging.error(f"Could not generate SAM at {self.control_point}")
+            return
+        g.groups = groups
+        self.control_point.base_defenses.append(g)
+
+    def generate_shorad(self) -> None:
+        position = self.location_finder.location_for(LocationType.BaseAirDefense)
+        if position is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = SamGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            for_airbase=True,
+        )
+
+        groups = generate_anti_air_group(
+            self.game, g, self.faction, ranges=[{AirDefenseRange.Short}]
+        )
+        if not groups:
+            logging.error(f"Could not generate SHORAD group at {self.control_point}")
+            return
+        g.groups = groups
+        self.control_point.base_defenses.append(g)
+
+
+class FobDefenseGenerator(BaseDefenseGenerator):
+    def generate(self) -> None:
+        self.generate_garrison()
+        self.generate_fob_defenses()
+
+    def generate_fob_defenses(self):
+        # First group has a 1/2 chance of being a SHORAD,
+        # and a 1/2 chance of a garrison.
+        #
+        # Further groups have a 1/3 chance of being SHORAD and 2/3 chance of
+        # being a garrison.
+        for i in range(random.randint(2, 5)):
+            if i == 0 and random.randint(0, 1) == 0:
+                self.generate_shorad()
+            elif i == 0 and random.randint(0, 1) == 0:
+                self.generate_garrison()
+            elif random.randint(0, 2) == 1:
+                self.generate_shorad()
+            else:
+                self.generate_garrison()
+
+
+class AirbaseGroundObjectGenerator(ControlPointGroundObjectGenerator):
+    def __init__(
+        self,
+        game: Game,
+        generator_settings: GeneratorSettings,
+        control_point: ControlPoint,
+        templates: GroundObjectTemplates,
+    ) -> None:
+        super().__init__(game, generator_settings, control_point)
+        self.templates = templates
+
+    def generate(self) -> bool:
+        if not super().generate():
+            return False
+
+        BaseDefenseGenerator(self.game, self.control_point).generate()
+        self.generate_ground_points()
+
+        if self.faction.missiles:
+            self.generate_missile_sites()
+
+        if self.faction.coastal_defenses:
+            self.generate_coastal_sites()
+
+        return True
+
+    def generate_ground_points(self) -> None:
+        """Generate ground objects and AA sites for the control point."""
+        skip_sams = self.generate_required_aa()
+        skip_ewrs = self.generate_required_ewr()
+
+        if self.control_point.is_global:
+            return
+
+        # Always generate at least one AA point.
+        self.generate_aa_site()
+
+        # And between 2 and 7 other objectives.
+        amount = random.randrange(2, 7)
+        for i in range(amount):
+            # 1 in 4 additional objectives are AA.
+            if random.randint(0, 3) == 0:
+                if skip_sams > 0:
+                    skip_sams -= 1
+                else:
+                    self.generate_aa_site()
+            # 1 in 4 additional objectives are EWR.
+            elif random.randint(0, 3) == 0:
+                if skip_ewrs > 0:
+                    skip_ewrs -= 1
+                else:
+                    self.generate_ewr_site()
+            else:
+                self.generate_ground_point()
+
+    def generate_required_aa(self) -> int:
+        """Generates the AA sites that are required by the campaign.
+
+        Returns:
+            The number of AA sites that were generated.
+        """
+        presets = self.control_point.preset_locations
+        for position in presets.required_long_range_sams:
+            self.generate_aa_at(
+                position,
+                ranges=[
+                    {AirDefenseRange.Long},
+                    {AirDefenseRange.Medium},
+                    {AirDefenseRange.Short},
+                ],
+            )
+        for position in presets.required_medium_range_sams:
+            self.generate_aa_at(
+                position,
+                ranges=[
+                    {AirDefenseRange.Medium},
+                    {AirDefenseRange.Short},
+                ],
+            )
+        return len(presets.required_long_range_sams) + len(
+            presets.required_medium_range_sams
+        )
+
+    def generate_required_ewr(self) -> int:
+        """Generates the EWR sites that are required by the campaign.
+
+        Returns:
+            The number of EWR sites that were generated.
+        """
+        presets = self.control_point.preset_locations
+        for position in presets.required_ewrs:
+            self.generate_ewr_at(position)
+        return len(presets.required_ewrs)
+
+    def generate_ground_point(self) -> None:
+        try:
+            category = random.choice(self.faction.building_set)
+        except IndexError:
+            logging.exception("Faction has no buildings defined")
+            return
+
+        obj_name = namegen.random_objective_name()
+        template = random.choice(list(self.templates[category].values()))
+
+        if category == "oil":
+            location_type = LocationType.OffshoreStrikeTarget
+        else:
+            location_type = LocationType.StrikeTarget
+
+        # Pick from preset locations
+        point = self.location_finder.location_for(location_type)
+        if point is None:
+            return
+
+        object_id = 0
+        group_id = self.game.next_group_id()
+
+        # TODO: Create only one TGO per objective, each with multiple units.
+        for unit in template:
+            object_id += 1
+
+            template_point = Point(unit["offset"].x, unit["offset"].y)
+            g = BuildingGroundObject(
+                obj_name,
+                category,
+                group_id,
+                object_id,
+                point + template_point,
+                unit["heading"],
+                self.control_point,
+                unit["type"],
+            )
+
+            self.control_point.connected_objectives.append(g)
+
+    def generate_aa_site(self) -> None:
+        position = self.location_finder.location_for(LocationType.Sam)
+        if position is None:
+            return
+        self.generate_aa_at(
+            position,
+            ranges=[
+                # Prefer to use proper SAMs, but fall back to SHORADs if needed.
+                {AirDefenseRange.Long, AirDefenseRange.Medium},
+                {AirDefenseRange.Short},
+            ],
+        )
+
+    def generate_aa_at(
+        self, position: Point, ranges: Iterable[Set[AirDefenseRange]]
+    ) -> None:
+        group_id = self.game.next_group_id()
+
+        g = SamGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            for_airbase=False,
+        )
+        groups = generate_anti_air_group(self.game, g, self.faction, ranges)
+        if not groups:
+            logging.error(
+                "Could not generate air defense group for %s at %s",
+                g.name,
+                self.control_point,
+            )
+            return
+        g.groups = groups
+        self.control_point.connected_objectives.append(g)
+
+    def generate_ewr_site(self) -> None:
+        position = self.location_finder.location_for(LocationType.Ewr)
+        if position is None:
+            return
+        self.generate_ewr_at(position)
+
+    def generate_ewr_at(self, position: Point) -> None:
+        group_id = self.game.next_group_id()
+
+        g = EwrGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            for_airbase=False,
+        )
+        group = generate_ewr_group(self.game, g, self.faction)
+        if group is None:
+            logging.error(
+                "Could not generate ewr group for %s at %s",
+                g.name,
+                self.control_point,
+            )
+            return
+        g.groups = [group]
+        self.control_point.connected_objectives.append(g)
+
+    def generate_missile_sites(self) -> None:
+        for i in range(self.faction.missiles_group_count):
+            self.generate_missile_site()
+
+    def generate_missile_site(self) -> None:
+        position = self.location_finder.location_for(LocationType.MissileSite)
+        if position is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = MissileSiteGroundObject(
+            namegen.random_objective_name(), group_id, position, self.control_point
+        )
+        group = generate_missile_group(self.game, g, self.faction_name)
+        g.groups = []
+        if group is not None:
+            g.groups.append(group)
+            self.control_point.connected_objectives.append(g)
+        return
+
+    def generate_coastal_sites(self) -> None:
+        for i in range(self.faction.coastal_group_count):
+            self.generate_coastal_site()
+
+    def generate_coastal_site(self) -> None:
+        position = self.location_finder.location_for(LocationType.Coastal)
+        if position is None:
+            return
+
+        group_id = self.game.next_group_id()
+
+        g = CoastalSiteGroundObject(
+            namegen.random_objective_name(),
+            group_id,
+            position,
+            self.control_point,
+            position.heading,
+        )
+        group = generate_coastal_group(self.game, g, self.faction_name)
+        g.groups = []
+        if group is not None:
+            g.groups.append(group)
+            self.control_point.connected_objectives.append(g)
+        return
+
+
+class FobGroundObjectGenerator(AirbaseGroundObjectGenerator):
+    def generate(self) -> bool:
+        self.generate_fob()
+        FobDefenseGenerator(self.game, self.control_point).generate()
+        self.generate_required_aa()
+        return True
+
+    def generate_fob(self) -> None:
+        try:
+            category = self.faction.building_set[self.faction.building_set.index("fob")]
+        except IndexError:
+            logging.exception("Faction has no fob buildings defined")
+            return
+
+        obj_name = self.control_point.name
+        template = random.choice(list(self.templates[category].values()))
+        point = self.control_point.position
+        # Pick from preset locations
+        object_id = 0
+        group_id = self.game.next_group_id()
+
+        # TODO: Create only one TGO per objective, each with multiple units.
+        for unit in template:
+            object_id += 1
+
+            template_point = Point(unit["offset"].x, unit["offset"].y)
+            g = BuildingGroundObject(
+                obj_name,
+                category,
+                group_id,
+                object_id,
+                point + template_point,
+                unit["heading"],
+                self.control_point,
+                unit["type"],
+                airbase_group=True,
+            )
+            self.control_point.connected_objectives.append(g)
+
+
+class GroundObjectGenerator:
+    def __init__(self, game: Game, generator_settings: GeneratorSettings) -> None:
+        self.game = game
+        self.generator_settings = generator_settings
+        with open("resources/groundobject_templates.p", "rb") as f:
+            self.templates: GroundObjectTemplates = pickle.load(f)
+
+    def generate(self) -> None:
+        # Copied so we can remove items from the original list without breaking
+        # the iterator.
+        control_points = list(self.game.theater.controlpoints)
+        for control_point in control_points:
+            if not self.generate_for_control_point(control_point):
+                self.game.theater.controlpoints.remove(control_point)
+
+    def generate_for_control_point(self, control_point: ControlPoint) -> bool:
+        generator: ControlPointGroundObjectGenerator
+        if control_point.cptype == ControlPointType.AIRCRAFT_CARRIER_GROUP:
+            generator = CarrierGroundObjectGenerator(
+                self.game, self.generator_settings, control_point
+            )
+        elif control_point.cptype == ControlPointType.LHA_GROUP:
+            generator = LhaGroundObjectGenerator(
+                self.game, self.generator_settings, control_point
+            )
+        elif isinstance(control_point, OffMapSpawn):
+            generator = NoOpGroundObjectGenerator(
+                self.game, self.generator_settings, control_point
+            )
+        elif isinstance(control_point, Fob):
+            generator = FobGroundObjectGenerator(
+                self.game, self.generator_settings, control_point, self.templates
+            )
+        else:
+            generator = AirbaseGroundObjectGenerator(
+                self.game, self.generator_settings, control_point, self.templates
+            )
+        return generator.generate()

game/theater/theatergroundobject.py

@@ -0,0 +1,501 @@
+from __future__ import annotations
+
+import itertools
+import logging
+from typing import Iterator, List, TYPE_CHECKING
+
+from dcs.mapping import Point
+from dcs.unit import Unit
+from dcs.unitgroup import Group
+
+from .. import db
+from ..data.radar_db import UNITS_WITH_RADAR
+from ..utils import Distance, meters
+
+if TYPE_CHECKING:
+    from .controlpoint import ControlPoint
+    from gen.flights.flight import FlightType
+
+from .missiontarget import MissionTarget
+
+NAME_BY_CATEGORY = {
+    "power": "Power plant",
+    "ammo": "Ammo depot",
+    "fuel": "Fuel depot",
+    "aa": "AA Defense Site",
+    "ware": "Warehouse",
+    "farp": "FARP",
+    "fob": "FOB",
+    "factory": "Factory",
+    "comms": "Comms. tower",
+    "oil": "Oil platform",
+    "derrick": "Derrick",
+    "ww2bunker": "Bunker",
+    "village": "Village",
+    "allycamp": "Camp",
+    "EWR": "EWR",
+}
+
+ABBREV_NAME = {
+    "power": "PLANT",
+    "ammo": "AMMO",
+    "fuel": "FUEL",
+    "aa": "AA",
+    "ware": "WARE",
+    "farp": "FARP",
+    "fob": "FOB",
+    "factory": "FACTORY",
+    "comms": "COMMST",
+    "oil": "OILP",
+    "derrick": "DERK",
+    "ww2bunker": "BUNK",
+    "village": "VLG",
+    "allycamp": "CMP",
+}
+
+CATEGORY_MAP = {
+    # Special cases
+    "CARRIER": ["CARRIER"],
+    "LHA": ["LHA"],
+    "aa": ["AA"],
+    # Buildings
+    "power": [
+        "Workshop A",
+        "Electric power box",
+        "Garage small A",
+        "Farm B",
+        "Repair workshop",
+        "Garage B",
+    ],
+    "ware": ["Warehouse", "Hangar A"],
+    "fuel": ["Tank", "Tank 2", "Tank 3", "Fuel tank"],
+    "ammo": [".Ammunition depot", "Hangar B"],
+    "farp": [
+        "FARP Tent",
+        "FARP Ammo Dump Coating",
+        "FARP Fuel Depot",
+        "FARP Command Post",
+        "FARP CP Blindage",
+    ],
+    "fob": ["Bunker 2", "Bunker 1", "Garage small B", ".Command Center", "Barracks 2"],
+    "factory": ["Tech combine", "Tech hangar A"],
+    "comms": ["TV tower", "Comms tower M"],
+    "oil": ["Oil platform"],
+    "derrick": ["Oil derrick", "Pump station", "Subsidiary structure 2"],
+    "ww2bunker": [
+        "Siegfried Line",
+        "Fire Control Bunker",
+        "SK_C_28_naval_gun",
+        "Concertina Wire",
+        "Czech hedgehogs 1",
+    ],
+    "village": ["Small house 1B", "Small House 1A", "Small warehouse 1"],
+    "allycamp": [],
+}
+
+
+class TheaterGroundObject(MissionTarget):
+    def __init__(
+        self,
+        name: str,
+        category: str,
+        group_id: int,
+        position: Point,
+        heading: int,
+        control_point: ControlPoint,
+        dcs_identifier: str,
+        airbase_group: bool,
+        sea_object: bool,
+    ) -> None:
+        super().__init__(name, position)
+        self.category = category
+        self.group_id = group_id
+        self.heading = heading
+        self.control_point = control_point
+        self.dcs_identifier = dcs_identifier
+        self.airbase_group = airbase_group
+        self.sea_object = sea_object
+        self.groups: List[Group] = []
+
+    @property
+    def is_dead(self) -> bool:
+        return self.alive_unit_count == 0
+
+    @property
+    def units(self) -> List[Unit]:
+        """
+        :return: all the units at this location
+        """
+        return list(itertools.chain.from_iterable([g.units for g in self.groups]))
+
+    @property
+    def group_name(self) -> str:
+        """The name of the unit group."""
+        return f"{self.category}|{self.group_id}"
+
+    @property
+    def waypoint_name(self) -> str:
+        return f"[{self.name}] {self.category}"
+
+    def __str__(self) -> str:
+        return NAME_BY_CATEGORY[self.category]
+
+    def is_same_group(self, identifier: str) -> bool:
+        return self.group_id == identifier
+
+    @property
+    def obj_name(self) -> str:
+        return self.name
+
+    @property
+    def faction_color(self) -> str:
+        return "BLUE" if self.control_point.captured else "RED"
+
+    def is_friendly(self, to_player: bool) -> bool:
+        return self.control_point.is_friendly(to_player)
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if self.is_friendly(for_player):
+            yield from [
+                # TODO: FlightType.LOGISTICS
+                # TODO: FlightType.TROOP_TRANSPORT
+            ]
+        else:
+            yield from [
+                FlightType.STRIKE,
+                FlightType.BAI,
+            ]
+        yield from super().mission_types(for_player)
+
+    @property
+    def alive_unit_count(self) -> int:
+        return sum(len(g.units) for g in self.groups)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return False
+
+    @property
+    def has_radar(self) -> bool:
+        """Returns True if the ground object contains a unit with radar."""
+        for group in self.groups:
+            for unit in group.units:
+                if db.unit_type_from_name(unit.type) in UNITS_WITH_RADAR:
+                    return True
+        return False
+
+    def _max_range_of_type(self, group: Group, range_type: str) -> Distance:
+        if not self.might_have_aa:
+            return meters(0)
+
+        max_range = meters(0)
+        for u in group.units:
+            unit = db.unit_type_from_name(u.type)
+            if unit is None:
+                logging.error(f"Unknown unit type {u.type}")
+                continue
+
+            # Some units in pydcs have detection_range/threat_range defined,
+            # but explicitly set to None.
+            unit_range = getattr(unit, range_type, None)
+            if unit_range is not None:
+                max_range = max(max_range, meters(unit_range))
+        return max_range
+
+    def detection_range(self, group: Group) -> Distance:
+        return self._max_range_of_type(group, "detection_range")
+
+    def threat_range(self, group: Group) -> Distance:
+        if not self.detection_range(group):
+            # For simple SAMs like shilkas, the unit has both a threat and
+            # detection range. For complex sites like SA-2s, the launcher has a
+            # threat range and the search/track radars have detection ranges. If
+            # the site has no detection range it has no radars and can't fire,
+            # so it's not actually a threat even if it still has launchers.
+            return meters(0)
+        return self._max_range_of_type(group, "threat_range")
+
+
+class BuildingGroundObject(TheaterGroundObject):
+    def __init__(
+        self,
+        name: str,
+        category: str,
+        group_id: int,
+        object_id: int,
+        position: Point,
+        heading: int,
+        control_point: ControlPoint,
+        dcs_identifier: str,
+        airbase_group=False,
+    ) -> None:
+        super().__init__(
+            name=name,
+            category=category,
+            group_id=group_id,
+            position=position,
+            heading=heading,
+            control_point=control_point,
+            dcs_identifier=dcs_identifier,
+            airbase_group=airbase_group,
+            sea_object=False,
+        )
+        self.object_id = object_id
+        # Other TGOs track deadness based on the number of alive units, but
+        # buildings don't have groups assigned to the TGO.
+        self._dead = False
+
+    @property
+    def group_name(self) -> str:
+        """The name of the unit group."""
+        return f"{self.category}|{self.group_id}|{self.object_id}"
+
+    @property
+    def waypoint_name(self) -> str:
+        return f"{super().waypoint_name} #{self.object_id}"
+
+    @property
+    def is_dead(self) -> bool:
+        if not hasattr(self, "_dead"):
+            self._dead = False
+        return self._dead
+
+    def kill(self) -> None:
+        self._dead = True
+
+
+class NavalGroundObject(TheaterGroundObject):
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if not self.is_friendly(for_player):
+            yield FlightType.ANTISHIP
+        yield from super().mission_types(for_player)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return True
+
+
+class GenericCarrierGroundObject(NavalGroundObject):
+    pass
+
+
+# TODO: Why is this both a CP and a TGO?
+class CarrierGroundObject(GenericCarrierGroundObject):
+    def __init__(self, name: str, group_id: int, control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="CARRIER",
+            group_id=group_id,
+            position=control_point.position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="CARRIER",
+            airbase_group=True,
+            sea_object=True,
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them,
+        # add to EWR.
+        return f"{self.faction_color}|EWR|{super().group_name}"
+
+
+# TODO: Why is this both a CP and a TGO?
+class LhaGroundObject(GenericCarrierGroundObject):
+    def __init__(self, name: str, group_id: int, control_point: ControlPoint) -> None:
+        super().__init__(
+            name=name,
+            category="LHA",
+            group_id=group_id,
+            position=control_point.position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="LHA",
+            airbase_group=True,
+            sea_object=True,
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them,
+        # add to EWR.
+        return f"{self.faction_color}|EWR|{super().group_name}"
+
+
+class MissileSiteGroundObject(TheaterGroundObject):
+    def __init__(
+        self, name: str, group_id: int, position: Point, control_point: ControlPoint
+    ) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=False,
+            sea_object=False,
+        )
+
+
+class CoastalSiteGroundObject(TheaterGroundObject):
+    def __init__(
+        self,
+        name: str,
+        group_id: int,
+        position: Point,
+        control_point: ControlPoint,
+        heading,
+    ) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=heading,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=False,
+            sea_object=False,
+        )
+
+
+class BaseDefenseGroundObject(TheaterGroundObject):
+    """Base type for all base defenses."""
+
+
+# TODO: Differentiate types.
+# This type gets used both for AA sites (SAM, AAA, or SHORAD). These should each
+# be split into their own types.
+class SamGroundObject(BaseDefenseGroundObject):
+    def __init__(
+        self,
+        name: str,
+        group_id: int,
+        position: Point,
+        control_point: ControlPoint,
+        for_airbase: bool,
+    ) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=for_airbase,
+            sea_object=False,
+        )
+        # Set by the SAM unit generator if the generated group is compatible
+        # with Skynet.
+        self.skynet_capable = False
+
+    @property
+    def group_name(self) -> str:
+        if self.skynet_capable:
+            # Prefix the group names of SAM sites with the side color so Skynet
+            # can find them.
+            return f"{self.faction_color}|SAM|{self.group_id}"
+        else:
+            return super().group_name
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if not self.is_friendly(for_player):
+            yield FlightType.DEAD
+        yield from super().mission_types(for_player)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return True
+
+
+class VehicleGroupGroundObject(BaseDefenseGroundObject):
+    def __init__(
+        self,
+        name: str,
+        group_id: int,
+        position: Point,
+        control_point: ControlPoint,
+        for_airbase: bool,
+    ) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=for_airbase,
+            sea_object=False,
+        )
+
+
+class EwrGroundObject(BaseDefenseGroundObject):
+    def __init__(
+        self,
+        name: str,
+        group_id: int,
+        position: Point,
+        control_point: ControlPoint,
+        for_airbase: bool,
+    ) -> None:
+        super().__init__(
+            name=name,
+            category="EWR",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="EWR",
+            airbase_group=for_airbase,
+            sea_object=False,
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them.
+        return f"{self.faction_color}|{super().group_name}"
+
+    def mission_types(self, for_player: bool) -> Iterator[FlightType]:
+        from gen.flights.flight import FlightType
+
+        if not self.is_friendly(for_player):
+            yield FlightType.DEAD
+        yield from super().mission_types(for_player)
+
+    @property
+    def might_have_aa(self) -> bool:
+        return True
+
+
+class ShipGroundObject(NavalGroundObject):
+    def __init__(
+        self, name: str, group_id: int, position: Point, control_point: ControlPoint
+    ) -> None:
+        super().__init__(
+            name=name,
+            category="aa",
+            group_id=group_id,
+            position=position,
+            heading=0,
+            control_point=control_point,
+            dcs_identifier="AA",
+            airbase_group=False,
+            sea_object=True,
+        )
+
+    @property
+    def group_name(self) -> str:
+        # Prefix the group names with the side color so Skynet can find them,
+        # add to EWR.
+        return f"{self.faction_color}|EWR|{super().group_name}"

game/threatzones.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from functools import singledispatchmethod
+from typing import Optional, TYPE_CHECKING, Union
+
+from dcs.mapping import Point as DcsPoint
+from shapely.geometry import (
+    LineString,
+    MultiPolygon,
+    Point as ShapelyPoint,
+    Polygon,
+)
+from shapely.geometry.base import BaseGeometry
+from shapely.ops import nearest_points, unary_union
+
+from game.theater import ControlPoint
+from game.utils import Distance, meters, nautical_miles
+from gen import Conflict
+from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.flights.flight import Flight
+
+if TYPE_CHECKING:
+    from game import Game
+
+
+ThreatPoly = Union[MultiPolygon, Polygon]
+
+
+class ThreatZones:
+    def __init__(self, airbases: ThreatPoly, air_defenses: ThreatPoly) -> None:
+        self.airbases = airbases
+        self.air_defenses = air_defenses
+        self.all = unary_union([airbases, air_defenses])
+
+    def closest_boundary(self, point: DcsPoint) -> DcsPoint:
+        boundary, _ = nearest_points(
+            self.all.boundary, self.dcs_to_shapely_point(point)
+        )
+        return DcsPoint(boundary.x, boundary.y)
+
+    @singledispatchmethod
+    def threatened(self, position) -> bool:
+        raise NotImplementedError
+
+    @threatened.register
+    def _threatened_geometry(self, position: BaseGeometry) -> bool:
+        return self.all.intersects(position)
+
+    @threatened.register
+    def _threatened_dcs_point(self, position: DcsPoint) -> bool:
+        return self.all.intersects(self.dcs_to_shapely_point(position))
+
+    def path_threatened(self, a: DcsPoint, b: DcsPoint) -> bool:
+        return self.threatened(
+            LineString([self.dcs_to_shapely_point(a), self.dcs_to_shapely_point(b)])
+        )
+
+    @singledispatchmethod
+    def threatened_by_aircraft(self, target) -> bool:
+        raise NotImplementedError
+
+    @threatened_by_aircraft.register
+    def _threatened_by_aircraft_geom(self, position: BaseGeometry) -> bool:
+        return self.airbases.intersects(position)
+
+    @threatened_by_aircraft.register
+    def _threatened_by_aircraft_flight(self, flight: Flight) -> bool:
+        return self.threatened_by_aircraft(
+            LineString((self.dcs_to_shapely_point(p.position) for p in flight.points))
+        )
+
+    @singledispatchmethod
+    def threatened_by_air_defense(self, target) -> bool:
+        raise NotImplementedError
+
+    @threatened_by_air_defense.register
+    def _threatened_by_air_defense_geom(self, position: BaseGeometry) -> bool:
+        return self.air_defenses.intersects(position)
+
+    @threatened_by_air_defense.register
+    def _threatened_by_air_defense_flight(self, flight: Flight) -> bool:
+        return self.threatened_by_air_defense(
+            LineString((self.dcs_to_shapely_point(p.position) for p in flight.points))
+        )
+
+    @classmethod
+    def closest_enemy_airbase(
+        cls, location: ControlPoint, max_distance: Distance
+    ) -> Optional[ControlPoint]:
+        airfields = ObjectiveDistanceCache.get_closest_airfields(location)
+        for airfield in airfields.airfields_within(max_distance):
+            if airfield.captured != location.captured:
+                return airfield
+        return None
+
+    @classmethod
+    def barcap_threat_range(cls, game: Game, control_point: ControlPoint) -> Distance:
+        doctrine = game.faction_for(control_point.captured).doctrine
+        cap_threat_range = (
+            doctrine.cap_max_distance_from_cp + doctrine.cap_engagement_range
+        )
+        opposing_airfield = cls.closest_enemy_airbase(
+            control_point, cap_threat_range * 2
+        )
+        if opposing_airfield is None:
+            return cap_threat_range
+
+        airfield_distance = meters(
+            opposing_airfield.position.distance_to_point(control_point.position)
+        )
+
+        # BARCAPs should not commit further than halfway to the closest enemy
+        # airfield (with some breathing room) to avoid those missions becoming
+        # offensive. For dissimilar doctrines we could weight this so that, as
+        # an example, modern US goes no closer than 70% of the way to the WW2
+        # German base, and the Germans go no closer than 30% of the way to the
+        # US base, but for now equal weighting is fine.
+        max_distance = airfield_distance * 0.45
+        return min(cap_threat_range, max_distance)
+
+    @classmethod
+    def for_faction(cls, game: Game, player: bool) -> ThreatZones:
+        """Generates the threat zones projected by the given coalition.
+
+        Args:
+            game: The game to generate the threat zone for.
+            player: True if the coalition projecting the threat zone belongs to
+            the player.
+
+        Returns:
+            The threat zones projected by the given coalition. If the threat
+            zone belongs to the player, it is the zone that will be avoided by
+            the enemy and vice versa.
+        """
+        air_threats = []
+        air_defenses = []
+        for control_point in game.theater.controlpoints:
+            if control_point.captured != player:
+                continue
+            if control_point.runway_is_operational():
+                point = ShapelyPoint(control_point.position.x, control_point.position.y)
+                cap_threat_range = cls.barcap_threat_range(game, control_point)
+                air_threats.append(point.buffer(cap_threat_range.meters))
+
+            for tgo in control_point.ground_objects:
+                for group in tgo.groups:
+                    threat_range = tgo.threat_range(group)
+                    # Any system with a shorter range than this is not worth
+                    # even avoiding.
+                    if threat_range > nautical_miles(3):
+                        point = ShapelyPoint(tgo.position.x, tgo.position.y)
+                        threat_zone = point.buffer(threat_range.meters)
+                        air_defenses.append(threat_zone)
+
+        return cls(
+            airbases=unary_union(air_threats), air_defenses=unary_union(air_defenses)
+        )
+
+    @staticmethod
+    def dcs_to_shapely_point(point: DcsPoint) -> ShapelyPoint:
+        return ShapelyPoint(point.x, point.y)

game/unitmap.py

@@ -0,0 +1,140 @@
+"""Maps generated units back to their Liberation types."""
+from dataclasses import dataclass
+from typing import Dict, Optional, Type
+
+from dcs.unit import Unit
+from dcs.unitgroup import FlyingGroup, Group, VehicleGroup
+from dcs.unittype import VehicleType
+
+from game import db
+from game.theater import Airfield, ControlPoint, TheaterGroundObject
+from game.theater.theatergroundobject import BuildingGroundObject
+from gen.flights.flight import Flight
+
+
+@dataclass(frozen=True)
+class FrontLineUnit:
+    unit_type: Type[VehicleType]
+    origin: ControlPoint
+
+
+@dataclass(frozen=True)
+class GroundObjectUnit:
+    ground_object: TheaterGroundObject
+    group: Group
+    unit: Unit
+
+
+@dataclass(frozen=True)
+class Building:
+    ground_object: BuildingGroundObject
+
+
+class UnitMap:
+    def __init__(self) -> None:
+        self.aircraft: Dict[str, Flight] = {}
+        self.airfields: Dict[str, Airfield] = {}
+        self.front_line_units: Dict[str, FrontLineUnit] = {}
+        self.ground_object_units: Dict[str, GroundObjectUnit] = {}
+        self.buildings: Dict[str, Building] = {}
+
+    def add_aircraft(self, group: FlyingGroup, flight: Flight) -> None:
+        for unit in group.units:
+            # The actual name is a String (the pydcs translatable string), which
+            # doesn't define __eq__.
+            name = str(unit.name)
+            if name in self.aircraft:
+                raise RuntimeError(f"Duplicate unit name: {name}")
+            self.aircraft[name] = flight
+
+    def flight(self, unit_name: str) -> Optional[Flight]:
+        return self.aircraft.get(unit_name, None)
+
+    def add_airfield(self, airfield: Airfield) -> None:
+        if airfield.name in self.airfields:
+            raise RuntimeError(f"Duplicate airfield: {airfield.name}")
+        self.airfields[airfield.name] = airfield
+
+    def airfield(self, name: str) -> Optional[Airfield]:
+        return self.airfields.get(name, None)
+
+    def add_front_line_units(self, group: Group, origin: ControlPoint) -> None:
+        for unit in group.units:
+            # The actual name is a String (the pydcs translatable string), which
+            # doesn't define __eq__.
+            name = str(unit.name)
+            if name in self.front_line_units:
+                raise RuntimeError(f"Duplicate front line unit: {name}")
+            unit_type = db.unit_type_from_name(unit.type)
+            if unit_type is None:
+                raise RuntimeError(f"Unknown unit type: {unit.type}")
+            if not issubclass(unit_type, VehicleType):
+                raise RuntimeError(
+                    f"{name} is a {unit_type.__name__}, expected a VehicleType"
+                )
+            self.front_line_units[name] = FrontLineUnit(unit_type, origin)
+
+    def front_line_unit(self, name: str) -> Optional[FrontLineUnit]:
+        return self.front_line_units.get(name, None)
+
+    def add_ground_object_units(
+        self,
+        ground_object: TheaterGroundObject,
+        persistence_group: Group,
+        miz_group: Group,
+    ) -> None:
+        """Adds a group associated with a TGO to the unit map.
+
+        Args:
+            ground_object: The TGO the group is associated with.
+            persistence_group: The Group tracked by the TGO itself.
+            miz_group: The Group spawned for the miz to match persistence_group.
+        """
+        # Deaths for units at TGOs are recorded in the Group that is contained
+        # by the TGO, but when groundobjectsgen populates the miz it creates new
+        # groups based on that template, so the units and groups in the miz are
+        # not a direct match for the units and groups that persist in the TGO.
+        #
+        # This means that we need to map the spawned unit names back to the
+        # original TGO units, not the ones in the miz.
+        if len(persistence_group.units) != len(miz_group.units):
+            raise ValueError("Persistent group does not match generated group")
+        unit_pairs = zip(persistence_group.units, miz_group.units)
+        for persistent_unit, miz_unit in unit_pairs:
+            # The actual name is a String (the pydcs translatable string), which
+            # doesn't define __eq__.
+            name = str(miz_unit.name)
+            if name in self.ground_object_units:
+                raise RuntimeError(f"Duplicate TGO unit: {name}")
+            self.ground_object_units[name] = GroundObjectUnit(
+                ground_object, persistence_group, persistent_unit
+            )
+
+    def ground_object_unit(self, name: str) -> Optional[GroundObjectUnit]:
+        return self.ground_object_units.get(name, None)
+
+    def add_building(self, ground_object: BuildingGroundObject, group: Group) -> None:
+        # The actual name is a String (the pydcs translatable string), which
+        # doesn't define __eq__.
+        # The name of the initiator in the DCS dead event will have " object"
+        # appended for statics.
+        name = f"{group.name} object"
+        if name in self.buildings:
+            raise RuntimeError(f"Duplicate TGO unit: {name}")
+        self.buildings[name] = Building(ground_object)
+
+    def add_fortification(
+        self, ground_object: BuildingGroundObject, group: VehicleGroup
+    ) -> None:
+        if len(group.units) != 1:
+            raise ValueError("Fortification groups must have exactly one unit.")
+        unit = group.units[0]
+        # The actual name is a String (the pydcs translatable string), which
+        # doesn't define __eq__.
+        name = str(unit.name)
+        if name in self.buildings:
+            raise RuntimeError(f"Duplicate TGO unit: {name}")
+        self.buildings[name] = Building(ground_object)
+
+    def building_or_fortification(self, name: str) -> Optional[Building]:
+        return self.buildings.get(name, None)

game/utils.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Union
+
+METERS_TO_FEET = 3.28084
+FEET_TO_METERS = 1 / METERS_TO_FEET
+NM_TO_METERS = 1852
+METERS_TO_NM = 1 / NM_TO_METERS
+
+KNOTS_TO_KPH = 1.852
+KPH_TO_KNOTS = 1 / KNOTS_TO_KPH
+MS_TO_KPH = 3.6
+KPH_TO_MS = 1 / MS_TO_KPH
+
+
+def heading_sum(h, a) -> int:
+    h += a
+    if h > 360:
+        return h - 360
+    elif h < 0:
+        return 360 + h
+    else:
+        return h
+
+
+def opposite_heading(h):
+    return heading_sum(h, 180)
+
+
+@dataclass(frozen=True, order=True)
+class Distance:
+    distance_in_meters: float
+
+    @property
+    def feet(self) -> float:
+        return self.distance_in_meters * METERS_TO_FEET
+
+    @property
+    def meters(self) -> float:
+        return self.distance_in_meters
+
+    @property
+    def nautical_miles(self) -> float:
+        return self.distance_in_meters * METERS_TO_NM
+
+    @classmethod
+    def from_feet(cls, value: float) -> Distance:
+        return cls(value * FEET_TO_METERS)
+
+    @classmethod
+    def from_meters(cls, value: float) -> Distance:
+        return cls(value)
+
+    @classmethod
+    def from_nautical_miles(cls, value: float) -> Distance:
+        return cls(value * NM_TO_METERS)
+
+    def __add__(self, other: Distance) -> Distance:
+        return meters(self.meters + other.meters)
+
+    def __sub__(self, other: Distance) -> Distance:
+        return meters(self.meters - other.meters)
+
+    def __mul__(self, other: Union[float, int]) -> Distance:
+        return meters(self.meters * other)
+
+    def __truediv__(self, other: Union[float, int]) -> Distance:
+        return meters(self.meters / other)
+
+    def __floordiv__(self, other: Union[float, int]) -> Distance:
+        return meters(self.meters // other)
+
+    def __bool__(self) -> bool:
+        return not math.isclose(self.meters, 0.0)
+
+
+def feet(value: float) -> Distance:
+    return Distance.from_feet(value)
+
+
+def meters(value: float) -> Distance:
+    return Distance.from_meters(value)
+
+
+def nautical_miles(value: float) -> Distance:
+    return Distance.from_nautical_miles(value)
+
+
+@dataclass(frozen=True, order=True)
+class Speed:
+    speed_in_kph: float
+
+    @property
+    def knots(self) -> float:
+        return self.speed_in_kph * KPH_TO_KNOTS
+
+    @property
+    def kph(self) -> float:
+        return self.speed_in_kph
+
+    @property
+    def meters_per_second(self) -> float:
+        return self.speed_in_kph * KPH_TO_MS
+
+    def mach(self, altitude: Distance = meters(0)) -> float:
+        c_sound = mach(1, altitude)
+        return self.speed_in_kph / c_sound.kph
+
+    @classmethod
+    def from_knots(cls, value: float) -> Speed:
+        return cls(value * KNOTS_TO_KPH)
+
+    @classmethod
+    def from_kph(cls, value: float) -> Speed:
+        return cls(value)
+
+    @classmethod
+    def from_meters_per_second(cls, value: float) -> Speed:
+        return cls(value * MS_TO_KPH)
+
+    @classmethod
+    def from_mach(cls, value: float, altitude: Distance) -> Speed:
+        # https://www.grc.nasa.gov/WWW/K-12/airplane/atmos.html
+        if altitude <= feet(36152):
+            temperature_f = 59 - 0.00356 * altitude.feet
+        else:
+            # There's another formula for altitudes over 82k feet, but we better
+            # not be planning waypoints that high...
+            temperature_f = -70
+
+        temperature_k = (temperature_f + 459.67) * (5 / 9)
+
+        # https://www.engineeringtoolbox.com/specific-heat-ratio-d_602.html
+        # Dependent on temperature, but varies very little (+/-0.001)
+        # between -40F and 180F.
+        heat_capacity_ratio = 1.4
+
+        # https://www.grc.nasa.gov/WWW/K-12/airplane/sound.html
+        gas_constant = 286  # m^2/s^2/K
+        c_sound = math.sqrt(heat_capacity_ratio * gas_constant * temperature_k)
+        return mps(c_sound) * value
+
+    def __add__(self, other: Speed) -> Speed:
+        return kph(self.kph + other.kph)
+
+    def __sub__(self, other: Speed) -> Speed:
+        return kph(self.kph - other.kph)
+
+    def __mul__(self, other: Union[float, int]) -> Speed:
+        return kph(self.kph * other)
+
+    def __truediv__(self, other: Union[float, int]) -> Speed:
+        return kph(self.kph / other)
+
+    def __floordiv__(self, other: Union[float, int]) -> Speed:
+        return kph(self.kph // other)
+
+    def __bool__(self) -> bool:
+        return not math.isclose(self.kph, 0.0)
+
+
+def knots(value: float) -> Speed:
+    return Speed.from_knots(value)
+
+
+def kph(value: float) -> Speed:
+    return Speed.from_kph(value)
+
+
+def mps(value: float) -> Speed:
+    return Speed.from_meters_per_second(value)
+
+
+def mach(value: float, altitude: Distance) -> Speed:
+    return Speed.from_mach(value, altitude)
+
+
+SPEED_OF_SOUND_AT_SEA_LEVEL = knots(661.5)

game/version.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+
+def _build_version_string() -> str:
+    components = ["2.5"]
+    build_number_path = Path("resources/buildnumber")
+    if build_number_path.exists():
+        with build_number_path.open("r") as build_number_file:
+            components.append(build_number_file.readline())
+
+    if not Path("resources/final").exists():
+        components.append("preview")
+
+    return "-".join(components)
+
+
+#: Current version of Liberation.
+VERSION = _build_version_string()

game/weather.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import datetime
+import logging
+import random
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional, TYPE_CHECKING
+
+from dcs.cloud_presets import Clouds as PydcsClouds
+from dcs.weather import CloudPreset, Weather as PydcsWeather, Wind
+
+from game.settings import Settings
+from game.utils import Distance, meters
+
+if TYPE_CHECKING:
+    from game.theater import ConflictTheater
+
+
+class TimeOfDay(Enum):
+    Dawn = "dawn"
+    Day = "day"
+    Dusk = "dusk"
+    Night = "night"
+
+
+@dataclass(frozen=True)
+class WindConditions:
+    at_0m: Wind
+    at_2000m: Wind
+    at_8000m: Wind
+
+
+@dataclass(frozen=True)
+class Clouds:
+    base: int
+    density: int
+    thickness: int
+    precipitation: PydcsWeather.Preceptions
+    preset: Optional[CloudPreset] = field(default=None)
+
+    @classmethod
+    def random_preset(cls, rain: bool) -> Clouds:
+        clouds = (p.value for p in PydcsClouds)
+        if rain:
+            presets = [p for p in clouds if "Rain" in p.name]
+        else:
+            presets = [p for p in clouds if "Rain" not in p.name]
+        preset = random.choice(presets)
+        return Clouds(
+            base=random.randint(preset.min_base, preset.max_base),
+            density=0,
+            thickness=0,
+            precipitation=PydcsWeather.Preceptions.None_,
+            preset=preset,
+        )
+
+
+@dataclass(frozen=True)
+class Fog:
+    visibility: Distance
+    thickness: int
+
+
+class Weather:
+    def __init__(self) -> None:
+        self.clouds = self.generate_clouds()
+        self.fog = self.generate_fog()
+        self.wind = self.generate_wind()
+
+    def generate_clouds(self) -> Optional[Clouds]:
+        raise NotImplementedError
+
+    def generate_fog(self) -> Optional[Fog]:
+        if random.randrange(5) != 0:
+            return None
+        return Fog(
+            visibility=meters(random.randint(2500, 5000)),
+            thickness=random.randint(100, 500),
+        )
+
+    def generate_wind(self) -> WindConditions:
+        raise NotImplementedError
+
+    @staticmethod
+    def random_wind(minimum: int, maximum) -> WindConditions:
+        wind_direction = random.randint(0, 360)
+        at_0m_factor = 1
+        at_2000m_factor = 2
+        at_8000m_factor = 3
+        base_wind = random.randint(minimum, maximum)
+
+        return WindConditions(
+            # Always some wind to make the smoke move a bit.
+            at_0m=Wind(wind_direction, max(1, base_wind * at_0m_factor)),
+            at_2000m=Wind(wind_direction, base_wind * at_2000m_factor),
+            at_8000m=Wind(wind_direction, base_wind * at_8000m_factor),
+        )
+
+    @staticmethod
+    def random_cloud_base() -> int:
+        return random.randint(2000, 3000)
+
+    @staticmethod
+    def random_cloud_thickness() -> int:
+        return random.randint(100, 400)
+
+
+class ClearSkies(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return None
+
+    def generate_fog(self) -> Optional[Fog]:
+        return None
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 0)
+
+
+class Cloudy(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return Clouds.random_preset(rain=False)
+
+    def generate_fog(self) -> Optional[Fog]:
+        # DCS 2.7 says to not use fog with the cloud presets.
+        return None
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 4)
+
+
+class Raining(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return Clouds.random_preset(rain=True)
+
+    def generate_fog(self) -> Optional[Fog]:
+        # DCS 2.7 says to not use fog with the cloud presets.
+        return None
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 6)
+
+
+class Thunderstorm(Weather):
+    def generate_clouds(self) -> Optional[Clouds]:
+        return Clouds(
+            base=self.random_cloud_base(),
+            density=random.randint(9, 10),
+            thickness=self.random_cloud_thickness(),
+            precipitation=PydcsWeather.Preceptions.Thunderstorm,
+        )
+
+    def generate_wind(self) -> WindConditions:
+        return self.random_wind(0, 8)
+
+
+@dataclass
+class Conditions:
+    time_of_day: TimeOfDay
+    start_time: datetime.datetime
+    weather: Weather
+
+    @classmethod
+    def generate(
+        cls,
+        theater: ConflictTheater,
+        day: datetime.date,
+        time_of_day: TimeOfDay,
+        settings: Settings,
+    ) -> Conditions:
+        return cls(
+            time_of_day=time_of_day,
+            start_time=cls.generate_start_time(
+                theater, day, time_of_day, settings.night_disabled
+            ),
+            weather=cls.generate_weather(),
+        )
+
+    @classmethod
+    def generate_start_time(
+        cls,
+        theater: ConflictTheater,
+        day: datetime.date,
+        time_of_day: TimeOfDay,
+        night_disabled: bool,
+    ) -> datetime.datetime:
+        if night_disabled:
+            logging.info("Skip Night mission due to user settings")
+            time_range = {
+                TimeOfDay.Dawn: (8, 9),
+                TimeOfDay.Day: (10, 12),
+                TimeOfDay.Dusk: (12, 14),
+                TimeOfDay.Night: (14, 17),
+            }[time_of_day]
+        else:
+            time_range = theater.daytime_map[time_of_day.value]
+
+        time = datetime.time(hour=random.randint(*time_range))
+        return datetime.datetime.combine(day, time)
+
+    @classmethod
+    def generate_weather(cls) -> Weather:
+        chances = {
+            Thunderstorm: 1,
+            Raining: 20,
+            Cloudy: 60,
+            ClearSkies: 20,
+        }
+        weather_type = random.choices(
+            list(chances.keys()), weights=list(chances.values())
+        )[0]
+        return weather_type()

gen/__init__.py

@@ -1,12 +1,13 @@
-from .aaa import *
 from .aircraft import *
 from .armor import *
-from .awacsgen import *
+from .airsupportgen import *
 from .conflictgen import *
-from .shipgen import *
 from .visualgen import *
 from .triggergen import *
 from .environmentgen import *
+from .groundobjectsgen import *
+from .briefinggen import *
+from .forcedoptionsgen import *
+from .kneeboard import *
 
 from . import naming
-

gen/aaa.py

@@ -1,74 +0,0 @@
-from game import *
-
-from theater.conflicttheater import ConflictTheater
-from .conflictgen import *
-from .naming import *
-
-from dcs.mission import *
-
-DISTANCE_FACTOR = 0.5, 1
-EXTRA_AA_MIN_DISTANCE = 35000
-EXTRA_AA_POSITION_FROM_CP = 550
-
-
-class AAConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict):
-        self.m = mission
-        self.conflict = conflict
-
-    def generate_at_defenders_location(self, units: db.AirDefenseDict):
-        for unit_type, count in units.items():
-            for _ in range(count):
-                self.m.vehicle_group(
-                    country=self.conflict.defenders_side,
-                    name=namegen.next_ground_group_name(),
-                    _type=unit_type,
-                    position=self.conflict.ground_defenders_location.random_point_within(100, 100),
-                    group_size=1)
-
-    def generate(self, units: db.AirDefenseDict):
-        for type, count in units.items():
-            for _, radial in zip(range(count), self.conflict.radials):
-                distance = randint(self.conflict.size * DISTANCE_FACTOR[0], self.conflict.size * DISTANCE_FACTOR[1])
-                p = self.conflict.position.point_from_heading(radial, distance)
-
-                self.m.vehicle_group(
-                        country=self.conflict.defenders_side,
-                        name=namegen.next_ground_group_name(),
-                        _type=type,
-                        position=p,
-                        group_size=1)
-
-
-class ExtraAAConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game, player_name: Country, enemy_name: Country):
-        self.mission = mission
-        self.game = game
-        self.conflict = conflict
-        self.player_name = player_name
-        self.enemy_name = enemy_name
-
-    def generate(self):
-        from theater.conflicttheater import ControlPoint
-
-        for cp in self.game.theater.controlpoints:
-            if cp.is_global:
-                continue
-
-            if cp.position.distance_to_point(self.conflict.position) < EXTRA_AA_MIN_DISTANCE:
-                continue
-
-            if cp.position.distance_to_point(self.conflict.from_cp.position) < EXTRA_AA_MIN_DISTANCE:
-                continue
-
-            country_name = cp.captured and self.player_name or self.enemy_name
-            position = cp.position.point_from_heading(0, EXTRA_AA_POSITION_FROM_CP)
-
-            self.mission.vehicle_group(
-                country=self.mission.country(country_name),
-                name=namegen.next_ground_group_name(),
-                _type=db.EXTRA_AA[country_name],
-                position=position,
-                group_size=2
-            )
-

gen/airsupportgen.py

@@ -0,0 +1,208 @@
+import logging
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import List, Type, Tuple, Optional
+
+from dcs.mission import Mission, StartType
+from dcs.planes import IL_78M, KC130, KC135MPRS, KC_135
+from dcs.unittype import UnitType
+from dcs.task import (
+    AWACS,
+    ActivateBeaconCommand,
+    MainTask,
+    Refueling,
+    SetImmortalCommand,
+    SetInvisibleCommand,
+)
+
+from game import db
+from .naming import namegen
+from .callsigns import callsign_for_support_unit
+from .conflictgen import Conflict
+from .radios import RadioFrequency, RadioRegistry
+from .tacan import TacanBand, TacanChannel, TacanRegistry
+
+
+TANKER_DISTANCE = 15000
+TANKER_ALT = 4572
+TANKER_HEADING_OFFSET = 45
+
+AWACS_DISTANCE = 150000
+AWACS_ALT = 13000
+
+
+@dataclass
+class AwacsInfo:
+    """AWACS information for the kneeboard."""
+
+    dcsGroupName: str
+    callsign: str
+    freq: RadioFrequency
+    depature_location: Optional[str]
+    start_time: Optional[timedelta]
+    end_time: Optional[timedelta]
+
+
+@dataclass
+class TankerInfo:
+    """Tanker information for the kneeboard."""
+
+    dcsGroupName: str
+    callsign: str
+    variant: str
+    freq: RadioFrequency
+    tacan: TacanChannel
+
+
+@dataclass
+class AirSupport:
+    awacs: List[AwacsInfo] = field(default_factory=list)
+    tankers: List[TankerInfo] = field(default_factory=list)
+
+
+class AirSupportConflictGenerator:
+    def __init__(
+        self,
+        mission: Mission,
+        conflict: Conflict,
+        game,
+        radio_registry: RadioRegistry,
+        tacan_registry: TacanRegistry,
+    ) -> None:
+        self.mission = mission
+        self.conflict = conflict
+        self.game = game
+        self.air_support = AirSupport()
+        self.radio_registry = radio_registry
+        self.tacan_registry = tacan_registry
+
+    @classmethod
+    def support_tasks(cls) -> List[Type[MainTask]]:
+        return [Refueling, AWACS]
+
+    @staticmethod
+    def _get_tanker_params(unit_type: Type[UnitType]) -> Tuple[int, int]:
+        if unit_type is KC130:
+            return (TANKER_ALT - 500, 596)
+        elif unit_type is KC_135:
+            return (TANKER_ALT, 770)
+        elif unit_type is KC135MPRS:
+            return (TANKER_ALT + 500, 596)
+        return (TANKER_ALT, 574)
+
+    def generate(self):
+        player_cp = (
+            self.conflict.from_cp
+            if self.conflict.from_cp.captured
+            else self.conflict.to_cp
+        )
+
+        fallback_tanker_number = 0
+
+        for i, tanker_unit_type in enumerate(
+            db.find_unittype(Refueling, self.conflict.attackers_side)
+        ):
+            alt, airspeed = self._get_tanker_params(tanker_unit_type)
+            variant = db.unit_type_name(tanker_unit_type)
+            freq = self.radio_registry.alloc_uhf()
+            tacan = self.tacan_registry.alloc_for_band(TacanBand.Y)
+            tanker_heading = (
+                self.conflict.to_cp.position.heading_between_point(
+                    self.conflict.from_cp.position
+                )
+                + TANKER_HEADING_OFFSET * i
+            )
+            tanker_position = player_cp.position.point_from_heading(
+                tanker_heading, TANKER_DISTANCE
+            )
+            tanker_group = self.mission.refuel_flight(
+                country=self.mission.country(self.game.player_country),
+                name=namegen.next_tanker_name(
+                    self.mission.country(self.game.player_country), tanker_unit_type
+                ),
+                airport=None,
+                plane_type=tanker_unit_type,
+                position=tanker_position,
+                altitude=alt,
+                race_distance=58000,
+                frequency=freq.mhz,
+                start_type=StartType.Warm,
+                speed=airspeed,
+                tacanchannel=str(tacan),
+            )
+            tanker_group.set_frequency(freq.mhz)
+
+            callsign = callsign_for_support_unit(tanker_group)
+            tacan_callsign = {
+                "Texaco": "TEX",
+                "Arco": "ARC",
+                "Shell": "SHL",
+            }.get(callsign)
+            if tacan_callsign is None:
+                # The dict above is all the callsigns currently in the game, but
+                # non-Western countries don't use the callsigns and instead just
+                # use numbers. It's possible that none of those nations have
+                # TACAN compatible refueling aircraft, but fallback just in
+                # case.
+                tacan_callsign = f"TK{fallback_tanker_number}"
+                fallback_tanker_number += 1
+
+            if tanker_unit_type != IL_78M:
+                # Override PyDCS tacan channel.
+                tanker_group.points[0].tasks.pop()
+                tanker_group.points[0].tasks.append(
+                    ActivateBeaconCommand(
+                        tacan.number,
+                        tacan.band.value,
+                        tacan_callsign,
+                        True,
+                        tanker_group.units[0].id,
+                        True,
+                    )
+                )
+
+            tanker_group.points[0].tasks.append(SetInvisibleCommand(True))
+            tanker_group.points[0].tasks.append(SetImmortalCommand(True))
+
+            self.air_support.tankers.append(
+                TankerInfo(str(tanker_group.name), callsign, variant, freq, tacan)
+            )
+
+        if not self.game.settings.disable_legacy_aewc:
+            possible_awacs = db.find_unittype(AWACS, self.conflict.attackers_side)
+
+            if len(possible_awacs) > 0:
+                awacs_unit = possible_awacs[0]
+                freq = self.radio_registry.alloc_uhf()
+
+                awacs_flight = self.mission.awacs_flight(
+                    country=self.mission.country(self.game.player_country),
+                    name=namegen.next_awacs_name(
+                        self.mission.country(self.game.player_country)
+                    ),
+                    plane_type=awacs_unit,
+                    altitude=AWACS_ALT,
+                    airport=None,
+                    position=self.conflict.position.random_point_within(
+                        AWACS_DISTANCE, AWACS_DISTANCE
+                    ),
+                    frequency=freq.mhz,
+                    start_type=StartType.Warm,
+                )
+                awacs_flight.set_frequency(freq.mhz)
+
+                awacs_flight.points[0].tasks.append(SetInvisibleCommand(True))
+                awacs_flight.points[0].tasks.append(SetImmortalCommand(True))
+
+                self.air_support.awacs.append(
+                    AwacsInfo(
+                        dcsGroupName=str(awacs_flight.name),
+                        callsign=callsign_for_support_unit(awacs_flight),
+                        freq=freq,
+                        depature_location=None,
+                        start_time=None,
+                        end_time=None,
+                    )
+                )
+            else:
+                logging.warning("No AWACS for faction")

gen/armor.py

@@ -1,64 +1,806 @@
-from game import db
-from .conflictgen import *
-from .naming import *
+from __future__ import annotations
 
-from dcs.mission import *
-from dcs.unittype import *
-from dcs.point import *
-from dcs.task import *
-from dcs.country import *
+import logging
+import random
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+from dcs import Mission
+from dcs.action import AITaskPush
+from dcs.condition import GroupLifeLess, Or, TimeAfter, UnitDamaged
+from dcs.country import Country
+from dcs.mapping import Point
+from dcs.planes import MQ_9_Reaper
+from dcs.point import PointAction
+from dcs.task import (
+    EPLRS,
+    AttackGroup,
+    ControlledTask,
+    FireAtPoint,
+    GoToWaypoint,
+    Hold,
+    OrbitAction,
+    SetImmortalCommand,
+    SetInvisibleCommand,
+)
+from dcs.triggers import Event, TriggerOnce
+from dcs.unit import Vehicle
+from dcs.unitgroup import VehicleGroup
+from dcs.unittype import VehicleType
+from game import db
+from game.unitmap import UnitMap
+from game.utils import heading_sum, opposite_heading
+from game.theater.controlpoint import ControlPoint
+
+from gen.ground_forces.ai_ground_planner import (
+    DISTANCE_FROM_FRONTLINE,
+    CombatGroup,
+    CombatGroupRole,
+)
+
+from .callsigns import callsign_for_support_unit
+from .conflictgen import Conflict
+from .ground_forces.combat_stance import CombatStance
+from .naming import namegen
+
+if TYPE_CHECKING:
+    from game import Game
 
 SPREAD_DISTANCE_FACTOR = 0.1, 0.3
 SPREAD_DISTANCE_SIZE_FACTOR = 0.1
 
+FRONTLINE_CAS_FIGHTS_COUNT = 16, 24
+FRONTLINE_CAS_GROUP_MIN = 1, 2
+FRONTLINE_CAS_PADDING = 12000
 
-class ArmorConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict):
-        self.m = mission
+RETREAT_DISTANCE = 20000
+BREAKTHROUGH_OFFENSIVE_DISTANCE = 35000
+AGGRESIVE_MOVE_DISTANCE = 16000
+
+FIGHT_DISTANCE = 3500
+
+RANDOM_OFFSET_ATTACK = 250
+
+INFANTRY_GROUP_SIZE = 5
+
+
+@dataclass(frozen=True)
+class JtacInfo:
+    """JTAC information."""
+
+    dcsGroupName: str
+    unit_name: str
+    callsign: str
+    region: str
+    code: str
+    # TODO: Radio info? Type?
+
+
+class GroundConflictGenerator:
+    def __init__(
+        self,
+        mission: Mission,
+        conflict: Conflict,
+        game: Game,
+        player_planned_combat_groups: List[CombatGroup],
+        enemy_planned_combat_groups: List[CombatGroup],
+        player_stance: CombatStance,
+        unit_map: UnitMap,
+    ) -> None:
+        self.mission = mission
         self.conflict = conflict
+        self.enemy_planned_combat_groups = enemy_planned_combat_groups
+        self.player_planned_combat_groups = player_planned_combat_groups
+        self.player_stance = CombatStance(player_stance)
+        self.enemy_stance = self._enemy_stance()
+        self.game = game
+        self.unit_map = unit_map
+        self.jtacs: List[JtacInfo] = []
 
-    def _group_point(self, point) -> Point:
-        distance = randint(
-                int(self.conflict.size * SPREAD_DISTANCE_FACTOR[0]),
-                int(self.conflict.size * SPREAD_DISTANCE_FACTOR[1]),
+    def _enemy_stance(self):
+        """Picks the enemy stance according to the number of planned groups on the frontline for each side"""
+        if len(self.enemy_planned_combat_groups) > len(
+            self.player_planned_combat_groups
+        ):
+            return random.choice(
+                [
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.AGGRESSIVE,
+                    CombatStance.ELIMINATION,
+                    CombatStance.BREAKTHROUGH,
+                ]
+            )
+        else:
+            return random.choice(
+                [
+                    CombatStance.DEFENSIVE,
+                    CombatStance.DEFENSIVE,
+                    CombatStance.DEFENSIVE,
+                    CombatStance.AMBUSH,
+                    CombatStance.AGGRESSIVE,
+                ]
+            )
+
+    @staticmethod
+    def _group_point(point: Point, base_distance) -> Point:
+        distance = random.randint(
+            int(base_distance * SPREAD_DISTANCE_FACTOR[0]),
+            int(base_distance * SPREAD_DISTANCE_FACTOR[1]),
+        )
+        return point.random_point_within(
+            distance, base_distance * SPREAD_DISTANCE_SIZE_FACTOR
+        )
+
+    def generate(self):
+        position = Conflict.frontline_position(
+            self.conflict.from_cp, self.conflict.to_cp, self.game.theater
+        )
+        frontline_vector = Conflict.frontline_vector(
+            self.conflict.from_cp, self.conflict.to_cp, self.game.theater
+        )
+
+        # Create player groups at random position
+        player_groups = self._generate_groups(
+            self.player_planned_combat_groups, frontline_vector, True
+        )
+
+        # Create enemy groups at random position
+        enemy_groups = self._generate_groups(
+            self.enemy_planned_combat_groups, frontline_vector, False
+        )
+
+        # Plan combat actions for groups
+        self.plan_action_for_groups(
+            self.player_stance,
+            player_groups,
+            enemy_groups,
+            self.conflict.heading + 90,
+            self.conflict.from_cp,
+            self.conflict.to_cp,
+        )
+        self.plan_action_for_groups(
+            self.enemy_stance,
+            enemy_groups,
+            player_groups,
+            self.conflict.heading - 90,
+            self.conflict.to_cp,
+            self.conflict.from_cp,
+        )
+
+        # Add JTAC
+        if self.game.player_faction.has_jtac:
+            n = "JTAC" + str(self.conflict.from_cp.id) + str(self.conflict.to_cp.id)
+            code = 1688 - len(self.jtacs)
+
+            utype = MQ_9_Reaper
+            if self.game.player_faction.jtac_unit is not None:
+                utype = self.game.player_faction.jtac_unit
+
+            jtac = self.mission.flight_group(
+                country=self.mission.country(self.game.player_country),
+                name=n,
+                aircraft_type=utype,
+                position=position[0],
+                airport=None,
+                altitude=5000,
+            )
+            jtac.points[0].tasks.append(SetInvisibleCommand(True))
+            jtac.points[0].tasks.append(SetImmortalCommand(True))
+            jtac.points[0].tasks.append(
+                OrbitAction(5000, 300, OrbitAction.OrbitPattern.Circle)
+            )
+            frontline = (
+                f"Frontline {self.conflict.from_cp.name}/{self.conflict.to_cp.name}"
+            )
+            # Note: Will need to change if we ever add ground based JTAC.
+            callsign = callsign_for_support_unit(jtac)
+            self.jtacs.append(
+                JtacInfo(str(jtac.name), n, callsign, frontline, str(code))
+            )
+
+    def gen_infantry_group_for_group(
+        self, group: VehicleGroup, is_player: bool, side: Country, forward_heading: int
+    ) -> None:
+
+        infantry_position = self.conflict.find_ground_position(
+            group.points[0].position.random_point_within(250, 50),
+            500,
+            forward_heading,
+            self.conflict.theater,
+        )
+        if not infantry_position:
+            logging.warning("Could not find infantry position")
+            return
+        if side == self.conflict.attackers_country:
+            cp = self.conflict.from_cp
+        else:
+            cp = self.conflict.to_cp
+
+        if is_player:
+            faction = self.game.player_name
+        else:
+            faction = self.game.enemy_name
+
+        # Disable infantry unit gen if disabled
+        if not self.game.settings.perf_infantry:
+            if self.game.settings.manpads:
+                # 50% of armored units protected by manpad
+                if random.choice([True, False]):
+                    manpads = db.find_manpad(faction)
+                    if len(manpads) > 0:
+                        u = random.choice(manpads)
+                        self.mission.vehicle_group(
+                            side,
+                            namegen.next_infantry_name(side, cp.id, u),
+                            u,
+                            position=infantry_position,
+                            group_size=1,
+                            heading=forward_heading,
+                            move_formation=PointAction.OffRoad,
+                        )
+            return
+
+        possible_infantry_units = db.find_infantry(
+            faction, allow_manpad=self.game.settings.manpads
+        )
+        if len(possible_infantry_units) == 0:
+            return
+
+        u = random.choice(possible_infantry_units)
+        self.mission.vehicle_group(
+            side,
+            namegen.next_infantry_name(side, cp.id, u),
+            u,
+            position=infantry_position,
+            group_size=1,
+            heading=forward_heading,
+            move_formation=PointAction.OffRoad,
+        )
+
+        for i in range(INFANTRY_GROUP_SIZE):
+            u = random.choice(possible_infantry_units)
+            position = infantry_position.random_point_within(55, 5)
+            self.mission.vehicle_group(
+                side,
+                namegen.next_infantry_name(side, cp.id, u),
+                u,
+                position=position,
+                group_size=1,
+                heading=forward_heading,
+                move_formation=PointAction.OffRoad,
+            )
+
+    def _set_reform_waypoint(
+        self, dcs_group: VehicleGroup, forward_heading: int
+    ) -> None:
+        """Setting a waypoint close to the spawn position allows the group to reform gracefully
+        rather than spin
+        """
+        reform_point = dcs_group.position.point_from_heading(forward_heading, 50)
+        dcs_group.add_waypoint(reform_point)
+
+    def _plan_artillery_action(
+        self,
+        stance: CombatStance,
+        gen_group: CombatGroup,
+        dcs_group: VehicleGroup,
+        forward_heading: int,
+        target: Point,
+    ) -> bool:
+        """
+        Handles adding the DCS tasks for artillery groups for all combat stances.
+        Returns True if tasking was added, returns False if the stance was not a combat stance.
+        """
+        self._set_reform_waypoint(dcs_group, forward_heading)
+        if stance != CombatStance.RETREAT:
+            hold_task = Hold()
+            hold_task.number = 1
+            dcs_group.add_trigger_action(hold_task)
+
+        # Artillery strike random start
+        artillery_trigger = TriggerOnce(
+            Event.NoEvent, "ArtilleryFireTask #" + str(dcs_group.id)
+        )
+        artillery_trigger.add_condition(TimeAfter(seconds=random.randint(1, 45) * 60))
+        # TODO: Update to fire at group instead of point
+        fire_task = FireAtPoint(target, len(gen_group.units) * 10, 100)
+        fire_task.number = 2 if stance != CombatStance.RETREAT else 1
+        dcs_group.add_trigger_action(fire_task)
+        artillery_trigger.add_action(AITaskPush(dcs_group.id, len(dcs_group.tasks)))
+        self.mission.triggerrules.triggers.append(artillery_trigger)
+
+        # Artillery will fall back when under attack
+        if stance != CombatStance.RETREAT:
+
+            # Hold position
+            dcs_group.points[1].tasks.append(Hold())
+            retreat = self.find_retreat_point(
+                dcs_group, forward_heading, (int)(RETREAT_DISTANCE / 3)
+            )
+            dcs_group.add_waypoint(
+                dcs_group.position.point_from_heading(forward_heading, 1),
+                PointAction.OffRoad,
+            )
+            dcs_group.points[2].tasks.append(Hold())
+            dcs_group.add_waypoint(retreat, PointAction.OffRoad)
+
+            artillery_fallback = TriggerOnce(
+                Event.NoEvent, "ArtilleryRetreat #" + str(dcs_group.id)
+            )
+            for i, u in enumerate(dcs_group.units):
+                artillery_fallback.add_condition(UnitDamaged(u.id))
+                if i < len(dcs_group.units) - 1:
+                    artillery_fallback.add_condition(Or())
+
+            hold_2 = Hold()
+            hold_2.number = 3
+            dcs_group.add_trigger_action(hold_2)
+
+            retreat_task = GoToWaypoint(to_index=3)
+            retreat_task.number = 4
+            dcs_group.add_trigger_action(retreat_task)
+
+            artillery_fallback.add_action(
+                AITaskPush(dcs_group.id, len(dcs_group.tasks))
+            )
+            self.mission.triggerrules.triggers.append(artillery_fallback)
+
+            for u in dcs_group.units:
+                u.initial = True
+                u.heading = forward_heading + random.randint(-5, 5)
+            return True
+        return False
+
+    def _plan_tank_ifv_action(
+        self,
+        stance: CombatStance,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        dcs_group: VehicleGroup,
+        forward_heading: int,
+        to_cp: ControlPoint,
+    ) -> bool:
+        """
+        Handles adding the DCS tasks for tank and IFV groups for all combat stances.
+        Returns True if tasking was added, returns False if the stance was not a combat stance.
+        """
+        self._set_reform_waypoint(dcs_group, forward_heading)
+        if stance == CombatStance.AGGRESSIVE:
+            # Attack nearest enemy if any
+            # Then move forward OR Attack enemy base if it is not too far away
+            target = self.find_nearest_enemy_group(dcs_group, enemy_groups)
+            if target is not None:
+                rand_offset = Point(
+                    random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK),
+                    random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK),
+                )
+                target_point = self.conflict.theater.nearest_land_pos(
+                    target.points[0].position + rand_offset
+                )
+                dcs_group.add_waypoint(target_point)
+                dcs_group.points[2].tasks.append(AttackGroup(target.id))
+
+            if (
+                to_cp.position.distance_to_point(dcs_group.points[0].position)
+                <= AGGRESIVE_MOVE_DISTANCE
+            ):
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+            else:
+                # We use an offset heading here because DCS doesn't always
+                # force vehicles to move if there's no heading change.
+                offset_heading = forward_heading - 2
+                if offset_heading < 0:
+                    offset_heading = 358
+                attack_point = self.find_offensive_point(
+                    dcs_group, offset_heading, AGGRESIVE_MOVE_DISTANCE
+                )
+            dcs_group.add_waypoint(attack_point, PointAction.OffRoad)
+        elif stance == CombatStance.BREAKTHROUGH:
+            # In breakthrough mode, the units will move forward
+            # If the enemy base is close enough, the units will attack the base
+            if (
+                to_cp.position.distance_to_point(dcs_group.points[0].position)
+                <= BREAKTHROUGH_OFFENSIVE_DISTANCE
+            ):
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+            else:
+                # We use an offset heading here because DCS doesn't always
+                # force vehicles to move if there's no heading change.
+                offset_heading = forward_heading - 1
+                if offset_heading < 0:
+                    offset_heading = 359
+                attack_point = self.find_offensive_point(
+                    dcs_group, offset_heading, BREAKTHROUGH_OFFENSIVE_DISTANCE
+                )
+            dcs_group.add_waypoint(attack_point, PointAction.OffRoad)
+        elif stance == CombatStance.ELIMINATION:
+            # In elimination mode, the units focus on destroying as much enemy groups as possible
+            targets = self.find_n_nearest_enemy_groups(dcs_group, enemy_groups, 3)
+            for i, target in enumerate(targets, start=1):
+                rand_offset = Point(
+                    random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK),
+                    random.randint(-RANDOM_OFFSET_ATTACK, RANDOM_OFFSET_ATTACK),
+                )
+                target_point = self.conflict.theater.nearest_land_pos(
+                    target.points[0].position + rand_offset
+                )
+                dcs_group.add_waypoint(target_point, PointAction.OffRoad)
+                dcs_group.points[i + 1].tasks.append(AttackGroup(target.id))
+            if (
+                to_cp.position.distance_to_point(dcs_group.points[0].position)
+                <= AGGRESIVE_MOVE_DISTANCE
+            ):
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+                dcs_group.add_waypoint(attack_point)
+
+        if stance != CombatStance.RETREAT:
+            self.add_morale_trigger(dcs_group, forward_heading)
+            return True
+        return False
+
+    def _plan_apc_atgm_action(
+        self,
+        stance: CombatStance,
+        dcs_group: VehicleGroup,
+        forward_heading: int,
+        to_cp: ControlPoint,
+    ) -> bool:
+        """
+        Handles adding the DCS tasks for APC and ATGM groups for all combat stances.
+        Returns True if tasking was added, returns False if the stance was not a combat stance.
+        """
+        self._set_reform_waypoint(dcs_group, forward_heading)
+        if stance in [
+            CombatStance.AGGRESSIVE,
+            CombatStance.BREAKTHROUGH,
+            CombatStance.ELIMINATION,
+        ]:
+            # APC & ATGM will never move too much forward, but will follow along any offensive
+            if (
+                to_cp.position.distance_to_point(dcs_group.points[0].position)
+                <= AGGRESIVE_MOVE_DISTANCE
+            ):
+                attack_point = self.conflict.theater.nearest_land_pos(
+                    to_cp.position.random_point_within(500, 0)
+                )
+            else:
+                attack_point = self.find_offensive_point(
+                    dcs_group, forward_heading, AGGRESIVE_MOVE_DISTANCE
+                )
+            dcs_group.add_waypoint(attack_point, PointAction.OffRoad)
+
+        if stance != CombatStance.RETREAT:
+            self.add_morale_trigger(dcs_group, forward_heading)
+            return True
+        return False
+
+    def plan_action_for_groups(
+        self,
+        stance: CombatStance,
+        ally_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        forward_heading: int,
+        from_cp: ControlPoint,
+        to_cp: ControlPoint,
+    ) -> None:
+
+        if not self.game.settings.perf_moving_units:
+            return
+
+        for dcs_group, group in ally_groups:
+            if hasattr(group.units[0], "eplrs") and group.units[0].eplrs:
+                dcs_group.points[0].tasks.append(EPLRS(dcs_group.id))
+
+            if group.role == CombatGroupRole.ARTILLERY:
+                if self.game.settings.perf_artillery:
+                    target = self.get_artillery_target_in_range(
+                        dcs_group, group, enemy_groups
+                    )
+                    if target is not None:
+                        self._plan_artillery_action(
+                            stance, group, dcs_group, forward_heading, target
+                        )
+
+            elif group.role in [CombatGroupRole.TANK, CombatGroupRole.IFV]:
+                self._plan_tank_ifv_action(
+                    stance, enemy_groups, dcs_group, forward_heading, to_cp
                 )
 
-        return point.random_point_within(distance, self.conflict.size * SPREAD_DISTANCE_SIZE_FACTOR)
+            elif group.role in [CombatGroupRole.APC, CombatGroupRole.ATGM]:
+                self._plan_apc_atgm_action(stance, dcs_group, forward_heading, to_cp)
 
-    def _generate_group(self, side: Country, unit: VehicleType, count: int, at: Point):
-        for c in range(count):
-            group = self.m.vehicle_group(
-                    side,
-                    namegen.next_armor_group_name(),
-                    unit,
-                    position=self._group_point(at),
-                    group_size=1,
-                    move_formation=PointAction.OffRoad)
-            wayp = group.add_waypoint(self.conflict.position.point_from_heading(0, 500))
-            wayp.tasks = []
+            if stance == CombatStance.RETREAT:
+                # In retreat mode, the units will fall back
+                # If the ally base is close enough, the units will even regroup there
+                if (
+                    from_cp.position.distance_to_point(dcs_group.points[0].position)
+                    <= RETREAT_DISTANCE
+                ):
+                    retreat_point = from_cp.position.random_point_within(500, 250)
+                else:
+                    retreat_point = self.find_retreat_point(dcs_group, forward_heading)
+                reposition_point = retreat_point.point_from_heading(
+                    forward_heading, 10
+                )  # Another point to make the unit face the enemy
+                dcs_group.add_waypoint(retreat_point, PointAction.OffRoad)
+                dcs_group.add_waypoint(reposition_point, PointAction.OffRoad)
 
-    def generate(self, attackers: db.ArmorDict, defenders: db.ArmorDict):
-        for type, count in attackers.items():
-            self._generate_group(
-                    side=self.conflict.attackers_side,
-                    unit=type,
-                    count=count,
-                    at=self.conflict.ground_attackers_location)
+    def add_morale_trigger(self, dcs_group: VehicleGroup, forward_heading: int) -> None:
+        """
+        This add a trigger to manage units fleeing whenever their group is hit hard, or being engaged by CAS
+        """
 
-        for type, count in defenders.items():
-            self._generate_group(
-                    side=self.conflict.defenders_side,
-                    unit=type,
-                    count=count,
-                    at=self.conflict.ground_defenders_location)
+        if len(dcs_group.units) == 1:
+            return
 
-    def generate_passengers(self, count: int):
-        unit_type = random.choice(db.find_unittype(Nothing, self.conflict.attackers_side.name))
+        # Units should hold position on last waypoint
+        dcs_group.points[len(dcs_group.points) - 1].tasks.append(Hold())
 
-        self.m.vehicle_group(
-            country=self.conflict.attackers_side,
-            name=namegen.next_passenger_group_name(),
-            _type=unit_type,
-            position=self.conflict.ground_attackers_location,
-            group_size=count
+        # Force unit heading
+        for unit in dcs_group.units:
+            unit.heading = forward_heading
+        dcs_group.manualHeading = True
+
+        # We add a new retreat waypoint
+        dcs_group.add_waypoint(
+            self.find_retreat_point(
+                dcs_group, forward_heading, (int)(RETREAT_DISTANCE / 8)
+            ),
+            PointAction.OffRoad,
         )
+
+        # Fallback task
+        fallback = ControlledTask(GoToWaypoint(to_index=len(dcs_group.points)))
+        fallback.enabled = False
+        dcs_group.add_trigger_action(Hold())
+        dcs_group.add_trigger_action(fallback)
+
+        # Create trigger
+        fallback = TriggerOnce(Event.NoEvent, "Morale manager #" + str(dcs_group.id))
+
+        # Usually more than 50% casualties = RETREAT
+        fallback.add_condition(GroupLifeLess(dcs_group.id, random.randint(51, 76)))
+
+        # Do retreat to the configured retreat waypoint
+        fallback.add_action(AITaskPush(dcs_group.id, len(dcs_group.tasks)))
+
+        self.mission.triggerrules.triggers.append(fallback)
+
+    def find_retreat_point(
+        self,
+        dcs_group: VehicleGroup,
+        frontline_heading: int,
+        distance: int = RETREAT_DISTANCE,
+    ) -> Point:
+        """
+        Find a point to retreat to
+        :param dcs_group: DCS mission group we are searching a retreat point for
+        :param frontline_heading: Heading of the frontline
+        :return: dcs.mapping.Point object with the desired position
+        """
+        desired_point = dcs_group.points[0].position.point_from_heading(
+            heading_sum(frontline_heading, +180), distance
+        )
+        if self.conflict.theater.is_on_land(desired_point):
+            return desired_point
+        return self.conflict.theater.nearest_land_pos(desired_point)
+
+    def find_offensive_point(
+        self, dcs_group: VehicleGroup, frontline_heading: int, distance: int
+    ) -> Point:
+        """
+        Find a point to attack
+        :param dcs_group:  DCS mission group we are searching an attack point for
+        :param frontline_heading: Heading of the frontline
+        :param distance: Distance of the offensive (how far unit should move)
+        :return: dcs.mapping.Point object with the desired position
+        """
+        desired_point = dcs_group.points[0].position.point_from_heading(
+            frontline_heading, distance
+        )
+        if self.conflict.theater.is_on_land(desired_point):
+            return desired_point
+        return self.conflict.theater.nearest_land_pos(desired_point)
+
+    @staticmethod
+    def find_n_nearest_enemy_groups(
+        player_group: VehicleGroup,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+        n: int,
+    ) -> List[VehicleGroup]:
+        """
+        Return the nearest enemy group for the player group
+        @param group Group for which we should find the nearest ennemies
+        @param enemy_groups Potential enemy groups
+        @param n number of nearby groups to take
+        """
+        targets = []  # type: List[Optional[VehicleGroup]]
+        sorted_list = sorted(
+            enemy_groups,
+            key=lambda group: player_group.points[0].position.distance_to_point(
+                group[0].points[0].position
+            ),
+        )
+        for i in range(n):
+            # TODO: Is this supposed to return no groups if enemy_groups is less than n?
+            if len(sorted_list) <= i:
+                break
+            else:
+                targets.append(sorted_list[i][0])
+        return targets
+
+    @staticmethod
+    def find_nearest_enemy_group(
+        player_group: VehicleGroup, enemy_groups: List[Tuple[VehicleGroup, CombatGroup]]
+    ) -> Optional[VehicleGroup]:
+        """
+        Search the enemy groups for a potential target suitable to armored assault
+        @param group Group for which we should find the nearest ennemy
+        @param enemy_groups Potential enemy groups
+        """
+        min_distance = 99999999
+        target = None
+        for dcs_group, _ in enemy_groups:
+            dist = player_group.points[0].position.distance_to_point(
+                dcs_group.points[0].position
+            )
+            if dist < min_distance:
+                min_distance = dist
+                target = dcs_group
+        return target
+
+    @staticmethod
+    def get_artillery_target_in_range(
+        dcs_group: VehicleGroup,
+        group: CombatGroup,
+        enemy_groups: List[Tuple[VehicleGroup, CombatGroup]],
+    ) -> Optional[Point]:
+        """
+        Search the enemy groups for a potential target suitable to an artillery unit
+        """
+        # TODO: Update to return a list of groups instead of a single point
+        rng = group.units[0].threat_range
+        if not enemy_groups:
+            return None
+        for _ in range(10):
+            potential_target = random.choice(enemy_groups)[0]
+            distance_to_target = dcs_group.points[0].position.distance_to_point(
+                potential_target.points[0].position
+            )
+            if distance_to_target < rng:
+                return potential_target.points[0].position
+        return None
+
+    @staticmethod
+    def get_artilery_group_distance_from_frontline(group: CombatGroup) -> int:
+        """
+        For artilery group, decide the distance from frontline with the range of the unit
+        """
+        rg = group.units[0].threat_range - 7500
+        if rg > DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1]:
+            rg = random.randint(
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][0],
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1],
+            )
+        elif rg < DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1]:
+            rg = random.randint(
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK][0],
+                DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK][1],
+            )
+        return rg
+
+    def get_valid_position_for_group(
+        self,
+        conflict_position: Point,
+        combat_width: int,
+        distance_from_frontline: int,
+        heading: int,
+        spawn_heading: int,
+    ):
+        shifted = conflict_position.point_from_heading(
+            heading, random.randint(0, combat_width)
+        )
+        desired_point = shifted.point_from_heading(
+            spawn_heading, distance_from_frontline
+        )
+        return Conflict.find_ground_position(
+            desired_point, combat_width, heading, self.conflict.theater
+        )
+
+    def _generate_groups(
+        self,
+        groups: List[CombatGroup],
+        frontline_vector: Tuple[Point, int, int],
+        is_player: bool,
+    ) -> List[Tuple[VehicleGroup, CombatGroup]]:
+        """Finds valid positions for planned groups and generates a pydcs group for them"""
+        positioned_groups = []
+        position, heading, combat_width = frontline_vector
+        spawn_heading = (
+            int(heading_sum(heading, -90))
+            if is_player
+            else int(heading_sum(heading, 90))
+        )
+        country = self.game.player_country if is_player else self.game.enemy_country
+        for group in groups:
+            if group.role == CombatGroupRole.ARTILLERY:
+                distance_from_frontline = (
+                    self.get_artilery_group_distance_from_frontline(group)
+                )
+            else:
+                distance_from_frontline = random.randint(
+                    DISTANCE_FROM_FRONTLINE[group.role][0],
+                    DISTANCE_FROM_FRONTLINE[group.role][1],
+                )
+
+            final_position = self.get_valid_position_for_group(
+                position, combat_width, distance_from_frontline, heading, spawn_heading
+            )
+
+            if final_position is not None:
+                g = self._generate_group(
+                    self.mission.country(country),
+                    group.units[0],
+                    len(group.units),
+                    final_position,
+                    distance_from_frontline,
+                    heading=opposite_heading(spawn_heading),
+                )
+                if is_player:
+                    g.set_skill(self.game.settings.player_skill)
+                else:
+                    g.set_skill(self.game.settings.enemy_vehicle_skill)
+                positioned_groups.append((g, group))
+
+                if group.role in [CombatGroupRole.APC, CombatGroupRole.IFV]:
+                    self.gen_infantry_group_for_group(
+                        g,
+                        is_player,
+                        self.mission.country(country),
+                        opposite_heading(spawn_heading),
+                    )
+            else:
+                logging.warning(f"Unable to get valid position for {group}")
+
+        return positioned_groups
+
+    def _generate_group(
+        self,
+        side: Country,
+        unit: VehicleType,
+        count: int,
+        at: Point,
+        distance_from_frontline,
+        move_formation: PointAction = PointAction.OffRoad,
+        heading=0,
+    ) -> VehicleGroup:
+
+        if side == self.conflict.attackers_country:
+            cp = self.conflict.from_cp
+        else:
+            cp = self.conflict.to_cp
+
+        logging.info("armorgen: {} for {}".format(unit, side.id))
+        group = self.mission.vehicle_group(
+            side,
+            namegen.next_unit_name(side, cp.id, unit),
+            unit,
+            position=at,
+            group_size=count,
+            heading=heading,
+            move_formation=move_formation,
+        )
+
+        self.unit_map.add_front_line_units(group, cp)
+
+        for c in range(count):
+            vehicle: Vehicle = group.units[c]
+            vehicle.player_can_drive = True
+
+        return group

gen/ato.py

@@ -0,0 +1,225 @@
+"""Air Tasking Orders.
+
+The classes of the Air Tasking Order (ATO) define all of the missions that have
+been planned, and which aircraft have been assigned to them. Each planned
+mission, or "package" is composed of individual flights. The package may contain
+dissimilar aircraft performing different roles, but all for the same goal. For
+example, the package to strike an enemy airfield may contain an escort flight,
+a SEAD flight, and the strike aircraft themselves. CAP packages may contain only
+the single CAP flight.
+"""
+import logging
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Dict, List, Optional
+
+from dcs.mapping import Point
+
+from game.theater.missiontarget import MissionTarget
+from game.utils import Speed
+from .flights.flight import Flight, FlightType
+from .flights.flightplan import FormationFlightPlan
+from .flights.traveltime import TotEstimator
+
+
+@dataclass(frozen=True)
+class Task:
+    """The main task of a flight or package."""
+
+    #: The type of task.
+    task_type: FlightType
+
+    #: The location of the objective.
+    location: str
+
+
+@dataclass(frozen=True)
+class PackageWaypoints:
+    join: Point
+    ingress: Point
+    egress: Point
+    split: Point
+
+
+@dataclass
+class Package:
+    """A mission package."""
+
+    #: The mission target. Currently can be either a ControlPoint or a
+    #: TheaterGroundObject (non-ControlPoint map objectives).
+    target: MissionTarget
+
+    #: The set of flights in the package.
+    flights: List[Flight] = field(default_factory=list)
+
+    delay: int = field(default=0)
+
+    #: 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 it to persist in the save.
+    auto_asap: bool = field(default=False)
+
+    #: Desired TOT as an offset from mission start.
+    time_over_target: timedelta = field(default=timedelta())
+
+    waypoints: Optional[PackageWaypoints] = field(default=None)
+
+    @property
+    def formation_speed(self) -> Optional[Speed]:
+        """The speed of the package when in formation.
+
+        If none of the flights in the package will join a formation, this
+        returns None. This is nto uncommon, since only strike-like (strike,
+        DEAD, anti-ship, BAI, etc.) flights and their escorts fly in formation.
+        Others (CAP and CAS, currently) will coordinate in target timing but
+        fly their own path to the target.
+        """
+        speeds = []
+        for flight in self.flights:
+            if isinstance(flight.flight_plan, FormationFlightPlan):
+                speeds.append(flight.flight_plan.best_flight_formation_speed)
+        if not speeds:
+            return None
+        return min(speeds)
+
+    # TODO: Should depend on the type of escort.
+    # SEAD might be able to leave before CAP.
+    @property
+    def escort_start_time(self) -> Optional[timedelta]:
+        times = []
+        for flight in self.flights:
+            waypoint = flight.flight_plan.request_escort_at()
+            if waypoint is None:
+                continue
+            tot = flight.flight_plan.tot_for_waypoint(waypoint)
+            if tot is None:
+                logging.error(
+                    f"{flight} requested escort at {waypoint} but that "
+                    "waypoint has no TOT. It may not be escorted."
+                )
+                continue
+            times.append(tot)
+        if times:
+            return min(times)
+        return None
+
+    @property
+    def escort_end_time(self) -> Optional[timedelta]:
+        times = []
+        for flight in self.flights:
+            waypoint = flight.flight_plan.dismiss_escort_at()
+            if waypoint is None:
+                continue
+            tot = flight.flight_plan.tot_for_waypoint(waypoint)
+            if tot is None:
+                tot = flight.flight_plan.depart_time_for_waypoint(waypoint)
+            if tot is None:
+                logging.error(
+                    f"{flight} dismissed escort at {waypoint} but that "
+                    "waypoint has no TOT or departure time. It may not be "
+                    "escorted."
+                )
+                continue
+            times.append(tot)
+        if times:
+            return max(times)
+        return None
+
+    @property
+    def mission_departure_time(self) -> Optional[timedelta]:
+        times = []
+        for flight in self.flights:
+            times.append(flight.flight_plan.mission_departure_time)
+        if times:
+            return max(times)
+        return None
+
+    def set_tot_asap(self) -> None:
+        self.time_over_target = TotEstimator(self).earliest_tot()
+
+    def add_flight(self, flight: Flight) -> None:
+        """Adds a flight to the package."""
+        self.flights.append(flight)
+
+    def remove_flight(self, flight: Flight) -> None:
+        """Removes a flight from the package."""
+        self.flights.remove(flight)
+        if not self.flights:
+            self.waypoints = None
+
+    @property
+    def primary_task(self) -> Optional[FlightType]:
+        if not self.flights:
+            return None
+
+        flight_counts: Dict[FlightType, int] = defaultdict(lambda: 0)
+        for flight in self.flights:
+            flight_counts[flight.flight_type] += 1
+
+        # The package will contain a mix of mission types, but in general we can
+        # determine the goal of the mission because some mission types are more
+        # likely to be the main task than others. For example, a package with
+        # only CAP flights is a CAP package, a flight with CAP and strike is a
+        # strike package, a flight with CAP and DEAD is a DEAD package, and a
+        # flight with strike and SEAD is an OCA/Strike package. The type of
+        # package is determined by the highest priority flight in the package.
+        task_priorities = [
+            FlightType.CAS,
+            FlightType.STRIKE,
+            FlightType.ANTISHIP,
+            FlightType.OCA_AIRCRAFT,
+            FlightType.OCA_RUNWAY,
+            FlightType.BAI,
+            FlightType.DEAD,
+            FlightType.SEAD,
+            FlightType.TARCAP,
+            FlightType.BARCAP,
+            FlightType.AEWC,
+            FlightType.SWEEP,
+            FlightType.ESCORT,
+        ]
+        for task in task_priorities:
+            if flight_counts[task]:
+                return task
+
+        # If we get here, our task_priorities list above is incomplete. Log the
+        # issue and return the type of *any* flight in the package.
+        some_mission = next(iter(self.flights)).flight_type
+        logging.warning(f"Unhandled mission type: {some_mission}")
+        return some_mission
+
+    @property
+    def package_description(self) -> str:
+        """Generates a package description based on flight composition."""
+        task = self.primary_task
+        if task is None:
+            return "No mission"
+        oca_strike_types = {FlightType.OCA_AIRCRAFT, FlightType.OCA_RUNWAY}
+        if task in oca_strike_types:
+            return "OCA Strike"
+        return str(task)
+
+    def __hash__(self) -> int:
+        # TODO: Far from perfect. Number packages?
+        return hash(self.target.name)
+
+
+@dataclass
+class AirTaskingOrder:
+    """The entire ATO for one coalition."""
+
+    #: The set of all planned packages in the ATO.
+    packages: List[Package] = field(default_factory=list)
+
+    def add_package(self, package: Package) -> None:
+        """Adds a package to the ATO."""
+        self.packages.append(package)
+
+    def remove_package(self, package: Package) -> None:
+        """Removes a package from the ATO."""
+        self.packages.remove(package)
+
+    def clear(self) -> None:
+        """Removes all packages from the ATO."""
+        self.packages.clear()

gen/awacsgen.py

@@ -1,30 +0,0 @@
-from game import db
-from .conflictgen import *
-from .naming import *
-
-from dcs.mission import *
-from dcs.unitgroup import *
-from dcs.unittype import *
-from dcs.task import *
-from dcs.terrain.terrain import NoParkingSlotError
-
-AWACS_DISTANCE = 150000
-AWACS_ALT = 10000
-
-
-class AWACSConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game):
-        self.mission = mission
-        self.conflict = conflict
-        self.game = game
-
-    def generate(self):
-        plane = db.find_unittype(AWACS, self.conflict.attackers_side.name)[0]
-
-        self.mission.awacs_flight(
-            country=self.mission.country(self.game.player),
-            name=namegen.next_awacs_group_name(),
-            plane_type=plane,
-            altitude=AWACS_ALT,
-            airport=None,
-            position=self.conflict.position.random_point_within(AWACS_DISTANCE, AWACS_DISTANCE))

gen/beacons.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from enum import auto, IntEnum
+import json
+from pathlib import Path
+from typing import Iterable, Optional
+
+from gen.radios import RadioFrequency
+from gen.tacan import TacanBand, TacanChannel
+
+
+BEACONS_RESOURCE_PATH = Path("resources/dcs/beacons")
+
+
+class BeaconType(IntEnum):
+    BEACON_TYPE_NULL = auto()
+    BEACON_TYPE_VOR = auto()
+    BEACON_TYPE_DME = auto()
+    BEACON_TYPE_VOR_DME = auto()
+    BEACON_TYPE_TACAN = auto()
+    BEACON_TYPE_VORTAC = auto()
+    BEACON_TYPE_RSBN = auto()
+    BEACON_TYPE_BROADCAST_STATION = auto()
+
+    BEACON_TYPE_HOMER = auto()
+    BEACON_TYPE_AIRPORT_HOMER = auto()
+    BEACON_TYPE_AIRPORT_HOMER_WITH_MARKER = auto()
+    BEACON_TYPE_ILS_FAR_HOMER = auto()
+    BEACON_TYPE_ILS_NEAR_HOMER = auto()
+
+    BEACON_TYPE_ILS_LOCALIZER = auto()
+    BEACON_TYPE_ILS_GLIDESLOPE = auto()
+
+    BEACON_TYPE_PRMG_LOCALIZER = auto()
+    BEACON_TYPE_PRMG_GLIDESLOPE = auto()
+
+    BEACON_TYPE_ICLS_LOCALIZER = auto()
+    BEACON_TYPE_ICLS_GLIDESLOPE = auto()
+
+    BEACON_TYPE_NAUTICAL_HOMER = auto()
+
+
+@dataclass(frozen=True)
+class Beacon:
+    name: str
+    callsign: str
+    beacon_type: BeaconType
+    hertz: int
+    channel: Optional[int]
+
+    @property
+    def frequency(self) -> RadioFrequency:
+        return RadioFrequency(self.hertz)
+
+    @property
+    def is_tacan(self) -> bool:
+        return self.beacon_type in (
+            BeaconType.BEACON_TYPE_VORTAC,
+            BeaconType.BEACON_TYPE_TACAN,
+        )
+
+    @property
+    def tacan_channel(self) -> TacanChannel:
+        assert self.is_tacan
+        assert self.channel is not None
+        return TacanChannel(self.channel, TacanBand.X)
+
+
+def load_beacons_for_terrain(name: str) -> Iterable[Beacon]:
+    beacons_file = BEACONS_RESOURCE_PATH / f"{name.lower()}.json"
+    if not beacons_file.exists():
+        raise RuntimeError(f"Beacon file {beacons_file.resolve()} is missing")
+
+    for beacon in json.loads(beacons_file.read_text()):
+        yield Beacon(**beacon)

gen/briefinggen.py

@@ -0,0 +1,181 @@
+"""
+Briefing generation logic
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Dict, List, TYPE_CHECKING
+
+from dcs.mission import Mission
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from game.theater import ControlPoint, FrontLine
+from .aircraft import FlightData
+from .airsupportgen import AwacsInfo, TankerInfo
+from .armor import JtacInfo
+from .flights.flight import FlightWaypoint
+from .ground_forces.combat_stance import CombatStance
+from .radios import RadioFrequency
+from .runways import RunwayData
+
+
+if TYPE_CHECKING:
+    from game import Game
+
+
+@dataclass
+class CommInfo:
+    """Communications information for the kneeboard."""
+
+    name: str
+    freq: RadioFrequency
+
+
+class FrontLineInfo:
+    def __init__(self, front_line: FrontLine):
+        self.front_line: FrontLine = front_line
+        self.player_base: ControlPoint = front_line.control_point_a
+        self.enemy_base: ControlPoint = front_line.control_point_b
+        self.player_zero: bool = self.player_base.base.total_armor == 0
+        self.enemy_zero: bool = self.enemy_base.base.total_armor == 0
+        self.advantage: bool = (
+            self.player_base.base.total_armor > self.enemy_base.base.total_armor
+        )
+        self.stance: CombatStance = self.player_base.stances[self.enemy_base.id]
+        self.combat_stances = CombatStance
+
+
+class MissionInfoGenerator:
+    """Base type for generators of mission information for the player.
+
+    Examples of subtypes include briefing generators, kneeboard generators, etc.
+    """
+
+    def __init__(self, mission: Mission, game: Game) -> None:
+        self.mission = mission
+        self.game = game
+        self.awacs: List[AwacsInfo] = []
+        self.comms: List[CommInfo] = []
+        self.flights: List[FlightData] = []
+        self.jtacs: List[JtacInfo] = []
+        self.tankers: List[TankerInfo] = []
+        self.frontlines: List[FrontLineInfo] = []
+        self.dynamic_runways: List[RunwayData] = []
+
+    def add_awacs(self, awacs: AwacsInfo) -> None:
+        """Adds an AWACS/GCI to the mission.
+
+        Args:
+            awacs: AWACS information.
+        """
+        self.awacs.append(awacs)
+
+    def add_comm(self, name: str, freq: RadioFrequency) -> None:
+        """Adds communications info to the mission.
+
+        Args:
+            name: Name of the radio channel.
+            freq: Frequency of the radio channel.
+        """
+        self.comms.append(CommInfo(name, freq))
+
+    def add_flight(self, flight: FlightData) -> None:
+        """Adds flight info to the mission.
+
+        Args:
+            flight: Flight information.
+        """
+        self.flights.append(flight)
+
+    def add_jtac(self, jtac: JtacInfo) -> None:
+        """Adds a JTAC to the mission.
+
+        Args:
+            jtac: JTAC information.
+        """
+        self.jtacs.append(jtac)
+
+    def add_tanker(self, tanker: TankerInfo) -> None:
+        """Adds a tanker to the mission.
+
+        Args:
+            tanker: Tanker information.
+        """
+        self.tankers.append(tanker)
+
+    def add_frontline(self, frontline: FrontLineInfo) -> None:
+        """Adds a frontline to the briefing
+
+        Arguments:
+            frontline: Frontline conflict information
+        """
+        self.frontlines.append(frontline)
+
+    def add_dynamic_runway(self, runway: RunwayData) -> None:
+        """Adds a dynamically generated runway to the briefing.
+
+        Dynamic runways are any valid landing point that is a unit rather than a
+        map feature. These include carriers, ships with a helipad, and FARPs.
+        """
+        self.dynamic_runways.append(runway)
+
+    def generate(self) -> None:
+        """Generates the mission information."""
+        raise NotImplementedError
+
+
+def format_waypoint_time(waypoint: FlightWaypoint, depart_prefix: str) -> str:
+    if waypoint.tot is not None:
+        time = timedelta(seconds=int(waypoint.tot.total_seconds()))
+        return f"T+{time} "
+    elif waypoint.departure_time is not None:
+        time = timedelta(seconds=int(waypoint.departure_time.total_seconds()))
+        return f"{depart_prefix} T+{time} "
+    return ""
+
+
+class BriefingGenerator(MissionInfoGenerator):
+    def __init__(self, mission: Mission, game: Game):
+        super().__init__(mission, game)
+        self.allied_flights_by_departure: Dict[str, List[FlightData]] = {}
+        env = Environment(
+            loader=FileSystemLoader("resources/briefing/templates"),
+            autoescape=select_autoescape(
+                disabled_extensions=("",),
+                default_for_string=True,
+                default=True,
+            ),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+        env.filters["waypoint_timing"] = format_waypoint_time
+        self.template = env.get_template("briefingtemplate_EN.j2")
+
+    def generate(self) -> None:
+        """Generate the mission briefing"""
+        self._generate_frontline_info()
+        self.generate_allied_flights_by_departure()
+        self.mission.set_description_text(self.template.render(vars(self)))
+        self.mission.add_picture_blue(
+            os.path.abspath("./resources/ui/splash_screen.png")
+        )
+
+    def _generate_frontline_info(self) -> None:
+        """Build FrontLineInfo objects from FrontLine type and append to briefing."""
+        for front_line in self.game.theater.conflicts(from_player=True):
+            self.add_frontline(FrontLineInfo(front_line))
+
+    # TODO: This should determine if runway is friendly through a method more robust than the existing string match
+    def generate_allied_flights_by_departure(self) -> None:
+        """Create iterable to display allied flights grouped by departure airfield."""
+        for flight in self.flights:
+            if not flight.client_units and flight.friendly:
+                name = flight.departure.airfield_name
+                if (
+                    name in self.allied_flights_by_departure
+                ):  # where else can we get this?
+                    self.allied_flights_by_departure[name].append(flight)
+                else:
+                    self.allied_flights_by_departure[name] = [flight]

gen/callsigns.py

@@ -0,0 +1,34 @@
+"""Support for working with DCS group callsigns."""
+import logging
+import re
+
+from dcs.unitgroup import FlyingGroup
+from dcs.flyingunit import FlyingUnit
+
+
+def callsign_for_support_unit(group: FlyingGroup) -> str:
+    # Either something like Overlord11 for Western AWACS, or else just a number.
+    # Convert to either "Overlord" or "Flight 123".
+    lead = group.units[0]
+    raw_callsign = lead.callsign_as_str()
+    try:
+        return f"Flight {int(raw_callsign)}"
+    except ValueError:
+        return raw_callsign.rstrip("1234567890")
+
+
+def create_group_callsign_from_unit(lead: FlyingUnit) -> str:
+    raw_callsign = lead.callsign_as_str()
+    if not lead.callsign_is_western:
+        # Callsigns for non-Western countries are just a number per flight,
+        # similar to tail numbers.
+        return f"Flight {raw_callsign}"
+
+    # Callsign from pydcs is in the format `<name><group ID><unit ID>`,
+    # where unit ID is guaranteed to be a single digit but the group ID may
+    # be more.
+    match = re.search(r"^(\D+)(\d+)(\d)$", raw_callsign)
+    if match is None:
+        logging.error(f"Could not parse unit callsign: {raw_callsign}")
+        return f"Flight {raw_callsign}"
+    return f"{match.group(1)} {match.group(2)}"

gen/coastal/coastal_group_generator.py

@@ -0,0 +1,31 @@
+import logging
+import random
+from game import db
+from gen.coastal.silkworm import SilkwormGenerator
+
+COASTAL_MAP = {
+    "SilkwormGenerator": SilkwormGenerator,
+}
+
+
+def generate_coastal_group(game, ground_object, faction_name: str):
+    """
+    This generate a coastal defenses group
+    :return: Nothing, but put the group reference inside the ground object
+    """
+    faction = db.FACTIONS[faction_name]
+    if len(faction.coastal_defenses) > 0:
+        generators = faction.coastal_defenses
+        if len(generators) > 0:
+            gen = random.choice(generators)
+            if gen in COASTAL_MAP.keys():
+                generator = COASTAL_MAP[gen](game, ground_object, faction)
+                generator.generate()
+                return generator.get_generated_group()
+            else:
+                logging.info(
+                    "Unable to generate missile group, generator : "
+                    + str(gen)
+                    + "does not exists"
+                )
+    return None

gen/coastal/silkworm.py

@@ -0,0 +1,58 @@
+from dcs.vehicles import MissilesSS, Unarmed, AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class SilkwormGenerator(GroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(SilkwormGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        positions = self.get_circular_position(5, launcher_distance=120, coverage=180)
+
+        self.add_unit(
+            MissilesSS.AShM_Silkworm_SR,
+            "SR#0",
+            self.position.x,
+            self.position.y,
+            self.heading,
+        )
+
+        # Launchers
+        for i, p in enumerate(positions):
+            self.add_unit(
+                MissilesSS.AShM_SS_N_2_Silkworm,
+                "Missile#" + str(i),
+                p[0],
+                p[1],
+                self.heading,
+            )
+
+        # Commander
+        self.add_unit(
+            Unarmed.Truck_KAMAZ_43101,
+            "KAMAZ#0",
+            self.position.x - 35,
+            self.position.y - 20,
+            self.heading,
+        )
+
+        # Shorad
+        self.add_unit(
+            AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
+            "SHILKA#0",
+            self.position.x - 55,
+            self.position.y - 38,
+            self.heading,
+        )
+
+        # Shorad 2
+        self.add_unit(
+            AirDefence.SAM_SA_9_Strela_1_Gaskin_TEL,
+            "STRELA#0",
+            self.position.x + 200,
+            self.position.y + 15,
+            90,
+        )

gen/conflictgen.py

@@ -1,264 +1,157 @@
-import typing
-import pdb
-import dcs
+import logging
+from typing import Tuple, Optional
 
-from random import randint
-from dcs import Mission
+from dcs.country import Country
+from dcs.mapping import Point
+from shapely.geometry import LineString, Point as ShapelyPoint
 
-from dcs.mission import *
-from dcs.vehicles import *
-from dcs.unitgroup import *
-from dcs.unittype import *
-from dcs.mapping import *
-from dcs.point import *
-from dcs.task import *
-from dcs.country import *
-
-from theater import *
-
-AIR_DISTANCE = 40000
+from game.theater.conflicttheater import ConflictTheater, FrontLine
+from game.theater.controlpoint import ControlPoint
+from game.utils import heading_sum, opposite_heading
 
 
-GROUND_DISTANCE_FACTOR = 1
-GROUNDINTERCEPT_DISTANCE_FACTOR = 6
-AIR_DISTANCE = 32000
-
-INTERCEPT_ATTACKERS_HEADING = -45, 45
-INTERCEPT_DEFENDERS_HEADING = -10, 10
-INTERCEPT_CONFLICT_DISTANCE = 50000
-INTERCEPT_ATTACKERS_DISTANCE = 100000
-INTERCEPT_MAX_DISTANCE = 160000
-INTERCEPT_MIN_DISTANCE = 100000
-
-NAVAL_INTERCEPT_DISTANCE_FACTOR = 0.4
-NAVAL_INTERCEPT_DISTANCE_MAX = 40000
-NAVAL_INTERCEPT_STEP = 5000
-
-
-def _opposite_heading(h):
-    return h+180
-
-
-def _heading_sum(h, a) -> int:
-    h += a
-    if h > 360:
-        return h - 360
-    elif h < 0:
-        return 360 + h
-    else:
-        return h
+FRONTLINE_LENGTH = 80000
 
 
 class Conflict:
-    attackers_side = None  # type: Country
-    defenders_side = None  # type: Country
-    from_cp = None  # type: ControlPoint
-    to_cp = None  # type: ControlPoint
-    position = None  # type: Point
-    size = None  # type: int
-    radials = None  # type: typing.List[int]
+    def __init__(
+        self,
+        theater: ConflictTheater,
+        from_cp: ControlPoint,
+        to_cp: ControlPoint,
+        attackers_side: str,
+        defenders_side: str,
+        attackers_country: Country,
+        defenders_country: Country,
+        position: Point,
+        heading: Optional[int] = None,
+        size: Optional[int] = None,
+    ):
 
-    ground_attackers_location = None  # type: Point
-    ground_defenders_location = None  # type: Point
-    air_attackers_location = None  # type: Point
-    air_defenders_location = None  # type: Point
-
-    def __init__(self,
-                 position: Point,
-                 theater: ConflictTheater,
-                 from_cp: ControlPoint,
-                 to_cp: ControlPoint,
-                 attackers_side: Country,
-                 defenders_side: Country,
-                 ground_attackers_location: Point,
-                 ground_defenders_location: Point,
-                 air_attackers_location: Point,
-                 air_defenders_location: Point):
         self.attackers_side = attackers_side
         self.defenders_side = defenders_side
+        self.attackers_country = attackers_country
+        self.defenders_country = defenders_country
+
         self.from_cp = from_cp
         self.to_cp = to_cp
         self.theater = theater
         self.position = position
-        self.size = to_cp.size
-        self.radials = to_cp.radials
-        self.ground_attackers_location = ground_attackers_location
-        self.ground_defenders_location = ground_defenders_location
-        self.air_attackers_location = air_attackers_location
-        self.air_defenders_location = air_defenders_location
+        self.heading = heading
+        self.size = size
 
     @classmethod
-    def _find_ground_location(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> Point:
-        for _ in range(0, int(max_distance), 800):
-            for _ in range(3):
-                if theater.is_on_land(initial):
-                    return initial
+    def has_frontline_between(cls, from_cp: ControlPoint, to_cp: ControlPoint) -> bool:
+        return from_cp.has_frontline and to_cp.has_frontline
 
-                initial = initial.random_point_within(1000, 1000)
+    @classmethod
+    def frontline_position(
+        cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater
+    ) -> Tuple[Point, int]:
+        frontline = FrontLine(from_cp, to_cp, theater)
+        attack_heading = frontline.attack_heading
+        position = cls.find_ground_position(
+            frontline.position,
+            FRONTLINE_LENGTH,
+            heading_sum(attack_heading, 90),
+            theater,
+        )
+        return position, opposite_heading(attack_heading)
 
-            initial = initial.point_from_heading(heading, 800)
+    @classmethod
+    def frontline_vector(
+        cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater
+    ) -> Tuple[Point, int, int]:
+        """
+        Returns a vector for a valid frontline location avoiding exclusion zones.
+        """
+        center_position, heading = cls.frontline_position(from_cp, to_cp, theater)
+        left_heading = heading_sum(heading, -90)
+        right_heading = heading_sum(heading, 90)
+        left_position = cls.extend_ground_position(
+            center_position, int(FRONTLINE_LENGTH / 2), left_heading, theater
+        )
+        right_position = cls.extend_ground_position(
+            center_position, int(FRONTLINE_LENGTH / 2), right_heading, theater
+        )
+        distance = int(left_position.distance_to_point(right_position))
+        return left_position, right_heading, distance
 
-        print("Didn't find ground position!")
+    @classmethod
+    def frontline_cas_conflict(
+        cls,
+        attacker_name: str,
+        defender_name: str,
+        attacker: Country,
+        defender: Country,
+        from_cp: ControlPoint,
+        to_cp: ControlPoint,
+        theater: ConflictTheater,
+    ):
+        assert cls.has_frontline_between(from_cp, to_cp)
+        position, heading, distance = cls.frontline_vector(from_cp, to_cp, theater)
+        conflict = cls(
+            position=position,
+            heading=heading,
+            theater=theater,
+            from_cp=from_cp,
+            to_cp=to_cp,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
+            size=distance,
+        )
+        return conflict
+
+    @classmethod
+    def extend_ground_position(
+        cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater
+    ) -> Point:
+        """Finds the first intersection with an exclusion zone in one heading from an initial point up to max_distance"""
+        extended = initial.point_from_heading(heading, max_distance)
+        if theater.landmap is None:
+            # TODO: Why is this possible?
+            return extended
+
+        p0 = ShapelyPoint(initial.x, initial.y)
+        p1 = ShapelyPoint(extended.x, extended.y)
+        line = LineString([p0, p1])
+
+        intersection = line.intersection(theater.landmap.inclusion_zone_only.boundary)
+        if intersection.is_empty:
+            # Max extent does not intersect with the boundary of the inclusion
+            # zone, so the full front line is usable. This does assume that the
+            # front line was centered on a valid location.
+            return extended
+
+        # Otherwise extend the front line only up to the intersection.
+        return initial.point_from_heading(heading, p0.distance(intersection))
+
+    @classmethod
+    def find_ground_position(
+        cls,
+        initial: Point,
+        max_distance: int,
+        heading: int,
+        theater: ConflictTheater,
+        coerce=True,
+    ) -> Optional[Point]:
+        """
+        Finds the nearest valid ground position along a provided heading and it's inverse up to max_distance.
+        `coerce=True` will return the closest land position to `initial` regardless of heading or distance
+        `coerce=False` will return None if a point isn't found
+        """
+        pos = initial
+        if theater.is_on_land(pos):
+            return pos
+        for distance in range(0, int(max_distance), 100):
+            pos = initial.point_from_heading(heading, distance)
+            if theater.is_on_land(pos):
+                return pos
+            pos = initial.point_from_heading(opposite_heading(heading), distance)
+        if coerce:
+            pos = theater.nearest_land_pos(initial)
+            return pos
+        logging.error("Didn't find ground position ({})!".format(initial))
         return None
-
-    @classmethod
-    def capture_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        position = to_cp.position
-        attack_raw_heading = to_cp.position.heading_between_point(from_cp.position)
-        attack_heading = to_cp.find_radial(attack_raw_heading)
-        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
-
-        distance = to_cp.size * GROUND_DISTANCE_FACTOR
-        attackers_location = position.point_from_heading(attack_heading, distance)
-        attackers_location = Conflict._find_ground_location(attackers_location, distance * 2, _heading_sum(attack_heading, 180), theater)
-
-        defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_location(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=attackers_location,
-            ground_defenders_location=defenders_location,
-            air_attackers_location=position.point_from_heading(attack_raw_heading, CAPTURE_AIR_ATTACKERS_DISTANCE),
-            air_defenders_location=position.point_from_heading(_opposite_heading(attack_raw_heading), CAPTURE_AIR_DEFENDERS_DISTANCE)
-        )
-
-    @classmethod
-    def intercept_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        raw_distance = from_cp.position.distance_to_point(to_cp.position) * 1.5
-        distance = max(min(raw_distance, INTERCEPT_MAX_DISTANCE), INTERCEPT_MIN_DISTANCE)
-
-        heading = _heading_sum(from_cp.position.heading_between_point(to_cp.position), random.choice([-1, 1]) * random.randint(60, 100))
-        position = from_cp.position.point_from_heading(heading, distance)
-
-        return cls(
-            position=position.point_from_heading(position.heading_between_point(to_cp.position), INTERCEPT_CONFLICT_DISTANCE),
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=None,
-            air_attackers_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, INTERCEPT_ATTACKERS_DISTANCE),
-            air_defenders_location=position
-        )
-
-    @classmethod
-    def ground_attack_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        heading = random.choice(to_cp.radials)
-        initial_location = to_cp.position.random_point_within(*GROUND_ATTACK_DISTANCE)
-        position = Conflict._find_ground_location(initial_location, GROUND_INTERCEPT_SPREAD, _heading_sum(heading, 180), theater)
-        if not position:
-            heading = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
-            position = to_cp.position.point_from_heading(heading, to_cp.size * GROUND_DISTANCE_FACTOR)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=position,
-            ground_defenders_location=None,
-            air_attackers_location=None,
-            air_defenders_location=position.point_from_heading(heading, AIR_DISTANCE),
-        )
-
-    @classmethod
-    def ground_intercept_conflict(cls, attacker: Country, defender: Country, heading: int, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        heading = random.choice(to_cp.radials)
-        initial_location = to_cp.position.point_from_heading(heading, to_cp.size * GROUNDINTERCEPT_DISTANCE_FACTOR)
-        max_distance = to_cp.size * GROUNDINTERCEPT_DISTANCE_FACTOR
-        ground_location = Conflict._find_ground_location(initial_location, max_distance, _heading_sum(heading, 180), theater)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=position,
-            air_attackers_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, AIR_DISTANCE),
-            air_defenders_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + _opposite_heading(heading), AIR_DISTANCE)
-        )
-
-    @classmethod
-    def ground_base_attack(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        position = to_cp.position
-        attack_heading = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
-        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
-
-        distance = to_cp.size * GROUND_DISTANCE_FACTOR
-        defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_location(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
-
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=defenders_location,
-            air_attackers_location=position.point_from_heading(attack_heading, AIR_DISTANCE),
-            air_defenders_location=position
-        )
-
-    @classmethod
-    def naval_intercept_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        radial = random.choice(to_cp.sea_radials)
-
-        initial_distance = min(int(from_cp.position.distance_to_point(to_cp.position) * NAVAL_INTERCEPT_DISTANCE_FACTOR), NAVAL_INTERCEPT_DISTANCE_MAX)
-        position = to_cp.position.point_from_heading(radial, initial_distance)
-        for offset in range(0, initial_distance, NAVAL_INTERCEPT_STEP):
-            position = to_cp.position.point_from_heading(_opposite_heading(radial), initial_distance - offset)
-
-            if not theater.is_on_land(position):
-                break
-
-        attacker_heading = from_cp.position.heading_between_point(to_cp.position)
-        return cls(
-            position=position,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=None,
-            ground_defenders_location=position,
-            air_attackers_location=position.point_from_heading(attacker_heading, AIR_DISTANCE),
-            air_defenders_location=position.point_from_heading(_opposite_heading(attacker_heading), AIR_DISTANCE)
-        )
-
-    @classmethod
-    def transport_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        frontline_position = cls._frontline_position(from_cp, to_cp)
-        heading = to_cp.position.heading_between_point(from_cp.position)
-        initial_dest = frontline_position.point_from_heading(heading, TRANSPORT_FRONTLINE_DIST)
-        dest = cls._find_ground_location(initial_dest, from_cp.position.distance_to_point(to_cp.position) / 3, heading, theater)
-        if not dest:
-            radial = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
-            dest = to_cp.position.point_from_heading(radial, to_cp.size * GROUND_DISTANCE_FACTOR)
-
-        return cls(
-            position=dest,
-            theater=theater,
-            from_cp=from_cp,
-            to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
-            ground_attackers_location=from_cp.position,
-            ground_defenders_location=frontline_position,
-            air_attackers_location=from_cp.position.point_from_heading(0, 100),
-            air_defenders_location=frontline_position
-        )

gen/defenses/armor_group_generator.py

@@ -0,0 +1,43 @@
+import random
+
+from dcs.vehicles import Armor
+
+from game import db
+from gen.defenses.armored_group_generator import (
+    ArmoredGroupGenerator,
+    FixedSizeArmorGroupGenerator,
+)
+
+
+def generate_armor_group(faction: str, game, ground_object):
+    """
+    This generate a group of ground units
+    :return: Generated group
+    """
+    possible_unit = [
+        u for u in db.FACTIONS[faction].frontline_units if u in Armor.__dict__.values()
+    ]
+    if len(possible_unit) > 0:
+        unit_type = random.choice(possible_unit)
+        return generate_armor_group_of_type(game, ground_object, unit_type)
+    return None
+
+
+def generate_armor_group_of_type(game, ground_object, unit_type):
+    """
+    This generate a group of ground units of given type
+    :return: Generated group
+    """
+    generator = ArmoredGroupGenerator(game, ground_object, unit_type)
+    generator.generate()
+    return generator.get_generated_group()
+
+
+def generate_armor_group_of_type_and_size(game, ground_object, unit_type, size: int):
+    """
+    This generate a group of ground units of given type and size
+    :return: Generated group
+    """
+    generator = FixedSizeArmorGroupGenerator(game, ground_object, unit_type, size)
+    generator.generate()
+    return generator.get_generated_group()

gen/defenses/armored_group_generator.py

@@ -0,0 +1,49 @@
+import random
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class ArmoredGroupGenerator(GroupGenerator):
+    def __init__(self, game, ground_object, unit_type):
+        super(ArmoredGroupGenerator, self).__init__(game, ground_object)
+        self.unit_type = unit_type
+
+    def generate(self):
+
+        grid_x = random.randint(2, 3)
+        grid_y = random.randint(1, 2)
+
+        spacing = random.randint(30, 80)
+
+        index = 0
+        for i in range(grid_x):
+            for j in range(grid_y):
+                index = index + 1
+                self.add_unit(
+                    self.unit_type,
+                    "Armor#" + str(index),
+                    self.position.x + spacing * i,
+                    self.position.y + spacing * j,
+                    self.heading,
+                )
+
+
+class FixedSizeArmorGroupGenerator(GroupGenerator):
+    def __init__(self, game, ground_object, unit_type, size):
+        super(FixedSizeArmorGroupGenerator, self).__init__(game, ground_object)
+        self.unit_type = unit_type
+        self.size = size
+
+    def generate(self):
+        spacing = random.randint(20, 70)
+
+        index = 0
+        for i in range(self.size):
+            index = index + 1
+            self.add_unit(
+                self.unit_type,
+                "Armor#" + str(index),
+                self.position.x + spacing * i,
+                self.position.y,
+                self.heading,
+            )

gen/environmentgen.py

@@ -1,107 +1,37 @@
-import typing
-import random
-from datetime import datetime, timedelta, time
+from typing import Optional
 
 from dcs.mission import Mission
-from dcs.triggers import *
-from dcs.condition import *
-from dcs.action import *
-from dcs.unit import Skill
-from dcs.point import MovingPoint, PointProperties
-from dcs.action import *
-from dcs.weather import *
 
-from game import db
-from theater import *
-from gen import *
-
-WEATHER_CLOUD_BASE = 2000, 3000
-WEATHER_CLOUD_DENSITY = 1, 8
-WEATHER_CLOUD_THICKNESS = 100, 400
-WEATHER_CLOUD_BASE_MIN = 1200
-
-RANDOM_TIME = {
-    "night": 5,
-    "dusk": 30,
-    "dawn": 30,
-    "day": 100,
-}
-
-RANDOM_WEATHER = {
-    1: 5,  # heavy rain
-    2: 15,  # rain
-    3: 25,  # dynamic
-    4: 35,  # clear
-    5: 100,  # random
-}
+from game.weather import Clouds, Fog, Conditions, WindConditions
 
 
-class EnvironmentSettings:
-    weather_dict = None
-    start_time = None
-
-
-class EnviromentGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game):
+class EnvironmentGenerator:
+    def __init__(self, mission: Mission, conditions: Conditions) -> None:
         self.mission = mission
-        self.conflict = conflict
-        self.game = game
+        self.conditions = conditions
 
-    def _gen_random_time(self):
-        start_time = datetime.combine(datetime.today(), time())
-        time_range = None
-        for k, v in RANDOM_TIME.items():
-            if self.game.settings.night_disabled and k == "night":
-                continue
+    def set_clouds(self, clouds: Optional[Clouds]) -> None:
+        if clouds is None:
+            return
+        self.mission.weather.clouds_base = clouds.base
+        self.mission.weather.clouds_thickness = clouds.thickness
+        self.mission.weather.clouds_density = clouds.density
+        self.mission.weather.clouds_iprecptns = clouds.precipitation
+        self.mission.weather.clouds_preset = clouds.preset
 
-            if random.randint(0, 100) <= v:
-                time_range = self.game.theater.daytime_map[k]
-                break
+    def set_fog(self, fog: Optional[Fog]) -> None:
+        if fog is None:
+            return
+        self.mission.weather.fog_visibility = fog.visibility.meters
+        self.mission.weather.fog_thickness = fog.thickness
 
-        start_time += timedelta(hours=random.randint(*time_range))
-        self.mission.start_time = start_time
-
-    def _gen_random_weather(self):
-        weather_type = None
-        for k, v in RANDOM_WEATHER.items():
-            if random.randint(0, 100) <= v:
-                weather_type = k
-                break
-
-        print("generated weather {}".format(weather_type))
-        if weather_type == 1:
-            self.mission.weather.heavy_rain()
-        elif weather_type == 2:
-            self.mission.weather.heavy_rain()
-            self.mission.weather.enable_fog = False
-        elif weather_type == 3:
-            self.mission.weather.random(self.mission.start_time, self.conflict.theater.terrain)
-        elif weather_type == 4:
-            pass
-        elif weather_type == 5:
-            self.mission.weather.clouds_base = random.randint(*WEATHER_CLOUD_BASE)
-            self.mission.weather.clouds_density = random.randint(*WEATHER_CLOUD_DENSITY)
-            self.mission.weather.clouds_thickness = random.randint(*WEATHER_CLOUD_THICKNESS)
-
-            wind_direction = random.randint(0, 360)
-            wind_speed = random.randint(0, 13)
-            self.mission.weather.wind_at_ground = Wind(wind_direction, wind_speed)
-            self.mission.weather.wind_at_2000 = Wind(wind_direction, wind_speed * 2)
-            self.mission.weather.wind_at_8000 = Wind(wind_direction, wind_speed * 3)
-
-        if self.mission.weather.clouds_density > 0:
-            self.mission.weather.clouds_base = max(self.mission.weather.clouds_base, WEATHER_CLOUD_BASE_MIN)
-
-    def generate(self) -> EnvironmentSettings:
-        self._gen_random_time()
-        self._gen_random_weather()
-
-        settings = EnvironmentSettings()
-        settings.start_time = self.mission.start_time
-        settings.weather_dict = self.mission.weather.dict()
-        return settings
-
-    def load(self, settings: EnvironmentSettings):
-        self.mission.start_time = settings.start_time
-        self.mission.weather.load_from_dict(settings.weather_dict)
+    def set_wind(self, wind: WindConditions) -> None:
+        self.mission.weather.wind_at_ground = wind.at_0m
+        self.mission.weather.wind_at_2000 = wind.at_2000m
+        self.mission.weather.wind_at_8000 = wind.at_8000m
 
+    def generate(self):
+        self.mission.start_time = self.conditions.start_time
+        self.set_clouds(self.conditions.weather.clouds)
+        self.set_fog(self.conditions.weather.fog)
+        self.set_wind(self.conditions.weather.wind)

gen/fleet/carrier_group.py

@@ -0,0 +1,123 @@
+import random
+
+from gen.sam.group_generator import ShipGroupGenerator
+
+from dcs.ships import DDG_Arleigh_Burke_IIa, CG_Ticonderoga
+
+
+class CarrierGroupGenerator(ShipGroupGenerator):
+    def generate(self):
+
+        # Carrier Strike Group 8
+        if self.faction.carrier_names[0] == "Carrier Strike Group 8":
+            carrier_type = random.choice(self.faction.aircraft_carrier)
+
+            self.add_unit(
+                carrier_type,
+                "CVN-75 Harry S. Truman",
+                self.position.x,
+                self.position.y,
+                self.heading,
+            )
+
+            # Add Arleigh Burke escort
+            self.add_unit(
+                DDG_Arleigh_Burke_IIa,
+                "USS Ramage",
+                self.position.x + 6482,
+                self.position.y + 6667,
+                self.heading,
+            )
+
+            self.add_unit(
+                DDG_Arleigh_Burke_IIa,
+                "USS Mitscher",
+                self.position.x - 7963,
+                self.position.y + 7037,
+                self.heading,
+            )
+
+            self.add_unit(
+                DDG_Arleigh_Burke_IIa,
+                "USS Forrest Sherman",
+                self.position.x - 7408,
+                self.position.y - 7408,
+                self.heading,
+            )
+
+            self.add_unit(
+                DDG_Arleigh_Burke_IIa,
+                "USS Lassen",
+                self.position.x + 8704,
+                self.position.y - 6296,
+                self.heading,
+            )
+
+            # Add Ticonderoga escort
+            if self.heading >= 180:
+                self.add_unit(
+                    CG_Ticonderoga,
+                    "USS Hué City",
+                    self.position.x + 2222,
+                    self.position.y - 3333,
+                    self.heading,
+                )
+            else:
+                self.add_unit(
+                    CG_Ticonderoga,
+                    "USS Hué City",
+                    self.position.x - 3333,
+                    self.position.y + 2222,
+                    self.heading,
+                )
+
+            self.get_generated_group().points[0].speed = 20
+        ##################################################################################################
+        # Add carrier for normal generation
+        else:
+            if len(self.faction.aircraft_carrier) > 0:
+                carrier_type = random.choice(self.faction.aircraft_carrier)
+                self.add_unit(
+                    carrier_type,
+                    "Carrier",
+                    self.position.x,
+                    self.position.y,
+                    self.heading,
+                )
+            else:
+                return
+
+            # Add destroyers escort
+            if len(self.faction.destroyers) > 0:
+                dd_type = random.choice(self.faction.destroyers)
+                self.add_unit(
+                    dd_type,
+                    "DD1",
+                    self.position.x + 2500,
+                    self.position.y + 4500,
+                    self.heading,
+                )
+                self.add_unit(
+                    dd_type,
+                    "DD2",
+                    self.position.x + 2500,
+                    self.position.y - 4500,
+                    self.heading,
+                )
+
+                self.add_unit(
+                    dd_type,
+                    "DD3",
+                    self.position.x + 4500,
+                    self.position.y + 8500,
+                    self.heading,
+                )
+                self.add_unit(
+                    dd_type,
+                    "DD4",
+                    self.position.x + 4500,
+                    self.position.y - 8500,
+                    self.heading,
+                )
+
+            self.get_generated_group().points[0].speed = 20

gen/fleet/cn_dd_group.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import random
+from typing import TYPE_CHECKING
+
+
+from dcs.ships import (
+    Type_052C_Destroyer,
+    Type_052B_Destroyer,
+    Type_054A_Frigate,
+)
+
+from game.factions.faction import Faction
+from gen.fleet.dd_group import DDGroupGenerator
+from gen.sam.group_generator import ShipGroupGenerator
+from game.theater.theatergroundobject import TheaterGroundObject
+
+if TYPE_CHECKING:
+    from game.game import Game
+
+
+class ChineseNavyGroupGenerator(ShipGroupGenerator):
+    def generate(self):
+
+        include_frigate = random.choice([True, True, False])
+        include_dd = random.choice([True, False])
+
+        if not any([include_frigate, include_dd]):
+            include_frigate = True
+
+        if include_frigate:
+            self.add_unit(
+                Type_054A_Frigate,
+                "FF1",
+                self.position.x + 1200,
+                self.position.y + 900,
+                self.heading,
+            )
+            self.add_unit(
+                Type_054A_Frigate,
+                "FF2",
+                self.position.x + 1200,
+                self.position.y - 900,
+                self.heading,
+            )
+
+        if include_dd:
+            dd_type = random.choice([Type_052C_Destroyer, Type_052B_Destroyer])
+            self.add_unit(
+                dd_type,
+                "DD1",
+                self.position.x + 2400,
+                self.position.y + 900,
+                self.heading,
+            )
+            self.add_unit(
+                dd_type,
+                "DD2",
+                self.position.x + 2400,
+                self.position.y - 900,
+                self.heading,
+            )
+
+        self.get_generated_group().points[0].speed = 20
+
+
+class Type54GroupGenerator(DDGroupGenerator):
+    def __init__(
+        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
+    ):
+        super(Type54GroupGenerator, self).__init__(
+            game, ground_object, faction, Type_054A_Frigate
+        )

gen/fleet/dd_group.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from game.factions.faction import Faction
+from game.theater.theatergroundobject import TheaterGroundObject
+
+from gen.sam.group_generator import ShipGroupGenerator
+from dcs.unittype import ShipType
+from dcs.ships import FFG_Oliver_Hazzard_Perry, DDG_Arleigh_Burke_IIa
+
+if TYPE_CHECKING:
+    from game.game import Game
+
+
+class DDGroupGenerator(ShipGroupGenerator):
+    def __init__(
+        self,
+        game: Game,
+        ground_object: TheaterGroundObject,
+        faction: Faction,
+        ddtype: ShipType,
+    ):
+        super(DDGroupGenerator, self).__init__(game, ground_object, faction)
+        self.ddtype = ddtype
+
+    def generate(self):
+        self.add_unit(
+            self.ddtype,
+            "DD1",
+            self.position.x + 500,
+            self.position.y + 900,
+            self.heading,
+        )
+        self.add_unit(
+            self.ddtype,
+            "DD2",
+            self.position.x + 500,
+            self.position.y - 900,
+            self.heading,
+        )
+        self.get_generated_group().points[0].speed = 20
+
+
+class OliverHazardPerryGroupGenerator(DDGroupGenerator):
+    def __init__(
+        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
+    ):
+        super(OliverHazardPerryGroupGenerator, self).__init__(
+            game, ground_object, faction, FFG_Oliver_Hazzard_Perry
+        )
+
+
+class ArleighBurkeGroupGenerator(DDGroupGenerator):
+    def __init__(
+        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
+    ):
+        super(ArleighBurkeGroupGenerator, self).__init__(
+            game, ground_object, faction, DDG_Arleigh_Burke_IIa
+        )

gen/fleet/lha_group.py

@@ -0,0 +1,34 @@
+import random
+
+from gen.sam.group_generator import ShipGroupGenerator
+
+
+class LHAGroupGenerator(ShipGroupGenerator):
+    def generate(self):
+
+        # Add carrier
+        if len(self.faction.helicopter_carrier) > 0:
+            carrier_type = random.choice(self.faction.helicopter_carrier)
+            self.add_unit(
+                carrier_type, "LHA", self.position.x, self.position.y, self.heading
+            )
+
+        # Add destroyers escort
+        if len(self.faction.destroyers) > 0:
+            dd_type = random.choice(self.faction.destroyers)
+            self.add_unit(
+                dd_type,
+                "DD1",
+                self.position.x + 1250,
+                self.position.y + 1450,
+                self.heading,
+            )
+            self.add_unit(
+                dd_type,
+                "DD2",
+                self.position.x + 1250,
+                self.position.y - 1450,
+                self.heading,
+            )
+
+        self.get_generated_group().points[0].speed = 20