Merge pull request #187 from Khopa/develop_2_1_x

2.1.5

.github/workflows/build.yml

@@ -18,30 +18,15 @@ jobs:
 
     - name: Install environment
       run: |
-        python -m venv ./venv
+        py -m venv ./venv
 
     - name: Install dependencies
       run: |
         ./venv/scripts/activate
-        python -m pip install -r requirements.txt
+        pip install -r requirements.txt
         # For some reason the shiboken2.abi3.dll is not found properly, so I copy it instead
         Copy-Item .\venv\Lib\site-packages\shiboken2\shiboken2.abi3.dll .\venv\Lib\site-packages\PySide2\ -Force
 
-    - name: mypy game
-      run: |
-        ./venv/scripts/activate
-        mypy game
-
-    - name: mypy gen
-      run: |
-        ./venv/scripts/activate
-        mypy gen
-
-    - name: mypy theater
-      run: |
-        ./venv/scripts/activate
-        mypy theater
-
     - name: Build binaries
       run: |
         ./venv/scripts/activate

.github/workflows/release.yml

@@ -20,30 +20,15 @@ jobs:
 
     - name: Install environment
       run: |
-        python -m venv ./venv
+        py -m venv ./venv
 
     - name: Install dependencies
       run: |
         ./venv/scripts/activate
-        python -m pip install -r requirements.txt
+        pip install -r requirements.txt
         # For some reason the shiboken2.abi3.dll is not found properly, so I copy it instead
         Copy-Item .\venv\Lib\site-packages\shiboken2\shiboken2.abi3.dll .\venv\Lib\site-packages\PySide2\ -Force
 
-    - name: mypy game
-      run: |
-        ./venv/scripts/activate
-        mypy game
-
-    - name: mypy gen
-      run: |
-        ./venv/scripts/activate
-        mypy gen
-
-    - name: mypy theater
-      run: |
-        ./venv/scripts/activate
-        mypy theater
-
     - name: Build binaries
       run: |
         ./venv/scripts/activate

.gitignore

@@ -8,6 +8,7 @@ logs.txt
 dist/**
 a.py
 resources/tools/a.miz
+tests/**
 # User-specific stuff
 .idea/
 
@@ -15,8 +16,9 @@ resources/tools/a.miz
 /liberation_preferences.json
 /state.json
 
-logs/
+logs/liberation.log
 
 qt_ui/logs/liberation.log
 
 *.psd
+resources/scripts/plugins/*

changelog.md

@@ -1,18 +1,3 @@
-# 2.2.X
-
-## Features/Improvements :
-* **[Flight Planner]** Flight planner overhaul, with package and TOT system
-* **[Map]** Highlight the selected flight path on the map
-* **[Map]** Improved flight plan display settings 
-* **[Map]** Improved SAM display settings
-* **[Map]** Added polygon debug mode display
-* **[New Game]** Starting budget can be freely selected 
-* **[Moddability]** Custom campaigns can be designed through json files 
-
-## Fixes :
-* **[Campaign generator]** Ship group and offshore buildings should not be generated on land anymore 
-* **[UI]** Missing TER weapons in custom payload now selectable.
-
 # 2.1.5
 
 ## Features/Improvements :
@@ -25,7 +10,9 @@
 # 2.1.4
 
 ## Fixes :
-* **[UI]** Fixed an issue that prevented generating the mission (take off button no working) on old savegames.
+* **[UI]** Fixed an issue that prevent generating the mission (take off button no working) on old savegames.
+
+# 2.1.3
 
 ## Features/Improvements :
 * **[Units/Factions]** Added A-10C_2 to USA 2005 and Bluefor modern factions

game/__init__.py

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

game/data/cap_capabilities_db.py

@@ -1,22 +1,4 @@
-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_51D,
-    P_51D_30_NA,
-    SpitfireLFMkIX,
-    SpitfireLFMkIXCW,
-)
-
+from dcs.planes import *
 from pydcs_extensions.a4ec.a4ec import A_4E_C
 
 """

game/data/doctrine.py

@@ -1,101 +1,95 @@
-from dataclasses import dataclass
-
 from game.utils import nm_to_meter, feet_to_meter
 
+MODERN_DOCTRINE = {
 
-@dataclass(frozen=True)
-class Doctrine:
-    cas: bool
-    cap: bool
-    sead: bool
-    strike: bool
-    antiship: bool
+    "GENERATORS": {
+        "CAS": True,
+        "CAP": True,
+        "SEAD": True,
+        "STRIKE": True,
+        "ANTISHIP": True,
+    },
 
-    strike_max_range: int
-    sead_max_range: int
+    "STRIKE_MAX_RANGE": 1500000,
+    "SEAD_MAX_RANGE": 1500000,
 
-    rendezvous_altitude: int
-    join_distance: int
-    split_distance: int
-    ingress_egress_distance: int
-    ingress_altitude: int
-    egress_altitude: int
+    "CAP_EVERY_X_MINUTES": 20,
+    "CAS_EVERY_X_MINUTES": 30,
+    "SEAD_EVERY_X_MINUTES": 40,
+    "STRIKE_EVERY_X_MINUTES": 40,
 
-    min_patrol_altitude: int
-    max_patrol_altitude: int
-    pattern_altitude: int
+    "INGRESS_EGRESS_DISTANCE": nm_to_meter(45),
+    "INGRESS_ALT": feet_to_meter(20000),
+    "EGRESS_ALT": feet_to_meter(20000),
+    "PATROL_ALT_RANGE": (feet_to_meter(15000), feet_to_meter(33000)),
+    "PATTERN_ALTITUDE": feet_to_meter(5000),
 
-    cap_min_track_length: int
-    cap_max_track_length: int
-    cap_min_distance_from_cp: int
-    cap_max_distance_from_cp: int
+    "CAP_PATTERN_LENGTH": (nm_to_meter(15), nm_to_meter(40)),
+    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(6), nm_to_meter(15)),
+    "CAP_DISTANCE_FROM_CP": (nm_to_meter(10), nm_to_meter(40)),
 
+    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
+}
 
-MODERN_DOCTRINE = Doctrine(
-    cap=True,
-    cas=True,
-    sead=True,
-    strike=True,
-    antiship=True,
-    strike_max_range=1500000,
-    sead_max_range=1500000,
-    rendezvous_altitude=feet_to_meter(25000),
-    join_distance=nm_to_meter(20),
-    split_distance=nm_to_meter(20),
-    ingress_egress_distance=nm_to_meter(45),
-    ingress_altitude=feet_to_meter(20000),
-    egress_altitude=feet_to_meter(20000),
-    min_patrol_altitude=feet_to_meter(15000),
-    max_patrol_altitude=feet_to_meter(33000),
-    pattern_altitude=feet_to_meter(5000),
-    cap_min_track_length=nm_to_meter(15),
-    cap_max_track_length=nm_to_meter(40),
-    cap_min_distance_from_cp=nm_to_meter(10),
-    cap_max_distance_from_cp=nm_to_meter(40),
-)
+COLDWAR_DOCTRINE = {
 
-COLDWAR_DOCTRINE = Doctrine(
-    cap=True,
-    cas=True,
-    sead=True,
-    strike=True,
-    antiship=True,
-    strike_max_range=1500000,
-    sead_max_range=1500000,
-    rendezvous_altitude=feet_to_meter(22000),
-    join_distance=nm_to_meter(10),
-    split_distance=nm_to_meter(10),
-    ingress_egress_distance=nm_to_meter(30),
-    ingress_altitude=feet_to_meter(18000),
-    egress_altitude=feet_to_meter(18000),
-    min_patrol_altitude=feet_to_meter(10000),
-    max_patrol_altitude=feet_to_meter(24000),
-    pattern_altitude=feet_to_meter(5000),
-    cap_min_track_length=nm_to_meter(12),
-    cap_max_track_length=nm_to_meter(24),
-    cap_min_distance_from_cp=nm_to_meter(8),
-    cap_max_distance_from_cp=nm_to_meter(25),
-)
+    "GENERATORS": {
+        "CAS": True,
+        "CAP": True,
+        "SEAD": True,
+        "STRIKE": True,
+        "ANTISHIP": True,
+    },
 
-WWII_DOCTRINE = Doctrine(
-    cap=True,
-    cas=True,
-    sead=False,
-    strike=True,
-    antiship=True,
-    strike_max_range=1500000,
-    sead_max_range=1500000,
-    join_distance=nm_to_meter(5),
-    split_distance=nm_to_meter(5),
-    rendezvous_altitude=feet_to_meter(10000),
-    ingress_egress_distance=nm_to_meter(7),
-    ingress_altitude=feet_to_meter(8000),
-    egress_altitude=feet_to_meter(8000),
-    min_patrol_altitude=feet_to_meter(4000),
-    max_patrol_altitude=feet_to_meter(15000),
-    pattern_altitude=feet_to_meter(5000),
-    cap_min_track_length=nm_to_meter(8),
-    cap_max_track_length=nm_to_meter(18),
-    cap_min_distance_from_cp=nm_to_meter(0),
-    cap_max_distance_from_cp=nm_to_meter(5),
-)
+    "STRIKE_MAX_RANGE": 1500000,
+    "SEAD_MAX_RANGE": 1500000,
+
+    "CAP_EVERY_X_MINUTES": 20,
+    "CAS_EVERY_X_MINUTES": 30,
+    "SEAD_EVERY_X_MINUTES": 40,
+    "STRIKE_EVERY_X_MINUTES": 40,
+
+    "INGRESS_EGRESS_DISTANCE": nm_to_meter(30),
+    "INGRESS_ALT": feet_to_meter(18000),
+    "EGRESS_ALT": feet_to_meter(18000),
+    "PATROL_ALT_RANGE": (feet_to_meter(10000), feet_to_meter(24000)),
+    "PATTERN_ALTITUDE": feet_to_meter(5000),
+
+    "CAP_PATTERN_LENGTH": (nm_to_meter(12), nm_to_meter(24)),
+    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(2), nm_to_meter(8)),
+    "CAP_DISTANCE_FROM_CP": (nm_to_meter(8), nm_to_meter(25)),
+
+    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
+}
+
+WWII_DOCTRINE = {
+
+    "GENERATORS": {
+        "CAS": True,
+        "CAP": True,
+        "SEAD": False,
+        "STRIKE": True,
+        "ANTISHIP": True,
+    },
+
+    "STRIKE_MAX_RANGE": 1500000,
+    "SEAD_MAX_RANGE": 1500000,
+
+    "CAP_EVERY_X_MINUTES": 20,
+    "CAS_EVERY_X_MINUTES": 30,
+    "SEAD_EVERY_X_MINUTES": 40,
+    "STRIKE_EVERY_X_MINUTES": 40,
+
+    "INGRESS_EGRESS_DISTANCE": nm_to_meter(7),
+    "INGRESS_ALT": feet_to_meter(8000),
+    "EGRESS_ALT": feet_to_meter(8000),
+    "PATROL_ALT_RANGE": (feet_to_meter(4000), feet_to_meter(15000)),
+    "PATTERN_ALTITUDE": feet_to_meter(5000),
+
+    "CAP_PATTERN_LENGTH": (nm_to_meter(8), nm_to_meter(18)),
+    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(1), nm_to_meter(6)),
+    "CAP_DISTANCE_FROM_CP": (nm_to_meter(0), nm_to_meter(5)),
+
+    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
+
+}

game/data/radar_db.py

@@ -1,26 +1,5 @@
-from dcs.ships import (
-    CGN_1144_2_Pyotr_Velikiy,
-    CG_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,
-    FFG_11540_Neustrashimy,
-    FFL_1124_4_Grisha,
-    FF_1135M_Rezky,
-    FSG_1241_1MP_Molniya,
-    LHA_1_Tarawa,
-    Oliver_Hazzard_Perry_class,
-    Ticonderoga_class,
-    Type_052B_Destroyer,
-    Type_052C_Destroyer,
-    Type_054A_Frigate,
-    USS_Arleigh_Burke_IIa,
-)
 from dcs.vehicles import AirDefence
+from dcs.ships import *
 
 UNITS_WITH_RADAR = [
 

game/db.py

@@ -1,171 +1,77 @@
+import typing
+import enum
 from datetime import datetime
-from enum import Enum
-from typing import Dict, List, Optional, Tuple, Type, Union
 
-from dcs.countries import country_dict
-from dcs.helicopters import (
-    AH_1W,
-    AH_64A,
-    AH_64D,
-    HelicopterType,
-    Ka_50,
-    Mi_24V,
-    Mi_28N,
-    Mi_8MT,
-    OH_58D,
-    SA342L,
-    SA342M,
-    SA342Minigun,
-    SA342Mistral,
-    UH_1H,
-    UH_60A,
-    helicopter_map,
-)
-from dcs.mapping import Point
-# mypy can't resolve these if they're wildcard imports for some reason.
-from dcs.planes import (
-    AJS37,
-    AV8BNA,
-    A_10A,
-    A_10C,
-    A_10C_2,
-    A_20G,
-    A_50,
-    An_26B,
-    An_30M,
-    B_17G,
-    B_1B,
-    B_52H,
-    Bf_109K_4,
-    C_101CC,
-    C_130,
-    E_3A,
-    FA_18C_hornet,
-    FW_190A8,
-    FW_190D9,
-    F_117A,
-    F_14B,
-    F_15C,
-    F_15E,
-    F_16A,
-    F_16C_50,
-    F_4E,
-    F_5E_3,
-    F_86F_Sabre,
-    F_A_18C,
-    IL_76MD,
-    IL_78M,
-    JF_17,
-    J_11A,
-    Ju_88A4,
-    KC130,
-    KC_135,
-    KJ_2000,
-    L_39C,
-    L_39ZA,
-    MQ_9_Reaper,
-    M_2000C,
-    MiG_15bis,
-    MiG_19P,
-    MiG_21Bis,
-    MiG_23MLD,
-    MiG_25PD,
-    MiG_27K,
-    MiG_29A,
-    MiG_29G,
-    MiG_29S,
-    MiG_31,
-    Mirage_2000_5,
-    P_47D_30,
-    P_47D_30bl1,
-    P_47D_40,
-    P_51D,
-    P_51D_30_NA,
-    PlaneType,
-    RQ_1A_Predator,
-    S_3B_Tanker,
-    SpitfireLFMkIX,
-    SpitfireLFMkIXCW,
-    Su_17M4,
-    Su_24M,
-    Su_24MR,
-    Su_25,
-    Su_25T,
-    Su_25TM,
-    Su_27,
-    Su_30,
-    Su_33,
-    Su_34,
-    Tornado_GR4,
-    Tornado_IDS,
-    Tu_160,
-    Tu_22M3,
-    Tu_95MS,
-    WingLoong_I,
-    Yak_40,
-    plane_map,
-)
-from dcs.ships import (
-    Armed_speedboat,
-    Bulk_cargo_ship_Yakushev,
-    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,
-    Dry_cargo_ship_Ivanov,
-    LHA_1_Tarawa,
-    Tanker_Elnya_160,
-    ship_map,
-)
-from dcs.task import (
-    AWACS,
-    AntishipStrike,
-    CAP,
-    CAS,
-    CargoTransportation,
-    Embarking,
-    Escort,
-    GroundAttack,
-    Intercept,
-    MainTask,
-    Nothing,
-    PinpointStrike,
-    Reconnaissance,
-    Refueling,
-    SEAD,
-    Task,
-    Transport,
-)
-from dcs.terrain.terrain import Airport
-from dcs.unit import Ship, Unit, Vehicle
-from dcs.unitgroup import ShipGroup, StaticGroup
-from dcs.unittype import FlyingType, ShipType, UnitType, VehicleType
-from dcs.vehicles import (
-    AirDefence,
-    Armor,
-    Artillery,
-    Carriage,
-    Infantry,
-    Unarmed,
-    vehicle_map,
-)
+from dcs.countries import get_by_id, country_dict
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+from dcs.task import *
+from dcs.unit import *
+from dcs.unittype import *
+from dcs.unitgroup import *
+
+from game.factions.australia_2005 import Australia_2005
+from game.factions.bluefor_coldwar import BLUEFOR_COLDWAR
+from game.factions.bluefor_coldwar_a4 import BLUEFOR_COLDWAR_A4
+from game.factions.bluefor_coldwar_mods import BLUEFOR_COLDWAR_MODS
+from game.factions.canada_2005 import Canada_2005
+from game.factions.china_2010 import China_2010
+from game.factions.france_1995 import France_1995
+from game.factions.france_2005 import France_2005
+from game.factions.france_modded import France_2005_Modded
+from game.factions.germany_1944_easy import Germany_1944_Easy
+from game.factions.germany_1990 import Germany_1990
+from game.factions.insurgent import Insurgent
+from game.factions.insurgent_modded import Insurgent_modded
+from game.factions.iran_2015 import Iran_2015
+from game.factions.israel_1948 import Israel_1948
+from game.factions.israel_1973 import Israel_1973, Israel_1973_NO_WW2_UNITS, Israel_1982
+from game.factions.israel_2000 import Israel_2000
+from game.factions.italy_1990 import Italy_1990
+from game.factions.italy_1990_mb339 import Italy_1990_MB339
+from game.factions.japan_2005 import Japan_2005
+from game.factions.libya_2011 import Libya_2011
+from game.factions.netherlands_1990 import Netherlands_1990
+from game.factions.north_korea_2000 import NorthKorea_2000
+from game.factions.pakistan_2015 import Pakistan_2015
+from game.factions.private_miltary_companies import PMC_WESTERN_B, PMC_RUSSIAN, PMC_WESTERN_A
+from game.factions.russia_1975 import Russia_1975
+from game.factions.germany_1944 import Germany_1944
+from game.factions.india_2010 import India_2010
+from game.factions.russia_1955 import Russia_1955
+from game.factions.russia_1965 import Russia_1965
+from game.factions.russia_1990 import Russia_1990
+from game.factions.russia_2010 import Russia_2010
+from game.factions.spain_1990 import Spain_1990
+from game.factions.sweden_1990 import Sweden_1990
+from game.factions.syria import Syria_2011, Syria_1967, Syria_1967_WW2_Weapons, Syria_1973, Arab_Armies_1948, Syria_1982
+from game.factions.turkey_2005 import Turkey_2005
+from game.factions.uae_2005 import UAE_2005
+from game.factions.uk_1944 import UK_1944
+from game.factions.uk_1990 import UnitedKingdom_1990
+from game.factions.ukraine_2010 import Ukraine_2010
+from game.factions.us_aggressors import US_Aggressors
+from game.factions.usa_1944 import USA_1944, ALLIES_1944
+from game.factions.usa_1955 import USA_1955
+from game.factions.usa_1960 import USA_1960
+from game.factions.usa_1965 import USA_1965
+from game.factions.usa_1990 import USA_1990
+from game.factions.usa_2005 import USA_2005
+from game.factions.bluefor_modern import BLUEFOR_MODERN
 
-import pydcs_extensions.frenchpack.frenchpack as frenchpack
-from game.factions.faction import Faction
 # PATCH pydcs data with MODS
-from game.factions.faction_loader import FactionLoader
 from pydcs_extensions.a4ec.a4ec import A_4E_C
 from pydcs_extensions.mb339.mb339 import MB_339PAN
+import pydcs_extensions.frenchpack.frenchpack as frenchpack
 from pydcs_extensions.rafale.rafale import Rafale_A_S, Rafale_M
-from pydcs_extensions.su57.su57 import Su_57
 
 plane_map["A-4E-C"] = A_4E_C
 plane_map["MB-339PAN"] = MB_339PAN
 plane_map["Rafale_M"] = Rafale_M
 plane_map["Rafale_A_S"] = Rafale_A_S
-plane_map["Su-57"] = Su_57
 
 vehicle_map["FieldHL"] = frenchpack._FIELD_HIDE
 vehicle_map["HARRIERH"] = frenchpack._FIELD_HIDE_SMALL
@@ -242,7 +148,6 @@ PRICES = {
     J_11A: 26,
     JF_17: 20,
     Su_30: 24,
-    Su_57: 40,
 
     SpitfireLFMkIX: 14,
     SpitfireLFMkIXCW: 14,
@@ -307,10 +212,6 @@ PRICES = {
     # Bombers
     B_52H: 35,
     B_1B: 50,
-    F_117A: 100,
-    Tu_160: 50,
-    Tu_22M3: 40,
-    Tu_95MS: 35,
 
     # special
     IL_76MD: 30,
@@ -558,7 +459,6 @@ UNIT_BY_TASK = {
         F_5E_3,
         Su_27,
         Su_33,
-        Su_57,
         MiG_19P,
         MiG_21Bis,
         MiG_23MLD,
@@ -591,53 +491,49 @@ UNIT_BY_TASK = {
         SA342Mistral
     ],
     CAS: [
-        AH_1W,
-        AH_64A,
-        AH_64D,
-        AJS37,
+        F_15E,
+        F_86F_Sabre,
+        MiG_15bis,
+        L_39ZA,
         AV8BNA,
+        AJS37,
         A_10A,
         A_10C,
         A_10C_2,
-        A_20G,
-        B_17G,
-        B_1B,
-        B_52H,
-        F_117A,
-        F_15E,
-        F_86F_Sabre,
-        Ju_88A4,
-        Ka_50,
-        L_39ZA,
-        MB_339PAN,
-        MQ_9_Reaper,
-        MiG_15bis,
-        MiG_27K,
-        Mi_24V,
-        Mi_28N,
-        Mi_8MT,
-        OH_58D,
-        P_47D_30,
-        P_47D_30bl1,
-        P_47D_40,
-        RQ_1A_Predator,
-        Rafale_A_S,
-        SA342L,
-        SA342M,
-        SA342Minigun,
         Su_17M4,
-        Su_24M,
-        Su_24MR,
         Su_25,
         Su_25T,
         Su_34,
-        Tornado_GR4,
+        Ka_50,
+        SA342M,
+        SA342L,
+        SA342Minigun,
+        Su_24M,
+        Su_24MR,
+        AH_64A,
+        AH_64D,
+        OH_58D,
+        B_52H,
+        B_1B,
         Tornado_IDS,
-        Tu_160,
-        Tu_22M3,
-        Tu_95MS,
+        Tornado_GR4,
         UH_1H,
+        Mi_8MT,
+        Mi_28N,
+        Mi_24V,
+        MiG_27K,
+        A_20G,
+        P_47D_30,
+        P_47D_30bl1,
+        P_47D_40,
+        Ju_88A4,
+        B_17G,
+        MB_339PAN,
+        Rafale_A_S,
         WingLoong_I,
+        MQ_9_Reaper,
+        RQ_1A_Predator,
+        AH_1W
     ],
     Transport: [
         IL_76MD,
@@ -897,13 +793,13 @@ SAM_CONVERT = {
 """
 Units that will always be spawned in the air
 """
-TAKEOFF_BAN: List[Type[FlyingType]] = [
+TAKEOFF_BAN = [
 ]
 
 """
 Units that will be always spawned in the air if launched from the carrier
 """
-CARRIER_TAKEOFF_BAN: List[Type[FlyingType]] = [
+CARRIER_TAKEOFF_BAN = [
    Su_33,  # Kuznecow is bugged in a way that only 2 aircraft could be spawned
 ]
 
@@ -911,7 +807,98 @@ CARRIER_TAKEOFF_BAN: List[Type[FlyingType]] = [
 Units separated by country. 
 country : DCS Country name
 """
-FACTIONS: Dict[str, Faction] = FactionLoader.load_factions()
+FACTIONS = {
+
+    "Bluefor Modern": BLUEFOR_MODERN,
+    "Bluefor Cold War 1970s": BLUEFOR_COLDWAR,
+    "Bluefor Cold War (with A-4)": BLUEFOR_COLDWAR_A4,
+    "Bluefor Cold War (with A-4 and MB339)": BLUEFOR_COLDWAR_MODS,
+
+    "USA 1955 (WW2 Pack)": USA_1955,
+    "USA 1960": USA_1960,
+    "USA 1965": USA_1965,
+    "USA 1990": USA_1990,
+    "USA 2005": USA_2005,
+    "USA Aggressors 2005": US_Aggressors,
+
+    "Russia 1955": Russia_1955,
+    "Russia 1965": Russia_1965,
+    "Russia 1975": Russia_1975,
+    "Russia 1990": Russia_1990,
+    "Russia 2010": Russia_2010,
+
+    "France 1995": France_1995,
+    "France 2005": France_2005,
+    "France 2005 (Modded)": France_2005_Modded,
+
+    "Germany 1990": Germany_1990,
+
+    "Netherlands 1990": Netherlands_1990,
+
+    "United Kingdom 1990": UnitedKingdom_1990,
+
+    "Spain 1990": Spain_1990,
+
+    "Italy 1990": Italy_1990,
+    "Italy 1990 (With MB339)": Italy_1990_MB339,
+
+    "Israel 2000": Israel_2000,
+    "Israel 1982": Israel_1982,
+    "Israel 1973 (WW2 Pack)": Israel_1973,
+    "Israel 1973": Israel_1973_NO_WW2_UNITS,
+    "Israel 1948": Israel_1948,
+
+    "Arab Armies 1982": Syria_1982,
+    "Arab Armies 1973": Syria_1973,
+    "Arab Armies 1967 (WW2 Pack)": Syria_1967_WW2_Weapons,
+    "Arab Armies 1967": Syria_1967,
+    "Arab League 1948": Arab_Armies_1948,
+
+    "China 2010": China_2010,
+
+    "Sweden 1990": Sweden_1990,
+
+    "Australia 2005": Australia_2005,
+
+    "Canada 2005": Canada_2005,
+
+    "Japan 2005": Japan_2005,
+
+    "Turkey 2005": Turkey_2005,
+
+    "United Arab Emirates 2005": UAE_2005,
+
+    "Ukraine 2010": Ukraine_2010,
+
+    "India 2010": India_2010,
+
+    "Libya 2011": Libya_2011,
+
+    "Syria 2011": Syria_2011,
+
+
+    "Pakistan 2015": Pakistan_2015,
+
+    "Iran 2015": Iran_2015,
+
+    "North Korea 2000": NorthKorea_2000,
+
+    "Insurgent": Insurgent,
+    "Insurgent (Modded)": Insurgent_modded,
+
+    "PMC (American)": PMC_WESTERN_A,
+    "PMC (American) - MB339": PMC_WESTERN_B,
+    "PMC (Russian)": PMC_RUSSIAN,
+
+    "Allies 1944 (WW2 Pack)": USA_1944,
+    "USA 1944 (WW2 Pack)": ALLIES_1944,
+    "UK 1944 (WW2 Pack)": UK_1944,
+
+    "Germany 1944 (WW2 Pack)": Germany_1944,
+    "Germany 1944 Easy (WW2 Pack)": Germany_1944_Easy,
+
+}
+
 
 CARRIER_TYPE_BY_PLANE = {
     FA_18C_hornet: CVN_74_John_C__Stennis,
@@ -947,29 +934,11 @@ COMMON_OVERRIDE = {
     PinpointStrike: "STRIKE",
     SEAD: "SEAD",
     AntishipStrike: "ANTISHIP",
-    GroundAttack: "STRIKE",
-    Escort: "CAP",
+    GroundAttack: "STRIKE"
 }
 
-PLANE_PAYLOAD_OVERRIDES: Dict[Type[PlaneType], Dict[Type[Task], str]] = {
+PLANE_PAYLOAD_OVERRIDES = {
 
-    B_1B: {
-        CAS: "GBU-38*16, CBU-97*20",
-        PinpointStrike: "GBU-31*8, GBU-38*32",
-        GroundAttack: "GBU-31*8, GBU-38*32",
-    },
-    B_52H: {
-        PinpointStrike: "AGM-86C*20",
-        GroundAttack: "Mk 82*51",
-    },
-    F_117A: {
-        PinpointStrike: "GBU-10*2",
-    },
-    F_15E: {
-        CAS: "AIM-120B*2,AIM-9M*2,FUEL,GBU-12*4,GBU-38*4,AGM-65D*2",
-        GroundAttack: "AIM-120B*2,AIM-9M*2,FUEL*3,CBU-97*12",
-        PinpointStrike: "AIM-120B*2,AIM-9M*2,FUEL,GBU-31*4,AGM-154C*2",
-    },
     FA_18C_hornet: {
         CAP: "CAP HEAVY",
         Intercept: "CAP HEAVY",
@@ -977,8 +946,7 @@ PLANE_PAYLOAD_OVERRIDES: Dict[Type[PlaneType], Dict[Type[Task], str]] = {
         PinpointStrike: "STRIKE",
         SEAD: "SEAD",
         AntishipStrike: "ANTISHIP",
-        GroundAttack: "STRIKE",
-        Escort: "CAP HEAVY",
+        GroundAttack: "STRIKE"
     },
     F_A_18C: {
         CAP: "CAP HEAVY",
@@ -987,17 +955,7 @@ PLANE_PAYLOAD_OVERRIDES: Dict[Type[PlaneType], Dict[Type[Task], str]] = {
         PinpointStrike: "STRIKE",
         SEAD: "SEAD",
         AntishipStrike: "ANTISHIP",
-        GroundAttack: "STRIKE",
-        Escort: "CAP HEAVY",
-    },
-    Tu_160: {
-        PinpointStrike: "Kh-65*12",
-    },
-    Tu_22M3: {
-        GroundAttack: "FAB-500*33, FAB-250*36",
-    },
-    Tu_95MS: {
-        PinpointStrike: "Kh-65*6",
+        GroundAttack: "STRIKE"
     },
     A_10A: COMMON_OVERRIDE,
     A_10C: COMMON_OVERRIDE,
@@ -1007,6 +965,7 @@ PLANE_PAYLOAD_OVERRIDES: Dict[Type[PlaneType], Dict[Type[Task], str]] = {
     F_5E_3: COMMON_OVERRIDE,
     F_14B: COMMON_OVERRIDE,
     F_15C: COMMON_OVERRIDE,
+    F_15E: COMMON_OVERRIDE,
     F_16C_50: COMMON_OVERRIDE,
     JF_17: COMMON_OVERRIDE,
     M_2000C: COMMON_OVERRIDE,
@@ -1024,7 +983,6 @@ PLANE_PAYLOAD_OVERRIDES: Dict[Type[PlaneType], Dict[Type[Task], str]] = {
     Su_24M:COMMON_OVERRIDE,
     Su_30: COMMON_OVERRIDE,
     Su_34: COMMON_OVERRIDE,
-    Su_57: COMMON_OVERRIDE,
     MiG_23MLD: COMMON_OVERRIDE,
     MiG_27K: COMMON_OVERRIDE,
     Tornado_GR4: COMMON_OVERRIDE,
@@ -1141,7 +1099,6 @@ CARRIER_CAPABLE = [
     AV8BNA,
     Su_33,
     A_4E_C,
-    Rafale_M,
 
     UH_1H,
     Mi_8MT,
@@ -1177,17 +1134,17 @@ LHA_CAPABLE = [
 ---------- END OF CONFIGURATION SECTION
 """
 
-UnitsDict = Dict[UnitType, int]
-PlaneDict = Dict[FlyingType, int]
-HeliDict = Dict[HelicopterType, int]
-ArmorDict = Dict[VehicleType, int]
-ShipDict = Dict[ShipType, int]
-AirDefenseDict = Dict[AirDefence, int]
+UnitsDict = typing.Dict[UnitType, int]
+PlaneDict = typing.Dict[FlyingType, int]
+HeliDict = typing.Dict[HelicopterType, int]
+ArmorDict = typing.Dict[VehicleType, int]
+ShipDict = typing.Dict[ShipType, int]
+AirDefenseDict = typing.Dict[AirDefence, int]
 
-AssignedUnitsDict = Dict[Type[UnitType], Tuple[int, int]]
-TaskForceDict = Dict[Type[MainTask], AssignedUnitsDict]
+AssignedUnitsDict = typing.Dict[typing.Type[UnitType], typing.Tuple[int, int]]
+TaskForceDict = typing.Dict[typing.Type[Task], AssignedUnitsDict]
 
-StartingPosition = Union[ShipGroup, StaticGroup, Airport, Point]
+StartingPosition = typing.Optional[typing.Union[ShipGroup, StaticGroup, Airport, Point]]
 
 
 def upgrade_to_supercarrier(unit, name: str):
@@ -1205,8 +1162,7 @@ def upgrade_to_supercarrier(unit, name: str):
     else:
         return unit
 
-
-def unit_task(unit: UnitType) -> Optional[Task]:
+def unit_task(unit: UnitType) -> Task:
     for task, units in UNIT_BY_TASK.items():
         if unit in units:
             return task
@@ -1217,12 +1173,10 @@ def unit_task(unit: UnitType) -> Optional[Task]:
     print(unit.name + " cause issue")
     return None
 
+def find_unittype(for_task: Task, country_name: str) -> typing.List[UnitType]:
+    return [x for x in UNIT_BY_TASK[for_task] if x in FACTIONS[country_name]["units"]]
 
-def find_unittype(for_task: Task, country_name: str) -> List[UnitType]:
-    return [x for x in UNIT_BY_TASK[for_task] if x in FACTIONS[country_name].units]
-
-
-def find_infantry(country_name: str) -> List[UnitType]:
+def find_infantry(country_name: str) -> typing.List[UnitType]:
     inf = [
         Infantry.Paratrooper_AKS, Infantry.Paratrooper_AKS, Infantry.Paratrooper_AKS, Infantry.Paratrooper_AKS, Infantry.Paratrooper_AKS,
         Infantry.Soldier_RPG,
@@ -1237,18 +1191,15 @@ def find_infantry(country_name: str) -> List[UnitType]:
         Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand, Infantry.Infantry_M1_Garand,
         Infantry.Infantry_Soldier_Insurgents, Infantry.Infantry_Soldier_Insurgents, Infantry.Infantry_Soldier_Insurgents
     ]
-    return [x for x in inf if x in FACTIONS[country_name].infantry_units]
-
+    return [x for x in inf if x in FACTIONS[country_name]["units"]]
 
 def unit_type_name(unit_type) -> str:
     return unit_type.id and unit_type.id or unit_type.name
 
-
 def unit_type_name_2(unit_type) -> str:
     return unit_type.name and unit_type.name or unit_type.id
 
-
-def unit_type_from_name(name: str) -> Optional[UnitType]:
+def unit_type_from_name(name: str) -> UnitType:
     if name in vehicle_map:
         return vehicle_map[name]
     elif name in plane_map:
@@ -1281,7 +1232,7 @@ def task_name(task) -> str:
         return task.name
 
 
-def choose_units(for_task: Task, factor: float, count: int, country: str) -> List[UnitType]:
+def choose_units(for_task: Task, factor: float, count: int, country: str) -> typing.Collection[UnitType]:
     suitable_unittypes = find_unittype(for_task, country)
     suitable_unittypes = [x for x in suitable_unittypes if x not in helicopter_map.values()]
     suitable_unittypes.sort(key=lambda x: PRICES[x])
@@ -1307,7 +1258,7 @@ def unitdict_merge(a: UnitsDict, b: UnitsDict) -> UnitsDict:
 
 
 def unitdict_split(unit_dict: UnitsDict, count: int):
-    buffer_dict: Dict[UnitType, int] = {}
+    buffer_dict = {}
     for unit_type, unit_count in unit_dict.items():
         for _ in range(unit_count):
             unitdict_append(buffer_dict, unit_type, 1)
@@ -1330,7 +1281,7 @@ def unitdict_restrict_count(unit_dict: UnitsDict, total_count: int) -> UnitsDict
         return {}
 
 
-def assigned_units_split(fd: AssignedUnitsDict) -> Tuple[PlaneDict, PlaneDict]:
+def assigned_units_split(fd: AssignedUnitsDict) -> typing.Tuple[PlaneDict, PlaneDict]:
     return {k: v1 for k, (v1, v2) in fd.items()}, {k: v2 for k, (v1, v2) in fd.items()},
 
 
@@ -1339,7 +1290,7 @@ def assigned_units_from(d: PlaneDict) -> AssignedUnitsDict:
 
 
 def assignedunits_split_to_count(dict: AssignedUnitsDict, count: int):
-    buffer_dict: Dict[Type[UnitType], Tuple[int, int]] = {}
+    buffer_dict = {}
     for unit_type, (unit_count, client_count) in dict.items():
         for _ in range(unit_count):
             new_count, new_client_count = buffer_dict.get(unit_type, (0, 0))

game/event/event.py

@@ -1,22 +1,24 @@
-from __future__ import annotations
-
+import typing
 import logging
-import math
-from typing import Dict, List, Optional, Type, TYPE_CHECKING
 
-from dcs.mapping import Point
-from dcs.task import Task
+from dcs.action import Coalition
+from dcs.unittype import UnitType
+from dcs.task import *
+from dcs.vehicles import AirDefence
 from dcs.unittype import UnitType
 
-from game import db, persistency
-from game.debriefing import Debriefing
+from game import *
 from game.infos.information import Information
-from game.operation.operation import Operation
-from gen.ground_forces.combat_stance import CombatStance
-from theater import ControlPoint
+from theater import *
+from gen.environmentgen import EnvironmentSettings
+from gen.conflictgen import Conflict
+from game.db import assigned_units_from, unitdict_from
+from theater.start_generator import generate_airbase_defense_group
 
-if TYPE_CHECKING:
-    from ..game import Game
+from userdata.debriefing import Debriefing
+from userdata import persistency
+
+import game.db as db
 
 DIFFICULTY_LOG_BASE = 1.1
 EVENT_DEPARTURE_MAX_DISTANCE = 340000
@@ -26,7 +28,6 @@ MINOR_DEFEAT_INFLUENCE = 0.1
 DEFEAT_INFLUENCE = 0.3
 STRONG_DEFEAT_INFLUENCE = 0.5
 
-
 class Event:
     silent = False
     informational = False
@@ -36,15 +37,17 @@ class Event:
     game = None  # type: Game
     location = None  # type: Point
     from_cp = None  # type: ControlPoint
+    departure_cp = None  # type: ControlPoint
     to_cp = None  # type: ControlPoint
 
     operation = None  # type: Operation
     difficulty = 1  # type: int
+    environment_settings = None  # type: EnvironmentSettings
     BONUS_BASE = 5
 
     def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str, defender_name: str):
         self.game = game
-        self.departure_cp: Optional[ControlPoint] = None
+        self.departure_cp = None
         self.from_cp = from_cp
         self.to_cp = target_cp
         self.location = location
@@ -56,14 +59,14 @@ class Event:
         return self.attacker_name == self.game.player_name
 
     @property
-    def enemy_cp(self) -> Optional[ControlPoint]:
+    def enemy_cp(self) -> ControlPoint:
         if self.attacker_name == self.game.player_name:
             return self.to_cp
         else:
             return self.departure_cp
 
     @property
-    def tasks(self) -> List[Type[Task]]:
+    def tasks(self) -> typing.Collection[typing.Type[Task]]:
         return []
 
     @property
@@ -88,6 +91,18 @@ class Event:
     def is_successfull(self, debriefing: Debriefing) -> bool:
         return self.operation.is_successfull(debriefing)
 
+    def player_attacking(self, cp: ControlPoint, flights: db.TaskForceDict):
+        if self.is_player_attacking:
+            self.departure_cp = cp
+        else:
+            self.to_cp = cp
+
+    def player_defending(self, cp: ControlPoint, flights: db.TaskForceDict):
+        if self.is_player_attacking:
+            self.departure_cp = cp
+        else:
+            self.to_cp = cp
+
     def generate(self):
         self.operation.is_awacs_enabled = self.is_awacs_enabled
         self.operation.ca_slots = self.ca_slots
@@ -194,19 +209,29 @@ class Event:
                     if cp.id == id:
 
                         if cp.captured and new_owner_coalition != coalition:
-                            for_player = False
+                            cp.captured = False
                             info = Information(cp.name + " lost !", "The ennemy took control of " + cp.name + "\nShame on us !", self.game.turn)
                             self.game.informations.append(info)
+                            pname = self.game.enemy_name
                             captured_cps.append(cp)
                         elif not(cp.captured) and new_owner_coalition == coalition:
-                            for_player = True
+                            cp.captured = True
                             info = Information(cp.name + " captured !", "We took control of " + cp.name + "! Great job !", self.game.turn)
                             self.game.informations.append(info)
+                            pname = self.game.player_name
                             captured_cps.append(cp)
                         else:
                             continue
 
-                        cp.capture(self.game, for_player)
+                        cp.base.aircraft = {}
+                        cp.base.armor = {}
+
+                        airbase_def_id = 0
+                        for g in cp.ground_objects:
+                            g.groups = []
+                            if g.airbase_group and pname != "":
+                                generate_airbase_defense_group(airbase_def_id, g, pname, self.game, cp)
+                                airbase_def_id = airbase_def_id + 1
 
                 for cp in captured_cps:
                     logging.info("Will run redeploy for " + cp.name)
@@ -228,7 +253,7 @@ class Event:
             for enemy_cp in enemy_cps:
                 print("Compute frontline progression for : " + cp.name + " to " + enemy_cp.name)
 
-                delta = 0.0
+                delta = 0
                 player_won = True
                 ally_casualties = killed_unit_count_by_cp[cp.id]
                 enemy_casualties = killed_unit_count_by_cp[enemy_cp.id]
@@ -351,6 +376,7 @@ class Event:
 
 class UnitsDeliveryEvent(Event):
     informational = True
+    units = None  # type: typing.Dict[UnitType, int]
 
     def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
         super(UnitsDeliveryEvent, self).__init__(game=game,
@@ -360,12 +386,12 @@ class UnitsDeliveryEvent(Event):
                                                  attacker_name=attacker_name,
                                                  defender_name=defender_name)
 
-        self.units: Dict[UnitType, int] = {}
+        self.units = {}
 
     def __str__(self):
         return "Pending delivery to {}".format(self.to_cp)
 
-    def deliver(self, units: Dict[UnitType, int]):
+    def deliver(self, units: typing.Dict[UnitType, int]):
         for k, v in units.items():
             self.units[k] = self.units.get(k, 0) + v
 

game/event/frontlineattack.py

@@ -1,17 +1,12 @@
-from typing import List, Type
-
-from dcs.task import CAP, CAS, Task
-
-from game import db
+from game.event import *
 from game.operation.frontlineattack import FrontlineAttackOperation
-from .event import Event
-from ..debriefing import Debriefing
+from userdata.debriefing import Debriefing
 
 
 class FrontlineAttackEvent(Event):
 
     @property
-    def tasks(self) -> List[Type[Task]]:
+    def tasks(self) -> typing.Collection[typing.Type[Task]]:
         if self.is_player_attacking:
             return [CAS, CAP]
         else:
@@ -39,7 +34,6 @@ class FrontlineAttackEvent(Event):
             self.to_cp.base.affect_strength(-0.1)
 
     def player_attacking(self, flights: db.TaskForceDict):
-        assert self.departure_cp is not None
         op = FrontlineAttackOperation(game=self.game,
                                       attacker_name=self.attacker_name,
                                       defender_name=self.defender_name,
@@ -47,3 +41,13 @@ class FrontlineAttackEvent(Event):
                                       departure_cp=self.departure_cp,
                                       to_cp=self.to_cp)
         self.operation = op
+
+    def player_defending(self, flights: db.TaskForceDict):
+        op = FrontlineAttackOperation(game=self.game,
+                                      attacker_name=self.attacker_name,
+                                      defender_name=self.defender_name,
+                                      from_cp=self.from_cp,
+                                      departure_cp=self.departure_cp,
+                                      to_cp=self.to_cp)
+        self.operation = op
+

game/factions/australia_2005.py

@@ -0,0 +1,50 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Australia_2005 = {
+    "country": "Australia",
+    "side": "blue",
+    "units": [
+        FA_18C_hornet,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        Armor.MBT_M1A2_Abrams,
+        Armor.MBT_Leopard_1A3,
+        Armor.APC_M113,
+        Armor.IFV_LAV_25,
+        Armor.IFV_MCV_80,
+
+        UH_1H,
+        AH_1W, # Standing as EC Tiger
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.Rapier_FSA_Launcher,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.Rapier_FSA_Launcher,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "lhanames": [
+        "HMAS Canberra",
+        "HMAS Adelaide"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/bluefor_coldwar.py

@@ -0,0 +1,58 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+BLUEFOR_COLDWAR = {
+    "country": "Combined Joint Task Forces Blue",
+    "side": "blue",
+    "units": [
+
+        F_14B,
+        F_4E,
+        F_5E_3,
+        A_10A,
+        AJS37,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        SA342M,
+        SA342L,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Chaparral_M48,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.AAA_Vulcan_M163,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "carrier_names": [
+        "CVN-71 Theodore Roosevelt",
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 George Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat": [
+    ], "has_jtac": True
+}

game/factions/bluefor_coldwar_a4.py

@@ -0,0 +1,65 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from pydcs_extensions.a4ec.a4ec import A_4E_C
+
+BLUEFOR_COLDWAR_A4 = {
+    "country": "Combined Joint Task Forces Blue",
+    "side": "blue",
+    "units": [
+
+        F_14B,
+        F_4E,
+        F_5E_3,
+        A_10A,
+        AJS37,
+        A_4E_C,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        SA342M,
+        SA342L,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Chaparral_M48,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.AAA_Vulcan_M163,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "CVN-71 Theodore Roosevelt",
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 George Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat": [
+    ], "requirements": {
+        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
+    }, "has_jtac": True
+}

game/factions/bluefor_coldwar_mods.py

@@ -0,0 +1,68 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from pydcs_extensions.a4ec.a4ec import A_4E_C
+from pydcs_extensions.mb339.mb339 import MB_339PAN
+
+BLUEFOR_COLDWAR_MODS = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+
+        F_14B,
+        F_4E,
+        F_5E_3,
+        A_10A,
+        AJS37,
+        A_4E_C,
+        MB_339PAN,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        SA342M,
+        SA342L,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Chaparral_M48,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.AAA_Vulcan_M163,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "CVN-71 Theodore Roosevelt",
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 George Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat": [
+    ], "requirements": {
+        "MB-339A": "http://www.freccetricolorivirtuali.net/",
+        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
+    }, "has_jtac": True
+}

game/factions/bluefor_modern.py

@@ -0,0 +1,83 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+BLUEFOR_MODERN = {
+    "country": "Combined Joint Task Forces Blue",
+    "side": "blue",
+    "units": [
+
+        F_15C,
+        F_14B,
+        FA_18C_hornet,
+        F_16C_50,
+        JF_17,
+        M_2000C,
+        F_5E_3,
+        Su_27,
+
+        Su_25T,
+        A_10A,
+        A_10C,
+        A_10C_2,
+        AV8BNA,
+        AJS37,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        AH_64D,
+        Ka_50,
+        SA342M,
+        SA342L,
+
+        Armor.MBT_M1A2_Abrams,
+        Armor.MBT_Leopard_2,
+        Armor.ATGM_M1134_Stryker,
+        Armor.IFV_M2A2_Bradley,
+        Armor.IFV_Marder,
+        Armor.APC_M1043_HMMWV_Armament,
+
+        Artillery.MLRS_M270,
+        Artillery.SPH_M109_Paladin,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Patriot_EPP_III,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.SAM_Avenger_M1097,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "CVN-71 Theodore Roosevelt",
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 George Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/canada_2005.py

@@ -0,0 +1,43 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Canada_2005 = {
+    "country": "Canada",
+    "side": "blue",
+    "units": [
+        FA_18C_hornet,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        Armor.MBT_Leopard_1A3,
+        Armor.MBT_Leopard_2,
+        Armor.IFV_LAV_25,
+        Armor.APC_M113,
+        Armor.IFV_MCV_80,
+
+        UH_1H,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Avenger_M1097,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.SAM_Avenger_M1097,
+    ], "destroyer": [
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "boat":[
+        "ArleighBurkeGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/china_2010.py

@@ -0,0 +1,80 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+China_2010 = {
+    "country": "China",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis, # Standing as J-7
+        Su_30,
+        Su_33,
+        J_11A,
+        JF_17,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        KJ_2000,
+
+        Mi_8MT,
+        Mi_28N,
+
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85C, # Standing as HQ-9+
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.HQ_7_Self_Propelled_LN,
+
+        Armor.ZTZ_96B,
+        Armor.MBT_T_55,
+        Armor.ZBD_04A,
+        Armor.IFV_BMP_1,
+        Artillery.MLRS_9A52_Smerch,
+        Artillery.SPH_2S9_Nona,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_AKS,
+        Infantry.Infantry_Soldier_Rus,
+        Infantry.Paratrooper_RPG_16,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160
+    ],
+    "shorad":[
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.Rapier_FSA_Launcher, # Standing as PL-9C Shorad
+        AirDefence.HQ_7_Self_Propelled_LN
+    ], "aircraft_carrier": [
+        CV_1143_5_Admiral_Kuznetsov,
+    ], "destroyer": [
+        Type_052B_Destroyer,
+        Type_052C_Destroyer
+    ], "cruiser": [
+        Type_054A_Frigate,
+    ], "helicopter_carrier": [
+        Type_071_Amphibious_Transport_Dock,
+    ], "lhanames": [
+        "Kunlun Shan",
+        "Jinggang Shan",
+        "Changbai Shan",
+        "Yimeng Shan",
+        "Longhu Shan",
+        "Wuzhi Shan",
+        "Wudang Shan"
+    ], "carrier_names": [
+        "001 Liaoning",
+        "002 Shandong",
+    ], "boat":[
+        "Type54GroupGenerator"
+    ],
+    "has_jtac": True,
+    "jtac_unit": WingLoong_I
+}

game/factions/faction.py

@@ -1,252 +0,0 @@
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import Optional, Dict, Type, List, Any, cast
-
-import dcs
-from dcs.countries import country_dict
-from dcs.planes import plane_map
-from dcs.unittype import FlyingType, ShipType, VehicleType, UnitType
-from dcs.vehicles import Armor, Unarmed, Infantry, Artillery, AirDefence
-
-from game.data.building_data import WW2_ALLIES_BUILDINGS, DEFAULT_AVAILABLE_BUILDINGS, WW2_GERMANY_BUILDINGS
-from game.data.doctrine import Doctrine, MODERN_DOCTRINE, COLDWAR_DOCTRINE, WWII_DOCTRINE
-from pydcs_extensions.mod_units import MODDED_VEHICLES, MODDED_AIRPLANES
-
-
-@dataclass
-class Faction:
-
-    # Country used by this faction
-    country: str = field(default="")
-
-    # Nice name of the faction
-    name: str = field(default="")
-
-    # List of faction file authors
-    authors: str = field(default="")
-
-    # A description of the faction
-    description: str = field(default="")
-
-    # Available aircraft
-    aircrafts: List[UnitType] = field(default_factory=list)
-
-    # Available awacs aircraft
-    awacs: List[UnitType] = field(default_factory=list)
-
-    # Available tanker aircraft
-    tankers: List[UnitType] = field(default_factory=list)
-
-    # Available frontline units
-    frontline_units: List[VehicleType] = field(default_factory=list)
-
-    # Available artillery units
-    artillery_units: List[VehicleType] = field(default_factory=list)
-
-    # Infantry units used
-    infantry_units: List[VehicleType] = field(default_factory=list)
-
-    # Logistics units used
-    logistics_units: List[VehicleType] = field(default_factory=list)
-
-    # List of units that can be deployed as SHORAD
-    shorads: List[str] = field(default_factory=list)
-
-    # Possible SAMS site generators for this faction
-    sams: List[str] = field(default_factory=list)
-
-    # Possible Missile site generators for this faction
-    missiles: List[str] = field(default_factory=list)
-
-    # Required mods or asset packs
-    requirements: Dict[str, str] = field(default_factory=dict)
-
-    # possible aircraft carrier units
-    aircraft_carrier: List[UnitType] = field(default_factory=list)
-
-    # possible helicopter carrier units
-    helicopter_carrier: List[UnitType] = field(default_factory=list)
-
-    # Possible carrier names
-    carrier_names: List[str] = field(default_factory=list)
-
-    # Possible helicopter carrier names
-    helicopter_carrier_names: List[str] = field(default_factory=list)
-
-    # Navy group generators
-    navy_generators: List[str] = field(default_factory=list)
-
-    # Available destroyers
-    destroyers: List[str] = field(default_factory=list)
-
-    # Available cruisers
-    cruisers: List[str] = field(default_factory=list)
-
-    # How many navy group should we try to generate per CP on startup for this faction
-    navy_group_count: int = field(default=1)
-
-    # How many missiles group should we try to generate per CP on startup for this faction
-    missiles_group_count: int = field(default=1)
-
-    # Whether this faction has JTAC access
-    has_jtac: bool = field(default=False)
-
-    # Unit to use as JTAC for this faction
-    jtac_unit: Optional[FlyingType] = field(default=None)
-
-    # doctrine
-    doctrine: Doctrine = field(default=MODERN_DOCTRINE)
-
-    # List of available buildings for this faction
-    building_set: List[str] = field(default_factory=list)
-
-    @classmethod
-    def from_json(cls: Type[Faction], json: Dict[str, Any]) -> Faction:
-
-        faction = Faction()
-
-        faction.country = json.get("country", "/")
-        if faction.country not in [c.name for c in country_dict.values()]:
-            raise AssertionError("Faction's country (\"{}\") is not a valid DCS country ID".format(faction.country))
-
-        faction.name = json.get("name", "")
-        if not faction.name:
-            raise AssertionError("Faction has no valid name")
-
-        faction.authors = json.get("authors", "")
-        faction.description = json.get("description", "")
-
-        faction.aircrafts = load_all_aircraft(json.get("aircrafts", []))
-        faction.awacs = load_all_aircraft(json.get("awacs", []))
-        faction.tankers = load_all_aircraft(json.get("tankers", []))
-
-        faction.frontline_units = load_all_vehicles(
-            json.get("frontline_units", []))
-        faction.artillery_units = load_all_vehicles(
-            json.get("artillery_units", []))
-        faction.infantry_units = load_all_vehicles(
-            json.get("infantry_units", []))
-        faction.logistics_units = load_all_vehicles(
-            json.get("logistics_units", []))
-
-        faction.sams = json.get("sams", [])
-        faction.shorads = json.get("shorads", [])
-        faction.missiles = json.get("missiles", [])
-        faction.requirements = json.get("requirements", {})
-
-        faction.carrier_names = json.get("carrier_names", [])
-        faction.helicopter_carrier_names = json.get(
-            "helicopter_carrier_names", [])
-        faction.navy_generators = json.get("navy_generators", [])
-        faction.aircraft_carrier = load_all_ships(
-            json.get("aircraft_carrier", []))
-        faction.helicopter_carrier = load_all_ships(
-            json.get("helicopter_carrier", []))
-        faction.destroyers = load_all_ships(json.get("destroyers", []))
-        faction.cruisers = load_all_ships(json.get("cruisers", []))
-        faction.has_jtac = json.get("has_jtac", False)
-        jtac_name = json.get("jtac_unit", None)
-        if jtac_name is not None:
-            faction.jtac_unit = load_aircraft(jtac_name)
-        else:
-            faction.jtac_unit = None
-        faction.navy_group_count = int(json.get("navy_group_count", 1))
-        faction.missiles_group_count = int(json.get("missiles_group_count", 0))
-
-        # Load doctrine
-        doctrine = json.get("doctrine", "modern")
-        if doctrine == "modern":
-            faction.doctrine = MODERN_DOCTRINE
-        elif doctrine == "coldwar":
-            faction.doctrine = COLDWAR_DOCTRINE
-        elif doctrine == "ww2":
-            faction.doctrine = WWII_DOCTRINE
-        else:
-            faction.doctrine = MODERN_DOCTRINE
-
-        # Load the building set
-        building_set = json.get("building_set", "default")
-        if building_set == "default":
-            faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
-        elif building_set == "ww2ally":
-            faction.building_set = WW2_ALLIES_BUILDINGS
-        elif building_set == "ww2germany":
-            faction.building_set = WW2_GERMANY_BUILDINGS
-        else:
-            faction.building_set = DEFAULT_AVAILABLE_BUILDINGS
-
-        return faction
-
-    @property
-    def units(self) -> List[UnitType]:
-        return (self.infantry_units + self.aircrafts + self.awacs +
-                self.artillery_units + self.frontline_units +
-                self.tankers + self.logistics_units)
-
-
-def unit_loader(unit: str, class_repository: List[Any]) -> Optional[UnitType]:
-    """
-    Find unit by name
-    :param unit: Unit name as string
-    :param class_repository: Repository of classes (Either a module, a class, or a list of classes)
-    :return: The unit as a PyDCS type
-    """
-    if unit is None:
-        return None
-    elif unit in plane_map.keys():
-        return plane_map[unit]
-    else:
-        for mother_class in class_repository:
-            if getattr(mother_class, unit, None) is not None:
-                return getattr(mother_class, unit)
-            if type(mother_class) is list:
-                for m in mother_class:
-                    if m.__name__ == unit:
-                        return m
-        logging.error(f"FACTION ERROR : Unable to find {unit} in pydcs")
-        return None
-
-
-def load_aircraft(name: str) -> Optional[FlyingType]:
-    return cast(Optional[FlyingType], unit_loader(
-        name, [dcs.planes, dcs.helicopters, MODDED_AIRPLANES]
-    ))
-
-
-def load_all_aircraft(data) -> List[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[VehicleType]:
-    return cast(Optional[FlyingType], unit_loader(
-        name, [Infantry, Unarmed, Armor, AirDefence, Artillery, MODDED_VEHICLES]
-    ))
-
-
-def load_all_vehicles(data) -> List[VehicleType]:
-    items = []
-    for name in data:
-        item = load_vehicle(name)
-        if item is not None:
-            items.append(item)
-    return items
-
-
-def load_ship(name: str) -> Optional[ShipType]:
-    return cast(Optional[FlyingType], unit_loader(name, [dcs.ships]))
-
-
-def load_all_ships(data) -> List[ShipType]:
-    items = []
-    for name in data:
-        item = load_ship(name)
-        if item is not None:
-            items.append(item)
-    return items

game/factions/faction_loader.py

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

game/factions/france_1995.py

@@ -0,0 +1,47 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+France_1995 = {
+    "country": "France",
+    "side": "blue",
+    "units": [
+        M_2000C,
+        Mirage_2000_5,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        SA342M,
+        SA342L,
+        SA342Mistral,
+
+        Armor.MBT_Leclerc,
+        Armor.TPz_Fuchs,  # Standing as VAB
+        Armor.APC_Cobra,  # Standing as VBL
+        Armor.ATGM_M1134_Stryker,  # Standing as VAB Mephisto
+        Artillery.SPH_M109_Paladin,  # Standing as AMX30 AuF1
+        Artillery.MLRS_M270,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Roland_ADS,
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.HQ_7_Self_Propelled_LN,  # Standing as Crotale
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+
+    ], "shorad": [
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.SAM_Roland_ADS
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/france_2005.py

@@ -0,0 +1,62 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+France_2005 = {
+    "country": "France",
+    "side": "blue",
+    "units":[
+        M_2000C,
+        Mirage_2000_5,
+        FA_18C_hornet, # Standing as Rafale M
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        SA342M,
+        SA342L,
+        SA342Mistral,
+
+        Armor.MBT_Leclerc,
+        Armor.TPz_Fuchs, # Standing as VAB
+        Armor.APC_Cobra, # Standing as VBL
+        Armor.ATGM_M1134_Stryker, # Standing as VAB Mephisto
+        Artillery.SPH_M109_Paladin, # Standing as AMX30 AuF1
+        Artillery.MLRS_M270,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Roland_ADS,
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.HQ_7_Self_Propelled_LN, # Standing as Crotale
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+        
+    ], "shorad":[
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.SAM_Roland_ADS
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis, # Standing as CDG Aircraft Carrier
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa, # Standing as Mistral Class
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "PA Charles de Gaulle",
+    ], "lhanames": [
+        "L9013 Mistral",
+        "L9014 Tonerre",
+        "L9015 Dixmude"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/france_modded.py

@@ -0,0 +1,80 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+import pydcs_extensions.frenchpack.frenchpack as frenchpack
+from pydcs_extensions.rafale.rafale import Rafale_M, Rafale_A_S
+
+France_2005_Modded = {
+    "country": "France",
+    "side": "blue",
+    "units": [
+        M_2000C,
+        Mirage_2000_5,
+        Rafale_M,
+        Rafale_A_S,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        SA342M,
+        SA342L,
+        SA342Mistral,
+
+        Armor.MBT_Leclerc,
+        Artillery.SPH_M109_Paladin,  # Standing as AMX30 AuF1
+        Artillery.MLRS_M270,
+
+        frenchpack.AMX_10RCR,
+        frenchpack.AMX_10RCR_SEPAR,
+        frenchpack.ERC_90,
+        frenchpack.TRM_2000_PAMELA,
+        frenchpack.VAB__50,
+        frenchpack.VAB_MEPHISTO,
+        frenchpack.VAB_T20_13,
+        frenchpack.VBL__50,
+        frenchpack.VBL_AANF1,
+        frenchpack.VBAE_CRAB,
+        frenchpack.VBAE_CRAB_MMP,
+        frenchpack.AMX_30B2,
+        frenchpack.Leclerc_Serie_XXI,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Roland_ADS,
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.HQ_7_Self_Propelled_LN,  # Standing as Crotale
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+
+    ], "shorad": [
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.SAM_Roland_ADS
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,  # Standing as CDG Aircraft Carrier
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,  # Standing as Mistral Class
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "PA Charles de Gaulle",
+    ], "lhanames": [
+        "L9013 Mistral",
+        "L9014 Tonerre",
+        "L9015 Dixmude"
+    ], "boat": [
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ], "requirements": {
+        "frenchpack V3.5": "https://forums.eagle.ru/showthread.php?t=279974",
+        "RAFALE 2.5.5": "https://www.digitalcombatsimulator.com/fr/files/3307478/",
+    }, "has_jtac": True
+}

game/factions/germany_1944.py

@@ -0,0 +1,47 @@
+from dcs.planes import *
+from dcs.vehicles import *
+
+from game.data.building_data import WW2_GERMANY_BUILDINGS
+from game.data.doctrine import WWII_DOCTRINE
+
+Germany_1944 = {
+    "country": "Third Reich",
+    "side": "red",
+    "units": [
+
+        FW_190A8,
+        FW_190D9,
+        Bf_109K_4,
+        Ju_88A4,
+
+        Armor.MT_Pz_Kpfw_V_Panther_Ausf_G,
+        Armor.MT_Pz_Kpfw_IV_Ausf_H,
+        Armor.HT_Pz_Kpfw_VI_Tiger_I,
+        Armor.HT_Pz_Kpfw_VI_Ausf__B__Tiger_II,
+        Armor.APC_Sd_Kfz_251,
+        Armor.IFV_Sd_Kfz_234_2_Puma,
+        Armor.Sd_Kfz_184_Elefant,
+        Armor.TD_Jagdpanther_G1,
+        Armor.TD_Jagdpanzer_IV,
+
+        Artillery.Sturmpanzer_IV_Brummbär,
+
+        Unarmed.Sd_Kfz_2,
+        Unarmed.Sd_Kfz_7,
+        Unarmed.Kübelwagen_82,
+
+        Infantry.Infantry_Mauser_98,
+        AirDefence.AAA_8_8cm_Flak_36,
+    ],"requirements":{
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "shorad": [
+        AirDefence.AAA_8_8cm_Flak_36,
+    ],
+    "objects": WW2_GERMANY_BUILDINGS,
+    "doctrine": WWII_DOCTRINE,
+    "boat": ["UBoatGroupGenerator", "SchnellbootGroupGenerator"],
+    "boat_count": 2,
+    "missiles": ["V1GroupGenerator"],
+    "missiles_count": 1
+}

game/factions/germany_1944_easy.py

@@ -0,0 +1,40 @@
+from dcs.planes import *
+from dcs.vehicles import *
+
+from game.data.building_data import WW2_GERMANY_BUILDINGS
+from game.data.doctrine import WWII_DOCTRINE
+
+Germany_1944_Easy = {
+    "country": "Third Reich",
+    "side": "red",
+    "units": [
+
+        FW_190A8,
+        FW_190D9,
+        Bf_109K_4,
+        Ju_88A4,
+
+        Armor.MT_Pz_Kpfw_IV_Ausf_H,
+        Armor.APC_Sd_Kfz_251,
+        Armor.IFV_Sd_Kfz_234_2_Puma,
+        Artillery.Sturmpanzer_IV_Brummbär,
+
+        Unarmed.Sd_Kfz_2,
+        Unarmed.Sd_Kfz_7,
+        Unarmed.Kübelwagen_82,
+
+        Infantry.Infantry_Mauser_98,
+        AirDefence.AAA_8_8cm_Flak_36,
+    ],"requirements":{
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "shorad":[
+        AirDefence.AAA_8_8cm_Flak_36,
+    ],
+    "objects": WW2_GERMANY_BUILDINGS,
+    "doctrine": WWII_DOCTRINE,
+    "boat": ["UBoatGroupGenerator", "SchnellbootGroupGenerator"],
+    "boat_count": 1,
+    "missiles": ["V1GroupGenerator"],
+    "missiles_count": 1
+}

game/factions/germany_1990.py

@@ -0,0 +1,45 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Germany_1990 = {
+    "country": "Germany",
+    "side": "blue",
+    "units":[
+        MiG_29G,
+        Tornado_IDS,
+        F_4E,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        SA342M,
+        SA342L,
+
+        Armor.TPz_Fuchs,
+        Armor.MBT_Leopard_1A3,
+        Armor.MBT_Leopard_2,
+        Armor.IFV_Marder,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Roland_ADS,
+        AirDefence.SAM_Hawk_PCP,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ],
+    "shorad":[
+        AirDefence.SPAAA_Gepard,
+        AirDefence.SAM_Roland_ADS,
+    ], "boat":[
+        "OliverHazardPerryGroupGenerator"
+    ]
+}

game/factions/india_2010.py

@@ -0,0 +1,55 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+India_2010 = {
+    "country": "India",
+    "side": "blue",
+    "units": [
+        Mirage_2000_5,
+        M_2000C,
+        MiG_27K,
+        MiG_21Bis,
+        MiG_29S,
+        Su_30,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        AH_64A,
+        Mi_8MT,
+
+        Armor.MBT_T_90,
+        Armor.MBT_T_72B,
+        Armor.IFV_BMP_2,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ],
+    "shorad":[
+        AirDefence.SAM_SA_8_Osa_9A33,
+        AirDefence.AAA_ZU_23_Emplacement,
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
+        AirDefence.SAM_SA_8_Osa_9A33,
+        AirDefence.SAM_SA_19_Tunguska_2S6
+    ], "aircraft_carrier": [
+        CV_1143_5_Admiral_Kuznetsov,
+    ], "destroyer": [
+        FSG_1241_1MP_Molniya,
+    ], "carrier_names": [
+        "INS Vikramaditya"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator", "MolniyaGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/insurgent.py

@@ -0,0 +1,27 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Insurgent = {
+    "country": "Insurgents",
+    "side": "red",
+    "units": [
+
+        AirDefence.AAA_ZU_23_Insurgent_Closed,
+        AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
+
+        Armor.APC_Cobra,
+        Armor.APC_MTLB,
+        Armor.ARV_BRDM_2,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+        Infantry.Infantry_Soldier_Insurgents,
+        Infantry.Soldier_RPG,
+
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160
+    ]
+}

game/factions/insurgent_modded.py

@@ -0,0 +1,33 @@
+from dcs.ships import *
+from dcs.vehicles import *
+
+from pydcs_extensions.frenchpack.frenchpack import DIM__TOYOTA_BLUE, DIM__TOYOTA_DESERT, DIM__TOYOTA_GREEN, \
+    DIM__KAMIKAZE
+
+Insurgent_modded = {
+    "country": "Insurgents",
+    "side": "red",
+    "units": [
+
+        AirDefence.AAA_ZU_23_Insurgent_Closed,
+        AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
+
+        DIM__TOYOTA_BLUE,
+        DIM__TOYOTA_DESERT,
+        DIM__TOYOTA_GREEN,
+        DIM__KAMIKAZE,
+        Armor.ARV_BRDM_2,
+        Armor.APC_Cobra,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+        Infantry.Soldier_AK,
+        Infantry.Infantry_Soldier_Insurgents,
+
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160
+    ], "requirements": {
+        "frenchpack V3.5": "https://forums.eagle.ru/showthread.php?t=279974",
+    }
+}

game/factions/iran_2015.py

@@ -0,0 +1,58 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Iran_2015 = {
+    "country": "Iran",
+    "side": "red",
+    "units": [
+
+        MiG_29A,
+        F_4E,
+        F_14B,
+        F_5E_3,
+
+        MiG_21Bis,
+        Su_24M,
+        Su_25,
+        Su_17M4,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        A_50,
+
+        Mi_28N,
+        Mi_24V,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_SA_2_LN_SM_90,
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
+
+        Armor.APC_M113,
+        Armor.APC_BTR_80,
+        Armor.MBT_M60A3_Patton,
+        Armor.MBT_T_72B,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+        Infantry.Soldier_AK,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160
+    ],
+    "shorad":[
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.AAA_ZU_23_Insurgent_Closed
+    ], "boat":[
+        "GrishaGroupGenerator", "MolniyaGroupGenerator", "KiloSubGroupGenerator"
+    ]
+}

game/factions/israel_1948.py

@@ -0,0 +1,33 @@
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Israel_1948 = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        SpitfireLFMkIXCW,
+        SpitfireLFMkIX,
+        P_51D,
+        P_51D_30_NA,
+        Bf_109K_4, # Standing as Avia S-199
+        B_17G,
+
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.APC_M2A1,
+        Armor.MT_M4_Sherman,
+        Armor.LAC_M8_Greyhound,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_SMLE_No_4_Mk_1,
+
+        AirDefence.AAA_Bofors_40mm,
+        Armed_speedboat,
+    ],"requirements":{
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "shorad": [
+        AirDefence.AAA_Bofors_40mm
+    ], "boat": [
+    ], "has_jtac": False
+}

game/factions/israel_1973.py

@@ -0,0 +1,112 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from pydcs_extensions.a4ec.a4ec import A_4E_C
+
+Israel_1973 = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        F_4E,
+        A_4E_C,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.APC_M2A1,
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.AAA_Bofors_40mm,
+        AirDefence.SAM_Chaparral_M48,
+
+        Armed_speedboat,
+    ], "requirements": {
+        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    }, "shorad": [
+        AirDefence.SAM_Chaparral_M48,
+        AirDefence.AAA_Bofors_40mm
+    ], "boat": [
+    ], "has_jtac": True
+}
+
+Israel_1973_NO_WW2_UNITS = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        F_4E,
+        A_4E_C,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Chaparral_M48,
+
+        Armed_speedboat,
+    ], "requirements": {
+        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
+    }, "shorad": [
+        AirDefence.SAM_Chaparral_M48,
+    ], "boat": [
+    ], "has_jtac": True
+}
+
+Israel_1982 = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        F_4E,
+        A_4E_C,
+        F_15C,
+        F_16A,
+        F_16C_50,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        AH_1W,
+
+        Armor.APC_M113,
+        Armor.MBT_M60A3_Patton,
+        Armor.MBT_Merkava_Mk__4,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Chaparral_M48,
+
+        Armed_speedboat,
+    ], "requirements": {
+        "Community A-4E": "https://heclak.github.io/community-a4e-c/",
+    }, "shorad": [
+        AirDefence.SAM_Chaparral_M48,
+    ], "boat": [
+    ], "has_jtac": True
+}

game/factions/israel_2000.py

@@ -0,0 +1,44 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Israel_2000 = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        F_16C_50,
+        F_15C,
+        F_15E,
+        F_4E,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        AH_1W,
+        AH_64D,
+
+        Armor.MBT_Merkava_Mk__4,
+        Armor.APC_M113,
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.ATGM_M1045_HMMWV_TOW,
+        Artillery.SPH_M109_Paladin,
+        Artillery.MLRS_M270,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_Patriot_EPP_III,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ],
+    "shorad": [
+        AirDefence.SAM_Avenger_M1097
+    ], "boat": [
+        "ArleighBurkeGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/italy_1990.py

@@ -0,0 +1,48 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Italy_1990 = {
+     "country": "Italy",
+     "side": "blue",
+     "units": [
+         Tornado_IDS,
+         AV8BNA,
+         # MB339,
+
+         KC_135,
+         S_3B_Tanker,
+         C_130,
+         E_3A,
+
+         AH_1W,
+         UH_1H,
+
+         Armor.MBT_Leopard_1A3,  # OF-40 MBT
+         Armor.APC_M113,
+
+         Unarmed.Transport_M818,
+         Infantry.Infantry_M4,
+
+         AirDefence.SAM_Hawk_PCP,
+         AirDefence.SAM_Avenger_M1097,
+
+         CVN_74_John_C__Stennis,
+         LHA_1_Tarawa,
+         Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "lhanames": [
+        "Giuseppe Garibaldi",
+        "Cavour",
+    ], "boat":[
+        "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/italy_1990_mb339.py

@@ -0,0 +1,52 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from pydcs_extensions.mb339.mb339 import MB_339PAN
+
+Italy_1990_MB339 = {
+     "country": "Italy",
+     "side": "blue",
+     "units": [
+         Tornado_IDS,
+         AV8BNA,
+         MB_339PAN,
+
+         KC_135,
+         S_3B_Tanker,
+         C_130,
+         E_3A,
+
+         AH_1W,
+         UH_1H,
+
+         Armor.MBT_Leopard_1A3,  # OF-40 MBT
+         Armor.APC_M113,
+
+         Unarmed.Transport_M818,
+         Infantry.Infantry_M4,
+
+         AirDefence.SAM_Hawk_PCP,
+         AirDefence.SAM_Avenger_M1097,
+
+         CVN_74_John_C__Stennis,
+         LHA_1_Tarawa,
+         Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "lhanames": [
+        "Giuseppe Garibaldi",
+        "Cavour",
+    ], "boat": [
+        "OliverHazardPerryGroupGenerator"
+    ], "requirements": {
+        "MB-339A": "http://www.freccetricolorivirtuali.net/",
+    }, "has_jtac": True
+}

game/factions/japan_2005.py

@@ -0,0 +1,54 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Japan_2005 = {
+    "country": "Japan",
+    "side": "blue",
+    "units": [
+        F_15C,     # F-15J/DJ
+        F_16C_50,  # F-2A/B
+        F_4E,      # F-4EJ
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        AH_1W,
+        AH_64D,
+
+        Armor.MBT_Merkava_Mk__4,  # Standing as Type 10 MBT
+        Armor.MBT_M1A2_Abrams,    # Standing as Type 90 MBT
+        Armor.IFV_Marder,         # Standing as Type 89 IFV
+        Armor.TPz_Fuchs,          # Standing as Type 96 APC
+        Armor.IFV_LAV_25,         # Standing as Type 16 or Type 87
+        Armor.APC_M1043_HMMWV_Armament,
+
+        Artillery.MLRS_M270,
+        Artillery.SPH_M109_Paladin,  # Standing as Type 99 SPH
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Patriot_EPP_III,
+
+        LHA_1_Tarawa,
+    ], "shorad": [
+        AirDefence.SPAAA_Gepard,  # Type 87 SPAG
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa, # Standing as Hyuga-class helicopter carrier
+    ], "destroyer": [
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "lhanames": [
+        "Hyuga",
+        "Ise",
+    ], "boat":[
+        "ArleighBurkeGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/libya_2011.py

@@ -0,0 +1,49 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.vehicles import *
+
+Libya_2011 = {
+    "country": "Libya",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_23MLD,
+        Su_24M,
+        Su_17M4,
+        Mi_24V,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+        A_50,
+
+        AirDefence.SAM_SA_8_Osa_9A33,
+        AirDefence.SAM_SA_2_LN_SM_90,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.HQ_7_Self_Propelled_LN,
+
+        Armor.IFV_BMP_1,
+        Armor.FDDM_Grad,
+        Armor.ARV_BRDM_2,
+        Armor.MBT_T_55,
+        Armor.MBT_T_72B,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Infantry_Soldier_Insurgents
+
+    ],
+    "shorad":[
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.SAM_SA_8_Osa_9A33,
+    ], "boat": [
+        "GrishaGroupGenerator", "MolniyaGroupGenerator"
+    ]
+}

game/factions/netherlands_1990.py

@@ -0,0 +1,38 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Netherlands_1990 = {
+    "country": "The Netherlands",
+    "side": "blue",
+    "units": [
+        F_16C_50,
+        F_5E_3,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        AH_64A,
+
+        Armor.APC_M113,
+        Armor.MBT_Leopard_1A3,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Avenger_M1097,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ],
+    "shorad": [
+        AirDefence.SAM_Avenger_M1097
+    ], "boat": [
+        "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/north_korea_2000.py

@@ -0,0 +1,53 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+NorthKorea_2000 = {
+    "country": "North Korea",
+    "side": "red",
+    "units":[
+        MiG_29A,
+        Su_25,
+        MiG_15bis,
+        MiG_21Bis,
+        MiG_23MLD,
+        MiG_19P,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        A_50,
+
+        Mi_8MT,
+        Mi_24V,
+
+        Armor.MBT_T_55,
+        Armor.MBT_T_72B,
+        Armor.MBT_T_80U,
+        Armor.IFV_BMP_1,
+        Armor.APC_BTR_80,
+        Armor.ARV_BRDM_2,
+
+        Unarmed.Transport_M818,
+        Infantry.Soldier_AK,
+
+        AirDefence.SAM_SA_2_LN_SM_90,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160
+    ],
+    "shorad":[
+        AirDefence.AAA_ZU_23_Emplacement,
+        AirDefence.SPAAA_ZSU_23_4_Shilka
+    ],
+    "boat": [
+        "GrishaGroupGenerator", "MolniyaGroupGenerator"
+    ]
+}

game/factions/pakistan_2015.py

@@ -0,0 +1,42 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Pakistan_2015 = {
+    "country": "Pakistan",
+    "side": "blue",
+    "units": [
+        JF_17,
+        F_16C_50,
+        MiG_21Bis, # Standing as J-7
+        MiG_19P, # Standing as J-6
+        IL_78M,
+        E_3A,
+
+        UH_1H,
+        AH_1W,
+
+        Armor.MBT_T_80U,
+        Armor.MBT_T_55, # Standing as Al-Zarrar / Type 59 MBT
+        Armor.ZBD_04A,
+        Armor.APC_BTR_80,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_SA_2_LN_SM_90,          # Standing as HQ-2
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85C, # Standing as HQ-9
+
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
+        AirDefence.AAA_ZU_23_Closed
+    ], "boat": [
+        "Type54GroupGenerator", "OliverHazardPerryGroupGenerator"
+    ],
+    "has_jtac": True,
+    "jtac_unit": WingLoong_I
+}

game/factions/private_miltary_companies.py

@@ -0,0 +1,91 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from pydcs_extensions.mb339.mb339 import MB_339PAN
+
+PMC_WESTERN_A = {
+     "country": "USA",
+     "side": "blue",
+     "units": [
+         C_101CC,
+
+         UH_1H,
+         Mi_8MT,
+         OH_58D,
+         SA342M,
+
+         Armor.APC_M1043_HMMWV_Armament,
+         Armor.IFV_MCV_80,
+
+         Unarmed.Transport_M818,
+         Infantry.Infantry_M4,
+         Infantry.Soldier_M249,
+
+         AirDefence.SAM_Avenger_M1097,
+
+         Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "has_jtac": True
+}
+
+PMC_WESTERN_B = {
+     "country": "USA",
+     "side": "blue",
+     "units": [
+         MB_339PAN,
+         C_101CC,
+
+         UH_1H,
+         Mi_8MT,
+         OH_58D,
+         SA342M,
+
+         Armor.APC_M1043_HMMWV_Armament,
+         Armor.IFV_MCV_80,
+
+         Unarmed.Transport_M818,
+         Infantry.Infantry_M4,
+         Infantry.Soldier_M249,
+
+         AirDefence.SAM_Avenger_M1097,
+
+         Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "has_jtac": True,
+    "requirements": {
+        "MB-339A": "http://www.freccetricolorivirtuali.net/",
+    }
+}
+
+PMC_RUSSIAN = {
+     "country": "Russia",
+     "side": "blue",
+     "units": [
+         L_39C,
+         L_39ZA,
+
+         Mi_8MT,
+         Mi_24V,
+         Ka_50,
+
+         Armor.APC_Cobra,
+         Armor.APC_BTR_80,
+         Armor.ARV_BRDM_2,
+
+         Unarmed.Transport_Ural_375,
+         Infantry.Paratrooper_AKS,
+         Infantry.Paratrooper_RPG_16,
+
+         AirDefence.AAA_ZU_23_on_Ural_375,
+
+         Armed_speedboat,
+    ], "shorad":[
+        AirDefence.AAA_ZU_23_on_Ural_375,
+        AirDefence.AAA_ZU_23_Closed,
+    ], "has_jtac": True
+}
+

game/factions/russia_1955.py

@@ -0,0 +1,38 @@
+from dcs.planes import MiG_15bis, IL_76MD, IL_78M, An_26B, An_30M, Yak_40
+from dcs.ships import CV_1143_5_Admiral_Kuznetsov, Bulk_cargo_ship_Yakushev, Dry_cargo_ship_Ivanov, Tanker_Elnya_160
+from dcs.vehicles import AirDefence, Armor, Unarmed, Infantry, Artillery
+
+Russia_1955 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+        MiG_15bis,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        AirDefence.AAA_ZU_23_Closed,
+        AirDefence.AAA_ZU_23_on_Ural_375,
+        Armor.ARV_BRDM_2,
+        Armor.FDDM_Grad,
+        Armor.APC_MTLB,
+        Armor.MBT_T_55,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+
+        # Infantry squad
+        Infantry.Paratrooper_AKS,
+        Infantry.Infantry_Soldier_Rus,
+        Infantry.Paratrooper_RPG_16,
+    ]
+}

game/factions/russia_1965.py

@@ -0,0 +1,55 @@
+from dcs.helicopters import Mi_8MT
+from dcs.planes import MiG_15bis, MiG_19P, MiG_21Bis, IL_76MD, IL_78M, An_26B, An_30M, Yak_40, A_50
+from dcs.ships import CV_1143_5_Admiral_Kuznetsov, Bulk_cargo_ship_Yakushev, Dry_cargo_ship_Ivanov, Tanker_Elnya_160
+from dcs.vehicles import AirDefence, Armor, Unarmed, Infantry, Artillery
+
+Russia_1965 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+        MiG_15bis,
+        MiG_19P,
+        MiG_21Bis,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        A_50,
+
+        Mi_8MT,
+
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_2_LN_SM_90,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+
+        Armor.ARV_BRDM_2,
+        Armor.APC_BTR_80,
+        Armor.ARV_BTR_RD,
+        Armor.IFV_BMD_1,
+        Armor.IFV_BMP_1,
+        Armor.MBT_T_55,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+
+        # Infantry squad
+        Infantry.Paratrooper_AKS,
+        Infantry.Infantry_Soldier_Rus,
+        Infantry.Paratrooper_RPG_16,
+
+    ],
+    "shorad":[
+        AirDefence.AAA_ZU_23_Closed
+    ], "boat": [
+        "GrishaGroupGenerator"
+    ]
+}

game/factions/russia_1975.py

@@ -0,0 +1,71 @@
+from dcs.helicopters import Mi_8MT, Mi_24V
+from dcs.planes import MiG_21Bis, MiG_23MLD, MiG_25PD, MiG_29A, Su_17M4, Su_24M, Su_25, IL_76MD, IL_78M, An_26B, An_30M, \
+    Yak_40, A_50
+from dcs.ships import *
+from dcs.vehicles import AirDefence, Armor, Unarmed, Infantry, Artillery
+
+Russia_1975 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_23MLD,
+        MiG_25PD,
+        MiG_29A,
+
+        Su_17M4,
+        Su_24M,
+        Su_25,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        A_50,
+
+        Mi_8MT,
+        Mi_24V,
+
+        AirDefence.AAA_ZU_23_Closed,
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+
+        Armor.ARV_BRDM_2,
+        Armor.APC_BTR_80,
+        Armor.IFV_BMD_1,
+        Armor.IFV_BMP_1,
+        Armor.MBT_T_55,
+
+        Artillery.SPH_2S9_Nona,
+        Artillery.SPH_2S1_Gvozdika,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+
+        # Infantry squad
+        Infantry.Paratrooper_AKS,
+        Infantry.Infantry_Soldier_Rus,
+        Infantry.Paratrooper_RPG_16,
+
+    ],
+    "shorad": [
+        AirDefence.AAA_ZU_23_Emplacement,
+        AirDefence.SPAAA_ZSU_23_4_Shilka
+    ], "aircraft_carrier": [
+        CV_1143_5_Admiral_Kuznetsov,
+    ], "destroyer": [
+        FF_1135M_Rezky,
+    ], "cruiser": [
+        CGN_1144_2_Pyotr_Velikiy,
+    ], "boat": [
+        "RussianNavyGroupGenerator", "KiloSubGroupGenerator", "MolniyaGroupGenerator"
+    ]
+}

game/factions/russia_1990.py

@@ -0,0 +1,74 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Russia_1990 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+
+        MiG_23MLD,
+        MiG_25PD,
+        MiG_29A,
+        MiG_29S,
+        MiG_31,
+        Su_27,
+
+        Su_24M,
+        Su_25,
+        Ka_50,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        A_50,
+
+        Mi_8MT,
+        Mi_24V,
+
+        AirDefence.AAA_ZU_23_Closed,
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+
+        Armor.ARV_BRDM_2,
+        Armor.APC_BTR_80,
+        Armor.IFV_BMD_1,
+        Armor.IFV_BMP_1,
+        Armor.MBT_T_55,
+        Artillery.MLRS_9K57_Uragan_BM_27,
+        Artillery.SPH_2S19_Msta,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+
+        # Infantry squad
+        Infantry.Paratrooper_AKS,
+        Infantry.Infantry_Soldier_Rus,
+        Infantry.Paratrooper_RPG_16,
+    ],
+    "shorad":[
+        AirDefence.SAM_SA_9_Strela_1_9P31,
+        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
+        AirDefence.SPAAA_ZSU_23_4_Shilka
+    ], "carrier_names": [
+        "Admiral Kuznetov",
+        "Admiral Gorshkov"
+    ], "aircraft_carrier": [
+        CV_1143_5_Admiral_Kuznetsov,
+    ], "destroyer": [
+        FF_1135M_Rezky,
+    ], "cruiser": [
+        FSG_1241_1MP_Molniya,
+    ], "boat":[
+        "RussianNavyGroupGenerator", "KiloSubGroupGenerator"
+    ]
+}

game/factions/russia_2010.py

@@ -0,0 +1,77 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Russia_2010 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+
+        Su_27,
+        Su_30,
+        Su_33,
+        MiG_29S,
+        MiG_31,
+
+        Su_25,
+        Su_25T,
+        Su_34,
+        Su_24M,
+        L_39ZA,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+        A_50,
+
+        Ka_50,
+        Mi_8MT,
+        Mi_24V,
+        Mi_28N,
+
+        AirDefence.SAM_SA_19_Tunguska_2S6,
+        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+
+        Armor.APC_BTR_80,
+        Armor.MBT_T_90,
+        Armor.MBT_T_80U,
+        Armor.MBT_T_72B,
+        Armor.IFV_BMP_1,
+        Armor.IFV_BMP_2,
+        Armor.IFV_BMP_3,
+
+        Artillery.MLRS_9K57_Uragan_BM_27,
+        Artillery.SPH_2S19_Msta,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+
+        # Infantry squad
+        Infantry.Paratrooper_AKS,
+        Infantry.Infantry_Soldier_Rus,
+        Infantry.Paratrooper_RPG_16,
+    ],
+    "shorad":[
+        AirDefence.SAM_SA_19_Tunguska_2S6,
+        AirDefence.SAM_SA_13_Strela_10M3_9A35M3
+    ], "aircraft_carrier": [
+        CV_1143_5_Admiral_Kuznetsov,
+    ], "carrier_names": [
+        "Admiral Kuznetov"
+    ], "destroyer": [
+        FF_1135M_Rezky,
+    ], "cruiser": [
+        FSG_1241_1MP_Molniya,
+    ], "boat": [
+        "RussianNavyGroupGenerator", "KiloSubGroupGenerator"
+    ]
+}

game/factions/spain_1990.py

@@ -0,0 +1,50 @@
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Spain_1990 = {
+    "country": "Spain",
+    "side": "blue",
+    "units": [
+        FA_18C_hornet,
+        AV8BNA,
+        F_5E_3,
+        C_101CC,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.MBT_Leopard_2,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Avenger_M1097,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis, # Standing as Principe de Asturias
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa, # Standing as Juan Carlos
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "Principe de Asturias",
+    ], "lhanames": [
+        "Juan Carlos I",
+    ], "boat":[
+        "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/sweden_1990.py

@@ -0,0 +1,31 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Sweden_1990 = {
+    "country": "Sweden",
+    "side": "blue",
+    "units": [
+        AJS37,
+
+        UH_1H,
+
+        AirDefence.SAM_Hawk_PCP,
+
+        Armor.IFV_MCV_80, # Standing  as Strf 90
+        Armor.MBT_Leopard_2,
+        Armor.APC_M1126_Stryker_ICV, # Closest thing available
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+        Infantry.Soldier_AK,
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+    ],
+    "shorad": [
+        AirDefence.SAM_Avenger_M1097
+    ], "has_jtac": True
+}

game/factions/syria.py

@@ -0,0 +1,267 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.vehicles import *
+
+Syria_2011 = {
+    "country": "Syria",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_23MLD,
+        MiG_25PD,
+        MiG_29S,
+
+        Su_17M4,
+        Su_24M,
+
+        L_39ZA,
+
+        Mi_24V,
+        Mi_8MT,
+        SA342M,
+        SA342L,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+        A_50,
+
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+        AirDefence.SAM_SA_2_LN_SM_90,
+        AirDefence.SAM_SA_8_Osa_9A33,
+        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+
+        Armor.IFV_BMP_1,
+        Armor.IFV_BMP_2,
+        Armor.APC_BTR_80,
+        Armor.ARV_BRDM_2,
+        Armor.APC_MTLB,
+        Armor.APC_Cobra,
+        Armor.MBT_T_55,
+        Armor.MBT_T_72B,
+        Armor.MBT_T_90,
+        Artillery.MLRS_BM_21_Grad,
+        Artillery.MLRS_9K57_Uragan_BM_27,
+        Artillery.SPH_2S1_Gvozdika,
+        Artillery.SPH_2S9_Nona,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Soldier_AK
+
+    ],
+    "shorad": [
+        AirDefence.SAM_SA_8_Osa_9A33,
+        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
+        AirDefence.SAM_SA_9_Strela_1_9P31,
+        AirDefence.SAM_SA_19_Tunguska_2S6,
+        AirDefence.AAA_ZU_23_on_Ural_375,
+    ], "boat": [
+        "GrishaGroupGenerator", "MolniyaGroupGenerator"
+    ]
+}
+
+Syria_1973 = {
+    "country": "Syria",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_19P,
+        MiG_15bis,  # Standing as Mig-17
+
+        Su_17M4,  # Standing as Su-7
+        Mi_8MT,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+        AirDefence.SAM_SA_2_LN_SM_90,
+
+        Armor.IFV_BMP_1,
+        Armor.APC_MTLB,
+        Armor.MBT_T_55,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Soldier_AK
+
+    ],
+    "shorad": [
+        AirDefence.AAA_ZU_23_on_Ural_375,
+    ], "boat": [
+        "GrishaGroupGenerator"
+    ]
+}
+
+
+Syria_1982 = {
+    "country": "Syria",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_23MLD,
+        MiG_25PD,
+        MiG_19P,
+
+        Su_17M4,  # Standing as Su-7
+        Mi_8MT,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+        AirDefence.SAM_SA_2_LN_SM_90,
+
+        Armor.IFV_BMP_1,
+        Armor.APC_MTLB,
+        Armor.MBT_T_55,
+        Armor.MBT_T_72B,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Soldier_AK
+
+    ],
+    "shorad": [
+        AirDefence.AAA_ZU_23_on_Ural_375,
+    ], "boat": [
+        "GrishaGroupGenerator"
+    ]
+}
+
+
+Syria_1967 = {
+    "country": "Syria",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_19P,
+        MiG_15bis,  # Standing as Mig-17
+
+        Su_17M4,  # Standing as Su-7
+        Mi_8MT,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        AirDefence.SAM_SA_2_LN_SM_90,
+
+        Armor.ARV_BRDM_2,
+        Armor.MBT_T_55,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Soldier_AK
+
+    ],
+    "shorad": [
+        AirDefence.AAA_ZU_23_on_Ural_375,
+    ], "boat": [
+        "GrishaGroupGenerator"
+    ]
+}
+
+Syria_1967_WW2_Weapons = {
+    "country": "Syria",
+    "side": "red",
+    "units": [
+
+        MiG_21Bis,
+        MiG_19P,
+        MiG_15bis,  # Standing as Mig-17
+
+        Su_17M4,  # Standing as Su-7
+        Mi_8MT,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+
+        AirDefence.SAM_SA_2_LN_SM_90,
+
+        Armor.ARV_BRDM_2,
+        Armor.MBT_T_55,
+        Armor.MT_Pz_Kpfw_IV_Ausf_H,
+        Armor.StuG_III_Ausf__G,
+        Armor.TD_Jagdpanzer_IV,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Soldier_RPG,
+        Infantry.Soldier_AK
+
+    ], "requirements": {
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "shorad": [
+        AirDefence.AAA_ZU_23_on_Ural_375,
+    ], "boat": [
+        "GrishaGroupGenerator"
+    ]
+}
+
+Arab_Armies_1948 = {
+    "country": "Syria",
+    "side": "red",
+    "units": [
+        SpitfireLFMkIX,
+        SpitfireLFMkIXCW,
+
+        AirDefence.SAM_SA_2_LN_SM_90,
+
+        Armor.MT_M4_Sherman,
+        Armor.MT_Pz_Kpfw_IV_Ausf_H,
+        Armor.APC_Sd_Kfz_251,
+        Armor.IFV_Sd_Kfz_234_2_Puma,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Infantry_SMLE_No_4_Mk_1,
+
+        AirDefence.AAA_8_8cm_Flak_36,
+
+    ], "requirements": {
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "shorad": [
+        AirDefence.AAA_8_8cm_Flak_36,
+    ], "boat": [
+        "GrishaGroupGenerator"
+    ]
+}

game/factions/turkey_2005.py

@@ -0,0 +1,41 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Turkey_2005 = {
+    "country": "Turkey",
+    "side": "blue",
+    "units":[
+        F_16C_50,
+        F_4E,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        AH_1W,
+
+        Armor.MBT_Leopard_2,
+        Armor.MBT_Leopard_1A3,
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_Cobra,
+        Armor.APC_BTR_80,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.SAM_Avenger_M1097,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad":[
+        AirDefence.AAA_ZU_23_Emplacement,
+        AirDefence.SPAAA_ZSU_23_4_Shilka
+    ], "boat":[
+        "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/uae_2005.py

@@ -0,0 +1,38 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+UAE_2005 = {
+    "country": "United Arab Emirates",
+    "side": "blue",
+    "units":[
+        M_2000C,
+        Mirage_2000_5,
+        F_16C_50,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        AH_64D,
+
+        Armor.MBT_Leclerc,
+        Armor.IFV_BMP_3,
+        Armor.TPz_Fuchs,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.Rapier_FSA_Launcher,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "boat":[
+        "OliverHazardPerryGroupGenerator"
+    ],
+    "has_jtac": True,
+    "jtac_unit": WingLoong_I
+}

game/factions/uk_1944.py

@@ -0,0 +1,44 @@
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from game.data.building_data import WW2_ALLIES_BUILDINGS
+from game.data.doctrine import WWII_DOCTRINE
+
+UK_1944 = {
+    "country": "UK",
+    "side": "blue",
+    "units": [
+        P_51D,
+        P_51D_30_NA,
+        P_47D_30,
+        SpitfireLFMkIX,
+        SpitfireLFMkIXCW,
+        A_20G,
+        B_17G,
+
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.MT_M4_Sherman,
+        Armor.APC_M2A1,
+        Armor.CT_Cromwell_IV,
+        Armor.ST_Centaur_IV,
+        Armor.HIT_Churchill_VII,
+
+        Infantry.Infantry_SMLE_No_4_Mk_1,
+
+        LS_Samuel_Chase,
+        LST_Mk_II,
+        LCVP__Higgins_boat,
+
+        Unarmed.CCKW_353,
+        AirDefence.AAA_Bofors_40mm,
+    ], "shorad":[
+        AirDefence.AAA_Bofors_40mm,
+    ],"requirements":{
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "objects": WW2_ALLIES_BUILDINGS,
+    "doctrine": WWII_DOCTRINE,
+    "boat": ["WW2LSTGroupGenerator"],
+    "boat_count": 1
+}

game/factions/uk_1990.py

@@ -0,0 +1,52 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+UnitedKingdom_1990 = {
+    "country": "UK",
+    "side": "blue",
+    "units":[
+        AV8BNA, # Standing as BAE Harrier 2
+        Tornado_GR4,
+        F_4E,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        SA342M,
+        AH_64A,
+
+        Armor.MBT_Challenger_II,
+        Armor.IFV_MCV_80,
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.ATGM_M1045_HMMWV_TOW,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.Rapier_FSA_Launcher,
+        AirDefence.SAM_Avenger_M1097, # Standing as Starstreak
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "lhanames": [
+        "HMS Invincible",
+        "HMS Illustrious",
+        "HMS Ark Royal",
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/ukraine_2010.py

@@ -0,0 +1,53 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Ukraine_2010 = {
+    "country": "Ukraine",
+    "side": "blue",
+    "units": [
+        Su_25,
+        Su_25T,
+        Su_24M,
+        Su_27,
+        MiG_29S,
+        L_39ZA,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+        A_50,
+
+        Mi_8MT,
+        Mi_24V,
+
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
+        AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.IFV_BMP_3,
+        Armor.IFV_BMP_2,
+        Armor.APC_BTR_80,
+        Armor.MBT_T_80U,
+        Armor.MBT_T_72B,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+        Infantry.Soldier_AK,
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+        Tanker_Elnya_160,
+    ],
+    "shorad":[
+        AirDefence.SAM_SA_19_Tunguska_2S6,
+        AirDefence.SAM_SA_13_Strela_10M3_9A35M3,
+        AirDefence.AAA_ZU_23_on_Ural_375
+    ], "boat":[
+        "GrishaGroupGenerator"
+    ]
+}

game/factions/us_aggressors.py

@@ -0,0 +1,72 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+US_Aggressors = {
+    "country": "USAF Aggressors",
+    "side": "red",
+    "units": [
+
+        F_15C,
+        F_5E_3,
+        FA_18C_hornet,
+        F_16C_50,
+        Su_27,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        AH_64D,
+        Ka_50,
+        SA342M,
+        SA342L,
+
+        Armor.MBT_M1A2_Abrams,
+        Armor.MBT_Leopard_2,
+        Armor.ATGM_M1134_Stryker,
+        Armor.IFV_M2A2_Bradley,
+        Armor.APC_M1043_HMMWV_Armament,
+
+        Artillery.MLRS_M270,
+        Artillery.SPH_M109_Paladin,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Patriot_EPP_III,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.SAM_Avenger_M1097,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "CVN-71 Theodore Roosevelt",
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 George Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ]
+}

game/factions/usa_1944.py

@@ -0,0 +1,86 @@
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+from game.data.building_data import WW2_ALLIES_BUILDINGS
+from game.data.doctrine import WWII_DOCTRINE
+
+USA_1944 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        P_51D,
+        P_51D_30_NA,
+        P_47D_30,
+        A_20G,
+        B_17G,
+
+        Armor.MT_M4_Sherman,
+        Armor.M30_Cargo_Carrier,
+        Armor.APC_M2A1,
+        Armor.LAC_M8_Greyhound,
+        Armor.TD_M10_GMC,
+        Artillery.M12_GMC,
+
+        Infantry.Infantry_M1_Garand,
+
+        LS_Samuel_Chase,
+        LST_Mk_II,
+        LCVP__Higgins_boat,
+
+        Unarmed.CCKW_353,
+        AirDefence.AAA_Bofors_40mm,
+    ], "shorad":[
+        AirDefence.AAA_Bofors_40mm,
+    ],"requirements":{
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "objects": WW2_ALLIES_BUILDINGS,
+    "doctrine": WWII_DOCTRINE,
+    "boat": ["WW2LSTGroupGenerator"],
+    "boat_count": 2
+}
+
+ALLIES_1944 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        P_51D,
+        P_51D_30_NA,
+        P_47D_30,
+        SpitfireLFMkIX,
+        SpitfireLFMkIXCW,
+        A_20G,
+        B_17G,
+
+        Armor.MT_M4_Sherman,
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.CT_Cromwell_IV,
+        Armor.M30_Cargo_Carrier,
+        Armor.APC_M2A1,
+        Armor.CT_Cromwell_IV,
+        Armor.ST_Centaur_IV,
+        Armor.HIT_Churchill_VII,
+        Armor.LAC_M8_Greyhound,
+        Armor.TD_M10_GMC,
+        Artillery.M12_GMC,
+
+        Infantry.Infantry_M1_Garand,
+        Infantry.Infantry_SMLE_No_4_Mk_1,
+
+        LS_Samuel_Chase,
+        LST_Mk_II,
+        LCVP__Higgins_boat,
+
+        Unarmed.CCKW_353,
+        AirDefence.AAA_Bofors_40mm,
+    ], "shorad":[
+        AirDefence.AAA_Bofors_40mm,
+    ],"requirements":{
+        "WW2 Asset Pack": "https://www.digitalcombatsimulator.com/en/products/other/wwii_assets_pack/",
+    },
+    "objects": WW2_ALLIES_BUILDINGS,
+    "doctrine": WWII_DOCTRINE,
+    "boat": ["WW2LSTGroupGenerator"],
+    "boat_count": 2
+}

game/factions/usa_1955.py

@@ -0,0 +1,33 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+USA_1955 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        F_86F_Sabre,
+        P_51D,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.MT_M4_Sherman,
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M2A1,
+        Armor.M30_Cargo_Carrier,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+
+        AirDefence.AAA_Bofors_40mm,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ]
+}

game/factions/usa_1960.py

@@ -0,0 +1,36 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+USA_1960 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        F_86F_Sabre,
+        P_51D,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.AAA_Vulcan_M163,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ],
+    "shorad":[
+        AirDefence.AAA_Vulcan_M163
+    ]
+}

game/factions/usa_1965.py

@@ -0,0 +1,41 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+USA_1965 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+
+        F_5E_3,
+        F_4E,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        B_52H,
+
+        UH_1H,
+
+        Armor.MBT_M60A3_Patton,
+        Armor.APC_M113,
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Chaparral_M48,
+        AirDefence.SAM_Hawk_PCP,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ],
+    "shorad":[
+        AirDefence.AAA_Vulcan_M163,
+        AirDefence.SAM_Chaparral_M48
+    ], "boat":[
+    ]
+}

game/factions/usa_1990.py

@@ -0,0 +1,65 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+USA_1990 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        F_15C,
+        F_15E,
+        F_14B,
+        FA_18C_hornet,
+        F_16C_50,
+
+        A_10A,
+        AV8BNA,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        AH_64A,
+
+        Armor.MBT_M1A2_Abrams,
+        Armor.IFV_LAV_25,
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.ATGM_M1045_HMMWV_TOW,
+        Armor.ATGM_M1134_Stryker,
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad":[
+        AirDefence.SAM_Avenger_M1097,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        Oliver_Hazzard_Perry_class,
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 Georges Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ], "has_jtac": True
+}

game/factions/usa_2005.py

@@ -0,0 +1,73 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+USA_2005 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        F_15C,
+        F_15E,
+        F_14B,
+        FA_18C_hornet,
+        F_16C_50,
+        A_10C,
+        A_10C_2,
+        AV8BNA,
+        MQ_9_Reaper,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        AH_64D,
+
+        Armor.MBT_M1A2_Abrams,
+        Armor.ATGM_M1134_Stryker,
+        Armor.APC_M1126_Stryker_ICV,
+        Armor.IFV_M2A2_Bradley,
+        Armor.IFV_LAV_25,
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.ATGM_M1045_HMMWV_TOW,
+
+        Artillery.MLRS_M270,
+        Artillery.SPH_M109_Paladin,
+
+        Unarmed.Transport_M818,
+        Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_Patriot_EPP_III,
+
+        CVN_74_John_C__Stennis,
+        LHA_1_Tarawa,
+        Armed_speedboat,
+    ], "shorad": [
+        AirDefence.SAM_Avenger_M1097,
+    ], "aircraft_carrier": [
+        CVN_74_John_C__Stennis,
+    ], "helicopter_carrier": [
+        LHA_1_Tarawa,
+    ], "destroyer": [
+        USS_Arleigh_Burke_IIa,
+    ], "cruiser": [
+        Ticonderoga_class,
+    ], "carrier_names": [
+        "CVN-71 Theodore Roosevelt",
+        "CVN-72 Abraham Lincoln",
+        "CVN-73 George Washington",
+        "CVN-74 John C. Stennis",
+    ], "lhanames": [
+        "LHA-1 Tarawa",
+        "LHA-2 Saipan",
+        "LHA-3 Belleau Wood",
+        "LHA-4 Nassau",
+        "LHA-5 Peleliu"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator"
+    ], "has_jtac": True
+}

game/game.py

@@ -1,36 +1,11 @@
-import logging
-import math
-import random
-import sys
-from datetime import date, datetime, timedelta
-from typing import Any, Dict, List
+from datetime import datetime, timedelta
 
-from dcs.action import Coalition
-from dcs.mapping import Point
-from dcs.task import CAP, CAS, PinpointStrike, Task
-from dcs.unittype import UnitType
-from dcs.vehicles import AirDefence
-
-from game import db
-from game.db import PLAYER_BUDGET_BASE, REWARDS
-from game.inventory import GlobalAircraftInventory
+from game.db import REWARDS, PLAYER_BUDGET_BASE, sys
 from game.models.game_stats import GameStats
-from gen.ato import AirTaskingOrder
-from gen.conflictgen import Conflict
-from gen.flights.ai_flight_planner import CoalitionMissionPlanner
-from gen.flights.closestairfields import ObjectiveDistanceCache
+from gen.flights.ai_flight_planner import FlightPlanner
 from gen.ground_forces.ai_ground_planner import GroundPlanner
-from theater import ConflictTheater, ControlPoint
-from theater.conflicttheater import IMPORTANCE_HIGH, IMPORTANCE_LOW
-from . import persistency
-from .debriefing import Debriefing
-from .event.event import Event, UnitsDeliveryEvent
-from .event.frontlineattack import FrontlineAttackEvent
-from .factions.faction import Faction
-from .infos.information import Information
+from .event import *
 from .settings import Settings
-from plugin import LuaPluginManager
-from .weather import Conditions, TimeOfDay
 
 COMMISION_UNIT_VARIETY = 4
 COMMISION_LIMITS_SCALE = 1.5
@@ -70,45 +45,41 @@ PLAYER_BUDGET_IMPORTANCE_LOG = 2
 
 
 class Game:
-    def __init__(self, player_name: str, enemy_name: str,
-                 theater: ConflictTheater, start_date: datetime,
-                 settings: Settings):
+    settings = None  # type: Settings
+    budget = PLAYER_BUDGET_INITIAL
+    events = None  # type: typing.List[Event]
+    pending_transfers = None  # type: typing.Dict[]
+    ignored_cps = None  # type: typing.Collection[ControlPoint]
+    turn = 0
+    game_stats: GameStats = None
+
+    current_unit_id = 0
+    current_group_id = 0
+
+    def __init__(self, player_name: str, enemy_name: str, theater: ConflictTheater, start_date: datetime, settings):
         self.settings = settings
-        self.events: List[Event] = []
+        self.events = []
         self.theater = theater
         self.player_name = player_name
-        self.player_country = db.FACTIONS[player_name].country
+        self.player_country = db.FACTIONS[player_name]["country"]
         self.enemy_name = enemy_name
-        self.enemy_country = db.FACTIONS[enemy_name].country
+        self.enemy_country = db.FACTIONS[enemy_name]["country"]
         self.turn = 0
-        self.date = date(start_date.year, start_date.month, start_date.day)
+        self.date = datetime(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.planners = {}
+        self.ground_planners = {}
         self.informations = []
         self.informations.append(Information("Game Start", "-" * 40, 0))
         self.__culling_points = self.compute_conflicts_position()
-        self.__destroyed_units: List[str] = []
+        self.__frontlineData = []
+        self.__destroyed_units = []
+        self.jtacs = []
         self.savepath = ""
-        self.budget = PLAYER_BUDGET_INITIAL
-        self.current_unit_id = 0
-        self.current_group_id = 0
-
-        self.conditions = self.generate_conditions()
-
-        self.blue_ato = AirTaskingOrder()
-        self.red_ato = AirTaskingOrder()
-
-        self.aircraft_inventory = GlobalAircraftInventory(
-            self.theater.controlpoints
-        )
 
         self.sanitize_sides()
-        self.on_load()
 
-    def generate_conditions(self) -> Conditions:
-        return Conditions.generate(self.theater, self.date,
-                                   self.current_turn_time_of_day, self.settings)
 
     def sanitize_sides(self):
         """
@@ -124,11 +95,11 @@ class Game:
                 self.enemy_country = "Russia"
 
     @property
-    def player_faction(self) -> Faction:
+    def player_faction(self):
         return db.FACTIONS[self.player_name]
 
     @property
-    def enemy_faction(self) -> Faction:
+    def enemy_faction(self):
         return db.FACTIONS[self.enemy_name]
 
     def _roll(self, prob, mult):
@@ -142,12 +113,10 @@ class Game:
         self.events.append(event_class(self, player_cp, enemy_cp, enemy_cp.position, self.player_name, self.enemy_name))
 
     def _generate_events(self):
-        for front_line in self.theater.conflicts(True):
-            self._generate_player_event(FrontlineAttackEvent,
-                                        front_line.control_point_a,
-                                        front_line.control_point_b)
+        for player_cp, enemy_cp in self.theater.conflicts(True):
+            self._generate_player_event(FrontlineAttackEvent, player_cp, enemy_cp)
 
-    def commision_unit_types(self, cp: ControlPoint, for_task: Task) -> List[UnitType]:
+    def commision_unit_types(self, cp: ControlPoint, for_task: Task) -> typing.Collection[UnitType]:
         importance_factor = (cp.importance - IMPORTANCE_LOW) / (IMPORTANCE_HIGH - IMPORTANCE_LOW)
 
         if for_task == AirDefence and not self.settings.sams:
@@ -225,23 +194,11 @@ class Game:
         else:
             return event and event.name and event.name == self.player_name
 
-    def on_load(self) -> None:
-        ObjectiveDistanceCache.set_theater(self.theater)
-        
-        # set the settings in all plugins
-        for plugin in LuaPluginManager().getPlugins():
-            plugin.setSettings(self.settings)
+    def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint] = None):
 
-        # Save game compatibility.
-
-        # TODO: Remove in 2.3.
-        if not hasattr(self, "conditions"):
-            self.conditions = self.generate_conditions()
-
-    def pass_turn(self, no_action: bool = False) -> None:
         logging.info("Pass turn")
         self.informations.append(Information("End of turn #" + str(self.turn), "-" * 40, 0))
-        self.turn += 1
+        self.turn = self.turn + 1
 
         for event in self.events:
             if self.settings.version == "dev":
@@ -262,37 +219,34 @@ class Game:
                 if not cp.is_carrier and not cp.is_lha:
                     cp.base.affect_strength(-PLAYER_BASE_STRENGTH_RECOVERY)
 
-        self.conditions = self.generate_conditions()
+        self.ignored_cps = []
+        if ignored_cps:
+            self.ignored_cps = ignored_cps
 
-        self.initialize_turn()
-
-        # Autosave progress
-        persistency.autosave(self)
-
-    def initialize_turn(self) -> None:
-        self.events = []
+        self.events = []  # type: typing.List[Event]
         self._generate_events()
 
         # Update statistics
         self.game_stats.update(self)
 
-        self.aircraft_inventory.reset()
-        for cp in self.theater.controlpoints:
-            self.aircraft_inventory.set_from_control_point(cp)
-
         # Plan flights & combat for next turn
         self.__culling_points = self.compute_conflicts_position()
+        self.planners = {}
         self.ground_planners = {}
-        self.blue_ato.clear()
-        self.red_ato.clear()
-        CoalitionMissionPlanner(self, is_player=True).plan_missions()
-        CoalitionMissionPlanner(self, is_player=False).plan_missions()
         for cp in self.theater.controlpoints:
+            if cp.has_runway():
+                planner = FlightPlanner(cp, self)
+                planner.plan_flights()
+                self.planners[cp.id] = planner
+
             if cp.has_frontline:
                 gplanner = GroundPlanner(cp, self)
                 gplanner.plan_groundwar()
                 self.ground_planners[cp.id] = gplanner
 
+        # Autosave progress
+        persistency.autosave(self)
+
     def _enemy_reinforcement(self):
         """
         Compute and commision reinforcement for enemy bases
@@ -320,7 +274,7 @@ class Game:
             potential_cp_armor = self.theater.enemy_points()
 
         i = 0
-        potential_units = db.FACTIONS[self.enemy_name].frontline_units
+        potential_units = [u for u in db.FACTIONS[self.enemy_name]["units"] if u in db.UNIT_BY_TASK[PinpointStrike]]
 
         print("Enemy Recruiting")
         print(potential_cp_armor)
@@ -346,9 +300,8 @@ class Game:
         if budget_for_armored_units > 0:
             budget_for_aircraft += budget_for_armored_units
 
-        potential_units = [u for u in db.FACTIONS[self.enemy_name].aircrafts
-                           if u in db.UNIT_BY_TASK[CAS] or u in db.UNIT_BY_TASK[CAP]]
-
+        potential_units = [u for u in db.FACTIONS[self.enemy_name]["units"] if
+                           u in db.UNIT_BY_TASK[CAS] or u in db.UNIT_BY_TASK[CAP]]
         if len(potential_units) > 0 and len(potential_cp_armor) > 0:
             while budget_for_aircraft > 0:
                 i = i + 1
@@ -366,11 +319,11 @@ class Game:
                 self.informations.append(info)
 
     @property
-    def current_turn_time_of_day(self) -> TimeOfDay:
-        return list(TimeOfDay)[self.turn % 4]
+    def current_turn_daytime(self):
+        return ["dawn", "day", "dusk", "night"][self.turn % 4]
 
     @property
-    def current_day(self) -> date:
+    def current_day(self):
         return self.date + timedelta(days=self.turn // 4)
 
     def next_unit_id(self):
@@ -395,13 +348,10 @@ class Game:
         points = []
 
         # By default, use the existing frontline conflict position
-        for front_line in self.theater.conflicts():
-            position = Conflict.frontline_position(self.theater,
-                                                   front_line.control_point_a,
-                                                   front_line.control_point_b)
-            points.append(position[0])
-            points.append(front_line.control_point_a.position)
-            points.append(front_line.control_point_b.position)
+        for conflict in self.theater.conflicts():
+            points.append(Conflict.frontline_position(self.theater, conflict[0], conflict[1])[0])
+            points.append(conflict[0].position)
+            points.append(conflict[1].position)
 
         # If there is no conflict take the center point between the two nearest opposing bases
         if len(points) == 0:
@@ -450,13 +400,6 @@ class Game:
                     return False
             return True
 
-    def get_culling_points(self):
-        """
-        Check culling points
-        :return: List of culling points
-        """
-        return self.__culling_points
-
     # 1 = red, 2 = blue
     def get_player_coalition_id(self):
         return 2
@@ -465,10 +408,10 @@ class Game:
         return 1
 
     def get_player_coalition(self):
-        return Coalition.Blue
+        return dcs.action.Coalition.Blue
 
     def get_enemy_coalition(self):
-        return Coalition.Red
+        return dcs.action.Coalition.Red
 
     def get_player_color(self):
         return "blue"

game/inventory.py

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

game/models/game_stats.py

@@ -1,5 +1,3 @@
-from typing import List
-
 class FactionTurnMetadata:
     """
     Store metadata about a faction
@@ -33,8 +31,10 @@ class GameStats:
     Store statistics for the current game
     """
 
+    data_per_turn: [GameTurnMetadata] = []
+
     def __init__(self):
-        self.data_per_turn: List[GameTurnMetadata] = []
+        self.data_per_turn = []
 
     def update(self, game):
         """

game/operation/frontlineattack.py

@@ -1,8 +1,7 @@
-from dcs.terrain.terrain import Terrain
+from game.db import assigned_units_split
+
+from .operation import *
 
-from gen.conflictgen import Conflict
-from .operation import Operation
-from .. import db
 
 MAX_DISTANCE_BETWEEN_GROUPS = 12000
 

game/operation/operation.py

@@ -1,51 +1,30 @@
-import logging
-import os
-from pathlib import Path
-from typing import List, Optional, Set
+from typing import Set
 
-from dcs import Mission
-from dcs.action import DoScript, DoScriptFile
-from dcs.coalition import Coalition
+from gen import *
+from gen.airfields import AIRFIELD_DATA
+from gen.beacons import load_beacons_for_terrain
+from gen.radios import RadioRegistry
+from gen.tacan import TacanRegistry
 from dcs.countries import country_dict
 from dcs.lua.parse import loads
-from dcs.mapping import Point
 from dcs.terrain.terrain import Terrain
-from dcs.translation import String
-from dcs.triggers import TriggerStart
-from dcs.unittype import UnitType
-
-from gen import Conflict, FlightType, VisualGenerator
-from gen.aircraft import AIRCRAFT_DATA, AircraftConflictGenerator, FlightData
-from gen.airfields import AIRFIELD_DATA
-from gen.airsupportgen import AirSupport, AirSupportConflictGenerator
-from gen.armor import GroundConflictGenerator, JtacInfo
-from gen.beacons import load_beacons_for_terrain
-from gen.briefinggen import BriefingGenerator
-from gen.environmentgen import EnvironmentGenerator
-from gen.forcedoptionsgen import ForcedOptionsGenerator
-from gen.groundobjectsgen import GroundObjectsGenerator
-from gen.kneeboard import KneeboardGenerator
-from gen.radios import RadioFrequency, RadioRegistry
-from gen.tacan import TacanRegistry
-from gen.triggergen import TRIGGER_RADIUS_MEDIUM, TriggersGenerator
-from plugin import LuaPluginManager
-from theater import ControlPoint
-from .. import db
-from ..debriefing import Debriefing
+from userdata.debriefing import *
 
 
 class Operation:
     attackers_starting_position = None  # type: db.StartingPosition
     defenders_starting_position = None  # type: db.StartingPosition
 
-    current_mission = None  # type: Mission
-    regular_mission = None  # type: Mission
-    quick_mission = None  # type: Mission
+    current_mission = None  # type: dcs.Mission
+    regular_mission = None  # type: dcs.Mission
+    quick_mission = None  # type: dcs.Mission
     conflict = None  # type: Conflict
+    armorgen = None  # type: ArmorConflictGenerator
     airgen = None  # type: AircraftConflictGenerator
     triggersgen = None  # type: TriggersGenerator
     airsupportgen = None  # type: AirSupportConflictGenerator
     visualgen = None  # type: VisualGenerator
+    envgen = None  # type: EnvironmentGenerator
     groundobjectgen = None  # type: GroundObjectsGenerator
     briefinggen = None  # type: BriefingGenerator
     forcedoptionsgen = None  # type: ForcedOptionsGenerator
@@ -64,20 +43,19 @@ class Operation:
                  defender_name: str,
                  from_cp: ControlPoint,
                  departure_cp: ControlPoint,
-                 to_cp: ControlPoint):
+                 to_cp: ControlPoint = None):
         self.game = game
         self.attacker_name = attacker_name
-        self.attacker_country = db.FACTIONS[attacker_name].country
+        self.attacker_country = db.FACTIONS[attacker_name]["country"]
         self.defender_name = defender_name
-        self.defender_country = db.FACTIONS[defender_name].country
+        self.defender_country = db.FACTIONS[defender_name]["country"]
         print(self.defender_country, self.attacker_country)
         self.from_cp = from_cp
         self.departure_cp = departure_cp
         self.to_cp = to_cp
         self.is_quick = False
-        self.plugin_scripts: List[str] = []
 
-    def units_of(self, country_name: str) -> List[UnitType]:
+    def units_of(self, country_name: str) -> typing.Collection[UnitType]:
         return []
 
     def is_successfull(self, debriefing: Debriefing) -> bool:
@@ -97,7 +75,7 @@ class Operation:
         with open("resources/default_options.lua", "r") as f:
             options_dict = loads(f.read())["options"]
 
-        self.current_mission = Mission(terrain)
+        self.current_mission = dcs.Mission(terrain)
 
         print(self.game.player_country)
         print(country_dict[db.country_id_from_name(self.game.player_country)])
@@ -128,43 +106,7 @@ class Operation:
             self.defenders_starting_position = None
         else:
             self.attackers_starting_position = self.departure_cp.at
-            # TODO: Is this possible?
-            if self.to_cp is not None:
-                self.defenders_starting_position = self.to_cp.at
-            else:
-                self.defenders_starting_position = None
-
-    def inject_lua_trigger(self, contents: str, comment: str) -> None:
-        trigger = TriggerStart(comment=comment)
-        trigger.add_action(DoScript(String(contents)))
-        self.current_mission.triggerrules.triggers.append(trigger)
-
-    def bypass_plugin_script(self, mnemonic: str) -> None:
-        self.plugin_scripts.append(mnemonic)
-
-    def inject_plugin_script(self, plugin_mnemonic: str, script: str,
-                             script_mnemonic: str) -> None:
-        if script_mnemonic in self.plugin_scripts:
-            logging.debug(
-                f"Skipping already loaded {script} for {plugin_mnemonic}"
-            )
-        else:
-            self.plugin_scripts.append(script_mnemonic)
-
-            plugin_path = Path("./resources/plugins", plugin_mnemonic)
-
-            script_path = Path(plugin_path, script)
-            if not script_path.exists():
-                logging.error(
-                    f"Cannot find {script_path} for plugin {plugin_mnemonic}"
-                )
-                return
-
-            trigger = TriggerStart(comment=f"Load {script_mnemonic}")
-            filename = script_path.resolve()
-            fileref = self.current_mission.map_resource.add_resource_file(filename)
-            trigger.add_action(DoScriptFile(fileref))
-            self.current_mission.triggerrules.triggers.append(trigger)
+            self.defenders_starting_position = self.to_cp.at
 
     def generate(self):
         radio_registry = RadioRegistry()
@@ -195,9 +137,13 @@ class Operation:
         for frequency in unique_map_frequencies:
             radio_registry.reserve(frequency)
 
-        # Set mission time and weather conditions.
-        EnvironmentGenerator(self.current_mission,
-                             self.game.conditions).generate()
+        # Generate meteo
+        envgen = EnviromentGenerator(self.current_mission, self.conflict,
+                                     self.game)
+        if self.environment_settings is None:
+            self.environment_settings = envgen.generate()
+        else:
+            envgen.load(self.environment_settings)
 
         # Generate ground object first
 
@@ -239,23 +185,23 @@ class Operation:
         airgen = AircraftConflictGenerator(
             self.current_mission, self.conflict, self.game.settings, self.game,
             radio_registry)
-
-        airgen.generate_flights(
-            self.current_mission.country(self.game.player_country),
-            self.game.blue_ato,
-            groundobjectgen.runways
-        )
-        airgen.generate_flights(
-            self.current_mission.country(self.game.enemy_country),
-            self.game.red_ato,
-            groundobjectgen.runways
-        )
+        for cp in self.game.theater.controlpoints:
+            side = cp.captured
+            if side:
+                country = self.current_mission.country(self.game.player_country)
+            else:
+                country = self.current_mission.country(self.game.enemy_country)
+            if cp.id in self.game.planners.keys():
+                airgen.generate_flights(
+                    cp,
+                    country,
+                    self.game.planners[cp.id],
+                    groundobjectgen.runways
+                )
 
         # Generate ground units on frontline everywhere
         jtacs: List[JtacInfo] = []
-        for front_line in self.game.theater.conflicts(True):
-            player_cp = front_line.control_point_a
-            enemy_cp = front_line.control_point_b
+        for player_cp, enemy_cp in self.game.theater.conflicts(True):
             conflict = Conflict.frontline_cas_conflict(self.attacker_name, self.defender_name,
                                                        self.current_mission.country(self.attacker_country),
                                                        self.current_mission.country(self.defender_country),
@@ -290,179 +236,98 @@ class Operation:
         if self.game.settings.perf_smoke_gen:
             visualgen.generate()
 
-        luaData = {}
-        luaData["AircraftCarriers"] = {}
-        luaData["Tankers"] = {}
-        luaData["AWACs"] = {}
-        luaData["JTACs"] = {}
-        luaData["TargetPoints"] = {}
+        # Inject Plugins Lua Scripts
+        listOfPluginsScripts = []
+        plugin_file_path = Path("./resources/scripts/plugins/__plugins.lst")
+        if plugin_file_path.exists():
+            for line in plugin_file_path.read_text().splitlines():
+                name = line.strip()
+                if not name.startswith( '#' ):
+                    trigger = TriggerStart(comment="Load " + name)
+                    listOfPluginsScripts.append(name)
+                    fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/plugins/" + name)
+                    trigger.add_action(DoScriptFile(fileref))
+                    self.current_mission.triggerrules.triggers.append(trigger)
+        else:
+            logging.info(
+                f"Not loading plugins, {plugin_file_path} does not exist")
 
-        self.assign_channels_to_flights(airgen.flights,
-                                        airsupportgen.air_support)
+        # Inject Mist Script if not done already in the plugins
+        if not "mist.lua" in listOfPluginsScripts and not "mist_4_3_74.lua" in listOfPluginsScripts: # don't load the script twice
+            trigger = TriggerStart(comment="Load Mist Lua framework")
+            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/mist_4_3_74.lua")
+            trigger.add_action(DoScriptFile(fileref))
+            self.current_mission.triggerrules.triggers.append(trigger)
 
-        kneeboard_generator = KneeboardGenerator(self.current_mission)
-        for dynamic_runway in groundobjectgen.runways.values():
-            self.briefinggen.add_dynamic_runway(dynamic_runway)
-
-        for tanker in airsupportgen.air_support.tankers:
-            self.briefinggen.add_tanker(tanker)
-            kneeboard_generator.add_tanker(tanker)
-            luaData["Tankers"][tanker.callsign] = { 
-                "dcsGroupName": tanker.dcsGroupName,
-                "callsign": tanker.callsign,
-                "variant": tanker.variant,
-                "radio": tanker.freq.mhz,
-                "tacan": str(tanker.tacan.number) + tanker.tacan.band.name
-            }
-
-        if self.is_awacs_enabled:
-            for awacs in airsupportgen.air_support.awacs:
-                self.briefinggen.add_awacs(awacs)
-                kneeboard_generator.add_awacs(awacs)
-                luaData["AWACs"][awacs.callsign] = { 
-                    "dcsGroupName": awacs.dcsGroupName,
-                    "callsign": awacs.callsign,
-                    "radio": awacs.freq.mhz
-                }
-
-        for jtac in jtacs:
-            self.briefinggen.add_jtac(jtac)
-            kneeboard_generator.add_jtac(jtac)
-            luaData["JTACs"][jtac.callsign] = { 
-                "dcsGroupName": jtac.dcsGroupName,
-                "callsign": jtac.callsign,
-                "zone": jtac.region,
-                "dcsUnit": jtac.unit_name,
-                "laserCode": jtac.code
-            }
-
-        for flight in airgen.flights:
-            self.briefinggen.add_flight(flight)
-            kneeboard_generator.add_flight(flight)
-            if flight.friendly and flight.flight_type in [FlightType.ANTISHIP, FlightType.DEAD, FlightType.SEAD, FlightType.STRIKE]:
-                flightType = flight.flight_type.name
-                flightTarget = flight.package.target
-                if flightTarget:
-                    flightTargetName = None
-                    flightTargetType = None
-                    if hasattr(flightTarget, 'obj_name'):
-                        flightTargetName = flightTarget.obj_name
-                        flightTargetType = flightType + f" TGT ({flightTarget.category})"
-                    elif hasattr(flightTarget, 'name'):
-                        flightTargetName = flightTarget.name
-                        flightTargetType = flightType + " TGT (Airbase)"
-                    luaData["TargetPoints"][flightTargetName] = { 
-                        "name": flightTargetName,
-                        "type": flightTargetType,
-                        "position": { "x": flightTarget.position.x, "y": flightTarget.position.y}
-                    }
-                
-
-        self.briefinggen.generate()
-        kneeboard_generator.generate()
+        # Inject JSON library if not done already in the plugins
+        if not "json.lua" in listOfPluginsScripts : # don't load the script twice
+            trigger = TriggerStart(comment="Load JSON Lua library")
+            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/json.lua")
+            trigger.add_action(DoScriptFile(fileref))
+            self.current_mission.triggerrules.triggers.append(trigger)
 
+        # Inject Ciribob's JTACAutoLase if not done already in the plugins
+        if not "JTACAutoLase.lua" in listOfPluginsScripts : # don't load the script twice
+            trigger = TriggerStart(comment="Load JTACAutoLase.lua script")
+            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/JTACAutoLase.lua")
+            trigger.add_action(DoScriptFile(fileref))
+            self.current_mission.triggerrules.triggers.append(trigger)
 
         # set a LUA table with data from Liberation that we want to set
         # at the moment it contains Liberation's install path, and an overridable definition for the JTACAutoLase function
         # later, we'll add data about the units and points having been generated, in order to facilitate the configuration of the plugin lua scripts
-        state_location = "[[" + os.path.abspath(".") + "]]"
+        state_location = "[[" + os.path.abspath("state.json") + "]]"
         lua = """
--- setting configuration table
-env.info("DCSLiberation|: setting configuration table")
-
--- all data in this table is overridable.
-dcsLiberation = {}
-
--- the base location for state.json; if non-existent, it'll be replaced with LIBERATION_EXPORT_DIR, TEMP, or DCS working directory
-dcsLiberation.installPath=""" + state_location + """
-
-"""
-        # Process the tankers
-        lua += """
-
--- list the tankers generated by Liberation
-dcsLiberation.Tankers = {
-"""
-        for key in luaData["Tankers"]:
-            data = luaData["Tankers"][key]
-            dcsGroupName= data["dcsGroupName"]
-            callsign = data["callsign"]
-            variant = data["variant"]
-            tacan = data["tacan"]
-            radio = data["radio"]
-            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', variant='{variant}', tacan='{tacan}', radio='{radio}' }}, \n"
-            #lua += f"    {{name='{dcsGroupName}', description='{callsign} ({variant})', information='Tacan:{tacan} Radio:{radio}' }}, \n"
-        lua += "}"
-
-        # Process the AWACSes
-        lua += """
-
--- list the AWACs generated by Liberation
-dcsLiberation.AWACs = {
-"""
-        for key in luaData["AWACs"]:
-            data = luaData["AWACs"][key]
-            dcsGroupName= data["dcsGroupName"]
-            callsign = data["callsign"]
-            radio = data["radio"]
-            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', radio='{radio}' }}, \n"
-            #lua += f"    {{name='{dcsGroupName}', description='{callsign} (AWACS)', information='Radio:{radio}' }}, \n"
-        lua += "}"
-
-        # Process the JTACs
-        lua += """
-
--- list the JTACs generated by Liberation
-dcsLiberation.JTACs = {
-"""
-        for key in luaData["JTACs"]:
-            data = luaData["JTACs"][key]
-            dcsGroupName= data["dcsGroupName"]
-            callsign = data["callsign"]
-            zone = data["zone"]
-            laserCode = data["laserCode"]
-            dcsUnit = data["dcsUnit"]
-            lua += f"    {{dcsGroupName='{dcsGroupName}', callsign='{callsign}', zone='{zone}', laserCode='{laserCode}', dcsUnit='{dcsUnit}' }}, \n"
-            #lua += f"    {{name='{dcsGroupName}', description='JTAC {callsign} ', information='Laser:{laserCode}', jtac={laserCode} }}, \n"
-        lua += "}"
-
-        # Process the Target Points
-        lua += """
-
--- list the target points generated by Liberation
-dcsLiberation.TargetPoints = {
-"""
-        for key in luaData["TargetPoints"]:
-            data = luaData["TargetPoints"][key]
-            name = data["name"]
-            pointType = data["type"]
-            positionX = data["position"]["x"]
-            positionY = data["position"]["y"]
-            lua += f"    {{name='{name}', pointType='{pointType}', positionX='{positionX}', positionY='{positionY}' }}, \n"
-            #lua += f"    {{name='{pointType} {name}', point{{x={positionX}, z={positionY} }} }}, \n"
-        lua += "}"
-
-        lua += """
-
--- list the airbases generated by Liberation
--- dcsLiberation.Airbases = {}
-
--- list the aircraft carriers generated by Liberation
--- dcsLiberation.Carriers = {}
-
--- later, we'll add more data to the table
-
-"""
-
+        -- setting configuration table
+        env.info("DCSLiberation|: setting configuration table")
+        
+        -- all data in this table is overridable.
+        dcsLiberation = {}
+        
+        -- the base location for state.json; if non-existent, it'll be replaced with LIBERATION_EXPORT_DIR, TEMP, or DCS working directory
+        dcsLiberation.installPath=""" + state_location + """
+        
+        -- you can override dcsLiberation.JTACAutoLase to make it use your own function ; it will be called with these parameters : ({jtac.unit_name}, {jtac.code}, {smoke}, 'vehicle') for all JTACs
+        if ctld then
+            dcsLiberation.JTACAutoLase=ctld.JTACAutoLase
+        elseif JTACAutoLase then
+            dcsLiberation.JTACAutoLase=JTACAutoLase
+        end
+        
+        -- later, we'll add more data to the table
+        --dcsLiberation.POIs = {}
+        --dcsLiberation.BASEs = {}
+        --dcsLiberation.JTACs = {}
+        """
 
         trigger = TriggerStart(comment="Set DCS Liberation data")
         trigger.add_action(DoScript(String(lua)))
         self.current_mission.triggerrules.triggers.append(trigger)
 
-        # Inject Plugins Lua Scripts and data
-        for plugin in LuaPluginManager().getPlugins():
-            plugin.injectScripts(self)
-            plugin.injectConfiguration(self)
+        # Inject DCS-Liberation script if not done already in the plugins
+        if not "dcs_liberation.lua" in listOfPluginsScripts : # don't load the script twice
+            trigger = TriggerStart(comment="Load DCS Liberation script")
+            fileref = self.current_mission.map_resource.add_resource_file("./resources/scripts/dcs_liberation.lua")
+            trigger.add_action(DoScriptFile(fileref))
+            self.current_mission.triggerrules.triggers.append(trigger)
+
+        # add a configuration for JTACAutoLase and start lasing for all JTACs
+        smoke = "true"
+        if hasattr(self.game.settings, "jtac_smoke_on"):
+            if not self.game.settings.jtac_smoke_on:
+                smoke = "false"
+
+        lua = """
+        -- setting and starting JTACs
+        env.info("DCSLiberation|: setting and starting JTACs")
+        """
+
+        for jtac in jtacs:
+            lua += f"if dcsLiberation.JTACAutoLase then dcsLiberation.JTACAutoLase('{jtac.unit_name}', {jtac.code}, {smoke}, 'vehicle') end\n"
+
+        trigger = TriggerStart(comment="Start JTACs")
+        trigger.add_action(DoScript(String(lua)))
+        self.current_mission.triggerrules.triggers.append(trigger)
 
         self.assign_channels_to_flights(airgen.flights,
                                         airsupportgen.air_support)
@@ -511,7 +376,6 @@ dcsLiberation.TargetPoints = {
             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
-            )
+        aircraft_data.channel_allocator.assign_channels_for_flight(
+            flight, air_support
+        )

game/settings.py

@@ -1,4 +1,3 @@
-from plugin import LuaPluginManager
 
 class Settings:
 
@@ -25,6 +24,8 @@ class Settings:
         self.sams = True # Legacy parameter do not use
         self.cold_start = False # Legacy parameter do not use
         self.version = None
+        self.include_jtac_if_available = True
+        self.jtac_smoke_on = True
 
         # Performance oriented
         self.perf_red_alert_state = True
@@ -39,21 +40,4 @@ class Settings:
         self.perf_culling = False
         self.perf_culling_distance = 100
 
-        # LUA Plugins system
-        self.plugins = {}
-        for plugin in LuaPluginManager().getPlugins():
-            plugin.setSettings(self)
 
-
-        # Cheating
-        self.show_red_ato = False
-
-    def __setstate__(self, state) -> None:
-        # __setstate__ is called with the dict of the object being unpickled. We
-        # can provide save compatibility for new settings options (which
-        # normally would not be present in the unpickled object) by creating a
-        # new settings object, updating it with the unpickled state, and
-        # updating our dict with that.
-        new_state = Settings().__dict__
-        new_state.update(state)
-        self.__dict__.update(new_state)

game/utils.py

@@ -1,14 +1,14 @@
-def meter_to_feet(value_in_meter: float) -> int:
+def meter_to_feet(value_in_meter):
     return int(3.28084 * value_in_meter)
 
 
-def feet_to_meter(value_in_feet: float) -> int:
-    return int(value_in_feet / 3.28084)
+def feet_to_meter(value_in_feet):
+    return int(float(value_in_feet)/3.048)
 
 
-def meter_to_nm(value_in_meter: float) -> int:
-    return int(value_in_meter / 1852)
+def meter_to_nm(value_in_meter):
+    return int(float(value_in_meter)*0.000539957)
 
 
-def nm_to_meter(value_in_nm: float) -> int:
-    return int(value_in_nm * 1852)
+def nm_to_meter(value_in_nm):
+    return int(float(value_in_nm)*1852)

game/version.py

@@ -1,2 +0,0 @@
-#: Current version of Liberation.
-VERSION = "2.2.0-preview"

game/weather.py

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

gen/__init__.py

@@ -1,3 +1,4 @@
+from .aaa import *
 from .aircraft import *
 from .armor import *
 from .airsupportgen import *
@@ -11,3 +12,4 @@ from .forcedoptionsgen import *
 from .kneeboard import *
 
 from . import naming
+

gen/aaa.py

@@ -0,0 +1,51 @@
+from .conflictgen import *
+from .naming import *
+
+from dcs.mission import *
+from dcs.mission import *
+
+from .conflictgen import *
+from .naming import *
+
+DISTANCE_FACTOR = 0.5, 1
+EXTRA_AA_MIN_DISTANCE = 50000
+EXTRA_AA_MAX_DISTANCE = 150000
+EXTRA_AA_POSITION_FROM_CP = 550
+
+class ExtraAAConflictGenerator:
+    def __init__(self, mission: Mission, conflict: Conflict, game, player_country: Country, enemy_country: Country):
+        self.mission = mission
+        self.game = game
+        self.conflict = conflict
+        self.player_country = player_country
+        self.enemy_country = enemy_country
+
+    def generate(self):
+
+        for cp in self.game.theater.controlpoints:
+            if cp.is_global:
+                continue
+
+            if cp.position.distance_to_point(self.conflict.position) < EXTRA_AA_MIN_DISTANCE:
+                continue
+
+            if cp.position.distance_to_point(self.conflict.from_cp.position) < EXTRA_AA_MIN_DISTANCE:
+                continue
+
+            if cp.position.distance_to_point(self.conflict.to_cp.position) < EXTRA_AA_MIN_DISTANCE:
+                continue
+
+            if cp.position.distance_to_point(self.conflict.position) > EXTRA_AA_MAX_DISTANCE:
+                continue
+
+            country_name = cp.captured and self.player_country or self.enemy_country
+            position = cp.position.point_from_heading(0, EXTRA_AA_POSITION_FROM_CP)
+
+            self.mission.vehicle_group(
+                country=self.mission.country(country_name),
+                name=namegen.next_basedefense_name(),
+                _type=db.EXTRA_AA[country_name],
+                position=position,
+                group_size=1
+            )
+

gen/airfields.py

@@ -3,11 +3,11 @@
 Remove once https://github.com/pydcs/dcs/issues/69 tracks getting the missing
 data added to pydcs. Until then, missing data can be manually filled in here.
 """
-from __future__ import annotations
-
 from dataclasses import dataclass, field
-from typing import Dict, Optional, Tuple
+import logging
+from typing import Dict, Iterator, Optional, Tuple
 
+from dcs.terrain.terrain import Airport
 from .radios import MHz, RadioFrequency
 from .tacan import TacanBand, TacanChannel
 
@@ -195,12 +195,10 @@ AIRFIELD_DATA = {
         runway_length=8623,
         atc=AtcData(MHz(3, 750), MHz(121, 0), MHz(38, 400), MHz(250, 0)),
         outer_ndb={
-            "22": ("AP", MHz(443, 0)),
-            "04": ("AN", MHz(443)),
+            "22": ("AP", MHz(443, 0)), "4": "443.00 (AN)"
         },
         inner_ndb={
-            "22": ("P", MHz(215, 0)),
-            "04": ("N", MHz(215)),
+            "22": ("P", MHz(215, 0)), "4": "215.00 (N)"
         },
     ),
 
@@ -1503,3 +1501,61 @@ AIRFIELD_DATA = {
         atc=AtcData(MHz(3, 775), MHz(118, 50), MHz(38, 450), MHz(250, 50)),
     ),
 }
+
+
+@dataclass(frozen=True)
+class RunwayData:
+    airfield_name: str
+    runway_name: str
+    atc: Optional[RadioFrequency] = None
+    tacan: Optional[TacanChannel] = None
+    tacan_callsign: Optional[str] = None
+    ils: Optional[RadioFrequency] = None
+    icls: Optional[int] = None
+
+    @classmethod
+    def for_airfield(cls, airport: Airport, runway: str) -> "RunwayData":
+        """Creates RunwayData for the given runway of an airfield.
+
+        Args:
+            airport: The airfield the runway belongs to.
+            runway: Identifier of the runway to use. e.g. "03" or "20L".
+        """
+        atc: Optional[RadioFrequency] = None
+        tacan: Optional[TacanChannel] = None
+        tacan_callsign: Optional[str] = None
+        ils: Optional[RadioFrequency] = None
+        try:
+            airfield = AIRFIELD_DATA[airport.name]
+            if airfield.atc is not None:
+                atc = airfield.atc.uhf
+            else:
+                atc = None
+            tacan = airfield.tacan
+            tacan_callsign = airfield.tacan_callsign
+            ils = airfield.ils_freq(runway)
+        except KeyError:
+            logging.warning(f"No airfield data for {airport.name}")
+        return cls(
+            airfield_name=airport.name,
+            runway_name=runway,
+            atc=atc,
+            tacan=tacan,
+            tacan_callsign=tacan_callsign,
+            ils=ils
+        )
+
+    @classmethod
+    def for_pydcs_airport(cls, airport: Airport) -> Iterator["RunwayData"]:
+        for runway in airport.runways:
+            runway_number = runway.heading // 10
+            runway_side = ["", "L", "R"][runway.leftright]
+            runway_name = f"{runway_number:02}{runway_side}"
+            yield cls.for_airfield(airport, runway_name)
+
+            # pydcs only exposes one runway per physical runway, so to expose
+            # both sides of the runway we need to generate the other.
+            runway_number = ((runway.heading + 180) % 360) // 10
+            runway_side = ["", "R", "L"][runway.leftright]
+            runway_name = f"{runway_number:02}{runway_side}"
+            yield cls.for_airfield(airport, runway_name)

gen/airsupportgen.py

@@ -1,21 +1,8 @@
 from dataclasses import dataclass, field
-from typing import List, Type
 
-from dcs.mission import Mission, StartType
-from dcs.planes import IL_78M
-from dcs.task import (
-    AWACS,
-    ActivateBeaconCommand,
-    MainTask,
-    Refueling,
-    SetImmortalCommand,
-    SetInvisibleCommand,
-)
-
-from game import db
-from .naming import namegen
 from .callsigns import callsign_for_support_unit
-from .conflictgen import Conflict
+from .conflictgen import *
+from .naming import *
 from .radios import RadioFrequency, RadioRegistry
 from .tacan import TacanBand, TacanChannel, TacanRegistry
 
@@ -30,7 +17,6 @@ AWACS_ALT = 13000
 @dataclass
 class AwacsInfo:
     """AWACS information for the kneeboard."""
-    dcsGroupName: str
     callsign: str
     freq: RadioFrequency
 
@@ -38,7 +24,6 @@ class AwacsInfo:
 @dataclass
 class TankerInfo:
     """Tanker information for the kneeboard."""
-    dcsGroupName: str
     callsign: str
     variant: str
     freq: RadioFrequency
@@ -64,7 +49,7 @@ class AirSupportConflictGenerator:
         self.tacan_registry = tacan_registry
 
     @classmethod
-    def support_tasks(cls) -> List[Type[MainTask]]:
+    def support_tasks(cls) -> typing.Collection[typing.Type[MainTask]]:
         return [Refueling, AWACS]
 
     def generate(self, is_awacs_enabled):
@@ -91,7 +76,6 @@ class AirSupportConflictGenerator:
                 speed=574,
                 tacanchannel=str(tacan),
             )
-            tanker_group.set_frequency(freq.mhz)
 
             callsign = callsign_for_support_unit(tanker_group)
             tacan_callsign = {
@@ -118,7 +102,7 @@ class AirSupportConflictGenerator:
             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))
+            self.air_support.tankers.append(TankerInfo(callsign, variant, freq, tacan))
 
         if is_awacs_enabled:
             try:
@@ -134,12 +118,10 @@ class AirSupportConflictGenerator:
                     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(
-                    str(awacs_flight.name), callsign_for_support_unit(awacs_flight), freq))
+                    callsign_for_support_unit(awacs_flight), freq))
             except:
                 print("No AWACS for faction")

gen/armor.py

@@ -1,40 +1,13 @@
-import logging
-import random
 from dataclasses import dataclass
-from typing import List
 
-from dcs import Mission
 from dcs.action import AITaskPush
-from dcs.condition import GroupLifeLess, Or, TimeAfter, UnitDamaged
-from dcs.country import Country
-from dcs.mapping import Point
-from dcs.planes import MQ_9_Reaper
-from dcs.point import PointAction
-from dcs.task import (
-    AttackGroup,
-    ControlledTask,
-    EPLRS,
-    FireAtPoint,
-    GoToWaypoint,
-    Hold,
-    OrbitAction,
-    SetImmortalCommand,
-    SetInvisibleCommand,
-)
-from dcs.triggers import Event, TriggerOnce
-from dcs.unit import Vehicle
-from dcs.unittype import VehicleType
+from dcs.condition import TimeAfter, UnitDamaged, Or, GroupLifeLess
+from dcs.triggers import TriggerOnce, Event
 
-from game import db
-from .naming import namegen
-from gen.ground_forces.ai_ground_planner import (
-    CombatGroupRole,
-    DISTANCE_FROM_FRONTLINE,
-)
+from gen import namegen
+from gen.ground_forces.ai_ground_planner import CombatGroupRole, DISTANCE_FROM_FRONTLINE
 from .callsigns import callsign_for_support_unit
-from .conflictgen import Conflict
-from .ground_forces.combat_stance import CombatStance
-from plugin import LuaPluginManager
+from .conflictgen import *
 
 SPREAD_DISTANCE_FACTOR = 0.1, 0.3
 SPREAD_DISTANCE_SIZE_FACTOR = 0.1
@@ -55,7 +28,6 @@ RANDOM_OFFSET_ATTACK = 250
 @dataclass(frozen=True)
 class JtacInfo:
     """JTAC information."""
-    dcsGroupName: str
     unit_name: str
     callsign: str
     region: str
@@ -76,7 +48,7 @@ class GroundConflictGenerator:
         self.jtacs: List[JtacInfo] = []
 
     def _group_point(self, point) -> Point:
-        distance = random.randint(
+        distance = randint(
                 int(self.conflict.size * SPREAD_DISTANCE_FACTOR[0]),
                 int(self.conflict.size * SPREAD_DISTANCE_FACTOR[1]),
                 )
@@ -140,15 +112,13 @@ class GroundConflictGenerator:
         self.plan_action_for_groups(self.enemy_stance, enemy_groups, player_groups, self.conflict.heading - 90, self.conflict.to_cp, self.conflict.from_cp)
 
         # Add JTAC
-        jtacPlugin = LuaPluginManager().getPlugin("jtacautolase")
-        useJTAC = jtacPlugin and jtacPlugin.isEnabled()
-        if self.game.player_faction.has_jtac and useJTAC:
+        if "has_jtac" in self.game.player_faction and self.game.player_faction["has_jtac"] and self.game.settings.include_jtac_if_available:
             n = "JTAC" + str(self.conflict.from_cp.id) + str(self.conflict.to_cp.id)
             code = 1688 - len(self.jtacs)
 
             utype = MQ_9_Reaper
-            if self.game.player_faction.jtac_unit is not None:
-                utype = self.game.player_faction.jtac_unit
+            if "jtac_unit" in self.game.player_faction:
+                utype = self.game.player_faction["jtac_unit"]
 
             jtac = self.mission.flight_group(country=self.mission.country(self.game.player_country),
                                              name=n,
@@ -162,7 +132,7 @@ class GroundConflictGenerator:
             frontline = f"Frontline {self.conflict.from_cp.name}/{self.conflict.to_cp.name}"
             # Note: Will need to change if we ever add ground based JTAC.
             callsign = callsign_for_support_unit(jtac)
-            self.jtacs.append(JtacInfo(str(jtac.name), n, callsign, frontline, str(code)))
+            self.jtacs.append(JtacInfo(n, callsign, frontline, str(code)))
 
     def gen_infantry_group_for_group(self, group, is_player, side:Country, forward_heading):
 
@@ -195,7 +165,7 @@ class GroundConflictGenerator:
                 heading=forward_heading,
                 move_formation=PointAction.OffRoad)
 
-        for i in range(random.randint(3, 10)):
+        for i in range(randint(3, 10)):
             u = random.choice(possible_infantry_units)
             position = infantry_position.random_point_within(55, 5)
             self.mission.vehicle_group(

gen/ato.py

@@ -1,144 +0,0 @@
-"""Air Tasking Orders.
-
-The classes of the Air Tasking Order (ATO) define all of the missions that have
-been planned, and which aircraft have been assigned to them. Each planned
-mission, or "package" is composed of individual flights. The package may contain
-dissimilar aircraft performing different roles, but all for the same goal. For
-example, the package to strike an enemy airfield may contain an escort flight,
-a SEAD flight, and the strike aircraft themselves. CAP packages may contain only
-the single CAP flight.
-"""
-import logging
-from collections import defaultdict
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional
-
-from dcs.mapping import Point
-
-from theater.missiontarget import MissionTarget
-from .flights.flight import Flight, FlightType
-
-
-@dataclass(frozen=True)
-class Task:
-    """The main task of a flight or package."""
-
-    #: The type of task.
-    task_type: FlightType
-
-    #: The location of the objective.
-    location: str
-
-
-@dataclass(frozen=True)
-class PackageWaypoints:
-    join: Point
-    ingress: Point
-    egress: Point
-    split: Point
-
-
-@dataclass
-class Package:
-    """A mission package."""
-
-    #: The mission target. Currently can be either a ControlPoint or a
-    #: TheaterGroundObject (non-ControlPoint map objectives).
-    target: MissionTarget
-
-    #: The set of flights in the package.
-    flights: List[Flight] = field(default_factory=list)
-
-    delay: int = field(default=0)
-
-    #: Desired TOT measured in seconds from mission start.
-    time_over_target: int = field(default=0)
-
-    waypoints: Optional[PackageWaypoints] = field(default=None)
-
-    def add_flight(self, flight: Flight) -> None:
-        """Adds a flight to the package."""
-        self.flights.append(flight)
-
-    def remove_flight(self, flight: Flight) -> None:
-        """Removes a flight from the package."""
-        self.flights.remove(flight)
-        if not self.flights:
-            self.waypoints = None
-
-    @property
-    def primary_task(self) -> Optional[FlightType]:
-        if not self.flights:
-            return None
-
-        flight_counts: Dict[FlightType, int] = defaultdict(lambda: 0)
-        for flight in self.flights:
-            flight_counts[flight.flight_type] += 1
-
-        # The package will contain a mix of mission types, but in general we can
-        # determine the goal of the mission because some mission types are more
-        # likely to be the main task than others. For example, a package with
-        # only CAP flights is a CAP package, a flight with CAP and strike is a
-        # strike package, a flight with CAP and DEAD is a DEAD package, and a
-        # flight with strike and SEAD is an OCA/Strike package. The type of
-        # package is determined by the highest priority flight in the package.
-        task_priorities = [
-            FlightType.CAS,
-            FlightType.STRIKE,
-            FlightType.ANTISHIP,
-            FlightType.BAI,
-            FlightType.EVAC,
-            FlightType.TROOP_TRANSPORT,
-            FlightType.RECON,
-            FlightType.ELINT,
-            FlightType.DEAD,
-            FlightType.SEAD,
-            FlightType.LOGISTICS,
-            FlightType.INTERCEPTION,
-            FlightType.TARCAP,
-            FlightType.CAP,
-            FlightType.BARCAP,
-            FlightType.EWAR,
-            FlightType.ESCORT,
-        ]
-        for task in task_priorities:
-            if flight_counts[task]:
-                return task
-
-        # If we get here, our task_priorities list above is incomplete. Log the
-        # issue and return the type of *any* flight in the package.
-        some_mission = next(iter(self.flights)).flight_type
-        logging.warning(f"Unhandled mission type: {some_mission}")
-        return some_mission
-
-    @property
-    def package_description(self) -> str:
-        """Generates a package description based on flight composition."""
-        task = self.primary_task
-        if task is None:
-            return "No mission"
-        return task.name
-
-    def __hash__(self) -> int:
-        # TODO: Far from perfect. Number packages?
-        return hash(self.target.name)
-
-
-@dataclass
-class AirTaskingOrder:
-    """The entire ATO for one coalition."""
-
-    #: The set of all planned packages in the ATO.
-    packages: List[Package] = field(default_factory=list)
-
-    def add_package(self, package: Package) -> None:
-        """Adds a package to the ATO."""
-        self.packages.append(package)
-
-    def remove_package(self, package: Package) -> None:
-        """Removes a package from the ATO."""
-        self.packages.remove(package)
-
-    def clear(self) -> None:
-        """Removes all packages from the ATO."""
-        self.packages.clear()

gen/briefinggen.py

@@ -1,20 +1,18 @@
-import datetime
 import os
-import random
 from collections import defaultdict
 from dataclasses import dataclass
+import random
 from typing import List
 
-from dcs.mission import Mission
-
 from game import db
+from dcs.mission import Mission
 from .aircraft import FlightData
+from .airfields import RunwayData
 from .airsupportgen import AwacsInfo, TankerInfo
 from .armor import JtacInfo
 from .conflictgen import Conflict
 from .ground_forces.combat_stance import CombatStance
 from .radios import RadioFrequency
-from .runways import RunwayData
 
 
 @dataclass
@@ -108,7 +106,7 @@ class BriefingGenerator(MissionInfoGenerator):
         aircraft = flight.aircraft_type
         flight_unit_name = db.unit_type_name(aircraft)
         self.description += "-" * 50 + "\n"
-        self.description += f"{flight_unit_name} x {flight.size}\n\n"
+        self.description += f"{flight_unit_name} x {flight.size + 2}\n\n"
 
         for i, wpt in enumerate(flight.waypoints):
             self.description += f"#{i + 1} -- {wpt.name} : {wpt.description}\n"
@@ -118,10 +116,9 @@ class BriefingGenerator(MissionInfoGenerator):
         assert not flight.client_units
         aircraft = flight.aircraft_type
         flight_unit_name = db.unit_type_name(aircraft)
-        delay = datetime.timedelta(seconds=flight.departure_delay)
         self.description += (
             f"{flight.flight_type.name} {flight_unit_name} x {flight.size}, "
-            f"departing in {delay}\n"
+            f"departing in {flight.departure_delay} minutes\n"
         )
 
     def generate(self):
@@ -130,11 +127,6 @@ class BriefingGenerator(MissionInfoGenerator):
         self.description += "DCS Liberation turn #" + str(self.game.turn) + "\n"
         self.description += "=" * 15 + "\n\n"
 
-        self.description += (
-            "Most briefing information, including communications and flight "
-            "plan information, can be found on your kneeboard.\n\n"
-        )
-
         self.generate_ongoing_war_text()
 
         self.description += "\n"*2
@@ -194,10 +186,14 @@ class BriefingGenerator(MissionInfoGenerator):
 
         conflict_number = 0
 
-        for front_line in self.game.theater.conflicts(from_player=True):
+        for c in self.game.theater.conflicts():
             conflict_number = conflict_number + 1
-            player_base = front_line.control_point_a
-            enemy_base = front_line.control_point_b
+            if c[0].captured:
+                player_base = c[0]
+                enemy_base = c[1]
+            else:
+                player_base = c[1]
+                enemy_base = c[0]
 
             has_numerical_superiority = player_base.base.total_armor > enemy_base.base.total_armor
             self.description += self.__random_frontline_sentence(player_base.name, enemy_base.name)
@@ -213,23 +209,23 @@ class BriefingGenerator(MissionInfoGenerator):
                     if has_numerical_superiority:
                         self.description += "On this location, our ground forces will try to make progress against the enemy"
                         self.description += ". As the enemy is outnumbered, our forces should have no issue making progress.\n"
-                    else:
+                    elif has_numerical_superiority:
                         self.description += "On this location, our ground forces will try an audacious assault against enemies in superior numbers. The operation is risky, and the enemy might counter attack.\n"
                 elif stance == CombatStance.ELIMINATION:
                     if has_numerical_superiority:
                         self.description += "On this location, our ground forces will focus on the destruction of enemy assets, before attempting to make progress toward " + enemy_base.name + ". "
                         self.description += "The enemy is already outnumbered, and this maneuver might draw a final blow to their forces.\n"
-                    else:
+                    elif has_numerical_superiority:
                         self.description += "On this location, our ground forces will try an audacious assault against enemies in superior numbers. The operation is risky, and the enemy might counter attack.\n"
                 elif stance == CombatStance.BREAKTHROUGH:
                     if has_numerical_superiority:
                         self.description += "On this location, our ground forces will focus on progression toward " + enemy_base.name + ".\n"
-                    else:
+                    elif has_numerical_superiority:
                         self.description += "On this location, our ground forces have been ordered to rush toward " + enemy_base.name + ". Wish them luck... We are also expecting a counter attack.\n"
                 elif stance in [CombatStance.DEFENSIVE, CombatStance.AMBUSH]:
                     if has_numerical_superiority:
                         self.description += "On this location, our ground forces will hold position. We are not expecting an enemy assault.\n"
-                    else:
+                    elif has_numerical_superiority:
                         self.description += "On this location, our ground forces have been ordered to hold still, and defend against enemy attacks. An enemy assault might be iminent.\n"
 
         if conflict_number == 0:

gen/conflictgen.py

@@ -1,11 +1,21 @@
 import logging
-import random
-from typing import Tuple
+import typing
+import pdb
+import dcs
 
-from dcs.country import Country
-from dcs.mapping import Point
+from random import randint
+from dcs import Mission
 
-from theater import ConflictTheater, ControlPoint
+from dcs.mission import *
+from dcs.vehicles import *
+from dcs.unitgroup import *
+from dcs.unittype import *
+from dcs.mapping import *
+from dcs.point import *
+from dcs.task import *
+from dcs.country import *
+
+from theater import *
 
 AIR_DISTANCE = 40000
 
@@ -55,6 +65,24 @@ def _heading_sum(h, a) -> int:
 
 
 class Conflict:
+    attackers_side = None  # type: str
+    defenders_side = None  # type: str
+    attackers_country = None  # type: Country
+    defenders_country = None  # type: Country
+    from_cp = None  # type: ControlPoint
+    to_cp = None  # type: ControlPoint
+    position = None  # type: Point
+    size = None  # type: int
+    radials = None  # type: typing.List[int]
+
+    heading = None  # type: int
+    distance = None  # type: int
+
+    ground_attackers_location = None  # type: Point
+    ground_defenders_location = None  # type: Point
+    air_attackers_location = None  # type: Point
+    air_defenders_location = None  # type: Point
+
     def __init__(self,
                  theater: ConflictTheater,
                  from_cp: ControlPoint,
@@ -127,7 +155,7 @@ class Conflict:
         else:
             return self.position
 
-    def find_ground_position(self, at: Point, heading: int, max_distance: int = 40000) -> Point:
+    def find_ground_position(self, at: Point, heading: int, max_distance: int = 40000) -> typing.Optional[Point]:
         return Conflict._find_ground_position(at, max_distance, heading, self.theater)
 
     @classmethod
@@ -135,7 +163,7 @@ class Conflict:
         return from_cp.has_frontline and to_cp.has_frontline
 
     @classmethod
-    def frontline_position(cls, theater: ConflictTheater, from_cp: ControlPoint, to_cp: ControlPoint) -> Tuple[Point, int]:
+    def frontline_position(cls, theater: ConflictTheater, from_cp: ControlPoint, to_cp: ControlPoint) -> typing.Optional[typing.Tuple[Point, int]]:
         attack_heading = from_cp.position.heading_between_point(to_cp.position)
         attack_distance = from_cp.position.distance_to_point(to_cp.position)
         middle_point = from_cp.position.point_from_heading(attack_heading, attack_distance / 2)
@@ -146,7 +174,9 @@ class Conflict:
 
 
     @classmethod
-    def frontline_vector(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> Tuple[Point, int, int]:
+    def frontline_vector(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> typing.Optional[typing.Tuple[Point, int, int]]:
+        initial, heading = cls.frontline_position(theater, from_cp, to_cp)
+
         """
         probe_end_point = initial.point_from_heading(heading, FRONTLINE_LENGTH)
         probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y) ])
@@ -163,6 +193,9 @@ class Conflict:
         return Point(*intersection.xy[0]), _heading_sum(heading, 90), intersection.length
         """
         frontline = cls.frontline_position(theater, from_cp, to_cp)
+        if not frontline:
+            return None
+
         center_position, heading = frontline
         left_position, right_position = None, None
 
@@ -210,7 +243,7 @@ class Conflict:
         """
 
     @classmethod
-    def _find_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> Point:
+    def _find_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> typing.Optional[Point]:
         pos = initial
         for _ in range(0, int(max_distance), 500):
             if theater.is_on_land(pos):
@@ -269,14 +302,10 @@ class Conflict:
 
         distance = to_cp.size * GROUND_DISTANCE_FACTOR
         attackers_location = position.point_from_heading(attack_heading, distance)
-        attackers_location = Conflict._find_ground_position(
-            attackers_location, int(distance * 2),
-            _heading_sum(attack_heading, 180), theater)
+        attackers_location = Conflict._find_ground_position(attackers_location, distance * 2, _heading_sum(attack_heading, 180), theater)
 
         defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_position(
-            defenders_location, int(distance * 2),
-            _heading_sum(defense_heading, 180), theater)
+        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
 
         return cls(
             position=position,
@@ -400,7 +429,7 @@ class Conflict:
         assert cls.has_frontline_between(from_cp, to_cp)
 
         position, heading, distance = cls.frontline_vector(from_cp, to_cp, theater)
-        attack_position = position.point_from_heading(heading, random.randint(0, int(distance)))
+        attack_position = position.point_from_heading(heading, randint(0, int(distance)))
         attackers_position = attack_position.point_from_heading(heading - 90, AIR_DISTANCE)
         defenders_position = attack_position.point_from_heading(heading + 90, random.randint(*CAP_CAS_DISTANCE))
 
@@ -427,9 +456,7 @@ class Conflict:
 
         distance = to_cp.size * GROUND_DISTANCE_FACTOR
         defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_position(
-            defenders_location, int(distance * 2),
-            _heading_sum(defense_heading, 180), theater)
+        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
 
         return cls(
             position=position,

gen/defenses/armor_group_generator.py

@@ -11,7 +11,8 @@ def generate_armor_group(faction:str, game, ground_object):
     This generate a group of ground units
     :return: Generated group
     """
-    possible_unit = [u for u in db.FACTIONS[faction].frontline_units if u in Armor.__dict__.values()]
+
+    possible_unit = [u for u in db.FACTIONS[faction]["units"] if u in Armor.__dict__.values()]
     if len(possible_unit) > 0:
         unit_type = random.choice(possible_unit)
         return generate_armor_group_of_type(game, ground_object, unit_type)

gen/environmentgen.py

@@ -1,36 +1,156 @@
-from typing import Optional
+import logging
+import typing
+import random
+from datetime import datetime, timedelta, time
 
 from dcs.mission import Mission
+from dcs.triggers import *
+from dcs.condition import *
+from dcs.action import *
+from dcs.unit import Skill
+from dcs.point import MovingPoint, PointProperties
+from dcs.action import *
+from dcs.weather import *
 
-from game.weather import Clouds, Fog, Conditions, WindConditions
+from game import db
+from theater import *
+from gen import *
+
+WEATHER_CLOUD_BASE = 2000, 3000
+WEATHER_CLOUD_DENSITY = 1, 8
+WEATHER_CLOUD_THICKNESS = 100, 400
+WEATHER_CLOUD_BASE_MIN = 1600
+
+WEATHER_FOG_CHANCE = 20
+WEATHER_FOG_VISIBILITY = 2500, 5000
+WEATHER_FOG_THICKNESS = 100, 500
+
+RANDOM_TIME = {
+    "night": 7,
+    "dusk": 40,
+    "dawn": 40,
+    "day": 100,
+}
+
+RANDOM_WEATHER = {
+    1: 0,  # thunderstorm
+    2: 20,  # rain
+    3: 80,  # clouds
+    4: 100,  # clear
+}
 
 
-class EnvironmentGenerator:
-    def __init__(self, mission: Mission, conditions: Conditions) -> None:
+class EnvironmentSettings:
+    weather_dict = None
+    start_time = None
+
+
+class EnviromentGenerator:
+    def __init__(self, mission: Mission, conflict: Conflict, game):
         self.mission = mission
-        self.conditions = conditions
+        self.conflict = conflict
+        self.game = game
 
-    def set_clouds(self, clouds: Optional[Clouds]) -> None:
-        if clouds is None:
-            return
-        self.mission.weather.clouds_base = clouds.base
-        self.mission.weather.clouds_thickness = clouds.thickness
-        self.mission.weather.clouds_density = clouds.density
-        self.mission.weather.clouds_iprecptns = clouds.precipitation
+    def _gen_time(self):
 
-    def set_fog(self, fog: Optional[Fog]) -> None:
-        if fog is None:
-            return
-        self.mission.weather.fog_visibility = fog.visibility
-        self.mission.weather.fog_thickness = fog.thickness
+        start_time = self.game.current_day
 
-    def set_wind(self, wind: WindConditions) -> None:
-        self.mission.weather.wind_at_ground = wind.at_0m
-        self.mission.weather.wind_at_2000 = wind.at_2000m
-        self.mission.weather.wind_at_8000 = wind.at_8000m
+        daytime = self.game.current_turn_daytime
+        logging.info("Mission time will be {}".format(daytime))
+        if self.game.settings.night_disabled:
+            logging.info("Skip Night mission due to user settings")
+            if daytime == "dawn":
+                time_range = (8, 9)
+            elif daytime == "day":
+                time_range = (10, 12)
+            elif daytime == "dusk":
+                time_range = (12, 14)
+            elif daytime == "night":
+                time_range = (14, 17)
+            else:
+                time_range = (10, 12)
+        else:
+            time_range = self.game.theater.daytime_map[daytime]
+
+        start_time += timedelta(hours=random.randint(*time_range))
+
+        logging.info("time - {}, slot - {}, night skipped - {}".format(
+            str(start_time),
+            str(time_range),
+            self.game.settings.night_disabled))
+
+        self.mission.start_time = start_time
+
+    def _generate_wind(self, wind_speed, wind_direction=None):
+        # wind
+        if not wind_direction:
+            wind_direction = random.randint(0, 360)
+
+        self.mission.weather.wind_at_ground = Wind(wind_direction, wind_speed)
+        self.mission.weather.wind_at_2000 = Wind(wind_direction, wind_speed * 2)
+        self.mission.weather.wind_at_8000 = Wind(wind_direction, wind_speed * 3)
+
+    def _generate_base_weather(self):
+        # clouds
+        self.mission.weather.clouds_base = random.randint(*WEATHER_CLOUD_BASE)
+        self.mission.weather.clouds_density = random.randint(*WEATHER_CLOUD_DENSITY)
+        self.mission.weather.clouds_thickness = random.randint(*WEATHER_CLOUD_THICKNESS)
+
+        # wind
+        self._generate_wind(random.randint(0, 4))
+
+        # fog
+        if random.randint(0, 100) < WEATHER_FOG_CHANCE:
+            self.mission.weather.fog_visibility = random.randint(*WEATHER_FOG_VISIBILITY)
+            self.mission.weather.fog_thickness = random.randint(*WEATHER_FOG_THICKNESS)
+
+    def _gen_random_weather(self):
+        weather_type = None
+        for k, v in RANDOM_WEATHER.items():
+            if random.randint(0, 100) <= v:
+                weather_type = k
+                break
+
+        logging.info("generated weather {}".format(weather_type))
+        if weather_type == 1:
+            # thunderstorm
+            self._generate_base_weather()
+            self._generate_wind(random.randint(0, 8))
+
+            self.mission.weather.clouds_density = random.randint(9, 10)
+            self.mission.weather.clouds_iprecptns = Weather.Preceptions.Thunderstorm
+        elif weather_type == 2:
+            # rain
+            self._generate_base_weather()
+            self.mission.weather.clouds_density = random.randint(5, 8)
+            self.mission.weather.clouds_iprecptns = Weather.Preceptions.Rain
+
+            self._generate_wind(random.randint(0, 6))
+        elif weather_type == 3:
+            # clouds
+            self._generate_base_weather()
+        elif weather_type == 4:
+            # clear
+            pass
+
+        if self.mission.weather.clouds_density > 0:
+            # sometimes clouds are randomized way too low and need to be fixed
+            self.mission.weather.clouds_base = max(self.mission.weather.clouds_base, WEATHER_CLOUD_BASE_MIN)
+
+        if self.mission.weather.wind_at_ground.speed == 0:
+            # frontline smokes look silly w/o any wind
+            self._generate_wind(1)
+
+    def generate(self) -> EnvironmentSettings:
+        self._gen_time()
+        self._gen_random_weather()
+
+        settings = EnvironmentSettings()
+        settings.start_time = self.mission.start_time
+        settings.weather_dict = self.mission.weather.dict()
+        return settings
+
+    def load(self, settings: EnvironmentSettings):
+        self.mission.start_time = settings.start_time
+        self.mission.weather.load_from_dict(settings.weather_dict)
 
-    def generate(self):
-        self.mission.start_time = self.conditions.start_time
-        self.set_clouds(self.conditions.weather.clouds)
-        self.set_fog(self.conditions.weather.fog)
-        self.set_wind(self.conditions.weather.wind)

gen/fleet/carrier_group.py

@@ -12,15 +12,19 @@ class CarrierGroupGenerator(GroupGenerator):
     def generate(self):
 
         # Add carrier
-        if len(self.faction.aircraft_carrier) > 0:
-            carrier_type = random.choice(self.faction.aircraft_carrier)
+        if "aircraft_carrier" in self.faction.keys():
+
+            if "supercarrier" in self.faction.keys() and self.game.settings.supercarrier:
+                carrier_type = random.choice(self.faction["supercarrier"])
+            else:
+                carrier_type = random.choice(self.faction["aircraft_carrier"])
             self.add_unit(carrier_type, "Carrier", self.position.x, self.position.y, self.heading)
         else:
             return
 
         # Add destroyers escort
-        if len(self.faction.destroyers) > 0:
-            dd_type = random.choice(self.faction.destroyers)
+        if "destroyer" in self.faction.keys():
+            dd_type = random.choice(self.faction["destroyer"])
             self.add_unit(dd_type, "DD1", self.position.x + 2500, self.position.y + 4500, self.heading)
             self.add_unit(dd_type, "DD2", self.position.x + 2500, self.position.y - 4500, self.heading)
 

gen/fleet/lha_group.py

@@ -12,13 +12,13 @@ class LHAGroupGenerator(GroupGenerator):
     def generate(self):
 
         # Add carrier
-        if len(self.faction.helicopter_carrier) > 0:
-            carrier_type = random.choice(self.faction.helicopter_carrier)
+        if "helicopter_carrier" in self.faction.keys():
+            carrier_type = random.choice(self.faction["helicopter_carrier"])
             self.add_unit(carrier_type, "LHA", self.position.x, self.position.y, self.heading)
 
         # Add destroyers escort
-        if len(self.faction.destroyers) > 0:
-            dd_type = random.choice(self.faction.destroyers)
+        if "destroyer" in self.faction.keys():
+            dd_type = random.choice(self.faction["destroyer"])
             self.add_unit(dd_type, "DD1", self.position.x + 1250, self.position.y + 1450, self.heading)
             self.add_unit(dd_type, "DD2", self.position.x + 1250, self.position.y - 1450, self.heading)
 

gen/fleet/ship_group_generator.py

@@ -28,20 +28,22 @@ SHIP_MAP = {
 }
 
 
-def generate_ship_group(game, ground_object, faction_name: str):
+def generate_ship_group(game, ground_object, faction:str):
     """
     This generate a ship group
     :return: Nothing, but put the group reference inside the ground object
     """
-    faction = db.FACTIONS[faction_name]
-    if len(faction.navy_generators) > 0:
-        gen = random.choice(faction.navy_generators)
-        if gen in SHIP_MAP.keys():
-            generator = SHIP_MAP[gen](game, ground_object, faction)
-            generator.generate()
-            return generator.get_generated_group()
-        else:
-            logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
+    faction = db.FACTIONS[faction]
+    if "boat" in faction.keys():
+        generators = faction["boat"]
+        if len(generators) > 0:
+            gen = random.choice(generators)
+            if gen in SHIP_MAP.keys():
+                generator = SHIP_MAP[gen](game, ground_object, faction)
+                generator.generate()
+                return generator.get_generated_group()
+            else:
+                logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
     return None
 
 

gen/flights/ai_flight_planner_db.py

@@ -1,84 +1,5 @@
-from dcs.helicopters import (
-    AH_1W,
-    AH_64A,
-    AH_64D,
-    Ka_50,
-    Mi_24V,
-    Mi_28N,
-    Mi_8MT,
-    OH_58D,
-    SA342L,
-    SA342M,
-    UH_1H,
-)
-from dcs.planes import (
-    AJS37,
-    AV8BNA,
-    A_10A,
-    A_10C,
-    A_10C_2,
-    A_20G,
-    B_17G,
-    B_1B,
-    B_52H,
-    Bf_109K_4,
-    C_101CC,
-    FA_18C_hornet,
-    FW_190A8,
-    FW_190D9,
-    F_117A,
-    F_14B,
-    F_15C,
-    F_15E,
-    F_16A,
-    F_16C_50,
-    F_4E,
-    F_5E_3,
-    F_86F_Sabre,
-    F_A_18C,
-    JF_17,
-    J_11A,
-    Ju_88A4,
-    L_39ZA,
-    MQ_9_Reaper,
-    M_2000C,
-    MiG_15bis,
-    MiG_19P,
-    MiG_21Bis,
-    MiG_23MLD,
-    MiG_25PD,
-    MiG_27K,
-    MiG_29A,
-    MiG_29G,
-    MiG_29K,
-    MiG_29S,
-    MiG_31,
-    Mirage_2000_5,
-    P_47D_30,
-    P_47D_30bl1,
-    P_47D_40,
-    P_51D,
-    P_51D_30_NA,
-    RQ_1A_Predator,
-    SpitfireLFMkIX,
-    SpitfireLFMkIXCW,
-    Su_17M4,
-    Su_24M,
-    Su_24MR,
-    Su_25,
-    Su_25T,
-    Su_25TM,
-    Su_27,
-    Su_30,
-    Su_33,
-    Su_34,
-    Tornado_GR4,
-    Tornado_IDS,
-    Tu_160,
-    Tu_22M3,
-    Tu_95MS,
-    WingLoong_I,
-)
+from dcs.planes import *
+from dcs.helicopters import *
 
 # Interceptor are the aircraft prioritized for interception tasks
 # If none is available, the AI will use regular CAP-capable aircraft instead
@@ -86,11 +7,6 @@ from pydcs_extensions.a4ec.a4ec import A_4E_C
 from pydcs_extensions.mb339.mb339 import MB_339PAN
 from pydcs_extensions.rafale.rafale import Rafale_A_S, Rafale_M
 
-# TODO: These lists really ought to be era (faction) dependent.
-# Factions which have F-5s, F-86s, and A-4s will should prefer F-5s for CAP, but
-# factions that also have F-4s should not.
-from pydcs_extensions.su57.su57 import Su_57
-
 INTERCEPT_CAPABLE = [
     MiG_21Bis,
     MiG_25PD,
@@ -127,7 +43,6 @@ CAP_CAPABLE = [
     JF_17,
     Su_30,
     Su_33,
-    Su_57,
 
     M_2000C,
     Mirage_2000_5,
@@ -162,43 +77,6 @@ CAP_CAPABLE = [
     Rafale_M,
 ]
 
-CAP_PREFERRED = [
-    MiG_15bis,
-    MiG_19P,
-    MiG_21Bis,
-    MiG_23MLD,
-    MiG_25PD,
-    MiG_29A,
-    MiG_29G,
-    MiG_29S,
-    MiG_31,
-
-    Su_27,
-    J_11A,
-    Su_30,
-    Su_33,
-    Su_57,
-
-    M_2000C,
-    Mirage_2000_5,
-
-    F_86F_Sabre,
-    F_14B,
-    F_15C,
-
-    P_51D_30_NA,
-    P_51D,
-
-    SpitfireLFMkIXCW,
-    SpitfireLFMkIX,
-
-    Bf_109K_4,
-    FW_190D9,
-    FW_190A8,
-
-    Rafale_M,
-]
-
 # Used for CAS (Close air support) and BAI (Battlefield Interdiction)
 CAS_CAPABLE = [
 
@@ -232,8 +110,6 @@ CAS_CAPABLE = [
     F_16C_50,
     FA_18C_hornet,
 
-    B_1B,
-
     Tornado_IDS,
     Tornado_GR4,
 
@@ -279,65 +155,12 @@ CAS_CAPABLE = [
     RQ_1A_Predator
 ]
 
-CAS_PREFERRED = [
-    Su_17M4,
-    Su_24M,
-    Su_24MR,
-    Su_25,
-    Su_25T,
-    Su_25TM,
-    Su_34,
-
-    JF_17,
-
-    A_10A,
-    A_10C,
-    A_10C_2,
-    AV8BNA,
-
-    F_15E,
-
-    Tornado_GR4,
-
-    C_101CC,
-    MB_339PAN,
-    L_39ZA,
-    AJS37,
-
-    SA342M,
-    SA342L,
-    OH_58D,
-
-    AH_64A,
-    AH_64D,
-    AH_1W,
-
-    UH_1H,
-
-    Mi_8MT,
-    Mi_28N,
-    Mi_24V,
-    Ka_50,
-
-    P_47D_30,
-    P_47D_30bl1,
-    P_47D_40,
-    A_20G,
-
-    A_4E_C,
-    Rafale_A_S,
-
-    WingLoong_I,
-    MQ_9_Reaper,
-    RQ_1A_Predator
-]
-
 # Aircraft used for SEAD / DEAD tasks
 SEAD_CAPABLE = [
     F_4E,
     FA_18C_hornet,
     F_15E,
-    F_16C_50,
+    # F_16C_50, Not yet
     AV8BNA,
     JF_17,
 
@@ -356,12 +179,6 @@ SEAD_CAPABLE = [
     Rafale_A_S
 ]
 
-SEAD_PREFERRED = [
-    F_4E,
-    Su_25T,
-    Tornado_IDS,
-]
-
 # Aircraft used for Strike mission
 STRIKE_CAPABLE = [
     MiG_15bis,
@@ -375,10 +192,6 @@ STRIKE_CAPABLE = [
     Su_25T,
     Su_34,
 
-    Tu_160,
-    Tu_22M3,
-    Tu_95MS,
-
     JF_17,
 
     M_2000C,
@@ -396,10 +209,6 @@ STRIKE_CAPABLE = [
     F_16C_50,
     FA_18C_hornet,
 
-    B_1B,
-    B_52H,
-    F_117A,
-
     Tornado_IDS,
     Tornado_GR4,
 
@@ -427,20 +236,6 @@ STRIKE_CAPABLE = [
 
 ]
 
-STRIKE_PREFERRED = [
-    AJS37,
-    A_20G,
-    B_17G,
-    B_1B,
-    B_52H,
-    F_117A,
-    F_15E,
-    Tornado_GR4,
-    Tu_160,
-    Tu_22M3,
-    Tu_95MS,
-]
-
 ANTISHIP_CAPABLE = [
     Su_24M,
     Su_17M4,

gen/flights/closestairfields.py

@@ -1,51 +0,0 @@
-"""Objective adjacency lists."""
-from typing import Dict, Iterator, List, Optional
-
-from theater import ConflictTheater, ControlPoint, MissionTarget
-
-
-class ClosestAirfields:
-    """Precalculates which control points are closes to the given target."""
-
-    def __init__(self, target: MissionTarget,
-                 all_control_points: List[ControlPoint]) -> None:
-        self.target = target
-        self.closest_airfields: List[ControlPoint] = sorted(
-            all_control_points, key=lambda c: self.target.distance_to(c)
-        )
-
-    def airfields_within(self, meters: int) -> Iterator[ControlPoint]:
-        """Iterates over all airfields within the given range of the target.
-
-        Note that this iterates over *all* airfields, not just friendly
-        airfields.
-        """
-        for cp in self.closest_airfields:
-            if cp.distance_to(self.target) < meters:
-                yield cp
-            else:
-                break
-
-
-class ObjectiveDistanceCache:
-    theater: Optional[ConflictTheater] = None
-    closest_airfields: Dict[str, ClosestAirfields] = {}
-
-    @classmethod
-    def set_theater(cls, theater: ConflictTheater) -> None:
-        if cls.theater is not None:
-            cls.closest_airfields = {}
-        cls.theater = theater
-
-    @classmethod
-    def get_closest_airfields(cls, location: MissionTarget) -> ClosestAirfields:
-        if cls.theater is None:
-            raise RuntimeError(
-                "Call ObjectiveDistanceCache.set_theater before using"
-            )
-
-        if location.name not in cls.closest_airfields:
-            cls.closest_airfields[location.name] = ClosestAirfields(
-                location, cls.theater.controlpoints
-            )
-        return cls.closest_airfields[location.name]

gen/flights/flight.py

@@ -1,21 +1,14 @@
-from __future__ import annotations
-
 from enum import Enum
-from typing import Dict, Iterable, List, Optional, TYPE_CHECKING
-
-from dcs.mapping import Point
-from dcs.point import MovingPoint, PointAction
-from dcs.unittype import UnitType
+from typing import List
 
 from game import db
-from theater.controlpoint import ControlPoint, MissionTarget
-
-if TYPE_CHECKING:
-    from gen.ato import Package
+from dcs.unittype import UnitType
+from dcs.point import MovingPoint, PointAction
+from theater.controlpoint import ControlPoint
 
 
 class FlightType(Enum):
-    CAP = 0  # Do not use. Use BARCAP or TARCAP.
+    CAP = 0
     TARCAP = 1
     BARCAP = 2
     CAS = 3
@@ -54,10 +47,6 @@ class FlightWaypointType(Enum):
     TARGET_GROUP_LOC = 13   # A target group approximate location
     TARGET_SHIP = 14        # A target ship known location
     CUSTOM = 15             # User waypoint (no specific behaviour)
-    JOIN = 16
-    SPLIT = 17
-    LOITER = 18
-    INGRESS_ESCORT = 19
 
 
 class PredefinedWaypointCategory(Enum):
@@ -75,15 +64,6 @@ class FlightWaypoint:
 
     def __init__(self, waypoint_type: FlightWaypointType, x: float, y: float,
                  alt: int = 0) -> None:
-        """Creates a flight waypoint.
-
-        Args:
-            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".
-        """
         self.waypoint_type = waypoint_type
         self.x = x
         self.y = y
@@ -91,30 +71,20 @@ class FlightWaypoint:
         self.alt_type = "BARO"
         self.name = ""
         self.description = ""
-        self.targets: List[MissionTarget] = []
-        self.targetGroup: Optional[MissionTarget] = None
+        self.targets = []
+        self.targetGroup = None
         self.obj_name = ""
         self.pretty_name = ""
         self.category: PredefinedWaypointCategory = PredefinedWaypointCategory.NOT_PREDEFINED
         self.only_for_player = False
         self.data = None
 
-        # These are set very late by the air conflict generator (part of mission
-        # generation). We do it late so that we don't need to propagate changes
-        # to waypoint times whenever the player alters the package TOT or the
-        # flight's offset in the UI.
-        self.tot: Optional[int] = None
-        self.departure_time: Optional[int] = None
-
-    @property
-    def position(self) -> Point:
-        return Point(self.x, self.y)
 
     @classmethod
     def from_pydcs(cls, point: MovingPoint,
                    from_cp: ControlPoint) -> "FlightWaypoint":
-        waypoint = FlightWaypoint(FlightWaypointType.NAV, point.position.x,
-                                  point.position.y, point.alt)
+        waypoint = FlightWaypoint(point.position.x, point.position.y,
+                                  point.alt)
         waypoint.alt_type = point.alt_type
         # Other actions exist... but none of them *should* be the first
         # waypoint for a flight.
@@ -138,38 +108,43 @@ class FlightWaypoint:
 
 
 class Flight:
+    unit_type: UnitType = None
+    from_cp = None
+    points: List[FlightWaypoint] = []
+    flight_type: FlightType = None
     count: int = 0
     client_count: int = 0
+    targets = []
     use_custom_loadout = False
+    loadout = {}
     preset_loadout_name = ""
+    start_type = "Runway"
     group = False # Contains DCS Mission group data after mission has been generated
 
-    def __init__(self, package: Package, unit_type: UnitType, count: int,
-                 from_cp: ControlPoint, flight_type: FlightType,
-                 start_type: str) -> None:
-        self.package = package
+    # How long before this flight should take off
+    scheduled_in = 0
+
+    def __init__(self, unit_type: UnitType, count: int, from_cp, flight_type: FlightType):
         self.unit_type = unit_type
         self.count = count
         self.from_cp = from_cp
         self.flight_type = flight_type
-        self.points: List[FlightWaypoint] = []
-        self.targets: List[MissionTarget] = []
-        self.loadout: Dict[str, str] = {}
-        self.start_type = start_type
-        # Late activation delay in seconds from mission start. This is not
-        # the same as the flight's takeoff time. Takeoff time depends on the
-        # mission's TOT and the other flights in the package. Takeoff time is
-        # determined by AirConflictGenerator.
-        self.scheduled_in = 0
+        self.points = []
+        self.targets = []
+        self.loadout = {}
+        self.start_type = "Runway"
 
     def __repr__(self):
         return self.flight_type.name + " | " + str(self.count) + "x" + db.unit_type_name(self.unit_type) \
-               + " (" + str(len(self.points)) + " wpt)"
+               + " in " + str(self.scheduled_in) + " minutes (" + str(len(self.points)) + " wpt)"
 
-    def waypoint_with_type(
-            self,
-            types: Iterable[FlightWaypointType]) -> Optional[FlightWaypoint]:
-        for waypoint in self.points:
-            if waypoint.waypoint_type in types:
-                return waypoint
-        return None
+
+# Test
+if __name__ == '__main__':
+    from pydcs.dcs.planes import A_10C
+    from theater import ControlPoint, Point, List
+
+    from_cp = ControlPoint(0, "AA", Point(0, 0), None, [], 0, 0)
+    f = Flight(A_10C(), 4, from_cp, FlightType.CAS)
+    f.scheduled_in = 50
+    print(f)

gen/flights/flightplan.py

@@ -1,454 +0,0 @@
-"""Flight plan generation.
-
-Flights are first planned generically by either the player or by the
-MissionPlanner. Those only plan basic information like the objective, aircraft
-type, and the size of the flight. The FlightPlanBuilder is responsible for
-generating the waypoints for the mission.
-"""
-from __future__ import annotations
-
-import logging
-import random
-from typing import List, Optional, TYPE_CHECKING
-
-from dcs.mapping import Point
-from dcs.unit import Unit
-
-from game.data.doctrine import Doctrine, MODERN_DOCTRINE
-from game.utils import nm_to_meter
-from gen.ato import Package, PackageWaypoints
-from theater import ControlPoint, FrontLine, MissionTarget, TheaterGroundObject
-from .closestairfields import ObjectiveDistanceCache
-from .flight import Flight, FlightType, FlightWaypoint
-from .waypointbuilder import WaypointBuilder
-from ..conflictgen import Conflict
-
-if TYPE_CHECKING:
-    from game import Game
-
-
-class InvalidObjectiveLocation(RuntimeError):
-    """Raised when the objective location is invalid for the mission type."""
-    def __init__(self, task: FlightType, location: MissionTarget) -> None:
-        super().__init__(
-            f"{location.name} is not valid for {task.name} missions."
-        )
-
-
-class FlightPlanBuilder:
-    """Generates flight plans for flights."""
-
-    def __init__(self, game: Game, package: Package, is_player: bool) -> None:
-        self.game = game
-        self.package = package
-        self.is_player = is_player
-        if is_player:
-            faction = self.game.player_faction
-        else:
-            faction = self.game.enemy_faction
-        self.doctrine: Doctrine = faction.doctrine
-
-    def populate_flight_plan(
-            self, flight: Flight,
-            # TODO: Custom targets should be an attribute of the flight.
-            custom_targets: Optional[List[Unit]] = None) -> None:
-        """Creates a default flight plan for the given mission."""
-        if flight not in self.package.flights:
-            raise RuntimeError("Flight must be a part of the package")
-        if self.package.waypoints is None:
-            self.regenerate_package_waypoints()
-
-        # TODO: Flesh out mission types.
-        try:
-            task = flight.flight_type
-            if task == FlightType.ANTISHIP:
-                logging.error(
-                    "Anti-ship flight plan generation not implemented"
-                )
-            elif task == FlightType.BAI:
-                logging.error("BAI flight plan generation not implemented")
-            elif task == FlightType.BARCAP:
-                self.generate_barcap(flight)
-            elif task == FlightType.CAS:
-                self.generate_cas(flight)
-            elif task == FlightType.DEAD:
-                self.generate_sead(flight, custom_targets)
-            elif task == FlightType.ELINT:
-                logging.error("ELINT flight plan generation not implemented")
-            elif task == FlightType.ESCORT:
-                self.generate_escort(flight)
-            elif task == FlightType.EVAC:
-                logging.error("Evac flight plan generation not implemented")
-            elif task == FlightType.EWAR:
-                logging.error("EWar flight plan generation not implemented")
-            elif task == FlightType.INTERCEPTION:
-                logging.error(
-                    "Intercept flight plan generation not implemented"
-                )
-            elif task == FlightType.LOGISTICS:
-                logging.error(
-                    "Logistics flight plan generation not implemented"
-                )
-            elif task == FlightType.RECON:
-                logging.error("Recon flight plan generation not implemented")
-            elif task == FlightType.SEAD:
-                self.generate_sead(flight, custom_targets)
-            elif task == FlightType.STRIKE:
-                self.generate_strike(flight)
-            elif task == FlightType.TARCAP:
-                self.generate_frontline_cap(flight)
-            elif task == FlightType.TROOP_TRANSPORT:
-                logging.error(
-                    "Troop transport flight plan generation not implemented"
-                )
-            else:
-                logging.error(f"Unsupported task type: {task.name}")
-        except InvalidObjectiveLocation:
-            logging.exception(f"Could not create flight plan")
-
-    def regenerate_package_waypoints(self) -> None:
-        ingress_point = self._ingress_point()
-        egress_point = self._egress_point()
-        join_point = self._join_point(ingress_point)
-        split_point = self._split_point(egress_point)
-
-        self.package.waypoints = PackageWaypoints(
-            join_point,
-            ingress_point,
-            egress_point,
-            split_point,
-        )
-
-    def generate_strike(self, flight: Flight) -> None:
-        """Generates a strike flight plan.
-
-        Args:
-            flight: The flight to generate the flight plan for.
-        """
-        assert self.package.waypoints is not None
-        location = self.package.target
-
-        # TODO: Support airfield strikes.
-        if not isinstance(location, TheaterGroundObject):
-            raise InvalidObjectiveLocation(flight.flight_type, location)
-
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(flight.from_cp)
-        builder.hold(self._hold_point(flight))
-        builder.join(self.package.waypoints.join)
-        builder.ingress_strike(self.package.waypoints.ingress, location)
-
-        if len(location.groups) > 0 and location.dcs_identifier == "AA":
-            # TODO: Replace with DEAD?
-            # Strike missions on SEAD targets target units.
-            for g in location.groups:
-                for j, u in enumerate(g.units):
-                    builder.strike_point(u, f"{u.type} #{j}", location)
-        else:
-            # TODO: Does this actually happen?
-            # ConflictTheater is built with the belief that multiple ground
-            # objects have the same name. If that's the case,
-            # TheaterGroundObject needs some refactoring because it behaves very
-            # differently for SAM sites than it does for strike targets.
-            buildings = self.game.theater.find_ground_objects_by_obj_name(
-                location.obj_name
-            )
-            for building in buildings:
-                if building.is_dead:
-                    continue
-
-                builder.strike_point(building, building.category, location)
-
-        builder.egress(self.package.waypoints.egress, location)
-        builder.split(self.package.waypoints.split)
-        builder.rtb(flight.from_cp)
-
-        flight.points = builder.build()
-
-    def generate_barcap(self, flight: Flight) -> None:
-        """Generate a BARCAP flight at a given location.
-
-        Args:
-            flight: The flight to generate the flight plan for.
-        """
-        location = self.package.target
-
-        if isinstance(location, FrontLine):
-            raise InvalidObjectiveLocation(flight.flight_type, location)
-
-        patrol_alt = random.randint(
-            self.doctrine.min_patrol_altitude,
-            self.doctrine.max_patrol_altitude
-        )
-
-        closest_cache = ObjectiveDistanceCache.get_closest_airfields(location)
-        for airfield in closest_cache.closest_airfields:
-            # If the mission is a BARCAP of an enemy airfield, find the *next*
-            # closest enemy airfield.
-            if airfield == self.package.target:
-                continue
-            if airfield.captured != self.is_player:
-                closest_airfield = airfield
-                break
-        else:
-            logging.error("Could not find any enemy airfields")
-            return
-
-        heading = location.position.heading_between_point(
-            closest_airfield.position
-        )
-
-        min_distance_from_enemy = nm_to_meter(20)
-        distance_to_airfield = int(closest_airfield.position.distance_to_point(
-            self.package.target.position
-        ))
-        distance_to_no_fly = distance_to_airfield - min_distance_from_enemy
-        min_cap_distance = min(self.doctrine.cap_min_distance_from_cp,
-                               distance_to_no_fly)
-        max_cap_distance = min(self.doctrine.cap_max_distance_from_cp,
-                               distance_to_no_fly)
-
-        end = location.position.point_from_heading(
-            heading,
-            random.randint(min_cap_distance, max_cap_distance)
-        )
-        diameter = random.randint(
-            self.doctrine.cap_min_track_length,
-            self.doctrine.cap_max_track_length
-        )
-        start = end.point_from_heading(heading - 180, diameter)
-
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(flight.from_cp)
-        builder.race_track(start, end, patrol_alt)
-        builder.rtb(flight.from_cp)
-        flight.points = builder.build()
-
-    def generate_frontline_cap(self, flight: Flight) -> None:
-        """Generate a CAP flight plan for the given front line.
-
-        Args:
-            flight: The flight to generate the flight plan for.
-        """
-        assert self.package.waypoints is not None
-        location = self.package.target
-
-        if not isinstance(location, FrontLine):
-            raise InvalidObjectiveLocation(flight.flight_type, location)
-
-        ally_cp, enemy_cp = location.control_points
-        patrol_alt = random.randint(self.doctrine.min_patrol_altitude,
-                                    self.doctrine.max_patrol_altitude)
-
-        # Find targets waypoints
-        ingress, heading, distance = Conflict.frontline_vector(
-            ally_cp, enemy_cp, self.game.theater
-        )
-        center = ingress.point_from_heading(heading, distance / 2)
-        orbit_center = center.point_from_heading(
-            heading - 90, random.randint(nm_to_meter(6), nm_to_meter(15))
-        )
-
-        combat_width = distance / 2
-        if combat_width > 500000:
-            combat_width = 500000
-        if combat_width < 35000:
-            combat_width = 35000
-
-        radius = combat_width*1.25
-        orbit0p = orbit_center.point_from_heading(heading, radius)
-        orbit1p = orbit_center.point_from_heading(heading + 180, radius)
-
-        # Create points
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(flight.from_cp)
-        builder.hold(self._hold_point(flight))
-        builder.join(self.package.waypoints.join)
-        builder.race_track(orbit0p, orbit1p, patrol_alt)
-        builder.split(self.package.waypoints.split)
-        builder.rtb(flight.from_cp)
-        flight.points = builder.build()
-
-    def generate_sead(self, flight: Flight,
-                      custom_targets: Optional[List[Unit]]) -> None:
-        """Generate a SEAD/DEAD flight at a given location.
-
-        Args:
-            flight: The flight to generate the flight plan for.
-            custom_targets: Specific radar equipped units selected by the user.
-        """
-        assert self.package.waypoints is not None
-        location = self.package.target
-
-        if not isinstance(location, TheaterGroundObject):
-            raise InvalidObjectiveLocation(flight.flight_type, location)
-
-        if custom_targets is None:
-            custom_targets = []
-
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(flight.from_cp)
-        builder.hold(self._hold_point(flight))
-        builder.join(self.package.waypoints.join)
-        builder.ingress_sead(self.package.waypoints.ingress, location)
-
-        # TODO: Unify these.
-        # There doesn't seem to be any reason to treat the UI fragged missions
-        # different from the automatic missions.
-        if custom_targets:
-            for target in custom_targets:
-                if flight.flight_type == FlightType.DEAD:
-                    builder.dead_point(target, location.name, location)
-                else:
-                    builder.sead_point(target, location.name, location)
-        else:
-            if flight.flight_type == FlightType.DEAD:
-                builder.dead_area(location)
-            else:
-                builder.sead_area(location)
-
-        builder.egress(self.package.waypoints.egress, location)
-        builder.split(self.package.waypoints.split)
-        builder.rtb(flight.from_cp)
-
-        flight.points = builder.build()
-
-    def _hold_point(self, flight: Flight) -> Point:
-        heading = flight.from_cp.position.heading_between_point(
-            self.package.target.position
-        )
-        return flight.from_cp.position.point_from_heading(
-            heading, nm_to_meter(15)
-        )
-
-    def generate_escort(self, flight: Flight) -> None:
-        assert self.package.waypoints is not None
-
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(flight.from_cp)
-        builder.hold(self._hold_point(flight))
-        builder.join(self.package.waypoints.join)
-        builder.escort(self.package.waypoints.ingress,
-                       self.package.target, self.package.waypoints.egress)
-        builder.split(self.package.waypoints.split)
-        builder.rtb(flight.from_cp)
-
-        flight.points = builder.build()
-
-    def generate_cas(self, flight: Flight) -> None:
-        """Generate a CAS flight plan for the given target.
-
-        Args:
-            flight: The flight to generate the flight plan for.
-        """
-        assert self.package.waypoints is not None
-        location = self.package.target
-
-        if not isinstance(location, FrontLine):
-            raise InvalidObjectiveLocation(flight.flight_type, location)
-
-        ingress, heading, distance = Conflict.frontline_vector(
-            location.control_points[0], location.control_points[1],
-            self.game.theater
-        )
-        center = ingress.point_from_heading(heading, distance / 2)
-        egress = ingress.point_from_heading(heading, distance)
-
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(flight.from_cp)
-        builder.hold(self._hold_point(flight))
-        builder.join(self.package.waypoints.join)
-        builder.ingress_cas(ingress, location)
-        builder.cas(center)
-        builder.egress(egress, location)
-        builder.split(self.package.waypoints.split)
-        builder.rtb(flight.from_cp)
-
-        flight.points = builder.build()
-
-    # TODO: Make a model for the waypoint builder and use that in the UI.
-    def generate_ascend_point(self, flight: Flight,
-                              departure: ControlPoint) -> FlightWaypoint:
-        """Generate ascend point.
-
-        Args:
-            flight: The flight to generate the descend point for.
-            departure: Departure airfield or carrier.
-        """
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.ascent(departure)
-        return builder.build()[0]
-
-    def generate_descend_point(self, flight: Flight,
-                               arrival: ControlPoint) -> FlightWaypoint:
-        """Generate approach/descend point.
-
-        Args:
-            flight: The flight to generate the descend point for.
-            arrival: Arrival airfield or carrier.
-        """
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.descent(arrival)
-        return builder.build()[0]
-
-    def generate_rtb_waypoint(self, flight: Flight,
-                              arrival: ControlPoint) -> FlightWaypoint:
-        """Generate RTB landing point.
-
-        Args:
-            flight: The flight to generate the landing waypoint for.
-            arrival: Arrival airfield or carrier.
-        """
-        builder = WaypointBuilder(self.game.conditions, flight, self.doctrine)
-        builder.land(arrival)
-        return builder.build()[0]
-
-    def _join_point(self, ingress_point: Point) -> Point:
-        heading = self._heading_to_package_airfield(ingress_point)
-        return ingress_point.point_from_heading(heading,
-                                                -self.doctrine.join_distance)
-
-    def _split_point(self, egress_point: Point) -> Point:
-        heading = self._heading_to_package_airfield(egress_point)
-        return egress_point.point_from_heading(heading,
-                                               -self.doctrine.split_distance)
-
-    def _ingress_point(self) -> Point:
-        heading = self._target_heading_to_package_airfield()
-        return self.package.target.position.point_from_heading(
-            heading - 180 + 25, self.doctrine.ingress_egress_distance
-        )
-
-    def _egress_point(self) -> Point:
-        heading = self._target_heading_to_package_airfield()
-        return self.package.target.position.point_from_heading(
-            heading - 180 - 25, self.doctrine.ingress_egress_distance
-        )
-
-    def _target_heading_to_package_airfield(self) -> int:
-        return self._heading_to_package_airfield(self.package.target.position)
-
-    def _heading_to_package_airfield(self, point: Point) -> int:
-        return self.package_airfield().position.heading_between_point(point)
-
-    def package_airfield(self) -> ControlPoint:
-        # We'll always have a package, but if this is being planned via the UI
-        # it could be the first flight in the package.
-        if not self.package.flights:
-            raise RuntimeError(
-                "Cannot determine source airfield for package with no flights"
-            )
-
-        # The package airfield is either the flight's airfield (when there is no
-        # package) or the closest airfield to the objective that is the
-        # departure airfield for some flight in the package.
-        cache = ObjectiveDistanceCache.get_closest_airfields(
-            self.package.target
-        )
-        for airfield in cache.closest_airfields:
-            for flight in self.package.flights:
-                if flight.from_cp == airfield:
-                    return airfield
-        raise RuntimeError(
-            "Could not find any airfield assigned to this package"
-        )

gen/flights/traveltime.py

@@ -1,392 +0,0 @@
-from __future__ import annotations
-
-import logging
-import math
-from dataclasses import dataclass
-from typing import Iterable, Optional
-
-from dcs.mapping import Point
-from dcs.unittype import FlyingType
-
-from game.utils import meter_to_nm
-from gen.ato import Package
-from gen.flights.flight import (
-    Flight,
-    FlightType,
-    FlightWaypoint,
-    FlightWaypointType,
-)
-
-
-CAP_DURATION = 30  # Minutes
-
-INGRESS_TYPES = {
-    FlightWaypointType.INGRESS_CAS,
-    FlightWaypointType.INGRESS_ESCORT,
-    FlightWaypointType.INGRESS_SEAD,
-    FlightWaypointType.INGRESS_STRIKE,
-}
-
-
-class GroundSpeed:
-    @staticmethod
-    def mission_speed(package: Package) -> int:
-        speeds = set()
-        for flight in package.flights:
-            # Find a waypoint that matches the mission start waypoint and use
-            # that for the altitude of the mission. That may not be true for the
-            # whole mission, but it's probably good enough for now.
-            waypoint = flight.waypoint_with_type({
-                FlightWaypointType.INGRESS_CAS,
-                FlightWaypointType.INGRESS_ESCORT,
-                FlightWaypointType.INGRESS_SEAD,
-                FlightWaypointType.INGRESS_STRIKE,
-                FlightWaypointType.PATROL_TRACK,
-            })
-            if waypoint is None:
-                logging.error(f"Could not find ingress point for {flight}.")
-                if flight.points:
-                    logging.warning(
-                        "Using first waypoint for mission altitude.")
-                    waypoint = flight.points[0]
-                else:
-                    logging.warning(
-                        "Flight has no waypoints. Assuming mission altitude "
-                        "of 25000 feet.")
-                    waypoint = FlightWaypoint(FlightWaypointType.NAV, 0, 0,
-                                              25000)
-            speeds.add(GroundSpeed.for_flight(flight, waypoint.alt))
-        return min(speeds)
-
-    @classmethod
-    def for_flight(cls, flight: Flight, altitude: int) -> int:
-        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.
-
-        c_sound_sea_level = 661.5
-
-        # DCS's max speed is in kph at 0 MSL. Convert to knots.
-        max_speed = flight.unit_type.max_speed * 0.539957
-        if max_speed > c_sound_sea_level:
-            # Aircraft is supersonic. Limit to mach 0.8 to conserve fuel and
-            # account for heavily loaded jets.
-            return int(cls.from_mach(0.8, altitude))
-
-        # For subsonic aircraft, assume the aircraft can reasonably perform at
-        # 80% of its maximum, and that it can maintain the same mach at altitude
-        # as it can at sea level. This probably isn't great assumption, but
-        # might. be sufficient given the wiggle room. We can come up with
-        # another heuristic if needed.
-        mach = max_speed * 0.8 / c_sound_sea_level
-        return int(cls.from_mach(mach, altitude))  # knots
-
-    @staticmethod
-    def from_mach(mach: float, altitude: int) -> float:
-        """Returns the ground speed in knots for the given mach and altitude.
-
-        Args:
-            mach: The mach number to convert to ground speed.
-            altitude: The altitude in feet.
-
-        Returns:
-            The ground speed corresponding to the given altitude and mach number
-            in knots.
-        """
-        # https://www.grc.nasa.gov/WWW/K-12/airplane/atmos.html
-        if altitude <= 36152:
-            temperature_f = 59 - 0.00356 * altitude
-        else:
-            # There's another formula for altitudes over 82k feet, but we better
-            # not be planning waypoints that high...
-            temperature_f = -70
-
-        temperature_k = (temperature_f + 459.67) * (5 / 9)
-
-        # https://www.engineeringtoolbox.com/specific-heat-ratio-d_602.html
-        # Dependent on temperature, but varies very little (+/-0.001)
-        # between -40F and 180F.
-        heat_capacity_ratio = 1.4
-
-        # https://www.grc.nasa.gov/WWW/K-12/airplane/sound.html
-        gas_constant = 286  # m^2/s^2/K
-        c_sound = math.sqrt(heat_capacity_ratio * gas_constant * temperature_k)
-        # c_sound is in m/s, convert to knots.
-        return (c_sound * 1.944) * mach
-
-
-class TravelTime:
-    @staticmethod
-    def between_points(a: Point, b: Point, speed: float) -> int:
-        error_factor = 1.1
-        distance = meter_to_nm(a.distance_to_point(b))
-        hours = distance / speed
-        seconds = hours * 3600
-        return int(seconds * error_factor)
-
-
-class TotEstimator:
-    # An extra five minutes given as wiggle room. Expected to be spent at the
-    # hold point performing any last minute configuration.
-    HOLD_TIME = 5 * 60
-
-    def __init__(self, package: Package) -> None:
-        self.package = package
-        self.timing = PackageWaypointTiming.for_package(package)
-
-    def mission_start_time(self, flight: Flight) -> int:
-        takeoff_time = self.takeoff_time_for_flight(flight)
-        startup_time = self.estimate_startup(flight)
-        ground_ops_time = self.estimate_ground_ops(flight)
-        return takeoff_time - startup_time - ground_ops_time
-
-    def takeoff_time_for_flight(self, flight: Flight) -> int:
-        stop_types = {FlightWaypointType.JOIN, FlightWaypointType.PATROL_TRACK}
-        travel_time = self.estimate_waypoints_to_target(flight, stop_types)
-        if travel_time is None:
-            logging.warning("Found no join point or patrol point. Cannot "
-                            f"estimate takeoff time takeoff time for {flight}")
-            # Takeoff immediately.
-            return 0
-
-        # BARCAP flights do not coordinate with the rest of the package on join
-        # or ingress points.
-        if flight.flight_type == FlightType.BARCAP:
-            start_time = self.timing.race_track_start(flight)
-        else:
-            start_time = self.timing.join
-        return start_time - travel_time - self.HOLD_TIME
-
-    def earliest_tot(self) -> int:
-        return max((
-            self.earliest_tot_for_flight(f) for f in self.package.flights
-        )) + self.HOLD_TIME
-
-    def earliest_tot_for_flight(self, flight: Flight) -> int:
-        """Estimate fastest time from mission start to the target position.
-
-        For BARCAP flights, this is time to race track start. This ensures that
-        they are on station at the same time any other package members reach
-        their ingress point.
-
-        For other mission types this is the time to the mission target.
-
-        Args:
-            flight: The flight to get the earliest TOT time for.
-
-        Returns:
-            The earliest possible TOT for the given flight in seconds. Returns 0
-            if an ingress point cannot be found.
-        """
-        if flight.flight_type == FlightType.BARCAP:
-            time_to_target = self.estimate_waypoints_to_target(flight, {
-                FlightWaypointType.PATROL_TRACK
-            })
-            if time_to_target is None:
-                logging.warning(
-                    f"Found no race track. Cannot estimate TOT for {flight}")
-                # Return 0 so this flight's travel time does not affect the rest
-                # of the package.
-                return 0
-        else:
-            time_to_ingress = self.estimate_waypoints_to_target(
-                flight, INGRESS_TYPES
-            )
-            if time_to_ingress is None:
-                logging.warning(
-                    f"Found no ingress types. Cannot estimate TOT for {flight}")
-                # Return 0 so this flight's travel time does not affect the rest
-                # of the package.
-                return 0
-
-            assert self.package.waypoints is not None
-            time_to_target = time_to_ingress + TravelTime.between_points(
-                self.package.waypoints.ingress, self.package.target.position,
-                GroundSpeed.mission_speed(self.package))
-        return sum([
-            self.estimate_startup(flight),
-            self.estimate_ground_ops(flight),
-            time_to_target,
-        ])
-
-    @staticmethod
-    def estimate_startup(flight: Flight) -> int:
-        if flight.start_type == "Cold":
-            if flight.client_count:
-                return 10 * 60
-            else:
-                # The AI doesn't seem to have a real startup procedure.
-                return 2 * 60
-        return 0
-
-    @staticmethod
-    def estimate_ground_ops(flight: Flight) -> int:
-        if flight.start_type in ("Runway", "In Flight"):
-            return 0
-        if flight.from_cp.is_fleet:
-            return 2 * 60
-        else:
-            return 5 * 60
-
-    def estimate_waypoints_to_target(
-            self, flight: Flight,
-            stop_types: Iterable[FlightWaypointType]) -> Optional[int]:
-        total = 0
-        # TODO: This is AGL. We want MSL.
-        previous_altitude = 0
-        previous_position = flight.from_cp.position
-        for waypoint in flight.points:
-            position = Point(waypoint.x, waypoint.y)
-            total += TravelTime.between_points(
-                previous_position, position,
-                self.speed_to_waypoint(flight, waypoint, previous_altitude)
-            )
-            previous_position = position
-            previous_altitude = waypoint.alt
-            if waypoint.waypoint_type in stop_types:
-                return total
-
-        return None
-
-    def speed_to_waypoint(self, flight: Flight, waypoint: FlightWaypoint,
-                          from_altitude: int) -> int:
-        # TODO: Adjust if AGL.
-        # We don't have an exact heightmap, but we should probably be performing
-        # *some* adjustment for NTTR since the minimum altitude of the map is
-        # near 2000 ft MSL.
-        alt_for_speed = min(from_altitude, waypoint.alt)
-        pre_join = (FlightWaypointType.LOITER, FlightWaypointType.JOIN)
-        if waypoint.waypoint_type == FlightWaypointType.ASCEND_POINT:
-            # Flights that start airborne already have some altitude and a good
-            # amount of speed.
-            factor = 1.0 if flight.start_type == "In Flight" else 0.5
-            return int(GroundSpeed.for_flight(flight, alt_for_speed) * factor)
-        elif waypoint.waypoint_type in pre_join:
-            return GroundSpeed.for_flight(flight, alt_for_speed)
-        return GroundSpeed.mission_speed(self.package)
-
-
-@dataclass(frozen=True)
-class PackageWaypointTiming:
-    #: The package being scheduled.
-    package: Package
-
-    #: The package join time.
-    join: int
-
-    #: The ingress waypoint TOT.
-    ingress: int
-
-    #: The egress waypoint TOT.
-    egress: int
-
-    #: The package split time.
-    split: int
-
-    @property
-    def target(self) -> int:
-        """The package time over target."""
-        assert self.package.time_over_target is not None
-        return self.package.time_over_target
-
-    def race_track_start(self, flight: Flight) -> int:
-        if flight.flight_type == FlightType.BARCAP:
-            return self.target
-        else:
-            # The only other type that (currently) uses race tracks is TARCAP,
-            # which is sort of in need of cleanup. TARCAP is only valid on front
-            # lines and they participate in join points and patrol between the
-            # ingress and egress points rather than on a race track actually
-            # pointed at the enemy.
-            return self.ingress
-
-    def race_track_end(self, flight: Flight) -> int:
-        if flight.flight_type == FlightType.BARCAP:
-            return self.target + CAP_DURATION * 60
-        else:
-            # For TARCAP. See the explanation in race_track_start.
-            return self.egress
-
-    def push_time(self, flight: Flight, hold_point: FlightWaypoint) -> int:
-        assert self.package.waypoints is not None
-        return self.join - TravelTime.between_points(
-            Point(hold_point.x, hold_point.y),
-            self.package.waypoints.join,
-            GroundSpeed.for_flight(flight, hold_point.alt)
-        )
-
-    def tot_for_waypoint(self, flight: Flight,
-                         waypoint: FlightWaypoint) -> Optional[int]:
-        target_types = (
-            FlightWaypointType.TARGET_GROUP_LOC,
-            FlightWaypointType.TARGET_POINT,
-            FlightWaypointType.TARGET_SHIP,
-        )
-
-        if waypoint.waypoint_type == FlightWaypointType.JOIN:
-            return self.join
-        elif waypoint.waypoint_type in INGRESS_TYPES:
-            return self.ingress
-        elif waypoint.waypoint_type in target_types:
-            return self.target
-        elif waypoint.waypoint_type == FlightWaypointType.EGRESS:
-            return self.egress
-        elif waypoint.waypoint_type == FlightWaypointType.SPLIT:
-            return self.split
-        elif waypoint.waypoint_type == FlightWaypointType.PATROL_TRACK:
-            return self.race_track_start(flight)
-        return None
-
-    def depart_time_for_waypoint(self, waypoint: FlightWaypoint,
-                                 flight: Flight) -> Optional[int]:
-        if waypoint.waypoint_type == FlightWaypointType.LOITER:
-            return self.push_time(flight, waypoint)
-        elif waypoint.waypoint_type == FlightWaypointType.PATROL:
-            return self.race_track_end(flight)
-        return None
-
-    @classmethod
-    def for_package(cls, package: Package) -> PackageWaypointTiming:
-        assert package.waypoints is not None
-
-        # TODO: Plan similar altitudes for the in-country leg of the mission.
-        # Waypoint altitudes for a given flight *shouldn't* differ too much
-        # between the join and split points, so we don't need speeds for each
-        # leg individually since they should all be fairly similar. This doesn't
-        # hold too well right now since nothing is stopping each waypoint from
-        # jumping 20k feet each time, but that's a huge waste of energy we
-        # should be avoiding anyway.
-        if not package.flights:
-            raise ValueError("Cannot plan TOT for package with no flights")
-
-        group_ground_speed = GroundSpeed.mission_speed(package)
-
-        ingress = package.time_over_target - TravelTime.between_points(
-            package.waypoints.ingress,
-            package.target.position,
-            group_ground_speed
-        )
-
-        join = ingress - TravelTime.between_points(
-            package.waypoints.join,
-            package.waypoints.ingress,
-            group_ground_speed
-        )
-
-        egress = package.time_over_target + TravelTime.between_points(
-            package.target.position,
-            package.waypoints.egress,
-            group_ground_speed
-        )
-
-        split = egress + TravelTime.between_points(
-            package.waypoints.egress,
-            package.waypoints.split,
-            group_ground_speed
-        )
-
-        return cls(package, join, ingress, egress, split)

gen/flights/waypointbuilder.py

@@ -1,348 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Optional, Union
-
-from dcs.mapping import Point
-from dcs.unit import Unit
-
-from game.data.doctrine import Doctrine
-from game.utils import nm_to_meter
-from game.weather import Conditions
-from theater import ControlPoint, MissionTarget, TheaterGroundObject
-from .flight import Flight, FlightWaypoint, FlightWaypointType
-from ..runways import RunwayAssigner
-
-
-class WaypointBuilder:
-    def __init__(self, conditions: Conditions, flight: Flight,
-                 doctrine: Doctrine) -> None:
-        self.conditions = conditions
-        self.flight = flight
-        self.doctrine = doctrine
-        self.waypoints: List[FlightWaypoint] = []
-        self.ingress_point: Optional[FlightWaypoint] = None
-
-    @property
-    def is_helo(self) -> bool:
-        return getattr(self.flight.unit_type, "helicopter", False)
-
-    def build(self) -> List[FlightWaypoint]:
-        return self.waypoints
-
-    def ascent(self, departure: ControlPoint) -> None:
-        """Create ascent waypoint for the given departure airfield or carrier.
-
-        Args:
-            departure: Departure airfield or carrier.
-        """
-        heading = RunwayAssigner(self.conditions).takeoff_heading(departure)
-        position = departure.position.point_from_heading(
-            heading, nm_to_meter(5)
-        )
-        waypoint = FlightWaypoint(
-            FlightWaypointType.ASCEND_POINT,
-            position.x,
-            position.y,
-            500 if self.is_helo else self.doctrine.pattern_altitude
-        )
-        waypoint.name = "ASCEND"
-        waypoint.alt_type = "RADIO"
-        waypoint.description = "Ascend"
-        waypoint.pretty_name = "Ascend"
-        self.waypoints.append(waypoint)
-
-    def descent(self, arrival: ControlPoint) -> None:
-        """Create descent waypoint for the given arrival airfield or carrier.
-
-        Args:
-            arrival: Arrival airfield or carrier.
-        """
-        landing_heading = RunwayAssigner(self.conditions).landing_heading(
-            arrival)
-        heading = (landing_heading + 180) % 360
-        position = arrival.position.point_from_heading(
-            heading, nm_to_meter(5)
-        )
-        waypoint = FlightWaypoint(
-            FlightWaypointType.DESCENT_POINT,
-            position.x,
-            position.y,
-            300 if self.is_helo else self.doctrine.pattern_altitude
-        )
-        waypoint.name = "DESCEND"
-        waypoint.alt_type = "RADIO"
-        waypoint.description = "Descend to pattern altitude"
-        waypoint.pretty_name = "Descend"
-        self.waypoints.append(waypoint)
-
-    def land(self, arrival: ControlPoint) -> None:
-        """Create descent waypoint for the given arrival airfield or carrier.
-
-        Args:
-            arrival: Arrival airfield or carrier.
-        """
-        position = arrival.position
-        waypoint = FlightWaypoint(
-            FlightWaypointType.LANDING_POINT,
-            position.x,
-            position.y,
-            0
-        )
-        waypoint.name = "LANDING"
-        waypoint.alt_type = "RADIO"
-        waypoint.description = "Land"
-        waypoint.pretty_name = "Land"
-        self.waypoints.append(waypoint)
-
-    def hold(self, position: Point) -> None:
-        waypoint = FlightWaypoint(
-            FlightWaypointType.LOITER,
-            position.x,
-            position.y,
-            500 if self.is_helo else self.doctrine.rendezvous_altitude
-        )
-        waypoint.pretty_name = "Hold"
-        waypoint.description = "Wait until push time"
-        waypoint.name = "HOLD"
-        self.waypoints.append(waypoint)
-
-    def join(self, position: Point) -> None:
-        waypoint = FlightWaypoint(
-            FlightWaypointType.JOIN,
-            position.x,
-            position.y,
-            500 if self.is_helo else self.doctrine.ingress_altitude
-        )
-        waypoint.pretty_name = "Join"
-        waypoint.description = "Rendezvous with package"
-        waypoint.name = "JOIN"
-        self.waypoints.append(waypoint)
-
-    def split(self, position: Point) -> None:
-        waypoint = FlightWaypoint(
-            FlightWaypointType.SPLIT,
-            position.x,
-            position.y,
-            500 if self.is_helo else self.doctrine.ingress_altitude
-        )
-        waypoint.pretty_name = "Split"
-        waypoint.description = "Depart from package"
-        waypoint.name = "SPLIT"
-        self.waypoints.append(waypoint)
-
-    def ingress_cas(self, position: Point, objective: MissionTarget) -> None:
-        self._ingress(FlightWaypointType.INGRESS_CAS, position, objective)
-
-    def ingress_escort(self, position: Point, objective: MissionTarget) -> None:
-        self._ingress(FlightWaypointType.INGRESS_ESCORT, position, objective)
-
-    def ingress_sead(self, position: Point, objective: MissionTarget) -> None:
-        self._ingress(FlightWaypointType.INGRESS_SEAD, position, objective)
-
-    def ingress_strike(self, position: Point, objective: MissionTarget) -> None:
-        self._ingress(FlightWaypointType.INGRESS_STRIKE, position, objective)
-
-    def _ingress(self, ingress_type: FlightWaypointType, position: Point,
-                 objective: MissionTarget) -> None:
-        if self.ingress_point is not None:
-            raise RuntimeError("A flight plan can have only one ingress point.")
-
-        waypoint = FlightWaypoint(
-            ingress_type,
-            position.x,
-            position.y,
-            500 if self.is_helo else self.doctrine.ingress_altitude
-        )
-        waypoint.pretty_name = "INGRESS on " + objective.name
-        waypoint.description = "INGRESS on " + objective.name
-        waypoint.name = "INGRESS"
-        self.waypoints.append(waypoint)
-        self.ingress_point = waypoint
-
-    def egress(self, position: Point, target: MissionTarget) -> None:
-        waypoint = FlightWaypoint(
-            FlightWaypointType.EGRESS,
-            position.x,
-            position.y,
-            500 if self.is_helo else self.doctrine.ingress_altitude
-        )
-        waypoint.pretty_name = "EGRESS from " + target.name
-        waypoint.description = "EGRESS from " + target.name
-        waypoint.name = "EGRESS"
-        self.waypoints.append(waypoint)
-
-    def dead_point(self, target: Union[TheaterGroundObject, Unit], name: str,
-                   location: MissionTarget) -> None:
-        self._target_point(target, name, f"STRIKE {name}", location)
-        # TODO: Seems fishy.
-        if self.ingress_point is not None:
-            self.ingress_point.targetGroup = location
-
-    def sead_point(self, target: Union[TheaterGroundObject, Unit], name: str,
-                   location: MissionTarget) -> None:
-        self._target_point(target, name, f"STRIKE {name}", location)
-        # TODO: Seems fishy.
-        if self.ingress_point is not None:
-            self.ingress_point.targetGroup = location
-
-    def strike_point(self, target: Union[TheaterGroundObject, Unit], name: str,
-                     location: MissionTarget) -> None:
-        self._target_point(target, name, f"STRIKE {name}", location)
-
-    def _target_point(self, target: Union[TheaterGroundObject, Unit], name: str,
-                      description: str, location: MissionTarget) -> None:
-        if self.ingress_point is None:
-            raise RuntimeError(
-                "An ingress point must be added before target points."
-            )
-
-        waypoint = FlightWaypoint(
-            FlightWaypointType.TARGET_POINT,
-            target.position.x,
-            target.position.y,
-            0
-        )
-        waypoint.description = description
-        waypoint.pretty_name = description
-        waypoint.name = name
-        # The target waypoints are only for the player's benefit. AI tasks for
-        # the target are set on the ingress point so they begin their attack
-        # *before* reaching the target.
-        waypoint.only_for_player = True
-        self.waypoints.append(waypoint)
-        # TODO: This seems wrong, but it's what was there before.
-        self.ingress_point.targets.append(location)
-
-    def sead_area(self, target: MissionTarget) -> None:
-        self._target_area(f"SEAD on {target.name}", target)
-        # TODO: Seems fishy.
-        if self.ingress_point is not None:
-            self.ingress_point.targetGroup = target
-
-    def dead_area(self, target: MissionTarget) -> None:
-        self._target_area(f"DEAD on {target.name}", target)
-        # TODO: Seems fishy.
-        if self.ingress_point is not None:
-            self.ingress_point.targetGroup = target
-
-    def _target_area(self, name: str, location: MissionTarget) -> None:
-        if self.ingress_point is None:
-            raise RuntimeError(
-                "An ingress point must be added before target points."
-            )
-
-        waypoint = FlightWaypoint(
-            FlightWaypointType.TARGET_GROUP_LOC,
-            location.position.x,
-            location.position.y,
-            0
-        )
-        waypoint.description = name
-        waypoint.pretty_name = name
-        waypoint.name = name
-        # The target waypoints are only for the player's benefit. AI tasks for
-        # the target are set on the ingress point so they begin their attack
-        # *before* reaching the target.
-        waypoint.only_for_player = True
-        self.waypoints.append(waypoint)
-        # TODO: This seems wrong, but it's what was there before.
-        self.ingress_point.targets.append(location)
-
-    def cas(self, position: Point) -> None:
-        waypoint = FlightWaypoint(
-            FlightWaypointType.CAS,
-            position.x,
-            position.y,
-            500 if self.is_helo else 1000
-        )
-        waypoint.alt_type = "RADIO"
-        waypoint.description = "Provide CAS"
-        waypoint.name = "CAS"
-        waypoint.pretty_name = "CAS"
-        self.waypoints.append(waypoint)
-
-    def race_track_start(self, position: Point, altitude: int) -> None:
-        """Creates a racetrack start waypoint.
-
-        Args:
-            position: Position of the waypoint.
-            altitude: Altitude of the racetrack in meters.
-        """
-        waypoint = FlightWaypoint(
-            FlightWaypointType.PATROL_TRACK,
-            position.x,
-            position.y,
-            altitude
-        )
-        waypoint.name = "RACETRACK START"
-        waypoint.description = "Orbit between this point and the next point"
-        waypoint.pretty_name = "Race-track start"
-        self.waypoints.append(waypoint)
-
-    def race_track_end(self, position: Point, altitude: int) -> None:
-        """Creates a racetrack end waypoint.
-
-        Args:
-            position: Position of the waypoint.
-            altitude: Altitude of the racetrack in meters.
-        """
-        waypoint = FlightWaypoint(
-            FlightWaypointType.PATROL,
-            position.x,
-            position.y,
-            altitude
-        )
-        waypoint.name = "RACETRACK END"
-        waypoint.description = "Orbit between this point and the previous point"
-        waypoint.pretty_name = "Race-track end"
-        self.waypoints.append(waypoint)
-
-    def race_track(self, start: Point, end: Point, altitude: int) -> None:
-        """Creates two waypoint for a racetrack orbit.
-
-        Args:
-            start: The beginning racetrack waypoint.
-            end: The ending racetrack waypoint.
-            altitude: The racetrack altitude.
-        """
-        self.race_track_start(start, altitude)
-        self.race_track_end(end, altitude)
-
-    def rtb(self, arrival: ControlPoint) -> None:
-        """Creates descent ant landing waypoints for the given control point.
-
-        Args:
-            arrival: Arrival airfield or carrier.
-        """
-        self.descent(arrival)
-        self.land(arrival)
-
-    def escort(self, ingress: Point, target: MissionTarget,
-               egress: Point) -> None:
-        """Creates the waypoints needed to escort the package.
-
-        Args:
-            ingress: The package ingress point.
-            target: The mission target.
-            egress: The package egress point.
-        """
-        # This would preferably be no points at all, and instead the Escort task
-        # would begin on the join point and end on the split point, however the
-        # escort task does not appear to work properly (see the longer
-        # description in gen.aircraft.JoinPointBuilder), so instead we give
-        # the escort flights a flight plan including the ingress point, target
-        # area, and egress point.
-        self._ingress(FlightWaypointType.INGRESS_ESCORT, ingress, target)
-
-        waypoint = FlightWaypoint(
-            FlightWaypointType.TARGET_GROUP_LOC,
-            target.position.x,
-            target.position.y,
-            500 if self.is_helo else self.doctrine.ingress_altitude
-        )
-        waypoint.name = "TARGET"
-        waypoint.description = "Escort the package"
-        waypoint.pretty_name = "Target area"
-        self.waypoints.append(waypoint)
-
-        self.egress(egress, target)

gen/ground_forces/ai_ground_planner.py

@@ -1,14 +1,14 @@
 import random
 from enum import Enum
-from typing import Dict, List
 
-from dcs.vehicles import Armor, Artillery, Infantry, Unarmed
-from dcs.unittype import VehicleType
+from dcs.vehicles import *
 
-import pydcs_extensions.frenchpack.frenchpack as frenchpack
+from gen import Conflict
 from gen.ground_forces.combat_stance import CombatStance
 from theater import ControlPoint
 
+import pydcs_extensions.frenchpack.frenchpack as frenchpack
+
 TYPE_TANKS = [
     Armor.MBT_T_55,
     Armor.MBT_T_72B,
@@ -207,8 +207,8 @@ GROUP_SIZES_BY_COMBAT_STANCE = {
 
 class CombatGroup:
 
-    def __init__(self, role: CombatGroupRole):
-        self.units: List[VehicleType] = []
+    def __init__(self, role:CombatGroupRole):
+        self.units = []
         self.role = role
         self.assigned_enemy_cp = None
         self.start_position = None
@@ -222,22 +222,33 @@ class CombatGroup:
 
 class GroundPlanner:
 
+    cp = None
+    combat_groups_dict = {}
+    connected_enemy_cp = []
+
+    tank_groups = []
+    apc_group = []
+    ifv_group = []
+    art_group = []
+    shorad_groups = []
+    logi_groups = []
+
     def __init__(self, cp:ControlPoint, game):
         self.cp = cp
         self.game = game
         self.connected_enemy_cp = [cp for cp in self.cp.connected_points if cp.captured != self.cp.captured]
-        self.tank_groups: List[CombatGroup] = []
-        self.apc_group: List[CombatGroup] = []
-        self.ifv_group: List[CombatGroup] = []
-        self.art_group: List[CombatGroup] = []
-        self.atgm_group: List[CombatGroup] = []
-        self.logi_groups: List[CombatGroup] = []
-        self.shorad_groups: List[CombatGroup] = []
+        self.tank_groups = []
+        self.apc_group = []
+        self.ifv_group = []
+        self.art_group = []
+        self.atgm_group = []
+        self.logi_groups = []
+        self.shorad_groups = []
 
-        self.units_per_cp: Dict[int, List[CombatGroup]] = {}
+        self.units_per_cp = {}
         for cp in self.connected_enemy_cp:
             self.units_per_cp[cp.id] = []
-        self.reserve: List[CombatGroup] = []
+        self.reserve = []
 
 
     def plan_groundwar(self):

gen/groundobjectsgen.py

@@ -1,328 +1,18 @@
-from __future__ import annotations
+from dcs.statics import *
+from dcs.unit import Ship, Vehicle
 
-import logging
-import random
-from typing import Dict, Iterator, Optional, TYPE_CHECKING
-
-from dcs import Mission
-from dcs.country import Country
-from dcs.statics import fortification_map, warehouse_map
-from dcs.task import (
-    ActivateBeaconCommand,
-    ActivateICLSCommand,
-    EPLRS,
-    OptAlarmState,
-)
-from dcs.unit import Ship, Vehicle, Unit
-from dcs.unitgroup import Group, ShipGroup, StaticGroup
-from dcs.unittype import StaticType, UnitType
-
-from game import db
-from game.data.building_data import FORTIFICATION_UNITS, FORTIFICATION_UNITS_ID
+from game.data.building_data import FORTIFICATION_UNITS_ID, FORTIFICATION_UNITS
 from game.db import unit_type_from_name
-from theater import ControlPoint, TheaterGroundObject
-from theater.theatergroundobject import (
-    BuildingGroundObject, CarrierGroundObject,
-    GenericCarrierGroundObject,
-    LhaGroundObject, ShipGroundObject,
-)
-from .conflictgen import Conflict
-from .radios import RadioFrequency, RadioRegistry
-from .runways import RunwayData
-from .tacan import TacanBand, TacanChannel, TacanRegistry
-
-if TYPE_CHECKING:
-    from game import Game
-
+from .airfields import RunwayData
+from .conflictgen import *
+from .naming import *
+from .radios import RadioRegistry
+from .tacan import TacanBand, TacanRegistry
 
 FARP_FRONTLINE_DISTANCE = 10000
 AA_CP_MIN_DISTANCE = 40000
 
 
-class GenericGroundObjectGenerator:
-    def __init__(self, ground_object: TheaterGroundObject, country: Country,
-                 game: Game, mission: Mission) -> None:
-        self.ground_object = ground_object
-        self.country = country
-        self.game = game
-        self.m = mission
-
-    def generate(self) -> None:
-        # Only covers SAMs and missile sites now.
-        if self.game.position_culled(self.ground_object.position):
-            return
-
-        for group in self.ground_object.groups:
-            if not group.units:
-                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}")
-
-            vg = self.m.vehicle_group(self.country, group.name, unit_type,
-                                      position=group.position,
-                                      heading=group.units[0].heading)
-            vg.units[0].name = self.m.string(group.units[0].name)
-            vg.units[0].player_can_drive = True
-            for i, u in enumerate(group.units):
-                if i > 0:
-                    vehicle = Vehicle(self.m.next_unit_id(),
-                                      self.m.string(u.name), u.type)
-                    vehicle.position.x = u.position.x
-                    vehicle.position.y = u.position.y
-                    vehicle.heading = u.heading
-                    vehicle.player_can_drive = True
-                    vg.add_unit(vehicle)
-
-            self.enable_eplrs(vg, unit_type)
-            self.set_alarm_state(vg)
-
-    @staticmethod
-    def enable_eplrs(group: Group, unit_type: UnitType) -> None:
-        if hasattr(unit_type, 'eplrs'):
-            if unit_type.eplrs:
-                group.points[0].tasks.append(EPLRS(group.id))
-
-    def set_alarm_state(self, group: Group) -> None:
-        if self.game.settings.perf_red_alert_state:
-            group.points[0].tasks.append(OptAlarmState(2))
-        else:
-            group.points[0].tasks.append(OptAlarmState(1))
-
-
-class BuildingSiteGenerator(GenericGroundObjectGenerator):
-    def __init__(self, ground_object: BuildingGroundObject, country: Country,
-                 game: Game, mission: Mission) -> None:
-        super().__init__(ground_object, country, game, mission)
-
-    def generate(self) -> None:
-        if self.game.position_culled(self.ground_object.position):
-            return
-
-        if self.ground_object.dcs_identifier in warehouse_map:
-            static_type = warehouse_map[self.ground_object.dcs_identifier]
-            self.generate_static(static_type)
-        elif self.ground_object.dcs_identifier in fortification_map:
-            static_type = fortification_map[self.ground_object.dcs_identifier]
-            self.generate_static(static_type)
-        elif self.ground_object.dcs_identifier in FORTIFICATION_UNITS_ID:
-            for f in FORTIFICATION_UNITS:
-                if f.id == self.ground_object.dcs_identifier:
-                    unit_type = f
-                    self.generate_vehicle_group(unit_type)
-                    break
-        else:
-            logging.error(
-                f"{self.ground_object.dcs_identifier} not found in static maps")
-
-    def generate_vehicle_group(self, unit_type: UnitType) -> None:
-        if not self.ground_object.is_dead:
-            self.m.vehicle_group(
-                country=self.country,
-                name=self.ground_object.string_identifier,
-                _type=unit_type,
-                position=self.ground_object.position,
-                heading=self.ground_object.heading,
-            )
-
-    def generate_static(self, static_type: StaticType) -> None:
-        self.m.static_group(
-            country=self.country,
-            name=self.ground_object.string_identifier,
-            _type=static_type,
-            position=self.ground_object.position,
-            heading=self.ground_object.heading,
-            dead=self.ground_object.is_dead,
-        )
-
-
-class GenericCarrierGenerator(GenericGroundObjectGenerator):
-    def __init__(self, ground_object: GenericCarrierGroundObject,
-                 control_point: ControlPoint, country: Country, game: Game,
-                 mission: Mission, radio_registry: RadioRegistry,
-                 tacan_registry: TacanRegistry, icls_alloc: Iterator[int],
-                 runways: Dict[str, RunwayData]) -> None:
-        super().__init__(ground_object, country, game, mission)
-        self.ground_object = ground_object
-        self.control_point = control_point
-        self.radio_registry = radio_registry
-        self.tacan_registry = tacan_registry
-        self.icls_alloc = icls_alloc
-        self.runways = runways
-
-    def generate(self) -> None:
-        # TODO: Require single group?
-        for group in self.ground_object.groups:
-            if not group.units:
-                logging.warning(
-                    f"Found empty carrier group in {self.control_point}")
-                continue
-
-            atc = self.radio_registry.alloc_uhf()
-            ship_group = self.configure_carrier(group, atc)
-            for unit in group.units[1:]:
-                ship_group.add_unit(self.create_ship(unit, atc))
-
-            tacan = self.tacan_registry.alloc_for_band(TacanBand.X)
-            tacan_callsign = self.tacan_callsign()
-            icls = next(self.icls_alloc)
-
-            brc = self.steam_into_wind(ship_group)
-            self.activate_beacons(ship_group, tacan, tacan_callsign, icls)
-            self.add_runway_data(brc or 0, atc, tacan, tacan_callsign, icls)
-
-    def get_carrier_type(self, group: Group) -> 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 configure_carrier(self, group: Group,
-                          atc_channel: RadioFrequency) -> ShipGroup:
-        unit_type = self.get_carrier_type(group)
-
-        ship_group = self.m.ship_group(self.country, group.name, unit_type,
-                                       position=group.position,
-                                       heading=group.units[0].heading)
-        ship_group.set_frequency(atc_channel.hertz)
-        ship_group.units[0].name = self.m.string(group.units[0].name)
-        return ship_group
-
-    def create_ship(self, unit: Unit, atc_channel: RadioFrequency) -> Ship:
-        ship = Ship(self.m.next_unit_id(),
-                    self.m.string(unit.name),
-                    unit_type_from_name(unit.type))
-        ship.position.x = unit.position.x
-        ship.position.y = unit.position.y
-        ship.heading = unit.heading
-        # TODO: Verify.
-        ship.set_frequency(atc_channel.hertz)
-        return ship
-
-    def steam_into_wind(self, group: ShipGroup) -> Optional[int]:
-        brc = self.m.weather.wind_at_ground.direction + 180
-        for attempt in range(5):
-            point = group.points[0].position.point_from_heading(
-                brc, 100000 - attempt * 20000)
-            if self.game.theater.is_in_sea(point):
-                group.add_waypoint(point)
-                return brc
-        return None
-
-    def tacan_callsign(self) -> str:
-        raise NotImplementedError
-
-    @staticmethod
-    def activate_beacons(group: ShipGroup, tacan: TacanChannel,
-                         callsign: str, icls: int) -> None:
-        group.points[0].tasks.append(ActivateBeaconCommand(
-            channel=tacan.number,
-            modechannel=tacan.band.value,
-            callsign=callsign,
-            unit_id=group.units[0].id,
-            aa=False
-        ))
-        group.points[0].tasks.append(ActivateICLSCommand(
-            icls, unit_id=group.units[0].id
-        ))
-
-    def add_runway_data(self, brc: int, atc: RadioFrequency,
-                        tacan: TacanChannel, callsign: str, icls: int) -> None:
-        # TODO: Make unit name usable.
-        # This relies on one control point mapping exactly
-        # to one LHA, carrier, or other usable "runway".
-        # This isn't wholly true, since the DD escorts of
-        # the carrier group are valid for helicopters, but
-        # they aren't exposed as such to the game. Should
-        # clean this up so that's possible. We can't use the
-        # unit name since it's an arbitrary ID.
-        self.runways[self.control_point.name] = RunwayData(
-            self.control_point.name,
-            brc,
-            "N/A",
-            atc=atc,
-            tacan=tacan,
-            tacan_callsign=callsign,
-            icls=icls,
-        )
-
-
-class CarrierGenerator(GenericCarrierGenerator):
-    def get_carrier_type(self, group: Group) -> UnitType:
-        unit_type = super().get_carrier_type(group)
-        if self.game.settings.supercarrier:
-            unit_type = db.upgrade_to_supercarrier(unit_type,
-                                                   self.control_point.name)
-        return unit_type
-
-    def tacan_callsign(self) -> str:
-        # TODO: Assign these properly.
-        return random.choice([
-            "STE",
-            "CVN",
-            "CVH",
-            "CCV",
-            "ACC",
-            "ARC",
-            "GER",
-            "ABR",
-            "LIN",
-            "TRU",
-        ])
-
-
-class LhaGenerator(GenericCarrierGenerator):
-    def tacan_callsign(self) -> str:
-        # TODO: Assign these properly.
-        return random.choice([
-            "LHD",
-            "LHA",
-            "LHB",
-            "LHC",
-            "LHD",
-            "LDS",
-        ])
-
-
-class ShipObjectGenerator(GenericGroundObjectGenerator):
-
-    def generate(self) -> None:
-        if self.game.position_culled(self.ground_object.position):
-            return
-
-        for group in self.ground_object.groups:
-            if not group.units:
-                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}")
-
-            self.generate_group(group, unit_type)
-
-    def generate_group(self, group_def: Group, unit_type: UnitType):
-        group = self.m.ship_group(self.country, group_def.name, unit_type,
-                                  position=group_def.position,
-                                  heading=group_def.units[0].heading)
-        group.units[0].name = self.m.string(group_def.units[0].name)
-        # TODO: Skipping the first unit looks like copy pasta from the carrier.
-        for unit in group_def.units[1:]:
-            unit_type = unit_type_from_name(unit.type)
-            ship = Ship(self.m.next_unit_id(),
-                        self.m.string(unit.name), unit_type)
-            ship.position.x = unit.position.x
-            ship.position.y = unit.position.y
-            ship.heading = unit.heading
-            group.add_unit(ship)
-        self.set_alarm_state(group)
-
-
 class GroundObjectsGenerator:
     FARP_CAPACITY = 4
 
@@ -336,7 +26,7 @@ class GroundObjectsGenerator:
         self.icls_alloc = iter(range(1, 21))
         self.runways: Dict[str, RunwayData] = {}
 
-    def generate_farps(self, number_of_units=1) -> Iterator[StaticGroup]:
+    def generate_farps(self, number_of_units=1) -> typing.Collection[StaticGroup]:
         if self.conflict.is_vector:
             center = self.conflict.center
             heading = self.conflict.heading - 90
@@ -359,34 +49,186 @@ class GroundObjectsGenerator:
             )
 
     def generate(self):
+
         for cp in self.game.theater.controlpoints:
+
             if cp.captured:
-                country_name = self.game.player_country
+                country = self.game.player_country
             else:
-                country_name = self.game.enemy_country
-            country = self.m.country(country_name)
+                country = self.game.enemy_country
+            side = self.m.country(country)
 
             for ground_object in cp.ground_objects:
-                if isinstance(ground_object, BuildingGroundObject):
-                    generator = BuildingSiteGenerator(ground_object, country,
-                                                      self.game, self.m)
-                elif isinstance(ground_object, CarrierGroundObject):
-                    generator = CarrierGenerator(ground_object, cp, country,
-                                                 self.game, self.m,
-                                                 self.radio_registry,
-                                                 self.tacan_registry,
-                                                 self.icls_alloc, self.runways)
-                elif isinstance(ground_object, LhaGroundObject):
-                    generator = CarrierGenerator(ground_object, cp, country,
-                                                 self.game, self.m,
-                                                 self.radio_registry,
-                                                 self.tacan_registry,
-                                                 self.icls_alloc, self.runways)
-                elif isinstance(ground_object, ShipGroundObject):
-                    generator = ShipObjectGenerator(ground_object, country,
-                                                    self.game, self.m)
+                if ground_object.dcs_identifier == "AA":
+
+                    if self.game.position_culled(ground_object.position):
+                        continue
+
+                    for g in ground_object.groups:
+                        if len(g.units) > 0:
+                            utype = unit_type_from_name(g.units[0].type)
+
+                            if not ground_object.sea_object:
+                                vg = self.m.vehicle_group(side, g.name, utype, position=g.position, heading=g.units[0].heading)
+                                vg.units[0].name = self.m.string(g.units[0].name)
+                                vg.units[0].player_can_drive = True
+                                for i, u in enumerate(g.units):
+                                    if i > 0:
+                                        vehicle = Vehicle(self.m.next_unit_id(), self.m.string(u.name), u.type)
+                                        vehicle.position.x = u.position.x
+                                        vehicle.position.y = u.position.y
+                                        vehicle.heading = u.heading
+                                        vehicle.player_can_drive = True
+                                        vg.add_unit(vehicle)
+
+                                if hasattr(utype, 'eplrs'):
+                                    if utype.eplrs:
+                                        vg.points[0].tasks.append(EPLRS(vg.id))
+                            else:
+                                vg = self.m.ship_group(side, g.name, utype, position=g.position,
+                                                          heading=g.units[0].heading)
+                                vg.units[0].name = self.m.string(g.units[0].name)
+                                for i, u in enumerate(g.units):
+                                    utype = unit_type_from_name(u.type)
+                                    if i > 0:
+                                        ship = Ship(self.m.next_unit_id(), self.m.string(u.name), utype)
+                                        ship.position.x = u.position.x
+                                        ship.position.y = u.position.y
+                                        ship.heading = u.heading
+                                        vg.add_unit(ship)
+
+                            if self.game.settings.perf_red_alert_state:
+                                vg.points[0].tasks.append(OptAlarmState(2))
+                            else:
+                                vg.points[0].tasks.append(OptAlarmState(1))
+
+
+                elif ground_object.dcs_identifier in ["CARRIER", "LHA"]:
+                    for g in ground_object.groups:
+                        if len(g.units) > 0:
+
+                            utype = unit_type_from_name(g.units[0].type)
+                            if ground_object.dcs_identifier == "CARRIER" and self.game.settings.supercarrier == True:
+                                utype = db.upgrade_to_supercarrier(utype, cp.name)
+
+                            sg = self.m.ship_group(side, g.name, utype, position=g.position, heading=g.units[0].heading)
+                            atc_channel = self.radio_registry.alloc_uhf()
+                            sg.set_frequency(atc_channel.hertz)
+                            sg.units[0].name = self.m.string(g.units[0].name)
+
+                            for i, u in enumerate(g.units):
+                                if i > 0:
+                                    ship = Ship(self.m.next_unit_id(), self.m.string(u.name), unit_type_from_name(u.type))
+                                    ship.position.x = u.position.x
+                                    ship.position.y = u.position.y
+                                    ship.heading = u.heading
+                                    # TODO: Verify.
+                                    ship.set_frequency(atc_channel.hertz)
+                                    sg.add_unit(ship)
+
+                            # Find carrier direction (In the wind)
+                            found_carrier_destination = False
+                            attempt = 0
+                            while not found_carrier_destination and attempt < 5:
+                                point = sg.points[0].position.point_from_heading(self.m.weather.wind_at_ground.direction + 180, 100000-attempt*20000)
+                                if self.game.theater.is_in_sea(point):
+                                    found_carrier_destination = True
+                                    sg.add_waypoint(point)
+                                else:
+                                    attempt = attempt + 1
+
+                            # Set UP TACAN and ICLS
+                            tacan = self.tacan_registry.alloc_for_band(TacanBand.X)
+                            icls_channel = next(self.icls_alloc)
+                            # TODO: Assign these properly.
+                            if ground_object.dcs_identifier == "CARRIER":
+                                tacan_callsign = random.choice([
+                                    "STE",
+                                    "CVN",
+                                    "CVH",
+                                    "CCV",
+                                    "ACC",
+                                    "ARC",
+                                    "GER",
+                                    "ABR",
+                                    "LIN",
+                                    "TRU",
+                                ])
+                            else:
+                                tacan_callsign = random.choice([
+                                    "LHD",
+                                    "LHA",
+                                    "LHB",
+                                    "LHC",
+                                    "LHD",
+                                    "LDS",
+                                ])
+                            sg.points[0].tasks.append(ActivateBeaconCommand(
+                                channel=tacan.number,
+                                modechannel=tacan.band.value,
+                                callsign=tacan_callsign,
+                                unit_id=sg.units[0].id,
+                                aa=False
+                            ))
+                            sg.points[0].tasks.append(ActivateICLSCommand(
+                                icls_channel,
+                                unit_id=sg.units[0].id
+                            ))
+                            # TODO: Make unit name usable.
+                            # This relies on one control point mapping exactly
+                            # to one LHA, carrier, or other usable "runway".
+                            # This isn't wholly true, since the DD escorts of
+                            # the carrier group are valid for helicopters, but
+                            # they aren't exposed as such to the game. Should
+                            # clean this up so that's possible. We can't use the
+                            # unit name since it's an arbitrary ID.
+                            self.runways[cp.name] = RunwayData(
+                                cp.name,
+                                "N/A",
+                                atc=atc_channel,
+                                tacan=tacan,
+                                tacan_callsign=tacan_callsign,
+                                icls=icls_channel,
+                            )
+
                 else:
-                    generator = GenericGroundObjectGenerator(ground_object,
-                                                             country, self.game,
-                                                             self.m)
-                generator.generate()
+
+                    if self.game.position_culled(ground_object.position):
+                        continue
+
+                    static_type = None
+                    if ground_object.dcs_identifier in warehouse_map:
+                        static_type = warehouse_map[ground_object.dcs_identifier]
+                    elif ground_object.dcs_identifier in fortification_map:
+                        static_type = fortification_map[ground_object.dcs_identifier]
+                    elif ground_object.dcs_identifier in FORTIFICATION_UNITS_ID:
+                        for f in FORTIFICATION_UNITS:
+                            if f.id == ground_object.dcs_identifier:
+                                unit_type = f
+                                break
+                    else:
+                        print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
+                        continue
+
+                    if static_type is None:
+                        if not ground_object.is_dead:
+                            group = self.m.vehicle_group(
+                                country=side,
+                                name=ground_object.string_identifier,
+                                _type=unit_type,
+                                position=ground_object.position,
+                                heading=ground_object.heading,
+                            )
+                            logging.info("generated {}object identifier {} with mission id {}".format(
+                                "dead " if ground_object.is_dead else "", group.name, group.id))
+                    else:
+                        group = self.m.static_group(
+                            country=side,
+                            name=ground_object.string_identifier,
+                            _type=static_type,
+                            position=ground_object.position,
+                            heading=ground_object.heading,
+                            dead=ground_object.is_dead,
+                        )
+
+                        logging.info("generated {}object identifier {} with mission id {}".format("dead " if ground_object.is_dead else "", group.name, group.id))

gen/kneeboard.py

@@ -22,7 +22,6 @@ https://forums.eagle.ru/showthread.php?t=206360 claims that kneeboard pages can
 only be added per airframe, so PvP missions where each side have the same
 aircraft will be able to see the enemy's kneeboard for the same airframe.
 """
-import datetime
 from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
@@ -33,14 +32,13 @@ from dcs.mission import Mission
 from dcs.unittype import FlyingType
 from tabulate import tabulate
 
-from game.utils import meter_to_nm
 from . import units
 from .aircraft import AIRCRAFT_DATA, FlightData
+from .airfields import RunwayData
 from .airsupportgen import AwacsInfo, TankerInfo
 from .briefinggen import CommInfo, JtacInfo, MissionInfoGenerator
 from .flights.flight import FlightWaypoint, FlightWaypointType
 from .radios import RadioFrequency
-from .runways import RunwayData
 
 
 class KneeboardPageWriter:
@@ -84,8 +82,6 @@ class KneeboardPageWriter:
 
     def table(self, cells: List[List[str]],
               headers: Optional[List[str]] = None) -> None:
-        if headers is None:
-            headers = []
         table = tabulate(cells, headers=headers, numalign="right")
         self.text(table, font=self.table_font)
 
@@ -108,11 +104,9 @@ class NumberedWaypoint:
 
 
 class FlightPlanBuilder:
-    def __init__(self, start_time: datetime.datetime) -> None:
-        self.start_time = start_time
+    def __init__(self) -> None:
         self.rows: List[List[str]] = []
         self.target_points: List[NumberedWaypoint] = []
-        self.last_waypoint: Optional[FlightWaypoint] = None
 
     def add_waypoint(self, waypoint_num: int, waypoint: FlightWaypoint) -> None:
         if waypoint.waypoint_type == FlightWaypointType.TARGET_POINT:
@@ -124,7 +118,6 @@ class FlightPlanBuilder:
             self.target_points = []
 
         self.add_waypoint_row(NumberedWaypoint(waypoint_num, waypoint))
-        self.last_waypoint = waypoint
 
     def coalesce_target_points(self) -> None:
         if len(self.target_points) <= 4:
@@ -138,60 +131,16 @@ class FlightPlanBuilder:
         self.rows.append([
             f"{first_waypoint_num}-{last_waypoint_num}",
             "Target points",
-            "0",
-            self._waypoint_distance(self.target_points[0].waypoint),
-            self._ground_speed(self.target_points[0].waypoint),
-            self._format_time(self.target_points[0].waypoint.tot),
-            self._format_time(self.target_points[0].waypoint.departure_time),
+            "0"
         ])
-        self.last_waypoint = self.target_points[-1].waypoint
 
     def add_waypoint_row(self, waypoint: NumberedWaypoint) -> None:
         self.rows.append([
-            str(waypoint.number),
+            waypoint.number,
             waypoint.waypoint.pretty_name,
-            str(int(units.meters_to_feet(waypoint.waypoint.alt))),
-            self._waypoint_distance(waypoint.waypoint),
-            self._ground_speed(waypoint.waypoint),
-            self._format_time(waypoint.waypoint.tot),
-            self._format_time(waypoint.waypoint.departure_time),
+            str(int(units.meters_to_feet(waypoint.waypoint.alt)))
         ])
 
-    def _format_time(self, time: Optional[int]) -> str:
-        if time is None:
-            return ""
-        local_time = self.start_time + datetime.timedelta(seconds=time)
-        return local_time.strftime(f"%H:%M:%S")
-
-    def _waypoint_distance(self, waypoint: FlightWaypoint) -> str:
-        if self.last_waypoint is None:
-            return "-"
-
-        distance = meter_to_nm(self.last_waypoint.position.distance_to_point(
-            waypoint.position
-        ))
-        return f"{distance} NM"
-
-    def _ground_speed(self, waypoint: FlightWaypoint) -> str:
-        if self.last_waypoint is None:
-            return "-"
-
-        if waypoint.tot is None:
-            return "-"
-
-        if self.last_waypoint.departure_time is not None:
-            last_time = self.last_waypoint.departure_time
-        elif self.last_waypoint.tot is not None:
-            last_time = self.last_waypoint.tot
-        else:
-            return "-"
-
-        distance = meter_to_nm(self.last_waypoint.position.distance_to_point(
-            waypoint.position
-        ))
-        duration = (waypoint.tot - last_time) / 3600
-        return f"{int(distance / duration)} kt"
-
     def build(self) -> List[List[str]]:
         return self.rows
 
@@ -200,13 +149,12 @@ class BriefingPage(KneeboardPage):
     """A kneeboard page containing briefing information."""
     def __init__(self, flight: FlightData, comms: List[CommInfo],
                  awacs: List[AwacsInfo], tankers: List[TankerInfo],
-                 jtacs: List[JtacInfo], start_time: datetime.datetime) -> None:
+                 jtacs: List[JtacInfo]) -> None:
         self.flight = flight
         self.comms = list(comms)
         self.awacs = awacs
         self.tankers = tankers
         self.jtacs = jtacs
-        self.start_time = start_time
         self.comms.append(CommInfo("Flight", self.flight.intra_flight_channel))
 
     def write(self, path: Path) -> None:
@@ -222,12 +170,11 @@ class BriefingPage(KneeboardPage):
         ], headers=["", "Airbase", "ATC", "TCN", "I(C)LS", "RWY"])
 
         writer.heading("Flight Plan")
-        flight_plan_builder = FlightPlanBuilder(self.start_time)
+        flight_plan_builder = FlightPlanBuilder()
         for num, waypoint in enumerate(self.flight.waypoints):
             flight_plan_builder.add_waypoint(num, waypoint)
-        writer.table(flight_plan_builder.build(), headers=[
-            "#", "Action", "Alt", "Dist", "GSPD", "Time", "Departure"
-        ])
+        writer.table(flight_plan_builder.build(),
+                     headers=["STPT", "Action", "Alt"])
 
         writer.heading("Comm Ladder")
         comms = []
@@ -247,7 +194,7 @@ class BriefingPage(KneeboardPage):
             tankers.append([
                 tanker.callsign,
                 tanker.variant,
-                str(tanker.tacan),
+                tanker.tacan,
                 self.format_frequency(tanker.freq),
             ])
         writer.table(tankers, headers=["Callsign", "Type", "TACAN", "UHF"])
@@ -278,22 +225,12 @@ class BriefingPage(KneeboardPage):
         atc = ""
         if runway.atc is not None:
             atc = self.format_frequency(runway.atc)
-        if runway.tacan is None:
-            tacan = ""
-        else:
-            tacan = str(runway.tacan)
-        if runway.ils is not None:
-            ils = str(runway.ils)
-        elif runway.icls is not None:
-            ils = str(runway.icls)
-        else:
-            ils = ""
         return [
             row_title,
             runway.airfield_name,
             atc,
-            tacan,
-            ils,
+            runway.tacan or "",
+            runway.ils or runway.icls or "",
             runway.runway_name,
         ]
 
@@ -348,11 +285,6 @@ class KneeboardGenerator(MissionInfoGenerator):
         """Returns a list of kneeboard pages for the given flight."""
         return [
             BriefingPage(
-                flight,
-                self.comms,
-                self.awacs,
-                self.tankers,
-                self.jtacs,
-                self.mission.start_time
+                flight, self.comms, self.awacs, self.tankers, self.jtacs
             ),
         ]

gen/missiles/missiles_group_generator.py

@@ -8,14 +8,14 @@ MISSILES_MAP = {
 }
 
 
-def generate_missile_group(game, ground_object, faction_name: str):
+def generate_missile_group(game, ground_object, faction:str):
     """
     This generate a ship group
     :return: Nothing, but put the group reference inside the ground object
     """
-    faction = db.FACTIONS[faction_name]
-    if len(faction.missiles) > 0:
-        generators = faction.missiles
+    faction = db.FACTIONS[faction]
+    if "missiles" in faction.keys():
+        generators = faction["missiles"]
         if len(generators) > 0:
             gen = random.choice(generators)
             if gen in MISSILES_MAP.keys():

gen/runways.py

@@ -1,139 +0,0 @@
-"""Runway information and selection."""
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from typing import Iterator, Optional
-
-from dcs.terrain.terrain import Airport
-
-from game.weather import Conditions
-from theater import ControlPoint, ControlPointType
-from .airfields import AIRFIELD_DATA
-from .radios import RadioFrequency
-from .tacan import TacanChannel
-
-
-@dataclass(frozen=True)
-class RunwayData:
-    airfield_name: str
-    runway_heading: int
-    runway_name: str
-    atc: Optional[RadioFrequency] = None
-    tacan: Optional[TacanChannel] = None
-    tacan_callsign: Optional[str] = None
-    ils: Optional[RadioFrequency] = None
-    icls: Optional[int] = None
-
-    @classmethod
-    def for_airfield(cls, airport: Airport, runway_heading: int,
-                     runway_name: str) -> RunwayData:
-        """Creates RunwayData for the given runway of an airfield.
-
-        Args:
-            airport: The airfield the runway belongs to.
-            runway_heading: Heading of the runway.
-            runway_name: Identifier of the runway to use. e.g. "03" or "20L".
-        """
-        atc: Optional[RadioFrequency] = None
-        tacan: Optional[TacanChannel] = None
-        tacan_callsign: Optional[str] = None
-        ils: Optional[RadioFrequency] = None
-        try:
-            airfield = AIRFIELD_DATA[airport.name]
-            if airfield.atc is not None:
-                atc = airfield.atc.uhf
-            else:
-                atc = None
-            tacan = airfield.tacan
-            tacan_callsign = airfield.tacan_callsign
-            ils = airfield.ils_freq(runway_name)
-        except KeyError:
-            logging.warning(f"No airfield data for {airport.name}")
-        return cls(
-            airfield_name=airport.name,
-            runway_heading=runway_heading,
-            runway_name=runway_name,
-            atc=atc,
-            tacan=tacan,
-            tacan_callsign=tacan_callsign,
-            ils=ils
-        )
-
-    @classmethod
-    def for_pydcs_airport(cls, airport: Airport) -> Iterator[RunwayData]:
-        for runway in airport.runways:
-            runway_number = runway.heading // 10
-            runway_side = ["", "L", "R"][runway.leftright]
-            runway_name = f"{runway_number:02}{runway_side}"
-            yield cls.for_airfield(airport, runway.heading, runway_name)
-
-            # pydcs only exposes one runway per physical runway, so to expose
-            # both sides of the runway we need to generate the other.
-            heading = (runway.heading + 180) % 360
-            runway_number = heading // 10
-            runway_side = ["", "R", "L"][runway.leftright]
-            runway_name = f"{runway_number:02}{runway_side}"
-            yield cls.for_airfield(airport, heading, runway_name)
-
-
-class RunwayAssigner:
-    def __init__(self, conditions: Conditions):
-        self.conditions = conditions
-
-    def angle_off_headwind(self, runway: RunwayData) -> int:
-        wind = self.conditions.weather.wind.at_0m.direction
-        ideal_heading = (wind + 180) % 360
-        return abs(runway.runway_heading - ideal_heading)
-
-    def get_preferred_runway(self, airport: Airport) -> RunwayData:
-        """Returns the preferred runway for the given airport.
-
-        Right now we're only selecting runways based on whether or not
-        they have
-        ILS, but we could also choose based on wind conditions, or which
-        direction flight plans should follow.
-        """
-        runways = list(RunwayData.for_pydcs_airport(airport))
-
-        # Find the runway with the best headwind first.
-        best_runways = [runways[0]]
-        best_angle_off_headwind = self.angle_off_headwind(best_runways[0])
-        for runway in runways[1:]:
-            angle_off_headwind = self.angle_off_headwind(runway)
-            if angle_off_headwind == best_angle_off_headwind:
-                best_runways.append(runway)
-            elif angle_off_headwind < best_angle_off_headwind:
-                best_runways = [runway]
-                best_angle_off_headwind = angle_off_headwind
-
-        for runway in best_runways:
-            # But if there are multiple runways with the same heading,
-            # prefer
-            # and ILS capable runway.
-            if runway.ils is not None:
-                return runway
-
-        # Otherwise the only difference between the two is the distance from
-        # parking, which we don't know, so just pick the first one.
-        return best_runways[0]
-
-    def takeoff_heading(self, departure: ControlPoint) -> int:
-        if departure.cptype == ControlPointType.AIRBASE:
-            return self.get_preferred_runway(departure.airport).runway_heading
-        elif departure.is_fleet:
-            # The carrier will be angled into the wind automatically.
-            return (self.conditions.weather.wind.at_0m.direction + 180) % 360
-        logging.warning(
-            f"Unhandled departure control point: {departure.cptype}")
-        return 0
-
-    def landing_heading(self, arrival: ControlPoint) -> int:
-        if arrival.cptype == ControlPointType.AIRBASE:
-            return self.get_preferred_runway(arrival.airport).runway_heading
-        elif arrival.is_fleet:
-            # The carrier will be angled into the wind automatically.
-            return (self.conditions.weather.wind.at_0m.direction + 180) % 360
-        logging.warning(
-            f"Unhandled departure control point: {arrival.cptype}")
-        return 0

gen/sam/genericsam_group_generator.py

@@ -1,19 +0,0 @@
-import random
-
-from dcs.vehicles import AirDefence
-from game import db
-from gen.sam.group_generator import GroupGenerator
-
-
-class GenericSamGroupGenerator(GroupGenerator):
-    """
-    This is the base for all SAM group generators
-    """
-
-    @property
-    def groupNamePrefix(self) -> str:
-        # prefix the SAM site for use with the Skynet IADS plugin
-        if self.faction == self.game.player_name: # this is the player faction
-            return "BLUE SAM " 
-        else:
-            return "RED SAM " 

gen/sam/group_generator.py

@@ -6,31 +6,22 @@ from dcs.point import PointAction
 from dcs.unit import Vehicle
 
 
-# TODO: Generate a group description rather than a pydcs group.
-# It appears that all of this work gets redone at miz generation time (see
-# groundobjectsgen for an example). We can do less work and include the data we
-# care about in the format we want if we just generate our own group description
-# types rather than pydcs groups.
-class GroupGenerator:
+class GroupGenerator():
 
-    def __init__(self, game, ground_object, faction = None): # faction is not mandatory because some subclasses do not use it
+    def __init__(self, game, ground_object):
         self.game = game
         self.go = ground_object
         self.position = ground_object.position
         self.heading = random.randint(0, 359)
-        self.faction = faction
-        self.vg = unitgroup.VehicleGroup(self.game.next_group_id(), self.groupNamePrefix + self.go.group_identifier)
+        self.vg = unitgroup.VehicleGroup(self.game.next_group_id(), self.go.group_identifier)
+
         wp = self.vg.add_waypoint(self.position, PointAction.OffRoad, 0)
         wp.ETA_locked = True
 
-    @property
-    def groupNamePrefix(self) -> str:
-        return ""
-
     def generate(self):
         raise NotImplementedError
 
-    def get_generated_group(self) -> unitgroup.VehicleGroup:
+    def get_generated_group(self):
         return self.vg
 
     def add_unit(self, unit_type, name, pos_x, pos_y, heading):

gen/sam/sam_group_generator.py

@@ -1,14 +1,13 @@
 import random
-from typing import List, Optional, Type
+from typing import List
 
-from dcs.unitgroup import VehicleGroup
+from dcs.unittype import UnitType
 from dcs.vehicles import AirDefence
 
-from game import Game, db
+from game import db
 from gen.sam.aaa_bofors import BoforsGenerator
 from gen.sam.aaa_flak import FlakGenerator
 from gen.sam.aaa_zu23_insurgent import ZU23InsurgentGenerator
-from gen.sam.group_generator import GroupGenerator
 from gen.sam.sam_avenger import AvengerGenerator
 from gen.sam.sam_chaparral import ChaparralGenerator
 from gen.sam.sam_gepard import GepardGenerator
@@ -33,36 +32,39 @@ from gen.sam.sam_zsu23 import ZSU23Generator
 from gen.sam.sam_zu23 import ZU23Generator
 from gen.sam.sam_zu23_ural import ZU23UralGenerator
 from gen.sam.sam_zu23_ural_insurgent import ZU23UralInsurgentGenerator
-from theater import TheaterGroundObject
 
 SAM_MAP = {
-    "HawkGenerator": HawkGenerator,
-    "ZU23Generator": ZU23Generator,
-    "ZU23UralGenerator": ZU23UralGenerator,
-    "ZU23UralInsurgentGenerator": ZU23UralInsurgentGenerator,
-    "ZU23InsurgentGenerator": ZU23InsurgentGenerator,
-    "ZSU23Generator": ZSU23Generator,
-    "VulcanGenerator": VulcanGenerator,
-    "LinebackerGenerator": LinebackerGenerator,
-    "RapierGenerator": RapierGenerator,
-    "AvengerGenerator": AvengerGenerator,
-    "GepardGenerator": GepardGenerator,
-    "RolandGenerator": RolandGenerator,
-    "PatriotGenerator": PatriotGenerator,
-    "ChaparralGenerator": ChaparralGenerator,
-    "BoforsGenerator": BoforsGenerator,
-    "FlakGenerator": FlakGenerator,
-    "SA2Generator": SA2Generator,
-    "SA3Generator": SA3Generator,
-    "SA6Generator": SA6Generator,
-    "SA8Generator": SA8Generator,
-    "SA9Generator": SA9Generator,
-    "SA10Generator": SA10Generator,
-    "SA11Generator": SA11Generator,
-    "SA13Generator": SA13Generator,
-    "SA15Generator": SA15Generator,
-    "SA19Generator": SA19Generator,
-    "HQ7Generator": HQ7Generator
+    AirDefence.SAM_Hawk_PCP: HawkGenerator,
+    AirDefence.AAA_ZU_23_Emplacement: ZU23Generator,
+    AirDefence.AAA_ZU_23_Closed: ZU23Generator,
+    AirDefence.AAA_ZU_23_on_Ural_375: ZU23UralGenerator,
+    AirDefence.AAA_ZU_23_Insurgent_on_Ural_375: ZU23UralInsurgentGenerator,
+    AirDefence.AAA_ZU_23_Insurgent_Closed: ZU23InsurgentGenerator,
+    AirDefence.AAA_ZU_23_Insurgent: ZU23InsurgentGenerator,
+    AirDefence.SPAAA_ZSU_23_4_Shilka: ZSU23Generator,
+    AirDefence.AAA_Vulcan_M163: VulcanGenerator,
+    AirDefence.SAM_Linebacker_M6: LinebackerGenerator,
+    AirDefence.Rapier_FSA_Launcher: RapierGenerator,
+    AirDefence.SAM_Avenger_M1097: AvengerGenerator,
+    AirDefence.SPAAA_Gepard: GepardGenerator,
+    AirDefence.SAM_Roland_ADS: RolandGenerator,
+    AirDefence.SAM_Patriot_LN_M901: PatriotGenerator,
+    AirDefence.SAM_Patriot_EPP_III: PatriotGenerator,
+    AirDefence.SAM_Chaparral_M48: ChaparralGenerator,
+    AirDefence.AAA_Bofors_40mm: BoforsGenerator,
+    AirDefence.AAA_8_8cm_Flak_36: FlakGenerator,
+    AirDefence.SAM_SA_2_LN_SM_90: SA2Generator,
+    AirDefence.SAM_SA_3_S_125_LN_5P73: SA3Generator,
+    AirDefence.SAM_SA_6_Kub_LN_2P25: SA6Generator,
+    AirDefence.SAM_SA_8_Osa_9A33: SA8Generator,
+    AirDefence.SAM_SA_9_Strela_1_9P31: SA9Generator,
+    AirDefence.SAM_SA_10_S_300PS_LN_5P85C: SA10Generator,
+    AirDefence.SAM_SA_10_S_300PS_CP_54K6: SA10Generator,
+    AirDefence.SAM_SA_11_Buk_LN_9A310M1: SA11Generator,
+    AirDefence.SAM_SA_13_Strela_10M3_9A35M3: SA13Generator,
+    AirDefence.SAM_SA_15_Tor_9A331: SA15Generator,
+    AirDefence.SAM_SA_19_Tunguska_2S6: SA19Generator,
+    AirDefence.HQ_7_Self_Propelled_LN: HQ7Generator
 }
 
 SAM_PRICES = {
@@ -100,39 +102,52 @@ SAM_PRICES = {
 }
 
 
-def get_faction_possible_sams_generator(faction: str) -> List[Type[GroupGenerator]]:
+def get_faction_possible_sams_units(faction: str) -> List[UnitType]:
+    """
+    Return the list
+    :param faction: Faction to search units for
+    """
+    return [u for u in db.FACTIONS[faction]["units"] if u in AirDefence.__dict__.values()]
+
+
+def get_faction_possible_sams_generator(faction: str) -> List[UnitType]:
     """
     Return the list of possible SAM generator for the given faction
-    :param faction: Faction name to search units for
+    :param faction: Faction to search units for
     """
-    return [SAM_MAP[s] for s in db.FACTIONS[faction].sams if s in SAM_MAP.keys()]
+    return [SAM_MAP[u] for u in get_faction_possible_sams_units(faction)]
 
-def generate_anti_air_group(game: Game, ground_object: TheaterGroundObject,
-                            faction: str) -> Optional[VehicleGroup]:
+
+def generate_anti_air_group(game, parent_cp, ground_object, faction:str):
     """
     This generate a SAM group
-    :param game: The Game.
-    :param ground_object: The ground object which will own the sam group.
-    :param faction: Owner faction.
-    :return: The generated group, or None if one could not be generated.
+    :param parentCp: The parent control point
+    :param ground_object: The ground object which will own the sam group
+    :param country: Owner country
+    :return: Nothing, but put the group reference inside the ground object
     """
-    possible_sams_generators = get_faction_possible_sams_generator(faction)
-    if len(possible_sams_generators) > 0:
-        sam_generator_class = random.choice(possible_sams_generators)
-        generator = sam_generator_class(game, ground_object, faction)
+    possible_sams = get_faction_possible_sams_units(faction)
+    if len(possible_sams) > 0:
+        sam = random.choice(possible_sams)
+        generator = SAM_MAP[sam](game, ground_object)
         generator.generate()
         return generator.get_generated_group()
     return None
 
 
-def generate_shorad_group(game: Game, ground_object: TheaterGroundObject,
-                          faction_name: str) -> Optional[VehicleGroup]:
-    faction = db.FACTIONS[faction_name]
-
-    if len(faction.shorads) > 0:
-        sam = random.choice(faction.shorads)
+def generate_shorad_group(game, parent_cp, ground_object, faction:str):
+    if("shorad") in db.FACTIONS[faction].keys():
+        shorad = db.FACTIONS[faction]["shorad"]
+        sam = random.choice(shorad)
         generator = SAM_MAP[sam](game, ground_object)
         generator.generate()
         return generator.get_generated_group()
     else:
-        return generate_anti_air_group(game, ground_object, faction_name)
+        return generate_anti_air_group(game, parent_cp, ground_object, faction)
+
+
+
+
+
+
+

gen/sam/sam_hawk.py

@@ -2,10 +2,10 @@ import random
 
 from dcs.vehicles import AirDefence
 
-from gen.sam.genericsam_group_generator import GenericSamGroupGenerator
+from gen.sam.group_generator import GroupGenerator
 
 
-class HawkGenerator(GenericSamGroupGenerator):
+class HawkGenerator(GroupGenerator):
     """
     This generate an HAWK group
     """
@@ -14,8 +14,8 @@ class HawkGenerator(GenericSamGroupGenerator):
     price = 115
 
     def generate(self):
-        self.add_unit(AirDefence.SAM_Hawk_SR_AN_MPQ_50, "SR", self.position.x + 20, self.position.y, self.heading)
         self.add_unit(AirDefence.SAM_Hawk_PCP, "PCP", self.position.x, self.position.y, self.heading)
+        self.add_unit(AirDefence.SAM_Hawk_SR_AN_MPQ_50, "SR", self.position.x + 20, self.position.y, self.heading)
         self.add_unit(AirDefence.SAM_Hawk_TR_AN_MPQ_46, "TR", self.position.x + 40, self.position.y, self.heading)
 
         # Triple A for close range defense