Open all files with utf-8 encoding

- will not be used for binary read/writes (rb,wb)!
- prevents a bug where units with special characters in the unit name can not be tracked anymore as there will be a name mismatch due to wrong encoding

(cherry-picked from b5b0d82)

.gitignore

@@ -12,6 +12,7 @@ resources/tools/a.miz
 # User-specific stuff
 .idea/
 .env
+env/
 
 /kneeboards
 /liberation_preferences.json

.gitmodules

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

README.md

@@ -14,7 +14,7 @@
 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)
+![Screenshot](https://user-images.githubusercontent.com/315852/120939254-0b4a9f80-c6cc-11eb-82f5-ce3f8d714bfe.png)
 
 ## Downloads
 

changelog.md

@@ -1,3 +1,120 @@
+# 4.1.2
+
+Saves from 4.1.1 are compatible with 4.1.2.
+
+## Features/Improvements
+
+* **[Mission Generation]** EWRs are now also headed towards the center of the conflict
+* **[UI]** Sell Button for aircraft will be disabled if there are no units available to be sold or all are already assigned to a mission
+
+## Fixes
+
+* **[UI]** Selling of Units is now visible again in the UI dialog and shows the correct amount of sold units
+* **[Mission Generation]** Mission results and other files will now be opened with enforced utf-8 encoding to prevent an issue where destroyed ground units were untracked because of special characters in their names.
+
+# 4.1.1
+
+Saves from 4.1.0 are compatible with 4.1.1.
+
+## Fixes
+
+* **[Campaign]** Fixed broken support for Mariana Islands map.
+* **[Mission Generation]** Fix SAM sites pointing towards the center of the conflict.
+* **[Flight Planning]** No longer using Su-34 for CAP missions.
+
+# 4.1.0
+
+Saves from 4.0.0 are compatible with 4.1.0.
+
+## Features/Improvements
+
+* **[Campaign]** Air defense sites now generate a fixed number of launchers per type.
+* **[Campaign]** Added support for Mariana Islands map.
+* **[Campaign AI]** Adjustments to aircraft selection priorities for most mission types.
+* **[Engine]** Support for DCS 2.7.4.9632 and newer, including the Marianas map, F-16 JSOWs, NASAMS, and Tin Shield EWR.
+* **[Flight Planning]** CAP patrol altitudes are now set per-aircraft. By default the altitude will be set based on the aircraft's maximum speed.
+* **[Flight Planning]** CAP patrol speeds are now set per-aircraft to be more suitable/sensible. By default the speed will be set based on the aircraft's maximum speed.
+* **[Mission Generation]** Improvements for better support of the Skynet Plugin and long range SAMs are now acting as EWR
+* **[Mods]** Support for version v1.5.0-Beta of Gripen mod. In-progress campaigns may need to re-plan Gripen flights to pick up updated loadouts.
+* **[Mission Generation]** SAM sites are now headed towards the center of the conflict
+* **[Plugins]** Increased time JTAC Autolase messages stay visible on the UI.
+* **[Plugins]** Updated SkynetIADS to 2.2.0 (adds NASAMS support).  
+* **[UI]** Added ability to take notes and have those notes appear as a kneeboard page.
+* **[UI]** Hovering over the weather information now dispalys the cloud base (meters and feet).
+* **[UI]** Google search link added to unit information when there is no information provided.
+* **[UI]** Control point name displayed with ground object group name on map.
+* **[UI]** Buy or Replace will now show the correct price for generated ground objects like sams.
+* **[UI]** Improved logging for frontline movement to be more descriptive about what happened and why.
+* **[UI]** Brought ruler map module into source, which should fix file integrity issues with the module.
+
+## Fixes
+
+* **[Campaign]** Fixed the Silkworm generator to include launchers and not all radars.
+* **[Data]** Fixed Introduction dates for targeting pods (ATFLIR and LITENING were both a few years too early).
+* **[Data]** Removed SA-10 from Syria 2011 faction.
+* **[Economy]** EWRs can now be bought and sold for the correct price and can no longer be used to generate money
+* **[Flight Planning]** Helicopters are now correctly identified, and will fly ingress/CAS/BAI/egress and similar at low altitude.
+* **[Flight Planning]** Fixed potential issue with angles > 360° or < 0° being generated when summing two angles.
+* **[Mission Generation]** The lua data for other plugins is now generated correctly
+* **[Mission Generation]** Fixed problem with opfor planning missions against sold ground objects like SAMs
+* **[Mission Generation]** The legacy always-available tanker option no longer prevents mission creation.
+* **[Mission Generation]** Prevent the creation of a transfer order with 0 units for a rare situtation when a point was captured.
+* **[Mission Generation]** Planned transfers which will be impossible after a base capture will no longer prevent the mission result submit.
+* **[Mission Generation]** Fix occasional KeyError preventing mission generation when all units of the same type in a convoy were killed.
+* **[Mission Generation]** Fix for AAA Flak generator using Opel Blitz preventing the mission from being generated because duplicate unit names were used.
+* **[Campaign AI]** Transport aircraft will now be bought only if necessary at control points which can produce ground units and are capable to operate transport aircraft.
+* **[UI]** Statistics window tick marks are now always integers.
+* **[UI]** Statistics window now shows the correct info for the turn
+* **[UI]** Toggling custom loadout for an aircraft with no preset loadouts no longer breaks the flight.
+
+# 4.0.0
+
+Saves from 3.x are not compatible with 4.0.
+
+## Features/Improvements
+
+* **[Engine]** Support for DCS 2.7.2.7910.1 and newer, including Cyprus, F-16 JDAMs, and the Hind.
+* **[Campaign]** Squadrons now (optionally, off by default) have a maximum size and killed pilots replenish at a limited rate.
+* **[Campaign]** Added an option to disable levelling up of AI pilots.
+* **[Campaign]** Added Russian Intervention 2015 campaign on Syria, for a small and somewhat realistic Russian COIN scenario.
+* **[Campaign]** Added Operation Atilla campaign on Syria, for a reasonably large invasion of Cyprus scenario.
+* **[Campaign AI]** AI will plan Tanker flights.
+* **[Campaign AI]** Removed max distance for AEW&C auto planning.
+* **[Economy]** Adjusted prices for aircraft to balance out some price inconsistencies.
+* **[Factions]** Added more tankers to factions.
+* **[Flight Planner]** Added ability to plan Tankers.
+* **[Modding]** Campaign format version is now 7.0 to account for DCS map changes that made scenery strike targets incompatible with existing campaigns.
+* **[Mods]** Added support for the Gripen mod.
+* **[Mods]** Removes MB-339PAN support, as the mod is now deprecated and no longer works with DCS 2.7+.
+* **[Mission Generation]** Added support for "Neutral Dot" label options.
+* **[New Game Wizard]** Mods are now selected via checkboxes in the new game wizard, not as separate factions.
+* **[UI]** Ctrl click and shift click now buy or sell 5 or 10 units respectively.
+* **[UI]** Multiple waypoints can now be deleted simultaneously if multiple waypoints are selected.
+* **[UI]** Carriers and LHAs now match the colour of airfields, and their destination icons are translucent.
+* **[UI]** Updated intel box text for first turn.
+* **[UI]** Base Capture Cheat is now usable at all bases and can also be used to transfer player-owned bases to OPFOR.
+* **[UI]** Pass Turn button is relabled as "Begin Campaign" on Turn 0.  
+* **[UI]** Added a ruler to the map.
+* **[UI]** Liberation now saves games to `<DCS user directory>/Liberation/Saves` by default to declutter the main directory.
+
+## Fixes
+
+* **[Campaign AI]** Fix procurement for factions that lack some unit types.
+* **[Campaign AI]** Fix auto purchase of aircraft for factions that have no transport aircraft.
+* **[Campaign AI]** Fix refunding of pending aircraft purchases when a side has no factory available.  
+* **[Mission Generation]** Fixed problem with mission load when control point name contained an apostrophe.
+* **[Mission Generation]** Fixed EWR group names so they contribute to Skynet again.
+* **[Mission Generation]** Fixed duplicate name error when generating convoys and cargo ships when creating manual transfers after loading a game.
+* **[Mission Generation]** Fixed empty convoys not being disbanded when all units are killed/removed.
+* **[Mission Generation]** Fixed player losing frontline progress when skipping from turn 0 to turn 1.
+* **[Mission Generation]** Fixed issue where frontline would only search to the right for valid locations.
+* **[UI]** Made non-interactive map elements less obstructive.
+* **[UI]** Added support for Neutral Dot difficulty label
+* **[UI]** Clear skies at night no longer described as "Sunny" by the weather widget.
+* **[UI]** Removed ability to buy (useless) ground units at carriers and LHAs.
+* **[UI]** Fixed enable/disable of buy/sell buttons.
+* **[UI]** EWRs now appear in the custom waypoint list.
+
 # 3.0.0
 
 Saves from 2.5 are not compatible with 3.0.

game/data/aaa_db.py

@@ -1,22 +0,0 @@
-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_Insurgent_Closed_Emplacement,
-    AirDefence.SPAAA_ZU_23_2_Insurgent_Mounted_Ural_375,
-    AirDefence.AAA_ZU_23_Insurgent_Emplacement,
-    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_Bofors_40mm,
-    AirDefence.AAA_S_60_57mm,
-]

game/data/alic.py

@@ -4,35 +4,37 @@ from dcs.vehicles import AirDefence
 
 class AlicCodes:
     CODES = {
-        AirDefence.EWR_1L13.id: 101,
-        AirDefence.EWR_55G6.id: 102,
-        AirDefence.SAM_SA_10_S_300_Grumble_Clam_Shell_SR.id: 103,
-        AirDefence.SAM_SA_10_S_300_Grumble_Big_Bird_SR.id: 104,
-        AirDefence.SAM_SA_11_Buk_Gadfly_Snow_Drift_SR.id: 107,
-        AirDefence.SAM_SA_6_Kub_Straight_Flush_STR.id: 108,
-        AirDefence.MCC_SR_Sborka_Dog_Ear_SR.id: 109,
-        AirDefence.SAM_SA_10_S_300_Grumble_Flap_Lid_TR.id: 110,
-        AirDefence.SAM_SA_11_Buk_Gadfly_Fire_Dome_TEL.id: 115,
-        AirDefence.SAM_SA_8_Osa_Gecko_TEL.id: 117,
-        AirDefence.SAM_SA_13_Strela_10M3_Gopher_TEL.id: 118,
-        AirDefence.SAM_SA_15_Tor_Gauntlet.id: 119,
-        AirDefence.SAM_SA_19_Tunguska_Grison.id: 120,
-        AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish.id: 121,
-        AirDefence.SAM_P19_Flat_Face_SR__SA_2_3.id: 122,
-        AirDefence.SAM_SA_3_S_125_Low_Blow_TR.id: 123,
-        AirDefence.SAM_Rapier_Blindfire_TR.id: 124,
-        AirDefence.SAM_Rapier_LN.id: 125,
-        AirDefence.SAM_SA_2_S_75_Fan_Song_TR.id: 126,
-        AirDefence.HQ_7_Self_Propelled_LN.id: 127,
-        AirDefence.HQ_7_Self_Propelled_STR.id: 128,
-        AirDefence.SAM_Roland_ADS.id: 201,
-        AirDefence.SAM_Patriot_STR.id: 202,
-        AirDefence.SAM_Hawk_SR__AN_MPQ_50.id: 203,
-        AirDefence.SAM_Hawk_TR__AN_MPQ_46.id: 204,
-        AirDefence.SAM_Roland_EWR.id: 205,
-        AirDefence.SAM_Hawk_CWAR_AN_MPQ_55.id: 206,
-        AirDefence.SPAAA_Gepard.id: 207,
-        AirDefence.SPAAA_Vulcan_M163.id: 208,
+        AirDefence._1L13_EWR.id: 101,
+        AirDefence._55G6_EWR.id: 102,
+        AirDefence.S_300PS_40B6MD_sr.id: 103,
+        AirDefence.S_300PS_64H6E_sr.id: 104,
+        AirDefence.SA_11_Buk_SR_9S18M1.id: 107,
+        AirDefence.Kub_1S91_str.id: 108,
+        AirDefence.Dog_Ear_radar.id: 109,
+        AirDefence.S_300PS_40B6M_tr.id: 110,
+        AirDefence.SA_11_Buk_LN_9A310M1.id: 115,
+        AirDefence.Osa_9A33_ln.id: 117,
+        AirDefence.Strela_10M3.id: 118,
+        AirDefence.Tor_9A331.id: 119,
+        AirDefence._2S6_Tunguska.id: 120,
+        AirDefence.ZSU_23_4_Shilka.id: 121,
+        AirDefence.P_19_s_125_sr.id: 122,
+        AirDefence.Snr_s_125_tr.id: 123,
+        AirDefence.Rapier_fsa_blindfire_radar.id: 124,
+        AirDefence.Rapier_fsa_launcher.id: 125,
+        AirDefence.SNR_75V.id: 126,
+        AirDefence.HQ_7_LN_SP.id: 127,
+        AirDefence.HQ_7_STR_SP.id: 128,
+        AirDefence.RLS_19J6.id: 130,
+        AirDefence.Roland_ADS.id: 201,
+        AirDefence.Patriot_str.id: 202,
+        AirDefence.Hawk_sr.id: 203,
+        AirDefence.Hawk_tr.id: 204,
+        AirDefence.Roland_Radar.id: 205,
+        AirDefence.Hawk_cwar.id: 206,
+        AirDefence.Gepard.id: 207,
+        AirDefence.Vulcan.id: 208,
+        AirDefence.NASAMS_Radar_MPQ64F1.id: 209,
     }
 
     @classmethod

game/data/cap_capabilities_db.py

@@ -1,51 +0,0 @@
-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/groundunitclass.py

@@ -1,239 +1,17 @@
+from __future__ import annotations
+
 from enum import unique, Enum
-from typing import Type
-
-from dcs.vehicles import AirDefence, Infantry, Unarmed, Artillery, Armor
-from dcs.unittype import VehicleType
-
-from pydcs_extensions.frenchpack import frenchpack
 
 
 @unique
 class GroundUnitClass(Enum):
-    Tank = (
-        "Tank",
-        (
-            Armor.MBT_T_55,
-            Armor.MBT_T_72B,
-            Armor.MBT_T_72B3,
-            Armor.MBT_T_80U,
-            Armor.MBT_T_90,
-            Armor.MBT_Leopard_2A4,
-            Armor.MBT_Leopard_2A4_Trs,
-            Armor.MBT_Leopard_2A5,
-            Armor.MBT_Leopard_2A6M,
-            Armor.MBT_Leopard_1A3,
-            Armor.MBT_Leclerc,
-            Armor.MBT_Challenger_II,
-            Armor.MBT_Chieftain_Mk_3,
-            Armor.MBT_M1A2_Abrams,
-            Armor.MBT_M60A3_Patton,
-            Armor.MBT_Merkava_IV,
-            Armor.ZTZ_96B,
-            # WW2
-            # Axis
-            Armor.Tk_PzIV_H,
-            Armor.SPG_Sturmpanzer_IV_Brummbar,
-            Armor.MT_Pz_Kpfw_V_Panther_Ausf_G,
-            Armor.HT_Pz_Kpfw_VI_Tiger_I,
-            Armor.HT_Pz_Kpfw_VI_Ausf__B_Tiger_II,
-            # Allies
-            Armor.Tk_M4_Sherman,
-            Armor.CT_Centaur_IV,
-            Armor.CT_Cromwell_IV,
-            Armor.HIT_Churchill_VII,
-            # Mods
-            frenchpack.DIM__TOYOTA_BLUE,
-            frenchpack.DIM__TOYOTA_GREEN,
-            frenchpack.DIM__TOYOTA_DESERT,
-            frenchpack.DIM__KAMIKAZE,
-            frenchpack.AMX_30B2,
-            frenchpack.Leclerc_Serie_XXI,
-        ),
-    )
-
-    Atgm = (
-        "ATGM",
-        (
-            Armor.ATGM_HMMWV,
-            Armor.ATGM_VAB_Mephisto,
-            Armor.ATGM_Stryker,
-            Armor.IFV_BMP_2,
-            # WW2 (Tank Destroyers)
-            # Axxis
-            Armor.SPG_StuG_III_Ausf__G,
-            Armor.SPG_StuG_IV,
-            Armor.SPG_Jagdpanzer_IV,
-            Armor.SPG_Jagdpanther_G1,
-            Armor.SPG_Sd_Kfz_184_Elefant,
-            # Allies
-            Armor.SPG_M10_GMC,
-            Armor.MT_M4A4_Sherman_Firefly,
-            # Mods
-            frenchpack.VBAE_CRAB_MMP,
-            frenchpack.VAB_MEPHISTO,
-            frenchpack.TRM_2000_PAMELA,
-        ),
-    )
-
-    Ifv = (
-        "IFV",
-        (
-            Armor.IFV_BMP_3,
-            Armor.IFV_BMP_2,
-            Armor.IFV_BMP_1,
-            Armor.IFV_Marder,
-            Armor.IFV_Warrior,
-            Armor.SPG_Stryker_MGS,
-            Armor.IFV_M2A2_Bradley,
-            Armor.IFV_BMD_1,
-            Armor.ZBD_04A,
-            # Mods
-            frenchpack.VBAE_CRAB,
-            frenchpack.VAB_T20_13,
-        ),
-    )
-
-    Apc = (
-        "APC",
-        (
-            Armor.IFV_M1126_Stryker_ICV,
-            Armor.APC_M113,
-            Armor.APC_BTR_80,
-            Armor.IFV_BTR_82A,
-            Armor.APC_MTLB,
-            Armor.APC_AAV_7_Amphibious,
-            Armor.APC_TPz_Fuchs,
-            Armor.APC_BTR_RD,
-            # WW2
-            Armor.APC_M2A1_Halftrack,
-            Armor.APC_Sd_Kfz_251_Halftrack,
-            # Mods
-            frenchpack.VAB__50,
-            frenchpack.VBL__50,
-            frenchpack.VBL_AANF1,
-        ),
-    )
-
-    Artillery = (
-        "Artillery",
-        (
-            Artillery.Grad_MRL_FDDM__FC,
-            Artillery.MLRS_9A52_Smerch_HE_300mm,
-            Artillery.SPH_2S1_Gvozdika_122mm,
-            Artillery.SPH_2S3_Akatsia_152mm,
-            Artillery.MLRS_BM_21_Grad_122mm,
-            Artillery.MLRS_9K57_Uragan_BM_27_220mm,
-            Artillery.SPH_M109_Paladin_155mm,
-            Artillery.MLRS_M270_227mm,
-            Artillery.SPM_2S9_Nona_120mm_M,
-            Artillery.SPH_Dana_vz77_152mm,
-            Artillery.SPH_T155_Firtina_155mm,
-            Artillery.PLZ_05,
-            Artillery.SPH_2S19_Msta_152mm,
-            Artillery.MLRS_9A52_Smerch_CM_300mm,
-            # WW2
-            Artillery.SPG_M12_GMC_155mm,
-        ),
-    )
-
-    Logistics = (
-        "Logistics",
-        (
-            Unarmed.Carrier_M30_Cargo,
-            Unarmed.Truck_M818_6x6,
-            Unarmed.Truck_KAMAZ_43101,
-            Unarmed.Truck_Ural_375,
-            Unarmed.Truck_GAZ_66,
-            Unarmed.Truck_GAZ_3307,
-            Unarmed.Truck_GAZ_3308,
-            Unarmed.Truck_Ural_4320_31_Arm_d,
-            Unarmed.Truck_Ural_4320T,
-            Unarmed.Truck_Opel_Blitz,
-            Unarmed.LUV_Kubelwagen_82,
-            Unarmed.Carrier_Sd_Kfz_7_Tractor,
-            Unarmed.LUV_Kettenrad,
-            Unarmed.Car_Willys_Jeep,
-            Unarmed.LUV_Land_Rover_109,
-            Unarmed.Truck_Land_Rover_101_FC,
-            # Mods
-            frenchpack.VBL,
-            frenchpack.VAB,
-        ),
-    )
-
-    Recon = (
-        "Recon",
-        (
-            Armor.Scout_HMMWV,
-            Armor.Scout_Cobra,
-            Armor.LT_PT_76,
-            Armor.IFV_LAV_25,
-            Armor.Scout_BRDM_2,
-            # WW2
-            Armor.LT_Mk_VII_Tetrarch,
-            Armor.IFV_Sd_Kfz_234_2_Puma,
-            Armor.Car_M8_Greyhound_Armored,
-            Armor.Car_Daimler_Armored,
-            # Mods
-            frenchpack.ERC_90,
-            frenchpack.AMX_10RCR,
-            frenchpack.AMX_10RCR_SEPAR,
-        ),
-    )
-
-    Infantry = (
-        "Infantry",
-        (
-            Infantry.Insurgent_AK_74,
-            Infantry.Infantry_AK_74,
-            Infantry.Infantry_M1_Garand,
-            Infantry.Infantry_Mauser_98,
-            Infantry.Infantry_SMLE_No_4_Mk_1,
-            Infantry.Infantry_M4_Georgia,
-            Infantry.Infantry_AK_74_Rus,
-            Infantry.Paratrooper_AKS,
-            Infantry.Paratrooper_RPG_16,
-            Infantry.Infantry_M249,
-            Infantry.Infantry_M4,
-            Infantry.Infantry_RPG,
-        ),
-    )
-
-    Shorads = (
-        "SHORADS",
-        (
-            AirDefence.SPAAA_ZU_23_2_Mounted_Ural_375,
-            AirDefence.SPAAA_ZU_23_2_Insurgent_Mounted_Ural_375,
-            AirDefence.SPAAA_ZSU_57_2,
-            AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
-            AirDefence.SAM_SA_8_Osa_Gecko_TEL,
-            AirDefence.SAM_SA_9_Strela_1_Gaskin_TEL,
-            AirDefence.SAM_SA_13_Strela_10M3_Gopher_TEL,
-            AirDefence.SAM_SA_15_Tor_Gauntlet,
-            AirDefence.SAM_SA_19_Tunguska_Grison,
-            AirDefence.SPAAA_Gepard,
-            AirDefence.SPAAA_Vulcan_M163,
-            AirDefence.SAM_Linebacker___Bradley_M6,
-            AirDefence.SAM_Chaparral_M48,
-            AirDefence.SAM_Avenger__Stinger,
-            AirDefence.SAM_Roland_ADS,
-            AirDefence.HQ_7_Self_Propelled_LN,
-            AirDefence.AAA_8_8cm_Flak_18,
-            AirDefence.AAA_8_8cm_Flak_36,
-            AirDefence.AAA_8_8cm_Flak_37,
-            AirDefence.AAA_8_8cm_Flak_41,
-            AirDefence.AAA_Bofors_40mm,
-            AirDefence.AAA_S_60_57mm,
-            AirDefence.AAA_M1_37mm,
-            AirDefence.AAA_QF_3_7,
-        ),
-    )
-
-    def __init__(
-        self, class_name: str, unit_list: tuple[Type[VehicleType], ...]
-    ) -> None:
-        self.class_name = class_name
-        self.unit_list = unit_list
-
-    def __contains__(self, unit_type: Type[VehicleType]) -> bool:
-        return unit_type in self.unit_list
+    Tank = "Tank"
+    Atgm = "ATGM"
+    Ifv = "IFV"
+    Apc = "APC"
+    Artillery = "Artillery"
+    Logistics = "Logistics"
+    Recon = "Recon"
+    Infantry = "Infantry"
+    Shorads = "SHORADS"
+    Manpads = "MANPADS"

game/data/radar_db.py

@@ -1,108 +1,108 @@
 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,
+    PIOTR,
+    MOSCOW,
+    VINSON,
+    CVN_71,
+    CVN_72,
+    CVN_73,
+    Stennis,
+    KUZNECOW,
+    CV_1143_5,
+    NEUSTRASH,
+    ALBATROS,
+    REZKY,
+    MOLNIYA,
+    LHA_Tarawa,
+    PERRY,
+    TICONDEROG,
+    Type_052B,
+    Type_052C,
+    Type_054A,
+    USS_Arleigh_Burke_IIa,
 )
 from dcs.vehicles import AirDefence
 
 TELARS = {
-    AirDefence.SAM_SA_19_Tunguska_Grison,
-    AirDefence.SAM_SA_11_Buk_Gadfly_Fire_Dome_TEL,
-    AirDefence.SAM_SA_8_Osa_Gecko_TEL,
-    AirDefence.SAM_SA_15_Tor_Gauntlet,
-    AirDefence.SAM_Roland_ADS,
+    AirDefence._2S6_Tunguska,
+    AirDefence.SA_11_Buk_SR_9S18M1,
+    AirDefence.Osa_9A33_ln,
+    AirDefence.Tor_9A331,
+    AirDefence.Roland_ADS,
 }
 
 TRACK_RADARS = {
-    AirDefence.SAM_SA_6_Kub_Straight_Flush_STR,
-    AirDefence.SAM_SA_3_S_125_Low_Blow_TR,
-    AirDefence.SAM_SA_10_S_300_Grumble_Flap_Lid_TR,
-    AirDefence.SAM_Hawk_TR__AN_MPQ_46,
-    AirDefence.SAM_Patriot_STR,
-    AirDefence.SAM_SA_2_S_75_Fan_Song_TR,
-    AirDefence.SAM_Rapier_Blindfire_TR,
-    AirDefence.HQ_7_Self_Propelled_STR,
+    AirDefence.Kub_1S91_str,
+    AirDefence.Snr_s_125_tr,
+    AirDefence.S_300PS_40B6M_tr,
+    AirDefence.Hawk_tr,
+    AirDefence.Patriot_str,
+    AirDefence.SNR_75V,
+    AirDefence.Rapier_fsa_blindfire_radar,
+    AirDefence.HQ_7_STR_SP,
 }
 
 LAUNCHER_TRACKER_PAIRS = {
-    AirDefence.SAM_SA_6_Kub_Gainful_TEL: AirDefence.SAM_SA_6_Kub_Straight_Flush_STR,
-    AirDefence.SAM_SA_3_S_125_Goa_LN: AirDefence.SAM_SA_3_S_125_Low_Blow_TR,
-    AirDefence.SAM_SA_10_S_300_Grumble_TEL_D: AirDefence.SAM_SA_10_S_300_Grumble_Flap_Lid_TR,
-    AirDefence.SAM_SA_10_S_300_Grumble_TEL_C: AirDefence.SAM_SA_10_S_300_Grumble_Flap_Lid_TR,
-    AirDefence.SAM_Hawk_LN_M192: AirDefence.SAM_Hawk_TR__AN_MPQ_46,
-    AirDefence.SAM_Patriot_LN: AirDefence.SAM_Patriot_STR,
-    AirDefence.SAM_SA_2_S_75_Guideline_LN: AirDefence.SAM_SA_2_S_75_Fan_Song_TR,
-    AirDefence.SAM_Rapier_LN: AirDefence.SAM_Rapier_Blindfire_TR,
-    AirDefence.HQ_7_Self_Propelled_LN: AirDefence.HQ_7_Self_Propelled_STR,
+    AirDefence.Kub_2P25_ln: AirDefence.Kub_1S91_str,
+    AirDefence._5p73_s_125_ln: AirDefence.Snr_s_125_tr,
+    AirDefence.S_300PS_5P85C_ln: AirDefence.S_300PS_40B6M_tr,
+    AirDefence.S_300PS_5P85D_ln: AirDefence.S_300PS_40B6M_tr,
+    AirDefence.Hawk_ln: AirDefence.Hawk_tr,
+    AirDefence.Patriot_ln: AirDefence.Patriot_str,
+    AirDefence.S_75M_Volhov: AirDefence.SNR_75V,
+    AirDefence.Rapier_fsa_launcher: AirDefence.Rapier_fsa_blindfire_radar,
+    AirDefence.HQ_7_LN_SP: AirDefence.HQ_7_STR_SP,
 }
 
 UNITS_WITH_RADAR = {
     # Radars
-    AirDefence.SAM_SA_19_Tunguska_Grison,
-    AirDefence.SAM_SA_11_Buk_Gadfly_Fire_Dome_TEL,
-    AirDefence.SAM_SA_8_Osa_Gecko_TEL,
-    AirDefence.SAM_SA_15_Tor_Gauntlet,
-    AirDefence.SPAAA_Gepard,
-    AirDefence.SPAAA_Vulcan_M163,
-    AirDefence.SAM_Roland_ADS,
-    AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
-    AirDefence.EWR_1L13,
-    AirDefence.SAM_SA_6_Kub_Straight_Flush_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.SAM_Rapier_Blindfire_TR,
-    AirDefence.HQ_7_Self_Propelled_LN,
-    AirDefence.HQ_7_Self_Propelled_STR,
-    AirDefence.EWR_FuMG_401_Freya_LZ,
-    AirDefence.EWR_FuSe_65_Würzburg_Riese,
+    AirDefence._2S6_Tunguska,
+    AirDefence.SA_11_Buk_LN_9A310M1,
+    AirDefence.Osa_9A33_ln,
+    AirDefence.Tor_9A331,
+    AirDefence.Gepard,
+    AirDefence.Vulcan,
+    AirDefence.Roland_ADS,
+    AirDefence.ZSU_23_4_Shilka,
+    AirDefence._1L13_EWR,
+    AirDefence.Kub_1S91_str,
+    AirDefence.S_300PS_40B6M_tr,
+    AirDefence.S_300PS_40B6MD_sr,
+    AirDefence._55G6_EWR,
+    AirDefence.S_300PS_64H6E_sr,
+    AirDefence.SA_11_Buk_SR_9S18M1,
+    AirDefence.Dog_Ear_radar,
+    AirDefence.Hawk_tr,
+    AirDefence.Hawk_sr,
+    AirDefence.Patriot_str,
+    AirDefence.Hawk_cwar,
+    AirDefence.P_19_s_125_sr,
+    AirDefence.Roland_Radar,
+    AirDefence.Snr_s_125_tr,
+    AirDefence.SNR_75V,
+    AirDefence.Rapier_fsa_blindfire_radar,
+    AirDefence.HQ_7_LN_SP,
+    AirDefence.HQ_7_STR_SP,
+    AirDefence.FuMG_401,
+    AirDefence.FuSe_65,
     # 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,
+    VINSON,
+    PERRY,
+    TICONDEROG,
+    ALBATROS,
+    KUZNECOW,
+    MOLNIYA,
+    MOSCOW,
+    NEUSTRASH,
+    PIOTR,
+    REZKY,
+    CV_1143_5,
+    Stennis,
+    CVN_71,
+    CVN_72,
+    CVN_73,
+    USS_Arleigh_Burke_IIa,
+    LHA_Tarawa,
+    Type_052B,
+    Type_054A,
+    Type_052C,
 }

game/data/weapons.py

@@ -4,15 +4,15 @@ import datetime
 import inspect
 import logging
 from collections import defaultdict
-from dataclasses import dataclass
-from typing import Dict, Iterator, Optional, Set, Tuple, Type, Union, cast
+from dataclasses import dataclass, field
+from typing import Dict, Iterator, Optional, Set, Tuple, cast, Any
 
 from dcs.unitgroup import FlyingGroup
-from dcs.unittype import FlyingType
 from dcs.weapons_data import Weapons, weapon_ids
 
+from game.dcs.aircrafttype import AircraftType
 
-PydcsWeapon = Dict[str, Union[int, str]]
+PydcsWeapon = Any
 PydcsWeaponAssignment = Tuple[int, PydcsWeapon]
 
 
@@ -21,8 +21,8 @@ class Weapon:
     """Wraps a pydcs weapon dict in a hashable type."""
 
     cls_id: str
-    name: str
-    weight: int
+    name: str = field(compare=False)
+    weight: int = field(compare=False)
 
     def available_on(self, date: datetime.date) -> bool:
         introduction_year = WEAPON_INTRODUCTION_YEARS.get(self)
@@ -83,7 +83,7 @@ class Pylon:
         # configuration.
         return weapon in self.allowed or weapon.cls_id == "<CLEAN>"
 
-    def equip(self, group: FlyingGroup, weapon: Weapon) -> None:
+    def equip(self, group: FlyingGroup[Any], weapon: Weapon) -> None:
         if not self.can_equip(weapon):
             logging.error(f"Pylon {self.number} cannot equip {weapon.name}")
         group.load_pylon(self.make_pydcs_assignment(weapon), self.number)
@@ -97,12 +97,12 @@ class Pylon:
                 yield weapon
 
     @classmethod
-    def for_aircraft(cls, aircraft: Type[FlyingType], number: int) -> Pylon:
+    def for_aircraft(cls, aircraft: AircraftType, number: int) -> Pylon:
         # In pydcs these are all arbitrary inner classes of the aircraft type.
         # The only way to identify them is by their name.
         pylons = [
             v
-            for v in aircraft.__dict__.values()
+            for v in aircraft.dcs_unit_type.__dict__.values()
             if inspect.isclass(v) and v.__name__.startswith("Pylon")
         ]
 
@@ -121,8 +121,8 @@ class Pylon:
         return cls(number, allowed)
 
     @classmethod
-    def iter_pylons(cls, aircraft: Type[FlyingType]) -> Iterator[Pylon]:
-        for pylon in sorted(list(aircraft.pylons)):
+    def iter_pylons(cls, aircraft: AircraftType) -> Iterator[Pylon]:
+        for pylon in sorted(list(aircraft.dcs_unit_type.pylons)):
             yield cls.for_aircraft(aircraft, pylon)
 
 
@@ -888,16 +888,16 @@ WEAPON_INTRODUCTION_YEARS = {
     Weapon.from_pydcs(Weapons.ALQ_184): 1989,
     Weapon.from_pydcs(Weapons.AN_ALQ_164_DECM_Pod): 1984,
     # TGP Pods
-    Weapon.from_pydcs(Weapons.AN_AAQ_28_LITENING___Targeting_Pod): 1995,
-    Weapon.from_pydcs(Weapons.AN_AAQ_28_LITENING___Targeting_Pod_): 1995,
-    Weapon.from_pydcs(Weapons.AN_ASQ_228_ATFLIR___Targeting_Pod): 1993,
+    Weapon.from_pydcs(Weapons.AN_AAQ_28_LITENING___Targeting_Pod): 1999,
+    Weapon.from_pydcs(Weapons.AN_AAQ_28_LITENING___Targeting_Pod_): 1999,
+    Weapon.from_pydcs(Weapons.AN_ASQ_228_ATFLIR___Targeting_Pod): 2003,
     Weapon.from_pydcs(
         Weapons.AN_ASQ_173_Laser_Spot_Tracker_Strike_CAMera__LST_SCAM_
     ): 1993,
     Weapon.from_pydcs(Weapons.AWW_13_DATALINK_POD): 1967,
-    Weapon.from_pydcs(Weapons.LANTIRN_Targeting_Pod): 1985,
-    Weapon.from_pydcs(Weapons.Lantirn_F_16): 1985,
-    Weapon.from_pydcs(Weapons.Lantirn_Target_Pod): 1985,
+    Weapon.from_pydcs(Weapons.LANTIRN_Targeting_Pod): 1990,
+    Weapon.from_pydcs(Weapons.Lantirn_F_16): 1990,
+    Weapon.from_pydcs(Weapons.Lantirn_Target_Pod): 1990,
     Weapon.from_pydcs(Weapons.Pavetack_F_111): 1982,
     # BLU-107
     Weapon.from_pydcs(Weapons.BLU_107___440lb_Anti_Runway_Penetrator_Bomb): 1983,

game/dcs/aircrafttype.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import ClassVar, Type, Iterator, TYPE_CHECKING, Optional, Any
+
+import yaml
+from dcs.helicopters import helicopter_map
+from dcs.planes import plane_map
+from dcs.unittype import FlyingType
+
+from game.dcs.unittype import UnitType
+from game.radio.channels import (
+    ChannelNamer,
+    RadioChannelAllocator,
+    CommonRadioChannelAllocator,
+    HueyChannelNamer,
+    SCR522ChannelNamer,
+    ViggenChannelNamer,
+    ViperChannelNamer,
+    TomcatChannelNamer,
+    MirageChannelNamer,
+    SingleRadioChannelNamer,
+    FarmerRadioChannelAllocator,
+    SCR522RadioChannelAllocator,
+    ViggenRadioChannelAllocator,
+    NoOpChannelAllocator,
+)
+from game.utils import (
+    Distance,
+    SPEED_OF_SOUND_AT_SEA_LEVEL,
+    Speed,
+    feet,
+    kph,
+    knots,
+)
+
+if TYPE_CHECKING:
+    from gen.aircraft import FlightData
+    from gen import AirSupport, RadioFrequency, RadioRegistry
+    from gen.radios import Radio
+
+
+@dataclass(frozen=True)
+class RadioConfig:
+    inter_flight: Optional[Radio]
+    intra_flight: Optional[Radio]
+    channel_allocator: Optional[RadioChannelAllocator]
+    channel_namer: Type[ChannelNamer]
+
+    @classmethod
+    def from_data(cls, data: dict[str, Any]) -> RadioConfig:
+        return RadioConfig(
+            cls.make_radio(data.get("inter_flight", None)),
+            cls.make_radio(data.get("intra_flight", None)),
+            cls.make_allocator(data.get("channels", {})),
+            cls.make_namer(data.get("channels", {})),
+        )
+
+    @classmethod
+    def make_radio(cls, name: Optional[str]) -> Optional[Radio]:
+        from gen.radios import get_radio
+
+        if name is None:
+            return None
+        return get_radio(name)
+
+    @classmethod
+    def make_allocator(cls, data: dict[str, Any]) -> Optional[RadioChannelAllocator]:
+        try:
+            alloc_type = data["type"]
+        except KeyError:
+            return None
+        allocator_type: Type[RadioChannelAllocator] = {
+            "SCR-522": SCR522RadioChannelAllocator,
+            "common": CommonRadioChannelAllocator,
+            "farmer": FarmerRadioChannelAllocator,
+            "noop": NoOpChannelAllocator,
+            "viggen": ViggenRadioChannelAllocator,
+        }[alloc_type]
+        return allocator_type.from_cfg(data)
+
+    @classmethod
+    def make_namer(cls, config: dict[str, Any]) -> Type[ChannelNamer]:
+        return {
+            "SCR-522": SCR522ChannelNamer,
+            "default": ChannelNamer,
+            "huey": HueyChannelNamer,
+            "mirage": MirageChannelNamer,
+            "single": SingleRadioChannelNamer,
+            "tomcat": TomcatChannelNamer,
+            "viggen": ViggenChannelNamer,
+            "viper": ViperChannelNamer,
+        }[config.get("namer", "default")]
+
+
+@dataclass(frozen=True)
+class PatrolConfig:
+    altitude: Optional[Distance]
+    speed: Optional[Speed]
+
+    @classmethod
+    def from_data(cls, data: dict[str, Any]) -> PatrolConfig:
+        altitude = data.get("altitude", None)
+        speed = data.get("speed", None)
+        return PatrolConfig(
+            feet(altitude) if altitude is not None else None,
+            knots(speed) if speed is not None else None,
+        )
+
+
+# TODO: Split into PlaneType and HelicopterType?
+@dataclass(frozen=True)
+class AircraftType(UnitType[Type[FlyingType]]):
+    carrier_capable: bool
+    lha_capable: bool
+    always_keeps_gun: bool
+
+    # If true, the aircraft does not use the guns as the last resort weapons, but as a main weapon.
+    # It'll RTB when it doesn't have gun ammo left.
+    gunfighter: bool
+
+    max_group_size: int
+    patrol_altitude: Optional[Distance]
+    patrol_speed: Optional[Speed]
+    intra_flight_radio: Optional[Radio]
+    channel_allocator: Optional[RadioChannelAllocator]
+    channel_namer: Type[ChannelNamer]
+
+    _by_name: ClassVar[dict[str, AircraftType]] = {}
+    _by_unit_type: ClassVar[dict[Type[FlyingType], list[AircraftType]]] = defaultdict(
+        list
+    )
+    _loaded: ClassVar[bool] = False
+
+    def __str__(self) -> str:
+        return self.name
+
+    @property
+    def dcs_id(self) -> str:
+        return self.dcs_unit_type.id
+
+    @property
+    def flyable(self) -> bool:
+        return self.dcs_unit_type.flyable
+
+    @cached_property
+    def max_speed(self) -> Speed:
+        return kph(self.dcs_unit_type.max_speed)
+
+    @property
+    def preferred_patrol_altitude(self) -> Distance:
+        if self.patrol_altitude is not None:
+            return self.patrol_altitude
+        else:
+            # Estimate based on max speed.
+            # Aircaft with max speed 600 kph will prefer patrol at 10 000 ft
+            # Aircraft with max speed 2800 kph will prefer pratrol at 33 000 ft
+            altitude_for_lowest_speed = feet(10 * 1000)
+            altitude_for_highest_speed = feet(33 * 1000)
+            lowest_speed = kph(600)
+            highest_speed = kph(2800)
+            factor = (self.max_speed - lowest_speed).kph / (
+                highest_speed - lowest_speed
+            ).kph
+            altitude = (
+                altitude_for_lowest_speed
+                + (altitude_for_highest_speed - altitude_for_lowest_speed) * factor
+            )
+            logging.debug(
+                f"Preferred patrol altitude for {self.dcs_unit_type.id}: {altitude.feet}"
+            )
+            rounded_altitude = feet(round(1000 * round(altitude.feet / 1000)))
+            return max(
+                altitude_for_lowest_speed,
+                min(altitude_for_highest_speed, rounded_altitude),
+            )
+
+    def preferred_patrol_speed(self, altitude: Distance) -> Speed:
+        """Preferred true airspeed when patrolling"""
+        if self.patrol_speed is not None:
+            return self.patrol_speed
+        else:
+            # Estimate based on max speed.
+            max_speed = self.max_speed
+            if max_speed > SPEED_OF_SOUND_AT_SEA_LEVEL * 1.6:
+                # Fast airplanes, should manage pretty high patrol speed
+                return (
+                    Speed.from_mach(0.85, altitude)
+                    if altitude.feet > 20000
+                    else Speed.from_mach(0.7, altitude)
+                )
+            elif max_speed > SPEED_OF_SOUND_AT_SEA_LEVEL * 1.2:
+                # Medium-fast like F/A-18C
+                return (
+                    Speed.from_mach(0.8, altitude)
+                    if altitude.feet > 20000
+                    else Speed.from_mach(0.65, altitude)
+                )
+            elif max_speed > SPEED_OF_SOUND_AT_SEA_LEVEL * 0.7:
+                # Semi-fast like airliners or similar
+                return (
+                    Speed.from_mach(0.5, altitude)
+                    if altitude.feet > 20000
+                    else Speed.from_mach(0.4, altitude)
+                )
+            else:
+                # Slow like warbirds or helicopters
+                # Use whichever is slowest - mach 0.35 or 70% of max speed
+                logging.debug(f"{self.name} max_speed * 0.7 is {max_speed * 0.7}")
+                return min(Speed.from_mach(0.35, altitude), max_speed * 0.7)
+
+    def alloc_flight_radio(self, radio_registry: RadioRegistry) -> RadioFrequency:
+        from gen.radios import ChannelInUseError, kHz
+
+        if self.intra_flight_radio is not None:
+            return radio_registry.alloc_for_radio(self.intra_flight_radio)
+
+        # The default radio frequency is set in megahertz. For some aircraft, it is a
+        # floating point value. For all current aircraft, adjusting to kilohertz will be
+        # sufficient to convert to an integer.
+        in_khz = float(self.dcs_unit_type.radio_frequency) * 1000
+        if not in_khz.is_integer():
+            logging.warning(
+                f"Found unexpected sub-kHz default radio for {self}: {in_khz} kHz. "
+                "Truncating to integer. The truncated frequency may not be valid for "
+                "the aircraft."
+            )
+
+        freq = kHz(int(in_khz))
+        try:
+            radio_registry.reserve(freq)
+        except ChannelInUseError:
+            pass
+        return freq
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        if self.channel_allocator is not None:
+            self.channel_allocator.assign_channels_for_flight(flight, air_support)
+
+    def channel_name(self, radio_id: int, channel_id: int) -> str:
+        return self.channel_namer.channel_name(radio_id, channel_id)
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        # Update any existing models with new data on load.
+        updated = AircraftType.named(state["name"])
+        state.update(updated.__dict__)
+        self.__dict__.update(state)
+
+    @classmethod
+    def register(cls, aircraft_type: AircraftType) -> None:
+        cls._by_name[aircraft_type.name] = aircraft_type
+        cls._by_unit_type[aircraft_type.dcs_unit_type].append(aircraft_type)
+
+    @classmethod
+    def named(cls, name: str) -> AircraftType:
+        if not cls._loaded:
+            cls._load_all()
+        return cls._by_name[name]
+
+    @classmethod
+    def for_dcs_type(cls, dcs_unit_type: Type[FlyingType]) -> Iterator[AircraftType]:
+        if not cls._loaded:
+            cls._load_all()
+        yield from cls._by_unit_type[dcs_unit_type]
+
+    @staticmethod
+    def _each_unit_type() -> Iterator[Type[FlyingType]]:
+        yield from helicopter_map.values()
+        yield from plane_map.values()
+
+    @classmethod
+    def _load_all(cls) -> None:
+        for unit_type in cls._each_unit_type():
+            for data in cls._each_variant_of(unit_type):
+                cls.register(data)
+        cls._loaded = True
+
+    @classmethod
+    def _each_variant_of(cls, aircraft: Type[FlyingType]) -> Iterator[AircraftType]:
+        data_path = Path("resources/units/aircraft") / f"{aircraft.id}.yaml"
+        if not data_path.exists():
+            logging.warning(f"No data for {aircraft.id}; it will not be available")
+            return
+
+        with data_path.open(encoding="utf-8") as data_file:
+            data = yaml.safe_load(data_file)
+
+        try:
+            price = data["price"]
+        except KeyError as ex:
+            raise KeyError(f"Missing required price field: {data_path}") from ex
+
+        radio_config = RadioConfig.from_data(data.get("radios", {}))
+        patrol_config = PatrolConfig.from_data(data.get("patrol", {}))
+
+        try:
+            introduction = data["introduced"]
+            if introduction is None:
+                introduction = "N/A"
+        except KeyError:
+            introduction = "No data."
+
+        for variant in data.get("variants", [aircraft.id]):
+            yield AircraftType(
+                dcs_unit_type=aircraft,
+                name=variant,
+                description=data.get(
+                    "description",
+                    f"No data. <a href=\"https://google.com/search?q=DCS+{variant.replace(' ', '+')}\"><span style=\"color:#FFFFFF\">Google {variant}</span></a>",
+                ),
+                year_introduced=introduction,
+                country_of_origin=data.get("origin", "No data."),
+                manufacturer=data.get("manufacturer", "No data."),
+                role=data.get("role", "No data."),
+                price=price,
+                carrier_capable=data.get("carrier_capable", False),
+                lha_capable=data.get("lha_capable", False),
+                always_keeps_gun=data.get("always_keeps_gun", False),
+                gunfighter=data.get("gunfighter", False),
+                max_group_size=data.get("max_group_size", aircraft.group_size_max),
+                patrol_altitude=patrol_config.altitude,
+                patrol_speed=patrol_config.speed,
+                intra_flight_radio=radio_config.intra_flight,
+                channel_allocator=radio_config.channel_allocator,
+                channel_namer=radio_config.channel_namer,
+            )

game/dcs/groundunittype.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Type, Optional, ClassVar, Iterator
+
+import yaml
+from dcs.unittype import VehicleType
+from dcs.vehicles import vehicle_map
+
+from game.data.groundunitclass import GroundUnitClass
+from game.dcs.unittype import UnitType
+
+
+@dataclass(frozen=True)
+class GroundUnitType(UnitType[Type[VehicleType]]):
+    unit_class: Optional[GroundUnitClass]
+    spawn_weight: int
+
+    _by_name: ClassVar[dict[str, GroundUnitType]] = {}
+    _by_unit_type: ClassVar[
+        dict[Type[VehicleType], list[GroundUnitType]]
+    ] = defaultdict(list)
+    _loaded: ClassVar[bool] = False
+
+    def __str__(self) -> str:
+        return self.name
+
+    @property
+    def dcs_id(self) -> str:
+        return self.dcs_unit_type.id
+
+    @classmethod
+    def register(cls, aircraft_type: GroundUnitType) -> None:
+        cls._by_name[aircraft_type.name] = aircraft_type
+        cls._by_unit_type[aircraft_type.dcs_unit_type].append(aircraft_type)
+
+    @classmethod
+    def named(cls, name: str) -> GroundUnitType:
+        if not cls._loaded:
+            cls._load_all()
+        return cls._by_name[name]
+
+    @classmethod
+    def for_dcs_type(cls, dcs_unit_type: Type[VehicleType]) -> Iterator[GroundUnitType]:
+        if not cls._loaded:
+            cls._load_all()
+        yield from cls._by_unit_type[dcs_unit_type]
+
+    @staticmethod
+    def _each_unit_type() -> Iterator[Type[VehicleType]]:
+        yield from vehicle_map.values()
+
+    @classmethod
+    def _load_all(cls) -> None:
+        for unit_type in cls._each_unit_type():
+            for data in cls._each_variant_of(unit_type):
+                cls.register(data)
+        cls._loaded = True
+
+    @classmethod
+    def _each_variant_of(cls, vehicle: Type[VehicleType]) -> Iterator[GroundUnitType]:
+        data_path = Path("resources/units/ground_units") / f"{vehicle.id}.yaml"
+        if not data_path.exists():
+            logging.warning(f"No data for {vehicle.id}; it will not be available")
+            return
+
+        with data_path.open(encoding="utf-8") as data_file:
+            data = yaml.safe_load(data_file)
+
+        try:
+            introduction = data["introduced"]
+            if introduction is None:
+                introduction = "N/A"
+        except KeyError:
+            introduction = "No data."
+
+        class_name = data.get("class")
+        unit_class: Optional[GroundUnitClass] = None
+        if class_name is not None:
+            unit_class = GroundUnitClass(class_name)
+
+        for variant in data.get("variants", [vehicle.id]):
+            yield GroundUnitType(
+                dcs_unit_type=vehicle,
+                unit_class=unit_class,
+                spawn_weight=data.get("spawn_weight", 0),
+                name=variant,
+                description=data.get(
+                    "description",
+                    f"No data. <a href=\"https://google.com/search?q=DCS+{variant.replace(' ', '+')}\"><span style=\"color:#FFFFFF\">Google {variant}</span></a>",
+                ),
+                year_introduced=introduction,
+                country_of_origin=data.get("origin", "No data."),
+                manufacturer=data.get("manufacturer", "No data."),
+                role=data.get("role", "No data."),
+                price=data.get("price", 1),
+            )

game/dcs/unittype.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TypeVar, Generic, Type
+
+from dcs.unittype import UnitType as DcsUnitType
+
+DcsUnitTypeT = TypeVar("DcsUnitTypeT", bound=Type[DcsUnitType])
+
+
+@dataclass(frozen=True)
+class UnitType(Generic[DcsUnitTypeT]):
+    dcs_unit_type: DcsUnitTypeT
+    name: str
+    description: str
+    year_introduced: str
+    country_of_origin: str
+    manufacturer: str
+    role: str
+    price: int
+
+    def __str__(self) -> str:
+        return self.name
+
+    @cached_property
+    def eplrs_capable(self) -> bool:
+        return getattr(self.dcs_unit_type, "eplrs", False)

game/debriefing.py

@@ -14,13 +14,13 @@ from typing import (
     Dict,
     Iterator,
     List,
-    Type,
     TYPE_CHECKING,
+    Union,
 )
 
-from dcs.unittype import FlyingType, UnitType
-
 from game import db
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.groundunittype import GroundUnitType
 from game.theater import Airfield, ControlPoint
 from game.transfers import CargoShip
 from game.unitmap import (
@@ -49,8 +49,8 @@ class AirLosses:
     def losses(self) -> Iterator[FlyingUnit]:
         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)
+    def by_type(self, player: bool) -> Dict[AircraftType, int]:
+        losses_by_type: Dict[AircraftType, int] = defaultdict(int)
         losses = self.player if player else self.enemy
         for loss in losses:
             losses_by_type[loss.flight.unit_type] += 1
@@ -78,8 +78,8 @@ class GroundLosses:
     player_airlifts: List[AirliftUnits] = field(default_factory=list)
     enemy_airlifts: List[AirliftUnits] = field(default_factory=list)
 
-    player_ground_objects: List[GroundObjectUnit] = field(default_factory=list)
-    enemy_ground_objects: List[GroundObjectUnit] = field(default_factory=list)
+    player_ground_objects: List[GroundObjectUnit[Any]] = field(default_factory=list)
+    enemy_ground_objects: List[GroundObjectUnit[Any]] = field(default_factory=list)
 
     player_buildings: List[Building] = field(default_factory=list)
     enemy_buildings: List[Building] = field(default_factory=list)
@@ -105,8 +105,9 @@ class StateData:
     #: 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]
+    #: List of descriptions of destroyed statics. Format of each element is a mapping of
+    #: the coordinate type ("x", "y", "z", "type", "orientation") to the value.
+    destroyed_statics: List[dict[str, Union[float, str]]]
 
     #: Mangled names of bases that were captured during the mission.
     base_capture_events: List[str]
@@ -165,7 +166,7 @@ class Debriefing:
         yield from self.ground_losses.enemy_airlifts
 
     @property
-    def ground_object_losses(self) -> Iterator[GroundObjectUnit]:
+    def ground_object_losses(self) -> Iterator[GroundObjectUnit[Any]]:
         yield from self.ground_losses.player_ground_objects
         yield from self.ground_losses.enemy_ground_objects
 
@@ -182,8 +183,8 @@ class Debriefing:
     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)
+    def front_line_losses_by_type(self, player: bool) -> dict[GroundUnitType, int]:
+        losses_by_type: dict[GroundUnitType, int] = defaultdict(int)
         if player:
             losses = self.ground_losses.player_front_line
         else:
@@ -192,8 +193,8 @@ class Debriefing:
             losses_by_type[loss.unit_type] += 1
         return losses_by_type
 
-    def convoy_losses_by_type(self, player: bool) -> Dict[Type[UnitType], int]:
-        losses_by_type: Dict[Type[UnitType], int] = defaultdict(int)
+    def convoy_losses_by_type(self, player: bool) -> dict[GroundUnitType, int]:
+        losses_by_type: dict[GroundUnitType, int] = defaultdict(int)
         if player:
             losses = self.ground_losses.player_convoy
         else:
@@ -202,8 +203,8 @@ class Debriefing:
             losses_by_type[loss.unit_type] += 1
         return losses_by_type
 
-    def cargo_ship_losses_by_type(self, player: bool) -> Dict[Type[UnitType], int]:
-        losses_by_type: Dict[Type[UnitType], int] = defaultdict(int)
+    def cargo_ship_losses_by_type(self, player: bool) -> dict[GroundUnitType, int]:
+        losses_by_type: dict[GroundUnitType, int] = defaultdict(int)
         if player:
             ships = self.ground_losses.player_cargo_ships
         else:
@@ -213,8 +214,8 @@ class Debriefing:
                 losses_by_type[unit_type] += count
         return losses_by_type
 
-    def airlift_losses_by_type(self, player: bool) -> Dict[Type[UnitType], int]:
-        losses_by_type: Dict[Type[UnitType], int] = defaultdict(int)
+    def airlift_losses_by_type(self, player: bool) -> dict[GroundUnitType, int]:
+        losses_by_type: dict[GroundUnitType, int] = defaultdict(int)
         if player:
             losses = self.ground_losses.player_airlifts
         else:
@@ -371,32 +372,38 @@ class PollDebriefingFileThread(threading.Thread):
         self.game = game
         self.unit_map = unit_map
 
-    def stop(self):
+    def stop(self) -> None:
         self._stop_event.set()
 
-    def stopped(self):
+    def stopped(self) -> bool:
         return self._stop_event.is_set()
 
-    def run(self):
+    def run(self) -> None:
         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
+            try:
+                if (
+                    os.path.isfile("state.json")
+                    and os.path.getmtime("state.json") > last_modified
+                ):
+                    with open("state.json", "r", encoding="utf-8") as json_file:
+                        json_data = json.load(json_file)
+                        debriefing = Debriefing(json_data, self.game, self.unit_map)
+                        self.callback(debriefing)
+                    break
+            except json.JSONDecodeError:
+                logging.exception(
+                    "Failed to decode state.json. Probably attempted read while DCS "
+                    "was still writing the file. Will retry in 5 seconds."
+                )
             time.sleep(5)
 
 
 def wait_for_debriefing(
-    callback: Callable[[Debriefing], None], game: Game, unit_map
+    callback: Callable[[Debriefing], None], game: Game, unit_map: UnitMap
 ) -> PollDebriefingFileThread:
     thread = PollDebriefingFileThread(callback, game, unit_map)
     thread.start()

game/event/airwar.py

@@ -1,14 +1,10 @@
 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):
+    def __str__(self) -> str:
         return "AirWar"

game/event/event.py

@@ -5,7 +5,6 @@ from typing import List, TYPE_CHECKING, Type
 
 from dcs.mapping import Point
 from dcs.task import Task
-from dcs.unittype import VehicleType
 
 from game import persistency
 from game.debriefing import AirLosses, Debriefing
@@ -14,6 +13,7 @@ from game.operation.operation import Operation
 from game.theater import ControlPoint
 from gen import AirTaskingOrder
 from gen.ground_forces.combat_stance import CombatStance
+from ..dcs.groundunittype import GroundUnitType
 from ..unitmap import UnitMap
 
 if TYPE_CHECKING:
@@ -37,13 +37,13 @@ class Event:
 
     def __init__(
         self,
-        game,
+        game: Game,
         from_cp: ControlPoint,
         target_cp: ControlPoint,
         location: Point,
         attacker_name: str,
         defender_name: str,
-    ):
+    ) -> None:
         self.game = game
         self.from_cp = from_cp
         self.to_cp = target_cp
@@ -53,7 +53,7 @@ class Event:
 
     @property
     def is_player_attacking(self) -> bool:
-        return self.attacker_name == self.game.player_name
+        return self.attacker_name == self.game.player_faction.name
 
     @property
     def tasks(self) -> List[Type[Task]]:
@@ -122,7 +122,7 @@ class Event:
 
     def commit_air_losses(self, debriefing: Debriefing) -> None:
         for loss in debriefing.air_losses.losses:
-            if (
+            if loss.pilot is not None and (
                 not loss.pilot.player
                 or not self.game.settings.invulnerable_player_pilots
             ):
@@ -219,10 +219,10 @@ class Event:
         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_losts = []  # type: ignore
 
             loss.group.units.remove(loss.unit)
-            loss.group.units_losts.append(loss.unit)
+            loss.group.units_losts.append(loss.unit)  # type: ignore
 
     def commit_building_losses(self, debriefing: Debriefing) -> None:
         for loss in debriefing.building_losses:
@@ -264,7 +264,7 @@ class Event:
             except Exception:
                 logging.exception(f"Could not process base capture {captured}")
 
-    def commit(self, debriefing: Debriefing):
+    def commit(self, debriefing: Debriefing) -> None:
         logging.info("Committing mission results")
 
         self.commit_air_losses(debriefing)
@@ -297,15 +297,16 @@ class Event:
 
                 delta = 0.0
                 player_won = True
+                status_msg: str = ""
                 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)
+                print(f"Remaining allied units: {ally_units_alive}")
+                print(f"Remaining enemy units: {enemy_units_alive}")
+                print(f"Allied casualties {ally_casualties}")
+                print(f"Enemy casualties {enemy_casualties}")
 
                 ratio = (1.0 + enemy_casualties) / (1.0 + ally_casualties)
 
@@ -318,24 +319,31 @@ class Event:
                 if ally_units_alive == 0:
                     player_won = False
                     delta = STRONG_DEFEAT_INFLUENCE
+                    status_msg = f"No allied units alive at {cp.name}-{enemy_cp.name} frontline.  Allied ground forces suffer a strong defeat."
                 elif enemy_units_alive == 0:
                     player_won = True
                     delta = STRONG_DEFEAT_INFLUENCE
+                    status_msg = f"No enemy units alive at {cp.name}-{enemy_cp.name} frontline.  Allied ground forces win a strong victory."
                 elif cp.stances[enemy_cp.id] == CombatStance.RETREAT:
                     player_won = False
                     delta = STRONG_DEFEAT_INFLUENCE
+                    status_msg = f"Allied forces are retreating along the {cp.name}-{enemy_cp.name} frontline, suffering a strong defeat."
                 else:
                     if enemy_casualties > ally_casualties:
                         player_won = True
                         if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
                             delta = STRONG_DEFEAT_INFLUENCE
+                            status_msg = f"Allied forces break through the {cp.name}-{enemy_cp.name} frontline, winning a strong victory"
                         else:
                             if ratio > 3:
                                 delta = STRONG_DEFEAT_INFLUENCE
+                                status_msg = f"Enemy casualties massively outnumber allied casualties along the {cp.name}-{enemy_cp.name} frontline.  Allied forces win a strong victory."
                             elif ratio < 1.5:
                                 delta = MINOR_DEFEAT_INFLUENCE
+                                status_msg = f"Enemy casualties minorly outnumber allied casualties along the {cp.name}-{enemy_cp.name} frontline.  Allied forces win a minor victory."
                             else:
                                 delta = DEFEAT_INFLUENCE
+                                status_msg = f"Enemy casualties outnumber allied casualties along the {cp.name}-{enemy_cp.name} frontline.  Allied forces claim a victory."
                     elif ally_casualties > enemy_casualties:
 
                         if (
@@ -345,54 +353,66 @@ class Event:
                             # Even with casualties if the enemy is overwhelmed, they are going to lose ground
                             player_won = True
                             delta = MINOR_DEFEAT_INFLUENCE
+                            status_msg = f"Despite suffering losses, allied forces still outnumber enemy forces along the {cp.name}-{enemy_cp.name} frontline.  Due to allied force's aggressive posture, allied forces claim a minor victory."
                         elif (
                             ally_units_alive > 3 * enemy_units_alive
                             and player_aggresive
                         ):
                             player_won = True
                             delta = STRONG_DEFEAT_INFLUENCE
+                            status_msg = f"Despite suffering losses, allied forces still heavily outnumber enemy forces along the {cp.name}-{enemy_cp.name} frontline.  Due to allied force's aggressive posture, allied forces claim a major victory."
                         else:
-                            # But is the enemy is not outnumbered, we lose
+                            # But if the enemy is not outnumbered, we lose
                             player_won = False
                             if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
                                 delta = STRONG_DEFEAT_INFLUENCE
+                                status_msg = f"Allied casualties outnumber enemy casualties along the {cp.name}-{enemy_cp.name} frontline.  Allied forces have overextended themselves, suffering a major defeat."
                             else:
-                                delta = STRONG_DEFEAT_INFLUENCE
+                                delta = DEFEAT_INFLUENCE
+                                status_msg = f"Allied casualties outnumber enemy casualties along the {cp.name}-{enemy_cp.name} frontline.  Allied forces suffer a defeat."
 
                     # 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")
+                        print(
+                            f"Allied forces have adopted a defensive stance along the {cp.name}-{enemy_cp.name} "
+                            f"frontline, making only limited progress."
+                        )
                         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)
+                # Handle the case where there are no casualties at all on either side but both sides still have units
+                if delta == 0.0:
+                    print(status_msg)
                     info = Information(
                         "Frontline Report",
-                        "Our ground forces from "
-                        + cp.name
-                        + " are making progress toward "
-                        + enemy_cp.name,
+                        f"Our ground forces from {cp.name} reached a stalemate with enemy forces from {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)
+                    if player_won:
+                        print(status_msg)
+                        cp.base.affect_strength(delta)
+                        enemy_cp.base.affect_strength(-delta)
+                        info = Information(
+                            "Frontline Report",
+                            f"Our ground forces from {cp.name} are making progress toward {enemy_cp.name}.  {status_msg}",
+                            self.game.turn,
+                        )
+                        self.game.informations.append(info)
+                    else:
+                        print(status_msg)
+                        enemy_cp.base.affect_strength(delta)
+                        cp.base.affect_strength(-delta)
+                        info = Information(
+                            "Frontline Report",
+                            f"Our ground forces from {cp.name} are losing ground against the enemy forces from "
+                            f"{enemy_cp.name}. {status_msg}",
+                            self.game.turn,
+                        )
+                        self.game.informations.append(info)
 
     def redeploy_units(self, cp: ControlPoint) -> None:
         """ "
@@ -434,12 +454,12 @@ class Event:
             moved_units[frontline_unit] = int(count * move_factor)
             total_units_redeployed = total_units_redeployed + int(count * move_factor)
 
-        destination.base.commision_units(moved_units)
+        destination.base.commission_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):
+            if not isinstance(unit_type, GroundUnitType):
                 continue
             if count <= 0:
                 # Don't transfer *sales*...

game/event/frontlineattack.py

@@ -8,5 +8,5 @@ class FrontlineAttackEvent(Event):
     future unique Event handling
     """
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "Frontline attack"

game/factions/faction.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
-from game.data.groundunitclass import GroundUnitClass
 
+import itertools
 import logging
 from dataclasses import dataclass, field
-from typing import Optional, Dict, Type, List, Any, cast
+from typing import Optional, Dict, Type, List, Any, Iterator, TYPE_CHECKING
 
 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 dcs.unittype import ShipType, UnitType
 
 from game.data.building_data import (
     WW2_ALLIES_BUILDINGS,
@@ -23,7 +21,12 @@ from game.data.doctrine import (
     COLDWAR_DOCTRINE,
     WWII_DOCTRINE,
 )
-from pydcs_extensions.mod_units import MODDED_VEHICLES, MODDED_AIRPLANES
+from game.data.groundunitclass import GroundUnitClass
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.groundunittype import GroundUnitType
+
+if TYPE_CHECKING:
+    from game.theater.start_generator import ModSettings
 
 
 @dataclass
@@ -45,25 +48,25 @@ class Faction:
     description: str = field(default="")
 
     # Available aircraft
-    aircrafts: List[Type[FlyingType]] = field(default_factory=list)
+    aircrafts: List[AircraftType] = field(default_factory=list)
 
     # Available awacs aircraft
-    awacs: List[Type[FlyingType]] = field(default_factory=list)
+    awacs: List[AircraftType] = field(default_factory=list)
 
     # Available tanker aircraft
-    tankers: List[Type[FlyingType]] = field(default_factory=list)
+    tankers: List[AircraftType] = field(default_factory=list)
 
     # Available frontline units
-    frontline_units: List[Type[VehicleType]] = field(default_factory=list)
+    frontline_units: List[GroundUnitType] = field(default_factory=list)
 
     # Available artillery units
-    artillery_units: List[Type[VehicleType]] = field(default_factory=list)
+    artillery_units: List[GroundUnitType] = field(default_factory=list)
 
     # Infantry units used
-    infantry_units: List[Type[VehicleType]] = field(default_factory=list)
+    infantry_units: List[GroundUnitType] = field(default_factory=list)
 
     # Logistics units used
-    logistics_units: List[Type[VehicleType]] = field(default_factory=list)
+    logistics_units: List[GroundUnitType] = field(default_factory=list)
 
     # Possible SAMS site generators for this faction
     air_defenses: List[str] = field(default_factory=list)
@@ -81,10 +84,10 @@ class Faction:
     requirements: Dict[str, str] = field(default_factory=dict)
 
     # possible aircraft carrier units
-    aircraft_carrier: List[Type[UnitType]] = field(default_factory=list)
+    aircraft_carrier: List[Type[ShipType]] = field(default_factory=list)
 
     # possible helicopter carrier units
-    helicopter_carrier: List[Type[UnitType]] = field(default_factory=list)
+    helicopter_carrier: List[Type[ShipType]] = field(default_factory=list)
 
     # Possible carrier names
     carrier_names: List[str] = field(default_factory=list)
@@ -114,7 +117,7 @@ class Faction:
     has_jtac: bool = field(default=False)
 
     # Unit to use as JTAC for this faction
-    jtac_unit: Optional[Type[FlyingType]] = field(default=None)
+    jtac_unit: Optional[AircraftType] = field(default=None)
 
     # doctrine
     doctrine: Doctrine = field(default=MODERN_DOCTRINE)
@@ -123,7 +126,7 @@ class 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)
+    liveries_overrides: Dict[AircraftType, 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
@@ -134,15 +137,11 @@ class Faction:
     #: both will use it.
     unrestricted_satnav: bool = False
 
-    def has_access_to_unittype(self, unitclass: GroundUnitClass) -> bool:
-        has_access = False
-        for vehicle in unitclass.unit_list:
-            if vehicle in self.frontline_units:
+    def has_access_to_unittype(self, unit_class: GroundUnitClass) -> bool:
+        for vehicle in itertools.chain(self.frontline_units, self.artillery_units):
+            if vehicle.unit_class is unit_class:
                 return True
-            if vehicle in self.artillery_units:
-                return True
-
-        return has_access
+        return False
 
     @classmethod
     def from_json(cls: Type[Faction], json: Dict[str, Any]) -> Faction:
@@ -163,16 +162,26 @@ class Faction:
         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.aircrafts = [AircraftType.named(n) for n in json.get("aircrafts", [])]
+        faction.awacs = [AircraftType.named(n) for n in json.get("awacs", [])]
+        faction.tankers = [AircraftType.named(n) for n in json.get("tankers", [])]
 
-        faction.aircrafts = list(set(faction.aircrafts + faction.awacs))
+        faction.aircrafts = list(
+            set(faction.aircrafts + faction.awacs + faction.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.frontline_units = [
+            GroundUnitType.named(n) for n in json.get("frontline_units", [])
+        ]
+        faction.artillery_units = [
+            GroundUnitType.named(n) for n in json.get("artillery_units", [])
+        ]
+        faction.infantry_units = [
+            GroundUnitType.named(n) for n in json.get("infantry_units", [])
+        ]
+        faction.logistics_units = [
+            GroundUnitType.named(n) for n in json.get("logistics_units", [])
+        ]
 
         faction.ewrs = json.get("ewrs", [])
 
@@ -196,7 +205,7 @@ class Faction:
         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)
+            faction.jtac_unit = AircraftType.named(jtac_name)
         else:
             faction.jtac_unit = None
         faction.navy_group_count = int(json.get("navy_group_count", 1))
@@ -230,90 +239,113 @@ class Faction:
         # 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]
+        for name, livery in liveries_overrides.items():
+            aircraft = AircraftType.named(name)
+            faction.liveries_overrides[aircraft] = [s.lower() for s in livery]
 
         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 ground_units(self) -> Iterator[GroundUnitType]:
+        yield from self.artillery_units
+        yield from self.frontline_units
+        yield from self.logistics_units
 
+    def infantry_with_class(
+        self, unit_class: GroundUnitClass
+    ) -> Iterator[GroundUnitType]:
+        for unit in self.infantry_units:
+            if unit.unit_class is unit_class:
+                yield unit
 
-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 apply_mod_settings(self, mod_settings: ModSettings) -> Faction:
+        # aircraft
+        if not mod_settings.a4_skyhawk:
+            self.remove_aircraft("A-4E-C")
+        if not mod_settings.hercules:
+            self.remove_aircraft("Hercules")
+        if not mod_settings.f22_raptor:
+            self.remove_aircraft("F-22A")
+        if not mod_settings.jas39_gripen:
+            self.remove_aircraft("JAS39Gripen")
+            self.remove_aircraft("JAS39Gripen_AG")
+        if not mod_settings.su57_felon:
+            self.remove_aircraft("Su-57")
+        # frenchpack
+        if not mod_settings.frenchpack:
+            self.remove_vehicle("AMX10RCR")
+            self.remove_vehicle("SEPAR")
+            self.remove_vehicle("ERC")
+            self.remove_vehicle("M120")
+            self.remove_vehicle("AA20")
+            self.remove_vehicle("TRM2000")
+            self.remove_vehicle("TRM2000_Citerne")
+            self.remove_vehicle("TRM2000_AA20")
+            self.remove_vehicle("TRMMISTRAL")
+            self.remove_vehicle("VABH")
+            self.remove_vehicle("VAB_RADIO")
+            self.remove_vehicle("VAB_50")
+            self.remove_vehicle("VIB_VBR")
+            self.remove_vehicle("VAB_HOT")
+            self.remove_vehicle("VAB_MORTIER")
+            self.remove_vehicle("VBL50")
+            self.remove_vehicle("VBLANF1")
+            self.remove_vehicle("VBL-radio")
+            self.remove_vehicle("VBAE")
+            self.remove_vehicle("VBAE_MMP")
+            self.remove_vehicle("AMX-30B2")
+            self.remove_vehicle("Tracma")
+            self.remove_vehicle("JTACFP")
+            self.remove_vehicle("SHERIDAN")
+            self.remove_vehicle("Leclerc_XXI")
+            self.remove_vehicle("Toyota_bleu")
+            self.remove_vehicle("Toyota_vert")
+            self.remove_vehicle("Toyota_desert")
+            self.remove_vehicle("Kamikaze")
+            self.remove_vehicle("AMX1375")
+            self.remove_vehicle("AMX1390")
+            self.remove_vehicle("VBCI")
+            self.remove_vehicle("T62")
+            self.remove_vehicle("T64BV")
+            self.remove_vehicle("T72M")
+            self.remove_vehicle("KORNET")
+        # high digit sams
+        if not mod_settings.high_digit_sams:
+            self.remove_air_defenses("SA10BGenerator")
+            self.remove_air_defenses("SA12Generator")
+            self.remove_air_defenses("SA20Generator")
+            self.remove_air_defenses("SA20BGenerator")
+            self.remove_air_defenses("SA23Generator")
+            self.remove_air_defenses("SA17Generator")
+            self.remove_air_defenses("KS19Generator")
+        return self
 
+    def remove_aircraft(self, name: str) -> None:
+        for i in self.aircrafts:
+            if i.dcs_unit_type.id == name:
+                self.aircrafts.remove(i)
 
-def load_aircraft(name: str) -> Optional[Type[FlyingType]]:
-    return cast(
-        Optional[FlyingType],
-        unit_loader(name, [dcs.planes, dcs.helicopters, MODDED_AIRPLANES]),
-    )
+    def remove_air_defenses(self, name: str) -> None:
+        for i in self.air_defenses:
+            if i == name:
+                self.air_defenses.remove(i)
 
-
-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 remove_vehicle(self, name: str) -> None:
+        for i in self.frontline_units:
+            if i.dcs_unit_type.id == name:
+                self.frontline_units.remove(i)
 
 
 def load_ship(name: str) -> Optional[Type[ShipType]]:
-    return cast(Optional[FlyingType], unit_loader(name, [dcs.ships]))
+    if (ship := getattr(dcs.ships, name, None)) is not None:
+        return ship
+    logging.error(f"FACTION ERROR : Unable to find {name} in dcs.ships")
+    return None
 
 
-def load_all_ships(data) -> List[Type[ShipType]]:
+def load_all_ships(data: list[str]) -> List[Type[ShipType]]:
     items = []
     for name in data:
         item = load_ship(name)

game/game.py

@@ -1,10 +1,11 @@
 import itertools
 import logging
+import math
 import random
 import sys
 from datetime import date, datetime, timedelta
 from enum import Enum
-from typing import Any, Dict, List, Iterator
+from typing import Any, List, Type, Union, cast
 
 from dcs.action import Coalition
 from dcs.mapping import Point
@@ -12,11 +13,10 @@ from dcs.task import CAP, CAS, PinpointStrike
 from dcs.vehicles import AirDefence
 from faker import Faker
 
-from game import db
 from game.inventory import GlobalAircraftInventory
 from game.models.game_stats import GameStats
 from game.plugins import LuaPluginManager
-from game.theater.theatergroundobject import MissileSiteGroundObject
+from gen import naming
 from gen.ato import AirTaskingOrder
 from gen.conflictgen import Conflict
 from gen.flights.ai_flight_planner import CoalitionMissionPlanner
@@ -34,8 +34,8 @@ from .navmesh import NavMesh
 from .procurement import AircraftProcurementRequest, ProcurementAi
 from .profiling import logged_duration
 from .settings import Settings, AutoAtoBehavior
-from .squadrons import Pilot, AirWing
-from .theater import ConflictTheater
+from .squadrons import AirWing
+from .theater import ConflictTheater, ControlPoint
 from .theater.bullseye import Bullseye
 from .theater.transitnetwork import TransitNetwork, TransitNetworkBuilder
 from .threatzones import ThreatZones
@@ -86,8 +86,8 @@ class TurnState(Enum):
 class Game:
     def __init__(
         self,
-        player_name: str,
-        enemy_name: str,
+        player_faction: Faction,
+        enemy_faction: Faction,
         theater: ConflictTheater,
         start_date: datetime,
         settings: Settings,
@@ -97,28 +97,29 @@ class Game:
         self.settings = settings
         self.events: List[Event] = []
         self.theater = theater
-        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.player_faction = player_faction
+        self.player_country = player_faction.country
+        self.enemy_faction = enemy_faction
+        self.enemy_country = enemy_faction.country
         # pass_turn() will be called when initialization is complete which will
         # increment this to turn 0 before it reaches the player.
         self.turn = -1
         # 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.notes = ""
+        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] = []
-        self.__destroyed_units: List[str] = []
+        self.__destroyed_units: list[dict[str, Union[float, str]]] = []
         self.savepath = ""
         self.budget = player_budget
         self.enemy_budget = enemy_budget
         self.current_unit_id = 0
         self.current_group_id = 0
+        self.name_generator = naming.namegen
 
         self.conditions = self.generate_conditions()
 
@@ -148,7 +149,7 @@ class Game:
 
         self.on_load(game_still_initializing=True)
 
-    def __getstate__(self) -> Dict[str, Any]:
+    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.
@@ -160,7 +161,7 @@ class Game:
         del state["red_faker"]
         return state
 
-    def __setstate__(self, state: Dict[str, Any]) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         self.__dict__.update(state)
         # Regenerate any state that was not persisted.
         self.on_load()
@@ -187,7 +188,7 @@ class Game:
             self.theater, self.current_day, self.current_turn_time_of_day, self.settings
         )
 
-    def sanitize_sides(self):
+    def sanitize_sides(self) -> None:
         """
         Make sure the opposing factions are using different countries
         :return:
@@ -200,14 +201,6 @@ class Game:
             else:
                 self.enemy_country = "Russia"
 
-    @property
-    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
@@ -233,26 +226,21 @@ class Game:
             return self.blue_bullseye
         return self.red_bullseye
 
-    def _roll(self, prob, mult):
-        if self.settings.version == "dev":
-            # always generate all events for dev
-            return 100
-        else:
-            return random.randint(1, 100) <= prob * mult
-
-    def _generate_player_event(self, event_class, player_cp, enemy_cp):
+    def _generate_player_event(
+        self, event_class: Type[Event], player_cp: ControlPoint, enemy_cp: ControlPoint
+    ) -> None:
         self.events.append(
             event_class(
                 self,
                 player_cp,
                 enemy_cp,
                 enemy_cp.position,
-                self.player_name,
-                self.enemy_name,
+                self.player_faction.name,
+                self.enemy_faction.name,
             )
         )
 
-    def _generate_events(self):
+    def _generate_events(self) -> None:
         for front_line in self.theater.conflicts():
             self._generate_player_event(
                 FrontlineAttackEvent,
@@ -266,21 +254,22 @@ class Game:
         else:
             self.enemy_budget += amount
 
-    def process_player_income(self):
+    def process_player_income(self) -> None:
         self.budget += Income(self, player=True).total
 
-    def process_enemy_income(self):
+    def process_enemy_income(self) -> None:
         # TODO: Clean up save compat.
         if not hasattr(self, "enemy_budget"):
             self.enemy_budget = 0
         self.enemy_budget += Income(self, player=False).total
 
-    def initiate_event(self, event: Event) -> UnitMap:
+    @staticmethod
+    def initiate_event(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):
+    def finish_event(self, event: Event, debriefing: Debriefing) -> None:
         logging.info("Finishing event {}".format(event))
         event.commit(debriefing)
 
@@ -289,17 +278,15 @@ class Game:
         else:
             logging.info("finish_event: event not in the events!")
 
-    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 on_load(self, game_still_initializing: bool = False) -> None:
+        if not hasattr(self, "name_generator"):
+            self.name_generator = naming.namegen
+        # Hack: Replace the global name generator state with the state from the save
+        # game.
+        #
+        # We need to persist this state so that names generated after game load don't
+        # conflict with those generated before exit.
+        naming.namegen = self.name_generator
         LuaPluginManager.load_settings(self.settings)
         ObjectiveDistanceCache.set_theater(self.theater)
         self.compute_conflicts_position()
@@ -313,6 +300,33 @@ class Game:
         self.red_ato.clear()
 
     def finish_turn(self, skipped: bool = False) -> None:
+        """Finalizes the current turn and advances to the next turn.
+
+        This handles the turn-end portion of passing a turn. Initialization of the next
+        turn is handled by `initialize_turn`. These are separate processes because while
+        turns may be initialized more than once under some circumstances (see the
+        documentation for `initialize_turn`), `finish_turn` performs the work that
+        should be guaranteed to happen only once per turn:
+
+        * Turn counter increment.
+        * Delivering units ordered the previous turn.
+        * Transfer progress.
+        * Squadron replenishment.
+        * Income distribution.
+        * Base strength (front line position) adjustment.
+        * Weather/time-of-day generation.
+
+        Some actions (like transit network assembly) will happen both here and in
+        `initialize_turn`. We need the network to be up to date so we can account for
+        base captures when processing the transfers that occurred last turn, but we also
+        need it to be up to date in the case of a re-initialization in `initialize_turn`
+        (such as to account for a cheat base capture) so that orders are only placed
+        where a supply route exists to the destination. This is a relatively cheap
+        operation so duplicating the effort is not a problem.
+
+        Args:
+            skipped: True if the turn was skipped.
+        """
         self.informations.append(
             Information("End of turn #" + str(self.turn), "-" * 40, 0)
         )
@@ -327,15 +341,18 @@ class Game:
         # one hop ahead. ControlPoint.process_turn handles unit deliveries.
         self.transfers.perform_transfers()
 
-        # Needs to happen *before* planning transfers so we don't cancel the
+        # Needs to happen *before* planning transfers so we don't cancel them.
         self.reset_ato()
         for control_point in self.theater.controlpoints:
             control_point.process_turn(self)
 
-        if not skipped and self.turn > 1:
+        self.blue_air_wing.replenish()
+        self.red_air_wing.replenish()
+
+        if not skipped:
             for cp in self.theater.player_points():
                 cp.base.affect_strength(+PLAYER_BASE_STRENGTH_RECOVERY)
-        else:
+        elif self.turn > 1:
             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)
@@ -346,10 +363,18 @@ class Game:
         self.process_player_income()
 
     def begin_turn_0(self) -> None:
+        """Initialization for the first turn of the game."""
         self.turn = 0
         self.initialize_turn()
 
     def pass_turn(self, no_action: bool = False) -> None:
+        """Ends the current turn and initializes the new turn.
+
+        Called both when skipping a turn or by ending the turn as the result of combat.
+
+        Args:
+            no_action: True if the turn was skipped.
+        """
         logging.info("Pass turn")
         with logged_duration("Turn finalization"):
             self.finish_turn(no_action)
@@ -359,7 +384,7 @@ class Game:
         # Autosave progress
         persistency.autosave(self)
 
-    def check_win_loss(self):
+    def check_win_loss(self) -> TurnState:
         player_airbases = {
             cp for cp in self.theater.player_points() if cp.runway_is_operational()
         }
@@ -379,26 +404,90 @@ class Game:
         self.blue_bullseye = Bullseye(enemy_cp.position)
         self.red_bullseye = Bullseye(player_cp.position)
 
-    def initialize_turn(self) -> None:
+    def initialize_turn(self, for_red: bool = True, for_blue: bool = True) -> None:
+        """Performs turn initialization for the specified players.
+
+        Turn initialization performs all of the beginning-of-turn actions. *End-of-turn*
+        processing happens in `pass_turn` (despite the name, it's called both for
+        skipping the turn and ending the turn after combat).
+
+        Special care needs to be taken here because initialization can occur more than
+        once per turn. A number of events can require re-initializing a turn:
+
+        * Cheat capture. Bases changing hands invalidates many missions in both ATOs,
+          purchase orders, threat zones, transit networks, etc. Practically speaking,
+          after a base capture the turn needs to be treated as fully new. The game might
+          even be over after a capture.
+        * Cheat front line position. CAS missions are no longer in the correct location,
+          and the ground planner may also need changes.
+        * Selling/buying units at TGOs. Selling a TGO might leave missions in the ATO
+          with invalid targets. Buying a new SAM (or even replacing some units in a SAM)
+          potentially changes the threat zone and may alter mission priorities and
+          flight planning.
+
+        Most of the work is delegated to initialize_turn_for, which handles the
+        coalition-specific turn initialization. In some cases only one coalition will be
+        (re-) initialized. This is the case when buying or selling TGO units, since we
+        don't want to force the player to redo all their planning just because they
+        repaired a SAM, but should replan opfor when that happens. On the other hand,
+        base captures are significant enough (and likely enough to be the first thing
+        the player does in a turn) that we replan blue as well. Front lines are less
+        impactful but also likely to be early, so they also cause a blue replan.
+
+        Args:
+            for_red: True if opfor should be re-initialized.
+            for_blue: True if the player coalition should be re-initialized.
+        """
         self.events = []
         self._generate_events()
-
         self.set_bullseye()
 
         # Update statistics
         self.game_stats.update(self)
 
-        self.blue_air_wing.reset()
-        self.red_air_wing.reset()
-        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 Coalition specific turn
+        if for_red:
+            self.initialize_turn_for(player=False)
+        if for_blue:
+            self.initialize_turn_for(player=True)
+
+        # Plan GroundWar
+        for cp in self.theater.controlpoints:
+            if cp.has_frontline:
+                gplanner = GroundPlanner(cp, self)
+                gplanner.plan_groundwar()
+                self.ground_planners[cp.id] = gplanner
+
+    def initialize_turn_for(self, player: bool) -> None:
+        """Processes coalition-specific turn initialization.
+
+        For more information on turn initialization in general, see the documentation
+        for `Game.initialize_turn`.
+
+        Args:
+            player: True if the player coalition is being initialized. False for opfor
+            initialization.
+        """
+        self.ato_for(player).clear()
+        self.air_wing_for(player).reset()
+
+        self.aircraft_inventory.reset()
+        for cp in self.theater.controlpoints:
+            self.aircraft_inventory.set_from_control_point(cp)
+            # Refund all pending deliveries for opfor and if player
+            # has automate_aircraft_reinforcements
+            if (not player and not cp.captured) or (
+                player
+                and cp.captured
+                and self.settings.automate_aircraft_reinforcements
+            ):
+                cp.pending_unit_deliveries.refund_all(self)
+
         # Plan flights & combat for next turn
         with logged_duration("Computing conflict positions"):
             self.compute_conflicts_position()
@@ -408,55 +497,48 @@ class Game:
             self.compute_transit_networks()
         self.ground_planners = {}
 
-        self.blue_procurement_requests.clear()
-        self.red_procurement_requests.clear()
+        self.procurement_requests_for(player).clear()
 
         with logged_duration("Procurement of airlift assets"):
             self.transfers.order_airlift_assets()
         with logged_duration("Transport planning"):
             self.transfers.plan_transports()
 
-        with logged_duration("Blue mission planning"):
-            if self.settings.auto_ato_behavior is not AutoAtoBehavior.Disabled:
-                blue_planner = CoalitionMissionPlanner(self, is_player=True)
-                blue_planner.plan_missions()
+        if not player or (
+            player and self.settings.auto_ato_behavior is not AutoAtoBehavior.Disabled
+        ):
+            color = "Blue" if player else "Red"
+            with logged_duration(f"{color} mission planning"):
+                mission_planner = CoalitionMissionPlanner(self, player)
+                mission_planner.plan_missions()
 
-        with logged_duration("Red mission planning"):
-            red_planner = CoalitionMissionPlanner(self, is_player=False)
-            red_planner.plan_missions()
+        self.plan_procurement_for(player)
 
-        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()
-
-    def plan_procurement(self) -> None:
+    def plan_procurement_for(self, for_player: bool) -> 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. After that the budget will be spend proportionally based on how much is already invested
 
-        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,
-        ).spend_budget(self.budget)
-
-        self.enemy_budget = ProcurementAi(
-            self,
-            for_player=False,
-            faction=self.enemy_faction,
-            manage_runways=True,
-            manage_front_line=True,
-            manage_aircraft=True,
-        ).spend_budget(self.enemy_budget)
+        if for_player:
+            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,
+            ).spend_budget(self.budget)
+        else:
+            self.enemy_budget = ProcurementAi(
+                self,
+                for_player=False,
+                faction=self.enemy_faction,
+                manage_runways=True,
+                manage_front_line=True,
+                manage_aircraft=True,
+            ).spend_budget(self.enemy_budget)
 
     def message(self, text: str) -> None:
         self.informations.append(Information(text, turn=self.turn))
@@ -469,14 +551,14 @@ class Game:
     def current_day(self) -> date:
         return self.date + timedelta(days=self.turn // 4)
 
-    def next_unit_id(self):
+    def next_unit_id(self) -> int:
         """
         Next unit id for pre-generated units
         """
         self.current_unit_id += 1
         return self.current_unit_id
 
-    def next_group_id(self):
+    def next_group_id(self) -> int:
         """
         Next unit id for pre-generated units
         """
@@ -510,7 +592,7 @@ class Game:
             return self.blue_navmesh
         return self.red_navmesh
 
-    def compute_conflicts_position(self):
+    def compute_conflicts_position(self) -> None:
         """
         Compute the current conflict center position(s), mainly used for culling calculation
         :return: List of points of interests
@@ -533,7 +615,7 @@ class Game:
         # 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
+            min_distance = math.inf
             for cp in self.theater.player_points():
                 for cp2 in self.theater.enemy_points():
                     d = cp.position.distance_to_point(cp2.position)
@@ -569,15 +651,15 @@ class Game:
 
         self.__culling_zones = zones
 
-    def add_destroyed_units(self, data):
-        pos = Point(data["x"], data["z"])
+    def add_destroyed_units(self, data: dict[str, Union[float, str]]) -> None:
+        pos = Point(cast(float, data["x"]), cast(float, data["z"]))
         if self.theater.is_on_land(pos):
             self.__destroyed_units.append(data)
 
-    def get_destroyed_units(self):
+    def get_destroyed_units(self) -> list[dict[str, Union[float, str]]]:
         return self.__destroyed_units
 
-    def position_culled(self, pos):
+    def position_culled(self, pos: Point) -> bool:
         """
         Check if unit can be generated at given position depending on culling performance settings
         :param pos: Position you are tryng to spawn stuff at
@@ -590,7 +672,7 @@ class Game:
                 return False
         return True
 
-    def get_culling_zones(self):
+    def get_culling_zones(self) -> list[Point]:
         """
         Check culling points
         :return: List of culling zones
@@ -598,30 +680,28 @@ class Game:
         return self.__culling_zones
 
     # 1 = red, 2 = blue
-    def get_player_coalition_id(self):
+    def get_player_coalition_id(self) -> int:
         return 2
 
-    def get_enemy_coalition_id(self):
+    def get_enemy_coalition_id(self) -> int:
         return 1
 
-    def get_player_coalition(self):
+    def get_player_coalition(self) -> Coalition:
         return Coalition.Blue
 
-    def get_enemy_coalition(self):
+    def get_enemy_coalition(self) -> Coalition:
         return Coalition.Red
 
-    def get_player_color(self):
+    def get_player_color(self) -> str:
         return "blue"
 
-    def get_enemy_color(self):
+    def get_enemy_color(self) -> str:
         return "red"
 
-    def process_win_loss(self, turn_state: TurnState):
+    def process_win_loss(self, turn_state: TurnState) -> None:
         if turn_state is TurnState.WIN:
-            return self.message(
-                "Congratulations, you are victorious!  Start a new campaign to continue."
+            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."
-            )
+            self.message("Game Over, you lose. Start a new campaign to continue.")

game/infos/information.py

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

game/inventory.py

@@ -6,6 +6,7 @@ from typing import Dict, Iterable, Iterator, Set, Tuple, TYPE_CHECKING, Type
 
 from dcs.unittype import FlyingType
 
+from game.dcs.aircrafttype import AircraftType
 from gen.flights.flight import Flight
 
 if TYPE_CHECKING:
@@ -17,9 +18,9 @@ class ControlPointAircraftInventory:
 
     def __init__(self, control_point: ControlPoint) -> None:
         self.control_point = control_point
-        self.inventory: Dict[Type[FlyingType], int] = defaultdict(int)
+        self.inventory: Dict[AircraftType, int] = defaultdict(int)
 
-    def add_aircraft(self, aircraft: Type[FlyingType], count: int) -> None:
+    def add_aircraft(self, aircraft: AircraftType, count: int) -> None:
         """Adds aircraft to the inventory.
 
         Args:
@@ -28,7 +29,7 @@ class ControlPointAircraftInventory:
         """
         self.inventory[aircraft] += count
 
-    def remove_aircraft(self, aircraft: Type[FlyingType], count: int) -> None:
+    def remove_aircraft(self, aircraft: AircraftType, count: int) -> None:
         """Removes aircraft from the inventory.
 
         Args:
@@ -42,12 +43,12 @@ class ControlPointAircraftInventory:
         available = self.inventory[aircraft]
         if available < count:
             raise ValueError(
-                f"Cannot remove {count} {aircraft.id} from "
+                f"Cannot remove {count} {aircraft} from "
                 f"{self.control_point.name}. Only have {available}."
             )
         self.inventory[aircraft] -= count
 
-    def available(self, aircraft: Type[FlyingType]) -> int:
+    def available(self, aircraft: AircraftType) -> int:
         """Returns the number of available aircraft of the given type.
 
         Args:
@@ -59,14 +60,14 @@ class ControlPointAircraftInventory:
             return 0
 
     @property
-    def types_available(self) -> Iterator[Type[FlyingType]]:
+    def types_available(self) -> Iterator[AircraftType]:
         """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]]:
+    def all_aircraft(self) -> Iterator[Tuple[AircraftType, int]]:
         """Iterates over all available aircraft types, including amounts."""
         for aircraft, count in self.inventory.items():
             if count > 0:
@@ -107,9 +108,9 @@ class GlobalAircraftInventory:
         return self.inventories[control_point]
 
     @property
-    def available_types_for_player(self) -> Iterator[Type[FlyingType]]:
+    def available_types_for_player(self) -> Iterator[AircraftType]:
         """Iterates over all aircraft types available to the player."""
-        seen: Set[Type[FlyingType]] = set()
+        seen: Set[AircraftType] = set()
         for control_point, inventory in self.inventories.items():
             if control_point.captured:
                 for aircraft in inventory.types_available:

game/models/destroyed_units.py

@@ -1,13 +0,0 @@
-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/game_stats.py

@@ -1,4 +1,9 @@
-from typing import List
+from __future__ import annotations
+
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from game import Game
 
 
 class FactionTurnMetadata:
@@ -10,7 +15,7 @@ class FactionTurnMetadata:
     vehicles_count: int = 0
     sam_count: int = 0
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.aircraft_count = 0
         self.vehicles_count = 0
         self.sam_count = 0
@@ -24,7 +29,7 @@ class GameTurnMetadata:
     allied_units: FactionTurnMetadata
     enemy_units: FactionTurnMetadata
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.allied_units = FactionTurnMetadata()
         self.enemy_units = FactionTurnMetadata()
 
@@ -34,15 +39,19 @@ class GameStats:
     Store statistics for the current game
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.data_per_turn: List[GameTurnMetadata] = []
 
-    def update(self, game):
+    def update(self, game: Game) -> None:
         """
         Save data for current turn
         :param game: Game we want to save the data about
         """
 
+        # Remove the current turn if its just an update for this turn
+        if 0 < game.turn < len(self.data_per_turn):
+            del self.data_per_turn[-1]
+
         turn_data = GameTurnMetadata()
 
         for cp in game.theater.controlpoints:

game/operation/operation.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import os
 from pathlib import Path
-from typing import Iterable, List, Set, TYPE_CHECKING
+from typing import Iterable, List, Set, TYPE_CHECKING, cast
 
 from dcs import Mission
 from dcs.action import DoScript, DoScriptFile
@@ -17,7 +17,7 @@ from dcs.triggers import TriggerStart
 from game.plugins import LuaPluginManager
 from game.theater.theatergroundobject import TheaterGroundObject
 from gen import Conflict, FlightType, VisualGenerator
-from gen.aircraft import AIRCRAFT_DATA, AircraftConflictGenerator, FlightData
+from gen.aircraft import AircraftConflictGenerator, FlightData
 from gen.airfields import AIRFIELD_DATA
 from gen.airsupportgen import AirSupport, AirSupportConflictGenerator
 from gen.armor import GroundConflictGenerator, JtacInfo
@@ -62,28 +62,14 @@ class Operation:
     plugin_scripts: List[str] = []
 
     @classmethod
-    def prepare(cls, game: Game):
-        with open("resources/default_options.lua", "r") as f:
+    def prepare(cls, game: Game) -> None:
+        with open("resources/default_options.lua", "r", encoding="utf-8") 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)
 
-    @classmethod
-    def conflicts(cls) -> Iterable[Conflict]:
-        assert cls.game
-        for frontline in cls.game.theater.conflicts():
-            yield Conflict(
-                cls.game.theater,
-                frontline,
-                cls.game.player_name,
-                cls.game.enemy_name,
-                cls.game.player_country,
-                cls.game.enemy_country,
-                frontline.position,
-            )
-
     @classmethod
     def air_conflict(cls) -> Conflict:
         assert cls.game
@@ -95,10 +81,10 @@ class Operation:
         return Conflict(
             cls.game.theater,
             FrontLine(player_cp, enemy_cp),
-            cls.game.player_name,
-            cls.game.enemy_name,
-            cls.game.player_country,
-            cls.game.enemy_country,
+            cls.game.player_faction.name,
+            cls.game.enemy_faction.name,
+            cls.current_mission.country(cls.game.player_country),
+            cls.current_mission.country(cls.game.enemy_country),
             mid_point,
         )
 
@@ -107,7 +93,7 @@ class Operation:
         cls.current_mission = mission
 
     @classmethod
-    def _setup_mission_coalitions(cls):
+    def _setup_mission_coalitions(cls) -> None:
         cls.current_mission.coalition["blue"] = Coalition(
             "blue", bullseye=cls.game.blue_bullseye.to_pydcs()
         )
@@ -163,7 +149,7 @@ class Operation:
         airsupportgen: AirSupportConflictGenerator,
         jtacs: List[JtacInfo],
         airgen: AircraftConflictGenerator,
-    ):
+    ) -> None:
         """Generates subscribed MissionInfoGenerator objects (currently kneeboards and briefings)"""
 
         gens: List[MissionInfoGenerator] = [
@@ -215,23 +201,7 @@ class Operation:
         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
-            )
+            flight.aircraft_type.assign_channels_for_flight(flight, air_support)
 
     @classmethod
     def _create_tacan_registry(
@@ -267,7 +237,7 @@ class Operation:
                 # beacon list.
 
     @classmethod
-    def _generate_ground_units(cls):
+    def _generate_ground_units(cls) -> None:
         cls.groundobjectgen = GroundObjectsGenerator(
             cls.current_mission,
             cls.game,
@@ -282,11 +252,16 @@ class Operation:
         """Add destroyed units to the Mission"""
         for d in cls.game.get_destroyed_units():
             try:
-                utype = db.unit_type_from_name(d["type"])
+                type_name = d["type"]
+                if not isinstance(type_name, str):
+                    raise TypeError(
+                        "Expected the type of the destroyed static to be a string"
+                    )
+                utype = db.unit_type_from_name(type_name)
             except KeyError:
                 continue
 
-            pos = Point(d["x"], d["z"])
+            pos = Point(cast(float, d["x"]), cast(float, d["z"]))
             if (
                 utype is not None
                 and not cls.game.position_culled(pos)
@@ -375,6 +350,7 @@ class Operation:
             cls.game.settings,
             cls.game,
             cls.radio_registry,
+            cls.tacan_registry,
             cls.unit_map,
             air_support=cls.airsupportgen.air_support,
         )
@@ -399,12 +375,13 @@ class Operation:
     @classmethod
     def _generate_ground_conflicts(cls) -> None:
         """For each frontline in the Operation, generate the ground conflicts and JTACs"""
+        cls.jtacs = []
         for front_line in cls.game.theater.conflicts():
             player_cp = front_line.blue_cp
             enemy_cp = front_line.red_cp
             conflict = Conflict.frontline_cas_conflict(
-                cls.game.player_name,
-                cls.game.enemy_name,
+                cls.game.player_faction.name,
+                cls.game.enemy_faction.name,
                 cls.current_mission.country(cls.game.player_country),
                 cls.current_mission.country(cls.game.enemy_country),
                 front_line,
@@ -432,7 +409,7 @@ class Operation:
         CargoShipGenerator(cls.current_mission, cls.game, cls.unit_map).generate()
 
     @classmethod
-    def reset_naming_ids(cls):
+    def reset_naming_ids(cls) -> None:
         namegen.reset_numbers()
 
     @classmethod
@@ -453,8 +430,8 @@ class Operation:
             "BlueAA": {},
         }  # type: ignore
 
-        for tanker in airsupportgen.air_support.tankers:
-            luaData["Tankers"][tanker.callsign] = {
+        for i, tanker in enumerate(airsupportgen.air_support.tankers):
+            luaData["Tankers"][i] = {
                 "dcsGroupName": tanker.group_name,
                 "callsign": tanker.callsign,
                 "variant": tanker.variant,
@@ -462,23 +439,22 @@ class Operation:
                 "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.group_name,
-                    "callsign": awacs.callsign,
-                    "radio": awacs.freq.mhz,
-                }
+        for i, awacs in enumerate(airsupportgen.air_support.awacs):
+            luaData["AWACs"][i] = {
+                "dcsGroupName": awacs.group_name,
+                "callsign": awacs.callsign,
+                "radio": awacs.freq.mhz,
+            }
 
-        for jtac in jtacs:
-            luaData["JTACs"][jtac.callsign] = {
+        for i, jtac in enumerate(jtacs):
+            luaData["JTACs"][i] = {
                 "dcsGroupName": jtac.group_name,
                 "callsign": jtac.callsign,
                 "zone": jtac.region,
                 "dcsUnit": jtac.unit_name,
                 "laserCode": jtac.code,
             }
-
+        flight_count = 0
         for flight in airgen.flights:
             if flight.friendly and flight.flight_type in [
                 FlightType.ANTISHIP,
@@ -499,7 +475,7 @@ class Operation:
                     elif hasattr(flightTarget, "name"):
                         flightTargetName = flightTarget.name
                         flightTargetType = flightType + " TGT (Airbase)"
-                    luaData["TargetPoints"][flightTargetName] = {
+                    luaData["TargetPoints"][flight_count] = {
                         "name": flightTargetName,
                         "type": flightTargetType,
                         "position": {
@@ -507,6 +483,7 @@ class Operation:
                             "y": flightTarget.position.y,
                         },
                     }
+                    flight_count += 1
 
         for cp in cls.game.theater.controlpoints:
             for ground_object in cp.ground_objects:
@@ -592,8 +569,7 @@ class Operation:
             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 += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', zone={repr(zone)}, laserCode='{laserCode}', dcsUnit='{dcsUnit}' }}, \n"
         lua += "}"
 
         # Process the Target Points

game/persistency.py

@@ -1,17 +1,23 @@
+from __future__ import annotations
+
 import logging
 import os
 import pickle
 import shutil
-from typing import Optional
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from game import Game
 
 _dcs_saved_game_folder: Optional[str] = None
-_file_abs_path = None
 
 
-def setup(user_folder: str):
+def setup(user_folder: str) -> None:
     global _dcs_saved_game_folder
     _dcs_saved_game_folder = user_folder
-    _file_abs_path = os.path.join(base_path(), "default.liberation")
+    if not save_dir().exists():
+        save_dir().mkdir(parents=True)
 
 
 def base_path() -> str:
@@ -20,19 +26,23 @@ def base_path() -> str:
     return _dcs_saved_game_folder
 
 
+def save_dir() -> Path:
+    return Path(base_path()) / "Liberation" / "Saves"
+
+
 def _temporary_save_file() -> str:
-    return os.path.join(base_path(), "tmpsave.liberation")
+    return str(save_dir() / "tmpsave.liberation")
 
 
 def _autosave_path() -> str:
-    return os.path.join(base_path(), "autosave.liberation")
+    return str(save_dir() / "autosave.liberation")
 
 
 def mission_path_for(name: str) -> str:
-    return os.path.join(base_path(), "Missions", "{}".format(name))
+    return os.path.join(base_path(), "Missions", name)
 
 
-def load_game(path):
+def load_game(path: str) -> Optional[Game]:
     with open(path, "rb") as f:
         try:
             save = pickle.load(f)
@@ -43,7 +53,7 @@ def load_game(path):
             return None
 
 
-def save_game(game) -> bool:
+def save_game(game: Game) -> bool:
     try:
         with open(_temporary_save_file(), "wb") as f:
             pickle.dump(game, f)
@@ -54,7 +64,7 @@ def save_game(game) -> bool:
         return False
 
 
-def autosave(game) -> bool:
+def autosave(game: Game) -> bool:
     """
     Autosave to the autosave location
     :param game: Game to save

game/plugins/luaplugin.py

@@ -38,7 +38,7 @@ class PluginSettings:
         self.settings = Settings()
         self.initialize_settings()
 
-    def set_settings(self, settings: Settings):
+    def set_settings(self, settings: Settings) -> None:
         self.settings = settings
         self.initialize_settings()
 
@@ -146,7 +146,7 @@ class LuaPlugin(PluginSettings):
 
         return cls(definition)
 
-    def set_settings(self, settings: Settings):
+    def set_settings(self, settings: Settings) -> None:
         super().set_settings(settings)
         for option in self.definition.options:
             option.set_settings(self.settings)

game/point_with_heading.py

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

game/positioned.py

@@ -0,0 +1,9 @@
+from typing import Protocol
+
+from dcs import Point
+
+
+class Positioned(Protocol):
+    @property
+    def position(self) -> Point:
+        raise NotImplementedError

game/procurement.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 import math
 import random
 from dataclasses import dataclass
-from typing import Iterator, List, Optional, TYPE_CHECKING, Tuple, Type
-
-from dcs.unittype import FlyingType, VehicleType
+from typing import Iterator, List, Optional, TYPE_CHECKING, Tuple
 
 from game import db
 from game.data.groundunitclass import GroundUnitClass
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.groundunittype import GroundUnitType
 from game.factions.faction import Faction
 from game.theater import ControlPoint, MissionTarget
 from game.utils import Distance
@@ -59,6 +59,18 @@ class ProcurementAi:
     def calculate_ground_unit_budget_share(self) -> float:
         armor_investment = 0
         aircraft_investment = 0
+
+        # faction has no ground units
+        if (
+            len(self.faction.artillery_units) == 0
+            and len(self.faction.frontline_units) == 0
+        ):
+            return 0
+
+        # faction has no planes
+        if len(self.faction.aircrafts) == 0:
+            return 1
+
         for cp in self.owned_points:
             cp_ground_units = cp.allocated_ground_units(self.game.transfers)
             armor_investment += cp_ground_units.total_value
@@ -113,7 +125,7 @@ class ProcurementAi:
                 if available % 2 == 0:
                     continue
                 inventory.remove_aircraft(aircraft, 1)
-                total += db.PRICES[aircraft]
+                total += aircraft.price
         return total
 
     def repair_runways(self, budget: float) -> float:
@@ -135,12 +147,17 @@ class ProcurementAi:
 
     def affordable_ground_unit_of_class(
         self, budget: float, unit_class: GroundUnitClass
-    ) -> Optional[Type[VehicleType]]:
+    ) -> Optional[GroundUnitType]:
         faction_units = set(self.faction.frontline_units) | set(
             self.faction.artillery_units
         )
-        of_class = set(unit_class.unit_list) & faction_units
-        affordable_units = [u for u in of_class if db.PRICES[u] <= budget]
+        of_class = {u for u in faction_units if u.unit_class is unit_class}
+
+        # faction has no access to needed unit type, take a random unit
+        if not of_class:
+            of_class = faction_units
+
+        affordable_units = [u for u in of_class if u.price <= budget]
         if not affordable_units:
             return None
         return random.choice(affordable_units)
@@ -162,7 +179,7 @@ class ProcurementAi:
                 # Can't afford any more units.
                 break
 
-            budget -= db.PRICES[unit]
+            budget -= unit.price
             cp.pending_unit_deliveries.order({unit: 1})
 
         return budget
@@ -198,12 +215,12 @@ class ProcurementAi:
         airbase: ControlPoint,
         number: int,
         max_price: float,
-    ) -> Optional[Type[FlyingType]]:
-        best_choice: Optional[Type[FlyingType]] = None
+    ) -> Optional[AircraftType]:
+        best_choice: Optional[AircraftType] = None
         for unit in aircraft_for_task(task):
             if unit not in self.faction.aircrafts:
                 continue
-            if db.PRICES[unit] * number > max_price:
+            if unit.price * number > max_price:
                 continue
             if not airbase.can_operate(unit):
                 continue
@@ -224,7 +241,7 @@ class ProcurementAi:
 
     def affordable_aircraft_for(
         self, request: AircraftProcurementRequest, airbase: ControlPoint, budget: float
-    ) -> Optional[Type[FlyingType]]:
+    ) -> Optional[AircraftType]:
         return self._affordable_aircraft_for_task(
             request.task_capability, airbase, request.number, budget
         )
@@ -242,7 +259,7 @@ class ProcurementAi:
                 # able to operate expensive aircraft.
                 continue
 
-            budget -= db.PRICES[unit] * request.number
+            budget -= unit.price * request.number
             airbase.pending_unit_deliveries.order({unit: request.number})
             return budget, True
         return budget, False
@@ -343,9 +360,9 @@ class ProcurementAi:
         class_cost = 0
         total_cost = 0
         for unit_type, count in allocations.all.items():
-            cost = db.PRICES[unit_type] * count
+            cost = unit_type.price * count
             total_cost += cost
-            if unit_type in unit_class:
+            if unit_type.unit_class is unit_class:
                 class_cost += cost
         if not total_cost:
             return 0

game/profiling.py

@@ -5,7 +5,8 @@ import timeit
 from collections import defaultdict
 from contextlib import contextmanager
 from datetime import timedelta
-from typing import Iterator
+from types import TracebackType
+from typing import Iterator, Optional, Type
 
 
 @contextmanager
@@ -23,7 +24,12 @@ class MultiEventTracer:
     def __enter__(self) -> MultiEventTracer:
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
         for event, duration in self.events.items():
             logging.debug("%s took %s", event, duration)
 

game/radio/channels.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from gen import FlightData, AirSupport
+
+
+class RadioChannelAllocator:
+    """Base class for radio channel allocators."""
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        """Assigns mission frequencies to preset channels for the flight."""
+        raise NotImplementedError
+
+    @classmethod
+    def from_cfg(cls, cfg: dict[str, Any]) -> RadioChannelAllocator:
+        return cls()
+
+    @classmethod
+    def name(cls) -> str:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class CommonRadioChannelAllocator(RadioChannelAllocator):
+    """Radio channel allocator suitable for most aircraft.
+
+    Most of the aircraft with preset channels available have one or more radios
+    with 20 or more channels available (typically per-radio, but this is not the
+    case for the JF-17).
+    """
+
+    #: Index of the radio used for intra-flight communications. Matches the
+    #: index of the panel_radio field of the pydcs.dcs.planes object.
+    inter_flight_radio_index: Optional[int]
+
+    #: Index of the radio used for intra-flight communications. Matches the
+    #: index of the panel_radio field of the pydcs.dcs.planes object.
+    intra_flight_radio_index: Optional[int]
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        if self.intra_flight_radio_index is not None:
+            flight.assign_channel(
+                self.intra_flight_radio_index, 1, flight.intra_flight_channel
+            )
+
+        if self.inter_flight_radio_index is None:
+            return
+
+        # For cases where the inter-flight and intra-flight radios share presets
+        # (the JF-17 only has one set of channels, even though it can use two
+        # channels simultaneously), start assigning inter-flight channels at 2.
+        radio_id = self.inter_flight_radio_index
+        if self.intra_flight_radio_index == radio_id:
+            first_channel = 2
+        else:
+            first_channel = 1
+
+        last_channel = flight.num_radio_channels(radio_id)
+        channel_alloc = iter(range(first_channel, last_channel + 1))
+
+        if flight.departure.atc is not None:
+            flight.assign_channel(radio_id, next(channel_alloc), flight.departure.atc)
+
+        # TODO: If there ever are multiple AWACS, limit to mission relevant.
+        for awacs in air_support.awacs:
+            flight.assign_channel(radio_id, next(channel_alloc), awacs.freq)
+
+        if flight.arrival != flight.departure and flight.arrival.atc is not None:
+            flight.assign_channel(radio_id, next(channel_alloc), flight.arrival.atc)
+
+        try:
+            # TODO: Skip incompatible tankers.
+            for tanker in air_support.tankers:
+                flight.assign_channel(radio_id, next(channel_alloc), tanker.freq)
+
+            if flight.divert is not None and flight.divert.atc is not None:
+                flight.assign_channel(radio_id, next(channel_alloc), flight.divert.atc)
+        except StopIteration:
+            # Any remaining channels are nice-to-haves, but not necessary for
+            # the few aircraft with a small number of channels available.
+            pass
+
+    @classmethod
+    def from_cfg(cls, cfg: dict[str, Any]) -> CommonRadioChannelAllocator:
+        return CommonRadioChannelAllocator(
+            inter_flight_radio_index=cfg["inter_flight_radio_index"],
+            intra_flight_radio_index=cfg["intra_flight_radio_index"],
+        )
+
+    @classmethod
+    def name(cls) -> str:
+        return "common"
+
+
+@dataclass(frozen=True)
+class NoOpChannelAllocator(RadioChannelAllocator):
+    """Channel allocator for aircraft that don't support preset channels."""
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        pass
+
+    @classmethod
+    def name(cls) -> str:
+        return "noop"
+
+
+@dataclass(frozen=True)
+class FarmerRadioChannelAllocator(RadioChannelAllocator):
+    """Preset channel allocator for the MiG-19P."""
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        # The Farmer only has 6 preset channels. It also only has a VHF radio,
+        # and currently our ATC data and AWACS are only in the UHF band.
+        radio_id = 1
+        flight.assign_channel(radio_id, 1, flight.intra_flight_channel)
+        # TODO: Assign 4-6 to VHF frequencies of departure, arrival, and divert.
+        # TODO: Assign 2 and 3 to AWACS if it is VHF.
+
+    @classmethod
+    def name(cls) -> str:
+        return "farmer"
+
+
+@dataclass(frozen=True)
+class ViggenRadioChannelAllocator(RadioChannelAllocator):
+    """Preset channel allocator for the AJS37."""
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        # The Viggen's preset channels are handled differently from other
+        # aircraft. The aircraft automatically configures channels for every
+        # allied flight in the game (including AWACS) and for every airfield. As
+        # such, we don't need to allocate any of those. There are seven presets
+        # we can modify, however: three channels for the main radio intended for
+        # communication with wingmen, and four emergency channels for the backup
+        # radio. We'll set the first channel of the main radio to the
+        # intra-flight channel, and the first three emergency channels to each
+        # of the flight plan's airfields. The fourth emergency channel is always
+        # the guard channel.
+        radio_id = 1
+        flight.assign_channel(radio_id, 1, flight.intra_flight_channel)
+        if flight.departure.atc is not None:
+            flight.assign_channel(radio_id, 4, flight.departure.atc)
+        if flight.arrival.atc is not None:
+            flight.assign_channel(radio_id, 5, flight.arrival.atc)
+        # TODO: Assign divert to 6 when we support divert airfields.
+
+    @classmethod
+    def name(cls) -> str:
+        return "viggen"
+
+
+@dataclass(frozen=True)
+class SCR522RadioChannelAllocator(RadioChannelAllocator):
+    """Preset channel allocator for the SCR522 WW2 radios. (4 channels)"""
+
+    def assign_channels_for_flight(
+        self, flight: FlightData, air_support: AirSupport
+    ) -> None:
+        radio_id = 1
+        flight.assign_channel(radio_id, 1, flight.intra_flight_channel)
+        if flight.departure.atc is not None:
+            flight.assign_channel(radio_id, 2, flight.departure.atc)
+        if flight.arrival.atc is not None:
+            flight.assign_channel(radio_id, 3, flight.arrival.atc)
+
+        # TODO : Some GCI on Channel 4 ?
+
+    @classmethod
+    def name(cls) -> str:
+        return "SCR-522"
+
+
+class ChannelNamer:
+    """Base class allowing channel name customization per-aircraft.
+
+    Most aircraft will want to customize this behavior, but the default is
+    reasonable for any aircraft with numbered radios.
+    """
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        """Returns the name of the channel for the given radio and channel."""
+        return f"COMM{radio_id} Ch {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "default"
+
+
+class SingleRadioChannelNamer(ChannelNamer):
+    """Channel namer for the aircraft with only a single radio.
+
+    Aircraft like the MiG-19P and the MiG-21bis only have a single radio, so
+    it's not necessary for us to name the radio when naming the channel.
+    """
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        return f"Ch {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "single"
+
+
+class HueyChannelNamer(ChannelNamer):
+    """Channel namer for the UH-1H."""
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        return f"COM3 Ch {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "huey"
+
+
+class MirageChannelNamer(ChannelNamer):
+    """Channel namer for the M-2000."""
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        radio_name = ["V/UHF", "UHF"][radio_id - 1]
+        return f"{radio_name} Ch {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "mirage"
+
+
+class TomcatChannelNamer(ChannelNamer):
+    """Channel namer for the F-14."""
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        radio_name = ["UHF", "VHF/UHF"][radio_id - 1]
+        return f"{radio_name} Ch {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "tomcat"
+
+
+class ViggenChannelNamer(ChannelNamer):
+    """Channel namer for the AJS37."""
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        if channel_id >= 4:
+            channel_letter = "EFGH"[channel_id - 4]
+            return f"FR 24 {channel_letter}"
+        return f"FR 22 Special {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "viggen"
+
+
+class ViperChannelNamer(ChannelNamer):
+    """Channel namer for the F-16."""
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        return f"COM{radio_id} Ch {channel_id}"
+
+    @classmethod
+    def name(cls) -> str:
+        return "viper"
+
+
+class SCR522ChannelNamer(ChannelNamer):
+    """
+    Channel namer for P-51 & P-47D
+    """
+
+    @staticmethod
+    def channel_name(radio_id: int, channel_id: int) -> str:
+        if channel_id > 3:
+            return "?"
+        else:
+            return f"Button " + "ABCD"[channel_id - 1]
+
+    @classmethod
+    def name(cls) -> str:
+        return "SCR-522"

game/savecompat.py

@@ -0,0 +1,48 @@
+"""Tools for aiding in save compat removal after compatibility breaks."""
+from collections import Callable
+from typing import TypeVar
+
+from game.version import MAJOR_VERSION
+
+ReturnT = TypeVar("ReturnT")
+
+
+class DeprecatedSaveCompatError(RuntimeError):
+    def __init__(self, function_name: str) -> None:
+        super().__init__(
+            f"{function_name} has save compat code for a different major version."
+        )
+
+
+def has_save_compat_for(
+    major: int,
+) -> Callable[[Callable[..., ReturnT]], Callable[..., ReturnT]]:
+    """Declares a function or method as having save compat code for a given version.
+
+    If the function has save compatibility for the current major version, there is no
+    change in behavior.
+
+    If the function has save compatibility for a *different* (future or past) major
+    version, DeprecatedSaveCompatError will be raised during startup. Since a break in
+    save compatibility is the definition of a major version break, there's no need to
+    keep around old save compat code; it only serves to mask initialization bugs.
+
+    Args:
+        major: The major version for which the decorated function has save
+        compatibility.
+
+    Returns:
+        The decorated function or method.
+
+    Raises:
+        DeprecatedSaveCompatError: The decorated function has save compat code for
+        another version of liberation, and that code (and the decorator declaring it)
+        should be removed from this branch.
+    """
+
+    def decorator(func: Callable[..., ReturnT]) -> Callable[..., ReturnT]:
+        if major != MAJOR_VERSION:
+            raise DeprecatedSaveCompatError(func.__name__)
+        return func
+
+    return decorator

game/settings.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from datetime import timedelta
 from enum import Enum, unique
-from typing import Dict, Optional
+from typing import Dict, Optional, Any
 
 from dcs.forcedoptions import ForcedOptions
 
@@ -20,6 +20,7 @@ class Settings:
     # Difficulty settings
     player_skill: str = "Good"
     enemy_skill: str = "Average"
+    ai_pilot_levelling: bool = True
     enemy_vehicle_skill: str = "Average"
     map_coalition_visibility: ForcedOptions.Views = ForcedOptions.Views.All
     labels: str = "Full"
@@ -33,6 +34,18 @@ class Settings:
     player_income_multiplier: float = 1.0
     enemy_income_multiplier: float = 1.0
 
+    #: Feature flag for squadron limits.
+    enable_squadron_pilot_limits: bool = False
+
+    #: The maximum number of pilots a squadron can have at one time. Changing this after
+    #: the campaign has started will have no immediate effect; pilots already in the
+    #: squadron will not be removed if the limit is lowered and pilots will not be
+    #: immediately created if the limit is raised.
+    squadron_pilot_limit: int = 12
+
+    #: The number of pilots a squadron can replace per turn.
+    squadron_replenishment_rate: int = 4
+
     default_start_type: str = "Cold"
 
     # Mission specific
@@ -44,6 +57,7 @@ class Settings:
     automate_aircraft_reinforcements: bool = False
     restrict_weapons_by_date: bool = False
     disable_legacy_aewc: bool = True
+    disable_legacy_tanker: bool = True
     generate_dark_kneeboard: bool = False
     invulnerable_player_pilots: bool = True
     auto_ato_behavior: AutoAtoBehavior = AutoAtoBehavior.Default
@@ -90,7 +104,7 @@ class Settings:
     def set_plugin_option(self, identifier: str, enabled: bool) -> None:
         self.plugins[self.plugin_settings_key(identifier)] = enabled
 
-    def __setstate__(self, state) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> 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

game/squadrons.py

@@ -8,19 +8,18 @@ from dataclasses import dataclass, field
 from enum import unique, Enum
 from pathlib import Path
 from typing import (
-    Type,
     Tuple,
     TYPE_CHECKING,
     Optional,
     Iterator,
     Sequence,
+    Any,
 )
 
 import yaml
-from dcs.unittype import FlyingType
 from faker import Faker
 
-from game.db import flying_type_from_name
+from game.dcs.aircrafttype import AircraftType
 from game.settings import AutoAtoBehavior
 
 if TYPE_CHECKING:
@@ -76,14 +75,23 @@ class Pilot:
 @dataclass
 class Squadron:
     name: str
-    nickname: str
+    nickname: Optional[str]
     country: str
     role: str
-    aircraft: Type[FlyingType]
+    aircraft: AircraftType
     livery: Optional[str]
     mission_types: tuple[FlightType, ...]
-    pilots: list[Pilot]
-    available_pilots: list[Pilot] = field(init=False, hash=False, compare=False)
+
+    #: The pool of pilots that have not yet been assigned to the squadron. This only
+    #: happens when a preset squadron defines more preset pilots than the squadron limit
+    #: allows. This pool will be consumed before random pilots are generated.
+    pilot_pool: list[Pilot]
+
+    current_roster: list[Pilot] = field(default_factory=list, init=False, hash=False)
+    available_pilots: list[Pilot] = field(
+        default_factory=list, init=False, hash=False, compare=False
+    )
+
     auto_assignable_mission_types: set[FlightType] = field(
         init=False, hash=False, compare=False
     )
@@ -95,18 +103,29 @@ class Squadron:
     player: bool
 
     def __post_init__(self) -> None:
-        self.available_pilots = list(self.active_pilots)
+        if any(p.status is not PilotStatus.Active for p in self.pilot_pool):
+            raise ValueError("Squadrons can only be created with active pilots.")
+        self._recruit_pilots(self.game.settings.squadron_pilot_limit)
         self.auto_assignable_mission_types = set(self.mission_types)
 
     def __str__(self) -> str:
+        if self.nickname is None:
+            return self.name
         return f'{self.name} "{self.nickname}"'
 
+    @property
+    def pilot_limits_enabled(self) -> bool:
+        return self.game.settings.enable_squadron_pilot_limits
+
+    def claim_new_pilot_if_allowed(self) -> Optional[Pilot]:
+        if self.pilot_limits_enabled:
+            return None
+        self._recruit_pilots(1)
+        return self.available_pilots.pop()
+
     def claim_available_pilot(self) -> Optional[Pilot]:
-        # No pilots available, so the preference is irrelevant. Create a new pilot and
-        # return it.
         if not self.available_pilots:
-            self.enlist_new_pilots(1)
-            return self.available_pilots.pop()
+            return self.claim_new_pilot_if_allowed()
 
         # For opfor, so player/AI option is irrelevant.
         if not self.player:
@@ -127,11 +146,12 @@ class Squadron:
         # No pilot was found that matched the user's preference.
         #
         # If they chose to *never* assign players and only players remain in the pool,
-        # we cannot fill the slot with the available pilots. Recruit a new one.
+        # we cannot fill the slot with the available pilots.
         #
-        # If they prefer players and we're out of players, just return an AI pilot.
+        # If they only *prefer* players and we're out of players, just return an AI
+        # pilot.
         if not prefer_players:
-            self.enlist_new_pilots(1)
+            return self.claim_new_pilot_if_allowed()
         return self.available_pilots.pop()
 
     def claim_pilot(self, pilot: Pilot) -> None:
@@ -151,23 +171,48 @@ class Squadron:
         # repopulating the same size flight from the same squadron.
         self.available_pilots.extend(reversed(pilots))
 
-    def enlist_new_pilots(self, count: int) -> None:
-        new_pilots = [Pilot(self.faker.name()) for _ in range(count)]
-        self.pilots.extend(new_pilots)
+    def _recruit_pilots(self, count: int) -> None:
+        new_pilots = self.pilot_pool[:count]
+        self.pilot_pool = self.pilot_pool[count:]
+        count -= len(new_pilots)
+        new_pilots.extend([Pilot(self.faker.name()) for _ in range(count)])
+        self.current_roster.extend(new_pilots)
         self.available_pilots.extend(new_pilots)
 
+    def replenish_lost_pilots(self) -> None:
+        if not self.pilot_limits_enabled:
+            return
+
+        replenish_count = min(
+            self.game.settings.squadron_replenishment_rate,
+            self._number_of_unfilled_pilot_slots,
+        )
+        if replenish_count > 0:
+            self._recruit_pilots(replenish_count)
+
     def return_all_pilots(self) -> None:
         self.available_pilots = list(self.active_pilots)
 
+    @staticmethod
+    def send_on_leave(pilot: Pilot) -> None:
+        pilot.send_on_leave()
+
+    def return_from_leave(self, pilot: Pilot) -> None:
+        if not self.has_unfilled_pilot_slots:
+            raise RuntimeError(
+                f"Cannot return {pilot} from leave because {self} is full"
+            )
+        pilot.return_from_leave()
+
     @property
     def faker(self) -> Faker:
         return self.game.faker_for(self.player)
 
     def _pilots_with_status(self, status: PilotStatus) -> list[Pilot]:
-        return [p for p in self.pilots if p.status == status]
+        return [p for p in self.current_roster if p.status == status]
 
     def _pilots_without_status(self, status: PilotStatus) -> list[Pilot]:
-        return [p for p in self.pilots if p.status != status]
+        return [p for p in self.current_roster if p.status != status]
 
     @property
     def active_pilots(self) -> list[Pilot]:
@@ -178,27 +223,47 @@ class Squadron:
         return self._pilots_with_status(PilotStatus.OnLeave)
 
     @property
-    def number_of_pilots_including_dead(self) -> int:
-        return len(self.pilots)
+    def number_of_pilots_including_inactive(self) -> int:
+        return len(self.current_roster)
 
     @property
-    def number_of_living_pilots(self) -> int:
-        return len(self._pilots_without_status(PilotStatus.Dead))
+    def _number_of_unfilled_pilot_slots(self) -> int:
+        return self.game.settings.squadron_pilot_limit - len(self.active_pilots)
+
+    @property
+    def number_of_available_pilots(self) -> int:
+        return len(self.available_pilots)
+
+    def can_provide_pilots(self, count: int) -> bool:
+        return not self.pilot_limits_enabled or self.number_of_available_pilots >= count
+
+    @property
+    def has_available_pilots(self) -> bool:
+        return not self.pilot_limits_enabled or bool(self.available_pilots)
+
+    @property
+    def has_unfilled_pilot_slots(self) -> bool:
+        return not self.pilot_limits_enabled or self._number_of_unfilled_pilot_slots > 0
+
+    def can_auto_assign(self, task: FlightType) -> bool:
+        return task in self.auto_assignable_mission_types
 
     def pilot_at_index(self, index: int) -> Pilot:
-        return self.pilots[index]
+        return self.current_roster[index]
 
     @classmethod
     def from_yaml(cls, path: Path, game: Game, player: bool) -> Squadron:
         from gen.flights.ai_flight_planner_db import tasks_for_aircraft
         from gen.flights.flight import FlightType
 
-        with path.open() as squadron_file:
+        with path.open(encoding="utf8") as squadron_file:
             data = yaml.safe_load(squadron_file)
 
-        unit_type = flying_type_from_name(data["aircraft"])
-        if unit_type is None:
-            raise KeyError(f"Could not find any aircraft with the ID {unit_type}")
+        name = data["aircraft"]
+        try:
+            unit_type = AircraftType.named(name)
+        except KeyError as ex:
+            raise KeyError(f"Could not find any aircraft named {name}") from ex
 
         pilots = [Pilot(n, player=False) for n in data.get("pilots", [])]
         pilots.extend([Pilot(n, player=True) for n in data.get("players", [])])
@@ -215,18 +280,18 @@ class Squadron:
 
         return Squadron(
             name=data["name"],
-            nickname=data["nickname"],
+            nickname=data.get("nickname"),
             country=data["country"],
             role=data["role"],
             aircraft=unit_type,
             livery=data.get("livery"),
             mission_types=tuple(mission_types),
-            pilots=pilots,
+            pilot_pool=pilots,
             game=game,
             player=player,
         )
 
-    def __setstate__(self, state) -> None:
+    def __setstate__(self, state: dict[str, Any]) -> None:
         # TODO: Remove save compat.
         if "auto_assignable_mission_types" not in state:
             state["auto_assignable_mission_types"] = set(state["mission_types"])
@@ -245,8 +310,8 @@ class SquadronLoader:
         yield Path(persistency.base_path()) / "Liberation/Squadrons"
         yield Path("resources/squadrons")
 
-    def load(self) -> dict[Type[FlyingType], list[Squadron]]:
-        squadrons: dict[Type[FlyingType], list[Squadron]] = defaultdict(list)
+    def load(self) -> dict[AircraftType, list[Squadron]]:
+        squadrons: dict[AircraftType, list[Squadron]] = defaultdict(list)
         country = self.game.country_for(self.player)
         faction = self.game.faction_for(self.player)
         any_country = country.startswith("Combined Joint Task Forces ")
@@ -311,21 +376,35 @@ class AirWing:
                     aircraft=aircraft,
                     livery=None,
                     mission_types=tuple(tasks_for_aircraft(aircraft)),
-                    pilots=[],
+                    pilot_pool=[],
                     game=game,
                     player=player,
                 )
             ]
 
-    def squadrons_for(self, aircraft: Type[FlyingType]) -> Sequence[Squadron]:
+    def squadrons_for(self, aircraft: AircraftType) -> Sequence[Squadron]:
         return self.squadrons[aircraft]
 
-    def squadrons_for_task(self, task: FlightType) -> Iterator[Squadron]:
+    def can_auto_plan(self, task: FlightType) -> bool:
+        try:
+            next(self.auto_assignable_for_task(task))
+            return True
+        except StopIteration:
+            return False
+
+    def auto_assignable_for_task(self, task: FlightType) -> Iterator[Squadron]:
         for squadron in self.iter_squadrons():
-            if task in squadron.mission_types:
+            if squadron.can_auto_assign(task):
                 yield squadron
 
-    def squadron_for(self, aircraft: Type[FlyingType]) -> Squadron:
+    def auto_assignable_for_task_with_type(
+        self, aircraft: AircraftType, task: FlightType
+    ) -> Iterator[Squadron]:
+        for squadron in self.squadrons_for(aircraft):
+            if squadron.can_auto_assign(task) and squadron.has_available_pilots:
+                yield squadron
+
+    def squadron_for(self, aircraft: AircraftType) -> Squadron:
         return self.squadrons_for(aircraft)[0]
 
     def iter_squadrons(self) -> Iterator[Squadron]:
@@ -334,6 +413,10 @@ class AirWing:
     def squadron_at_index(self, index: int) -> Squadron:
         return list(self.iter_squadrons())[index]
 
+    def replenish(self) -> None:
+        for squadron in self.iter_squadrons():
+            squadron.replenish_lost_pilots()
+
     def reset(self) -> None:
         for squadron in self.iter_squadrons():
             squadron.return_all_pilots()

game/theater/base.py

@@ -1,33 +1,20 @@
 import itertools
 import logging
-import math
-import typing
-from typing import Dict, Type
+from typing import Any
 
-from dcs.task import AWACS, CAP, CAS, Embarking, PinpointStrike, Task, Transport
-from dcs.unittype import FlyingType, UnitType, VehicleType
-from dcs.vehicles import AirDefence, Armor
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.groundunittype import GroundUnitType
+from game.dcs.unittype import UnitType
 
-from game import db
-from game.db import PRICES
-
-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
+BASE_MAX_STRENGTH = 1.0
+BASE_MIN_STRENGTH = 0.0
 
 
 class Base:
-    def __init__(self):
-        self.aircraft: Dict[Type[FlyingType], int] = {}
-        self.armor: Dict[Type[VehicleType], int] = {}
-        # TODO: Appears unused.
-        self.aa: Dict[AirDefence, int] = {}
-        self.commision_points: Dict[Type, float] = {}
-        self.strength = 1
+    def __init__(self) -> None:
+        self.aircraft: dict[AircraftType, int] = {}
+        self.armor: dict[GroundUnitType, int] = {}
+        self.strength = 1.0
 
     @property
     def total_aircraft(self) -> int:
@@ -41,147 +28,54 @@ class Base:
     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}")
+            total += unit_type.price * count
         return total
 
-    @property
-    def total_aa(self) -> int:
-        return sum(self.aa.values())
-
-    def total_units(self, task: Task) -> int:
+    def total_units_of_type(self, unit_type: UnitType[Any]) -> 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()
-                )
+                for t, c in itertools.chain(self.aircraft.items(), self.armor.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]):
-
+    def commission_units(self, units: dict[Any, int]) -> None:
         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
-                or for_task == Transport
-            ):
+            target_dict: dict[Any, int]
+            if isinstance(unit_type, AircraftType):
                 target_dict = self.aircraft
-            elif for_task == PinpointStrike:
+            elif isinstance(unit_type, GroundUnitType):
                 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))
+                logging.error(f"Unexpected unit type of {unit_type}")
+                return
 
-    def commit_losses(self, units_lost: typing.Dict[typing.Any, int]):
+            target_dict[unit_type] = target_dict.get(unit_type, 0) + unit_count
 
+    def commit_losses(self, units_lost: dict[Any, int]) -> None:
         for unit_type, count in units_lost.items():
-
+            target_dict: dict[Any, int]
             if unit_type in self.aircraft:
-                target_array = self.aircraft
+                target_dict = self.aircraft
             elif unit_type in self.armor:
-                target_array = self.armor
+                target_dict = self.armor
             else:
                 print("Base didn't find event type {}".format(unit_type))
                 continue
 
-            if unit_type not in target_array:
+            if unit_type not in target_dict:
                 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]
+            target_dict[unit_type] = max(target_dict[unit_type] - count, 0)
+            if target_dict[unit_type] == 0:
+                del target_dict[unit_type]
 
-    def affect_strength(self, amount):
+    def affect_strength(self, amount: float) -> None:
         self.strength += amount
         if self.strength > BASE_MAX_STRENGTH:
             self.strength = BASE_MAX_STRENGTH
@@ -190,55 +84,3 @@ class Base:
 
     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/conflicttheater.py

@@ -5,7 +5,7 @@ import math
 from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path
-from typing import Any, Dict, Iterator, List, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Tuple, TYPE_CHECKING
 
 from dcs import Mission
 from dcs.countries import (
@@ -16,10 +16,10 @@ from dcs.country import Country
 from dcs.mapping import Point
 from dcs.planes import F_15C
 from dcs.ships import (
-    Bulker_Handy_Wind,
-    CVN_74_John_C__Stennis,
-    DDG_Arleigh_Burke_IIa,
-    LHA_1_Tarawa,
+    HandyWind,
+    Stennis,
+    USS_Arleigh_Burke_IIa,
+    LHA_Tarawa,
 )
 from dcs.statics import Fortification, Warehouse
 from dcs.terrain import (
@@ -29,14 +29,14 @@ from dcs.terrain import (
     persiangulf,
     syria,
     thechannel,
+    marianaislands,
 )
 from dcs.terrain.terrain import Airport, Terrain
 from dcs.unitgroup import (
-    FlyingGroup,
-    Group,
     ShipGroup,
     StaticGroup,
     VehicleGroup,
+    PlaneGroup,
 )
 from dcs.vehicles import AirDefence, Armor, MissilesSS, Unarmed
 from pyproj import CRS, Transformer
@@ -56,10 +56,14 @@ from .landmap import Landmap, load_landmap, poly_contains
 from .latlon import LatLon
 from .projections import TransverseMercator
 from ..point_with_heading import PointWithHeading
+from ..positioned import Positioned
 from ..profiling import logged_duration
 from ..scenery_group import SceneryGroup
 from ..utils import Distance, meters
 
+if TYPE_CHECKING:
+    from . import TheaterGroundObject
+
 SIZE_TINY = 150
 SIZE_SMALL = 600
 SIZE_REGULAR = 1000
@@ -77,53 +81,53 @@ class MizCampaignLoader:
 
     OFF_MAP_UNIT_TYPE = F_15C.id
 
-    CV_UNIT_TYPE = CVN_74_John_C__Stennis.id
-    LHA_UNIT_TYPE = LHA_1_Tarawa.id
-    FRONT_LINE_UNIT_TYPE = Armor.APC_M113.id
-    SHIPPING_LANE_UNIT_TYPE = Bulker_Handy_Wind.id
+    CV_UNIT_TYPE = Stennis.id
+    LHA_UNIT_TYPE = LHA_Tarawa.id
+    FRONT_LINE_UNIT_TYPE = Armor.M_113.id
+    SHIPPING_LANE_UNIT_TYPE = HandyWind.id
 
-    FOB_UNIT_TYPE = Unarmed.Truck_SKP_11_Mobile_ATC.id
+    FOB_UNIT_TYPE = Unarmed.SKP_11.id
     FARP_HELIPAD = "SINGLE_HELIPAD"
 
     OFFSHORE_STRIKE_TARGET_UNIT_TYPE = Fortification.Oil_platform.id
-    SHIP_UNIT_TYPE = DDG_Arleigh_Burke_IIa.id
-    MISSILE_SITE_UNIT_TYPE = MissilesSS.SSM_SS_1C_Scud_B.id
-    COASTAL_DEFENSE_UNIT_TYPE = MissilesSS.AShM_SS_N_2_Silkworm.id
+    SHIP_UNIT_TYPE = USS_Arleigh_Burke_IIa.id
+    MISSILE_SITE_UNIT_TYPE = MissilesSS.Scud_B.id
+    COASTAL_DEFENSE_UNIT_TYPE = MissilesSS.Hy_launcher.id
 
     # Multiple options for air defenses so campaign designers can more accurately see
     # the coverage of their IADS for the expected type.
     LONG_RANGE_SAM_UNIT_TYPES = {
-        AirDefence.SAM_Patriot_LN.id,
-        AirDefence.SAM_SA_10_S_300_Grumble_TEL_C.id,
-        AirDefence.SAM_SA_10_S_300_Grumble_TEL_D.id,
+        AirDefence.Patriot_ln.id,
+        AirDefence.S_300PS_5P85C_ln.id,
+        AirDefence.S_300PS_5P85D_ln.id,
     }
 
     MEDIUM_RANGE_SAM_UNIT_TYPES = {
-        AirDefence.SAM_Hawk_LN_M192.id,
-        AirDefence.SAM_SA_2_S_75_Guideline_LN.id,
-        AirDefence.SAM_SA_3_S_125_Goa_LN.id,
+        AirDefence.Hawk_ln.id,
+        AirDefence.S_75M_Volhov.id,
+        AirDefence._5p73_s_125_ln.id,
     }
 
     SHORT_RANGE_SAM_UNIT_TYPES = {
-        AirDefence.SAM_Avenger__Stinger.id,
-        AirDefence.SAM_Rapier_LN.id,
-        AirDefence.SAM_SA_19_Tunguska_Grison.id,
-        AirDefence.SAM_SA_9_Strela_1_Gaskin_TEL.id,
+        AirDefence.M1097_Avenger.id,
+        AirDefence.Rapier_fsa_launcher.id,
+        AirDefence._2S6_Tunguska.id,
+        AirDefence.Strela_1_9P31.id,
     }
 
     AAA_UNIT_TYPES = {
-        AirDefence.AAA_8_8cm_Flak_18.id,
-        AirDefence.SPAAA_Vulcan_M163.id,
-        AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish.id,
+        AirDefence.Flak18.id,
+        AirDefence.Vulcan.id,
+        AirDefence.ZSU_23_4_Shilka.id,
     }
 
-    EWR_UNIT_TYPE = AirDefence.EWR_1L13.id
+    EWR_UNIT_TYPE = AirDefence._1L13_EWR.id
 
-    ARMOR_GROUP_UNIT_TYPE = Armor.MBT_M1A2_Abrams.id
+    ARMOR_GROUP_UNIT_TYPE = Armor.M_1_Abrams.id
 
     FACTORY_UNIT_TYPE = Fortification.Workshop_A.id
 
-    AMMUNITION_DEPOT_UNIT_TYPE = Warehouse.Ammunition_depot.id
+    AMMUNITION_DEPOT_UNIT_TYPE = Warehouse._Ammunition_depot.id
 
     STRIKE_TARGET_UNIT_TYPE = Fortification.Tech_combine.id
 
@@ -181,7 +185,7 @@ class MizCampaignLoader:
     def red(self) -> Country:
         return self.country(blue=False)
 
-    def off_map_spawns(self, blue: bool) -> Iterator[FlyingGroup]:
+    def off_map_spawns(self, blue: bool) -> Iterator[PlaneGroup]:
         for group in self.country(blue).plane_group:
             if group.units[0].type == self.OFF_MAP_UNIT_TYPE:
                 yield group
@@ -305,26 +309,26 @@ class MizCampaignLoader:
                 control_point.captured = blue
                 control_point.captured_invert = group.late_activation
                 control_points[control_point.id] = control_point
-            for group in self.carriers(blue):
+            for ship in self.carriers(blue):
                 # TODO: Name the carrier.
                 control_point = Carrier(
-                    "carrier", group.position, next(self.control_point_id)
+                    "carrier", ship.position, next(self.control_point_id)
                 )
                 control_point.captured = blue
-                control_point.captured_invert = group.late_activation
+                control_point.captured_invert = ship.late_activation
                 control_points[control_point.id] = control_point
-            for group in self.lhas(blue):
+            for ship in self.lhas(blue):
                 # TODO: Name the LHA.db
-                control_point = Lha("lha", group.position, next(self.control_point_id))
+                control_point = Lha("lha", ship.position, next(self.control_point_id))
                 control_point.captured = blue
-                control_point.captured_invert = group.late_activation
+                control_point.captured_invert = ship.late_activation
                 control_points[control_point.id] = control_point
-            for group in self.fobs(blue):
+            for fob in self.fobs(blue):
                 control_point = Fob(
-                    str(group.name), group.position, next(self.control_point_id)
+                    str(fob.name), fob.position, next(self.control_point_id)
                 )
                 control_point.captured = blue
-                control_point.captured_invert = group.late_activation
+                control_point.captured_invert = fob.late_activation
                 control_points[control_point.id] = control_point
 
         return control_points
@@ -385,22 +389,22 @@ class MizCampaignLoader:
                 origin, list(reversed(waypoints))
             )
 
-    def objective_info(self, group: Group) -> Tuple[ControlPoint, Distance]:
-        closest = self.theater.closest_control_point(group.position)
-        distance = meters(closest.position.distance_to_point(group.position))
+    def objective_info(self, near: Positioned) -> Tuple[ControlPoint, Distance]:
+        closest = self.theater.closest_control_point(near.position)
+        distance = meters(closest.position.distance_to_point(near.position))
         return closest, distance
 
     def add_preset_locations(self) -> None:
-        for group in self.offshore_strike_targets:
-            closest, distance = self.objective_info(group)
+        for static in self.offshore_strike_targets:
+            closest, distance = self.objective_info(static)
             closest.preset_locations.offshore_strike_locations.append(
-                PointWithHeading.from_point(group.position, group.units[0].heading)
+                PointWithHeading.from_point(static.position, static.units[0].heading)
             )
 
-        for group in self.ships:
-            closest, distance = self.objective_info(group)
+        for ship in self.ships:
+            closest, distance = self.objective_info(ship)
             closest.preset_locations.ships.append(
-                PointWithHeading.from_point(group.position, group.units[0].heading)
+                PointWithHeading.from_point(ship.position, ship.units[0].heading)
             )
 
         for group in self.missile_sites:
@@ -451,33 +455,33 @@ class MizCampaignLoader:
                 PointWithHeading.from_point(group.position, group.units[0].heading)
             )
 
-        for group in self.helipads:
-            closest, distance = self.objective_info(group)
+        for static in self.helipads:
+            closest, distance = self.objective_info(static)
             closest.helipads.append(
-                PointWithHeading.from_point(group.position, group.units[0].heading)
+                PointWithHeading.from_point(static.position, static.units[0].heading)
             )
 
-        for group in self.factories:
-            closest, distance = self.objective_info(group)
+        for static in self.factories:
+            closest, distance = self.objective_info(static)
             closest.preset_locations.factories.append(
-                PointWithHeading.from_point(group.position, group.units[0].heading)
+                PointWithHeading.from_point(static.position, static.units[0].heading)
             )
 
-        for group in self.ammunition_depots:
-            closest, distance = self.objective_info(group)
+        for static in self.ammunition_depots:
+            closest, distance = self.objective_info(static)
             closest.preset_locations.ammunition_depots.append(
-                PointWithHeading.from_point(group.position, group.units[0].heading)
+                PointWithHeading.from_point(static.position, static.units[0].heading)
             )
 
-        for group in self.strike_targets:
-            closest, distance = self.objective_info(group)
+        for static in self.strike_targets:
+            closest, distance = self.objective_info(static)
             closest.preset_locations.strike_locations.append(
-                PointWithHeading.from_point(group.position, group.units[0].heading)
+                PointWithHeading.from_point(static.position, static.units[0].heading)
             )
 
-        for group in self.scenery:
-            closest, distance = self.objective_info(group)
-            closest.preset_locations.scenery.append(group)
+        for scenery_group in self.scenery:
+            closest, distance = self.objective_info(scenery_group)
+            closest.preset_locations.scenery.append(scenery_group)
 
     def populate_theater(self) -> None:
         for control_point in self.control_points.values():
@@ -504,7 +508,7 @@ class ConflictTheater:
     """
     daytime_map: Dict[str, Tuple[int, int]]
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.controlpoints: List[ControlPoint] = []
         self.point_to_ll_transformer = Transformer.from_crs(
             self.projection_parameters.to_crs(), CRS("WGS84")
@@ -536,10 +540,12 @@ class ConflictTheater:
             CRS("WGS84"), self.projection_parameters.to_crs()
         )
 
-    def add_controlpoint(self, point: ControlPoint):
+    def add_controlpoint(self, point: ControlPoint) -> None:
         self.controlpoints.append(point)
 
-    def find_ground_objects_by_obj_name(self, obj_name):
+    def find_ground_objects_by_obj_name(
+        self, obj_name: str
+    ) -> list[TheaterGroundObject[Any]]:
         found = []
         for cp in self.controlpoints:
             for g in cp.ground_objects:
@@ -581,12 +587,12 @@ class ConflictTheater:
 
         return True
 
-    def nearest_land_pos(self, point: Point, extend_dist: int = 50) -> Point:
+    def nearest_land_pos(self, near: Point, extend_dist: int = 50) -> Point:
         """Returns the nearest point inside a land exclusion zone from point
         `extend_dist` determines how far inside the zone the point should be placed"""
-        if self.is_on_land(point):
-            return point
-        point = geometry.Point(point.x, point.y)
+        if self.is_on_land(near):
+            return near
+        point = geometry.Point(near.x, near.y)
         nearest_points = []
         if not self.landmap:
             raise RuntimeError("Landmap not initialized")
@@ -698,6 +704,7 @@ class ConflictTheater:
             "Normandy": NormandyTheater,
             "The Channel": TheChannelTheater,
             "Syria": SyriaTheater,
+            "MarianaIslands": MarianaIslandsTheater,
         }
         theater = theaters[data["theater"]]
         t = theater()
@@ -856,3 +863,22 @@ class SyriaTheater(ConflictTheater):
         from .syria import PARAMETERS
 
         return PARAMETERS
+
+
+class MarianaIslandsTheater(ConflictTheater):
+    terrain = marianaislands.MarianaIslands()
+    overview_image = "marianaislands.gif"
+
+    landmap = load_landmap("resources\\marianaislandslandmap.p")
+    daytime_map = {
+        "dawn": (6, 8),
+        "day": (8, 16),
+        "dusk": (16, 18),
+        "night": (0, 5),
+    }
+
+    @property
+    def projection_parameters(self) -> TransverseMercator:
+        from .marianaislands import PARAMETERS
+
+        return PARAMETERS

game/theater/controlpoint.py

@@ -16,7 +16,6 @@ from typing import (
     Optional,
     Set,
     TYPE_CHECKING,
-    Type,
     Union,
     Sequence,
     Iterable,
@@ -25,14 +24,13 @@ from typing import (
 
 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,
+    Stennis,
+    KUZNECOW,
+    LHA_Tarawa,
+    Type_071,
 )
 from dcs.terrain.terrain import Airport, ParkingSlot
 from dcs.unit import Unit
-from dcs.unittype import FlyingType, VehicleType
 
 from game import db
 from game.point_with_heading import PointWithHeading
@@ -45,8 +43,10 @@ from .missiontarget import MissionTarget
 from .theatergroundobject import (
     GenericCarrierGroundObject,
     TheaterGroundObject,
+    NavalGroundObject,
 )
-from ..db import PRICES
+from ..dcs.aircrafttype import AircraftType
+from ..dcs.groundunittype import GroundUnitType
 from ..utils import nautical_miles
 from ..weather import Conditions
 
@@ -125,19 +125,19 @@ class PresetLocations:
 
 @dataclass(frozen=True)
 class AircraftAllocations:
-    present: dict[Type[FlyingType], int]
-    ordered: dict[Type[FlyingType], int]
-    transferring: dict[Type[FlyingType], int]
+    present: dict[AircraftType, int]
+    ordered: dict[AircraftType, int]
+    transferring: dict[AircraftType, int]
 
     @property
     def total_value(self) -> int:
         total: int = 0
         for unit_type, count in self.present.items():
-            total += PRICES[unit_type] * count
+            total += unit_type.price * count
         for unit_type, count in self.ordered.items():
-            total += PRICES[unit_type] * count
+            total += unit_type.price * count
         for unit_type, count in self.transferring.items():
-            total += PRICES[unit_type] * count
+            total += unit_type.price * count
 
         return total
 
@@ -160,13 +160,13 @@ class AircraftAllocations:
 
 @dataclass(frozen=True)
 class GroundUnitAllocations:
-    present: dict[Type[VehicleType], int]
-    ordered: dict[Type[VehicleType], int]
-    transferring: dict[Type[VehicleType], int]
+    present: dict[GroundUnitType, int]
+    ordered: dict[GroundUnitType, int]
+    transferring: dict[GroundUnitType, int]
 
     @property
-    def all(self) -> dict[Type[VehicleType], int]:
-        combined: dict[Type[VehicleType], int] = defaultdict(int)
+    def all(self) -> dict[GroundUnitType, int]:
+        combined: dict[GroundUnitType, int] = defaultdict(int)
         for unit_type, count in itertools.chain(
             self.present.items(), self.ordered.items(), self.transferring.items()
         ):
@@ -177,11 +177,11 @@ class GroundUnitAllocations:
     def total_value(self) -> int:
         total: int = 0
         for unit_type, count in self.present.items():
-            total += PRICES[unit_type] * count
+            total += unit_type.price * count
         for unit_type, count in self.ordered.items():
-            total += PRICES[unit_type] * count
+            total += unit_type.price * count
         for unit_type, count in self.transferring.items():
-            total += PRICES[unit_type] * count
+            total += unit_type.price * count
 
         return total
 
@@ -291,15 +291,15 @@ class ControlPoint(MissionTarget, ABC):
         at: db.StartingPosition,
         size: int,
         importance: float,
-        has_frontline=True,
-        cptype=ControlPointType.AIRBASE,
-    ):
+        has_frontline: bool = True,
+        cptype: ControlPointType = ControlPointType.AIRBASE,
+    ) -> None:
         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.connected_objectives: List[TheaterGroundObject[Any]] = []
         self.preset_locations = PresetLocations()
         self.helipads: List[PointWithHeading] = []
 
@@ -323,11 +323,11 @@ class ControlPoint(MissionTarget, ABC):
 
         self.target_position: Optional[Point] = None
 
-    def __repr__(self):
-        return f"<{__class__}: {self.name}>"
+    def __repr__(self) -> str:
+        return f"<{self.__class__}: {self.name}>"
 
     @property
-    def ground_objects(self) -> List[TheaterGroundObject]:
+    def ground_objects(self) -> List[TheaterGroundObject[Any]]:
         return list(self.connected_objectives)
 
     @property
@@ -335,11 +335,11 @@ class ControlPoint(MissionTarget, ABC):
     def heading(self) -> int:
         ...
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
     @property
-    def is_global(self):
+    def is_global(self) -> bool:
         return not self.connected_points
 
     def transitive_connected_friendly_points(
@@ -406,21 +406,21 @@ class ControlPoint(MissionTarget, ABC):
         return False
 
     @property
-    def is_carrier(self):
+    def is_carrier(self) -> bool:
         """
         :return: Whether this control point is an aircraft carrier
         """
         return False
 
     @property
-    def is_fleet(self):
+    def is_fleet(self) -> bool:
         """
         :return: Whether this control point is a boat (mobile)
         """
         return False
 
     @property
-    def is_lha(self):
+    def is_lha(self) -> bool:
         """
         :return: Whether this control point is an LHA
         """
@@ -440,7 +440,7 @@ class ControlPoint(MissionTarget, ABC):
 
     @property
     @abstractmethod
-    def total_aircraft_parking(self):
+    def total_aircraft_parking(self) -> int:
         """
         :return: The maximum number of aircraft that can be stored in this
                  control point
@@ -472,7 +472,7 @@ class ControlPoint(MissionTarget, ABC):
         ...
 
     # TODO: Should be naval specific.
-    def get_carrier_group_name(self):
+    def get_carrier_group_name(self) -> Optional[str]:
         """
         Get the carrier group name if the airbase is a carrier
         :return: Carrier group name
@@ -486,22 +486,24 @@ class ControlPoint(MissionTarget, ABC):
                     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,
+                                Stennis,
+                                KUZNECOW,
                             ]:
                                 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]:
+                            if db.unit_type_from_name(u.type) in [LHA_Tarawa]:
                                 return group.name
         return None
 
     # TODO: Should be Airbase specific.
-    def is_connected(self, to) -> bool:
+    def is_connected(self, to: ControlPoint) -> bool:
         return to in self.connected_points
 
-    def find_ground_objects_by_obj_name(self, obj_name):
+    def find_ground_objects_by_obj_name(
+        self, obj_name: str
+    ) -> list[TheaterGroundObject[Any]]:
         found = []
         for g in self.ground_objects:
             if g.obj_name == obj_name:
@@ -523,7 +525,7 @@ class ControlPoint(MissionTarget, ABC):
             f"vehicles have been captured and sold for ${total}M."
         )
 
-    def retreat_ground_units(self, game: Game):
+    def retreat_ground_units(self, game: Game) -> None:
         # 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
@@ -541,27 +543,19 @@ class ControlPoint(MissionTarget, ABC):
         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.control_point.base.commission_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
-
+    def capture_aircraft(self, game: Game, airframe: AircraftType, count: int) -> None:
+        value = airframe.price * count
         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."
+            f"No valid retreat destination in range of {self.name} for {airframe}"
+            f"{count} aircraft have been captured and sold for ${value}M."
         )
 
     def aircraft_retreat_destination(
-        self, game: Game, airframe: Type[FlyingType]
+        self, game: Game, airframe: AircraftType
     ) -> Optional[ControlPoint]:
         closest = ObjectiveDistanceCache.get_closest_airfields(self)
         # TODO: Should be airframe dependent.
@@ -579,17 +573,17 @@ class ControlPoint(MissionTarget, ABC):
         return None
 
     def _retreat_air_units(
-        self, game: Game, airframe: Type[FlyingType], count: int
+        self, game: Game, airframe: AircraftType, count: int
     ) -> None:
         while count:
-            logging.debug(f"Retreating {count} {airframe.id} from {self.name}")
+            logging.debug(f"Retreating {count} {airframe} 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})
+            destination.base.commission_units({airframe: transfer_amount})
             count -= transfer_amount
 
     def retreat_air_units(self, game: Game) -> None:
@@ -618,16 +612,16 @@ class ControlPoint(MissionTarget, ABC):
         self.base.set_strength_to_minimum()
 
     @abstractmethod
-    def can_operate(self, aircraft: Type[FlyingType]) -> bool:
+    def can_operate(self, aircraft: AircraftType) -> bool:
         ...
 
-    def aircraft_transferring(self, game: Game) -> dict[Type[FlyingType], int]:
+    def aircraft_transferring(self, game: Game) -> dict[AircraftType, int]:
         if self.captured:
             ato = game.blue_ato
         else:
             ato = game.red_ato
 
-        transferring: defaultdict[Type[FlyingType], int] = defaultdict(int)
+        transferring: defaultdict[AircraftType, int] = defaultdict(int)
         for package in ato.packages:
             for flight in package.flights:
                 if flight.departure == flight.arrival:
@@ -692,7 +686,7 @@ class ControlPoint(MissionTarget, ABC):
     def allocated_aircraft(self, game: Game) -> AircraftAllocations:
         on_order = {}
         for unit_bought, count in self.pending_unit_deliveries.units.items():
-            if issubclass(unit_bought, FlyingType):
+            if isinstance(unit_bought, AircraftType):
                 on_order[unit_bought] = count
 
         return AircraftAllocations(
@@ -704,10 +698,10 @@ class ControlPoint(MissionTarget, ABC):
     ) -> GroundUnitAllocations:
         on_order = {}
         for unit_bought, count in self.pending_unit_deliveries.units.items():
-            if issubclass(unit_bought, VehicleType):
+            if isinstance(unit_bought, GroundUnitType):
                 on_order[unit_bought] = count
 
-        transferring: dict[Type[VehicleType], int] = defaultdict(int)
+        transferring: dict[GroundUnitType, int] = defaultdict(int)
         for transfer in transfers:
             if transfer.destination == self:
                 for unit_type, count in transfer.units.items():
@@ -757,7 +751,7 @@ class ControlPoint(MissionTarget, ABC):
         return len([obj for obj in self.connected_objectives if obj.category == "ammo"])
 
     @property
-    def strike_targets(self) -> List[Union[MissionTarget, Unit]]:
+    def strike_targets(self) -> Sequence[Union[MissionTarget, Unit]]:
         return []
 
     @property
@@ -773,8 +767,8 @@ class ControlPoint(MissionTarget, ABC):
 
 class Airfield(ControlPoint):
     def __init__(
-        self, airport: Airport, size: int, importance: float, has_frontline=True
-    ):
+        self, airport: Airport, size: int, importance: float, has_frontline: bool = True
+    ) -> None:
         super().__init__(
             airport.id,
             airport.name,
@@ -788,7 +782,7 @@ class Airfield(ControlPoint):
         self.airport = airport
         self._runway_status = RunwayStatus()
 
-    def can_operate(self, aircraft: FlyingType) -> bool:
+    def can_operate(self, aircraft: AircraftType) -> bool:
         # TODO: Allow helicopters.
         # Need to implement ground spawns so the helos don't use the runway.
         # TODO: Allow harrier.
@@ -810,6 +804,7 @@ class Airfield(ControlPoint):
         if self.is_friendly(for_player):
             yield from [
                 FlightType.AEWC,
+                FlightType.REFUELING,
                 # TODO: FlightType.INTERCEPTION
                 # TODO: FlightType.LOGISTICS
             ]
@@ -887,9 +882,12 @@ class NavalControlPoint(ControlPoint, ABC):
     def heading(self) -> int:
         return 0  # TODO compute heading
 
-    def find_main_tgo(self) -> TheaterGroundObject:
+    def find_main_tgo(self) -> GenericCarrierGroundObject:
         for g in self.ground_objects:
-            if g.dcs_identifier in ["CARRIER", "LHA"]:
+            if isinstance(g, GenericCarrierGroundObject) and g.dcs_identifier in [
+                "CARRIER",
+                "LHA",
+            ]:
                 return g
         raise RuntimeError(f"Found no carrier/LHA group for {self.name}")
 
@@ -899,10 +897,10 @@ class NavalControlPoint(ControlPoint, ABC):
         for group in self.find_main_tgo().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,
+                    Stennis,
+                    LHA_Tarawa,
+                    KUZNECOW,
+                    Type_071,
                 ]:
                     return True
         return False
@@ -959,17 +957,20 @@ class Carrier(NavalControlPoint):
 
         yield from super().mission_types(for_player)
         if self.is_friendly(for_player):
-            yield FlightType.AEWC
+            yield from [
+                FlightType.AEWC,
+                FlightType.REFUELING,
+            ]
 
     def capture(self, game: Game, for_player: bool) -> None:
         raise RuntimeError("Carriers cannot be captured")
 
     @property
-    def is_carrier(self):
+    def is_carrier(self) -> bool:
         return True
 
-    def can_operate(self, aircraft: FlyingType) -> bool:
-        return aircraft in db.CARRIER_CAPABLE
+    def can_operate(self, aircraft: AircraftType) -> bool:
+        return aircraft.carrier_capable
 
     @property
     def total_aircraft_parking(self) -> int:
@@ -1002,8 +1003,8 @@ class Lha(NavalControlPoint):
     def is_lha(self) -> bool:
         return True
 
-    def can_operate(self, aircraft: FlyingType) -> bool:
-        return aircraft in db.LHA_CAPABLE
+    def can_operate(self, aircraft: AircraftType) -> bool:
+        return aircraft.lha_capable
 
     @property
     def total_aircraft_parking(self) -> int:
@@ -1042,7 +1043,7 @@ class OffMapSpawn(ControlPoint):
     def total_aircraft_parking(self) -> int:
         return 1000
 
-    def can_operate(self, aircraft: FlyingType) -> bool:
+    def can_operate(self, aircraft: AircraftType) -> bool:
         return True
 
     @property
@@ -1113,7 +1114,7 @@ class Fob(ControlPoint):
     def total_aircraft_parking(self) -> int:
         return 0
 
-    def can_operate(self, aircraft: FlyingType) -> bool:
+    def can_operate(self, aircraft: AircraftType) -> bool:
         return False
 
     @property

game/theater/frontline.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Iterator, List, Tuple
+from typing import Iterator, List, Tuple, Any
 
 from dcs.mapping import Point
 
@@ -66,7 +66,15 @@ class FrontLine(MissionTarget):
         self.segments: List[FrontLineSegment] = [
             FrontLineSegment(a, b) for a, b in pairwise(route)
         ]
-        self.name = f"Front line {blue_point}/{red_point}"
+        super().__init__(
+            f"Front line {blue_point}/{red_point}",
+            self.point_from_a(self._position_distance),
+        )
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        if not hasattr(self, "position"):
+            self.position = self.point_from_a(self._position_distance)
 
     def control_point_hostile_to(self, player: bool) -> ControlPoint:
         if player:
@@ -81,19 +89,12 @@ class FrontLine(MissionTarget):
         yield from [
             FlightType.CAS,
             FlightType.AEWC,
+            FlightType.REFUELING
             # TODO: FlightType.TROOP_TRANSPORT
             # TODO: FlightType.EVAC
         ]
         yield from super().mission_types(for_player)
 
-    @property
-    def position(self):
-        """
-        The position where the conflict should occur
-        according to the current strength of each control point.
-        """
-        return self.point_from_a(self._position_distance)
-
     @property
     def points(self) -> Iterator[Point]:
         yield self.segments[0].point_a
@@ -106,12 +107,12 @@ class FrontLine(MissionTarget):
         return self.blue_cp, self.red_cp
 
     @property
-    def attack_distance(self):
+    def attack_distance(self) -> float:
         """The total distance of all segments"""
         return sum(i.attack_distance for i in self.segments)
 
     @property
-    def attack_heading(self):
+    def attack_heading(self) -> float:
         """The heading of the active attack segment from player to enemy control point"""
         return self.active_segment.attack_heading
 
@@ -148,6 +149,9 @@ class FrontLine(MissionTarget):
                 )
             else:
                 remaining_dist -= segment.attack_distance
+        raise RuntimeError(
+            f"Could not find front line point {distance} from {self.blue_cp}"
+        )
 
     @property
     def _position_distance(self) -> float:

game/theater/landmap.py

@@ -14,7 +14,7 @@ class Landmap:
     exclusion_zones: MultiPolygon
     sea_zones: MultiPolygon
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if not self.inclusion_zones.is_valid:
             raise RuntimeError("Inclusion zones not valid")
         if not self.exclusion_zones.is_valid:
@@ -36,13 +36,5 @@ def load_landmap(filename: str) -> Optional[Landmap]:
         return None
 
 
-def poly_contains(x, y, poly: Union[MultiPolygon, Polygon]):
+def poly_contains(x: float, y: float, poly: Union[MultiPolygon, Polygon]) -> bool:
     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/marianaislands.py

@@ -0,0 +1,8 @@
+from game.theater.projections import TransverseMercator
+
+PARAMETERS = TransverseMercator(
+    central_meridian=147,
+    false_easting=238417.99999989968,
+    false_northing=-1491840.000000048,
+    scale_factor=0.9996,
+)

game/theater/missiontarget.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections import Sequence
 from typing import Iterator, TYPE_CHECKING, List, Union
 
 from dcs.mapping import Point
@@ -20,7 +21,7 @@ class MissionTarget:
         self.name = name
         self.position = position
 
-    def distance_to(self, other: MissionTarget) -> int:
+    def distance_to(self, other: MissionTarget) -> float:
         """Computes the distance to the given mission target."""
         return self.position.distance_to_point(other.position)
 
@@ -45,5 +46,5 @@ class MissionTarget:
             ]
 
     @property
-    def strike_targets(self) -> List[Union[MissionTarget, Unit]]:
+    def strike_targets(self) -> Sequence[Union[MissionTarget, Unit]]:
         return []

game/theater/start_generator.py

@@ -78,20 +78,33 @@ class GeneratorSettings:
     no_enemy_navy: bool
 
 
+@dataclass
+class ModSettings:
+    a4_skyhawk: bool = False
+    f22_raptor: bool = False
+    hercules: bool = False
+    jas39_gripen: bool = False
+    su57_felon: bool = False
+    frenchpack: bool = False
+    high_digit_sams: bool = False
+
+
 class GameGenerator:
     def __init__(
         self,
-        player: str,
-        enemy: str,
+        player: Faction,
+        enemy: Faction,
         theater: ConflictTheater,
         settings: Settings,
         generator_settings: GeneratorSettings,
+        mod_settings: ModSettings,
     ) -> None:
         self.player = player
         self.enemy = enemy
         self.theater = theater
         self.settings = settings
         self.generator_settings = generator_settings
+        self.mod_settings = mod_settings
 
     def generate(self) -> Game:
         with logged_duration("TGO population"):
@@ -99,8 +112,8 @@ class GameGenerator:
             namegen.reset()
             self.prepare_theater()
             game = Game(
-                player_name=self.player,
-                enemy_name=self.enemy,
+                player_faction=self.player.apply_mod_settings(self.mod_settings),
+                enemy_faction=self.enemy.apply_mod_settings(self.mod_settings),
                 theater=self.theater,
                 start_date=self.generator_settings.start_date,
                 settings=self.settings,
@@ -159,9 +172,9 @@ class ControlPointGroundObjectGenerator:
     @property
     def faction_name(self) -> str:
         if self.control_point.captured:
-            return self.game.player_name
+            return self.game.player_faction.name
         else:
-            return self.game.enemy_name
+            return self.game.enemy_faction.name
 
     @property
     def faction(self) -> Faction:

game/theater/theatergroundobject.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import itertools
 import logging
-from typing import Iterator, List, TYPE_CHECKING, Union
+from collections import Sequence
+from typing import Iterator, List, TYPE_CHECKING, Union, Generic, TypeVar, Any
 
 from dcs.mapping import Point
 from dcs.triggers import TriggerZone
 from dcs.unit import Unit
-from dcs.unitgroup import Group
-from dcs.unittype import VehicleType
+from dcs.unitgroup import ShipGroup, VehicleGroup
 
 from .. import db
 from ..data.radar_db import (
@@ -47,7 +47,10 @@ NAME_BY_CATEGORY = {
 }
 
 
-class TheaterGroundObject(MissionTarget):
+GroupT = TypeVar("GroupT", ShipGroup, VehicleGroup)
+
+
+class TheaterGroundObject(MissionTarget, Generic[GroupT]):
     def __init__(
         self,
         name: str,
@@ -66,7 +69,7 @@ class TheaterGroundObject(MissionTarget):
         self.control_point = control_point
         self.dcs_identifier = dcs_identifier
         self.sea_object = sea_object
-        self.groups: List[Group] = []
+        self.groups: List[GroupT] = []
 
     @property
     def is_dead(self) -> bool:
@@ -147,7 +150,7 @@ class TheaterGroundObject(MissionTarget):
                 return True
         return False
 
-    def _max_range_of_type(self, group: Group, range_type: str) -> Distance:
+    def _max_range_of_type(self, group: GroupT, range_type: str) -> Distance:
         if not self.might_have_aa:
             return meters(0)
 
@@ -168,13 +171,13 @@ class TheaterGroundObject(MissionTarget):
     def max_detection_range(self) -> Distance:
         return max(self.detection_range(g) for g in self.groups)
 
-    def detection_range(self, group: Group) -> Distance:
+    def detection_range(self, group: GroupT) -> Distance:
         return self._max_range_of_type(group, "detection_range")
 
     def max_threat_range(self) -> Distance:
         return max(self.threat_range(g) for g in self.groups)
 
-    def threat_range(self, group: Group, radar_only: bool = False) -> Distance:
+    def threat_range(self, group: GroupT, radar_only: bool = False) -> Distance:
         return self._max_range_of_type(group, "threat_range")
 
     @property
@@ -187,7 +190,7 @@ class TheaterGroundObject(MissionTarget):
         return False
 
     @property
-    def strike_targets(self) -> List[Union[MissionTarget, Unit]]:
+    def strike_targets(self) -> Sequence[Union[MissionTarget, Unit]]:
         return self.units
 
     @property
@@ -206,7 +209,7 @@ class TheaterGroundObject(MissionTarget):
         raise NotImplementedError
 
 
-class BuildingGroundObject(TheaterGroundObject):
+class BuildingGroundObject(TheaterGroundObject[VehicleGroup]):
     def __init__(
         self,
         name: str,
@@ -217,7 +220,7 @@ class BuildingGroundObject(TheaterGroundObject):
         heading: int,
         control_point: ControlPoint,
         dcs_identifier: str,
-        is_fob_structure=False,
+        is_fob_structure: bool = False,
     ) -> None:
         super().__init__(
             name=name,
@@ -253,7 +256,7 @@ class BuildingGroundObject(TheaterGroundObject):
     def kill(self) -> None:
         self._dead = True
 
-    def iter_building_group(self) -> Iterator[TheaterGroundObject]:
+    def iter_building_group(self) -> Iterator[TheaterGroundObject[Any]]:
         for tgo in self.control_point.ground_objects:
             if tgo.obj_name == self.obj_name and not tgo.is_dead:
                 yield tgo
@@ -338,7 +341,7 @@ class FactoryGroundObject(BuildingGroundObject):
         )
 
 
-class NavalGroundObject(TheaterGroundObject):
+class NavalGroundObject(TheaterGroundObject[ShipGroup]):
     def mission_types(self, for_player: bool) -> Iterator[FlightType]:
         from gen.flights.flight import FlightType
 
@@ -407,7 +410,7 @@ class LhaGroundObject(GenericCarrierGroundObject):
         return f"{self.faction_color}|EWR|{super().group_name}"
 
 
-class MissileSiteGroundObject(TheaterGroundObject):
+class MissileSiteGroundObject(TheaterGroundObject[VehicleGroup]):
     def __init__(
         self, name: str, group_id: int, position: Point, control_point: ControlPoint
     ) -> None:
@@ -431,14 +434,14 @@ class MissileSiteGroundObject(TheaterGroundObject):
         return False
 
 
-class CoastalSiteGroundObject(TheaterGroundObject):
+class CoastalSiteGroundObject(TheaterGroundObject[VehicleGroup]):
     def __init__(
         self,
         name: str,
         group_id: int,
         position: Point,
         control_point: ControlPoint,
-        heading,
+        heading: int,
     ) -> None:
         super().__init__(
             name=name,
@@ -460,10 +463,10 @@ class CoastalSiteGroundObject(TheaterGroundObject):
         return False
 
 
-# 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(TheaterGroundObject):
+# The SamGroundObject represents all type of AA
+# The TGO can have multiple types of units (AAA,SAM,Support...)
+# Differentiation can be made during generation with the airdefensegroupgenerator
+class SamGroundObject(TheaterGroundObject[VehicleGroup]):
     def __init__(
         self,
         name: str,
@@ -481,18 +484,6 @@ class SamGroundObject(TheaterGroundObject):
             dcs_identifier="AA",
             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
@@ -506,33 +497,25 @@ class SamGroundObject(TheaterGroundObject):
     def might_have_aa(self) -> bool:
         return True
 
-    def threat_range(self, group: Group, radar_only: bool = False) -> Distance:
+    def threat_range(self, group: VehicleGroup, radar_only: bool = False) -> Distance:
         max_non_radar = meters(0)
         live_trs = set()
         max_telar_range = meters(0)
         launchers = set()
         for unit in group.units:
-            unit_type = db.unit_type_from_name(unit.type)
-            if unit_type is None or not issubclass(unit_type, VehicleType):
-                continue
+            unit_type = db.vehicle_type_from_name(unit.type)
             if unit_type in TRACK_RADARS:
                 live_trs.add(unit_type)
             elif unit_type in TELARS:
-                max_telar_range = max(
-                    max_telar_range, meters(getattr(unit_type, "threat_range", 0))
-                )
+                max_telar_range = max(max_telar_range, meters(unit_type.threat_range))
             elif unit_type in LAUNCHER_TRACKER_PAIRS:
                 launchers.add(unit_type)
             else:
-                max_non_radar = max(
-                    max_non_radar, meters(getattr(unit_type, "threat_range", 0))
-                )
+                max_non_radar = max(max_non_radar, meters(unit_type.threat_range))
         max_tel_range = meters(0)
         for launcher in launchers:
             if LAUNCHER_TRACKER_PAIRS[launcher] in live_trs:
-                max_tel_range = max(
-                    max_tel_range, meters(getattr(launcher, "threat_range"))
-                )
+                max_tel_range = max(max_tel_range, meters(unit_type.threat_range))
         if radar_only:
             return max(max_tel_range, max_telar_range)
         else:
@@ -547,7 +530,7 @@ class SamGroundObject(TheaterGroundObject):
         return True
 
 
-class VehicleGroupGroundObject(TheaterGroundObject):
+class VehicleGroupGroundObject(TheaterGroundObject[VehicleGroup]):
     def __init__(
         self,
         name: str,
@@ -575,7 +558,7 @@ class VehicleGroupGroundObject(TheaterGroundObject):
         return True
 
 
-class EwrGroundObject(TheaterGroundObject):
+class EwrGroundObject(TheaterGroundObject[VehicleGroup]):
     def __init__(
         self,
         name: str,
@@ -597,7 +580,8 @@ class EwrGroundObject(TheaterGroundObject):
     @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}"
+        # Use Group Id and uppercase EWR
+        return f"{self.faction_color}|EWR|{self.group_id}"
 
     def mission_types(self, for_player: bool) -> Iterator[FlightType]:
         from gen.flights.flight import FlightType

game/threatzones.py

@@ -27,7 +27,10 @@ ThreatPoly = Union[MultiPolygon, Polygon]
 
 class ThreatZones:
     def __init__(
-        self, airbases: ThreatPoly, air_defenses: ThreatPoly, radar_sam_threats
+        self,
+        airbases: ThreatPoly,
+        air_defenses: ThreatPoly,
+        radar_sam_threats: ThreatPoly,
     ) -> None:
         self.airbases = airbases
         self.air_defenses = air_defenses
@@ -44,8 +47,10 @@ class ThreatZones:
         boundary = self.closest_boundary(point)
         return meters(boundary.distance_to_point(point))
 
+    # Type checking ignored because singledispatchmethod doesn't work with required type
+    # definitions. The implementation methods are all typed, so should be fine.
     @singledispatchmethod
-    def threatened(self, position) -> bool:
+    def threatened(self, position) -> bool:  # type: ignore
         raise NotImplementedError
 
     @threatened.register
@@ -61,8 +66,10 @@ class ThreatZones:
             LineString([self.dcs_to_shapely_point(a), self.dcs_to_shapely_point(b)])
         )
 
+    # Type checking ignored because singledispatchmethod doesn't work with required type
+    # definitions. The implementation methods are all typed, so should be fine.
     @singledispatchmethod
-    def threatened_by_aircraft(self, target) -> bool:
+    def threatened_by_aircraft(self, target) -> bool:  # type: ignore
         raise NotImplementedError
 
     @threatened_by_aircraft.register
@@ -82,8 +89,10 @@ class ThreatZones:
             LineString((self.dcs_to_shapely_point(p.position) for p in waypoints))
         )
 
+    # Type checking ignored because singledispatchmethod doesn't work with required type
+    # definitions. The implementation methods are all typed, so should be fine.
     @singledispatchmethod
-    def threatened_by_air_defense(self, target) -> bool:
+    def threatened_by_air_defense(self, target) -> bool:  # type: ignore
         raise NotImplementedError
 
     @threatened_by_air_defense.register
@@ -102,8 +111,10 @@ class ThreatZones:
             self.dcs_to_shapely_point(target.position)
         )
 
+    # Type checking ignored because singledispatchmethod doesn't work with required type
+    # definitions. The implementation methods are all typed, so should be fine.
     @singledispatchmethod
-    def threatened_by_radar_sam(self, target) -> bool:
+    def threatened_by_radar_sam(self, target) -> bool:  # type: ignore
         raise NotImplementedError
 
     @threatened_by_radar_sam.register

game/transfers.py

@@ -6,20 +6,19 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from functools import singledispatchmethod
 from typing import (
-    Dict,
     Generic,
     Iterator,
     List,
     Optional,
     TYPE_CHECKING,
-    Type,
     TypeVar,
     Sequence,
 )
 
 from dcs.mapping import Point
-from dcs.unittype import FlyingType, VehicleType
 
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.groundunittype import GroundUnitType
 from game.procurement import AircraftProcurementRequest
 from game.squadrons import Squadron
 from game.theater import ControlPoint, MissionTarget
@@ -29,7 +28,7 @@ from game.theater.transitnetwork import (
 )
 from game.utils import meters, nautical_miles
 from gen.ato import Package
-from gen.flights.ai_flight_planner_db import TRANSPORT_CAPABLE
+from gen.flights.ai_flight_planner_db import TRANSPORT_CAPABLE, aircraft_for_task
 from gen.flights.closestairfields import ObjectiveDistanceCache
 from gen.flights.flight import Flight, FlightType
 from gen.flights.flightplan import FlightPlanBuilder
@@ -72,10 +71,18 @@ class TransferOrder:
     player: bool = field(init=False)
 
     #: The units being transferred.
-    units: Dict[Type[VehicleType], int]
+    units: dict[GroundUnitType, int]
 
     transport: Optional[Transport] = field(default=None)
 
+    def __str__(self) -> str:
+        """Returns the text that should be displayed for the transfer."""
+        count = self.size
+        origin = self.origin.name
+        destination = self.destination.name
+        description = "Transfer" if self.player else "Enemy transfer"
+        return f"{description} of {count} units from {origin} to {destination}"
+
     def __post_init__(self) -> None:
         self.position = self.origin
         self.player = self.origin.is_friendly(to_player=True)
@@ -89,27 +96,30 @@ class TransferOrder:
     def kill_all(self) -> None:
         self.units.clear()
 
-    def kill_unit(self, unit_type: Type[VehicleType]) -> None:
+    def kill_unit(self, unit_type: GroundUnitType) -> None:
         if unit_type not in self.units or not self.units[unit_type]:
-            raise KeyError(f"{self.destination} has no {unit_type} remaining")
-        self.units[unit_type] -= 1
+            raise KeyError(f"{self} has no {unit_type} remaining")
+        if self.units[unit_type] == 1:
+            del self.units[unit_type]
+        else:
+            self.units[unit_type] -= 1
 
     @property
     def size(self) -> int:
-        return sum(c for c in self.units.values())
+        return sum(self.units.values())
 
-    def iter_units(self) -> Iterator[Type[VehicleType]]:
+    def iter_units(self) -> Iterator[GroundUnitType]:
         for unit_type, count in self.units.items():
             for _ in range(count):
                 yield unit_type
 
     @property
     def completed(self) -> bool:
-        return self.destination == self.position or not self.units
+        return self.destination == self.position or not self.size
 
     def disband_at(self, location: ControlPoint) -> None:
         logging.info(f"Units halting at {location}.")
-        location.base.commision_units(self.units)
+        location.base.commission_units(self.units)
         self.units.clear()
 
     @property
@@ -120,22 +130,64 @@ class TransferOrder:
             )
         return self.transport.destination
 
-    def proceed(self) -> None:
-        if self.transport is None:
-            return
+    def find_escape_route(self) -> Optional[ControlPoint]:
+        if self.transport is not None:
+            return self.transport.find_escape_route()
+        return None
 
-        if not self.destination.is_friendly(self.player):
-            logging.info(f"Transfer destination {self.destination} was captured.")
-            if self.position.is_friendly(self.player):
-                self.disband_at(self.position)
-            elif (escape_route := self.transport.find_escape_route()) is not None:
-                self.disband_at(escape_route)
-            else:
+    def disband(self) -> None:
+        """
+        Disbands the specific transfer at the current position if friendly, at a
+        possible escape route or kills all units if none is possible
+        """
+        if self.position.is_friendly(self.player):
+            self.disband_at(self.position)
+        elif (escape_route := self.find_escape_route()) is not None:
+            self.disband_at(escape_route)
+        else:
+            logging.info(
+                f"No escape route available. Units were surrounded and destroyed "
+                "during transfer."
+            )
+            self.kill_all()
+
+    def is_completable(self, network: TransitNetwork) -> bool:
+        """
+        Checks if the transfer can be completed with the current theater state / transit
+        network to ensure that there is possible route between the current position and
+        the planned destination. This also ensures that the points are friendly.
+        """
+        if self.transport is None:
+            # Check if unplanned transfers could be completed
+            if not self.position.is_friendly(self.player):
                 logging.info(
-                    f"No escape route available. Units were surrounded and destroyed "
-                    "during transfer."
+                    f"Current position ({self.position}) "
+                    f"of the halting transfer was captured."
                 )
-                self.kill_all()
+                return False
+            if not network.has_path_between(self.position, self.destination):
+                logging.info(
+                    f"Destination of transfer ({self.destination}) "
+                    f"can not be reached anymore."
+                )
+                return False
+
+        if self.transport is not None and not self.next_stop.is_friendly(self.player):
+            # check if already proceeding transfers can reach the next stop
+            logging.info(
+                f"The next stop of the transfer ({self.next_stop}) "
+                f"was captured while transfer was on route."
+            )
+            return False
+
+        return True
+
+    def proceed(self) -> None:
+        """
+        Let the transfer proceed to the next stop and disbands it if the next stop
+        is the destination
+        """
+        if self.transport is None:
             return
 
         self.position = self.next_stop
@@ -156,7 +208,7 @@ class Airlift(Transport):
         self.flight = flight
 
     @property
-    def units(self) -> Dict[Type[VehicleType], int]:
+    def units(self) -> dict[GroundUnitType, int]:
         return self.transfer.units
 
     @property
@@ -191,9 +243,9 @@ class AirliftPlanner:
         self.package = Package(target=next_stop, auto_asap=True)
 
     def compatible_with_mission(
-        self, unit_type: Type[FlyingType], airfield: ControlPoint
+        self, unit_type: AircraftType, airfield: ControlPoint
     ) -> bool:
-        if not unit_type in TRANSPORT_CAPABLE:
+        if unit_type not in aircraft_for_task(FlightType.TRANSPORT):
             return False
         if not self.transfer.origin.can_operate(unit_type):
             return False
@@ -201,7 +253,7 @@ class AirliftPlanner:
             return False
 
         # Cargo planes have no maximum range.
-        if not unit_type.helicopter:
+        if not unit_type.dcs_unit_type.helicopter:
             return True
 
         # A helicopter that is transport capable and able to operate at both bases. Need
@@ -227,36 +279,46 @@ class AirliftPlanner:
         distance_cache = ObjectiveDistanceCache.get_closest_airfields(
             self.transfer.position
         )
+        air_wing = self.game.air_wing_for(self.for_player)
         for cp in distance_cache.closest_airfields:
             if cp.captured != self.for_player:
                 continue
 
             inventory = self.game.aircraft_inventory.for_control_point(cp)
             for unit_type, available in inventory.all_aircraft:
-                squadrons = [
-                    s
-                    for s in self.game.air_wing_for(self.for_player).squadrons_for(
-                        unit_type
-                    )
-                    if FlightType.TRANSPORT in s.auto_assignable_mission_types
-                ]
-                if not squadrons:
-                    continue
-                squadron = squadrons[0]
-                if self.compatible_with_mission(unit_type, cp):
-                    while available and self.transfer.transport is None:
-                        flight_size = self.create_airlift_flight(squadron, inventory)
-                        available -= flight_size
+                squadrons = air_wing.auto_assignable_for_task_with_type(
+                    unit_type, FlightType.TRANSPORT
+                )
+                for squadron in squadrons:
+                    if self.compatible_with_mission(unit_type, cp):
+                        while (
+                            available
+                            and squadron.has_available_pilots
+                            and self.transfer.transport is None
+                        ):
+                            flight_size = self.create_airlift_flight(
+                                squadron, inventory
+                            )
+                            available -= flight_size
         if self.package.flights:
             self.game.ato_for(self.for_player).add_package(self.package)
 
     def create_airlift_flight(
         self, squadron: Squadron, inventory: ControlPointAircraftInventory
     ) -> int:
-        available = inventory.available(squadron.aircraft)
-        capacity_each = 1 if squadron.aircraft.helicopter else 2
+        available_aircraft = inventory.available(squadron.aircraft)
+        capacity_each = 1 if squadron.aircraft.dcs_unit_type.helicopter else 2
         required = math.ceil(self.transfer.size / capacity_each)
-        flight_size = min(required, available, squadron.aircraft.group_size_max)
+        flight_size = min(
+            required,
+            available_aircraft,
+            squadron.aircraft.dcs_unit_type.group_size_max,
+        )
+        # TODO: Use number_of_available_pilots directly once feature flag is gone.
+        # The number of currently available pilots is not relevant when pilot limits
+        # are disabled.
+        if not squadron.can_provide_pilots(flight_size):
+            flight_size = squadron.number_of_available_pilots
         capacity = flight_size * capacity_each
 
         if capacity < self.transfer.size:
@@ -308,7 +370,7 @@ class MultiGroupTransport(MissionTarget, Transport):
         transfer.transport = None
         self.transfers.remove(transfer)
 
-    def kill_unit(self, unit_type: Type[VehicleType]) -> None:
+    def kill_unit(self, unit_type: GroundUnitType) -> None:
         for transfer in self.transfers:
             try:
                 transfer.kill_unit(unit_type)
@@ -328,16 +390,21 @@ class MultiGroupTransport(MissionTarget, Transport):
 
     @property
     def size(self) -> int:
-        return sum(sum(t.units.values()) for t in self.transfers)
+        return sum(t.size for t in self.transfers)
 
     @property
-    def units(self) -> Dict[Type[VehicleType], int]:
-        units: Dict[Type[VehicleType], int] = defaultdict(int)
+    def units(self) -> dict[GroundUnitType, int]:
+        units: dict[GroundUnitType, int] = defaultdict(int)
         for transfer in self.transfers:
             for unit_type, count in transfer.units.items():
                 units[unit_type] += count
         return units
 
+    def iter_units(self) -> Iterator[GroundUnitType]:
+        for unit_type, count in self.units.items():
+            for _ in range(count):
+                yield unit_type
+
     @property
     def player_owned(self) -> bool:
         return self.origin.captured
@@ -403,8 +470,8 @@ TransportType = TypeVar("TransportType", bound=MultiGroupTransport)
 class TransportMap(Generic[TransportType]):
     def __init__(self) -> None:
         # Dict of origin -> destination -> transport.
-        self.transports: Dict[
-            ControlPoint, Dict[ControlPoint, TransportType]
+        self.transports: dict[
+            ControlPoint, dict[ControlPoint, TransportType]
         ] = defaultdict(dict)
 
     def create_transport(
@@ -458,14 +525,14 @@ class TransportMap(Generic[TransportType]):
             yield from destination_dict.values()
 
 
-class ConvoyMap(TransportMap):
+class ConvoyMap(TransportMap[Convoy]):
     def create_transport(
         self, origin: ControlPoint, destination: ControlPoint
     ) -> Convoy:
         return Convoy(origin, destination)
 
 
-class CargoShipMap(TransportMap):
+class CargoShipMap(TransportMap[CargoShip]):
     def create_transport(
         self, origin: ControlPoint, destination: ControlPoint
     ) -> CargoShip:
@@ -531,8 +598,14 @@ class PendingTransfers:
         self.pending_transfers.append(new_transfer)
         return new_transfer
 
+    # Type checking ignored because singledispatchmethod doesn't work with required type
+    # definitions. The implementation methods are all typed, so should be fine.
     @singledispatchmethod
-    def cancel_transport(self, transport, transfer: TransferOrder) -> None:
+    def cancel_transport(  # type: ignore
+        self,
+        transport,
+        transfer: TransferOrder,
+    ) -> None:
         pass
 
     @cancel_transport.register
@@ -562,9 +635,15 @@ class PendingTransfers:
         if transfer.transport is not None:
             self.cancel_transport(transfer.transport, transfer)
         self.pending_transfers.remove(transfer)
-        transfer.origin.base.commision_units(transfer.units)
+        transfer.origin.base.commission_units(transfer.units)
 
     def perform_transfers(self) -> None:
+        """
+        Performs completable transfers from the list of pending transfers and adds
+        uncompleted transfers which are en route back to the list of pending transfers.
+        Disbands all convoys and cargo ships
+        """
+        self.disband_uncompletable_transfers()
         incomplete = []
         for transfer in self.pending_transfers:
             transfer.proceed()
@@ -575,24 +654,78 @@ class PendingTransfers:
         self.cargo_ships.disband_all()
 
     def plan_transports(self) -> None:
+        """
+        Plan transports for all pending and completable transfers which don't have a
+        transport assigned already. This calculates the shortest path between current
+        position and destination on every execution to ensure the route is adopted to
+        recent changes in the theater state / transit network.
+        """
+        self.disband_uncompletable_transfers()
         for transfer in self.pending_transfers:
             if transfer.transport is None:
                 self.arrange_transport(transfer)
 
+    def disband_uncompletable_transfers(self) -> None:
+        """
+        Disbands all transfers from the list of pending_transfers which can not be
+        completed anymore because the theater state changed or the transit network does
+        not allow a route to the destination anymore
+        """
+        completable_transfers = []
+        for transfer in self.pending_transfers:
+            if not transfer.is_completable(self.network_for(transfer.position)):
+                transfer.disband()
+            else:
+                completable_transfers.append(transfer)
+        self.pending_transfers = completable_transfers
+
     def order_airlift_assets(self) -> None:
         for control_point in self.game.theater.controlpoints:
-            self.order_airlift_assets_at(control_point)
+            if self.game.air_wing_for(control_point.captured).can_auto_plan(
+                FlightType.TRANSPORT
+            ):
+                self.order_airlift_assets_at(control_point)
 
-    @staticmethod
-    def desired_airlift_capacity(control_point: ControlPoint) -> int:
-        return 4 if control_point.has_factory else 0
+    def desired_airlift_capacity(self, control_point: ControlPoint) -> int:
+
+        if control_point.has_factory:
+            is_major_hub = control_point.total_aircraft_parking > 0
+            # Check if there is a CP which is only reachable via Airlift
+            transit_network = self.network_for(control_point)
+            for cp in self.game.theater.control_points_for(control_point.captured):
+                # check if the CP has no factory, is reachable from the current
+                # position and can only be reached with airlift connections
+                if (
+                    cp.can_deploy_ground_units
+                    and not cp.has_factory
+                    and transit_network.has_link(control_point, cp)
+                    and not any(
+                        link_type
+                        for link, link_type in transit_network.nodes[cp].items()
+                        if not link_type == TransitConnection.Airlift
+                    )
+                ):
+                    return 4
+
+                if (
+                    is_major_hub
+                    and cp.has_factory
+                    and cp.total_aircraft_parking > control_point.total_aircraft_parking
+                ):
+                    is_major_hub = False
+
+            if is_major_hub:
+                # If the current CP is a major hub keep always 2 planes on reserve
+                return 2
+
+        return 0
 
     def current_airlift_capacity(self, control_point: ControlPoint) -> int:
         inventory = self.game.aircraft_inventory.for_control_point(control_point)
-        squadrons = self.game.air_wing_for(control_point.captured).squadrons_for_task(
-            FlightType.TRANSPORT
-        )
-        unit_types = {s.aircraft for s in squadrons}.intersection(TRANSPORT_CAPABLE)
+        squadrons = self.game.air_wing_for(
+            control_point.captured
+        ).auto_assignable_for_task(FlightType.TRANSPORT)
+        unit_types = {s.aircraft for s in squadrons}
         return sum(
             count
             for unit_type, count in inventory.all_aircraft
@@ -600,9 +733,16 @@ class PendingTransfers:
         )
 
     def order_airlift_assets_at(self, control_point: ControlPoint) -> None:
-        gap = self.desired_airlift_capacity(
-            control_point
-        ) - self.current_airlift_capacity(control_point)
+        unclaimed_parking = control_point.unclaimed_parking(self.game)
+        # Buy a maximum of unclaimed_parking only to prevent that aircraft procurement
+        # take place at another base
+        gap = min(
+            [
+                self.desired_airlift_capacity(control_point)
+                - self.current_airlift_capacity(control_point),
+                unclaimed_parking,
+            ]
+        )
 
         if gap <= 0:
             return
@@ -612,6 +752,10 @@ class PendingTransfers:
             # aesthetic.
             gap += 1
 
+        if gap > unclaimed_parking:
+            # Prevent to buy more aircraft than possible
+            return
+
         self.game.procurement_requests_for(player=control_point.captured).append(
             AircraftProcurementRequest(
                 control_point, nautical_miles(200), FlightType.TRANSPORT, gap

game/unitdelivery.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 import logging
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Dict, Optional, TYPE_CHECKING, Type
-
-from dcs.unittype import UnitType, VehicleType
+from typing import Optional, TYPE_CHECKING, Any
 
 from game.theater import ControlPoint
-from .db import PRICES
+from .dcs.groundunittype import GroundUnitType
+from .dcs.unittype import UnitType
 from .theater.transitnetwork import (
     NoPathError,
     TransitNetwork,
@@ -29,41 +28,47 @@ class PendingUnitDeliveries:
         self.destination = destination
 
         # Maps unit type to order quantity.
-        self.units: Dict[Type[UnitType], int] = defaultdict(int)
+        self.units: dict[UnitType[Any], int] = defaultdict(int)
 
     def __str__(self) -> str:
         return f"Pending delivery to {self.destination}"
 
-    def order(self, units: Dict[Type[UnitType], int]) -> None:
+    def order(self, units: dict[UnitType[Any], int]) -> None:
         for k, v in units.items():
             self.units[k] += v
 
-    def sell(self, units: Dict[Type[UnitType], int]) -> None:
+    def sell(self, units: dict[UnitType[Any], int]) -> None:
         for k, v in units.items():
             self.units[k] -= v
+            if self.units[k] == 0:
+                del self.units[k]
 
     def refund_all(self, game: Game) -> None:
         self.refund(game, self.units)
         self.units = defaultdict(int)
 
-    def refund(self, game: Game, units: Dict[Type[UnitType], int]) -> None:
+    def refund_ground_units(self, game: Game) -> None:
+        ground_units: dict[UnitType[Any], int] = {
+            u: self.units[u] for u in self.units.keys() if isinstance(u, GroundUnitType)
+        }
+        self.refund(game, ground_units)
+        for gu in ground_units.keys():
+            del self.units[gu]
+
+    def refund(self, game: Game, units: dict[UnitType[Any], int]) -> None:
         for unit_type, count in units.items():
-            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} at {self.destination.name}")
+            game.adjust_budget(
+                unit_type.price * count, player=self.destination.captured
+            )
 
-            logging.info(f"Refunding {count} {unit_type.id} at {self.destination.name}")
-            game.adjust_budget(price * count, player=self.destination.captured)
-
-    def pending_orders(self, unit_type: Type[UnitType]) -> int:
+    def pending_orders(self, unit_type: UnitType[Any]) -> int:
         pending_units = self.units.get(unit_type)
         if pending_units is None:
             pending_units = 0
         return pending_units
 
-    def available_next_turn(self, unit_type: Type[UnitType]) -> int:
+    def available_next_turn(self, unit_type: UnitType[Any]) -> int:
         current_units = self.destination.base.total_units_of_type(unit_type)
         return self.pending_orders(unit_type) + current_units
 
@@ -74,18 +79,16 @@ class PendingUnitDeliveries:
                 f"{self.destination.name} lost its source for ground unit "
                 "reinforcements. Refunding purchase price."
             )
-            self.refund_all(game)
-            return
+            self.refund_ground_units(game)
 
-        bought_units: Dict[Type[UnitType], int] = {}
-        units_needing_transfer: Dict[Type[VehicleType], int] = {}
-        sold_units: Dict[Type[UnitType], int] = {}
+        bought_units: dict[UnitType[Any], int] = {}
+        units_needing_transfer: dict[GroundUnitType, int] = {}
+        sold_units: dict[UnitType[Any], int] = {}
         for unit_type, count in self.units.items():
             coalition = "Ally" if self.destination.captured else "Enemy"
-            name = unit_type.id
-
+            d: dict[Any, int]
             if (
-                issubclass(unit_type, VehicleType)
+                isinstance(unit_type, GroundUnitType)
                 and self.destination != ground_unit_source
             ):
                 source = ground_unit_source
@@ -97,22 +100,27 @@ class PendingUnitDeliveries:
             if count >= 0:
                 d[unit_type] = count
                 game.message(
-                    f"{coalition} reinforcements: {name} x {count} at {source}"
+                    f"{coalition} reinforcements: {unit_type} x {count} at {source}"
                 )
             else:
                 sold_units[unit_type] = -count
-                game.message(f"{coalition} sold: {name} x {-count} at {source}")
+                game.message(f"{coalition} sold: {unit_type} x {-count} at {source}")
 
         self.units = defaultdict(int)
-        self.destination.base.commision_units(bought_units)
+        self.destination.base.commission_units(bought_units)
         self.destination.base.commit_losses(sold_units)
 
         if units_needing_transfer:
-            ground_unit_source.base.commision_units(units_needing_transfer)
+            if ground_unit_source is None:
+                raise RuntimeError(
+                    f"ground unit source could not be found for {self.destination} but still tried to "
+                    f"transfer units to there"
+                )
+            ground_unit_source.base.commission_units(units_needing_transfer)
             self.create_transfer(game, ground_unit_source, units_needing_transfer)
 
     def create_transfer(
-        self, game: Game, source: ControlPoint, units: Dict[Type[VehicleType], int]
+        self, game: Game, source: ControlPoint, units: dict[GroundUnitType, int]
     ) -> None:
         game.transfers.new_transfer(TransferOrder(source, self.destination, units))
 

game/unitmap.py

@@ -2,13 +2,12 @@
 import itertools
 import math
 from dataclasses import dataclass
-from typing import Dict, Optional, Type
+from typing import Dict, Optional, Any, Union, TypeVar, Generic
 
-from dcs.unit import Unit
-from dcs.unitgroup import FlyingGroup, Group, VehicleGroup
-from dcs.unittype import VehicleType
+from dcs.unit import Vehicle, Ship
+from dcs.unitgroup import FlyingGroup, VehicleGroup, StaticGroup, ShipGroup, MovingGroup
 
-from game import db
+from game.dcs.groundunittype import GroundUnitType
 from game.squadrons import Pilot
 from game.theater import Airfield, ControlPoint, TheaterGroundObject
 from game.theater.theatergroundobject import BuildingGroundObject, SceneryGroundObject
@@ -19,31 +18,34 @@ from gen.flights.flight import Flight
 @dataclass(frozen=True)
 class FlyingUnit:
     flight: Flight
-    pilot: Pilot
+    pilot: Optional[Pilot]
 
 
 @dataclass(frozen=True)
 class FrontLineUnit:
-    unit_type: Type[VehicleType]
+    unit_type: GroundUnitType
     origin: ControlPoint
 
 
+UnitT = TypeVar("UnitT", Ship, Vehicle)
+
+
 @dataclass(frozen=True)
-class GroundObjectUnit:
-    ground_object: TheaterGroundObject
-    group: Group
-    unit: Unit
+class GroundObjectUnit(Generic[UnitT]):
+    ground_object: TheaterGroundObject[Any]
+    group: MovingGroup[UnitT]
+    unit: UnitT
 
 
 @dataclass(frozen=True)
 class ConvoyUnit:
-    unit_type: Type[VehicleType]
+    unit_type: GroundUnitType
     convoy: Convoy
 
 
 @dataclass(frozen=True)
 class AirliftUnits:
-    cargo: tuple[Type[VehicleType], ...]
+    cargo: tuple[GroundUnitType, ...]
     transfer: TransferOrder
 
 
@@ -57,21 +59,19 @@ class UnitMap:
         self.aircraft: Dict[str, FlyingUnit] = {}
         self.airfields: Dict[str, Airfield] = {}
         self.front_line_units: Dict[str, FrontLineUnit] = {}
-        self.ground_object_units: Dict[str, GroundObjectUnit] = {}
+        self.ground_object_units: Dict[str, GroundObjectUnit[Any]] = {}
         self.buildings: Dict[str, Building] = {}
         self.convoys: Dict[str, ConvoyUnit] = {}
         self.cargo_ships: Dict[str, CargoShip] = {}
         self.airlifts: Dict[str, AirliftUnits] = {}
 
-    def add_aircraft(self, group: FlyingGroup, flight: Flight) -> None:
+    def add_aircraft(self, group: FlyingGroup[Any], flight: Flight) -> None:
         for pilot, unit in zip(flight.roster.pilots, 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}")
-            if pilot is None:
-                raise ValueError(f"{name} has no pilot assigned")
             self.aircraft[name] = FlyingUnit(flight, pilot)
         if flight.cargo is not None:
             self.add_airlift_units(group, flight.cargo)
@@ -87,20 +87,15 @@ class UnitMap:
     def airfield(self, name: str) -> Optional[Airfield]:
         return self.airfields.get(name, None)
 
-    def add_front_line_units(self, group: Group, origin: ControlPoint) -> None:
+    def add_front_line_units(
+        self, group: VehicleGroup, origin: ControlPoint, unit_type: GroundUnitType
+    ) -> 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]:
@@ -108,9 +103,9 @@ class UnitMap:
 
     def add_ground_object_units(
         self,
-        ground_object: TheaterGroundObject,
-        persistence_group: Group,
-        miz_group: Group,
+        ground_object: TheaterGroundObject[Any],
+        persistence_group: Union[ShipGroup, VehicleGroup],
+        miz_group: Union[ShipGroup, VehicleGroup],
     ) -> None:
         """Adds a group associated with a TGO to the unit map.
 
@@ -139,29 +134,22 @@ class UnitMap:
                 ground_object, persistence_group, persistent_unit
             )
 
-    def ground_object_unit(self, name: str) -> Optional[GroundObjectUnit]:
+    def ground_object_unit(self, name: str) -> Optional[GroundObjectUnit[Any]]:
         return self.ground_object_units.get(name, None)
 
-    def add_convoy_units(self, group: Group, convoy: Convoy) -> None:
-        for unit in group.units:
+    def add_convoy_units(self, group: VehicleGroup, convoy: Convoy) -> None:
+        for unit, unit_type in zip(group.units, convoy.iter_units()):
             # The actual name is a String (the pydcs translatable string), which
             # doesn't define __eq__.
             name = str(unit.name)
             if name in self.convoys:
                 raise RuntimeError(f"Duplicate convoy 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.convoys[name] = ConvoyUnit(unit_type, convoy)
 
     def convoy_unit(self, name: str) -> Optional[ConvoyUnit]:
         return self.convoys.get(name, None)
 
-    def add_cargo_ship(self, group: Group, ship: CargoShip) -> None:
+    def add_cargo_ship(self, group: ShipGroup, ship: CargoShip) -> None:
         if len(group.units) > 1:
             # Cargo ship "groups" are single units. Killing the one ship kills the whole
             # transfer. If we ever want to add escorts or create multiple cargo ships in
@@ -178,7 +166,9 @@ class UnitMap:
     def cargo_ship(self, name: str) -> Optional[CargoShip]:
         return self.cargo_ships.get(name, None)
 
-    def add_airlift_units(self, group: FlyingGroup, transfer: TransferOrder) -> None:
+    def add_airlift_units(
+        self, group: FlyingGroup[Any], transfer: TransferOrder
+    ) -> None:
         capacity_each = math.ceil(transfer.size / len(group.units))
         for idx, transport in enumerate(group.units):
             # Slice the units in groups based on the capacity of each unit. Cargo is
@@ -201,7 +191,9 @@ class UnitMap:
     def airlift_unit(self, name: str) -> Optional[AirliftUnits]:
         return self.airlifts.get(name, None)
 
-    def add_building(self, ground_object: BuildingGroundObject, group: Group) -> None:
+    def add_building(
+        self, ground_object: BuildingGroundObject, group: StaticGroup
+    ) -> 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"

game/utils.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import itertools
 import math
+from collections import Iterable
 from dataclasses import dataclass
-from typing import Union
+from typing import Union, Any
 
 METERS_TO_FEET = 3.28084
 FEET_TO_METERS = 1 / METERS_TO_FEET
@@ -16,17 +17,12 @@ MS_TO_KPH = 3.6
 KPH_TO_MS = 1 / MS_TO_KPH
 
 
-def heading_sum(h, a) -> int:
+def heading_sum(h: int, a: int) -> int:
     h += a
-    if h > 360:
-        return h - 360
-    elif h < 0:
-        return 360 + h
-    else:
-        return h
+    return h % 360
 
 
-def opposite_heading(h):
+def opposite_heading(h: int) -> int:
     return heading_sum(h, 180)
 
 
@@ -58,6 +54,10 @@ class Distance:
     def from_nautical_miles(cls, value: float) -> Distance:
         return cls(value * NM_TO_METERS)
 
+    @classmethod
+    def inf(cls) -> Distance:
+        return cls.from_meters(math.inf)
+
     def __add__(self, other: Distance) -> Distance:
         return meters(self.meters + other.meters)
 
@@ -181,7 +181,7 @@ def mach(value: float, altitude: Distance) -> Speed:
 SPEED_OF_SOUND_AT_SEA_LEVEL = knots(661.5)
 
 
-def pairwise(iterable):
+def pairwise(iterable: Iterable[Any]) -> Iterable[tuple[Any, Any]]:
     """
     itertools recipe
     s -> (s0,s1), (s1,s2), (s2, s3), ...

game/version.py

@@ -1,11 +1,18 @@
 from pathlib import Path
 
 
+MAJOR_VERSION = 4
+MINOR_VERSION = 1
+MICRO_VERSION = 2
+
+
 def _build_version_string() -> str:
-    components = ["3.0"]
+    components = [
+        ".".join(str(v) for v in (MAJOR_VERSION, MINOR_VERSION, MICRO_VERSION))
+    ]
     build_number_path = Path("resources/buildnumber")
     if build_number_path.exists():
-        with build_number_path.open("r") as build_number_file:
+        with build_number_path.open("r", encoding="utf-8") as build_number_file:
             components.append(build_number_file.readline())
 
     if not Path("resources/final").exists():
@@ -70,9 +77,9 @@ VERSION = _build_version_string()
 #: Version 4.2
 #: * Adds support for AAA objectives. Place with any of the following units (either red
 #:   or blue):
-#:     * AAA_8_8cm_Flak_18,
-#:     * SPAAA_Vulcan_M163,
-#:     * SPAAA_ZSU_23_4_Shilka_Gun_Dish,
+#:     * Flak18,
+#:     * Vulcan,
+#:     * ZSU_23_4_Shilka,
 #:
 #: Version 5.0
 #: * Ammunition Depots objective locations are now predetermined using the "Ammunition
@@ -87,4 +94,20 @@ VERSION = _build_version_string()
 #: Version 6.0
 #: * Random objective generation no is longer supported. Fixed objective locations were
 #:   added in 4.1.
-CAMPAIGN_FORMAT_VERSION = (6, 0)
+#:
+#: Version 6.1
+#: * Support for new Syrian airfields in DCS 2.7.2.7910.1 (Cyprus update).
+#:
+#: Version 7.0
+#: * DCS 2.7.2.7910.1 (Cyprus update) changed the IDs of scenery strike targets. Any
+#:   mission using map buildings as strike targets must check and potentially recreate
+#:   all those objectives. This definitely affects all Syria campaigns, other maps are
+#:   not yet verified.
+#:
+#: Version 7.1
+#: * Support for Mariana Islands terrain
+#:
+#: Version 8.0
+#: * DCS 2.7.4.9632 changed scenery target IDs. Any mission using map buildings as
+#:   strike targets must check and potentially recreate all those objectives.
+CAMPAIGN_FORMAT_VERSION = (8, 0)

game/weather.py

@@ -83,7 +83,7 @@ class Weather:
         raise NotImplementedError
 
     @staticmethod
-    def random_wind(minimum: int, maximum) -> WindConditions:
+    def random_wind(minimum: int, maximum: int) -> WindConditions:
         wind_direction = random.randint(0, 360)
         at_0m_factor = 1
         at_2000m_factor = 2

gen/airfields.py

@@ -674,7 +674,7 @@ AIRFIELD_DATA = {
         vor=("DAN", MHz(108, 400)),
         atc=AtcData(MHz(3, 900), MHz(38, 700), MHz(122, 100), MHz(360, 100)),
         ils={
-            "50": ("IDAN", MHz(109, 300)),
+            "05": ("IDAN", MHz(109, 300)),
             "23": ("DANM", MHz(111, 700)),
         },
     ),
@@ -966,7 +966,96 @@ AIRFIELD_DATA = {
         runway_length=8871,
         atc=AtcData(MHz(3, 775), MHz(38, 450), MHz(120, 100), MHz(250, 50)),
         ils={
-            "28": ("IGNP", MHz(109, 10)),
+            "28": ("IGNP", MHz(109, 100)),
+        },
+    ),
+    "Gecitkale": AirfieldData(
+        theater="Syria",
+        icao="LCGK",
+        elevation=147,
+        runway_length=8156,
+        vor=("GKE", MHz(114, 300)),
+        atc=AtcData(MHz(3, 775), MHz(4, 800), MHz(40, 500), MHz(252, 50)),
+    ),
+    "Kingsfield": AirfieldData(
+        theater="Syria",
+        icao="CY-0004",
+        elevation=270,
+        runway_length=3069,
+        atc=AtcData(MHz(4, 650), MHz(40, 200), MHz(121), MHz(251, 750)),
+    ),
+    "Larnaca": AirfieldData(
+        theater="Syria",
+        icao="LCRE",
+        elevation=16,
+        runway_length=8009,
+        vor=("LCA", MHz(112, 80)),
+        atc=AtcData(MHz(4, 700), MHz(40, 300), MHz(121, 200), MHz(251, 850)),
+        ils={
+            "22": ("ILC", MHz(110, 300)),
+        },
+    ),
+    "Ercan": AirfieldData(
+        theater="Syria",
+        icao="LCEN",
+        elevation=383,
+        runway_length=7559,
+        vor=("ECN", MHz(117)),
+        atc=AtcData(MHz(4, 750), MHz(40, 400), MHz(120, 200), MHz(251, 950)),
+    ),
+    "Lakatamia": AirfieldData(
+        theater="Syria",
+        icao="CY-0001",
+        elevation=757,
+        runway_length=1230,
+        atc=AtcData(MHz(4, 725), MHz(40, 350), MHz(120, 200), MHz(251, 900)),
+    ),
+    "Nicosia": AirfieldData(
+        theater="Syria",
+        icao="LCNC",
+        elevation=716,
+        runway_length=0,
+    ),
+    "Pinarbashi": AirfieldData(
+        theater="Syria",
+        icao="CY-0003",
+        elevation=770,
+        runway_length=3364,
+        atc=AtcData(MHz(4, 825), MHz(40, 550), MHz(121), MHz(252, 100)),
+    ),
+    "Akrotiri": AirfieldData(
+        theater="Syria",
+        icao="LCRA",
+        elevation=62,
+        runway_length=8276,
+        tacan=TacanChannel(107, TacanBand.X),
+        tacan_callsign="AKR",
+        vor=("AKR", MHz(116)),
+        atc=AtcData(MHz(4, 625), MHz(40, 150), MHz(128), MHz(251, 700)),
+        ils={
+            "28": ("IAK", MHz(109, 700)),
+        },
+    ),
+    "Paphos": AirfieldData(
+        theater="Syria",
+        icao="LCPH",
+        elevation=40,
+        runway_length=8425,
+        vor=("PHA", MHz(117, 900)),
+        atc=AtcData(MHz(4, 675), MHz(40, 250), MHz(119, 900), MHz(251, 800)),
+        ils={
+            "29": ("IPA", MHz(108, 900)),
+        },
+    ),
+    "Gazipasa": AirfieldData(
+        theater="Syria",
+        icao="LTFG",
+        elevation=36,
+        runway_length=6885,
+        vor=("GZP", MHz(114, 200)),
+        atc=AtcData(MHz(4, 600), MHz(40, 100), MHz(119, 250), MHz(251, 650)),
+        ils={
+            "8": ("IGZP", MHz(108, 500)),
         },
     ),
     # NTTR
@@ -1432,4 +1521,47 @@ AIRFIELD_DATA = {
         runway_length=3953,
         atc=AtcData(MHz(3, 850), MHz(118, 200), MHz(38, 600), MHz(250, 200)),
     ),
+    "Antonio B. Won Pat Intl": AirfieldData(
+        theater="MarianaIslands",
+        icao="PGUM",
+        elevation=255,
+        runway_length=9359,
+        atc=AtcData(MHz(3, 825), MHz(118, 100), MHz(38, 550), MHz(340, 200)),
+        ils={
+            "06": ("IGUM", MHz(110, 30)),
+        },
+    ),
+    "Andersen AFB": AirfieldData(
+        theater="MarianaIslands",
+        icao="PGUA",
+        elevation=545,
+        runway_length=10490,
+        tacan=TacanChannel(54, TacanBand.X),
+        tacan_callsign="UAM",
+        atc=AtcData(MHz(3, 850), MHz(126, 200), MHz(38, 600), MHz(250, 100)),
+    ),
+    "Rota Intl": AirfieldData(
+        theater="MarianaIslands",
+        icao="PGRO",
+        elevation=568,
+        runway_length=6105,
+        atc=AtcData(MHz(3, 750), MHz(123, 600), MHz(38, 400), MHz(250, 0)),
+    ),
+    "Tinian Intl": AirfieldData(
+        theater="MarianaIslands",
+        icao="PGWT",
+        elevation=240,
+        runway_length=7777,
+        atc=AtcData(MHz(3, 800), MHz(123, 650), MHz(38, 500), MHz(250, 50)),
+    ),
+    "Saipan Intl": AirfieldData(
+        theater="MarianaIslands",
+        icao="PGSN",
+        elevation=213,
+        runway_length=7790,
+        atc=AtcData(MHz(3, 775), MHz(125, 700), MHz(38, 450), MHz(256, 900)),
+        ils={
+            "07": ("IGSN", MHz(109, 90)),
+        },
+    ),
 }

gen/airsupportgen.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
+
 import logging
 from dataclasses import dataclass, field
 from datetime import timedelta
-from typing import List, Type, Tuple, Optional
+from typing import List, Type, Tuple, Optional, TYPE_CHECKING
 
 from dcs.mission import Mission, StartType
-from dcs.planes import IL_78M, KC130, KC135MPRS, KC_135
-from dcs.unittype import UnitType
+from dcs.planes import IL_78M, KC130, KC135MPRS, KC_135, PlaneType
 from dcs.task import (
     AWACS,
     ActivateBeaconCommand,
@@ -14,14 +15,17 @@ from dcs.task import (
     SetImmortalCommand,
     SetInvisibleCommand,
 )
+from dcs.unittype import UnitType
 
-from game import db
-from .naming import namegen
 from .callsigns import callsign_for_support_unit
 from .conflictgen import Conflict
+from .flights.ai_flight_planner_db import AEWC_CAPABLE
+from .naming import namegen
 from .radios import RadioFrequency, RadioRegistry
 from .tacan import TacanBand, TacanChannel, TacanRegistry
 
+if TYPE_CHECKING:
+    from game import Game
 
 TANKER_DISTANCE = 15000
 TANKER_ALT = 4572
@@ -53,6 +57,8 @@ class TankerInfo:
     variant: str
     freq: RadioFrequency
     tacan: TacanChannel
+    start_time: Optional[timedelta]
+    end_time: Optional[timedelta]
     blue: bool
 
 
@@ -67,7 +73,7 @@ class AirSupportConflictGenerator:
         self,
         mission: Mission,
         conflict: Conflict,
-        game,
+        game: Game,
         radio_registry: RadioRegistry,
         tacan_registry: TacanRegistry,
     ) -> None:
@@ -92,127 +98,145 @@ class AirSupportConflictGenerator:
             return (TANKER_ALT + 500, 596)
         return (TANKER_ALT, 574)
 
-    def generate(self):
+    def generate(self) -> None:
         player_cp = (
             self.conflict.blue_cp
             if self.conflict.blue_cp.captured
             else self.conflict.red_cp
         )
 
-        fallback_tanker_number = 0
+        if not self.game.settings.disable_legacy_tanker:
+            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.red_cp.position.heading_between_point(
-                    self.conflict.blue_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)
+            for i, tanker_unit_type in enumerate(
+                self.game.faction_for(player=True).tankers
+            ):
+                unit_type = tanker_unit_type.dcs_unit_type
+                if not issubclass(unit_type, PlaneType):
+                    logging.warning(f"Refueling aircraft {unit_type} must be a plane")
+                    continue
 
-            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,
-                    blue=True,
-                )
-            )
-
-        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]
+                # TODO: Make loiter altitude a property of the unit type.
+                alt, airspeed = self._get_tanker_params(tanker_unit_type.dcs_unit_type)
                 freq = self.radio_registry.alloc_uhf()
-
-                awacs_flight = self.mission.awacs_flight(
+                tacan = self.tacan_registry.alloc_for_band(TacanBand.Y)
+                tanker_heading = (
+                    self.conflict.red_cp.position.heading_between_point(
+                        self.conflict.blue_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_awacs_name(
-                        self.mission.country(self.game.player_country)
+                    name=namegen.next_tanker_name(
+                        self.mission.country(self.game.player_country), tanker_unit_type
                     ),
-                    plane_type=awacs_unit,
-                    altitude=AWACS_ALT,
                     airport=None,
-                    position=self.conflict.position.random_point_within(
-                        AWACS_DISTANCE, AWACS_DISTANCE
-                    ),
+                    plane_type=unit_type,
+                    position=tanker_position,
+                    altitude=alt,
+                    race_distance=58000,
                     frequency=freq.mhz,
                     start_type=StartType.Warm,
+                    speed=airspeed,
+                    tacanchannel=str(tacan),
                 )
-                awacs_flight.set_frequency(freq.mhz)
+                tanker_group.set_frequency(freq.mhz)
 
-                awacs_flight.points[0].tasks.append(SetInvisibleCommand(True))
-                awacs_flight.points[0].tasks.append(SetImmortalCommand(True))
+                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
 
-                self.air_support.awacs.append(
-                    AwacsInfo(
-                        group_name=str(awacs_flight.name),
-                        callsign=callsign_for_support_unit(awacs_flight),
-                        freq=freq,
-                        depature_location=None,
+                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,
+                        tanker_unit_type.name,
+                        freq,
+                        tacan,
                         start_time=None,
                         end_time=None,
                         blue=True,
                     )
                 )
-            else:
+
+        if not self.game.settings.disable_legacy_aewc:
+            possible_awacs = [
+                a
+                for a in self.game.faction_for(player=True).aircrafts
+                if a in AEWC_CAPABLE
+            ]
+
+            if not possible_awacs:
                 logging.warning("No AWACS for faction")
+                return
+
+            awacs_unit = possible_awacs[0]
+            freq = self.radio_registry.alloc_uhf()
+
+            unit_type = awacs_unit.dcs_unit_type
+            if not issubclass(unit_type, PlaneType):
+                logging.warning(f"AWACS aircraft {unit_type} must be a plane")
+                return
+
+            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=unit_type,
+                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(
+                    group_name=str(awacs_flight.name),
+                    callsign=callsign_for_support_unit(awacs_flight),
+                    freq=freq,
+                    depature_location=None,
+                    start_time=None,
+                    end_time=None,
+                    blue=True,
+                )
+            )

gen/armor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import math
 import random
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, List, Optional, Tuple
@@ -10,7 +11,6 @@ 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,
@@ -24,20 +24,20 @@ from dcs.task import (
     SetInvisibleCommand,
 )
 from dcs.triggers import Event, TriggerOnce
-from dcs.unit import Vehicle
+from dcs.unit import Vehicle, Skill
 from dcs.unitgroup import VehicleGroup
-from dcs.unittype import VehicleType
-from game import db
+
+from game.data.groundunitclass import GroundUnitClass
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.groundunittype import GroundUnitType
+from game.theater.controlpoint import ControlPoint
 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
@@ -98,7 +98,7 @@ class GroundConflictGenerator:
         self.unit_map = unit_map
         self.jtacs: List[JtacInfo] = []
 
-    def _enemy_stance(self):
+    def _enemy_stance(self) -> CombatStance:
         """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
@@ -123,20 +123,11 @@ class GroundConflictGenerator:
                 ]
             )
 
-    @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):
+    def generate(self) -> None:
         position = Conflict.frontline_position(
             self.conflict.front_line, self.game.theater
         )
+
         frontline_vector = Conflict.frontline_vector(
             self.conflict.front_line, self.game.theater
         )
@@ -151,6 +142,13 @@ class GroundConflictGenerator:
             self.enemy_planned_combat_groups, frontline_vector, False
         )
 
+        # TODO: Differentiate AirConflict and GroundConflict classes.
+        if self.conflict.heading is None:
+            raise RuntimeError(
+                "Cannot generate ground units for non-ground conflict. Ground unit "
+                "conflicts cannot have the heading `None`."
+            )
+
         # Plan combat actions for groups
         self.plan_action_for_groups(
             self.player_stance,
@@ -174,14 +172,14 @@ class GroundConflictGenerator:
             n = "JTAC" + str(self.conflict.blue_cp.id) + str(self.conflict.red_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
+            utype = self.game.player_faction.jtac_unit
+            if utype is None:
+                utype = AircraftType.named("MQ-9 Reaper")
 
             jtac = self.mission.flight_group(
                 country=self.mission.country(self.game.player_country),
                 name=n,
-                aircraft_type=utype,
+                aircraft_type=utype.dcs_unit_type,
                 position=position[0],
                 airport=None,
                 altitude=5000,
@@ -225,23 +223,22 @@ class GroundConflictGenerator:
         else:
             cp = self.conflict.red_cp
 
-        if is_player:
-            faction = self.game.player_name
-        else:
-            faction = self.game.enemy_name
+        faction = self.game.faction_for(is_player)
 
         # 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)
+                    manpads = list(faction.infantry_with_class(GroundUnitClass.Manpads))
+                    if manpads:
+                        u = random.choices(
+                            manpads, weights=[m.spawn_weight for m in manpads]
+                        )[0]
                         self.mission.vehicle_group(
                             side,
                             namegen.next_infantry_name(side, cp.id, u),
-                            u,
+                            u.dcs_unit_type,
                             position=infantry_position,
                             group_size=1,
                             heading=forward_heading,
@@ -249,30 +246,38 @@ class GroundConflictGenerator:
                         )
             return
 
-        possible_infantry_units = db.find_infantry(
-            faction, allow_manpad=self.game.settings.manpads
+        possible_infantry_units = set(
+            faction.infantry_with_class(GroundUnitClass.Infantry)
         )
-        if len(possible_infantry_units) == 0:
+        if self.game.settings.manpads:
+            possible_infantry_units |= set(
+                faction.infantry_with_class(GroundUnitClass.Manpads)
+            )
+        if not possible_infantry_units:
             return
 
-        u = random.choice(possible_infantry_units)
+        infantry_choices = list(possible_infantry_units)
+        units = random.choices(
+            infantry_choices,
+            weights=[u.spawn_weight for u in infantry_choices],
+            k=INFANTRY_GROUP_SIZE,
+        )
         self.mission.vehicle_group(
             side,
-            namegen.next_infantry_name(side, cp.id, u),
-            u,
+            namegen.next_infantry_name(side, cp.id, units[0]),
+            units[0].dcs_unit_type,
             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)
+        for unit in units[1:]:
             position = infantry_position.random_point_within(55, 5)
             self.mission.vehicle_group(
                 side,
-                namegen.next_infantry_name(side, cp.id, u),
-                u,
+                namegen.next_infantry_name(side, cp.id, unit),
+                unit.dcs_unit_type,
                 position=position,
                 group_size=1,
                 heading=forward_heading,
@@ -312,7 +317,7 @@ class GroundConflictGenerator:
         )
         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 = FireAtPoint(target, gen_group.size * 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)))
@@ -355,7 +360,6 @@ class GroundConflictGenerator:
             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
@@ -502,7 +506,7 @@ class GroundConflictGenerator:
             return
 
         for dcs_group, group in ally_groups:
-            if hasattr(group.units[0], "eplrs") and group.units[0].eplrs:
+            if group.unit_type.eplrs_capable:
                 dcs_group.points[0].tasks.append(EPLRS(dcs_group.id))
 
             if group.role == CombatGroupRole.ARTILLERY:
@@ -564,10 +568,10 @@ class GroundConflictGenerator:
         )
 
         # Fallback task
-        fallback = ControlledTask(GoToWaypoint(to_index=len(dcs_group.points)))
-        fallback.enabled = False
+        task = ControlledTask(GoToWaypoint(to_index=len(dcs_group.points)))
+        task.enabled = False
         dcs_group.add_trigger_action(Hold())
-        dcs_group.add_trigger_action(fallback)
+        dcs_group.add_trigger_action(task)
 
         # Create trigger
         fallback = TriggerOnce(Event.NoEvent, "Morale manager #" + str(dcs_group.id))
@@ -628,7 +632,7 @@ class GroundConflictGenerator:
         @param enemy_groups Potential enemy groups
         @param n number of nearby groups to take
         """
-        targets = []  # type: List[Optional[VehicleGroup]]
+        targets = []  # type: List[VehicleGroup]
         sorted_list = sorted(
             enemy_groups,
             key=lambda group: player_group.points[0].position.distance_to_point(
@@ -652,7 +656,7 @@ class GroundConflictGenerator:
         @param group Group for which we should find the nearest ennemy
         @param enemy_groups Potential enemy groups
         """
-        min_distance = 99999999
+        min_distance = math.inf
         target = None
         for dcs_group, _ in enemy_groups:
             dist = player_group.points[0].position.distance_to_point(
@@ -673,7 +677,7 @@ class GroundConflictGenerator:
         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
+        rng = getattr(group.unit_type.dcs_unit_type, "threat_range", 0)
         if not enemy_groups:
             return None
         for _ in range(10):
@@ -690,7 +694,7 @@ class GroundConflictGenerator:
         """
         For artilery group, decide the distance from frontline with the range of the unit
         """
-        rg = group.units[0].threat_range - 7500
+        rg = group.unit_type.dcs_unit_type.threat_range - 7500
         if rg > DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][1]:
             rg = random.randint(
                 DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY][0],
@@ -710,7 +714,7 @@ class GroundConflictGenerator:
         distance_from_frontline: int,
         heading: int,
         spawn_heading: int,
-    ):
+    ) -> Optional[Point]:
         shifted = conflict_position.point_from_heading(
             heading, random.randint(0, combat_width)
         )
@@ -723,7 +727,7 @@ class GroundConflictGenerator:
 
     def _generate_groups(
         self,
-        groups: List[CombatGroup],
+        groups: list[CombatGroup],
         frontline_vector: Tuple[Point, int, int],
         is_player: bool,
     ) -> List[Tuple[VehicleGroup, CombatGroup]]:
@@ -754,16 +758,15 @@ class GroundConflictGenerator:
             if final_position is not None:
                 g = self._generate_group(
                     self.mission.country(country),
-                    group.units[0],
-                    len(group.units),
+                    group.unit_type,
+                    group.size,
                     final_position,
-                    distance_from_frontline,
                     heading=opposite_heading(spawn_heading),
                 )
                 if is_player:
-                    g.set_skill(self.game.settings.player_skill)
+                    g.set_skill(Skill(self.game.settings.player_skill))
                 else:
-                    g.set_skill(self.game.settings.enemy_vehicle_skill)
+                    g.set_skill(Skill(self.game.settings.enemy_vehicle_skill))
                 positioned_groups.append((g, group))
 
                 if group.role in [CombatGroupRole.APC, CombatGroupRole.IFV]:
@@ -781,12 +784,11 @@ class GroundConflictGenerator:
     def _generate_group(
         self,
         side: Country,
-        unit: VehicleType,
+        unit_type: GroundUnitType,
         count: int,
         at: Point,
-        distance_from_frontline,
         move_formation: PointAction = PointAction.OffRoad,
-        heading=0,
+        heading: int = 0,
     ) -> VehicleGroup:
 
         if side == self.conflict.attackers_country:
@@ -794,18 +796,17 @@ class GroundConflictGenerator:
         else:
             cp = self.conflict.red_cp
 
-        logging.info("armorgen: {} for {}".format(unit, side.id))
         group = self.mission.vehicle_group(
             side,
-            namegen.next_unit_name(side, cp.id, unit),
-            unit,
+            namegen.next_unit_name(side, cp.id, unit_type),
+            unit_type.dcs_unit_type,
             position=at,
             group_size=count,
             heading=heading,
             move_formation=move_formation,
         )
 
-        self.unit_map.add_front_line_units(group, cp)
+        self.unit_map.add_front_line_units(group, cp, unit_type)
 
         for c in range(count):
             vehicle: Vehicle = group.units[c]

gen/ato.py

@@ -168,9 +168,10 @@ class Package:
         # 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 = [
+        # flight with strike and SEAD is an OCA/Strike package. This list defines the
+        # priority order for package task names. The package's primary task will be the
+        # first task in this list that matches a flight in the package.
+        tasks_by_priority = [
             FlightType.CAS,
             FlightType.STRIKE,
             FlightType.ANTISHIP,
@@ -183,10 +184,11 @@ class Package:
             FlightType.TARCAP,
             FlightType.BARCAP,
             FlightType.AEWC,
+            FlightType.REFUELING,
             FlightType.SWEEP,
             FlightType.ESCORT,
         ]
-        for task in task_priorities:
+        for task in tasks_by_priority:
             if flight_counts[task]:
                 return task
 

gen/callsigns.py

@@ -1,12 +1,13 @@
 """Support for working with DCS group callsigns."""
 import logging
 import re
+from typing import Any
 
 from dcs.unitgroup import FlyingGroup
 from dcs.flyingunit import FlyingUnit
 
 
-def callsign_for_support_unit(group: FlyingGroup) -> str:
+def callsign_for_support_unit(group: FlyingGroup[Any]) -> str:
     # Either something like Overlord11 for Western AWACS, or else just a number.
     # Convert to either "Overlord" or "Flight 123".
     lead = group.units[0]

gen/cargoshipgen.py

@@ -4,7 +4,7 @@ import itertools
 from typing import TYPE_CHECKING
 
 from dcs import Mission
-from dcs.ships import Bulker_Handy_Wind
+from dcs.ships import HandyWind
 from dcs.unitgroup import ShipGroup
 
 from game.transfers import CargoShip
@@ -35,7 +35,7 @@ class CargoShipGenerator:
         group = self.mission.ship_group(
             country,
             ship.name,
-            Bulker_Handy_Wind,
+            HandyWind,
             position=waypoints[0],
             group_size=1,
         )

gen/coastal/coastal_group_generator.py

@@ -1,6 +1,11 @@
 import logging
 import random
-from game import db
+from typing import Optional
+
+from dcs.unitgroup import VehicleGroup
+
+from game import db, Game
+from game.theater.theatergroundobject import CoastalSiteGroundObject
 from gen.coastal.silkworm import SilkwormGenerator
 
 COASTAL_MAP = {
@@ -8,10 +13,13 @@ COASTAL_MAP = {
 }
 
 
-def generate_coastal_group(game, ground_object, faction_name: str):
+def generate_coastal_group(
+    game: Game, ground_object: CoastalSiteGroundObject, faction_name: str
+) -> Optional[VehicleGroup]:
     """
     This generate a coastal defenses group
-    :return: Nothing, but put the group reference inside the ground object
+    :return: The generated group, or None if this faction does not support coastal
+    defenses.
     """
     faction = db.FACTIONS[faction_name]
     if len(faction.coastal_defenses) > 0:

gen/coastal/silkworm.py

@@ -1,19 +1,24 @@
 from dcs.vehicles import MissilesSS, Unarmed, AirDefence
 
-from gen.sam.group_generator import GroupGenerator
+from game import Game
+from game.factions.faction import Faction
+from game.theater.theatergroundobject import CoastalSiteGroundObject
+from gen.sam.group_generator import VehicleGroupGenerator
 
 
-class SilkwormGenerator(GroupGenerator):
-    def __init__(self, game, ground_object, faction):
+class SilkwormGenerator(VehicleGroupGenerator[CoastalSiteGroundObject]):
+    def __init__(
+        self, game: Game, ground_object: CoastalSiteGroundObject, faction: Faction
+    ) -> None:
         super(SilkwormGenerator, self).__init__(game, ground_object)
         self.faction = faction
 
-    def generate(self):
+    def generate(self) -> None:
 
         positions = self.get_circular_position(5, launcher_distance=120, coverage=180)
 
         self.add_unit(
-            MissilesSS.AShM_Silkworm_SR,
+            MissilesSS.Silkworm_SR,
             "SR#0",
             self.position.x,
             self.position.y,
@@ -23,7 +28,7 @@ class SilkwormGenerator(GroupGenerator):
         # Launchers
         for i, p in enumerate(positions):
             self.add_unit(
-                MissilesSS.AShM_SS_N_2_Silkworm,
+                MissilesSS.Hy_launcher,
                 "Missile#" + str(i),
                 p[0],
                 p[1],
@@ -32,7 +37,7 @@ class SilkwormGenerator(GroupGenerator):
 
         # Commander
         self.add_unit(
-            Unarmed.Truck_KAMAZ_43101,
+            Unarmed.KAMAZ_Truck,
             "KAMAZ#0",
             self.position.x - 35,
             self.position.y - 20,
@@ -41,7 +46,7 @@ class SilkwormGenerator(GroupGenerator):
 
         # Shorad
         self.add_unit(
-            AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
+            AirDefence.ZSU_23_4_Shilka,
             "SHILKA#0",
             self.position.x - 55,
             self.position.y - 38,
@@ -50,7 +55,7 @@ class SilkwormGenerator(GroupGenerator):
 
         # Shorad 2
         self.add_unit(
-            AirDefence.SAM_SA_9_Strela_1_Gaskin_TEL,
+            AirDefence.Strela_1_9P31,
             "STRELA#0",
             self.position.x + 200,
             self.position.y + 15,

gen/conflictgen.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from typing import Tuple, Optional
 
@@ -54,13 +56,15 @@ class Conflict:
     def frontline_position(
         cls, frontline: FrontLine, theater: ConflictTheater
     ) -> Tuple[Point, int]:
-        attack_heading = frontline.attack_heading
+        attack_heading = int(frontline.attack_heading)
         position = cls.find_ground_position(
             frontline.position,
             FRONTLINE_LENGTH,
             heading_sum(attack_heading, 90),
             theater,
         )
+        if position is None:
+            raise RuntimeError("Could not find front line position")
         return position, opposite_heading(attack_heading)
 
     @classmethod
@@ -91,7 +95,7 @@ class Conflict:
         defender: Country,
         front_line: FrontLine,
         theater: ConflictTheater,
-    ):
+    ) -> Conflict:
         assert cls.has_frontline_between(front_line.blue_cp, front_line.red_cp)
         position, heading, distance = cls.frontline_vector(front_line, theater)
         conflict = cls(
@@ -138,7 +142,7 @@ class Conflict:
         max_distance: int,
         heading: int,
         theater: ConflictTheater,
-        coerce=True,
+        coerce: bool = True,
     ) -> Optional[Point]:
         """
         Finds the nearest valid ground position along a provided heading and it's inverse up to max_distance.
@@ -153,6 +157,8 @@ class Conflict:
             if theater.is_on_land(pos):
                 return pos
             pos = initial.point_from_heading(opposite_heading(heading), distance)
+            if theater.is_on_land(pos):
+                return pos
         if coerce:
             pos = theater.nearest_land_pos(initial)
             return pos

gen/convoygen.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
 import itertools
-from typing import Dict, TYPE_CHECKING, Type
+from typing import TYPE_CHECKING
 
 from dcs import Mission
 from dcs.mapping import Point
 from dcs.point import PointAction
 from dcs.unit import Vehicle
 from dcs.unitgroup import VehicleGroup
-from dcs.unittype import VehicleType
 
+from game.dcs.groundunittype import GroundUnitType
 from game.transfers import Convoy
 from game.unitmap import UnitMap
 from game.utils import kph
@@ -50,7 +50,7 @@ class ConvoyGenerator:
         self,
         name: str,
         position: Point,
-        units: Dict[Type[VehicleType], int],
+        units: dict[GroundUnitType, int],
         for_player: bool,
     ) -> VehicleGroup:
         country = self.mission.country(
@@ -63,7 +63,7 @@ class ConvoyGenerator:
         group = self.mission.vehicle_group(
             country,
             name,
-            main_unit_type,
+            main_unit_type.dcs_unit_type,
             position=position,
             group_size=main_unit_count,
             move_formation=PointAction.OnRoad,
@@ -76,7 +76,7 @@ class ConvoyGenerator:
         for unit_type, count in unit_types[1:]:
             for i in range(count):
                 v = self.mission.vehicle(
-                    f"{name} Unit #{next(unit_name_counter)}", unit_type
+                    f"{name} Unit #{next(unit_name_counter)}", unit_type.dcs_unit_type
                 )
                 v.position.x = position.x
                 v.position.y = next(y)

gen/defenses/armor_group_generator.py

@@ -1,21 +1,33 @@
 import random
+from typing import Optional
 
-from dcs.vehicles import Armor
+from dcs.unitgroup import VehicleGroup
 
-from game import db
+from game import db, Game
+from game.data.groundunitclass import GroundUnitClass
+from game.dcs.groundunittype import GroundUnitType
+from game.theater.theatergroundobject import VehicleGroupGroundObject
 from gen.defenses.armored_group_generator import (
     ArmoredGroupGenerator,
     FixedSizeArmorGroupGenerator,
 )
 
 
-def generate_armor_group(faction: str, game, ground_object):
+def generate_armor_group(
+    faction: str, game: Game, ground_object: VehicleGroupGroundObject
+) -> Optional[VehicleGroup]:
     """
     This generate a group of ground units
     :return: Generated group
     """
+    armor_types = (
+        GroundUnitClass.Apc,
+        GroundUnitClass.Atgm,
+        GroundUnitClass.Ifv,
+        GroundUnitClass.Tank,
+    )
     possible_unit = [
-        u for u in db.FACTIONS[faction].frontline_units if u in Armor.__dict__.values()
+        u for u in db.FACTIONS[faction].frontline_units if u.unit_class in armor_types
     ]
     if len(possible_unit) > 0:
         unit_type = random.choice(possible_unit)
@@ -23,7 +35,9 @@ def generate_armor_group(faction: str, game, ground_object):
     return None
 
 
-def generate_armor_group_of_type(game, ground_object, unit_type):
+def generate_armor_group_of_type(
+    game: Game, ground_object: VehicleGroupGroundObject, unit_type: GroundUnitType
+) -> VehicleGroup:
     """
     This generate a group of ground units of given type
     :return: Generated group
@@ -33,7 +47,12 @@ def generate_armor_group_of_type(game, ground_object, unit_type):
     return generator.get_generated_group()
 
 
-def generate_armor_group_of_type_and_size(game, ground_object, unit_type, size: int):
+def generate_armor_group_of_type_and_size(
+    game: Game,
+    ground_object: VehicleGroupGroundObject,
+    unit_type: GroundUnitType,
+    size: int,
+) -> VehicleGroup:
     """
     This generate a group of ground units of given type and size
     :return: Generated group

gen/defenses/armored_group_generator.py

@@ -1,15 +1,22 @@
 import random
 
-from gen.sam.group_generator import GroupGenerator
+from game import Game
+from game.dcs.groundunittype import GroundUnitType
+from game.theater.theatergroundobject import VehicleGroupGroundObject
+from gen.sam.group_generator import VehicleGroupGenerator
 
 
-class ArmoredGroupGenerator(GroupGenerator):
-    def __init__(self, game, ground_object, unit_type):
-        super(ArmoredGroupGenerator, self).__init__(game, ground_object)
+class ArmoredGroupGenerator(VehicleGroupGenerator[VehicleGroupGroundObject]):
+    def __init__(
+        self,
+        game: Game,
+        ground_object: VehicleGroupGroundObject,
+        unit_type: GroundUnitType,
+    ) -> None:
+        super().__init__(game, ground_object)
         self.unit_type = unit_type
 
-    def generate(self):
-
+    def generate(self) -> None:
         grid_x = random.randint(2, 3)
         grid_y = random.randint(1, 2)
 
@@ -20,7 +27,7 @@ class ArmoredGroupGenerator(GroupGenerator):
             for j in range(grid_y):
                 index = index + 1
                 self.add_unit(
-                    self.unit_type,
+                    self.unit_type.dcs_unit_type,
                     "Armor#" + str(index),
                     self.position.x + spacing * i,
                     self.position.y + spacing * j,
@@ -28,20 +35,26 @@ class ArmoredGroupGenerator(GroupGenerator):
                 )
 
 
-class FixedSizeArmorGroupGenerator(GroupGenerator):
-    def __init__(self, game, ground_object, unit_type, size):
-        super(FixedSizeArmorGroupGenerator, self).__init__(game, ground_object)
+class FixedSizeArmorGroupGenerator(VehicleGroupGenerator[VehicleGroupGroundObject]):
+    def __init__(
+        self,
+        game: Game,
+        ground_object: VehicleGroupGroundObject,
+        unit_type: GroundUnitType,
+        size: int,
+    ) -> None:
+        super().__init__(game, ground_object)
         self.unit_type = unit_type
         self.size = size
 
-    def generate(self):
+    def generate(self) -> None:
         spacing = random.randint(20, 70)
 
         index = 0
         for i in range(self.size):
             index = index + 1
             self.add_unit(
-                self.unit_type,
+                self.unit_type.dcs_unit_type,
                 "Armor#" + str(index),
                 self.position.x + spacing * i,
                 self.position.y,

gen/environmentgen.py

@@ -22,7 +22,7 @@ class EnvironmentGenerator:
     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_visibility = int(fog.visibility.meters)
         self.mission.weather.fog_thickness = fog.thickness
 
     def set_wind(self, wind: WindConditions) -> None:
@@ -30,7 +30,7 @@ class EnvironmentGenerator:
         self.mission.weather.wind_at_2000 = wind.at_2000m
         self.mission.weather.wind_at_8000 = wind.at_8000m
 
-    def generate(self):
+    def generate(self) -> None:
         self.mission.start_time = self.conditions.start_time
         self.set_clouds(self.conditions.weather.clouds)
         self.set_fog(self.conditions.weather.fog)

gen/fleet/carrier_group.py

@@ -2,11 +2,11 @@ import random
 
 from gen.sam.group_generator import ShipGroupGenerator
 
-from dcs.ships import DDG_Arleigh_Burke_IIa, CG_Ticonderoga
+from dcs.ships import USS_Arleigh_Burke_IIa, TICONDEROG
 
 
 class CarrierGroupGenerator(ShipGroupGenerator):
-    def generate(self):
+    def generate(self) -> None:
 
         # Carrier Strike Group 8
         if self.faction.carrier_names[0] == "Carrier Strike Group 8":
@@ -22,7 +22,7 @@ class CarrierGroupGenerator(ShipGroupGenerator):
 
             # Add Arleigh Burke escort
             self.add_unit(
-                DDG_Arleigh_Burke_IIa,
+                USS_Arleigh_Burke_IIa,
                 "USS Ramage",
                 self.position.x + 6482,
                 self.position.y + 6667,
@@ -30,7 +30,7 @@ class CarrierGroupGenerator(ShipGroupGenerator):
             )
 
             self.add_unit(
-                DDG_Arleigh_Burke_IIa,
+                USS_Arleigh_Burke_IIa,
                 "USS Mitscher",
                 self.position.x - 7963,
                 self.position.y + 7037,
@@ -38,7 +38,7 @@ class CarrierGroupGenerator(ShipGroupGenerator):
             )
 
             self.add_unit(
-                DDG_Arleigh_Burke_IIa,
+                USS_Arleigh_Burke_IIa,
                 "USS Forrest Sherman",
                 self.position.x - 7408,
                 self.position.y - 7408,
@@ -46,7 +46,7 @@ class CarrierGroupGenerator(ShipGroupGenerator):
             )
 
             self.add_unit(
-                DDG_Arleigh_Burke_IIa,
+                USS_Arleigh_Burke_IIa,
                 "USS Lassen",
                 self.position.x + 8704,
                 self.position.y - 6296,
@@ -56,7 +56,7 @@ class CarrierGroupGenerator(ShipGroupGenerator):
             # Add Ticonderoga escort
             if self.heading >= 180:
                 self.add_unit(
-                    CG_Ticonderoga,
+                    TICONDEROG,
                     "USS Hué City",
                     self.position.x + 2222,
                     self.position.y - 3333,
@@ -64,7 +64,7 @@ class CarrierGroupGenerator(ShipGroupGenerator):
                 )
             else:
                 self.add_unit(
-                    CG_Ticonderoga,
+                    TICONDEROG,
                     "USS Hué City",
                     self.position.x - 3333,
                     self.position.y + 2222,

gen/fleet/cn_dd_group.py

@@ -3,24 +3,23 @@ from __future__ import annotations
 import random
 from typing import TYPE_CHECKING
 
-
 from dcs.ships import (
-    Type_052C_Destroyer,
-    Type_052B_Destroyer,
-    Type_054A_Frigate,
+    Type_052C,
+    Type_052B,
+    Type_054A,
 )
 
 from game.factions.faction import Faction
+from game.theater.theatergroundobject import ShipGroundObject
 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):
+    def generate(self) -> None:
 
         include_frigate = random.choice([True, True, False])
         include_dd = random.choice([True, False])
@@ -30,14 +29,14 @@ class ChineseNavyGroupGenerator(ShipGroupGenerator):
 
         if include_frigate:
             self.add_unit(
-                Type_054A_Frigate,
+                Type_054A,
                 "FF1",
                 self.position.x + 1200,
                 self.position.y + 900,
                 self.heading,
             )
             self.add_unit(
-                Type_054A_Frigate,
+                Type_054A,
                 "FF2",
                 self.position.x + 1200,
                 self.position.y - 900,
@@ -45,7 +44,7 @@ class ChineseNavyGroupGenerator(ShipGroupGenerator):
             )
 
         if include_dd:
-            dd_type = random.choice([Type_052C_Destroyer, Type_052B_Destroyer])
+            dd_type = random.choice([Type_052C, Type_052B])
             self.add_unit(
                 dd_type,
                 "DD1",
@@ -65,9 +64,7 @@ class ChineseNavyGroupGenerator(ShipGroupGenerator):
 
 
 class Type54GroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
         super(Type54GroupGenerator, self).__init__(
-            game, ground_object, faction, Type_054A_Frigate
+            game, ground_object, faction, Type_054A
         )

gen/fleet/dd_group.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING
+
+from typing import TYPE_CHECKING, Type
+
+from dcs.ships import PERRY, USS_Arleigh_Burke_IIa
+from dcs.unittype import ShipType
 
 from game.factions.faction import Faction
-from game.theater.theatergroundobject import TheaterGroundObject
-
+from game.theater.theatergroundobject import ShipGroundObject
 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
@@ -16,14 +17,14 @@ class DDGroupGenerator(ShipGroupGenerator):
     def __init__(
         self,
         game: Game,
-        ground_object: TheaterGroundObject,
+        ground_object: ShipGroundObject,
         faction: Faction,
-        ddtype: ShipType,
+        ddtype: Type[ShipType],
     ):
         super(DDGroupGenerator, self).__init__(game, ground_object, faction)
         self.ddtype = ddtype
 
-    def generate(self):
+    def generate(self) -> None:
         self.add_unit(
             self.ddtype,
             "DD1",
@@ -42,18 +43,14 @@ class DDGroupGenerator(ShipGroupGenerator):
 
 
 class OliverHazardPerryGroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
         super(OliverHazardPerryGroupGenerator, self).__init__(
-            game, ground_object, faction, FFG_Oliver_Hazzard_Perry
+            game, ground_object, faction, PERRY
         )
 
 
 class ArleighBurkeGroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
         super(ArleighBurkeGroupGenerator, self).__init__(
-            game, ground_object, faction, DDG_Arleigh_Burke_IIa
+            game, ground_object, faction, USS_Arleigh_Burke_IIa
         )

gen/fleet/lacombattanteII.py

@@ -1,12 +1,13 @@
-from dcs.ships import FAC_La_Combattante_IIa
+from dcs.ships import La_Combattante_II
 
+from game import Game
 from game.factions.faction import Faction
-from game.theater import TheaterGroundObject
+from game.theater.theatergroundobject import ShipGroundObject
 from gen.fleet.dd_group import DDGroupGenerator
 
 
 class LaCombattanteIIGroupGenerator(DDGroupGenerator):
-    def __init__(self, game, ground_object: TheaterGroundObject, faction: Faction):
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
         super(LaCombattanteIIGroupGenerator, self).__init__(
-            game, ground_object, faction, FAC_La_Combattante_IIa
+            game, ground_object, faction, La_Combattante_II
         )

gen/fleet/lha_group.py

@@ -4,7 +4,7 @@ from gen.sam.group_generator import ShipGroupGenerator
 
 
 class LHAGroupGenerator(ShipGroupGenerator):
-    def generate(self):
+    def generate(self) -> None:
 
         # Add carrier
         if len(self.faction.helicopter_carrier) > 0:

gen/fleet/ru_dd_group.py

@@ -1,29 +1,29 @@
 from __future__ import annotations
+
 import random
 from typing import TYPE_CHECKING
 
 from dcs.ships import (
-    Corvette_1124_4_Grisha,
-    Corvette_1241_1_Molniya,
-    Frigate_11540_Neustrashimy,
-    Frigate_1135M_Rezky,
-    Cruiser_1164_Moskva,
-    SSK_877V_Kilo,
-    SSK_641B_Tango,
+    ALBATROS,
+    MOLNIYA,
+    NEUSTRASH,
+    REZKY,
+    MOSCOW,
+    KILO,
+    SOM,
 )
 
+from game.factions.faction import Faction
+from game.theater.theatergroundobject import ShipGroundObject
 from gen.fleet.dd_group import DDGroupGenerator
 from gen.sam.group_generator import ShipGroupGenerator
-from game.factions.faction import Faction
-from game.theater.theatergroundobject import TheaterGroundObject
-
 
 if TYPE_CHECKING:
     from game.game import Game
 
 
 class RussianNavyGroupGenerator(ShipGroupGenerator):
-    def generate(self):
+    def generate(self) -> None:
 
         include_frigate = random.choice([True, True, False])
         include_dd = random.choice([True, False])
@@ -37,9 +37,7 @@ class RussianNavyGroupGenerator(ShipGroupGenerator):
             include_frigate = True
 
         if include_frigate:
-            frigate_type = random.choice(
-                [Corvette_1124_4_Grisha, Corvette_1241_1_Molniya]
-            )
+            frigate_type = random.choice([ALBATROS, MOLNIYA])
             self.add_unit(
                 frigate_type,
                 "FF1",
@@ -56,7 +54,7 @@ class RussianNavyGroupGenerator(ShipGroupGenerator):
             )
 
         if include_dd:
-            dd_type = random.choice([Frigate_11540_Neustrashimy, Frigate_1135M_Rezky])
+            dd_type = random.choice([NEUSTRASH, REZKY])
             self.add_unit(
                 dd_type,
                 "DD1",
@@ -76,7 +74,7 @@ class RussianNavyGroupGenerator(ShipGroupGenerator):
             # Only include the Moskva for now, the Pyotry Velikiy is an unkillable monster.
             # See https://github.com/dcs-liberation/dcs_liberation/issues/567
             self.add_unit(
-                Cruiser_1164_Moskva,
+                MOSCOW,
                 "CC1",
                 self.position.x,
                 self.position.y,
@@ -87,36 +85,24 @@ class RussianNavyGroupGenerator(ShipGroupGenerator):
 
 
 class GrishaGroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
         super(GrishaGroupGenerator, self).__init__(
-            game, ground_object, faction, Corvette_1124_4_Grisha
+            game, ground_object, faction, ALBATROS
         )
 
 
 class MolniyaGroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
         super(MolniyaGroupGenerator, self).__init__(
-            game, ground_object, faction, Corvette_1241_1_Molniya
+            game, ground_object, faction, MOLNIYA
         )
 
 
 class KiloSubGroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
-        super(KiloSubGroupGenerator, self).__init__(
-            game, ground_object, faction, SSK_877V_Kilo
-        )
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
+        super(KiloSubGroupGenerator, self).__init__(game, ground_object, faction, KILO)
 
 
 class TangoSubGroupGenerator(DDGroupGenerator):
-    def __init__(
-        self, game: Game, ground_object: TheaterGroundObject, faction: Faction
-    ):
-        super(TangoSubGroupGenerator, self).__init__(
-            game, ground_object, faction, SSK_641B_Tango
-        )
+    def __init__(self, game: Game, ground_object: ShipGroundObject, faction: Faction):
+        super(TangoSubGroupGenerator, self).__init__(game, ground_object, faction, SOM)

gen/fleet/schnellboot.py

@@ -1,16 +1,16 @@
 import random
 
-from dcs.ships import Boat_Schnellboot_type_S130
+from dcs.ships import Schnellboot_type_S130
 
 from gen.sam.group_generator import ShipGroupGenerator
 
 
 class SchnellbootGroupGenerator(ShipGroupGenerator):
-    def generate(self):
+    def generate(self) -> None:
 
         for i in range(random.randint(2, 4)):
             self.add_unit(
-                Boat_Schnellboot_type_S130,
+                Schnellboot_type_S130,
                 "Schnellboot" + str(i),
                 self.position.x + i * random.randint(100, 250),
                 self.position.y + (random.randint(100, 200) - 100),

gen/fleet/ship_group_generator.py

@@ -1,7 +1,17 @@
+from __future__ import annotations
+
 import logging
 import random
+from typing import TYPE_CHECKING, Optional
+
+from dcs.unitgroup import ShipGroup
 
 from game import db
+from game.theater.theatergroundobject import (
+    LhaGroundObject,
+    CarrierGroundObject,
+    ShipGroundObject,
+)
 from gen.fleet.carrier_group import CarrierGroupGenerator
 from gen.fleet.cn_dd_group import ChineseNavyGroupGenerator, Type54GroupGenerator
 from gen.fleet.dd_group import (
@@ -21,6 +31,9 @@ from gen.fleet.schnellboot import SchnellbootGroupGenerator
 from gen.fleet.uboat import UBoatGroupGenerator
 from gen.fleet.ww2lst import WW2LSTGroupGenerator
 
+if TYPE_CHECKING:
+    from game import Game
+
 
 SHIP_MAP = {
     "SchnellbootGroupGenerator": SchnellbootGroupGenerator,
@@ -39,10 +52,12 @@ SHIP_MAP = {
 }
 
 
-def generate_ship_group(game, ground_object, faction_name: str):
+def generate_ship_group(
+    game: Game, ground_object: ShipGroundObject, faction_name: str
+) -> Optional[ShipGroup]:
     """
     This generate a ship group
-    :return: Nothing, but put the group reference inside the ground object
+    :return: The generated group, or None if this faction does not support ships.
     """
     faction = db.FACTIONS[faction_name]
     if len(faction.navy_generators) > 0:
@@ -61,26 +76,30 @@ def generate_ship_group(game, ground_object, faction_name: str):
     return None
 
 
-def generate_carrier_group(faction: str, game, ground_object):
-    """
-    This generate a carrier group
-    :param parentCp: The parent control point
+def generate_carrier_group(
+    faction: str, game: Game, ground_object: CarrierGroundObject
+) -> ShipGroup:
+    """Generates a carrier group.
+
+    :param faction: The faction the TGO belongs to.
+    :param game: The Game the group is being generated for.
     :param ground_object: The ground object which will own the ship group
-    :param country: Owner country
-    :return: Nothing, but put the group reference inside the ground object
+    :return: The generated group.
     """
     generator = CarrierGroupGenerator(game, ground_object, db.FACTIONS[faction])
     generator.generate()
     return generator.get_generated_group()
 
 
-def generate_lha_group(faction: str, game, ground_object):
-    """
-    This generate a lha carrier group
-    :param parentCp: The parent control point
+def generate_lha_group(
+    faction: str, game: Game, ground_object: LhaGroundObject
+) -> ShipGroup:
+    """Generate an LHA group.
+
+    :param faction: The faction the TGO belongs to.
+    :param game: The Game the group is being generated for.
     :param ground_object: The ground object which will own the ship group
-    :param country: Owner country
-    :return: Nothing, but put the group reference inside the ground object
+    :return: The generated group.
     """
     generator = LHAGroupGenerator(game, ground_object, db.FACTIONS[faction])
     generator.generate()

gen/fleet/uboat.py

@@ -1,16 +1,16 @@
 import random
 
-from dcs.ships import U_boat_VIIC_U_flak
+from dcs.ships import Uboat_VIIC
 
 from gen.sam.group_generator import ShipGroupGenerator
 
 
 class UBoatGroupGenerator(ShipGroupGenerator):
-    def generate(self):
+    def generate(self) -> None:
 
         for i in range(random.randint(1, 4)):
             self.add_unit(
-                U_boat_VIIC_U_flak,
+                Uboat_VIIC,
                 "Uboat" + str(i),
                 self.position.x + i * random.randint(100, 250),
                 self.position.y + (random.randint(100, 200) - 100),

gen/fleet/ww2lst.py

@@ -1,16 +1,16 @@
 import random
 
-from dcs.ships import LS_Samuel_Chase, LST_Mk_II
+from dcs.ships import USS_Samuel_Chase, LST_Mk2
 
 from gen.sam.group_generator import ShipGroupGenerator
 
 
 class WW2LSTGroupGenerator(ShipGroupGenerator):
-    def generate(self):
+    def generate(self) -> None:
 
         # Add LS Samuel Chase
         self.add_unit(
-            LS_Samuel_Chase,
+            USS_Samuel_Chase,
             "SamuelChase",
             self.position.x,
             self.position.y,
@@ -19,7 +19,7 @@ class WW2LSTGroupGenerator(ShipGroupGenerator):
 
         for i in range(1, random.randint(3, 4)):
             self.add_unit(
-                LST_Mk_II,
+                LST_Mk2,
                 "LST" + str(i),
                 self.position.x + i * random.randint(800, 1200),
                 self.position.y,

gen/flights/ai_flight_planner.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import math
 import operator
 import random
 from collections import defaultdict
@@ -16,14 +17,11 @@ from typing import (
     Set,
     TYPE_CHECKING,
     Tuple,
-    Type,
     TypeVar,
-    Union,
+    Any,
 )
 
-from dcs.unittype import FlyingType
-
-from game.factions.faction import Faction
+from game.dcs.aircrafttype import AircraftType
 from game.infos.information import Information
 from game.procurement import AircraftProcurementRequest
 from game.profiling import logged_duration, MultiEventTracer
@@ -166,8 +164,6 @@ class AircraftAllocator:
             flight.max_distance
         )
 
-        # Prefer using squadrons with pilots first
-        best_understaffed: Optional[Tuple[ControlPoint, Squadron]] = None
         for airfield in airfields_in_range:
             if not airfield.is_friendly(self.is_player):
                 continue
@@ -179,24 +175,14 @@ class AircraftAllocator:
                     continue
                 # Valid location with enough aircraft available. Find a squadron to fit
                 # the role.
-                for squadron in self.air_wing.squadrons_for(aircraft):
-                    if task not in squadron.auto_assignable_mission_types:
-                        continue
-                    if len(squadron.available_pilots) >= flight.num_aircraft:
+                squadrons = self.air_wing.auto_assignable_for_task_with_type(
+                    aircraft, task
+                )
+                for squadron in squadrons:
+                    if squadron.can_provide_pilots(flight.num_aircraft):
                         inventory.remove_aircraft(aircraft, flight.num_aircraft)
                         return airfield, squadron
-
-                    # A compatible squadron that doesn't have enough pilots. Remember it
-                    # as a fallback in case we find no better choices.
-                    if best_understaffed is None:
-                        best_understaffed = airfield, squadron
-
-        if best_understaffed is not None:
-            airfield, squadron = best_understaffed
-            self.global_inventory.for_control_point(airfield).remove_aircraft(
-                squadron.aircraft, flight.num_aircraft
-            )
-        return best_understaffed
+        return None
 
 
 class PackageBuilder:
@@ -255,7 +241,7 @@ class PackageBuilder:
         return True
 
     def find_divert_field(
-        self, aircraft: Type[FlyingType], arrival: ControlPoint
+        self, aircraft: AircraftType, arrival: ControlPoint
     ) -> Optional[ControlPoint]:
         divert_limit = nautical_miles(150)
         for airfield in self.closest_airfields.operational_airfields_within(
@@ -299,7 +285,7 @@ class ObjectiveFinder:
         self.game = game
         self.is_player = is_player
 
-    def enemy_air_defenses(self) -> Iterator[tuple[TheaterGroundObject, Distance]]:
+    def enemy_air_defenses(self) -> Iterator[tuple[TheaterGroundObject[Any], Distance]]:
         """Iterates over all enemy SAM sites."""
         doctrine = self.game.faction_for(self.is_player).doctrine
         threat_zones = self.game.threat_zone_for(not self.is_player)
@@ -329,14 +315,14 @@ class ObjectiveFinder:
 
                 yield ground_object, target_range
 
-    def threatening_air_defenses(self) -> Iterator[TheaterGroundObject]:
+    def threatening_air_defenses(self) -> Iterator[TheaterGroundObject[Any]]:
         """Iterates over enemy SAMs in threat range of friendly control points.
 
         SAM sites are sorted by their closest proximity to any friendly control
         point (airfield or fleet).
         """
 
-        target_ranges: list[tuple[TheaterGroundObject, Distance]] = []
+        target_ranges: list[tuple[TheaterGroundObject[Any], Distance]] = []
         for target, threat_range in self.enemy_air_defenses():
             ranges: list[Distance] = []
             for cp in self.friendly_control_points():
@@ -389,9 +375,9 @@ class ObjectiveFinder:
     def _targets_by_range(
         self, targets: Iterable[MissionTargetType]
     ) -> Iterator[MissionTargetType]:
-        target_ranges: List[Tuple[MissionTargetType, int]] = []
+        target_ranges: list[tuple[MissionTargetType, float]] = []
         for target in targets:
-            ranges: List[int] = []
+            ranges: list[float] = []
             for cp in self.friendly_control_points():
                 ranges.append(target.distance_to(cp))
             target_ranges.append((target, min(ranges)))
@@ -400,13 +386,13 @@ class ObjectiveFinder:
         for target, _range in target_ranges:
             yield target
 
-    def strike_targets(self) -> Iterator[TheaterGroundObject]:
+    def strike_targets(self) -> Iterator[TheaterGroundObject[Any]]:
         """Iterates over enemy strike targets.
 
         Targets are sorted by their closest proximity to any friendly control
         point (airfield or fleet).
         """
-        targets: List[Tuple[TheaterGroundObject, int]] = []
+        targets: list[tuple[TheaterGroundObject[Any], float]] = []
         # Building objectives are made of several individual TGOs (one per
         # building).
         found_targets: Set[str] = set()
@@ -445,7 +431,7 @@ class ObjectiveFinder:
                     continue
                 if ground_object.name in found_targets:
                     continue
-                ranges: List[int] = []
+                ranges: list[float] = []
                 for friendly_cp in self.friendly_control_points():
                     ranges.append(ground_object.distance_to(friendly_cp))
                 targets.append((ground_object, min(ranges)))
@@ -524,6 +510,24 @@ class ObjectiveFinder:
             raise RuntimeError("Found no friendly control points. You probably lost.")
         return farthest
 
+    def closest_friendly_control_point(self) -> ControlPoint:
+        """Finds the friendly control point that is closest to any threats."""
+        threat_zones = self.game.threat_zone_for(not self.is_player)
+
+        closest = None
+        min_distance = meters(math.inf)
+        for cp in self.friendly_control_points():
+            if isinstance(cp, OffMapSpawn):
+                continue
+            distance = threat_zones.distance_to_threat(cp.position)
+            if distance < min_distance:
+                closest = cp
+                min_distance = distance
+
+        if closest is None:
+            raise RuntimeError("Found no friendly control points. You probably lost.")
+        return closest
+
     def enemy_control_points(self) -> Iterator[ControlPoint]:
         """Iterates over all enemy control points."""
         return (
@@ -581,7 +585,8 @@ class CoalitionMissionPlanner:
     MAX_OCA_RANGE = nautical_miles(150)
     MAX_SEAD_RANGE = nautical_miles(150)
     MAX_STRIKE_RANGE = nautical_miles(150)
-    MAX_AWEC_RANGE = nautical_miles(200)
+    MAX_AWEC_RANGE = Distance.inf()
+    MAX_TANKER_RANGE = nautical_miles(200)
 
     def __init__(self, game: Game, is_player: bool) -> None:
         self.game = game
@@ -600,14 +605,7 @@ class CoalitionMissionPlanner:
         also possible for the player to exclude mission types from their squadron
         designs.
         """
-        all_compatible = aircraft_for_task(mission_type)
-        for squadron in self.game.air_wing_for(self.is_player).iter_squadrons():
-            if (
-                squadron.aircraft in all_compatible
-                and mission_type in squadron.auto_assignable_mission_types
-            ):
-                return True
-        return False
+        return self.game.air_wing_for(self.is_player).can_auto_plan(mission_type)
 
     def critical_missions(self) -> Iterator[ProposedMission]:
         """Identifies the most important missions to plan this turn.
@@ -628,6 +626,11 @@ class CoalitionMissionPlanner:
             asap=True,
         )
 
+        yield ProposedMission(
+            self.objective_finder.closest_friendly_control_point(),
+            [ProposedFlight(FlightType.REFUELING, 1, self.MAX_TANKER_RANGE)],
+        )
+
         # Find friendly CPs within 100 nmi from an enemy airfield, plan CAP.
         for cp in self.objective_finder.vulnerable_control_points():
             # Plan CAP in such a way, that it is established during the whole desired mission length
@@ -842,7 +845,7 @@ class CoalitionMissionPlanner:
         for cp in self.objective_finder.friendly_control_points():
             inventory = self.game.aircraft_inventory.for_control_point(cp)
             for aircraft, available in inventory.all_aircraft:
-                self.message("Unused aircraft", f"{available} {aircraft.id} from {cp}")
+                self.message("Unused aircraft", f"{available} {aircraft} from {cp}")
 
     def plan_flight(
         self,
@@ -1055,7 +1058,7 @@ class CoalitionMissionPlanner:
                 # delayed until their takeoff time by AirConflictGenerator.
                 package.time_over_target = next(start_time) + tot
 
-    def message(self, title, text) -> None:
+    def message(self, title: str, text: str) -> None:
         """Emits a planning message to the player.
 
         If the mission planner belongs to the players coalition, this emits a

gen/flights/ai_flight_planner_db.py

@@ -1,5 +1,6 @@
 import logging
-from typing import List, Type
+from collections import Sequence
+from typing import Type
 
 from dcs.helicopters import (
     AH_1W,
@@ -8,6 +9,7 @@ from dcs.helicopters import (
     CH_47D,
     CH_53E,
     Ka_50,
+    Mi_24P,
     Mi_24V,
     Mi_26,
     Mi_28N,
@@ -51,10 +53,13 @@ from dcs.planes import (
     F_5E_3,
     F_86F_Sabre,
     IL_76MD,
-    I_16,
+    IL_78M,
     JF_17,
     J_11A,
     Ju_88A4,
+    KC130,
+    KC135MPRS,
+    KC_135,
     KJ_2000,
     L_39ZA,
     MQ_9_Reaper,
@@ -77,6 +82,7 @@ from dcs.planes import (
     P_51D_30_NA,
     RQ_1A_Predator,
     S_3B,
+    S_3B_Tanker,
     SpitfireLFMkIX,
     SpitfireLFMkIXCW,
     Su_17M4,
@@ -100,11 +106,12 @@ from dcs.planes import (
 )
 from dcs.unittype import FlyingType
 
+from game.dcs.aircrafttype import AircraftType
 from gen.flights.flight import FlightType
 from pydcs_extensions.a4ec.a4ec import A_4E_C
 from pydcs_extensions.f22a.f22a import F_22A
 from pydcs_extensions.hercules.hercules import Hercules
-from pydcs_extensions.mb339.mb339 import MB_339PAN
+from pydcs_extensions.jas39.jas39 import JAS39Gripen, JAS39Gripen_AG
 from pydcs_extensions.su57.su57 import Su_57
 
 # All aircraft lists are in priority order. Aircraft higher in the list will be
@@ -118,28 +125,29 @@ from pydcs_extensions.su57.su57 import Su_57
 CAP_CAPABLE = [
     Su_57,
     F_22A,
-    MiG_31,
+    F_15C,
     F_14B,
     F_14A_135_GR,
-    MiG_25PD,
     Su_33,
+    J_11A,
     Su_30,
     Su_27,
-    J_11A,
-    F_15C,
     MiG_29S,
-    MiG_29G,
-    MiG_29A,
     F_16C_50,
     FA_18C_hornet,
+    JF_17,
+    JAS39Gripen,
     F_16A,
     F_4E,
-    JF_17,
+    MiG_31,
+    MiG_25PD,
+    MiG_29G,
+    MiG_29A,
     MiG_23MLD,
     MiG_21Bis,
     Mirage_2000_5,
-    M_2000C,
     F_15E,
+    M_2000C,
     F_5E_3,
     MiG_19P,
     A_4E_C,
@@ -166,6 +174,7 @@ CAS_CAPABLE = [
     A_10C_2,
     A_10C,
     Hercules,
+    Su_34,
     Su_25TM,
     Su_25T,
     Su_25,
@@ -174,6 +183,7 @@ CAS_CAPABLE = [
     FA_18C_hornet,
     Tornado_GR4,
     Tornado_IDS,
+    JAS39Gripen_AG,
     JF_17,
     AV8BNA,
     A_10A,
@@ -182,17 +192,16 @@ CAS_CAPABLE = [
     F_14B,
     F_14A_135_GR,
     AJS37,
-    Su_24MR,
     Su_24M,
     Su_17M4,
+    Su_33,
     F_4E,
     S_3B,
-    Su_34,
     Su_30,
-    MiG_19P,
     MiG_29S,
     MiG_27K,
     MiG_29A,
+    MiG_21Bis,
     AH_64D,
     AH_64A,
     AH_1W,
@@ -201,16 +210,17 @@ CAS_CAPABLE = [
     SA342L,
     Ka_50,
     Mi_28N,
+    Mi_24P,
     Mi_24V,
     Mi_8MT,
-    UH_1H,
+    MiG_19P,
     MiG_15bis,
     M_2000C,
     F_5E_3,
     F_86F_Sabre,
     C_101CC,
-    MB_339PAN,
     L_39ZA,
+    UH_1H,
     A_20G,
     Ju_88A4,
     P_47D_40,
@@ -242,6 +252,7 @@ SEAD_CAPABLE = [
     A_4E_C,
     F_14B,
     F_14A_135_GR,
+    JAS39Gripen_AG,
     AV8BNA,
     Su_24M,
     Su_17M4,
@@ -257,6 +268,7 @@ DEAD_CAPABLE = [
     AJS37,
     F_14B,
     F_14A_135_GR,
+    JAS39Gripen_AG,
     B_1B,
     B_52H,
     Tu_160,
@@ -289,12 +301,14 @@ STRIKE_CAPABLE = [
     Tornado_GR4,
     F_16C_50,
     FA_18C_hornet,
+    AV8BNA,
+    JF_17,
     F_16A,
     F_14B,
     F_14A_135_GR,
+    JAS39Gripen_AG,
     Tornado_IDS,
     Su_17M4,
-    Su_24MR,
     Su_24M,
     Su_25TM,
     Su_25T,
@@ -306,11 +320,9 @@ STRIKE_CAPABLE = [
     MiG_29S,
     MiG_29G,
     MiG_29A,
-    JF_17,
     F_4E,
     A_10C_2,
     A_10C,
-    AV8BNA,
     S_3B,
     A_4E_C,
     M_2000C,
@@ -319,7 +331,6 @@ STRIKE_CAPABLE = [
     MiG_15bis,
     F_5E_3,
     F_86F_Sabre,
-    MB_339PAN,
     C_101CC,
     L_39ZA,
     B_17G,
@@ -342,6 +353,7 @@ ANTISHIP_CAPABLE = [
     AJS37,
     Tu_22M3,
     FA_18C_hornet,
+    JAS39Gripen_AG,
     Su_24M,
     Su_17M4,
     JF_17,
@@ -364,6 +376,7 @@ RUNWAY_ATTACK_CAPABLE = [
     Su_34,
     Su_30,
     Tornado_IDS,
+    M_2000C,
 ] + STRIKE_CAPABLE
 
 # For any aircraft that isn't necessarily directly involved in strike
@@ -394,8 +407,17 @@ AEWC_CAPABLE = [
     KJ_2000,
 ]
 
+# Priority is given to the tankers that can carry the most fuel.
+REFUELING_CAPABALE = [
+    KC_135,
+    KC135MPRS,
+    IL_78M,
+    KC130,
+    S_3B_Tanker,
+]
 
-def aircraft_for_task(task: FlightType) -> List[Type[FlyingType]]:
+
+def dcs_types_for_task(task: FlightType) -> Sequence[Type[FlyingType]]:
     cap_missions = (FlightType.BARCAP, FlightType.TARCAP, FlightType.SWEEP)
     if task in cap_missions:
         return CAP_CAPABLE
@@ -421,6 +443,8 @@ def aircraft_for_task(task: FlightType) -> List[Type[FlyingType]]:
         return CAP_CAPABLE
     elif task == FlightType.AEWC:
         return AEWC_CAPABLE
+    elif task == FlightType.REFUELING:
+        return REFUELING_CAPABALE
     elif task == FlightType.TRANSPORT:
         return TRANSPORT_CAPABLE
     else:
@@ -428,7 +452,15 @@ def aircraft_for_task(task: FlightType) -> List[Type[FlyingType]]:
         return []
 
 
-def tasks_for_aircraft(aircraft: Type[FlyingType]) -> list[FlightType]:
+def aircraft_for_task(task: FlightType) -> list[AircraftType]:
+    dcs_types = dcs_types_for_task(task)
+    types: list[AircraftType] = []
+    for dcs_type in dcs_types:
+        types.extend(AircraftType.for_dcs_type(dcs_type))
+    return types
+
+
+def tasks_for_aircraft(aircraft: AircraftType) -> list[FlightType]:
     tasks = []
     for task in FlightType:
         if aircraft in aircraft_for_task(task):

gen/flights/flight.py

@@ -1,16 +1,14 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from datetime import timedelta
 from enum import Enum
-from typing import List, Optional, TYPE_CHECKING, Type, Union
+from typing import List, Optional, TYPE_CHECKING, Union, Sequence
 
 from dcs.mapping import Point
 from dcs.point import MovingPoint, PointAction
 from dcs.unit import Unit
-from dcs.unittype import FlyingType
 
-from game import db
+from game.dcs.aircrafttype import AircraftType
 from game.squadrons import Pilot, Squadron
 from game.theater.controlpoint import ControlPoint, MissionTarget
 from game.utils import Distance, meters
@@ -69,6 +67,7 @@ class FlightType(Enum):
     AEWC = "AEW&C"
     TRANSPORT = "Transport"
     SEAD_ESCORT = "SEAD Escort"
+    REFUELING = "Refueling"
 
     def __str__(self) -> str:
         return self.value
@@ -141,8 +140,8 @@ class FlightWaypoint:
             waypoint_type: The waypoint type.
             x: X cooidinate of the waypoint.
             y: Y coordinate of the waypoint.
-            alt: Altitude of the waypoint. By default this is AGL, but it can be
-            changed to MSL by setting alt_type to "RADIO".
+            alt: Altitude of the waypoint. By default this is MSL, but it can be
+            changed to AGL by setting alt_type to "RADIO"
         """
         self.waypoint_type = waypoint_type
         self.x = x
@@ -154,7 +153,7 @@ class FlightWaypoint:
         # Only used in the waypoint list in the flight edit page. No sense
         # having three names. A short and long form is enough.
         self.description = ""
-        self.targets: List[Union[MissionTarget, Unit]] = []
+        self.targets: Sequence[Union[MissionTarget, Unit]] = []
         self.obj_name = ""
         self.pretty_name = ""
         self.only_for_player = False
@@ -299,7 +298,7 @@ class Flight:
         return self.roster.player_count
 
     @property
-    def unit_type(self) -> Type[FlyingType]:
+    def unit_type(self) -> AircraftType:
         return self.squadron.aircraft
 
     @property
@@ -323,14 +322,12 @@ class Flight:
     def clear_roster(self) -> None:
         self.roster.clear()
 
-    def __repr__(self):
-        name = db.unit_type_name(self.unit_type)
+    def __repr__(self) -> str:
         if self.custom_name:
-            return f"{self.custom_name} {self.count} x {name}"
-        return f"[{self.flight_type}] {self.count} x {name}"
+            return f"{self.custom_name} {self.count} x {self.unit_type}"
+        return f"[{self.flight_type}] {self.count} x {self.unit_type}"
 
-    def __str__(self):
-        name = db.unit_get_expanded_info(self.country, self.unit_type, "name")
+    def __str__(self) -> str:
         if self.custom_name:
-            return f"{self.custom_name} {self.count} x {name}"
-        return f"[{self.flight_type}] {self.count} x {name}"
+            return f"{self.custom_name} {self.count} x {self.unit_type}"
+        return f"[{self.flight_type}] {self.count} x {self.unit_type}"

gen/flights/flightplan.py

@@ -16,12 +16,10 @@ from functools import cached_property
 from typing import Iterator, List, Optional, Set, TYPE_CHECKING, Tuple
 
 from dcs.mapping import Point
-from dcs.planes import E_3A, E_2C, A_50, KJ_2000
 from dcs.unit import Unit
 from shapely.geometry import Point as ShapelyPoint
 
 from game.data.doctrine import Doctrine
-from game.squadrons import Pilot
 from game.theater import (
     Airfield,
     ControlPoint,
@@ -29,9 +27,10 @@ from game.theater import (
     MissionTarget,
     SamGroundObject,
     TheaterGroundObject,
+    NavalControlPoint,
 )
-from game.theater.theatergroundobject import EwrGroundObject
-from game.utils import Distance, Speed, feet, meters, nautical_miles
+from game.theater.theatergroundobject import EwrGroundObject, NavalGroundObject
+from game.utils import Distance, Speed, feet, meters, nautical_miles, knots
 from .closestairfields import ObjectiveDistanceCache
 from .flight import Flight, FlightType, FlightWaypoint, FlightWaypointType
 from .traveltime import GroundSpeed, TravelTime
@@ -220,11 +219,7 @@ class FlightPlan:
         tot_waypoint = self.tot_waypoint
         if tot_waypoint is None:
             return None
-
-        time = self.tot
-        if time is None:
-            return None
-        return time - self._travel_time_to_waypoint(tot_waypoint)
+        return self.tot - self._travel_time_to_waypoint(tot_waypoint)
 
     def startup_time(self) -> Optional[timedelta]:
         takeoff_time = self.takeoff_time()
@@ -395,6 +390,9 @@ class PatrollingFlightPlan(FlightPlan):
     #: Maximum time to remain on station.
     patrol_duration: timedelta
 
+    #: Racetrack speed TAS.
+    patrol_speed: Speed
+
     #: The engagement range of any Search Then Engage task, or the radius of a
     #: Search Then Engage in Zone task. Any enemies of the appropriate type for
     #: this mission within this range of the flight's current position (or the
@@ -769,6 +767,25 @@ class AwacsFlightPlan(LoiterFlightPlan):
         return self.push_time
 
 
+@dataclass(frozen=True)
+class RefuelingFlightPlan(PatrollingFlightPlan):
+    takeoff: FlightWaypoint
+    land: FlightWaypoint
+    divert: Optional[FlightWaypoint]
+    bullseye: FlightWaypoint
+
+    def iter_waypoints(self) -> Iterator[FlightWaypoint]:
+        yield self.takeoff
+        yield from self.nav_to
+        yield self.patrol_start
+        yield self.patrol_end
+        yield from self.nav_from
+        yield self.land
+        if self.divert is not None:
+            yield self.divert
+        yield self.bullseye
+
+
 @dataclass(frozen=True)
 class AirliftFlightPlan(FlightPlan):
     takeoff: FlightWaypoint
@@ -919,6 +936,8 @@ class FlightPlanBuilder:
             return self.generate_aewc(flight)
         elif task == FlightType.TRANSPORT:
             return self.generate_transport(flight)
+        elif task == FlightType.REFUELING:
+            return self.generate_refueling_racetrack(flight)
         raise PlanningError(f"{task} flight plan generation not implemented")
 
     def regenerate_package_waypoints(self) -> None:
@@ -1059,35 +1078,28 @@ class FlightPlanBuilder:
 
         orbit_location = self.aewc_orbit(location)
 
-        # As high as possible to maximize detection and on-station time.
-        if flight.unit_type == E_2C:
-            patrol_alt = feet(30000)
-        elif flight.unit_type == E_3A:
-            patrol_alt = feet(35000)
-        elif flight.unit_type == A_50:
-            patrol_alt = feet(33000)
-        elif flight.unit_type == KJ_2000:
-            patrol_alt = feet(40000)
+        if flight.unit_type.patrol_altitude is not None:
+            patrol_alt = flight.unit_type.patrol_altitude
         else:
             patrol_alt = feet(25000)
 
         builder = WaypointBuilder(flight, self.game, self.is_player)
-        orbit_location = builder.orbit(orbit_location, patrol_alt)
+        orbit = builder.orbit(orbit_location, patrol_alt)
 
         return AwacsFlightPlan(
             package=self.package,
             flight=flight,
             takeoff=builder.takeoff(flight.departure),
             nav_to=builder.nav_path(
-                flight.departure.position, orbit_location.position, patrol_alt
+                flight.departure.position, orbit.position, patrol_alt
             ),
             nav_from=builder.nav_path(
-                orbit_location.position, flight.arrival.position, patrol_alt
+                orbit.position, flight.arrival.position, patrol_alt
             ),
             land=builder.land(flight.arrival),
             divert=builder.divert(flight.divert),
             bullseye=builder.bullseye(),
-            hold=orbit_location,
+            hold=orbit,
             hold_duration=timedelta(hours=4),
         )
 
@@ -1118,7 +1130,7 @@ class FlightPlanBuilder:
         )
 
     @staticmethod
-    def anti_ship_targets_for_tgo(tgo: TheaterGroundObject) -> List[StrikeTarget]:
+    def anti_ship_targets_for_tgo(tgo: NavalGroundObject) -> List[StrikeTarget]:
         return [StrikeTarget(f"{g.name} at {tgo.name}", g) for g in tgo.groups]
 
     def generate_anti_ship(self, flight: Flight) -> StrikeFlightPlan:
@@ -1131,12 +1143,9 @@ class FlightPlanBuilder:
 
         from game.transfers import CargoShip
 
-        if isinstance(location, ControlPoint):
-            if not location.is_fleet:
-                raise InvalidObjectiveLocation(flight.flight_type, location)
-            # The first group generated will be the carrier group itself.
-            targets = self.anti_ship_targets_for_tgo(location.ground_objects[0])
-        elif isinstance(location, TheaterGroundObject):
+        if isinstance(location, NavalControlPoint):
+            targets = self.anti_ship_targets_for_tgo(location.find_main_tgo())
+        elif isinstance(location, NavalGroundObject):
             targets = self.anti_ship_targets_for_tgo(location)
         elif isinstance(location, CargoShip):
             targets = [StrikeTarget(location.name, location)]
@@ -1158,21 +1167,28 @@ class FlightPlanBuilder:
         if isinstance(location, FrontLine):
             raise InvalidObjectiveLocation(flight.flight_type, location)
 
-        start, end = self.racetrack_for_objective(location, barcap=True)
-        patrol_alt = meters(
-            random.randint(
-                int(self.doctrine.min_patrol_altitude.meters),
-                int(self.doctrine.max_patrol_altitude.meters),
-            )
+        start_pos, end_pos = self.racetrack_for_objective(location, barcap=True)
+
+        preferred_alt = flight.unit_type.preferred_patrol_altitude
+        randomized_alt = preferred_alt + feet(random.randint(-2, 1) * 1000)
+        patrol_alt = max(
+            self.doctrine.min_patrol_altitude,
+            min(self.doctrine.max_patrol_altitude, randomized_alt),
+        )
+
+        patrol_speed = flight.unit_type.preferred_patrol_speed(patrol_alt)
+        logging.debug(
+            f"BARCAP patrol speed for {flight.unit_type.name} at {patrol_alt.feet}ft: {patrol_speed.knots} KTAS"
         )
 
         builder = WaypointBuilder(flight, self.game, self.is_player)
-        start, end = builder.race_track(start, end, patrol_alt)
+        start, end = builder.race_track(start_pos, end_pos, patrol_alt)
 
         return BarCapFlightPlan(
             package=self.package,
             flight=flight,
             patrol_duration=self.doctrine.cap_duration,
+            patrol_speed=patrol_speed,
             engagement_distance=self.doctrine.cap_engagement_range,
             takeoff=builder.takeoff(flight.departure),
             nav_to=builder.nav_path(
@@ -1198,10 +1214,12 @@ class FlightPlanBuilder:
         target = self.package.target.position
 
         heading = self.package.waypoints.join.heading_between_point(target)
-        start = target.point_from_heading(heading, -self.doctrine.sweep_distance.meters)
+        start_pos = target.point_from_heading(
+            heading, -self.doctrine.sweep_distance.meters
+        )
 
         builder = WaypointBuilder(flight, self.game, self.is_player)
-        start, end = builder.sweep(start, target, self.doctrine.ingress_altitude)
+        start, end = builder.sweep(start_pos, target, self.doctrine.ingress_altitude)
 
         hold = builder.hold(self._hold_point(flight))
 
@@ -1395,11 +1413,15 @@ class FlightPlanBuilder:
         """
         location = self.package.target
 
-        patrol_alt = meters(
-            random.randint(
-                int(self.doctrine.min_patrol_altitude.meters),
-                int(self.doctrine.max_patrol_altitude.meters),
-            )
+        preferred_alt = flight.unit_type.preferred_patrol_altitude
+        randomized_alt = preferred_alt + feet(random.randint(-2, 1) * 1000)
+        patrol_alt = max(
+            self.doctrine.min_patrol_altitude,
+            min(self.doctrine.max_patrol_altitude, randomized_alt),
+        )
+        patrol_speed = flight.unit_type.preferred_patrol_speed(patrol_alt)
+        logging.debug(
+            f"TARCAP patrol speed for {flight.unit_type.name} at {patrol_alt.feet}ft: {patrol_speed.knots} KTAS"
         )
 
         # Create points
@@ -1422,6 +1444,7 @@ class FlightPlanBuilder:
             # requests an escort the CAP flight will remain on station for the
             # duration of the escorted mission, or until it is winchester/bingo.
             patrol_duration=self.doctrine.cap_duration,
+            patrol_speed=patrol_speed,
             engagement_distance=self.doctrine.cap_engagement_range,
             takeoff=builder.takeoff(flight.departure),
             nav_to=builder.nav_path(flight.departure.position, orbit0p, patrol_alt),
@@ -1590,16 +1613,33 @@ class FlightPlanBuilder:
 
         builder = WaypointBuilder(flight, self.game, self.is_player)
 
+        # 2021-08-02: patrol_speed will currently have no effect because
+        # CAS doesn't use OrbitAction. But all PatrollingFlightPlan are expected
+        # to have patrol_speed
+        is_helo = flight.unit_type.dcs_unit_type.helicopter
+        ingress_egress_altitude = (
+            self.doctrine.ingress_altitude if not is_helo else meters(50)
+        )
+        patrol_speed = flight.unit_type.preferred_patrol_speed(ingress_egress_altitude)
+        use_agl_ingress_egress = is_helo
+
         return CasFlightPlan(
             package=self.package,
             flight=flight,
             patrol_duration=self.doctrine.cas_duration,
+            patrol_speed=patrol_speed,
             takeoff=builder.takeoff(flight.departure),
             nav_to=builder.nav_path(
-                flight.departure.position, ingress, self.doctrine.ingress_altitude
+                flight.departure.position,
+                ingress,
+                ingress_egress_altitude,
+                use_agl_ingress_egress,
             ),
             nav_from=builder.nav_path(
-                egress, flight.arrival.position, self.doctrine.ingress_altitude
+                egress,
+                flight.arrival.position,
+                ingress_egress_altitude,
+                use_agl_ingress_egress,
             ),
             patrol_start=builder.ingress(
                 FlightWaypointType.INGRESS_CAS, ingress, location
@@ -1612,6 +1652,75 @@ class FlightPlanBuilder:
             bullseye=builder.bullseye(),
         )
 
+    def generate_refueling_racetrack(self, flight: Flight) -> RefuelingFlightPlan:
+        location = self.package.target
+
+        closest_boundary = self.threat_zones.closest_boundary(location.position)
+        heading_to_threat_boundary = location.position.heading_between_point(
+            closest_boundary
+        )
+        distance_to_threat = meters(
+            location.position.distance_to_point(closest_boundary)
+        )
+        orbit_heading = heading_to_threat_boundary
+
+        # Station 70nm outside the threat zone.
+        threat_buffer = nautical_miles(70)
+        if self.threat_zones.threatened(location.position):
+            orbit_distance = distance_to_threat + threat_buffer
+        else:
+            orbit_distance = distance_to_threat - threat_buffer
+
+        racetrack_center = location.position.point_from_heading(
+            orbit_heading, orbit_distance.meters
+        )
+
+        racetrack_half_distance = Distance.from_nautical_miles(20).meters
+
+        racetrack_start = racetrack_center.point_from_heading(
+            orbit_heading + 90, racetrack_half_distance
+        )
+        racetrack_end = racetrack_center.point_from_heading(
+            orbit_heading - 90, racetrack_half_distance
+        )
+
+        builder = WaypointBuilder(flight, self.game, self.is_player)
+
+        tanker_type = flight.unit_type
+        if tanker_type.patrol_altitude is not None:
+            altitude = tanker_type.patrol_altitude
+        else:
+            altitude = feet(21000)
+
+        # TODO: Could use flight.unit_type.preferred_patrol_speed(altitude) instead.
+        if tanker_type.patrol_speed is not None:
+            speed = tanker_type.patrol_speed
+        else:
+            # ~280 knots IAS at 21000.
+            speed = knots(400)
+
+        racetrack = builder.race_track(racetrack_start, racetrack_end, altitude)
+
+        return RefuelingFlightPlan(
+            package=self.package,
+            flight=flight,
+            takeoff=builder.takeoff(flight.departure),
+            nav_to=builder.nav_path(
+                flight.departure.position, racetrack_start, altitude
+            ),
+            nav_from=builder.nav_path(racetrack_end, flight.arrival.position, altitude),
+            patrol_start=racetrack[0],
+            patrol_end=racetrack[1],
+            land=builder.land(flight.arrival),
+            divert=builder.divert(flight.divert),
+            bullseye=builder.bullseye(),
+            patrol_duration=timedelta(hours=1),
+            patrol_speed=speed,
+            # TODO: Factor out a common base of the combat and non-combat race-tracks.
+            # No harm in setting this, but we ought to clean up a bit.
+            engagement_distance=meters(0),
+        )
+
     @staticmethod
     def target_waypoint(
         flight: Flight, builder: WaypointBuilder, target: StrikeTarget
@@ -1788,23 +1897,23 @@ class FlightPlanBuilder:
             return self._retreating_rendezvous_point(attack_transition)
         return self._advancing_rendezvous_point(attack_transition)
 
-    def _ingress_point(self, heading: int) -> Point:
+    def _ingress_point(self, heading: float) -> Point:
         return self.package.target.position.point_from_heading(
             heading - 180 + 15, self.doctrine.ingress_egress_distance.meters
         )
 
-    def _egress_point(self, heading: int) -> Point:
+    def _egress_point(self, heading: float) -> Point:
         return self.package.target.position.point_from_heading(
             heading - 180 - 15, self.doctrine.ingress_egress_distance.meters
         )
 
-    def _target_heading_to_package_airfield(self) -> int:
+    def _target_heading_to_package_airfield(self) -> float:
         return self._heading_to_package_airfield(self.package.target.position)
 
-    def _heading_to_package_airfield(self, point: Point) -> int:
+    def _heading_to_package_airfield(self, point: Point) -> float:
         return self.package_airfield().position.heading_between_point(point)
 
-    def _distance_to_package_airfield(self, point: Point) -> int:
+    def _distance_to_package_airfield(self, point: Point) -> float:
         return self.package_airfield().position.distance_to_point(point)
 
     def package_airfield(self) -> ControlPoint:

gen/flights/loadouts.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 import datetime
-from typing import Optional, List, Iterator, Type, TYPE_CHECKING, Mapping
-
-from dcs.unittype import FlyingType
+from typing import Optional, List, Iterator, TYPE_CHECKING, Mapping
 
 from game.data.weapons import Weapon, Pylon
+from game.dcs.aircrafttype import AircraftType
 
 if TYPE_CHECKING:
     from gen.flights.flight import Flight
@@ -20,16 +19,18 @@ class Loadout:
         is_custom: bool = False,
     ) -> None:
         self.name = name
-        self.pylons = {k: v for k, v in pylons.items() if v is not None}
+        # We clear unused pylon entries on initialization, but UI actions can still
+        # cause a pylon to be emptied, so make the optional type explicit.
+        self.pylons: Mapping[int, Optional[Weapon]] = {
+            k: v for k, v in pylons.items() if v is not None
+        }
         self.date = date
         self.is_custom = is_custom
 
     def derive_custom(self, name: str) -> Loadout:
         return Loadout(name, self.pylons, self.date, is_custom=True)
 
-    def degrade_for_date(
-        self, unit_type: Type[FlyingType], date: datetime.date
-    ) -> Loadout:
+    def degrade_for_date(self, unit_type: AircraftType, date: datetime.date) -> Loadout:
         if self.date is not None and self.date <= date:
             return Loadout(self.name, self.pylons, self.date)
 
@@ -61,7 +62,7 @@ class Loadout:
         #       {"CLSID": class ID, "num": pylon number}
         #   "tasks": List (as a dict) of task IDs the payload is used by.
         # }
-        payloads = flight.unit_type.load_payloads()
+        payloads = flight.unit_type.dcs_unit_type.load_payloads()
         for payload in payloads.values():
             name = payload["name"]
             pylons = payload["pylons"]
@@ -95,6 +96,7 @@ class Loadout:
             FlightType.CAS: ("CAS MAVERICK F", "CAS"),
             FlightType.STRIKE: ("STRIKE",),
             FlightType.ANTISHIP: ("ANTISHIP",),
+            FlightType.DEAD: ("DEAD",),
             FlightType.SEAD: ("SEAD",),
             FlightType.BAI: ("BAI",),
             FlightType.OCA_RUNWAY: ("RUNWAY_ATTACK", "RUNWAY_STRIKE"),
@@ -126,8 +128,8 @@ class Loadout:
         for name in cls.default_loadout_names_for(flight):
             # This operation is cached, but must be called before load_by_name will
             # work.
-            flight.unit_type.load_payloads()
-            payload = flight.unit_type.loadout_by_name(name)
+            flight.unit_type.dcs_unit_type.load_payloads()
+            payload = flight.unit_type.dcs_unit_type.loadout_by_name(name)
             if payload is not None:
                 return Loadout(
                     name,
@@ -136,4 +138,8 @@ class Loadout:
                 )
 
         # TODO: Try group.load_task_default_loadout(loadout_for_task)
+        return cls.empty_loadout()
+
+    @classmethod
+    def empty_loadout(cls) -> Loadout:
         return Loadout("Empty", {}, date=None)

gen/flights/traveltime.py

@@ -25,16 +25,13 @@ if TYPE_CHECKING:
 class GroundSpeed:
     @classmethod
     def for_flight(cls, flight: Flight, altitude: Distance) -> Speed:
-        if not issubclass(flight.unit_type, FlyingType):
-            raise TypeError("Flight has non-flying unit")
-
         # TODO: Expose both a cruise speed and target speed.
         # The cruise speed can be used for ascent, hold, join, and RTB to save
         # on fuel, but mission speed will be fast enough to keep the flight
         # safer.
 
         # DCS's max speed is in kph at 0 MSL.
-        max_speed = kph(flight.unit_type.max_speed)
+        max_speed = flight.unit_type.max_speed
         if max_speed > SPEED_OF_SOUND_AT_SEA_LEVEL:
             # Aircraft is supersonic. Limit to mach 0.85 to conserve fuel and
             # account for heavily loaded jets.

gen/flights/waypointbuilder.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import logging
 
 import random
 from dataclasses import dataclass
@@ -10,11 +11,12 @@ from typing import (
     TYPE_CHECKING,
     Tuple,
     Union,
+    Any,
 )
 
 from dcs.mapping import Point
 from dcs.unit import Unit
-from dcs.unitgroup import Group, VehicleGroup
+from dcs.unitgroup import Group, VehicleGroup, ShipGroup
 
 if TYPE_CHECKING:
     from game import Game
@@ -33,7 +35,9 @@ from .flight import Flight, FlightWaypoint, FlightWaypointType
 @dataclass(frozen=True)
 class StrikeTarget:
     name: str
-    target: Union[VehicleGroup, TheaterGroundObject, Unit, Group, MultiGroupTransport]
+    target: Union[
+        VehicleGroup, TheaterGroundObject[Any], Unit, ShipGroup, MultiGroupTransport
+    ]
 
 
 class WaypointBuilder:
@@ -54,7 +58,7 @@ class WaypointBuilder:
 
     @property
     def is_helo(self) -> bool:
-        return getattr(self.flight.unit_type, "helicopter", False)
+        return self.flight.unit_type.dcs_unit_type.helicopter
 
     def takeoff(self, departure: ControlPoint) -> FlightWaypoint:
         """Create takeoff waypoint for the given arrival airfield or carrier.
@@ -441,7 +445,7 @@ class WaypointBuilder:
         # description in gen.aircraft.JoinPointBuilder), so instead we give
         # the escort flights a flight plan including the ingress point, target
         # area, and egress point.
-        ingress = self.ingress(FlightWaypointType.INGRESS_ESCORT, ingress, target)
+        ingress_wp = self.ingress(FlightWaypointType.INGRESS_ESCORT, ingress, target)
 
         waypoint = FlightWaypoint(
             FlightWaypointType.TARGET_GROUP_LOC,
@@ -455,8 +459,8 @@ class WaypointBuilder:
         waypoint.description = "Escort the package"
         waypoint.pretty_name = "Target area"
 
-        egress = self.egress(egress, target)
-        return ingress, waypoint, egress
+        egress_wp = self.egress(egress, target)
+        return ingress_wp, waypoint, egress_wp
 
     @staticmethod
     def pickup(control_point: ControlPoint) -> FlightWaypoint:

gen/forcedoptionsgen.py

@@ -32,6 +32,8 @@ class ForcedOptionsGenerator:
             self.mission.forced_options.labels = ForcedOptions.Labels.Abbreviate
         elif self.game.settings.labels == "Dot Only":
             self.mission.forced_options.labels = ForcedOptions.Labels.DotOnly
+        elif self.game.settings.labels == "Neutral Dot":
+            self.mission.forced_options.labels = ForcedOptions.Labels.NeutralDot
         elif self.game.settings.labels == "Off":
             self.mission.forced_options.labels = ForcedOptions.Labels.None_
 
@@ -41,7 +43,7 @@ class ForcedOptionsGenerator:
         if blue.unrestricted_satnav or red.unrestricted_satnav:
             self.mission.forced_options.unrestricted_satnav = True
 
-    def generate(self):
+    def generate(self) -> None:
         self._set_options_view()
         self._set_external_views()
         self._set_labels()

gen/ground_forces/ai_ground_planner.py

@@ -1,15 +1,18 @@
+from __future__ import annotations
+
 import logging
 import random
 from enum import Enum
-from typing import Dict, List
-
-from dcs.unittype import VehicleType
-
-from game.theater import ControlPoint
+from typing import Dict, List, TYPE_CHECKING
 
 from game.data.groundunitclass import GroundUnitClass
+from game.dcs.groundunittype import GroundUnitType
+from game.theater import ControlPoint
 from gen.ground_forces.combat_stance import CombatStance
 
+if TYPE_CHECKING:
+    from game import Game
+
 MAX_COMBAT_GROUP_PER_CP = 10
 
 
@@ -22,17 +25,19 @@ class CombatGroupRole(Enum):
     LOGI = 6
     INFANTRY = 7
     ATGM = 8
+    RECON = 9
 
 
 DISTANCE_FROM_FRONTLINE = {
     CombatGroupRole.TANK: (2200, 3200),
-    CombatGroupRole.APC: (7500, 8500),
+    CombatGroupRole.APC: (2700, 3700),
     CombatGroupRole.IFV: (2700, 3700),
     CombatGroupRole.ARTILLERY: (16000, 18000),
-    CombatGroupRole.SHORAD: (12000, 13000),
+    CombatGroupRole.SHORAD: (5000, 8000),
     CombatGroupRole.LOGI: (18000, 20000),
     CombatGroupRole.INFANTRY: (2800, 3300),
     CombatGroupRole.ATGM: (5200, 6200),
+    CombatGroupRole.RECON: (2000, 3000),
 }
 
 GROUP_SIZES_BY_COMBAT_STANCE = {
@@ -46,22 +51,23 @@ GROUP_SIZES_BY_COMBAT_STANCE = {
 
 
 class CombatGroup:
-    def __init__(self, role: CombatGroupRole):
-        self.units: List[VehicleType] = []
+    def __init__(
+        self, role: CombatGroupRole, unit_type: GroundUnitType, size: int
+    ) -> None:
+        self.unit_type = unit_type
+        self.size = size
         self.role = role
-        self.assigned_enemy_cp = None
         self.start_position = None
 
-    def __str__(self):
-        s = ""
-        s += "ROLE : " + str(self.role) + "\n"
-        if len(self.units) > 0:
-            s += "UNITS " + self.units[0].name + " * " + str(len(self.units))
+    def __str__(self) -> str:
+        s = f"ROLE : {self.role}\n"
+        if self.size:
+            s += f"UNITS {self.unit_type} * {self.size}"
         return s
 
 
 class GroundPlanner:
-    def __init__(self, cp: ControlPoint, game):
+    def __init__(self, cp: ControlPoint, game: Game) -> None:
         self.cp = cp
         self.game = game
         self.connected_enemy_cp = [
@@ -74,47 +80,50 @@ class GroundPlanner:
         self.atgm_group: List[CombatGroup] = []
         self.logi_groups: List[CombatGroup] = []
         self.shorad_groups: List[CombatGroup] = []
+        self.recon_groups: List[CombatGroup] = []
 
         self.units_per_cp: Dict[int, List[CombatGroup]] = {}
         for cp in self.connected_enemy_cp:
             self.units_per_cp[cp.id] = []
         self.reserve: List[CombatGroup] = []
 
-    def plan_groundwar(self):
+    def plan_groundwar(self) -> None:
 
         ground_unit_limit = self.cp.frontline_unit_count_limit
 
         remaining_available_frontline_units = ground_unit_limit
 
-        if hasattr(self.cp, "stance"):
-            group_size_choice = GROUP_SIZES_BY_COMBAT_STANCE[self.cp.stance]
-        else:
-            self.cp.stance = CombatStance.DEFENSIVE
-            group_size_choice = GROUP_SIZES_BY_COMBAT_STANCE[CombatStance.DEFENSIVE]
+        # TODO: Fix to handle the per-front stances.
+        # https://github.com/dcs-liberation/dcs_liberation/issues/1417
+        group_size_choice = GROUP_SIZES_BY_COMBAT_STANCE[CombatStance.DEFENSIVE]
 
         # Create combat groups and assign them randomly to each enemy CP
         for unit_type in self.cp.base.armor:
-            if unit_type in GroundUnitClass.Tank:
+            unit_class = unit_type.unit_class
+            if unit_class is GroundUnitClass.Tank:
                 collection = self.tank_groups
                 role = CombatGroupRole.TANK
-            elif unit_type in GroundUnitClass.Apc:
+            elif unit_class is GroundUnitClass.Apc:
                 collection = self.apc_group
                 role = CombatGroupRole.APC
-            elif unit_type in GroundUnitClass.Artillery:
+            elif unit_class is GroundUnitClass.Artillery:
                 collection = self.art_group
                 role = CombatGroupRole.ARTILLERY
-            elif unit_type in GroundUnitClass.Ifv:
+            elif unit_class is GroundUnitClass.Ifv:
                 collection = self.ifv_group
                 role = CombatGroupRole.IFV
-            elif unit_type in GroundUnitClass.Logistics:
+            elif unit_class is GroundUnitClass.Logistics:
                 collection = self.logi_groups
                 role = CombatGroupRole.LOGI
-            elif unit_type in GroundUnitClass.Atgm:
+            elif unit_class is GroundUnitClass.Atgm:
                 collection = self.atgm_group
                 role = CombatGroupRole.ATGM
-            elif unit_type in GroundUnitClass.Shorads:
+            elif unit_class is GroundUnitClass.Shorads:
                 collection = self.shorad_groups
                 role = CombatGroupRole.SHORAD
+            elif unit_class is GroundUnitClass.Recon:
+                collection = self.recon_groups
+                role = CombatGroupRole.RECON
             else:
                 logging.warning(
                     f"Unused front line vehicle at base {unit_type}: unknown unit class"
@@ -131,37 +140,23 @@ class GroundPlanner:
             while available > 0:
 
                 if role == CombatGroupRole.SHORAD:
-                    n = 1
+                    count = 1
                 else:
-                    n = random.choice(group_size_choice)
-                    if n > available:
+                    count = random.choice(group_size_choice)
+                    if count > available:
                         if available >= 2:
-                            n = 2
+                            count = 2
                         else:
-                            n = 1
-                available -= n
+                            count = 1
+                available -= count
 
-                group = CombatGroup(role)
+                group = CombatGroup(role, unit_type, count)
                 if len(self.connected_enemy_cp) > 0:
                     enemy_cp = random.choice(self.connected_enemy_cp).id
                     self.units_per_cp[enemy_cp].append(group)
-                    group.assigned_enemy_cp = enemy_cp
                 else:
                     self.reserve.append(group)
-                    group.assigned_enemy_cp = "__reserve__"
-
-                for i in range(n):
-                    group.units.append(unit_type)
                 collection.append(group)
 
             if remaining_available_frontline_units == 0:
                 break
-
-        print("------------------")
-        print("Ground Planner : ")
-        print(self.cp.name)
-        print("------------------")
-        for unit_type in self.units_per_cp.keys():
-            print("For : #" + str(unit_type))
-            for group in self.units_per_cp[unit_type]:
-                print(str(group))

gen/groundobjectsgen.py

@@ -9,12 +9,23 @@ from __future__ import annotations
 
 import logging
 import random
-from typing import Dict, Iterator, Optional, TYPE_CHECKING, Type, List
+from typing import (
+    Dict,
+    Iterator,
+    Optional,
+    TYPE_CHECKING,
+    Type,
+    List,
+    TypeVar,
+    Any,
+    Generic,
+    Union,
+)
 
 from dcs import Mission, Point, unitgroup
 from dcs.action import SceneryDestructionZone
 from dcs.country import Country
-from dcs.point import StaticPoint
+from dcs.point import StaticPoint, MovingPoint
 from dcs.statics import Fortification, fortification_map, warehouse_map
 from dcs.task import (
     ActivateBeaconCommand,
@@ -26,12 +37,12 @@ from dcs.task import (
 from dcs.triggers import TriggerStart, TriggerZone
 from dcs.unit import Ship, Unit, Vehicle, SingleHeliPad
 from dcs.unitgroup import Group, ShipGroup, StaticGroup, VehicleGroup
-from dcs.unittype import StaticType, UnitType
+from dcs.unittype import StaticType, UnitType, ShipType, VehicleType
 from dcs.vehicles import vehicle_map
 
 from game import db
 from game.data.building_data import FORTIFICATION_UNITS, FORTIFICATION_UNITS_ID
-from game.db import unit_type_from_name
+from game.db import unit_type_from_name, ship_type_from_name, vehicle_type_from_name
 from game.theater import ControlPoint, TheaterGroundObject
 from game.theater.theatergroundobject import (
     BuildingGroundObject,
@@ -56,7 +67,10 @@ FARP_FRONTLINE_DISTANCE = 10000
 AA_CP_MIN_DISTANCE = 40000
 
 
-class GenericGroundObjectGenerator:
+TgoT = TypeVar("TgoT", bound=TheaterGroundObject[Any])
+
+
+class GenericGroundObjectGenerator(Generic[TgoT]):
     """An unspecialized ground object generator.
 
     Currently used only for SAM
@@ -64,7 +78,7 @@ class GenericGroundObjectGenerator:
 
     def __init__(
         self,
-        ground_object: TheaterGroundObject,
+        ground_object: TgoT,
         country: Country,
         game: Game,
         mission: Mission,
@@ -89,10 +103,7 @@ class GenericGroundObjectGenerator:
                 logging.warning(f"Found empty group in {self.ground_object}")
                 continue
 
-            unit_type = unit_type_from_name(group.units[0].type)
-            if unit_type is None:
-                raise RuntimeError(f"Unrecognized unit type: {group.units[0].type}")
-
+            unit_type = vehicle_type_from_name(group.units[0].type)
             vg = self.m.vehicle_group(
                 self.country,
                 group.name,
@@ -116,24 +127,27 @@ class GenericGroundObjectGenerator:
             self._register_unit_group(group, vg)
 
     @staticmethod
-    def enable_eplrs(group: Group, unit_type: Type[UnitType]) -> None:
-        if hasattr(unit_type, "eplrs"):
-            if unit_type.eplrs:
-                group.points[0].tasks.append(EPLRS(group.id))
+    def enable_eplrs(group: VehicleGroup, unit_type: Type[VehicleType]) -> None:
+        if unit_type.eplrs:
+            group.points[0].tasks.append(EPLRS(group.id))
 
-    def set_alarm_state(self, group: Group) -> None:
+    def set_alarm_state(self, group: Union[ShipGroup, VehicleGroup]) -> None:
         if self.game.settings.perf_red_alert_state:
             group.points[0].tasks.append(OptAlarmState(2))
         else:
             group.points[0].tasks.append(OptAlarmState(1))
 
-    def _register_unit_group(self, persistence_group: Group, miz_group: Group) -> None:
+    def _register_unit_group(
+        self,
+        persistence_group: Union[ShipGroup, VehicleGroup],
+        miz_group: Union[ShipGroup, VehicleGroup],
+    ) -> None:
         self.unit_map.add_ground_object_units(
             self.ground_object, persistence_group, miz_group
         )
 
 
-class MissileSiteGenerator(GenericGroundObjectGenerator):
+class MissileSiteGenerator(GenericGroundObjectGenerator[MissileSiteGroundObject]):
     @property
     def culled(self) -> bool:
         # Don't cull missile sites - their range is long enough to make them easily
@@ -148,7 +162,7 @@ class MissileSiteGenerator(GenericGroundObjectGenerator):
         for group in self.ground_object.groups:
             vg = self.m.find_group(group.name)
             if vg is not None:
-                targets = self.possible_missile_targets(vg)
+                targets = self.possible_missile_targets()
                 if targets:
                     target = random.choice(targets)
                     real_target = target.point_from_heading(
@@ -165,7 +179,7 @@ class MissileSiteGenerator(GenericGroundObjectGenerator):
                     "Couldn't setup missile site to fire, group was not generated."
                 )
 
-    def possible_missile_targets(self, vg: Group) -> List[Point]:
+    def possible_missile_targets(self) -> List[Point]:
         """
         Find enemy control points in range
         :param vg: Vehicle group we are searching a target for (There is always only oe group right now)
@@ -174,7 +188,7 @@ class MissileSiteGenerator(GenericGroundObjectGenerator):
         targets: List[Point] = []
         for cp in self.game.theater.controlpoints:
             if cp.captured != self.ground_object.control_point.captured:
-                distance = cp.position.distance_to_point(vg.position)
+                distance = cp.position.distance_to_point(self.ground_object.position)
                 if distance < self.missile_site_range:
                     targets.append(cp.position)
         return targets
@@ -196,7 +210,7 @@ class MissileSiteGenerator(GenericGroundObjectGenerator):
         return site_range
 
 
-class BuildingSiteGenerator(GenericGroundObjectGenerator):
+class BuildingSiteGenerator(GenericGroundObjectGenerator[BuildingGroundObject]):
     """Generator for building sites.
 
     Building sites are the primary type of non-airbase objective locations that
@@ -225,7 +239,7 @@ class BuildingSiteGenerator(GenericGroundObjectGenerator):
                 f"{self.ground_object.dcs_identifier} not found in static maps"
             )
 
-    def generate_vehicle_group(self, unit_type: Type[UnitType]) -> None:
+    def generate_vehicle_group(self, unit_type: Type[VehicleType]) -> None:
         if not self.ground_object.is_dead:
             group = self.m.vehicle_group(
                 country=self.country,
@@ -324,7 +338,7 @@ class SceneryGenerator(BuildingSiteGenerator):
         self.unit_map.add_scenery(scenery)
 
 
-class GenericCarrierGenerator(GenericGroundObjectGenerator):
+class GenericCarrierGenerator(GenericGroundObjectGenerator[GenericCarrierGroundObject]):
     """Base type for carrier group generation.
 
     Used by both CV(N) groups and LHA groups.
@@ -376,13 +390,12 @@ class GenericCarrierGenerator(GenericGroundObjectGenerator):
             self.add_runway_data(brc or 0, atc, tacan, tacan_callsign, icls)
             self._register_unit_group(group, ship_group)
 
-    def get_carrier_type(self, group: Group) -> Type[UnitType]:
-        unit_type = unit_type_from_name(group.units[0].type)
-        if unit_type is None:
-            raise RuntimeError(f"Unrecognized carrier name: {group.units[0].type}")
-        return unit_type
+    def get_carrier_type(self, group: ShipGroup) -> Type[ShipType]:
+        return ship_type_from_name(group.units[0].type)
 
-    def configure_carrier(self, group: Group, atc_channel: RadioFrequency) -> ShipGroup:
+    def configure_carrier(
+        self, group: ShipGroup, atc_channel: RadioFrequency
+    ) -> ShipGroup:
         unit_type = self.get_carrier_type(group)
 
         ship_group = self.m.ship_group(
@@ -474,7 +487,7 @@ class GenericCarrierGenerator(GenericGroundObjectGenerator):
 class CarrierGenerator(GenericCarrierGenerator):
     """Generator for CV(N) groups."""
 
-    def get_carrier_type(self, group: Group) -> UnitType:
+    def get_carrier_type(self, group: ShipGroup) -> Type[ShipType]:
         unit_type = super().get_carrier_type(group)
         if self.game.settings.supercarrier:
             unit_type = db.upgrade_to_supercarrier(unit_type, self.control_point.name)
@@ -518,7 +531,7 @@ class LhaGenerator(GenericCarrierGenerator):
         )
 
 
-class ShipObjectGenerator(GenericGroundObjectGenerator):
+class ShipObjectGenerator(GenericGroundObjectGenerator[ShipGroundObject]):
     """Generator for non-carrier naval groups."""
 
     def generate(self) -> None:
@@ -529,14 +542,11 @@ class ShipObjectGenerator(GenericGroundObjectGenerator):
             if not group.units:
                 logging.warning(f"Found empty group in {self.ground_object}")
                 continue
+            self.generate_group(group, ship_type_from_name(group.units[0].type))
 
-            unit_type = unit_type_from_name(group.units[0].type)
-            if unit_type is None:
-                raise RuntimeError(f"Unrecognized unit type: {group.units[0].type}")
-
-            self.generate_group(group, unit_type)
-
-    def generate_group(self, group_def: Group, first_unit_type: Type[UnitType]) -> None:
+    def generate_group(
+        self, group_def: ShipGroup, first_unit_type: Type[ShipType]
+    ) -> None:
         group = self.m.ship_group(
             self.country,
             group_def.name,
@@ -624,7 +634,7 @@ class GroundObjectsGenerator:
         self.icls_alloc = iter(range(1, 21))
         self.runways: Dict[str, RunwayData] = {}
 
-    def generate(self):
+    def generate(self) -> None:
         for cp in self.game.theater.controlpoints:
             if cp.captured:
                 country_name = self.game.player_country
@@ -637,6 +647,7 @@ class GroundObjectsGenerator:
             ).generate()
 
             for ground_object in cp.ground_objects:
+                generator: GenericGroundObjectGenerator[Any]
                 if isinstance(ground_object, FactoryGroundObject):
                     generator = FactoryGenerator(
                         ground_object, country, self.game, self.m, self.unit_map

gen/kneeboard.py

@@ -32,15 +32,16 @@ from typing import Dict, List, Optional, TYPE_CHECKING, Tuple, Iterator
 from PIL import Image, ImageDraw, ImageFont
 from dcs.mission import Mission
 from dcs.unit import Unit
-from dcs.unittype import FlyingType
 from tabulate import tabulate
 
 from game.data.alic import AlicCodes
 from game.db import unit_type_from_name
+from game.dcs.aircrafttype import AircraftType
+from game.savecompat import has_save_compat_for
 from game.theater import ConflictTheater, TheaterGroundObject, LatLon
 from game.theater.bullseye import Bullseye
 from game.utils import meters
-from .aircraft import AIRCRAFT_DATA, FlightData
+from .aircraft import FlightData
 from .airsupportgen import AwacsInfo, TankerInfo
 from .briefinggen import CommInfo, JtacInfo, MissionInfoGenerator
 from .flights.flight import FlightWaypoint, FlightWaypointType, FlightType
@@ -63,7 +64,8 @@ class KneeboardPageWriter:
         else:
             self.foreground_fill = (15, 15, 15)
             self.background_fill = (255, 252, 252)
-        self.image = Image.new("RGB", (768, 1024), self.background_fill)
+        self.image_size = (768, 1024)
+        self.image = Image.new("RGB", self.image_size, self.background_fill)
         # These font sizes create a relatively full page for current sorties. If
         # we start generating more complicated flight plans, or start including
         # more information in the comm ladder (the latter of which we should
@@ -82,6 +84,7 @@ class KneeboardPageWriter:
             "resources/fonts/Inconsolata.otf", 20, layout_engine=ImageFont.LAYOUT_BASIC
         )
         self.draw = ImageDraw.Draw(self.image)
+        self.page_margin = page_margin
         self.x = page_margin
         self.y = page_margin
         self.line_spacing = line_spacing
@@ -91,10 +94,24 @@ class KneeboardPageWriter:
         return self.x, self.y
 
     def text(
-        self, text: str, font=None, fill: Tuple[int, int, int] = (0, 0, 0)
+        self,
+        text: str,
+        font: Optional[ImageFont.FreeTypeFont] = None,
+        fill: Optional[Tuple[int, int, int]] = None,
+        wrap: bool = False,
     ) -> None:
         if font is None:
             font = self.content_font
+        if fill is None:
+            fill = self.foreground_fill
+
+        if wrap:
+            text = "\n".join(
+                self.wrap_line_with_font(
+                    line, self.image_size[0] - self.page_margin - self.x, font
+                )
+                for line in text.splitlines()
+            )
 
         self.draw.text(self.position, text, font=font, fill=fill)
         width, height = self.draw.textsize(text, font=font)
@@ -134,6 +151,24 @@ class KneeboardPageWriter:
                 output = combo
         return "".join(segments + [output]).strip()
 
+    @staticmethod
+    def wrap_line_with_font(
+        inputstr: str, max_width: int, font: ImageFont.FreeTypeFont
+    ) -> str:
+        if font.getsize(inputstr)[0] <= max_width:
+            return inputstr
+        tokens = inputstr.split(" ")
+        output = ""
+        segments = []
+        for token in tokens:
+            combo = output + " " + token
+            if font.getsize(combo)[0] > max_width:
+                segments.append(output + "\n")
+                output = token
+            else:
+                output = combo
+        return "".join(segments + [output]).strip()
+
 
 class KneeboardPage:
     """Base class for all kneeboard pages."""
@@ -142,7 +177,8 @@ class KneeboardPage:
         """Writes the kneeboard page to the given path."""
         raise NotImplementedError
 
-    def format_ll(self, ll: LatLon) -> str:
+    @staticmethod
+    def format_ll(ll: LatLon) -> str:
         ns = "N" if ll.latitude >= 0 else "S"
         ew = "E" if ll.longitude >= 0 else "W"
         return f"{ll.latitude:.4}°{ns} {ll.longitude:.4}°{ew}"
@@ -355,8 +391,9 @@ class BriefingPage(KneeboardPage):
         if channel is None:
             return str(frequency)
 
-        namer = AIRCRAFT_DATA[self.flight.aircraft_type.id].channel_namer
-        channel_name = namer.channel_name(channel.radio_id, channel.channel)
+        channel_name = self.flight.aircraft_type.channel_name(
+            channel.radio_id, channel.channel
+        )
         return f"{channel_name}\n{frequency}"
 
 
@@ -452,9 +489,10 @@ class SupportPage(KneeboardPage):
         if channel is None:
             return str(frequency)
 
-        namer = AIRCRAFT_DATA[self.flight.aircraft_type.id].channel_namer
-        channel_name = namer.channel_name(channel.radio_id, channel.channel)
-        return f"{channel_name} {frequency}"
+        channel_name = self.flight.aircraft_type.channel_name(
+            channel.radio_id, channel.channel
+        )
+        return f"{channel_name}\n{frequency}"
 
     def _format_time(self, time: Optional[datetime.timedelta]) -> str:
         if time is None:
@@ -551,6 +589,24 @@ class StrikeTaskPage(KneeboardPage):
         ]
 
 
+class NotesPage(KneeboardPage):
+    """A kneeboard page containing the campaign owner's notes."""
+
+    def __init__(
+        self,
+        notes: str,
+        dark_kneeboard: bool,
+    ) -> None:
+        self.notes = notes
+        self.dark_kneeboard = dark_kneeboard
+
+    def write(self, path: Path) -> None:
+        writer = KneeboardPageWriter(dark_theme=self.dark_kneeboard)
+        writer.title(f"Notes")
+        writer.text(self.notes, wrap=True)
+        writer.write(path)
+
+
 class KneeboardGenerator(MissionInfoGenerator):
     """Creates kneeboard pages for each client flight in the mission."""
 
@@ -565,14 +621,14 @@ class KneeboardGenerator(MissionInfoGenerator):
         temp_dir = Path("kneeboards")
         temp_dir.mkdir(exist_ok=True)
         for aircraft, pages in self.pages_by_airframe().items():
-            aircraft_dir = temp_dir / aircraft.id
+            aircraft_dir = temp_dir / aircraft.dcs_unit_type.id
             aircraft_dir.mkdir(exist_ok=True)
             for idx, page in enumerate(pages):
                 page_path = aircraft_dir / f"page{idx:02}.png"
                 page.write(page_path)
-                self.mission.add_aircraft_kneeboard(aircraft, page_path)
+                self.mission.add_aircraft_kneeboard(aircraft.dcs_unit_type, page_path)
 
-    def pages_by_airframe(self) -> Dict[FlyingType, List[KneeboardPage]]:
+    def pages_by_airframe(self) -> Dict[AircraftType, List[KneeboardPage]]:
         """Returns a list of kneeboard pages per airframe in the mission.
 
         Only client flights will be included, but because DCS does not support
@@ -583,7 +639,7 @@ class KneeboardGenerator(MissionInfoGenerator):
             A dict mapping aircraft types to the list of kneeboard pages for
             that aircraft.
         """
-        all_flights: Dict[FlyingType, List[KneeboardPage]] = defaultdict(list)
+        all_flights: Dict[AircraftType, List[KneeboardPage]] = defaultdict(list)
         for flight in self.flights:
             if not flight.client_units:
                 continue
@@ -599,6 +655,7 @@ class KneeboardGenerator(MissionInfoGenerator):
             return StrikeTaskPage(flight, self.dark_kneeboard, self.game.theater)
         return None
 
+    @has_save_compat_for(4)
     def generate_flight_kneeboard(self, flight: FlightData) -> List[KneeboardPage]:
         """Returns a list of kneeboard pages for the given flight."""
         pages: List[KneeboardPage] = [
@@ -620,6 +677,10 @@ class KneeboardGenerator(MissionInfoGenerator):
             ),
         ]
 
+        # Only create the notes page if there are notes to show.
+        if notes := getattr(self.game, "notes", ""):
+            pages.append(NotesPage(notes, self.dark_kneeboard))
+
         if (target_page := self.generate_task_page(flight)) is not None:
             pages.append(target_page)
 

gen/locations/preset_control_point_locations.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass, field
-
-from typing import List
-
-from gen.locations.preset_locations import PresetLocation
-
-
-@dataclass
-class PresetControlPointLocations:
-    """A repository of preset locations for a given control point"""
-
-    # List of possible ashore locations to generate objects (Represented in miz file by an APC_AAV_7_Amphibious)
-    ashore_locations: List[PresetLocation] = field(default_factory=list)
-
-    # List of possible offshore locations to generate ship groups (Represented in miz file by an Oliver Hazard Perry)
-    offshore_locations: List[PresetLocation] = field(default_factory=list)
-
-    # Possible antiship missiles sites locations (Represented in miz file by Iranian Silkworm missiles)
-    antiship_locations: List[PresetLocation] = field(default_factory=list)
-
-    # List of possible powerplants locations (Represented in miz file by static Workshop A object, USA)
-    powerplant_locations: List[PresetLocation] = field(default_factory=list)

gen/locations/preset_locations.py

@@ -1,21 +0,0 @@
-from dataclasses import dataclass
-
-from dcs import Point
-
-
-@dataclass
-class PresetLocation:
-    """A preset location"""
-
-    position: Point
-    heading: int
-    id: str
-
-    def __str__(self):
-        return (
-            "-" * 10
-            + "X: {}\n Y: {}\nHdg: {}°\nId: {}".format(
-                self.position.x, self.position.y, self.heading, self.id
-            )
-            + "-" * 10
-        )

gen/missiles/missiles_group_generator.py

@@ -1,13 +1,20 @@
 import logging
 import random
-from game import db
+from typing import Optional
+
+from dcs.unitgroup import VehicleGroup
+
+from game import db, Game
+from game.theater.theatergroundobject import MissileSiteGroundObject
 from gen.missiles.scud_site import ScudGenerator
 from gen.missiles.v1_group import V1GroupGenerator
 
 MISSILES_MAP = {"V1GroupGenerator": V1GroupGenerator, "ScudGenerator": ScudGenerator}
 
 
-def generate_missile_group(game, ground_object, faction_name: str):
+def generate_missile_group(
+    game: Game, ground_object: MissileSiteGroundObject, faction_name: str
+) -> Optional[VehicleGroup]:
     """
     This generate a missiles group
     :return: Nothing, but put the group reference inside the ground object

gen/missiles/scud_site.py

@@ -2,33 +2,38 @@ import random
 
 from dcs.vehicles import Unarmed, MissilesSS, AirDefence
 
-from gen.sam.group_generator import GroupGenerator
+from game import Game
+from game.factions.faction import Faction
+from game.theater.theatergroundobject import MissileSiteGroundObject
+from gen.sam.group_generator import VehicleGroupGenerator
 
 
-class ScudGenerator(GroupGenerator):
-    def __init__(self, game, ground_object, faction):
+class ScudGenerator(VehicleGroupGenerator[MissileSiteGroundObject]):
+    def __init__(
+        self, game: Game, ground_object: MissileSiteGroundObject, faction: Faction
+    ) -> None:
         super(ScudGenerator, self).__init__(game, ground_object)
         self.faction = faction
 
-    def generate(self):
+    def generate(self) -> None:
 
         # Scuds
         self.add_unit(
-            MissilesSS.SSM_SS_1C_Scud_B,
+            MissilesSS.Scud_B,
             "V1#0",
             self.position.x,
             self.position.y + random.randint(1, 8),
             self.heading,
         )
         self.add_unit(
-            MissilesSS.SSM_SS_1C_Scud_B,
+            MissilesSS.Scud_B,
             "V1#1",
             self.position.x + 50,
             self.position.y + random.randint(1, 8),
             self.heading,
         )
         self.add_unit(
-            MissilesSS.SSM_SS_1C_Scud_B,
+            MissilesSS.Scud_B,
             "V1#2",
             self.position.x + 100,
             self.position.y + random.randint(1, 8),
@@ -37,7 +42,7 @@ class ScudGenerator(GroupGenerator):
 
         # Commander
         self.add_unit(
-            Unarmed.LUV_UAZ_469_Jeep,
+            Unarmed.UAZ_469,
             "Kubel#0",
             self.position.x - 35,
             self.position.y - 20,
@@ -46,7 +51,7 @@ class ScudGenerator(GroupGenerator):
 
         # Shorad
         self.add_unit(
-            AirDefence.SPAAA_ZSU_23_4_Shilka_Gun_Dish,
+            AirDefence.ZSU_23_4_Shilka,
             "SHILKA#0",
             self.position.x - 55,
             self.position.y - 38,
@@ -54,7 +59,7 @@ class ScudGenerator(GroupGenerator):
         )
 
         self.add_unit(
-            AirDefence.SAM_SA_9_Strela_1_Gaskin_TEL,
+            AirDefence.Strela_1_9P31,
             "STRELA#0",
             self.position.x + 200,
             self.position.y + 15,

gen/missiles/v1_group.py

@@ -2,33 +2,38 @@ import random
 
 from dcs.vehicles import Unarmed, MissilesSS, AirDefence
 
-from gen.sam.group_generator import GroupGenerator
+from game import Game
+from game.factions.faction import Faction
+from game.theater.theatergroundobject import MissileSiteGroundObject
+from gen.sam.group_generator import VehicleGroupGenerator
 
 
-class V1GroupGenerator(GroupGenerator):
-    def __init__(self, game, ground_object, faction):
+class V1GroupGenerator(VehicleGroupGenerator[MissileSiteGroundObject]):
+    def __init__(
+        self, game: Game, ground_object: MissileSiteGroundObject, faction: Faction
+    ) -> None:
         super(V1GroupGenerator, self).__init__(game, ground_object)
         self.faction = faction
 
-    def generate(self):
+    def generate(self) -> None:
 
         # Ramps
         self.add_unit(
-            MissilesSS.SSM_V_1_Launcher,
+            MissilesSS.V1_launcher,
             "V1#0",
             self.position.x,
             self.position.y + random.randint(1, 8),
             self.heading,
         )
         self.add_unit(
-            MissilesSS.SSM_V_1_Launcher,
+            MissilesSS.V1_launcher,
             "V1#1",
             self.position.x + 50,
             self.position.y + random.randint(1, 8),
             self.heading,
         )
         self.add_unit(
-            MissilesSS.SSM_V_1_Launcher,
+            MissilesSS.V1_launcher,
             "V1#2",
             self.position.x + 100,
             self.position.y + random.randint(1, 8),
@@ -37,7 +42,7 @@ class V1GroupGenerator(GroupGenerator):
 
         # Commander
         self.add_unit(
-            Unarmed.LUV_Kubelwagen_82,
+            Unarmed.Kubelwagen_82,
             "Kubel#0",
             self.position.x - 35,
             self.position.y - 20,
@@ -45,9 +50,7 @@ class V1GroupGenerator(GroupGenerator):
         )
 
         # Self defense flak
-        flak_unit = random.choice(
-            [AirDefence.AAA_Flak_Vierling_38_Quad_20mm, AirDefence.AAA_Flak_38_20mm]
-        )
+        flak_unit = random.choice([AirDefence.Flak38, AirDefence.Flak30])
 
         self.add_unit(
             flak_unit,
@@ -58,7 +61,7 @@ class V1GroupGenerator(GroupGenerator):
         )
 
         self.add_unit(
-            Unarmed.Truck_Opel_Blitz,
+            Unarmed.Blitz_36_6700A,
             "Blitz#0",
             self.position.x + 200,
             self.position.y + 15,

gen/naming.py

@@ -1,12 +1,11 @@
 import random
 import time
-from typing import List
+from typing import List, Any
 
 from dcs.country import Country
-from dcs.unittype import UnitType
-
-from game import db
 
+from game.dcs.aircrafttype import AircraftType
+from game.dcs.unittype import UnitType
 from gen.flights.flight import Flight
 
 ALPHA_MILITARY = [
@@ -257,7 +256,7 @@ class NameGenerator:
     existing_alphas: List[str] = []
 
     @classmethod
-    def reset(cls):
+    def reset(cls) -> None:
         cls.number = 0
         cls.infantry_number = 0
         cls.convoy_number = 0
@@ -266,7 +265,7 @@ class NameGenerator:
         cls.existing_alphas = []
 
     @classmethod
-    def reset_numbers(cls):
+    def reset_numbers(cls) -> None:
         cls.number = 0
         cls.infantry_number = 0
         cls.aircraft_number = 0
@@ -274,7 +273,9 @@ class NameGenerator:
         cls.cargo_ship_number = 0
 
     @classmethod
-    def next_aircraft_name(cls, country: Country, parent_base_id: int, flight: Flight):
+    def next_aircraft_name(
+        cls, country: Country, parent_base_id: int, flight: Flight
+    ) -> str:
         cls.aircraft_number += 1
         try:
             if flight.custom_name:
@@ -290,42 +291,42 @@ class NameGenerator:
             country.id,
             cls.aircraft_number,
             parent_base_id,
-            db.unit_type_name(flight.unit_type),
+            flight.unit_type.name,
         )
 
     @classmethod
-    def next_unit_name(cls, country: Country, parent_base_id: int, unit_type: UnitType):
+    def next_unit_name(
+        cls, country: Country, parent_base_id: int, unit_type: UnitType[Any]
+    ) -> str:
         cls.number += 1
         return "unit|{}|{}|{}|{}|".format(
-            country.id, cls.number, parent_base_id, db.unit_type_name(unit_type)
+            country.id, cls.number, parent_base_id, unit_type.name
         )
 
     @classmethod
     def next_infantry_name(
-        cls, country: Country, parent_base_id: int, unit_type: UnitType
-    ):
+        cls, country: Country, parent_base_id: int, unit_type: UnitType[Any]
+    ) -> str:
         cls.infantry_number += 1
         return "infantry|{}|{}|{}|{}|".format(
             country.id,
             cls.infantry_number,
             parent_base_id,
-            db.unit_type_name(unit_type),
+            unit_type.name,
         )
 
     @classmethod
-    def next_awacs_name(cls, country: Country):
+    def next_awacs_name(cls, country: Country) -> str:
         cls.number += 1
         return "awacs|{}|{}|0|".format(country.id, cls.number)
 
     @classmethod
-    def next_tanker_name(cls, country: Country, unit_type: UnitType):
+    def next_tanker_name(cls, country: Country, unit_type: AircraftType) -> str:
         cls.number += 1
-        return "tanker|{}|{}|0|{}".format(
-            country.id, cls.number, db.unit_type_name(unit_type)
-        )
+        return "tanker|{}|{}|0|{}".format(country.id, cls.number, unit_type.name)
 
     @classmethod
-    def next_carrier_name(cls, country: Country):
+    def next_carrier_name(cls, country: Country) -> str:
         cls.number += 1
         return "carrier|{}|{}|0|".format(country.id, cls.number)
 
@@ -340,7 +341,7 @@ class NameGenerator:
         return f"Cargo Ship {cls.cargo_ship_number:03}"
 
     @classmethod
-    def random_objective_name(cls):
+    def random_objective_name(cls) -> str:
         if cls.animals:
             animal = random.choice(cls.animals)
             cls.animals.remove(animal)

gen/radios.py

@@ -15,7 +15,7 @@ class RadioFrequency:
     #: The frequency in kilohertz.
     hertz: int
 
-    def __str__(self):
+    def __str__(self) -> str:
         if self.hertz >= 1000000:
             return self.format("MHz", 1000000)
         return self.format("kHz", 1000)
@@ -134,6 +134,7 @@ RADIOS: List[Radio] = [
     Radio("AN/ARC-51BX", MHz(225), MHz(400), step=kHz(50)),
     Radio("AN/ARC-131", MHz(30), MHz(76), step=kHz(50)),
     Radio("AN/ARC-134", MHz(116), MHz(150), step=kHz(25)),
+    Radio("R&S Series 6000", MHz(100), MHz(156), step=kHz(25)),
 ]
 
 
@@ -152,7 +153,7 @@ def get_radio(name: str) -> Radio:
     for radio in RADIOS:
         if radio.name == name:
             return radio
-    raise KeyError
+    raise KeyError(f"Unknown radio: {name}")
 
 
 class RadioRegistry:

gen/sam/aaa_bofors.py

@@ -14,25 +14,21 @@ class BoforsGenerator(AirDefenseGroupGenerator):
     """
 
     name = "Bofors AAA"
-    price = 75
 
-    def generate(self):
-        grid_x = random.randint(2, 3)
-        grid_y = random.randint(2, 3)
-
-        spacing = random.randint(10, 40)
+    def generate(self) -> None:
 
         index = 0
-        for i in range(grid_x):
-            for j in range(grid_y):
-                index = index + 1
-                self.add_unit(
-                    AirDefence.AAA_Bofors_40mm,
-                    "AAA#" + str(index),
-                    self.position.x + spacing * i,
-                    self.position.y + spacing * j,
-                    self.heading,
-                )
+        for i in range(4):
+            spacing_x = random.randint(10, 40)
+            spacing_y = random.randint(10, 40)
+            index = index + 1
+            self.add_unit(
+                AirDefence.Bofors40,
+                "AAA#" + str(index),
+                self.position.x + spacing_x * i,
+                self.position.y + spacing_y * i,
+                self.heading,
+            )
 
     @classmethod
     def range(cls) -> AirDefenseRange:

gen/sam/aaa_flak.py

@@ -8,12 +8,12 @@ from gen.sam.airdefensegroupgenerator import (
 )
 
 GFLAK = [
-    AirDefence.AAA_Flak_Vierling_38_Quad_20mm,
-    AirDefence.AAA_8_8cm_Flak_18,
-    AirDefence.AAA_8_8cm_Flak_36,
-    AirDefence.AAA_8_8cm_Flak_37,
-    AirDefence.AAA_8_8cm_Flak_41,
-    AirDefence.AAA_Flak_38_20mm,
+    AirDefence.Flak38,
+    AirDefence.Flak18,
+    AirDefence.Flak36,
+    AirDefence.Flak37,
+    AirDefence.Flak41,
+    AirDefence.Flak30,
 ]
 
 
@@ -23,37 +23,32 @@ class FlakGenerator(AirDefenseGroupGenerator):
     """
 
     name = "Flak Site"
-    price = 135
-
-    def generate(self):
-        grid_x = random.randint(2, 3)
-        grid_y = random.randint(2, 3)
-
-        spacing = random.randint(20, 35)
 
+    def generate(self) -> None:
         index = 0
         mixed = random.choice([True, False])
         unit_type = random.choice(GFLAK)
 
-        for i in range(grid_x):
-            for j in range(grid_y):
-                index = index + 1
-                self.add_unit(
-                    unit_type,
-                    "AAA#" + str(index),
-                    self.position.x + spacing * i + random.randint(1, 5),
-                    self.position.y + spacing * j + random.randint(1, 5),
-                    self.heading,
-                )
+        for i in range(4):
+            index = index + 1
+            spacing_x = random.randint(10, 40)
+            spacing_y = random.randint(10, 40)
+            self.add_unit(
+                unit_type,
+                "AAA#" + str(index),
+                self.position.x + spacing_x * i + random.randint(1, 5),
+                self.position.y + spacing_y * i + random.randint(1, 5),
+                self.heading,
+            )
 
-                if mixed:
-                    unit_type = random.choice(GFLAK)
+            if mixed:
+                unit_type = random.choice(GFLAK)
 
         # Search lights
         search_pos = self.get_circular_position(random.randint(2, 3), 80)
         for index, pos in enumerate(search_pos):
             self.add_unit(
-                AirDefence.SL_Flakscheinwerfer_37,
+                AirDefence.Flakscheinwerfer_37,
                 "SearchLight#" + str(index),
                 pos[0],
                 pos[1],
@@ -62,14 +57,14 @@ class FlakGenerator(AirDefenseGroupGenerator):
 
         # Support
         self.add_unit(
-            AirDefence.PU_Maschinensatz_33,
+            AirDefence.Maschinensatz_33,
             "MC33#",
             self.position.x - 20,
             self.position.y - 20,
             self.heading,
         )
         self.add_unit(
-            AirDefence.AAA_SP_Kdo_G_40,
+            AirDefence.KDO_Mod40,
             "KDO#",
             self.position.x - 25,
             self.position.y - 20,
@@ -78,7 +73,7 @@ class FlakGenerator(AirDefenseGroupGenerator):
 
         # Commander
         self.add_unit(
-            Unarmed.LUV_Kubelwagen_82,
+            Unarmed.Kubelwagen_82,
             "Kubel#",
             self.position.x - 35,
             self.position.y - 20,
@@ -86,10 +81,12 @@ class FlakGenerator(AirDefenseGroupGenerator):
         )
 
         # Some Opel Blitz trucks
-        for i in range(int(max(1, grid_x / 2))):
-            for j in range(int(max(1, grid_x / 2))):
+        index = 0
+        for i in range(int(max(1, 2))):
+            for j in range(int(max(1, 2))):
+                index += 1
                 self.add_unit(
-                    Unarmed.Truck_Opel_Blitz,
+                    Unarmed.Blitz_36_6700A,
                     "BLITZ#" + str(index),
                     self.position.x + 125 + 15 * i + random.randint(1, 5),
                     self.position.y + 15 * j + random.randint(1, 5),

gen/sam/aaa_flak18.py

@@ -14,9 +14,8 @@ class Flak18Generator(AirDefenseGroupGenerator):
     """
 
     name = "WW2 Flak Site"
-    price = 40
 
-    def generate(self):
+    def generate(self) -> None:
 
         spacing = random.randint(30, 60)
         index = 0
@@ -25,7 +24,7 @@ class Flak18Generator(AirDefenseGroupGenerator):
             for j in range(2):
                 index = index + 1
                 self.add_unit(
-                    AirDefence.AAA_8_8cm_Flak_18,
+                    AirDefence.Flak18,
                     "AAA#" + str(index),
                     self.position.x + spacing * i + random.randint(1, 5),
                     self.position.y + spacing * j + random.randint(1, 5),
@@ -34,7 +33,7 @@ class Flak18Generator(AirDefenseGroupGenerator):
 
         # Add a commander truck
         self.add_unit(
-            Unarmed.Truck_Opel_Blitz,
+            Unarmed.Blitz_36_6700A,
             "Blitz#",
             self.position.x - 35,
             self.position.y - 20,

gen/sam/aaa_ks19.py

@@ -13,12 +13,8 @@ class KS19Generator(AirDefenseGroupGenerator):
     """
 
     name = "KS-19 AAA Site"
-    price = 98
-
-    def generate(self):
-
-        spacing = random.randint(10, 40)
 
+    def generate(self) -> None:
         self.add_unit(
             highdigitsams.AAA_SON_9_Fire_Can,
             "TR",
@@ -28,16 +24,17 @@ class KS19Generator(AirDefenseGroupGenerator):
         )
 
         index = 0
-        for i in range(3):
-            for j in range(3):
-                index = index + 1
-                self.add_unit(
-                    highdigitsams.AAA_100mm_KS_19,
-                    "AAA#" + str(index),
-                    self.position.x + spacing * i,
-                    self.position.y + spacing * j,
-                    self.heading,
-                )
+        for i in range(4):
+            spacing_x = random.randint(10, 40)
+            spacing_y = random.randint(10, 40)
+            index = index + 1
+            self.add_unit(
+                highdigitsams.AAA_100mm_KS_19,
+                "AAA#" + str(index),
+                self.position.x + spacing_x * i,
+                self.position.y + spacing_y * i,
+                self.heading,
+            )
 
     @classmethod
     def range(cls) -> AirDefenseRange:

gen/sam/aaa_ww2_ally_flak.py

@@ -14,14 +14,13 @@ class AllyWW2FlakGenerator(AirDefenseGroupGenerator):
     """
 
     name = "WW2 Ally Flak Site"
-    price = 140
 
-    def generate(self):
+    def generate(self) -> None:
 
         positions = self.get_circular_position(4, launcher_distance=30, coverage=360)
         for i, position in enumerate(positions):
             self.add_unit(
-                AirDefence.AAA_QF_3_7,
+                AirDefence.QF_37_AA,
                 "AA#" + str(i),
                 position[0],
                 position[1],
@@ -31,7 +30,7 @@ class AllyWW2FlakGenerator(AirDefenseGroupGenerator):
         positions = self.get_circular_position(8, launcher_distance=60, coverage=360)
         for i, position in enumerate(positions):
             self.add_unit(
-                AirDefence.AAA_M1_37mm,
+                AirDefence.M1_37mm,
                 "AA#" + str(4 + i),
                 position[0],
                 position[1],
@@ -41,7 +40,7 @@ class AllyWW2FlakGenerator(AirDefenseGroupGenerator):
         positions = self.get_circular_position(8, launcher_distance=90, coverage=360)
         for i, position in enumerate(positions):
             self.add_unit(
-                AirDefence.AAA_M45_Quadmount_HB_12_7mm,
+                AirDefence.M45_Quadmount,
                 "AA#" + str(12 + i),
                 position[0],
                 position[1],
@@ -50,28 +49,28 @@ class AllyWW2FlakGenerator(AirDefenseGroupGenerator):
 
         # Add a commander truck
         self.add_unit(
-            Unarmed.Car_Willys_Jeep,
+            Unarmed.Willys_MB,
             "CMD#1",
             self.position.x,
             self.position.y - 20,
             random.randint(0, 360),
         )
         self.add_unit(
-            Unarmed.Carrier_M30_Cargo,
+            Unarmed.M30_CC,
             "LOG#1",
             self.position.x,
             self.position.y + 20,
             random.randint(0, 360),
         )
         self.add_unit(
-            Unarmed.Tractor_M4_Hi_Speed,
+            Unarmed.M4_Tractor,
             "LOG#2",
             self.position.x + 20,
             self.position.y,
             random.randint(0, 360),
         )
         self.add_unit(
-            Unarmed.Truck_Bedford,
+            Unarmed.Bedford_MWD,
             "LOG#3",
             self.position.x - 20,
             self.position.y,

gen/sam/aaa_zsu57.py

@@ -12,16 +12,15 @@ class ZSU57Generator(AirDefenseGroupGenerator):
     """
 
     name = "ZSU-57-2 Group"
-    price = 60
 
-    def generate(self):
-        num_launchers = 5
+    def generate(self) -> None:
+        num_launchers = 4
         positions = self.get_circular_position(
             num_launchers, launcher_distance=110, coverage=360
         )
         for i, position in enumerate(positions):
             self.add_unit(
-                AirDefence.SPAAA_ZSU_57_2,
+                AirDefence.ZSU_57_2,
                 "SPAA#" + str(i),
                 position[0],
                 position[1],

gen/sam/aaa_zu23_insurgent.py

@@ -14,25 +14,20 @@ class ZU23InsurgentGenerator(AirDefenseGroupGenerator):
     """
 
     name = "Zu-23 Site"
-    price = 56
-
-    def generate(self):
-        grid_x = random.randint(2, 3)
-        grid_y = random.randint(2, 3)
-
-        spacing = random.randint(10, 40)
 
+    def generate(self) -> None:
         index = 0
-        for i in range(grid_x):
-            for j in range(grid_y):
-                index = index + 1
-                self.add_unit(
-                    AirDefence.AAA_ZU_23_Insurgent_Closed_Emplacement,
-                    "AAA#" + str(index),
-                    self.position.x + spacing * i,
-                    self.position.y + spacing * j,
-                    self.heading,
-                )
+        for i in range(4):
+            index = index + 1
+            spacing_x = random.randint(10, 40)
+            spacing_y = random.randint(10, 40)
+            self.add_unit(
+                AirDefence.ZU_23_Closed_Insurgent,
+                "AAA#" + str(index),
+                self.position.x + spacing_x * i,
+                self.position.y + spacing_y * i,
+                self.heading,
+            )
 
     @classmethod
     def range(cls) -> AirDefenseRange: