README update for QT UI branch

TACAN infos are displayed in briefing.

.gitignore

@@ -10,9 +10,4 @@ a.py
 resources/tools/a.miz
 tests/**
 # User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/dictionaries
-.idea/**/shelf
-.idea/misc.xml
-.idea/*.iml
+.idea/

.gitmodules

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

.idea/inspectionProfiles/Project_Default.xml

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

.idea/modules.xml

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

.idea/vcs.xml

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

README.md

@@ -1,33 +1,12 @@
 ![Logo](https://i.imgur.com/c2k18E1.png)
 
-[DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player dynamic campaign. 
+[DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player semi dynamic campaign. 
 
-Uses [pydcs](http://github.com/pydcs/dcs) for mission generation.
+DCS Liberation uses [pydcs](http://github.com/pydcs/dcs) for mission generation
+and [Mist](https://github.com/mrSkortch/MissionScriptingTools) for mission scripting
 
-## Installation
-1. Download and install **Python 3.6.0** package from https://www.python.org/downloads/release/python-360/ (look at the bottom under *Files*; any option will do if it matches your architecture) with default set of options (you need to have *Install launcher for all users (recommended)* checked)
-1. Download archived release (https://github.com/shdwp/dcs_liberation/releases; **not source code zip**, file should be named **dcs_liberation_xx.zip**)
-1. Unzip the archive somewhere. Path does not matter. **Application will not work** if you start it without extracting
-1. Run **start.bat**
-1. If **"Windows protected your PC"** popup appears on your computer (windows blocks any application unknown to it), you can click on **"More info"** and **"Run anyway"**
+## Resources
 
-## Tutorials
-* [Manual](https://github.com/shdwp/dcs_liberation/wiki/Manual)
+* [Getting Started](https://github.com/Khopa/dcs_liberation/wiki/Getting-started)
 
-You should start with the manual, it covers everything you need to know before playing the campaign.
-
-* [Strike objectives reference images](https://imgur.com/a/vCSHa9f)
-
-If you can't find the strike objective you can see here how it's supposed to look.
-
-* [Troubleshooting](https://github.com/shdwp/dcs_liberation/wiki/Troubleshooting)
-
-You could also briefly check the troubleshooting page to get familiar with the known issues that you could probably fix by yourself.
-
-* [Modding tutorial](https://github.com/shdwp/dcs_liberation/wiki/Modding-tutorial)
-
-Modding tutorial will cover how to change default loadouts, configure which planes are present in the campaign (or add new altogether) and more. Check this out if you find that something is not going for your liking, there could be a tutorial for changing that. Although be aware that it would require changing source files and could easily result in non functioning application.
-
-* [Development guide](https://github.com/shdwp/dcs_liberation/wiki/Development-guide)
-
-If you want to contribute to the project, this will give you a brief overview and on how to actually run it from source files.
+* [Tutorials](https://github.com/Khopa/dcs_liberation/wiki/Tutorial-01-:-UI)

a.py

@@ -1,38 +0,0 @@
-from theater.caucasus import *
-from gen.conflictgen import Conflict
-
-from matplotlib import pyplot
-from matplotlib import lines
-from shapely import geometry
-from shapely.geometry import Polygon
-from descartes.patch import PolygonPatch
-
-def put_lines(ls, ax):
-    for g in ls.geoms:
-        ax.plot([g.xy[0][0], g.xy[0][1]], [g.xy[1][0], g.xy[1][1]])
-
-cau = CaucasusTheater()
-#left, heading, dist = Conflict.frontline_vector(cau.soganlug, cau.kutaisi, cau)
-#right = left.point_from_heading(heading, dist)
-
-left, heading = Conflict.frontline_position(cau, cau.soganlug, cau.kutaisi)
-right = left.point_from_heading(heading+90, 80000)
-left = left.point_from_heading(heading-90, 80000)
-
-line = geometry.LineString([(left.x, left.y), (right.x, right.y)])
-line = line.intersection(cau.land_poly)
-
-fig = pyplot.figure(1, figsize=(20, 20), dpi=90)
-ax = fig.add_subplot(121)
-ax.set_ylim([0, 1500000])
-ax.set_xlim([-600000, 400000])
-
-patch = PolygonPatch(cau.land_poly, facecolor=(0, 0, 0), edgecolor=(0, 0, 0), alpha=0.5, zorder=2)
-ax.add_patch(patch)
-ax.plot([left.x, right.x], [left.y, right.y], 'k-', lw=2)
-
-ax.plot([cau.soganlug.position.x, cau.soganlug.position.x+1000], [cau.soganlug.position.y, cau.soganlug.position.y+1000], lw=5)
-ax.plot([cau.kutaisi.position.x, cau.kutaisi.position.x+1000], [cau.kutaisi.position.y, cau.kutaisi.position.y+1000], lw=5)
-put_lines(line, ax)
-pyplot.show()
-

dcs

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

game/db.py

@@ -1,6 +1,8 @@
 import typing
 import enum
+from datetime import datetime
 
+from dcs.countries import get_by_id, country_dict
 from dcs.vehicles import *
 from dcs.ships import *
 from dcs.planes import *
@@ -11,6 +13,38 @@ from dcs.unit import *
 from dcs.unittype import *
 from dcs.unitgroup import *
 
+from game.factions.china_2000 import China_2000
+from game.factions.france_1995 import France_1995
+from game.factions.france_2005 import France_2005
+from game.factions.germany_1990 import Germany_1990
+from game.factions.insurgent import Insurgent
+from game.factions.iran_2015 import Iran_2015
+from game.factions.israel_2000 import Israel_2000
+from game.factions.italy_1990 import Italy_1990
+from game.factions.libya_2011 import Lybia_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.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.turkey_2005 import Turkey_2005
+from game.factions.uae_2005 import UAE_2005
+from game.factions.uk_1990 import UnitedKingdom_1990
+from game.factions.ukraine_2010 import Ukraine_2010
+from game.factions.usa_1944 import USA_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
+
 """
 ---------- BEGINNING OF CONFIGURATION SECTION
 """
@@ -44,32 +78,65 @@ PRICES = {
     Su_33: 22,
     MiG_29A: 18,
     MiG_29S: 20,
+    MiG_29G: 18,
+    MiG_31: 30,
+    J_11A: 26,
+    JF_17: 20,
+    Su_30: 24,
+    SpitfireLFMkIX:3,
+    SpitfireLFMkIXCW:3,
+    Bf_109K_4:3,
+    FW_190D9:3,
+    FW_190A8:3,
 
-    F_5E_3: 6,
-    MiG_15bis: 5,
-    MiG_21Bis: 6,
-    AJS37: 8,
+    F_5E_3: 8,
+    MiG_15bis: 4,
+    MiG_19P: 6,
+    F_86F_Sabre: 4,
+    MiG_21Bis: 8,
+    F_4E: 10,
+    AJS37: 12,
+    C_101CC: 6,
 
-    AV8BNA: 13,
-    M_2000C: 13,
-    FA_18C_hornet: 18,
-    F_15C: 20,
-    F_14B: 14,
+    AV8BNA: 14,
+    M_2000C: 16,
+    Mirage_2000_5: 22,
+    FA_18C_hornet: 24,
+    F_15C: 26,
+    F_16C_50: 20,
+    F_14B: 22,
+    Tornado_IDS: 24,
+    Tornado_GR4: 24,
 
     # bomber
+    Su_17M4: 10,
     Su_25: 15,
-    Su_25T: 13,
+    Su_25T: 18,
     L_39ZA: 10,
-    Su_34: 18,
+    Su_34: 24,
+    Su_24M: 20,
+    Su_24MR: 24,
+    MiG_27K: 20,
 
-    A_10A: 18,
-    A_10C: 20,
+    A_10A: 16,
+    A_10C: 22,
 
     # heli
     Ka_50: 13,
     SA342M: 8,
+    SA342L: 5,
     UH_1H: 4,
     Mi_8MT: 5,
+    Mi_24V: 12,
+    Mi_28N: 16,
+    AH_1W: 10,
+    AH_64A: 12,
+    AH_64D: 16,
+    OH_58D: 6,
+
+    # Bombers
+    B_52H: 25,
+    B_1B: 50,
 
     # special
     IL_76MD: 13,
@@ -84,15 +151,56 @@ PRICES = {
     E_3A: 8,
     C_130: 8,
 
-    # armor
-    Armor.APC_BTR_80: 16,
-    Armor.MBT_T_55: 22,
-    Armor.MBT_T_80U: 28,
-    Armor.MBT_T_90: 35,
+    # WW2
+    P_51D_30_NA: 3,
+    P_51D: 3,
 
-    Armor.ATGM_M1134_Stryker: 18,
-    Armor.MBT_M60A3_Patton: 24,
+    # armor
+    Armor.APC_MTLB: 4,
+    Armor.ARV_MTLB_U_BOMAN: 5,
+    Armor.ARV_BRDM_2: 6,
+    Armor.ARV_BTR_RD: 8,
+    Armor.APC_BTR_80: 8,
+    Armor.MBT_T_55: 18,
+    Armor.MBT_T_72B: 25,
+    Armor.MBT_T_80U: 30,
+    Armor.MBT_T_90: 35,
+    Armor.IFV_BMD_1: 8,
+    Armor.IFV_BMP_1: 14,
+    Armor.IFV_BMP_2: 16,
+    Armor.IFV_BMP_3: 18,
+    Armor.ZBD_04A: 12,
+    Armor.ZTZ_96B: 35,
+
+    Armor.APC_Cobra: 4,
+    Armor.APC_M113: 6,
+    Armor.APC_M1043_HMMWV_Armament: 2,
+    Armor.ATGM_M1045_HMMWV_TOW: 8,
+    Armor.IFV_M2A2_Bradley: 12,
+    Armor.APC_M1126_Stryker_ICV: 10,
+    Armor.ATGM_M1134_Stryker: 12,
+    Armor.MBT_M60A3_Patton: 18,
     Armor.MBT_M1A2_Abrams: 35,
+    Armor.MBT_Leclerc: 35,
+    Armor.MBT_Leopard_1A3: 24,
+    Armor.MBT_Leopard_2: 35,
+    Armor.MBT_Merkava_Mk__4: 35,
+    Armor.TPz_Fuchs: 5,
+    Armor.MBT_Challenger_II: 30,
+    Armor.IFV_Marder: 10,
+    Armor.IFV_MCV_80: 10,
+    Armor.IFV_LAV_25: 7,
+
+    Artillery.MLRS_M270: 55,
+    Artillery.SPH_M109_Paladin: 25,
+
+    Artillery.SPH_2S9_Nona: 12,
+    Artillery.SPH_2S1_Gvozdika: 18,
+    Artillery.SPH_2S3_Akatsia: 24,
+    Artillery.SPH_2S19_Msta: 30,
+    Artillery.MLRS_BM_21_Grad: 15,
+    Artillery.MLRS_9K57_Uragan_BM_27: 40,
+    Artillery.MLRS_9A52_Smerch: 40,
 
     Unarmed.Transport_UAZ_469: 3,
     Unarmed.Transport_Ural_375: 3,
@@ -104,9 +212,37 @@ PRICES = {
     AirDefence.AAA_Vulcan_M163: 5,
     AirDefence.SAM_Linebacker_M6: 10,
 
-    AirDefence.SPAAA_ZSU_23_4_Shilka: 8,
-    AirDefence.SAM_SA_9_Strela_1_9P31: 13,
-    AirDefence.SAM_SA_8_Osa_9A33: 18,
+    AirDefence.AAA_ZU_23_Closed: 2,
+    AirDefence.SPAAA_ZSU_23_4_Shilka: 4,
+    AirDefence.SAM_SA_9_Strela_1_9P31: 8,
+    AirDefence.SAM_SA_19_Tunguska_2S6: 15,
+    AirDefence.SAM_SA_6_Kub_LN_2P25: 22,
+    AirDefence.SAM_SA_8_Osa_9A33: 12,
+    AirDefence.SAM_SA_3_S_125_LN_5P73: 20,
+    AirDefence.SAM_SA_2_LN_SM_90: 15,
+    AirDefence.SAM_SA_11_Buk_LN_9A310M1: 25,
+    AirDefence.SAM_Hawk_PCP: 20,
+    AirDefence.SAM_Patriot_LN_M901: 60,
+    AirDefence.SAM_SA_10_S_300PS_LN_5P85C: 60,
+    AirDefence.SAM_Chaparral_M48: 10,
+
+    # WW2
+    Armor.MT_Pz_Kpfw_V_Panther_Ausf_G:7,
+    Armor.MT_Pz_Kpfw_IV_Ausf_H:4,
+    Armor.HT_Pz_Kpfw_VI_Tiger_I:10,
+    Armor.HT_Pz_Kpfw_VI_Ausf__B__Tiger_II:12,
+    Armor.APC_Sd_Kfz_251:3,
+    Armor.IFV_Sd_Kfz_234_2_Puma:4,
+    Armor.MT_M4_Sherman:4,
+    Armor.MT_M4A4_Sherman_Firefly:6,
+    Armor.CT_Cromwell_IV:8,
+    Armor.M30_Cargo_Carrier:2,
+    Armor.APC_M2A1:2,
+    AirDefence.AAA_Bofors_40mm:4,
+    AirDefence.AAA_Flak_36:6,
+    AirDefence.AAA_Flak_18:4,
+    Artillery.M12_GMC:2,
+    Artillery.Sturmpanzer_IV_Brummbär:2,
 
     # ship
     CV_1143_5_Admiral_Kuznetsov: 100,
@@ -141,28 +277,60 @@ UNIT_BY_TASK = {
         MiG_23MLD,
         Su_27,
         Su_33,
+        MiG_19P,
         MiG_21Bis,
         MiG_29A,
         MiG_29S,
         FA_18C_hornet,
         F_15C,
         F_14B,
+        F_16C_50,
         M_2000C,
+        Mirage_2000_5,
+        P_51D_30_NA,
+        P_51D,
+        MiG_29G,
+        Su_30,
+        J_11A,
+        JF_17,
+        F_4E,
+        C_101CC,
+        Bf_109K_4,
+        FW_190D9,
+        FW_190A8,
+        SpitfireLFMkIXCW,
+        SpitfireLFMkIX
     ],
     CAS: [
+        F_86F_Sabre,
         MiG_15bis,
         L_39ZA,
         AV8BNA,
         AJS37,
         A_10A,
         A_10C,
+        Su_17M4,
         Su_25,
         Su_25T,
         Su_34,
         Ka_50,
         SA342M,
+        SA342L,
+        Su_24M,
+        Su_24MR,
+        AH_64A,
+        AH_64D,
+        OH_58D,
+        B_52H,
+        B_1B,
+        Tornado_IDS,
+        Tornado_GR4,
+        UH_1H,
+        Mi_8MT,
+        Mi_28N,
+        Mi_24V,
+        MiG_27K,
     ],
-
     Transport: [
         IL_76MD,
         An_26B,
@@ -171,34 +339,134 @@ UNIT_BY_TASK = {
 
         C_130,
     ],
-
     Refueling: [
         IL_78M,
         KC_135,
         S_3B_Tanker,
     ],
-
     AWACS: [E_3A, A_50, ],
-
     PinpointStrike: [
+        Armor.APC_MTLB,
+        Armor.APC_MTLB,
+        Armor.APC_MTLB,
+        Armor.APC_MTLB,
+        Armor.APC_MTLB,
+        Armor.ARV_MTLB_U_BOMAN,
+        Armor.ARV_MTLB_U_BOMAN,
+        Armor.ARV_MTLB_U_BOMAN,
+        Armor.ARV_MTLB_U_BOMAN,
+        Armor.ARV_MTLB_U_BOMAN,
+        Armor.ARV_BRDM_2,
+        Armor.ARV_BRDM_2,
+        Armor.ARV_BRDM_2,
+        Armor.ARV_BTR_RD,
+        Armor.ARV_BTR_RD,
+        Armor.ARV_BTR_RD,
+        Armor.ARV_BTR_RD,
         Armor.APC_BTR_80,
         Armor.APC_BTR_80,
         Armor.APC_BTR_80,
+        Armor.APC_BTR_80,
+        Armor.APC_BTR_80,
+        Armor.IFV_BMP_1,
+        Armor.IFV_BMP_1,
+        Armor.IFV_BMP_1,
+        Armor.IFV_BMP_2,
+        Armor.IFV_BMP_2,
+        Armor.IFV_BMP_3,
+        Armor.IFV_BMP_3,
+        Armor.ZBD_04A,
+        Armor.ZBD_04A,
+        Armor.ZBD_04A,
         Armor.MBT_T_55,
         Armor.MBT_T_55,
         Armor.MBT_T_55,
+        Armor.MBT_T_72B,
+        Armor.MBT_T_72B,
         Armor.MBT_T_80U,
         Armor.MBT_T_80U,
         Armor.MBT_T_90,
+        Armor.ZTZ_96B,
 
+        Armor.APC_Cobra,
+        Armor.APC_Cobra,
+        Armor.APC_Cobra,
+        Armor.APC_Cobra,
+        Armor.APC_M113,
+        Armor.APC_M113,
+        Armor.APC_M113,
+        Armor.APC_M113,
+        Armor.TPz_Fuchs,
+        Armor.TPz_Fuchs,
+        Armor.TPz_Fuchs,
+        Armor.TPz_Fuchs,
+        Armor.ATGM_M1045_HMMWV_TOW,
+        Armor.ATGM_M1045_HMMWV_TOW,
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.APC_M1043_HMMWV_Armament,
+        Armor.IFV_M2A2_Bradley,
+        Armor.IFV_M2A2_Bradley,
         Armor.ATGM_M1134_Stryker,
         Armor.ATGM_M1134_Stryker,
+        Armor.APC_M1126_Stryker_ICV,
+        Armor.APC_M1126_Stryker_ICV,
+        Armor.APC_M1126_Stryker_ICV,
+        Armor.IFV_MCV_80,
+        Armor.IFV_MCV_80,
+        Armor.IFV_MCV_80,
+        Armor.IFV_LAV_25,
+        Armor.IFV_LAV_25,
+        Armor.IFV_Marder,
+        Armor.IFV_Marder,
+        Armor.IFV_Marder,
+        Armor.IFV_Marder,
         Armor.MBT_M60A3_Patton,
         Armor.MBT_M60A3_Patton,
         Armor.MBT_M60A3_Patton,
+        Armor.MBT_Leopard_1A3,
+        Armor.MBT_Leopard_1A3,
         Armor.MBT_M1A2_Abrams,
+        Armor.MBT_Leclerc,
+        Armor.MBT_Leopard_2,
+        Armor.MBT_Challenger_II,
+        Armor.MBT_Merkava_Mk__4,
+
+        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.APC_Sd_Kfz_251,
+        Armor.APC_Sd_Kfz_251,
+        Armor.APC_Sd_Kfz_251,
+        Armor.IFV_Sd_Kfz_234_2_Puma,
+        Armor.IFV_Sd_Kfz_234_2_Puma,
+        Armor.MT_M4_Sherman,
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.CT_Cromwell_IV,
+        Armor.M30_Cargo_Carrier,
+        Armor.M30_Cargo_Carrier,
+        Armor.APC_M2A1,
+        Armor.APC_M2A1,
+        Armor.APC_M2A1,
+        Armor.APC_M2A1,
+
+        Artillery.MLRS_M270,
+        Artillery.SPH_M109_Paladin,
+        Artillery.SPH_2S9_Nona,
+        Artillery.SPH_2S1_Gvozdika,
+        Artillery.SPH_2S3_Akatsia,
+        Artillery.SPH_2S19_Msta,
+        Artillery.MLRS_BM_21_Grad,
+        Artillery.MLRS_BM_21_Grad,
+        Artillery.MLRS_9K57_Uragan_BM_27,
+        Artillery.MLRS_9A52_Smerch,
+        Artillery.M12_GMC,
+        Artillery.Sturmpanzer_IV_Brummbär,
+
     ],
     AirDefence: [
+
         # those are listed multiple times here to balance prioritization more into lower tier AAs
         AirDefence.AAA_Vulcan_M163,
         AirDefence.AAA_Vulcan_M163,
@@ -206,19 +474,21 @@ UNIT_BY_TASK = {
         AirDefence.SAM_Linebacker_M6,
 
         AirDefence.SPAAA_ZSU_23_4_Shilka,
-        AirDefence.SPAAA_ZSU_23_4_Shilka,
-        AirDefence.SPAAA_ZSU_23_4_Shilka,
-        AirDefence.SAM_SA_9_Strela_1_9P31,
+        AirDefence.AAA_ZU_23_Closed,
         AirDefence.SAM_SA_9_Strela_1_9P31,
         AirDefence.SAM_SA_8_Osa_9A33,
+        AirDefence.SAM_SA_19_Tunguska_2S6,
+        AirDefence.SAM_SA_6_Kub_LN_2P25,
+        AirDefence.SAM_SA_3_S_125_LN_5P73,
+        AirDefence.SAM_Hawk_PCP,
+        AirDefence.SAM_SA_2_LN_SM_90,
+        AirDefence.SAM_SA_11_Buk_LN_9A310M1,
     ],
-
     Reconnaissance: [Unarmed.Transport_M818, Unarmed.Transport_Ural_375, Unarmed.Transport_UAZ_469],
     Nothing: [Infantry.Infantry_M4, Infantry.Soldier_AK, ],
-    Embarking: [UH_1H, Mi_8MT, ],
-
+    Embarking: [],
     Carriage: [CVN_74_John_C__Stennis, LHA_1_Tarawa, CV_1143_5_Admiral_Kuznetsov, ],
-    CargoTransportation: [Dry_cargo_ship_Ivanov, Bulk_cargo_ship_Yakushev, Tanker_Elnya_160, Armed_speedboat, ],
+    CargoTransportation: [Dry_cargo_ship_Ivanov, Bulk_cargo_ship_Yakushev, Tanker_Elnya_160, Armed_speedboat, ]
 }
 
 """
@@ -229,8 +499,41 @@ SAM_BAN = [
 
     AirDefence.SAM_SA_9_Strela_1_9P31,
     AirDefence.SAM_SA_8_Osa_9A33,
+    AirDefence.SAM_SA_19_Tunguska_2S6,
+    AirDefence.SAM_SA_6_Kub_LN_2P25,
+    AirDefence.SAM_SA_8_Osa_9A33,
+    AirDefence.SAM_SA_3_S_125_LN_5P73,
+    AirDefence.SAM_Hawk_PCP,
+    AirDefence.SAM_SA_2_LN_SM_90,
+    AirDefence.SAM_SA_11_Buk_LN_9A310M1,
 ]
 
+"""
+Used to convert SAM site parts to the corresponding site
+"""
+SAM_CONVERT = {
+    AirDefence.SAM_SR_P_19: AirDefence.SAM_SA_3_S_125_LN_5P73,
+    AirDefence.SAM_SA_3_S_125_TR_SNR: AirDefence.SAM_SA_3_S_125_LN_5P73,
+    AirDefence.SAM_SA_3_S_125_LN_5P73: AirDefence.SAM_SA_3_S_125_LN_5P73,
+    AirDefence.SAM_SA_6_Kub_LN_2P25: AirDefence.SAM_SA_6_Kub_LN_2P25,
+    AirDefence.SAM_SA_6_Kub_STR_9S91: AirDefence.SAM_SA_6_Kub_LN_2P25,
+    AirDefence.SAM_SA_10_S_300PS_LN_5P85C: AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+    AirDefence.SAM_SA_10_S_300PS_SR_5N66M: AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+    AirDefence.SAM_SA_10_S_300PS_TR_30N6: AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+    AirDefence.SAM_SA_10_S_300PS_CP_54K6: AirDefence.SAM_SA_10_S_300PS_LN_5P85C,
+    AirDefence.SAM_SA_10_S_300PS_SR_64H6E: AirDefence.SAM_SA_10_S_300PS_CP_54K6,
+    AirDefence.SAM_Hawk_TR_AN_MPQ_46: AirDefence.SAM_Hawk_PCP,
+    AirDefence.SAM_Hawk_SR_AN_MPQ_50: AirDefence.SAM_Hawk_PCP,
+    AirDefence.SAM_Hawk_LN_M192: AirDefence.SAM_Hawk_PCP,
+    'except': {
+        # this radar is shared between the two S300's. if we attempt to find a SAM site at a base and can't find one
+        #  model, we can safely assume the other was deployed
+        # well, perhaps not safely, but we'll make the assumption anyway :p
+        AirDefence.SAM_SA_10_S_300PS_TR_30N6: AirDefence.SAM_SA_10_S_300PS_CP_54K6,
+        AirDefence.SAM_SR_P_19: AirDefence.SAM_SA_2_LN_SM_90
+    }
+}
+
 """
 Units that will always be spawned in the air
 """
@@ -244,103 +547,47 @@ CARRIER_TAKEOFF_BAN = [
    Su_33,  # Kuznecow is bugged in a way that only 2 aircraft could be spawned
 ]
 
-"""
-AirDefense units that will be spawned at control points not related to the current operation
-"""
-EXTRA_AA = {
-    "Russia": AirDefence.SAM_SA_19_Tunguska_2S6,
-    "USA": AirDefence.SAM_Linebacker_M6,
-}
-
 """
 Units separated by country. Currently only Russia and USA are supported. 
-Be advised that putting unit to the country that have not access to the unit in the game itself will result in incorrect missions generated!
+country : DCS Country name
 """
-UNIT_BY_COUNTRY = {
-    "Russia": [
-        AJS37,
-        MiG_23MLD,
-        F_5E_3,
-        Su_25,
-        Su_27,
-        Su_33,
-        MiG_15bis,
-        MiG_21Bis,
-        MiG_29A,
-        MiG_29S,
-        M_2000C,
+FACTIONS = {
+    "Russia 1955": Russia_1955,
+    "Russia 1965": Russia_1965,
+    "Russia 1975": Russia_1975,
+    "Russia 1990": Russia_1990,
+    "Russia 2010": Russia_2010,
+    "Iran 2015": Iran_2015,
+    "Lybia 2011": Lybia_2011,
+    "China 2000": China_2000,
+    "North Korea 2000": NorthKorea_2000,
+    "Insurgent": Insurgent,
 
-        Su_25T,
-        Su_34,
-        L_39ZA,
-
-        IL_76MD,
-        IL_78M,
-        An_26B,
-        An_30M,
-        Yak_40,
-        A_50,
-
-        Ka_50,
-        SA342M,
-        UH_1H,
-        Mi_8MT,
-
-        AirDefence.SPAAA_ZSU_23_4_Shilka,
-        AirDefence.SAM_SA_9_Strela_1_9P31,
-        AirDefence.SAM_SA_8_Osa_9A33,
-
-        Armor.APC_BTR_80,
-        Armor.MBT_T_90,
-        Armor.MBT_T_80U,
-        Armor.MBT_T_55,
-        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,
-    ],
-
-    "USA": [
-        F_5E_3,
-        F_15C,
-        F_14B,
-        FA_18C_hornet,
-        AJS37,
-        M_2000C,
-        MiG_21Bis,
-        MiG_15bis,
-
-        A_10A,
-        A_10C,
-        AV8BNA,
-
-        KC_135,
-        S_3B_Tanker,
-        C_130,
-        E_3A,
-
-        Ka_50,
-        SA342M,
-        UH_1H,
-        Mi_8MT,
-
-        Armor.MBT_M1A2_Abrams,
-        Armor.MBT_M60A3_Patton,
-        Armor.ATGM_M1134_Stryker,
-        Unarmed.Transport_M818,
-        Infantry.Infantry_M4,
-
-        AirDefence.AAA_Vulcan_M163,
-        AirDefence.SAM_Linebacker_M6,
-
-        CVN_74_John_C__Stennis,
-        LHA_1_Tarawa,
-        Armed_speedboat,
-    ],
+    "USA 2005": USA_2005,
+    "USA 1990": USA_1990,
+    "USA 1965": USA_1965,
+    "USA 1960": USA_1960,
+    "USA 1955 (Require WW2 Pack)": USA_1955,
+    "USA 1944 (Require WW2 Pack)": USA_1944,
+    "France 1995": France_1995,
+    "France 2005": France_2005,
+    "Germany 1990": Germany_1990,
+    "Netherlands 1990": Netherlands_1990,
+    "United Kingdown 1990": UnitedKingdom_1990,
+    "Spain 1990": Spain_1990,
+    "Italy 1990": Italy_1990,
+    "Sweden 1990": Sweden_1990,
+    "Ukraine 2010": Ukraine_2010,
+    "India 2010": India_2010,
+    "Pakistan 2015": Pakistan_2015,
+    "Israel 2000": Israel_2000,
+    "Turkey 2005": Turkey_2005,
+    "United Arab Emirates 2005": UAE_2005,
+    "Germany 1944 (Require WW2 Pack)": Germany_1944
 }
+BLUEFOR_FACTIONS = [FACTIONS[f]["country"] for f in FACTIONS if FACTIONS[f]["side"] == "blue"]
+print(BLUEFOR_FACTIONS)
+
 
 CARRIER_TYPE_BY_PLANE = {
     FA_18C_hornet: CVN_74_John_C__Stennis,
@@ -368,57 +615,77 @@ where:
                      
 Payload will be used for operation of following type, "*" category will be used always, no matter the operation.
 """
+
+COMMON_OVERRIDE = {
+    CAP: "CAP",
+    Intercept: "CAP",
+    CAS: "CAS",
+    PinpointStrike: "STRIKE",
+    SEAD: "SEAD",
+    AntishipStrike: "ANTISHIP",
+    GroundAttack: "STRIKE"
+}
+
 PLANE_PAYLOAD_OVERRIDES = {
+
     FA_18C_hornet: {
-        CAP: "AIM-120*4,AIM-9*2,AIM-7*2,Fuel",
-        Escort: "AIM-120*4,AIM-9*2,AIM-7*2,Fuel",
-        PinpointStrike: "MK-82*8,AIM-9*2,AIM-7,FLIR Pod,Fuel",
-        AntishipStrike: "MK-82*8,AIM-9*2,AIM-7,FLIR Pod,Fuel",
+        CAP: "CAP HEAVY",
+        Intercept: "CAP HEAVY",
+        CAS: "CAS MAVERICK F",
+        PinpointStrike: "STRIKE",
+        SEAD: "SEAD",
+        AntishipStrike: "ANTISHIP",
+        GroundAttack: "STRIKE"
     },
 
-    F_14B: {
-        CAP: "AIM-54A-MK47*4, AIM-7M*2, AIM-9M*2, XT*2",
-        Escort: "AIM-54A-MK47*4, AIM-7M*2, AIM-9M*2, XT*2",
-        CAS: "AIM-54A-MK60*1, AIM-7M*1, AIM-9M*2, XT*2, Mk-82*2, LANTIRN",
-        GroundAttack: "AIM54, AIM-9M*2, XT*2, GBU-12*4, LANTIRN",
+    A_10A: COMMON_OVERRIDE,
+    A_10C: COMMON_OVERRIDE,
+    AV8BNA: COMMON_OVERRIDE,
+    C_101CC: COMMON_OVERRIDE,
+    F_5E_3: COMMON_OVERRIDE,
+    F_14B: COMMON_OVERRIDE,
+    F_15C: COMMON_OVERRIDE,
+    F_16C_50: COMMON_OVERRIDE,
+    JF_17: COMMON_OVERRIDE,
+    M_2000C: COMMON_OVERRIDE,
+    MiG_15bis: COMMON_OVERRIDE,
+    MiG_19P: COMMON_OVERRIDE,
+    MiG_21Bis: COMMON_OVERRIDE,
+    AJS37: COMMON_OVERRIDE,
+    Su_25T:COMMON_OVERRIDE,
+    Su_25:COMMON_OVERRIDE,
+    Su_27:COMMON_OVERRIDE,
+    Su_33:COMMON_OVERRIDE,
+    MiG_29A:COMMON_OVERRIDE,
+    MiG_29G:COMMON_OVERRIDE,
+    MiG_29S:COMMON_OVERRIDE,
+    Su_24M:COMMON_OVERRIDE,
+    Su_30: COMMON_OVERRIDE,
+    Su_34: COMMON_OVERRIDE,
+    MiG_23MLD: COMMON_OVERRIDE,
+    MiG_27K: COMMON_OVERRIDE,
+    Tornado_GR4: COMMON_OVERRIDE,
+    Tornado_IDS: COMMON_OVERRIDE,
+    Mirage_2000_5: COMMON_OVERRIDE,
+    MiG_31:COMMON_OVERRIDE,
+    SA342M:COMMON_OVERRIDE,
+    SA342L:COMMON_OVERRIDE,
+    SA342Mistral:COMMON_OVERRIDE,
+    Mi_8MT:COMMON_OVERRIDE,
+    Ka_50:COMMON_OVERRIDE,
+    L_39ZA:COMMON_OVERRIDE,
+    L_39C:COMMON_OVERRIDE,
+    Su_17M4: COMMON_OVERRIDE,
+    F_4E: COMMON_OVERRIDE,
+
+    AH_64D:{
+        CAS: "AGM-114K*16"
     },
 
-    Su_25T: {
-        CAS: "APU-8 Vikhr-M*2,Kh-25ML,R-73*2,SPPU-22*2,Mercury LLTV Pod,MPS-410",
+    Su_25TM: {
+        SEAD: "Kh-31P*2_Kh-25ML*4_R-73*2_L-081_MPS410",
     },
 
-    Su_33: {
-        CAP: "R-73*4,R-27R*2,R-27ER*6",
-        Escort: "R-73*4,R-27R*2,R-27ER*6",
-    },
-
-    AJS37: {
-        CAS: "CAS (75 GUN): RB-75*2, AKAN",
-    },
-
-    AV8BNA: {
-        CAS: "AS 2",
-    },
-
-    A_10C: {
-        CAS: "AGM-65D*2,AGM-65H*2,GBU-12*2,GBU-38*2,AIM-9*2,TGP,ECM,MK151*7",
-        GroundAttack: "AGM-65K*2,GBU-12*8,AIM-9M*2.ECM,TGP",
-    },
-
-    Ka_50: {
-        CAS: "12x9A4172, 40xS-8",
-        GroundAttack: "12x9A4172, 40xS-8",
-    },
-
-    M_2000C: {
-        CAP: "Combat Air Patrol",
-        Escort: "Combat Air Patrol",
-        GroundAttack: "MK-82S Heavy Strike",
-    },
-
-    MiG_21Bis: {
-        CAP: "Patrol, medium range",
-    }
 }
 
 """
@@ -433,6 +700,86 @@ PLANE_LIVERY_OVERRIDES = {
     FA_18C_hornet: "VFA-34",  # default livery for the hornet is blue angels one
 }
 
+
+
+"""
+Possible time periods for new games
+
+    `Name`: daytime(day, month, year),
+
+`Identifier` is the name that will appear in the menu
+The object is a python datetime object
+"""
+TIME_PERIODS = {
+    "WW2 - Winter [1944]": datetime(1944, 1, 1),
+    "WW2 - Spring [1944]": datetime(1944, 4, 1),
+    "WW2 - Summer [1944]": datetime(1944, 6, 1),
+    "WW2 - Fall [1944]": datetime(1944, 10, 1),
+    "Early Cold War - Winter [1952]": datetime(1952, 1, 1),
+    "Early Cold War - Spring [1952]": datetime(1952, 4, 1),
+    "Early Cold War - Summer [1952]": datetime(1952, 6, 1),
+    "Early Cold War - Fall [1952]": datetime(1952, 10, 1),
+    "Cold War - Winter [1970]": datetime(1970, 1, 1),
+    "Cold War - Spring [1970]": datetime(1970, 4, 1),
+    "Cold War - Summer [1970]": datetime(1970, 6, 1),
+    "Cold War - Fall [1970]": datetime(1970, 10, 1),
+    "Late Cold War - Winter [1985]": datetime(1985, 1, 1),
+    "Late Cold War - Spring [1985]": datetime(1985, 4, 1),
+    "Late Cold War - Summer [1985]": datetime(1985, 6, 1),
+    "Late Cold War - Fall [1985]": datetime(1985, 10, 1),
+    "Gulf War - Winter [1990]": datetime(1990, 1, 1),
+    "Gulf War - Spring [1990]": datetime(1990, 4, 1),
+    "Gulf War - Summer [1990]": datetime(1990, 6, 1),
+    "Gulf War - Fall [1990]": datetime(1990, 10, 1),
+    "Modern - Winter [2010]": datetime(2010, 1, 1),
+    "Modern - Spring [2010]": datetime(2010, 4, 1),
+    "Modern - Summer [2010]": datetime(2010, 6, 1),
+    "Modern - Fall [2010]": datetime(2010, 10, 1),
+    "Georgian War [2008]": datetime(2008, 8, 7),
+    "Syrian War [2011]": datetime(2011, 8, 7),
+}
+
+REWARDS = {
+    "power": 4, "warehouse": 2, "fuel": 2, "ammo": 2,
+    "farp": 1, "fob": 1, "factory": 10, "comms": 10, "oil": 10
+}
+
+# Base post-turn bonus value
+PLAYER_BUDGET_BASE = 20
+
+CARRIER_CAPABLE = [
+    FA_18C_hornet,
+    F_14B,
+    AV8BNA,
+    Su_33,
+
+    UH_1H,
+    Mi_8MT,
+    Ka_50,
+    AH_1W,
+    OH_58D,
+
+    SA342L,
+    SA342M,
+    SA342Minigun,
+    SA342Mistral,
+]
+
+LHA_CAPABLE = [
+    AV8BNA,
+
+    UH_1H,
+    Mi_8MT,
+    Ka_50,
+    AH_1W,
+    OH_58D,
+
+    SA342L,
+    SA342M,
+    SA342Minigun,
+    SA342Mistral
+]
+
 """
 ---------- END OF CONFIGURATION SECTION
 """
@@ -455,12 +802,31 @@ def unit_task(unit: UnitType) -> Task:
         if unit in units:
             return task
 
-    assert False
+    if unit in SAM_CONVERT:
+        return unit_task(SAM_CONVERT[unit])
 
+    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 UNIT_BY_COUNTRY[country_name]]
+    return [x for x in UNIT_BY_TASK[for_task] if x in FACTIONS[country_name]["units"]]
 
+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,
+        Infantry.Infantry_M4, Infantry.Infantry_M4, Infantry.Infantry_M4, Infantry.Infantry_M4, Infantry.Infantry_M4,
+        Infantry.Soldier_M249,
+        Infantry.Soldier_AK, Infantry.Soldier_AK, Infantry.Soldier_AK, Infantry.Soldier_AK, Infantry.Soldier_AK,
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Georgian_soldier_with_M4, Infantry.Georgian_soldier_with_M4, Infantry.Georgian_soldier_with_M4, Infantry.Georgian_soldier_with_M4,
+        Infantry.Infantry_Soldier_Rus, Infantry.Infantry_Soldier_Rus, Infantry.Infantry_Soldier_Rus, Infantry.Infantry_Soldier_Rus,
+        Infantry.Infantry_SMLE_No_4_Mk_1, Infantry.Infantry_SMLE_No_4_Mk_1, Infantry.Infantry_SMLE_No_4_Mk_1,
+        Infantry.Infantry_Mauser_98, Infantry.Infantry_Mauser_98, Infantry.Infantry_Mauser_98, Infantry.Infantry_Mauser_98,
+        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]["units"]]
 
 def unit_type_name(unit_type) -> str:
     return unit_type.id and unit_type.id or unit_type.name
@@ -473,6 +839,8 @@ def unit_type_from_name(name: str) -> UnitType:
         return plane_map[name]
     elif name in ship_map:
         return ship_map[name]
+    if name in helicopter_map:
+        return helicopter_map[name]
     else:
         return None
 
@@ -483,7 +851,7 @@ def unit_type_of(unit: Unit) -> UnitType:
     elif isinstance(unit, Ship):
         return ship_map[unit.type]
     else:
-        return unit.unit_type
+        return unit.type
 
 
 def task_name(task) -> str:
@@ -491,6 +859,8 @@ def task_name(task) -> str:
         return "AirDefence"
     elif task == Embarking:
         return "Transportation"
+    elif task == PinpointStrike:
+        return "Frontline units"
     else:
         return task.name
 
@@ -577,25 +947,39 @@ def unitdict_from(fd: AssignedUnitsDict) -> Dict:
     return {k: v1 for k, (v1, v2) in fd.items()}
 
 
+def country_id_from_name(name):
+    for k,v in country_dict.items():
+        if v.name == name:
+            return k
+    return -1
+
+
 def _validate_db():
     # check unit by task uniquity
     total_set = set()
     for t, unit_collection in UNIT_BY_TASK.items():
         for unit_type in set(unit_collection):
-            assert unit_type not in total_set, "{} is duplicate".format(unit_type)
+            assert unit_type not in total_set, "{} is duplicate for task {}".format(unit_type, t)
             total_set.add(unit_type)
 
     # check country allegiance
     for unit_type in total_set:
         did_find = False
-        for country_units_list in UNIT_BY_COUNTRY.values():
-            if unit_type in country_units_list:
+        for country_units_list in FACTIONS.values():
+            if unit_type in country_units_list["units"]:
                 did_find = True
-        assert did_find, "{} not in country list".format(unit_type)
+        print("WARN : {} not in country list".format(unit_type))
 
     # check prices
     for unit_type in total_set:
         assert unit_type in PRICES, "{} not in prices".format(unit_type)
 
-
 _validate_db()
+
+class DefaultLiveries:
+    class Default(Enum):
+        af_standard = ""
+
+OH_58D.Liveries = DefaultLiveries
+F_16C_50.Liveries = DefaultLiveries
+P_51D_30_NA.Liveries = DefaultLiveries

game/event/__init__.py

@@ -1,10 +1,2 @@
 from .event import *
 from .frontlineattack import *
-from .frontlinepatrol import *
-from .intercept import *
-from .baseattack import *
-from .navalintercept import *
-from .insurgentattack import *
-from .convoystrike import *
-from .infantrytransport import *
-from .strike import *

game/event/baseattack.py

@@ -1,98 +0,0 @@
-from game.operation.baseattack import BaseAttackOperation
-
-from .event import *
-from game.db import assigned_units_from
-
-
-class BaseAttackEvent(Event):
-    silent = True
-    BONUS_BASE = 15
-    STRENGTH_RECOVERY = 0.55
-
-    def __str__(self):
-        return "Base attack"
-
-    @property
-    def tasks(self):
-        return [CAP, CAS, PinpointStrike]
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAP:
-            return "Escort flight"
-        elif for_task == CAS:
-            return "CAS flight"
-        elif for_task == PinpointStrike:
-            return "Ground attack"
-
-    def is_successfull(self, debriefing: Debriefing):
-        alive_attackers = sum([v for k, v in debriefing.alive_units.get(self.attacker_name, {}).items() if db.unit_task(k) == PinpointStrike])
-        alive_defenders = sum([v for k, v in debriefing.alive_units.get(self.defender_name, {}).items() if db.unit_task(k) == PinpointStrike])
-        attackers_success = alive_attackers >= alive_defenders
-        if self.departure_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def commit(self, debriefing: Debriefing):
-        super(BaseAttackEvent, self).commit(debriefing)
-        if self.is_successfull(debriefing):
-            if self.departure_cp.captured:
-                self.to_cp.captured = True
-                self.to_cp.ground_objects = []
-                self.to_cp.base.filter_units(db.UNIT_BY_COUNTRY[self.attacker_name])
-
-            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
-        else:
-            if not self.departure_cp.captured:
-                self.to_cp.captured = False
-            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
-
-    def skip(self):
-        if not self.is_player_attacking and self.to_cp.captured:
-            self.to_cp.captured = False
-
-    def player_defending(self, flights: db.TaskForceDict):
-        assert CAP in flights and len(flights) == 1,  "Invalid scrambled flights"
-
-        cas = self.departure_cp.base.scramble_cas(self.game.settings.multiplier)
-        escort = self.departure_cp.base.scramble_sweep(self.game.settings.multiplier)
-        attackers = self.departure_cp.base.armor
-
-        op = BaseAttackOperation(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)
-
-        op.setup(cas=assigned_units_from(cas),
-                 escort=assigned_units_from(escort),
-                 intercept=flights[CAP],
-                 attack=attackers,
-                 defense=self.to_cp.base.armor,
-                 aa=self.to_cp.base.aa)
-
-        self.operation = op
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert CAP in flights and CAS in flights and PinpointStrike in flights and len(flights) == 3, "Invalid flights"
-
-        op = BaseAttackOperation(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)
-
-        defenders = self.to_cp.base.scramble_sweep(self.game.settings.multiplier)
-        defenders.update(self.to_cp.base.scramble_cas(self.game.settings.multiplier))
-
-        op.setup(cas=flights[CAS],
-                 escort=flights[CAP],
-                 attack=unitdict_from(flights[PinpointStrike]),
-                 intercept=assigned_units_from(defenders),
-                 defense=self.to_cp.base.armor,
-                 aa=self.to_cp.base.assemble_aa())
-
-        self.operation = op
-

game/event/convoystrike.py

@@ -1,83 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-
-from game import *
-from game.event import *
-from game.event.frontlineattack import FrontlineAttackEvent
-
-from .event import *
-from game.operation.convoystrike import ConvoyStrikeOperation
-
-TRANSPORT_COUNT = 4, 6
-DEFENDERS_AMOUNT_FACTOR = 4
-
-
-class ConvoyStrikeEvent(Event):
-    SUCCESS_FACTOR = 0.6
-    STRENGTH_INFLUENCE = 0.25
-
-    targets = None  # type: db.ArmorDict
-
-    @property
-    def threat_description(self):
-        return ""
-
-    @property
-    def tasks(self):
-        return [CAS]
-
-    @property
-    def global_cp_available(self) -> bool:
-        return True
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAS:
-            return "Strike flight"
-
-    def __str__(self):
-        return "Convoy Strike"
-
-    def skip(self):
-        self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def commit(self, debriefing: Debriefing):
-        super(ConvoyStrikeEvent, self).commit(debriefing)
-
-        if self.from_cp.captured:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def is_successfull(self, debriefing: Debriefing):
-        killed_units = sum([v for k, v in debriefing.destroyed_units.get(self.defender_name, {}).items() if db.unit_task(k) in [PinpointStrike, Reconnaissance]])
-        all_units = sum(self.targets.values())
-        attackers_success = (float(killed_units) / (all_units + 0.01)) > self.SUCCESS_FACTOR
-        if self.from_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert CAS in flights and len(flights) == 1, "Invalid flights"
-
-        convoy_unittype = db.find_unittype(Reconnaissance, self.defender_name)[0]
-        defense_unittype = db.find_unittype(PinpointStrike, self.defender_name)[0]
-
-        defenders_count = int(math.ceil(self.from_cp.base.strength * self.from_cp.importance * DEFENDERS_AMOUNT_FACTOR))
-        self.targets = {convoy_unittype: random.randrange(*TRANSPORT_COUNT),
-                        defense_unittype: defenders_count, }
-
-        op = ConvoyStrikeOperation(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)
-        op.setup(target=self.targets,
-                 strikegroup=flights[CAS])
-
-        self.operation = op

game/event/event.py

@@ -1,12 +1,14 @@
 import typing
 import logging
 
+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 *
+from game.infos.information import Information
 from theater import *
 from gen.environmentgen import EnvironmentSettings
 from gen.conflictgen import Conflict
@@ -15,10 +17,16 @@ from game.db import assigned_units_from, unitdict_from
 from userdata.debriefing import Debriefing
 from userdata import persistency
 
+import game.db as db
+
 DIFFICULTY_LOG_BASE = 1.1
 EVENT_DEPARTURE_MAX_DISTANCE = 340000
 
 
+MINOR_DEFEAT_INFLUENCE = 0.1
+DEFEAT_INFLUENCE = 0.3
+STRONG_DEFEAT_INFLUENCE = 0.5
+
 class Event:
     silent = False
     informational = False
@@ -47,11 +55,11 @@ class Event:
 
     @property
     def is_player_attacking(self) -> bool:
-        return self.attacker_name == self.game.player
+        return self.attacker_name == self.game.player_name
 
     @property
     def enemy_cp(self) -> ControlPoint:
-        if self.attacker_name == self.game.player:
+        if self.attacker_name == self.game.player_name:
             return self.to_cp
         else:
             return self.departure_cp
@@ -119,36 +127,189 @@ class Event:
         self.environment_settings = self.operation.environment_settings
 
     def generate_quick(self):
-        self.operation.is_awacs_enabled = self.is_awacs_enabled
-        self.operation.environment_settings = self.environment_settings
-
-        self.operation.prepare(self.game.theater.terrain, is_quick=True)
-        self.operation.generate()
-        self.operation.current_mission.save(persistency.mission_path_for("liberation_nextturn_quick.miz"))
+        pass
+        # TODO : This is not needed anymore. The player can start mission in flight from the flight planner if he want it to be quick.
+        # TODO : remove this method
+        #self.operation.is_awacs_enabled = self.is_awacs_enabled
+        #self.operation.environment_settings = self.environment_settings
+        #
+        #self.operation.prepare(self.game.theater.terrain, is_quick=True)
+        #self.operation.generate()
+        #self.operation.current_mission.save(persistency.mission_path_for("liberation_nextturn_quick.miz"))
 
     def commit(self, debriefing: Debriefing):
-        for country, losses in debriefing.destroyed_units.items():
-            if country == self.attacker_name:
-                cp = self.departure_cp
-            else:
-                cp = self.to_cp
 
-            logging.info("base {} commit losses {}".format(cp.base, losses))
-            cp.base.commit_losses(losses)
+        logging.info("Commiting mission results")
 
-        for object_identifier in debriefing.destroyed_objects:
+        # ------------------------------
+        # Destroyed aircrafts
+        cp_map = {cp.id: cp for cp in self.game.theater.controlpoints}
+        for destroyed_aircraft in debriefing.killed_aircrafts:
+            try:
+                cpid = int(destroyed_aircraft.split("|")[3])
+                type = db.unit_type_from_name(destroyed_aircraft.split("|")[4])
+                if cpid in cp_map.keys():
+                    cp = cp_map[cpid]
+                    if type in cp.base.aircraft.keys():
+                        logging.info("Aircraft destroyed : " + str(type))
+                        cp.base.aircraft[type] = max(0, cp.base.aircraft[type]-1)
+            except Exception as e:
+                print(e)
+
+        # ------------------------------
+        # Destroyed ground units
+        killed_unit_count_by_cp = {cp.id: 0 for cp in self.game.theater.controlpoints}
+        cp_map = {cp.id: cp for cp in self.game.theater.controlpoints}
+        for killed_ground_unit in debriefing.killed_ground_units:
+            try:
+                cpid = int(killed_ground_unit.split("|")[3])
+                type = db.unit_type_from_name(killed_ground_unit.split("|")[4])
+                if cpid in cp_map.keys():
+                    killed_unit_count_by_cp[cpid] = killed_unit_count_by_cp[cpid] + 1
+                    cp = cp_map[cpid]
+                    if type in cp.base.armor.keys():
+                        logging.info("Ground unit destroyed : " + str(type))
+                        cp.base.armor[type] = max(0, cp.base.armor[type] - 1)
+            except Exception as e:
+                print(e)
+
+        # ------------------------------
+        # Static ground objects
+        for destroyed_ground_unit_name in debriefing.killed_ground_units:
             for cp in self.game.theater.controlpoints:
                 if not cp.ground_objects:
                     continue
 
+                # -- Static ground objects
                 for i, ground_object in enumerate(cp.ground_objects):
                     if ground_object.is_dead:
                         continue
 
-                    if ground_object.matches_string_identifier(object_identifier):
+                    if ground_object.matches_string_identifier(destroyed_ground_unit_name):
                         logging.info("cp {} killing ground object {}".format(cp, ground_object.string_identifier))
                         cp.ground_objects[i].is_dead = True
 
+                # -- AA Site groups
+                for i, ground_object in enumerate(cp.ground_objects):
+                    if ground_object.dcs_identifier in ["AA", "CARRIER", "LHA"]:
+                        for g in ground_object.groups:
+                            for u in g.units:
+                                if u.name == destroyed_ground_unit_name:
+                                    g.units.remove(u)
+                        ucount = sum([len(g.units) for g in ground_object.groups])
+                        if ucount == 0:
+                            ground_object.is_dead = True
+
+        # ------------------------------
+        # Captured bases
+        if self.game.player_country in db.BLUEFOR_FACTIONS:
+            coalition = 2 # Value in DCS mission event for BLUE
+        else:
+            coalition = 1 # Value in DCS mission event for RED
+
+        for captured in debriefing.base_capture_events:
+            try:
+                id = int(captured.split("||")[0])
+                new_owner_coalition = int(captured.split("||")[1])
+
+                for cp in self.game.theater.controlpoints:
+                    if cp.id == id:
+                        if cp.captured and new_owner_coalition != coalition:
+                            cp.captured = False
+                            cp.base.aircraft = {}
+                            cp.base.armor = {}
+                            cp.base.aa = {}
+                            for g in cp.ground_objects:
+                                g.groups = []
+                            info = Information(cp.name + " lost !",
+                                               "The ennemy took control of " + cp.name + "\nShame on us !",
+                                               self.game.turn)
+                            self.game.informations.append(info)
+                        elif not(cp.captured) and new_owner_coalition == coalition:
+                            cp.captured = True
+                            cp.base.aircraft = {}
+                            cp.base.armor = {}
+                            cp.base.aa = {}
+                            for g in cp.ground_objects:
+                                g.groups = []
+                            info = Information(cp.name + " captured !",
+                                               "The ennemy took control of " + cp.name + "\nShame on us !",
+                                               self.game.turn)
+                            self.game.informations.append(info)
+            except Exception as e:
+                print(e)
+
+        # -----------------------------------
+        # Compute damage to bases
+        for cp in self.game.theater.player_points():
+            enemy_cps = [e for e in cp.connected_points if not e.captured]
+            for enemy_cp in enemy_cps:
+                print("Compute frontline progression for : " + cp.name + " to " + enemy_cp.name)
+
+                delta = 0
+                player_won = True
+                ally_casualties = killed_unit_count_by_cp[cp.id]
+                enemy_casualties = killed_unit_count_by_cp[enemy_cp.id]
+                ally_units_alive = cp.base.total_armor
+                enemy_units_alive = enemy_cp.base.total_armor
+
+                print(ally_units_alive)
+                print(enemy_units_alive)
+                print(ally_casualties)
+                print(enemy_casualties)
+
+                ratio = (1.0 + enemy_casualties) / (1.0 + ally_casualties)
+
+                if ally_units_alive == 0:
+                    player_won = False
+                    delta = STRONG_DEFEAT_INFLUENCE
+                elif enemy_units_alive == 0:
+                    player_won = True
+                    delta = STRONG_DEFEAT_INFLUENCE
+                elif cp.stances[enemy_cp.id] == CombatStance.RETREAT:
+                    player_won = False
+                    delta = STRONG_DEFEAT_INFLUENCE
+                else:
+                    if enemy_casualties > ally_casualties:
+                        player_won = True
+                        if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
+                            delta = STRONG_DEFEAT_INFLUENCE
+                        else:
+                            if ratio > 3:
+                                delta = STRONG_DEFEAT_INFLUENCE
+                            elif ratio < 1.5:
+                                delta = MINOR_DEFEAT_INFLUENCE
+                            else:
+                                delta = DEFEAT_INFLUENCE
+                    elif ally_casualties > enemy_casualties:
+                        player_won = False
+                        if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
+                            delta = STRONG_DEFEAT_INFLUENCE
+                        else:
+                            delta = STRONG_DEFEAT_INFLUENCE
+
+                    # No progress with defensive strategies
+                    if player_won and cp.stances[enemy_cp.id] in [CombatStance.DEFENSIVE, CombatStance.AMBUSH]:
+                        print("Defensive stance, progress is limited")
+                        delta = MINOR_DEFEAT_INFLUENCE
+
+                if player_won:
+                    print(cp.name + " won !  factor > " + str(delta))
+                    cp.base.affect_strength(delta)
+                    enemy_cp.base.affect_strength(-delta)
+                    info = Information("Frontline Report",
+                                       "Our ground forces from " + cp.name + " are making progress toward " + enemy_cp.name,
+                                       self.game.turn)
+                    self.game.informations.append(info)
+                else:
+                    print(cp.name + " lost !  factor > " + str(delta))
+                    enemy_cp.base.affect_strength(delta)
+                    cp.base.affect_strength(-delta)
+                    info = Information("Frontline Report",
+                                       "Our ground forces from " + cp.name + " are losing ground against the enemy forces from" + enemy_cp.name,
+                                       self.game.turn)
+                    self.game.informations.append(info)
+
     def skip(self):
         pass
 
@@ -175,4 +336,9 @@ class UnitsDeliveryEvent(Event):
             self.units[k] = self.units.get(k, 0) + v
 
     def skip(self):
+
+        for k, v in self.units.items():
+            info = Information("Ally Reinforcement", str(k.id) + " x " + str(v) + " at " + self.to_cp.name, self.game.turn)
+            self.game.informations.append(info)
+
         self.to_cp.base.commision_units(self.units)

game/event/frontlineattack.py

@@ -38,9 +38,20 @@ class FrontlineAttackEvent(Event):
         return "Frontline attack"
 
     def is_successfull(self, debriefing: Debriefing):
-        alive_attackers = sum([v for k, v in debriefing.alive_units.get(self.attacker_name, {}).items() if db.unit_task(k) == PinpointStrike])
-        alive_defenders = sum([v for k, v in debriefing.alive_units.get(self.defender_name, {}).items() if db.unit_task(k) == PinpointStrike])
-        attackers_success = (float(alive_attackers) / (alive_defenders + 0.01)) > self.SUCCESS_FACTOR
+
+        if self.game.player_name == self.attacker_name:
+            attacker_country = self.game.player_country
+            defender_country = self.game.enemy_country
+        else:
+            attacker_country = self.game.enemy_country
+            defender_country = self.game.player_country
+
+        # TODO : Rework
+        #alive_attackers = sum([v for k, v in debriefing.alive_units.get(attacker_country, {}).items() if db.unit_task(k) == PinpointStrike])
+        #alive_defenders = sum([v for k, v in debriefing.alive_units.get(defender_country, {}).items() if db.unit_task(k) == PinpointStrike])
+        #attackers_success = (float(alive_attackers) / (alive_defenders + 0.01)) > self.SUCCESS_FACTOR
+        attackers_success = True
+
         if self.from_cp.captured:
             return attackers_success
         else:
@@ -49,23 +60,12 @@ class FrontlineAttackEvent(Event):
     def commit(self, debriefing: Debriefing):
         super(FrontlineAttackEvent, self).commit(debriefing)
 
-        if self.from_cp.captured:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(+self.STRENGTH_INFLUENCE)
-        else:
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
     def skip(self):
         if self.to_cp.captured:
             self.to_cp.base.affect_strength(-0.1)
 
     def player_attacking(self, flights: db.TaskForceDict):
-        assert CAS in flights and CAP in flights and len(flights) == 2, "Invalid flights"
+        # assert CAS in flights and CAP in flights and len(flights) == 2, "Invalid flights"
 
         op = FrontlineAttackOperation(game=self.game,
                                       attacker_name=self.attacker_name,
@@ -86,7 +86,7 @@ class FrontlineAttackEvent(Event):
         self.operation = op
 
     def player_defending(self, flights: db.TaskForceDict):
-        assert CAP in flights and len(flights) == 1, "Invalid flights"
+        # assert CAP in flights and len(flights) == 1, "Invalid flights"
 
         op = FrontlineAttackOperation(game=self.game,
                                       attacker_name=self.attacker_name,

game/event/frontlinepatrol.py

@@ -1,78 +0,0 @@
-from game.event import *
-from game.operation.frontlinepatrol import FrontlinePatrolOperation
-from userdata.debriefing import Debriefing
-
-
-class FrontlinePatrolEvent(Event):
-    ESCORT_FACTOR = 0.5
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_FACTOR = 0.8
-
-    cas = None  # type: db.PlaneDict
-    escort = None  # type: db.PlaneDict
-
-    @property
-    def threat_description(self):
-        return "{} aircraft + ? CAS".format(self.to_cp.base.scramble_count(self.game.settings.multiplier * self.ESCORT_FACTOR, CAP))
-
-    @property
-    def tasks(self):
-        return [CAP]
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAP:
-            return "CAP flight"
-        elif for_task == PinpointStrike:
-            return "Ground attack"
-
-    def __str__(self):
-        return "Frontline CAP"
-
-    def is_successfull(self, debriefing: Debriefing):
-        alive_attackers = sum([v for k, v in debriefing.alive_units[self.attacker_name].items() if db.unit_task(k) == PinpointStrike])
-        alive_defenders = sum([v for k, v in debriefing.alive_units[self.defender_name].items() if db.unit_task(k) == PinpointStrike])
-        attackers_success = (float(alive_attackers) / (alive_defenders + 0.01)) >= self.SUCCESS_FACTOR
-        if self.from_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def commit(self, debriefing: Debriefing):
-        super(FrontlinePatrolEvent, self).commit(debriefing)
-
-        if self.from_cp.captured:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(+self.STRENGTH_INFLUENCE)
-        else:
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        pass
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert CAP in flights and len(flights) == 1, "Invalid flights"
-
-        self.cas = self.to_cp.base.scramble_cas(self.game.settings.multiplier)
-        self.escort = self.to_cp.base.scramble_sweep(self.game.settings.multiplier * self.ESCORT_FACTOR)
-
-        op = FrontlinePatrolOperation(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)
-
-        defenders = self.to_cp.base.assemble_attack()
-        attackers = db.unitdict_restrict_count(self.from_cp.base.assemble_attack(), sum(defenders.values()))
-        op.setup(cas=assigned_units_from(self.cas),
-                 escort=assigned_units_from(self.escort),
-                 interceptors=flights[CAP],
-                 armor_attackers=attackers,
-                 armor_defenders=defenders)
-
-        self.operation = op

game/event/infantrytransport.py

@@ -1,56 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-from dcs.vehicles import *
-
-from game import db
-from game.operation.infantrytransport import InfantryTransportOperation
-from theater.conflicttheater import *
-from userdata.debriefing import Debriefing
-
-from .event import *
-
-
-class InfantryTransportEvent(Event):
-    STRENGTH_INFLUENCE = 0.3
-
-    def __str__(self):
-        return "Frontline transport troops"
-
-    @property
-    def tasks(self):
-        return [Embarking]
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == Embarking:
-            return "Transport flight"
-
-    def is_successfull(self, debriefing: Debriefing):
-        return True
-
-    def commit(self, debriefing: Debriefing):
-        super(InfantryTransportEvent, self).commit(debriefing)
-
-        if self.is_successfull(debriefing):
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            self.departure_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert Embarking in flights and len(flights) == 1, "Invalid flights"
-
-        op = InfantryTransportOperation(
-            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
-        )
-
-        air_defense = db.find_unittype(AirDefence, self.defender_name)[0]
-        op.setup(transport=flights[Embarking],
-                 aa={air_defense: 2})
-
-        self.operation = op

game/event/insurgentattack.py

@@ -1,65 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-
-from game import *
-from game.event import *
-from game.event.frontlineattack import FrontlineAttackEvent
-from game.operation.insurgentattack import InsurgentAttackOperation
-
-from .event import *
-
-
-class InsurgentAttackEvent(Event):
-    SUCCESS_FACTOR = 0.7
-    TARGET_VARIETY = 2
-    TARGET_AMOUNT_FACTOR = 0.5
-    STRENGTH_INFLUENCE = 0.1
-
-    @property
-    def threat_description(self):
-        return ""
-
-    @property
-    def tasks(self):
-        return [CAS]
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAS:
-            return "Ground intercept flight"
-
-    def __str__(self):
-        return "Destroy insurgents"
-
-    def skip(self):
-        self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def is_successfull(self, debriefing: Debriefing):
-        killed_units = sum([v for k, v in debriefing.destroyed_units[self.attacker_name].items() if db.unit_task(k) == PinpointStrike])
-        all_units = sum(self.targets.values())
-        attackers_success = (float(killed_units) / (all_units + 0.01)) > self.SUCCESS_FACTOR
-        if self.from_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def player_defending(self, flights: db.TaskForceDict):
-        assert CAS in flights and len(flights) == 1, "Invalid flights"
-
-        suitable_unittypes = db.find_unittype(Reconnaissance, self.attacker_name)
-        random.shuffle(suitable_unittypes)
-        unittypes = suitable_unittypes[:self.TARGET_VARIETY]
-        typecount = max(math.floor(self.difficulty * self.TARGET_AMOUNT_FACTOR), 1)
-        self.targets = {unittype: typecount for unittype in unittypes}
-
-        op = InsurgentAttackOperation(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)
-        op.setup(target=self.targets,
-                 strikegroup=flights[CAS])
-
-        self.operation = op

game/event/intercept.py

@@ -1,118 +0,0 @@
-from game.operation.intercept import InterceptOperation
-
-from .event import *
-
-
-class InterceptEvent(Event):
-    STRENGTH_INFLUENCE = 0.3
-    GLOBAL_STRENGTH_INFLUENCE = 0.3
-    AIRDEFENSE_COUNT = 3
-
-    transport_unit = None  # type: FlyingType
-
-    def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str,
-                 defender_name: str):
-        super().__init__(game, from_cp, target_cp, location, attacker_name, defender_name)
-        self.location = Conflict.intercept_position(self.from_cp, self.to_cp)
-
-    def __str__(self):
-        return "Air Intercept"
-
-    @property
-    def tasks(self):
-        return [CAP]
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAP:
-            if self.is_player_attacking:
-                return "Intercept flight"
-            else:
-                return "Escort flight"
-
-    def _enemy_scramble_multiplier(self) -> float:
-        is_global = self.departure_cp.is_global or self.to_cp.is_global
-        return self.game.settings.multiplier * is_global and 0.5 or 1
-
-    @property
-    def threat_description(self):
-        return "{} aircraft".format(self.enemy_cp.base.scramble_count(self._enemy_scramble_multiplier(), CAP))
-
-    @property
-    def global_cp_available(self) -> bool:
-        return True
-
-    def is_successfull(self, debriefing: Debriefing):
-        units_destroyed = debriefing.destroyed_units.get(self.defender_name, {}).get(self.transport_unit, 0)
-        if self.from_cp.captured:
-            return units_destroyed > 0
-        else:
-            return units_destroyed == 0
-
-    def commit(self, debriefing: Debriefing):
-        super(InterceptEvent, self).commit(debriefing)
-
-        if self.attacker_name == self.game.player:
-            if self.is_successfull(debriefing):
-                for _, cp in self.game.theater.conflicts(True):
-                    cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            # enemy attacking
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert CAP in flights and len(flights) == 1, "Invalid flights"
-
-        escort = self.to_cp.base.scramble_sweep(self._enemy_scramble_multiplier())
-
-        self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
-        assert self.transport_unit is not None
-
-        airdefense_unit = db.find_unittype(AirDefence, self.defender_name)[-1]
-        op = InterceptOperation(game=self.game,
-                                attacker_name=self.attacker_name,
-                                defender_name=self.defender_name,
-                                from_cp=self.from_cp,
-                                departure_cp=self.departure_cp,
-                                to_cp=self.to_cp)
-
-        op.setup(location=self.location,
-                 escort=assigned_units_from(escort),
-                 transport={self.transport_unit: 1},
-                 airdefense={airdefense_unit: self.AIRDEFENSE_COUNT},
-                 interceptors=flights[CAP])
-
-        self.operation = op
-
-    def player_defending(self, flights: db.TaskForceDict):
-        assert CAP in flights and len(flights) == 1, "Invalid flights"
-
-        interceptors = self.from_cp.base.scramble_interceptors(self.game.settings.multiplier)
-
-        self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
-        assert self.transport_unit is not None
-
-        op = InterceptOperation(game=self.game,
-                                attacker_name=self.attacker_name,
-                                defender_name=self.defender_name,
-                                from_cp=self.from_cp,
-                                departure_cp=self.departure_cp,
-                                to_cp=self.to_cp)
-
-        op.setup(location=self.location,
-                 escort=flights[CAP],
-                 transport={self.transport_unit: 1},
-                 interceptors=assigned_units_from(interceptors),
-                 airdefense={})
-
-        self.operation = op
-
-

game/event/navalintercept.py

@@ -1,124 +0,0 @@
-from game.operation.navalintercept import NavalInterceptionOperation
-
-from .event import *
-
-
-class NavalInterceptEvent(Event):
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_RATE = 0.5
-
-    targets = None  # type: db.ShipDict
-
-    def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str,
-                 defender_name: str):
-        super().__init__(game, from_cp, target_cp, location, attacker_name, defender_name)
-        self.location = Conflict.naval_intercept_position(from_cp, target_cp, game.theater)
-
-    def _targets_count(self) -> int:
-        from gen.conflictgen import IMPORTANCE_LOW
-        factor = (self.to_cp.importance - IMPORTANCE_LOW + 0.1) * 20
-        return max(int(factor), 1)
-
-    def __str__(self) -> str:
-        return "Naval intercept"
-
-    @property
-    def tasks(self):
-        if self.is_player_attacking:
-            return [CAS]
-        else:
-            return [CAP]
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAS:
-            return "Naval intercept flight"
-        elif for_task == CAP:
-            return "CAP flight"
-
-    @property
-    def threat_description(self):
-        s = "{} ship(s)".format(self._targets_count())
-        if not self.departure_cp.captured:
-            s += ", {} aircraft".format(self.departure_cp.base.scramble_count(self.game.settings.multiplier))
-        return s
-
-    @property
-    def global_cp_available(self) -> bool:
-        return True
-
-    def is_successfull(self, debriefing: Debriefing):
-        total_targets = sum(self.targets.values())
-        destroyed_targets = 0
-        for unit, count in debriefing.destroyed_units.get(self.defender_name, {}).items():
-            if unit in self.targets:
-                destroyed_targets += count
-
-        if self.departure_cp.captured:
-            return math.ceil(float(destroyed_targets) / total_targets) > self.SUCCESS_RATE
-        else:
-            return math.ceil(float(destroyed_targets) / total_targets) < self.SUCCESS_RATE
-
-    def commit(self, debriefing: Debriefing):
-        super(NavalInterceptEvent, self).commit(debriefing)
-
-        if self.attacker_name == self.game.player:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.departure_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            # enemy attacking
-            if self.is_successfull(debriefing):
-                self.departure_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert CAS in flights and len(flights) == 1, "Invalid flights"
-
-        self.targets = {
-            random.choice(db.find_unittype(CargoTransportation, self.defender_name)): self._targets_count(),
-        }
-
-        op = NavalInterceptionOperation(
-            self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            from_cp=self.from_cp,
-            departure_cp=self.departure_cp,
-            to_cp=self.to_cp
-        )
-
-        op.setup(location=self.location,
-                 strikegroup=flights[CAS],
-                 interceptors={},
-                 targets=self.targets)
-
-        self.operation = op
-
-    def player_defending(self, flights: db.TaskForceDict):
-        assert CAP in flights and len(flights) == 1, "Invalid flights"
-
-        self.targets = {
-            random.choice(db.find_unittype(CargoTransportation, self.defender_name)): self._targets_count(),
-        }
-
-        op = NavalInterceptionOperation(
-            self.game,
-            attacker_name=self.attacker_name,
-            defender_name=self.defender_name,
-            from_cp=self.from_cp,
-            departure_cp=self.departure_cp,
-            to_cp=self.to_cp
-        )
-
-        strikegroup = self.departure_cp.base.scramble_cas(self.game.settings.multiplier)
-        op.setup(strikegroup=assigned_units_from(strikegroup),
-                 interceptors=flights[CAP],
-                 targets=self.targets)
-
-        self.operation = op

game/event/strike.py

@@ -1,73 +0,0 @@
-from game.operation.strike import StrikeOperation
-
-from .event import *
-
-
-class StrikeEvent(Event):
-    STRENGTH_INFLUENCE = 0.0
-    SINGLE_OBJECT_STRENGTH_INFLUENCE = 0.05
-
-    def __str__(self):
-        return "Strike / SEAD"
-
-    def is_successfull(self, debriefing: Debriefing):
-        return True
-
-    @property
-    def threat_description(self):
-        return "{} aircraft + AA".format(self.to_cp.base.scramble_count(self.game.settings.multiplier, CAP))
-
-    @property
-    def tasks(self):
-        if self.is_player_attacking:
-            return [CAP, CAS, SEAD]
-        else:
-            return [CAP]
-
-    @property
-    def ai_banned_tasks(self):
-        return [CAS]
-
-    @property
-    def player_banned_tasks(self):
-        return [SEAD]
-
-    @property
-    def global_cp_available(self) -> bool:
-        return True
-
-    def flight_name(self, for_task: typing.Type[Task]) -> str:
-        if for_task == CAP:
-            if self.is_player_attacking:
-                return "Escort flight"
-            else:
-                return "CAP flight"
-        elif for_task == SEAD:
-            return "SEAD flight"
-        elif for_task == CAS:
-            return "Strike flight"
-
-    def commit(self, debriefing: Debriefing):
-        super(StrikeEvent, self).commit(debriefing)
-
-        self.to_cp.base.affect_strength(-self.SINGLE_OBJECT_STRENGTH_INFLUENCE * len(debriefing.destroyed_objects))
-
-    def player_attacking(self, flights: db.TaskForceDict):
-        assert CAP in flights and CAS in flights and SEAD in flights and len(flights) == 3, "Invalid flights"
-
-        op = StrikeOperation(
-            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
-        )
-
-        interceptors = self.to_cp.base.scramble_interceptors(self.game.settings.multiplier)
-        op.setup(strikegroup=flights[CAS],
-                 sead=flights[SEAD],
-                 escort=flights[CAP],
-                 interceptors=assigned_units_from(interceptors))
-
-        self.operation = op

game/factions/china_2000.py

@@ -0,0 +1,63 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+China_2000 = {
+    "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,
+
+        A_50,
+
+        Mi_8MT,
+
+        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.Soldier_AK,
+        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,
+    ], "carrier_names": [
+        "001 Liaoning",
+        "002 Shandong",
+    ]
+}

game/factions/france_1995.py

@@ -0,0 +1,44 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+France_1995 = {
+    "country": "France",
+    "side": "blue",
+    "units": [
+        M_2000C,
+        Mirage_2000_5,
+
+        KC_135,
+        S_3B_Tanker,
+        C_130,
+        E_3A,
+
+        SA342M,
+        SA342L,
+
+        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
+    ]
+}

game/factions/france_2005.py

@@ -0,0 +1,59 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+France_2005 = {
+    "country": "France",
+    "side": "blue",
+    "units":[
+        M_2000C,
+        Mirage_2000_5,
+        FA_18C_hornet, # Standing as Rafale M
+
+        KC_135,
+        S_3B_Tanker,
+        C_130,
+        E_3A,
+
+        SA342M,
+        SA342L,
+
+        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": [
+        "R91 Charles de Gaulle",
+    ], "lhanames": [
+        "L9013 Mistral",
+        "L9014 Tonerre",
+        "L9015 Dixmude"
+    ]
+}

game/factions/germany_1944.py

@@ -0,0 +1,28 @@
+from dcs.planes import *
+from dcs.vehicles import *
+
+Germany_1944 = {
+    "country": "Third Reich",
+    "side": "red",
+    "units": [
+
+        FW_190A8,
+        FW_190D9,
+        Bf_109K_4,
+
+        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,
+
+        Unarmed.Sd_Kfz_2,
+        Unarmed.Sd_Kfz_7,
+        Unarmed.Kübelwagen_82,
+
+        Infantry.Infantry_Mauser_98,
+
+        AirDefence.AAA_Flak_36,
+    ]
+}

game/factions/germany_1990.py

@@ -0,0 +1,43 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Germany_1990 = {
+    "country": "Germany",
+    "side": "blue",
+    "units":[
+        MiG_29G,
+        Tornado_IDS,
+        F_4E,
+
+        KC_135,
+        S_3B_Tanker,
+        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,
+    ]
+}

game/factions/india_2010.py

@@ -0,0 +1,53 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+India_2010 = {
+    "country": "India",
+    "side": "blue",
+    "units": [
+        Mirage_2000_5,
+        M_2000C,
+        MiG_27K,
+        MiG_21Bis,
+        MiG_29S,
+        Su_30,
+
+        KC_135,
+        S_3B_Tanker,
+        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"
+    ]
+}

game/factions/insurgent.py

@@ -0,0 +1,25 @@
+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,
+
+        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
+    ]
+}

game/factions/iran_2015.py

@@ -0,0 +1,56 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters 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
+    ]
+}

game/factions/israel_2000.py

@@ -0,0 +1,37 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Israel_2000 = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        F_16C_50,
+        F_15C,
+        F_4E,
+
+        KC_135,
+        S_3B_Tanker,
+        C_130,
+        E_3A,
+
+        AH_1W,
+        AH_64D,
+
+        Armor.MBT_Merkava_Mk__4,
+        Armor.APC_M113,
+
+        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
+    ]
+}

game/factions/italy_1990.py

@@ -0,0 +1,46 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters 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,
+    ], "lha_names": [
+        "Giuseppe Garibaldi",
+        "Cavour",
+    ]
+}

game/factions/libya_2011.py

@@ -0,0 +1,48 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Lybia_2011 = {
+    "country": "Russia",
+    "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.ARV_MTLB_U_BOMAN,
+        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,
+    ]
+}

game/factions/netherlands_1990.py

@@ -0,0 +1,36 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Netherlands_1990 = {
+    "country": "The Netherlands",
+    "side": "blue",
+    "units": [
+        F_16C_50,
+        F_5E_3,
+
+        KC_135,
+        S_3B_Tanker,
+        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
+    ]
+}

game/factions/north_korea_2000.py

@@ -0,0 +1,50 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters 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
+    ]
+}

game/factions/pakistan_2015.py

@@ -0,0 +1,38 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters 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
+    ]
+}

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.ARV_MTLB_U_BOMAN,
+        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,53 @@
+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
+    ]
+}

game/factions/russia_1975.py

@@ -0,0 +1,69 @@
+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,
+    ]
+}

game/factions/russia_1990.py

@@ -0,0 +1,68 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Russia_1990 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+
+        MiG_23MLD,
+        MiG_25PD,
+        MiG_29A,
+        MiG_29S,
+        MiG_31,
+        Su_27,
+
+        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.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
+    ], "aircraft_carrier": [
+        CV_1143_5_Admiral_Kuznetsov,
+    ], "destroyer": [
+        FF_1135M_Rezky,
+    ], "cruiser": [
+        FSG_1241_1MP_Molniya,
+    ]
+}

game/factions/russia_2010.py

@@ -0,0 +1,67 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Russia_2010 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+        AJS37,
+        MiG_23MLD,
+        Su_25,
+        Su_27,
+        Su_33,
+        MiG_29S,
+
+        Su_25T,
+        Su_34,
+        Su_24M,
+        L_39ZA,
+
+        IL_76MD,
+        IL_78M,
+        An_26B,
+        An_30M,
+        Yak_40,
+        A_50,
+
+        Ka_50,
+        Mi_8MT,
+
+        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,
+
+        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,
+    ], "destroyer": [
+        FF_1135M_Rezky,
+    ], "cruiser": [
+        FSG_1241_1MP_Molniya,
+    ]
+}

game/factions/spain_1990.py

@@ -0,0 +1,48 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+
+Spain_1990 = {
+    "country": "Spain",
+    "side": "blue",
+    "units": [
+        FA_18C_hornet,
+        AV8BNA,
+        F_5E_3,
+        C_101CC,
+
+        KC_135,
+        S_3B_Tanker,
+        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",
+    ]
+}

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_LN_M192,
+
+        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
+    ]
+}

game/factions/turkey_2005.py

@@ -0,0 +1,40 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+Turkey_2005 = {
+    "country": "Turkey",
+    "side": "blue",
+    "units":[
+        F_16C_50,
+        F_4E,
+
+        KC_135,
+        S_3B_Tanker,
+        C_130,
+        E_3A,
+
+        UH_1H,
+        OH_58D,
+        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
+    ]
+}

game/factions/uae_2005.py

@@ -0,0 +1,34 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+UAE_2005 = {
+    "country": "United Arab Emirates",
+    "side": "blue",
+    "units":[
+        M_2000C,
+        Mirage_2000_5,
+        F_16C_50,
+
+        KC_135,
+        S_3B_Tanker,
+        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,
+    ]
+}

game/factions/uk_1990.py

@@ -0,0 +1,50 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+UnitedKingdom_1990 = {
+    "country": "UK",
+    "side": "blue",
+    "units":[
+        AV8BNA, # Standing as BAE Harrier 2
+        Tornado_GR4,
+        F_4E,
+
+        KC_135,
+        S_3B_Tanker,
+        C_130,
+        E_3A,
+
+        SA342L,
+        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,
+    ], "lha_names": [
+        "HMS Invincible",
+        "HMS Illustrious",
+        "HMS Ark Royal",
+    ]
+}

game/factions/ukraine_2010.py

@@ -0,0 +1,51 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters 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
+    ]
+}

game/factions/usa_1944.py

@@ -0,0 +1,30 @@
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+USA_1944 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        P_51D,
+        P_51D_30_NA,
+        SpitfireLFMkIX,
+        SpitfireLFMkIXCW,
+
+        Armor.MT_M4_Sherman,
+        Armor.MT_M4A4_Sherman_Firefly,
+        Armor.M30_Cargo_Carrier,
+        Armor.APC_M2A1,
+        Armor.CT_Cromwell_IV,
+        Artillery.M12_GMC,
+
+        Infantry.Infantry_M1_Garand,
+
+        LS_Samuel_Chase,
+        LST_Mk_II,
+        LCVP__Higgins_boat,
+
+        Unarmed.CCKW_353,
+        AirDefence.AAA_Bofors_40mm,
+    ]
+}

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,
+        S_3B_Tanker,
+        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,
+        S_3B_Tanker,
+        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,40 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+USA_1965 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+
+        F_5E_3,
+        F_4E,
+
+        KC_135,
+        S_3B_Tanker,
+        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
+    ]
+}

game/factions/usa_1990.py

@@ -0,0 +1,62 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+USA_1990 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        F_15C,
+        F_14B,
+        FA_18C_hornet,
+
+        A_10A,
+        AV8BNA,
+
+        B_1B,
+
+        KC_135,
+        S_3B_Tanker,
+        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,
+    ], "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"
+    ]
+}

game/factions/usa_2005.py

@@ -0,0 +1,69 @@
+from dcs.vehicles import *
+from dcs.ships import *
+from dcs.planes import *
+from dcs.helicopters import *
+
+USA_2005 = {
+    "country": "USA",
+    "side": "blue",
+    "units": [
+        F_15C,
+        F_14B,
+        FA_18C_hornet,
+        F_16C_50,
+        JF_17,
+
+        A_10C,
+        AV8BNA,
+
+        KC_135,
+        S_3B_Tanker,
+        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": [
+        Oliver_Hazzard_Perry_class,
+    ], "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"
+    ]
+}

game/game.py

@@ -6,13 +6,19 @@ import math
 from dcs.task import *
 from dcs.vehicles import *
 
+from game.db import REWARDS, PLAYER_BUDGET_BASE
+from game.game_stats import GameStats
+from game.infos.information import Information
 from gen.conflictgen import Conflict
+from gen.flights.ai_flight_planner import FlightPlanner
+from gen.ground_forces.ai_ground_planner import GroundPlanner
 from userdata.debriefing import Debriefing
 from theater import *
 
 from . import db
 from .settings import Settings
 from .event import *
+from datetime import datetime, timedelta
 
 COMMISION_UNIT_VARIETY = 4
 COMMISION_LIMITS_SCALE = 1.5
@@ -20,7 +26,7 @@ COMMISION_LIMITS_FACTORS = {
     PinpointStrike: 10,
     CAS: 5,
     CAP: 8,
-    AirDefence: 1,
+    AirDefence: 8,
 }
 
 COMMISION_AMOUNTS_SCALE = 1.5
@@ -28,46 +34,13 @@ COMMISION_AMOUNTS_FACTORS = {
     PinpointStrike: 3,
     CAS: 1,
     CAP: 2,
-    AirDefence: 0.3,
+    AirDefence: 0.8,
 }
 
 PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE = 30
 PLAYER_INTERCEPT_GLOBAL_PROBABILITY_LOG = 2
 PLAYER_BASEATTACK_THRESHOLD = 0.4
 
-"""
-Various events probabilities. First key is player probabilty, second is enemy probability.
-For the enemy events, only 1 event of each type could be generated for a turn.
-
-Events:
-* BaseAttackEvent - capture base
-* InterceptEvent - air intercept
-* FrontlineAttackEvent - frontline attack
-* NavalInterceptEvent - naval intercept
-* StrikeEvent - strike event
-* InfantryTransportEvent - helicopter infantry transport
-"""
-EVENT_PROBABILITIES = {
-    # events always present; only for the player
-    FrontlineAttackEvent: [100, 9],
-    #FrontlinePatrolEvent: [100, 0],
-    StrikeEvent: [100, 0],
-
-    # events randomly present; only for the player
-    #InfantryTransportEvent: [25, 0],
-    ConvoyStrikeEvent: [25, 0],
-
-    # events conditionally present; for both enemy and player
-    BaseAttackEvent: [100, 9],
-
-    # events randomly present; for both enemy and player
-    InterceptEvent: [25, 9],
-    NavalInterceptEvent: [25, 9],
-
-    # events randomly present; only for the enemy
-    InsurgentAttackEvent: [0, 6],
-}
-
 # amount of strength player bases recover for the turn
 PLAYER_BASE_STRENGTH_RECOVERY = 0.2
 
@@ -78,9 +51,8 @@ ENEMY_BASE_STRENGTH_RECOVERY = 0.05
 AWACS_BUDGET_COST = 4
 
 # Initial budget value
-PLAYER_BUDGET_INITIAL = 170
-# Base post-turn bonus value
-PLAYER_BUDGET_BASE = 14
+PLAYER_BUDGET_INITIAL = 650
+
 # Bonus multiplier logarithm base
 PLAYER_BUDGET_IMPORTANCE_LOG = 2
 
@@ -91,13 +63,28 @@ class Game:
     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
 
-    def __init__(self, player_name: str, enemy_name: str, theater: ConflictTheater):
+    current_unit_id = 0
+    current_group_id = 0
+
+    def __init__(self, player_name: str, enemy_name: str, theater: ConflictTheater, start_date: datetime):
         self.settings = Settings()
         self.events = []
         self.theater = theater
-        self.player = player_name
-        self.enemy = enemy_name
+        self.player_name = player_name
+        self.player_country = db.FACTIONS[player_name]["country"]
+        self.enemy_name = enemy_name
+        self.enemy_country = db.FACTIONS[enemy_name]["country"]
+        self.turn = 0
+        self.date = datetime(start_date.year, start_date.month, start_date.day)
+        self.game_stats = GameStats()
+        self.game_stats.update(self)
+        self.planners = {}
+        self.ground_planners = {}
+        self.informations = []
+        self.informations.append(Information("Game Start", "-" * 40, 0))
 
     def _roll(self, prob, mult):
         if self.settings.version == "dev":
@@ -107,117 +94,48 @@ class Game:
             return random.randint(1, 100) <= prob * mult
 
     def _generate_player_event(self, event_class, player_cp, enemy_cp):
-        if event_class == NavalInterceptEvent and enemy_cp.radials == LAND:
-            # skip naval events for non-coastal CPs
-            return
-
-        if event_class == BaseAttackEvent and enemy_cp.base.strength > PLAYER_BASEATTACK_THRESHOLD and self.settings.version != "dev":
-            # skip base attack events for CPs yet too strong
-            return
-
-        if event_class == StrikeEvent and not enemy_cp.ground_objects:
-            # skip strikes in case of no targets
-            return
-
-        self.events.append(event_class(self, player_cp, enemy_cp, enemy_cp.position, self.player, self.enemy))
-
-    def _generate_enemy_event(self, event_class, player_cp, enemy_cp):
-        if event_class in [type(x) for x in self.events if not self.is_player_attack(x)]:
-            # skip already generated enemy event types
-            return
-
-        if player_cp in self.ignored_cps:
-            # skip attacks against ignored CPs (for example just captured ones)
-            return
-
-        if enemy_cp.base.total_planes == 0:
-            # skip event if there's no planes on the base
-            return
-
-        if player_cp.is_global:
-            # skip carriers
-            return
-
-        if event_class == NavalInterceptEvent:
-            if player_cp.radials == LAND:
-                # skip naval events for non-coastal CPs
-                return
-        elif event_class == StrikeEvent:
-            if not player_cp.ground_objects:
-                # skip strikes if there's no ground objects
-                return
-        elif event_class == BaseAttackEvent:
-            if BaseAttackEvent in [type(x) for x in self.events]:
-                # skip base attack event if there's another one going on
-                return
-
-            if enemy_cp.base.total_armor == 0:
-                # skip base attack if there's no armor
-                return
-
-            if player_cp.base.strength > PLAYER_BASEATTACK_THRESHOLD:
-                # skip base attack if strength is too high
-                return
-
-        self.events.append(event_class(self, enemy_cp, player_cp, player_cp.position, self.enemy, self.player))
+        self.events.append(event_class(self, player_cp, enemy_cp, enemy_cp.position, self.player_name, self.enemy_name))
 
     def _generate_events(self):
-        strikes_generated_for = set()
-        base_attack_generated_for = set()
-
         for player_cp, enemy_cp in self.theater.conflicts(True):
-            for event_class, (player_probability, enemy_probability) in EVENT_PROBABILITIES.items():
-                if event_class in [FrontlineAttackEvent, FrontlinePatrolEvent, InfantryTransportEvent, ConvoyStrikeEvent]:
-                    # skip events requiring frontline
-                    if not Conflict.has_frontline_between(player_cp, enemy_cp):
-                        continue
-
-                # don't generate multiple 100% events from each attack direction
-                if event_class is StrikeEvent:
-                    if enemy_cp in strikes_generated_for:
-                        continue
-                if event_class is BaseAttackEvent:
-                    if enemy_cp in base_attack_generated_for:
-                        continue
-
-                if player_probability == 100 or player_probability > 0 and self._roll(player_probability, player_cp.base.strength):
-                    self._generate_player_event(event_class, player_cp, enemy_cp)
-                    if event_class is StrikeEvent:
-                        strikes_generated_for.add(enemy_cp)
-                    if event_class is BaseAttackEvent:
-                        base_attack_generated_for.add(enemy_cp)
-
-                if enemy_probability == 100 or  enemy_probability > 0 and self._roll(enemy_probability, enemy_cp.base.strength):
-                    self._generate_enemy_event(event_class, player_cp, enemy_cp)
+            self._generate_player_event(FrontlineAttackEvent, player_cp, enemy_cp)
 
     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:
-            return [x for x in db.find_unittype(AirDefence, self.enemy) if x not in db.SAM_BAN]
+            return [x for x in db.find_unittype(AirDefence, self.enemy_name) if x not in db.SAM_BAN]
         else:
-            return db.choose_units(for_task, importance_factor, COMMISION_UNIT_VARIETY, self.enemy)
+            return db.choose_units(for_task, importance_factor, COMMISION_UNIT_VARIETY, self.enemy_name)
 
     def _commision_units(self, cp: ControlPoint):
-        for for_task in [PinpointStrike, CAS, CAP, AirDefence]:
-            limit = COMMISION_LIMITS_FACTORS[for_task] * math.pow(cp.importance, COMMISION_LIMITS_SCALE) * self.settings.multiplier
+        for for_task in [CAS, CAP, AirDefence]:
+            limit = COMMISION_LIMITS_FACTORS[for_task] * math.pow(cp.importance,
+                                                                  COMMISION_LIMITS_SCALE) * self.settings.multiplier
             missing_units = limit - cp.base.total_units(for_task)
             if missing_units > 0:
-                awarded_points = COMMISION_AMOUNTS_FACTORS[for_task] * math.pow(cp.importance, COMMISION_AMOUNTS_SCALE) * self.settings.multiplier
+                awarded_points = COMMISION_AMOUNTS_FACTORS[for_task] * math.pow(cp.importance,
+                                                                                COMMISION_AMOUNTS_SCALE) * self.settings.multiplier
                 points_to_spend = cp.base.append_commision_points(for_task, awarded_points)
                 if points_to_spend > 0:
                     unittypes = self.commision_unit_types(cp, for_task)
-                    d = {random.choice(unittypes): points_to_spend}
-                    logging.info("Commision {}: {}".format(cp, d))
-                    cp.base.commision_units(d)
+                    if len(unittypes) > 0:
+                        d = {random.choice(unittypes): points_to_spend}
+                        logging.info("Commision {}: {}".format(cp, d))
+                        cp.base.commision_units(d)
 
     @property
     def budget_reward_amount(self):
+        reward = 0
         if len(self.theater.player_points()) > 0:
-            total_importance = sum([x.importance * x.base.strength for x in self.theater.player_points()])
-            return math.ceil(math.log(total_importance + 1, PLAYER_BUDGET_IMPORTANCE_LOG) * PLAYER_BUDGET_BASE * self.settings.multiplier)
+            reward = PLAYER_BUDGET_BASE * len(self.theater.player_points())
+            for cp in self.theater.player_points():
+                for g in cp.ground_objects:
+                    if g.category in REWARDS.keys():
+                        reward = reward + REWARDS[g.category]
+            return reward
         else:
-            return 0
+            return reward
 
     def _budget_player(self):
         self.budget += self.budget_reward_amount
@@ -226,8 +144,8 @@ class Game:
         self.budget -= AWACS_BUDGET_COST
 
     def units_delivery_event(self, to_cp: ControlPoint) -> UnitsDeliveryEvent:
-        event = UnitsDeliveryEvent(attacker_name=self.player,
-                                   defender_name=self.player,
+        event = UnitsDeliveryEvent(attacker_name=self.player_name,
+                                   defender_name=self.player_name,
                                    from_cp=to_cp,
                                    to_cp=to_cp,
                                    game=self)
@@ -259,12 +177,15 @@ class Game:
 
     def is_player_attack(self, event):
         if isinstance(event, Event):
-            return event.attacker_name == self.player
+            return event.attacker_name == self.player_name
         else:
-            return event.name == self.player
+            return event.name == self.player_name
 
-    def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint]=None):
+    def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint] = None):
         logging.info("Pass turn")
+        self.informations.append(Information("End of turn #" + str(self.turn), "-" * 40, 0))
+        self.turn = self.turn + 1
+
         for event in self.events:
             if self.settings.version == "dev":
                 # don't damage player CPs in by skipping in dev mode
@@ -273,14 +194,16 @@ class Game:
             else:
                 event.skip()
 
+        self._enemy_reinforcement()
+        self._budget_player()
+
         if not no_action:
-            self._budget_player()
-
-            for cp in self.theater.enemy_points():
-                self._commision_units(cp)
-
             for cp in self.theater.player_points():
                 cp.base.affect_strength(+PLAYER_BASE_STRENGTH_RECOVERY)
+        else:
+            for cp in self.theater.player_points():
+                if not cp.is_carrier and not cp.is_lha:
+                    cp.base.affect_strength(-PLAYER_BASE_STRENGTH_RECOVERY)
 
         self.ignored_cps = []
         if ignored_cps:
@@ -288,5 +211,109 @@ class Game:
 
         self.events = []  # type: typing.List[Event]
         self._generate_events()
-        #self._generate_globalinterceptions()
 
+        # Update statistics
+        self.game_stats.update(self)
+
+        # Plan flights & combat for next turn
+        self.planners = {}
+        self.ground_planners = {}
+        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
+
+    def _enemy_reinforcement(self):
+        MAX_ARMOR = 30 * self.settings.multiplier
+        MAX_AIRCRAFT = 25 * self.settings.multiplier
+
+        production = 0.0
+        for enemy_point in self.theater.enemy_points():
+            for g in enemy_point.ground_objects:
+                if g.category in REWARDS.keys():
+                    production = production + REWARDS[g.category]
+
+        production = production * 0.75
+        budget_for_armored_units = production / 2
+        budget_for_aircraft = production / 2
+
+        potential_cp_armor = []
+        for cp in self.theater.enemy_points():
+            for cpe in cp.connected_points:
+                if cpe.captured and cp.base.total_armor < MAX_ARMOR:
+                    potential_cp_armor.append(cp)
+        if len(potential_cp_armor) == 0:
+            potential_cp_armor = self.theater.enemy_points()
+
+        i = 0
+        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)
+        print(budget_for_armored_units)
+        print(potential_units)
+
+        if len(potential_units) > 0 and len(potential_cp_armor) > 0:
+            while budget_for_armored_units > 0:
+                i = i + 1
+                if i > 50 or budget_for_armored_units <= 0:
+                    break
+                target_cp = random.choice(potential_cp_armor)
+                if target_cp.base.total_armor >= MAX_ARMOR:
+                    continue
+                unit = random.choice(potential_units)
+                price = db.PRICES[unit] * 2
+                budget_for_armored_units -= price * 2
+                target_cp.base.armor[unit] = target_cp.base.armor.get(unit, 0) + 2
+                info = Information("Enemy Reinforcement", unit.id + " x 2 at " + target_cp.name, self.turn)
+                print(str(info))
+                self.informations.append(info)
+
+        if budget_for_armored_units > 0:
+            budget_for_aircraft += budget_for_armored_units
+
+        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
+                if i > 50 or budget_for_aircraft <= 0:
+                    break
+                target_cp = random.choice(potential_cp_armor)
+                if target_cp.base.total_planes >= MAX_AIRCRAFT:
+                    continue
+                unit = random.choice(potential_units)
+                price = db.PRICES[unit] * 2
+                budget_for_aircraft -= price * 2
+                target_cp.base.aircraft[unit] = target_cp.base.aircraft.get(unit, 0) + 2
+                info = Information("Enemy Reinforcement", unit.id + " x 2 at " + target_cp.name, self.turn)
+                print(str(info))
+                self.informations.append(info)
+
+    @property
+    def current_turn_daytime(self):
+        return ["dawn", "day", "dusk", "night"][self.turn % 4]
+
+    @property
+    def current_day(self):
+        return self.date + timedelta(days=self.turn // 4)
+
+    def next_unit_id(self):
+        """
+        Next unit id for pre-generated units
+        """
+        self.current_unit_id += 1
+        return self.current_unit_id
+
+    def next_group_id(self):
+        """
+        Next unit id for pre-generated units
+        """
+        self.current_group_id += 1
+        return self.current_group_id

game/game_stats.py

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

game/infos/information.py

@@ -0,0 +1,11 @@
+
+class Information():
+
+    def __init__(self, title="", text="", turn=0):
+        self.title = title
+        self.text = text
+        self.turn = turn
+
+    def __str__(self):
+        s = "[" + str(self.turn) + "] " + self.title + "\n" + self.text
+        return s

game/operation/baseattack.py

@@ -1,69 +0,0 @@
-from game.db import assigned_units_split
-
-from gen.triggergen import *
-
-from .operation import *
-
-
-class BaseAttackOperation(Operation):
-    cas = None  # type: db.AssignedUnitsDict
-    escort = None  # type: db.AssignedUnitsDict
-    intercept = None  # type: db.AssignedUnitsDict
-    attack = None  # type: db.ArmorDict
-    defense = None  # type: db.ArmorDict
-    aa = None  # type: db.AirDefenseDict
-
-    trigger_radius = TRIGGER_RADIUS_SMALL
-
-    def setup(self,
-              cas: db.AssignedUnitsDict,
-              escort: db.AssignedUnitsDict,
-              attack: db.AssignedUnitsDict,
-              intercept: db.AssignedUnitsDict,
-              defense: db.ArmorDict,
-              aa: db.AirDefenseDict):
-        self.cas = cas
-        self.escort = escort
-        self.intercept = intercept
-        self.attack = attack
-        self.defense = defense
-        self.aa = aa
-
-    def prepare(self, terrain: dcs.terrain.Terrain, is_quick: bool):
-        super(BaseAttackOperation, self).prepare(terrain, is_quick)
-
-        self.defenders_starting_position = None
-        if self.game.player == self.defender_name:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.capture_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.armorgen.generate(self.attack, self.defense)
-        self.aagen.generate(self.aa)
-
-        self.airgen.generate_defense(*assigned_units_split(self.intercept), at=self.defenders_starting_position)
-
-        self.airgen.generate_cas_strikegroup(*assigned_units_split(self.cas), at=self.attackers_starting_position)
-        self.airgen.generate_attackers_escort(*assigned_units_split(self.escort), at=self.attackers_starting_position)
-
-        self.visualgen.generate_target_smokes(self.to_cp)
-
-        self.briefinggen.title = "Base attack"
-        self.briefinggen.description = "The goal of an attacker is to lower defender presence by destroying their armor and aircraft. Base will be considered captured if attackers on the ground overrun the defenders. Be advised that your flight will not attack anything until you explicitly tell them so by comms menu."
-
-        if self.game.player == self.attacker_name:
-            self.briefinggen.append_waypoint("TARGET")
-        else:
-            pass
-
-        super(BaseAttackOperation, self).generate()
-

game/operation/convoystrike.py

@@ -1,49 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-class ConvoyStrikeOperation(Operation):
-    strikegroup = None  # type: db.AssignedUnitsDict
-    target = None  # type: db.ArmorDict
-
-    def setup(self,
-              target: db.ArmorDict,
-              strikegroup: db.AssignedUnitsDict):
-        self.strikegroup = strikegroup
-        self.target = target
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(ConvoyStrikeOperation, self).prepare(terrain, is_quick)
-
-        conflict = Conflict.convoy_strike_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        if self.is_player_attack:
-            self.prepare_carriers(db.unitdict_from(self.strikegroup))
-
-        planes_flights = {k: v for k, v in self.strikegroup.items() if k in plane_map.values()}
-        self.airgen.generate_cas_strikegroup(*assigned_units_split(planes_flights), at=self.attackers_starting_position)
-
-        heli_flights = {k: v for k, v in self.strikegroup.items() if k in helicopters.helicopter_map.values()}
-        if heli_flights:
-            self.briefinggen.append_frequency("FARP + Heli flights", "127.5 MHz AM")
-            for farp, dict in zip(self.groundobjectgen.generate_farps(sum([x[0] for x in heli_flights.values()])),
-                                  db.assignedunits_split_to_count(heli_flights, self.groundobjectgen.FARP_CAPACITY)):
-                self.airgen.generate_cas_strikegroup(*assigned_units_split(dict),
-                                                     at=farp,
-                                                     escort=len(planes_flights) == 0)
-
-        self.armorgen.generate_convoy(self.target)
-
-        self.briefinggen.append_waypoint("TARGET")
-        super(ConvoyStrikeOperation, self).generate()

game/operation/frontlineattack.py

@@ -29,13 +29,15 @@ class FrontlineAttackOperation(Operation):
 
     def prepare(self, terrain: Terrain, is_quick: bool):
         super(FrontlineAttackOperation, self).prepare(terrain, is_quick)
-        if self.defender_name == self.game.player:
+        if self.defender_name == self.game.player_name:
             self.attackers_starting_position = None
             self.defenders_starting_position = None
 
         conflict = Conflict.frontline_cas_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
+            attacker_name=self.attacker_name,
+            defender_name=self.defender_name,
+            attacker=self.current_mission.country(self.attacker_country),
+            defender=self.current_mission.country(self.defender_country),
             from_cp=self.from_cp,
             to_cp=self.to_cp,
             theater=self.game.theater
@@ -45,28 +47,28 @@ class FrontlineAttackOperation(Operation):
                         conflict=conflict)
 
     def generate(self):
-        if self.is_player_attack:
-            self.prepare_carriers(db.unitdict_from(self.strikegroup))
+        #if self.is_player_attack:
+        #    self.prepare_carriers(db.unitdict_from(self.strikegroup))
 
         # ground units
-        self.armorgen.generate_vec(self.attackers, self.defenders)
+        # self.armorgen.generate_vec(self.attackers, self.defenders)
 
-        # strike group w/ heli support
-        planes_flights = {k: v for k, v in self.strikegroup.items() if k in plane_map.values()}
-        self.airgen.generate_cas_strikegroup(*assigned_units_split(planes_flights), at=self.attackers_starting_position)
+        ## strike group w/ heli support
+        #planes_flights = {k: v for k, v in self.strikegroup.items() if k in plane_map.values()}
+        #self.airgen.generate_cas_strikegroup(*assigned_units_split(planes_flights), at=self.attackers_starting_position)
 
-        heli_flights = {k: v for k, v in self.strikegroup.items() if k in helicopters.helicopter_map.values()}
-        if heli_flights:
-            self.briefinggen.append_frequency("FARP + Heli flights", "127.5 MHz AM")
-            for farp, dict in zip(self.groundobjectgen.generate_farps(sum([x[0] for x in heli_flights.values()])),
-                                  db.assignedunits_split_to_count(heli_flights, self.groundobjectgen.FARP_CAPACITY)):
-                self.airgen.generate_cas_strikegroup(*assigned_units_split(dict),
-                                                     at=farp,
-                                                     escort=len(planes_flights) == 0)
+        #heli_flights = {k: v for k, v in self.strikegroup.items() if k in helicopters.helicopter_map.values()}
+        #if heli_flights:
+        #    self.briefinggen.append_frequency("FARP + Heli flights", "127.5 MHz AM")
+        #    for farp, dict in zip(self.groundobjectgen.generate_farps(sum([x[0] for x in heli_flights.values()])),
+        #                          db.assignedunits_split_to_count(heli_flights, self.groundobjectgen.FARP_CAPACITY)):
+        #        self.airgen.generate_cas_strikegroup(*assigned_units_split(dict),
+        #                                             at=farp,
+        #                                             escort=len(planes_flights) == 0)
 
-        self.airgen.generate_attackers_escort(*assigned_units_split(self.escort), at=self.attackers_starting_position)
+        #self.airgen.generate_attackers_escort(*assigned_units_split(self.escort), at=self.attackers_starting_position)
 
-        self.airgen.generate_defense(*assigned_units_split(self.interceptors), at=self.defenders_starting_position)
+        #self.airgen.generate_defense(*assigned_units_split(self.interceptors), at=self.defenders_starting_position)
 
         self.briefinggen.title = "Frontline CAS"
         self.briefinggen.description = "Provide CAS for the ground forces attacking enemy lines. Operation will be considered successful if total number of enemy units will be lower than your own by a factor of 1.5 (i.e. with 12 units from both sides, enemy forces need to be reduced to at least 8), meaning that you (and, probably, your wingmans) should concentrate on destroying the enemy units. Target base strength will be lowered as a result. Be advised that your flight will not attack anything until you explicitly tell them so by comms menu."

game/operation/frontlinepatrol.py

@@ -1,59 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-MAX_DISTANCE_BETWEEN_GROUPS = 12000
-
-
-class FrontlinePatrolOperation(Operation):
-    cas = None  # type: db.AssignedUnitsDict
-    escort = None  # type: db.AssignedUnitsDict
-    interceptors = None  # type: db.AssignedUnitsDict
-
-    armor_attackers = None  # type: db.ArmorDict
-    armor_defenders = None  # type: db.ArmorDict
-
-    def setup(self,
-              cas: db.AssignedUnitsDict,
-              escort: db.AssignedUnitsDict,
-              interceptors: db.AssignedUnitsDict,
-              armor_attackers: db.ArmorDict,
-              armor_defenders: db.ArmorDict):
-        self.cas = cas
-        self.escort = escort
-        self.interceptors = interceptors
-
-        self.armor_attackers = armor_attackers
-        self.armor_defenders = armor_defenders
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(FrontlinePatrolOperation, self).prepare(terrain, is_quick)
-        self.defenders_starting_position = None
-
-        conflict = Conflict.frontline_cap_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        if self.is_player_attack:
-            self.prepare_carriers(db.unitdict_from(self.interceptors))
-
-        self.airgen.generate_defenders_cas(*assigned_units_split(self.cas), at=self.defenders_starting_position)
-        self.airgen.generate_defenders_escort(*assigned_units_split(self.escort), at=self.defenders_starting_position)
-        self.airgen.generate_migcap(*assigned_units_split(self.interceptors), at=self.attackers_starting_position)
-
-        self.armorgen.generate_vec(self.armor_attackers, self.armor_defenders)
-
-        self.briefinggen.title = "Frontline CAP"
-        self.briefinggen.description = "Providing CAP support for ground units attacking enemy lines. Enemy will scramble its CAS and your task is to intercept it. Operation will be considered successful if total number of friendly units will be lower than enemy by at least a factor of 0.8 (i.e. with 12 units from both sides, there should be at least 8 friendly units alive), lowering targets strength as a result."
-        self.briefinggen.append_waypoint("CAP AREA IP")
-        self.briefinggen.append_waypoint("CAP AREA EGRESS")
-        super(FrontlinePatrolOperation, self).generate()

game/operation/infantrytransport.py

@@ -1,46 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-class InfantryTransportOperation(Operation):
-    transport = None  # type: db.AssignedUnitsDict
-    aa = None  # type: db.AirDefenseDict
-
-    def setup(self, transport: db.AssignedUnitsDict, aa: db.AirDefenseDict):
-        self.transport = transport
-        self.aa = aa
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(InfantryTransportOperation, self).prepare(terrain, is_quick)
-
-        conflict = Conflict.transport_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_passenger_transport(*assigned_units_split(self.transport), at=self.attackers_starting_position)
-
-        self.armorgen.generate_passengers(count=6)
-        self.aagen.generate_at_defenders_location(self.aa)
-
-        self.visualgen.generate_transportation_marker(self.conflict.ground_attackers_location)
-        self.visualgen.generate_transportation_destination(self.conflict.position)
-
-        self.briefinggen.title = "Infantry transport"
-        self.briefinggen.description = "Helicopter operation to transport infantry troops from the base to the front line. Lowers target strength"
-        self.briefinggen.append_waypoint("DROP POINT")
-
-        # TODO: horrible, horrible hack
-        # this will disable vehicle activation triggers,
-        # which aren't needed on this type of missions
-        self.is_quick = True
-        super(InfantryTransportOperation, self).generate()
-        self.is_quick = False

game/operation/insurgentattack.py

@@ -1,38 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-class InsurgentAttackOperation(Operation):
-    strikegroup = None  # type: db.AssignedUnitsDict
-    target = None  # type: db.ArmorDict
-
-    def setup(self,
-              target: db.ArmorDict,
-              strikegroup: db.AssignedUnitsDict):
-        self.strikegroup = strikegroup
-        self.target = target
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(InsurgentAttackOperation, self).prepare(terrain, is_quick)
-
-        conflict = Conflict.ground_attack_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_defenders_cas(*assigned_units_split(self.strikegroup), at=self.defenders_starting_position)
-        self.armorgen.generate(self.target, {})
-
-        self.briefinggen.title = "Destroy insurgents"
-        self.briefinggen.description = "Destroy vehicles of insurgents in close proximity of the friendly base. Be advised that your flight will not attack anything until you explicitly tell them so by comms menu."
-        self.briefinggen.append_waypoint("TARGET")
-
-        super(InsurgentAttackOperation, self).generate()

game/operation/intercept.py

@@ -1,65 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-class InterceptOperation(Operation):
-    location = None  # type: Point
-    escort = None  # type: db.AssignedUnitsDict
-    transport = None  # type: db.PlaneDict
-    interceptors = None  # type: db.AssignedUnitsDict
-    airdefense = None  # type: db.AirDefenseDict
-
-    trigger_radius = TRIGGER_RADIUS_LARGE
-
-    def setup(self,
-              location: Point,
-              escort: db.AssignedUnitsDict,
-              transport: db.PlaneDict,
-              airdefense: db.AirDefenseDict,
-              interceptors: db.AssignedUnitsDict):
-        self.location = location
-        self.escort = escort
-        self.transport = transport
-        self.airdefense = airdefense
-        self.interceptors = interceptors
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(InterceptOperation, self).prepare(terrain, is_quick)
-        self.defenders_starting_position = None
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.intercept_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            position=self.location,
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        if self.is_player_attack:
-            self.prepare_carriers(db.unitdict_from(self.interceptors))
-
-        self.airgen.generate_transport(self.transport, self.to_cp.at)
-        self.airgen.generate_defenders_escort(*assigned_units_split(self.escort), at=self.defenders_starting_position)
-
-        self.airgen.generate_interception(*assigned_units_split(self.interceptors), at=self.attackers_starting_position)
-
-        self.briefinggen.title = "Air Intercept"
-
-        if self.game.player == self.attacker_name:
-            self.briefinggen.description = "Intercept enemy supply transport aircraft. Escort will also be present if there are available planes on the base. Operation will be considered successful if most of the targets are destroyed, lowering targets strength as a result"
-            self.briefinggen.append_waypoint("TARGET")
-            for unit_type, count in self.transport.items():
-                self.briefinggen.append_target("{} ({})".format(db.unit_type_name(unit_type), count))
-        else:
-            self.briefinggen.description = "Escort friendly supply transport aircraft. Operation will be considered failed if most of the targets are destroyed, lowering CP strength as a result"
-
-        super(InterceptOperation, self).generate()
-

game/operation/navalintercept.py

@@ -1,67 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-class NavalInterceptionOperation(Operation):
-    location = None  # type: Point
-    strikegroup = None  # type: db.AssignedUnitsDict
-    interceptors = None  # type: db.AssignedUnitsDict
-    targets = None  # type: db.ShipDict
-    trigger_radius = TRIGGER_RADIUS_LARGE
-
-    def setup(self,
-              location: Point,
-              strikegroup: db.AssignedUnitsDict,
-              interceptors: db.AssignedUnitsDict,
-              targets: db.ShipDict):
-        self.location = location
-        self.strikegroup = strikegroup
-        self.interceptors = interceptors
-        self.targets = targets
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(NavalInterceptionOperation, self).prepare(terrain, is_quick)
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.naval_intercept_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            position=self.location,
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(self.current_mission, conflict)
-
-    def generate(self):
-        if self.is_player_attack:
-            self.prepare_carriers(db.unitdict_from(self.strikegroup))
-
-        target_groups = self.shipgen.generate_cargo(units=self.targets)
-
-        self.airgen.generate_ship_strikegroup(
-            *assigned_units_split(self.strikegroup),
-            target_groups=target_groups,
-            at=self.attackers_starting_position
-        )
-
-        if self.interceptors:
-            self.airgen.generate_defense(
-                *assigned_units_split(self.interceptors),
-                at=self.defenders_starting_position
-            )
-
-        self.briefinggen.title = "Naval Intercept"
-        if self.game.player == self.attacker_name:
-            self.briefinggen.description = "Destroy supply transport ships. Lowers target strength. Be advised that your flight will not attack anything until you explicitly tell them so by comms menu."
-            for unit_type, count in self.targets.items():
-                self.briefinggen.append_target("{} ({})".format(db.unit_type_name(unit_type), count))
-        else:
-            self.briefinggen.description = "Protect supply transport ships."
-        self.briefinggen.append_waypoint("TARGET")
-
-        super(NavalInterceptionOperation, self).generate()
-

game/operation/operation.py

@@ -1,8 +1,9 @@
+from dcs.countries import country_dict
 from dcs.lua.parse import loads
-
-from userdata.debriefing import *
+from dcs.terrain import Terrain
 
 from gen import *
+from userdata.debriefing import *
 
 TANKER_CALLSIGNS = ["Texaco", "Arco", "Shell"]
 
@@ -17,8 +18,6 @@ class Operation:
     conflict = None  # type: Conflict
     armorgen = None  # type: ArmorConflictGenerator
     airgen = None  # type: AircraftConflictGenerator
-    aagen = None  # type: AAConflictGenerator
-    extra_aagen = None  # type: ExtraAAConflictGenerator
     shipgen = None  # type: ShipGenerator
     triggersgen = None  # type: TriggersGenerator
     airsupportgen = None  # type: AirSupportConflictGenerator
@@ -43,7 +42,10 @@ class Operation:
                  to_cp: ControlPoint = None):
         self.game = game
         self.attacker_name = attacker_name
+        self.attacker_country = db.FACTIONS[attacker_name]["country"]
         self.defender_name = defender_name
+        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
@@ -62,9 +64,7 @@ class Operation:
     def initialize(self, mission: Mission, conflict: Conflict):
         self.current_mission = mission
         self.conflict = conflict
-        self.armorgen = ArmorConflictGenerator(mission, conflict)
         self.airgen = AircraftConflictGenerator(mission, conflict, self.game.settings)
-        self.aagen = AAConflictGenerator(mission, conflict)
         self.shipgen = ShipGenerator(mission, conflict)
         self.airsupportgen = AirSupportConflictGenerator(mission, conflict, self.game)
         self.triggersgen = TriggersGenerator(mission, conflict, self.game)
@@ -74,15 +74,31 @@ class Operation:
         self.groundobjectgen = GroundObjectsGenerator(mission, conflict, self.game)
         self.briefinggen = BriefingGenerator(mission, conflict, self.game)
 
-        player_name = self.from_cp.captured and self.attacker_name or self.defender_name
-        enemy_name = self.from_cp.captured and self.defender_name or self.attacker_name
-        self.extra_aagen = ExtraAAConflictGenerator(mission, conflict, self.game, player_name, enemy_name)
+        player_country = self.from_cp.captured and self.attacker_country or self.defender_country
+        enemy_country = self.from_cp.captured and self.defender_country or self.attacker_country
 
     def prepare(self, terrain: Terrain, is_quick: bool):
         with open("resources/default_options.lua", "r") as f:
             options_dict = loads(f.read())["options"]
 
         self.current_mission = dcs.Mission(terrain)
+
+        print(self.game.player_country)
+        print(country_dict[db.country_id_from_name(self.game.player_country)])
+        print(country_dict[db.country_id_from_name(self.game.player_country)]())
+
+        # Setup coalition :
+        self.current_mission.coalition["blue"] = Coalition("blue")
+        self.current_mission.coalition["red"] = Coalition("red")
+        if self.game.player_country and self.game.player_country in db.BLUEFOR_FACTIONS:
+            self.current_mission.coalition["blue"].add_country(country_dict[db.country_id_from_name(self.game.player_country)]())
+            self.current_mission.coalition["red"].add_country(country_dict[db.country_id_from_name(self.game.enemy_country)]())
+        else:
+            self.current_mission.coalition["blue"].add_country(country_dict[db.country_id_from_name(self.game.enemy_country)]())
+            self.current_mission.coalition["red"].add_country(country_dict[db.country_id_from_name(self.game.player_country)]())
+        print([c for c in self.current_mission.coalition["blue"].countries.keys()])
+        print([c for c in self.current_mission.coalition["red"].countries.keys()])
+
         if is_quick:
             self.quick_mission = self.current_mission
         else:
@@ -98,48 +114,51 @@ class Operation:
             self.attackers_starting_position = self.departure_cp.at
             self.defenders_starting_position = self.to_cp.at
 
-    def prepare_carriers(self, for_units: db.UnitsDict):
-        if not self.departure_cp.is_global:
-            return
-
-        ship = self.shipgen.generate_carrier(for_units=[t for t, c in for_units.items() if c > 0],
-                                             country=self.game.player,
-                                             at=self.departure_cp.at)
-
-        if not self.is_quick:
-            if not self.to_cp.captured:
-                self.attackers_starting_position = ship
-            else:
-                self.defenders_starting_position = ship
-
     def generate(self):
-        # air support
+
+        # Generate ground object first
+        self.groundobjectgen.generate()
+
+        # Air Support (Tanker & Awacs)
         self.airsupportgen.generate(self.is_awacs_enabled)
-        for i, tanker_type in enumerate(self.airsupportgen.generated_tankers):
-            self.briefinggen.append_frequency("Tanker {} ({})".format(TANKER_CALLSIGNS[i], tanker_type), "{}X/{} MHz AM".format(97+i, 130+i))
 
-        if self.is_awacs_enabled:
-            self.briefinggen.append_frequency("AWACS", "133 MHz AM")
+        # Generate Activity on the map
+        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():
+                self.airgen.generate_flights(cp, country, self.game.planners[cp.id])
 
-        # combined arms
+        # Generate ground units on frontline everywhere
+        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),
+                                                       player_cp, enemy_cp, self.game.theater)
+            # Generate frontline ops
+            player_gp = self.game.ground_planners[player_cp.id].units_per_cp[enemy_cp.id]
+            enemy_gp = self.game.ground_planners[enemy_cp.id].units_per_cp[player_cp.id]
+            groundConflictGen = GroundConflictGenerator(self.current_mission, conflict, self.game, player_gp, enemy_gp, player_cp.stances[enemy_cp.id])
+            groundConflictGen.generate()
+
+        # Setup combined arms parameters
         self.current_mission.groundControl.pilot_can_control_vehicles = self.ca_slots > 0
-        if self.game.player in [country.name for country in self.current_mission.coalition["blue"].countries.values()]:
+        if self.game.player_country in [country.name for country in self.current_mission.coalition["blue"].countries.values()]:
             self.current_mission.groundControl.blue_tactical_commander = self.ca_slots
         else:
             self.current_mission.groundControl.red_tactical_commander = self.ca_slots
 
-        # ground infrastructure
-        self.groundobjectgen.generate()
-        self.extra_aagen.generate()
-
         # triggers
-        if self.game.is_player_attack(self.conflict.attackers_side):
+        if self.game.is_player_attack(self.conflict.attackers_country):
             cp = self.conflict.from_cp
         else:
             cp = self.conflict.to_cp
 
         self.triggersgen.generate(player_cp=cp,
-                                  is_quick=self.is_quick,
+                                  is_quick=False,
                                   activation_trigger_radius=self.trigger_radius,
                                   awacs_enabled=self.is_awacs_enabled)
 
@@ -152,14 +171,38 @@ class Operation:
         # options
         self.forcedoptionsgen.generate()
 
-        # main frequencies
+        # Generate Visuals Smoke Effects
+        self.visualgen.generate()
+
+        # Inject Lua Scripts
+        load_mist = TriggerStart(comment="Load Mist Lua Framework")
+        with open("./resources/scripts/mist_4_3_74.lua") as f:
+            load_mist.add_action(DoScript(String(f.read())))
+        self.current_mission.triggerrules.triggers.append(load_mist)
+
+        load_dcs_libe = TriggerStart(comment="Load DCS Liberation Script")
+        with open("./resources/scripts/dcs_liberation.lua") as f:
+            script = f.read()
+            json_location = "[["+os.path.abspath("resources\\scripts\\json.lua")+"]]"
+            state_location = "[[" + os.path.abspath("state.json") + "]]"
+            script = script.replace("{{json_file_abs_location}}", json_location)
+            script = script.replace("{{debriefing_file_location}}", state_location)
+            load_dcs_libe.add_action(DoScript(String(script)))
+        self.current_mission.triggerrules.triggers.append(load_dcs_libe)
+
+        # Briefing Generation
+        for i, tanker_type in enumerate(self.airsupportgen.generated_tankers):
+            self.briefinggen.append_frequency("Tanker {} ({})".format(TANKER_CALLSIGNS[i], tanker_type), "{}X/{} MHz AM".format(97+i, 130+i))
+
+        if self.is_awacs_enabled:
+            self.briefinggen.append_frequency("AWACS", "133 MHz AM")
+
         self.briefinggen.append_frequency("Flight", "251 MHz AM")
         if self.departure_cp.is_global or self.conflict.to_cp.is_global:
             self.briefinggen.append_frequency("Carrier", "20X/ICLS CHAN1")
 
-        # briefing
+        # Generate the briefing
         self.briefinggen.generate()
 
-        # visuals
-        self.visualgen.generate()
+
 

game/operation/strike.py

@@ -1,94 +0,0 @@
-from game.db import assigned_units_split
-
-from .operation import *
-
-
-class StrikeOperation(Operation):
-    strikegroup = None  # type: db.AssignedUnitsDict
-    sead = None  # type: db.AssignedUnitsDict
-    escort = None  # type: db.AssignedUnitsDict
-    interceptors = None  # type: db.AssignedUnitsDict
-
-    trigger_radius = TRIGGER_RADIUS_ALL_MAP
-
-    def setup(self,
-              strikegroup: db.AssignedUnitsDict,
-              sead: db.AssignedUnitsDict,
-              escort: db.AssignedUnitsDict,
-              interceptors: db.AssignedUnitsDict):
-        self.strikegroup = strikegroup
-        self.sead = sead
-        self.escort = escort
-        self.interceptors = interceptors
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        super(StrikeOperation, self).prepare(terrain, is_quick)
-
-        self.defenders_starting_position = None
-        if self.game.player == self.defender_name:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.strike_conflict(
-            attacker=self.current_mission.country(self.attacker_name),
-            defender=self.current_mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp,
-            theater=self.game.theater
-        )
-
-        self.initialize(mission=self.current_mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.prepare_carriers(db.unitdict_merge(db.unitdict_from(self.strikegroup), db.unitdict_from(self.escort)))
-
-        targets = []  # type: typing.List[typing.Tuple[str, str, Point]]
-        sead_targets = []  # type: typing.List[typing.Tuple[str, str, Point]]
-        category_counters = {}  # type: typing.Dict[str, int]
-        processed_groups = []
-
-        for object in self.to_cp.ground_objects:
-            if object.group_identifier in processed_groups:
-                continue
-
-            processed_groups.append(object.group_identifier)
-            category_counters[object.category] = category_counters.get(object.category, 0) + 1
-            markpoint_name = "{}{}".format(object.name_abbrev, category_counters[object.category])
-
-            if object.category == "aa":
-                sead_targets.append((str(object), markpoint_name, object.position))
-
-            targets.append((str(object), markpoint_name, object.position))
-
-        targets.sort(key=lambda x: self.from_cp.position.distance_to_point(x[2]))
-
-        for (name, markpoint_name, _) in targets:
-            self.briefinggen.append_waypoint("TARGET {} (TP {})".format(str(name), markpoint_name))
-
-        planes_flights = {k: v for k, v in self.strikegroup.items() if k in plane_map.values()}
-        self.airgen.generate_ground_attack_strikegroup(*assigned_units_split(planes_flights),
-                                                       targets=[(mp, pos) for (n, mp, pos) in targets],
-                                                       at=self.attackers_starting_position,
-                                                       escort=len(self.sead) == 0)
-
-        self.airgen.generate_sead_strikegroup(*assigned_units_split(self.sead),
-                                              targets=[(mp, pos) for (n, mp, pos) in sead_targets],
-                                              at=self.attackers_starting_position,
-                                              escort=len(self.sead) > 0)
-
-        heli_flights = {k: v for k, v in self.strikegroup.items() if k in helicopters.helicopter_map.values()}
-        if heli_flights:
-            self.briefinggen.append_frequency("FARP", "127.5 MHz AM")
-            for farp, dict in zip(self.groundobjectgen.generate_farps(sum([x[0] for x in heli_flights.values()])),
-                                  db.assignedunits_split_to_count(heli_flights, self.groundobjectgen.FARP_CAPACITY)):
-                self.airgen.generate_ground_attack_strikegroup(*assigned_units_split(dict),
-                                                               targets=[(mp, pos) for (n, mp, pos) in targets],
-                                                               at=farp,
-                                                               escort=len(planes_flights) == 0)
-
-        self.airgen.generate_attackers_escort(*assigned_units_split(self.escort), at=self.attackers_starting_position)
-        self.airgen.generate_barcap(*assigned_units_split(self.interceptors), at=self.defenders_starting_position)
-
-        self.briefinggen.title = "Strike"
-        self.briefinggen.description = "Destroy infrastructure assets and military supplies in the region. Each building destroyed will lower targets strength."
-        super(StrikeOperation, self).generate()

game/settings.py

@@ -7,7 +7,7 @@ class Settings:
     labels = "Full"
     only_player_takeoff = True
     night_disabled = False
-
+    supercarrier = False
     multiplier = 1
     sams = True
     cold_start = False

gen/aaa.py

@@ -2,52 +2,25 @@ 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 AAConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict):
-        self.m = mission
-        self.conflict = conflict
-
-    def generate_at_defenders_location(self, units: db.AirDefenseDict):
-        for unit_type, count in units.items():
-            for _ in range(count):
-                self.m.vehicle_group(
-                    country=self.conflict.defenders_side,
-                    name=namegen.next_unit_name(self.conflict.defenders_side, unit_type),
-                    _type=unit_type,
-                    position=self.conflict.ground_defenders_location.random_point_within(100, 100),
-                    group_size=1)
-
-    def generate(self, units: db.AirDefenseDict):
-        for type, count in units.items():
-            for _, radial in zip(range(count), self.conflict.radials):
-                distance = randint(self.conflict.size * DISTANCE_FACTOR[0], self.conflict.size * DISTANCE_FACTOR[1])
-                p = self.conflict.position.point_from_heading(radial, distance)
-
-                self.m.vehicle_group(
-                        country=self.conflict.defenders_side,
-                        name=namegen.next_unit_name(self.conflict.defenders_side, type),
-                        _type=type,
-                        position=p,
-                        group_size=1)
-
-
 class ExtraAAConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game, player_name: Country, enemy_name: Country):
+    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_name = player_name
-        self.enemy_name = enemy_name
+        self.player_country = player_country
+        self.enemy_country = enemy_country
 
     def generate(self):
-        from theater.conflicttheater import ControlPoint
 
         for cp in self.game.theater.controlpoints:
             if cp.is_global:
@@ -65,7 +38,7 @@ class ExtraAAConflictGenerator:
             if cp.position.distance_to_point(self.conflict.position) > EXTRA_AA_MAX_DISTANCE:
                 continue
 
-            country_name = cp.captured and self.player_name or self.enemy_name
+            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(

gen/aircraft.py

@@ -1,7 +1,11 @@
 import logging
 
+from dcs.helicopters import UH_1H
+
 from game import db
 from game.settings import Settings
+from gen.flights.ai_flight_planner import FlightPlanner
+from gen.flights.flight import Flight, FlightType
 from .conflictgen import *
 from .naming import *
 from .triggergen import TRIGGER_WAYPOINT_OFFSET
@@ -10,7 +14,7 @@ from dcs.mission import *
 from dcs.unitgroup import *
 from dcs.unittype import *
 from dcs.task import *
-from dcs.terrain.terrain import NoParkingSlotError
+from dcs.terrain.terrain import NoParkingSlotError, RunwayOccupiedError
 
 SPREAD_DISTANCE_FACTOR = 1, 2
 ESCORT_ENGAGEMENT_MAX_DIST = 100000
@@ -38,18 +42,14 @@ TRANSPORT_LANDING_ALT = 2000
 DEFENCE_ENGAGEMENT_MAX_DISTANCE = 60000
 INTERCEPT_MAX_DISTANCE = 200000
 
-GROUP_VERTICAL_OFFSET = 300
-
 
 class AircraftConflictGenerator:
     escort_targets = [] # type: typing.List[typing.Tuple[FlyingGroup, int]]
-    vertical_offset = None  # type: int
 
     def __init__(self, mission: Mission, conflict: Conflict, settings: Settings):
         self.m = mission
         self.settings = settings
         self.conflict = conflict
-        self.vertical_offset = 0
         self.escort_targets = []
 
     def _start_type(self) -> StartType:
@@ -86,6 +86,9 @@ class AircraftConflictGenerator:
     def _setup_group(self, group: FlyingGroup, for_task: typing.Type[Task], client_count: int):
         did_load_loadout = False
         unit_type = group.units[0].unit_type
+
+        print("SETUP GROUP : " + str(for_task) + " -- " + str(group.name))
+
         if unit_type in db.PLANE_PAYLOAD_OVERRIDES:
             override_loadout = db.PLANE_PAYLOAD_OVERRIDES[unit_type]
             if type(override_loadout) == dict:
@@ -117,18 +120,32 @@ class AircraftConflictGenerator:
             else:
                 group.units[idx].set_client()
 
+            # Do not generate player group with late activation.
+            if group.late_activation:
+                group.late_activation = False
+
+            # Set up F-14 Client to have pre-stored alignement
+            if unit_type is F_14B:
+                group.units[idx].set_property(F_14B.Properties.INSAlignmentStored.id, True)
+
         group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
 
-        if unit_type in helicopters.helicopter_map.values():
-            print(unit_type)
+        if unit_type in helicopters.helicopter_map.values() and unit_type not in [UH_1H]:
             group.set_frequency(127.5)
         else:
-            group.set_frequency(251.0)
+            if unit_type not in [P_51D_30_NA, P_51D, SpitfireLFMkIX, SpitfireLFMkIXCW, FW_190A8, FW_190D9, Bf_109K_4]:
+                group.set_frequency(251.0)
+            else:
+                # WW2
+                group.set_frequency(124.0)
 
-    def _generate_at_airport(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, airport: Airport = None) -> FlyingGroup:
+    def _generate_at_airport(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, airport: Airport = None, start_type = None) -> FlyingGroup:
         assert count > 0
         assert unit is not None
 
+        if start_type is None:
+            start_type = self._start_type()
+
         logging.info("airgen: {} for {} at {}".format(unit_type, side.id, airport))
         return self.m.flight_group_from_airport(
             country=side,
@@ -136,7 +153,7 @@ class AircraftConflictGenerator:
             aircraft_type=unit_type,
             airport=self.m.terrain.airport_by_id(airport.id),
             maintask=None,
-            start_type=self._start_type(),
+            start_type=start_type,
             group_size=count,
             parking_slots=None)
 
@@ -144,12 +161,11 @@ class AircraftConflictGenerator:
         assert count > 0
         assert unit is not None
 
-        self.vertical_offset += GROUP_VERTICAL_OFFSET
         if unit_type in helicopters.helicopter_map.values():
-            alt = WARM_START_HELI_ALT + self.vertical_offset
+            alt = WARM_START_HELI_ALT
             speed = WARM_START_HELI_AIRSPEED
         else:
-            alt = WARM_START_ALTITUDE + self.vertical_offset
+            alt = WARM_START_ALTITUDE
             speed = WARM_START_AIRSPEED
 
         pos = Point(at.x + random.randint(100, 1000), at.y + random.randint(100, 1000))
@@ -239,11 +255,11 @@ class AircraftConflictGenerator:
         else:
             assert False
 
-    def _generate_escort(self, side: Country, units: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition, is_quick=False, should_orbit=False):
+    def _generate_escort(self, side: Country, units: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition, cp, is_quick=False, should_orbit=False):
         groups = []
         for flying_type, count, client_count in self._split_to_groups(units, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(side, flying_type),
+                name=namegen.next_unit_name(side, cp.id, flying_type),
                 side=side,
                 unit_type=flying_type,
                 count=count,
@@ -271,13 +287,190 @@ class AircraftConflictGenerator:
             groups.append(group)
         return groups
 
+    def _setup_custom_payload(self, flight, group:FlyingGroup):
+        if flight.use_custom_loadout:
+
+            logging.info("Custom loadout for flight : " + flight.__repr__())
+            for p in group.units:
+                p.pylons.clear()
+
+            for key in flight.loadout.keys():
+                if "Pylon" + key in flight.unit_type.__dict__.keys():
+                    print(flight.loadout)
+                    weapon_dict = flight.unit_type.__dict__["Pylon" + key].__dict__
+                    if flight.loadout[key] in weapon_dict.keys():
+                        weapon = weapon_dict[flight.loadout[key]]
+                        group.load_pylon(weapon, int(key))
+                else:
+                    logging.warning("Pylon not found ! => Pylon" + key + " on " + str(flight.unit_type))
+
+
+    def generate_flights(self, cp, country, flight_planner:FlightPlanner):
+
+        for flight in flight_planner.interceptor_flights:
+            group = self.generate_planned_flight(cp, country, flight)
+            self.setup_group_as_intercept_flight(group, flight)
+            self._setup_custom_payload(flight, group)
+
+        for flight in flight_planner.cap_flights:
+            group = self.generate_planned_flight(cp, country, flight)
+            self.setup_group_as_cap_flight(group, flight)
+            self._setup_custom_payload(flight, group)
+
+        for flight in flight_planner.cas_flights:
+            group = self.generate_planned_flight(cp, country, flight)
+            self.setup_group_as_cas_flight(group, flight)
+            self._setup_custom_payload(flight, group)
+
+        for flight in flight_planner.sead_flights:
+            group = self.generate_planned_flight(cp, country, flight)
+            self.setup_group_as_sead_flight(group, flight)
+            self._setup_custom_payload(flight, group)
+
+        for flight in flight_planner.custom_flights:
+            group = self.generate_planned_flight(cp, country, flight)
+            if flight.flight_type == FlightType.INTERCEPTION:
+                self.setup_group_as_intercept_flight(group, flight)
+            elif flight.flight_type in [FlightType.CAP, FlightType.TARCAP, FlightType.BARCAP]:
+                self.setup_group_as_cap_flight(group, flight)
+            elif flight.flight_type in [FlightType.CAS, FlightType.BAI]:
+                self.setup_group_as_cas_flight(group, flight)
+            elif flight.flight_type in [FlightType.STRIKE]:
+                self.setup_group_as_strike_flight(group, flight)
+            elif flight.flight_type in [FlightType.ANTISHIP]:
+                self.setup_group_as_antiship_flight(group, flight)
+            elif flight.flight_type in [FlightType.SEAD, FlightType.DEAD]:
+                self.setup_group_as_sead_flight(group, flight)
+            else:
+                self.setup_group_as_cap_flight(group, flight)
+            self._setup_custom_payload(flight, group)
+
+    def generate_planned_flight(self, cp, country, flight:Flight):
+        try:
+            if flight.start_type == "In Flight" or flight.client_count == 0:
+                group = self._generate_group(
+                    name=namegen.next_unit_name(country, cp.id, flight.unit_type),
+                    side=country,
+                    unit_type=flight.unit_type,
+                    count=flight.count,
+                    client_count=0,
+                    at=cp.position)
+            else:
+
+                st = StartType.Runway
+                if flight.start_type == "Cold":
+                    st = StartType.Cold
+                elif flight.start_type == "Warm":
+                    st = StartType.Warm
+
+                if cp.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP]:
+                    group_name = cp.get_carrier_group_name()
+                    group = self._generate_at_group(
+                        name=namegen.next_unit_name(country, cp.id, flight.unit_type),
+                        side=country,
+                        unit_type=flight.unit_type,
+                        count=flight.count,
+                        client_count=0,
+                        at=self.m.find_group(group_name),)
+                else:
+                    group = self._generate_at_airport(
+                        name=namegen.next_unit_name(country, cp.id, flight.unit_type),
+                        side=country,
+                        unit_type=flight.unit_type,
+                        count=flight.count,
+                        client_count=0,
+                        airport=self.m.terrain.airport_by_id(cp.at.id),
+                        start_type=st)
+        except Exception:
+            # Generated when there is no place on Runway or on Parking Slots
+            group = self._generate_group(
+                name=namegen.next_unit_name(country, cp.id, flight.unit_type),
+                side=country,
+                unit_type=flight.unit_type,
+                count=flight.count,
+                client_count=0,
+                at=cp.position)
+            group.points[0].alt = 1500
+        group.points[0].ETA = flight.scheduled_in * 60
+
+        return group
+
+    def setup_group_as_intercept_flight(self, group, flight):
+        group.points[0].ETA = 0
+        group.late_activation = True
+        self._setup_group(group, Intercept, flight.client_count)
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
+
+
+    def setup_group_as_cap_flight(self, group, flight):
+        self._setup_group(group, CAP, flight.client_count)
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
+
+    def setup_group_as_cas_flight(self, group, flight):
+        group.task = CAS.name
+        self._setup_group(group, CAS, flight.client_count)
+
+        group.points[0].tasks.clear()
+        group.points[0].tasks.append(CASTaskAction())
+        group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+        group.points[0].tasks.append(OptROE(OptROE.Values.OpenFireWeaponFree))
+        group.points[0].tasks.append(OptRestrictJettison(True))
+
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
+
+    def setup_group_as_sead_flight(self, group, flight):
+        group.task = SEAD.name
+        self._setup_group(group, SEAD, flight.client_count)
+
+        group.points[0].tasks.clear()
+        group.points[0].tasks.append(SEADTaskAction())
+        group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+        group.points[0].tasks.append(OptROE(OptROE.Values.OpenFireWeaponFree))
+        group.points[0].tasks.append(OptRestrictJettison(True))
+
+        i = 1
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
+            group.points[i].tasks.clear()
+            group.points[i].tasks.append(SEADTaskAction())
+            i = i + 1
+
+    def setup_group_as_strike_flight(self, group, flight):
+        group.task = PinpointStrike.name
+        self._setup_group(group, GroundAttack, flight.client_count)
+
+        group.points[0].tasks.clear()
+        group.points[0].tasks.append(CASTaskAction())
+        group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+        group.points[0].tasks.append(OptROE(OptROE.Values.OpenFireWeaponFree))
+        group.points[0].tasks.append(OptRestrictJettison(True))
+
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
+
+    def setup_group_as_antiship_flight(self, group, flight):
+        group.task = AntishipStrike.name
+        self._setup_group(group, AntishipStrike, flight.client_count)
+
+        group.points[0].tasks.clear()
+        group.points[0].tasks.append(AntishipStrikeTaskAction())
+        group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+        group.points[0].tasks.append(OptROE(OptROE.Values.OpenFireWeaponFree))
+        group.points[0].tasks.append(OptRestrictJettison(True))
+
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
+
     def generate_cas_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None, escort=True):
         assert not escort or len(self.escort_targets) == 0
 
         for flying_type, count, client_count in self._split_to_groups(attackers, clients):
             group = self._generate_group(
-                    name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
-                    side=self.conflict.attackers_side,
+                    name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                    side=self.conflict.attackers_country,
                     unit_type=flying_type,
                     count=count,
                     client_count=client_count,
@@ -298,8 +491,8 @@ class AircraftConflictGenerator:
 
         for flying_type, count, client_count in self._split_to_groups(strikegroup, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
-                side=self.conflict.attackers_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.attackers_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -324,8 +517,8 @@ class AircraftConflictGenerator:
 
         for flying_type, count, client_count in self._split_to_groups(strikegroup, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
-                side=self.conflict.attackers_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.attackers_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -350,8 +543,8 @@ class AircraftConflictGenerator:
 
         for flying_type, count, client_count in self._split_to_groups(defenders, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.defenders_side, flying_type),
-                side=self.conflict.defenders_side,
+                name=namegen.next_unit_name(self.conflict.defenders_country, self.conflict.to_cp.id, flying_type),
+                side=self.conflict.defenders_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -376,8 +569,8 @@ class AircraftConflictGenerator:
 
         for flying_type, count, client_count in self._split_to_groups(attackers, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
-                side=self.conflict.attackers_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.attackers_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -395,29 +588,31 @@ class AircraftConflictGenerator:
 
     def generate_attackers_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for g in self._generate_escort(
-                side=self.conflict.attackers_side,
+                side=self.conflict.attackers_country,
                 units=attackers,
                 clients=clients,
                 at=at and at or self._group_point(self.conflict.air_attackers_location),
                 is_quick=at is None,
+                cp=self.conflict.from_cp,
                 should_orbit=True):
             self._rtb_for(g, self.conflict.from_cp, at)
 
     def generate_defenders_escort(self, escort: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for g in self._generate_escort(
-                side=self.conflict.defenders_side,
+                side=self.conflict.defenders_country,
                 units=escort,
                 clients=clients,
                 at=at and at or self._group_point(self.conflict.air_defenders_location),
                 is_quick=at is None,
+                cp=self.conflict.to_cp,
                 should_orbit=False):
             self._rtb_for(g, self.conflict.to_cp, at)
 
     def generate_defense(self, defenders: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for flying_type, count, client_count in self._split_to_groups(defenders, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.defenders_side, flying_type),
-                side=self.conflict.defenders_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.to_cp.id, flying_type),
+                side=self.conflict.defenders_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -433,8 +628,8 @@ class AircraftConflictGenerator:
     def generate_migcap(self, patrol: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for flying_type, count, client_count in self._split_to_groups(patrol, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
-                side=self.conflict.attackers_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.attackers_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -451,8 +646,8 @@ class AircraftConflictGenerator:
     def generate_barcap(self, patrol: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for flying_type, count, client_count in self._split_to_groups(patrol, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.defenders_side, flying_type),
-                side=self.conflict.defenders_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.defenders_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -477,8 +672,8 @@ class AircraftConflictGenerator:
 
         for flying_type, count, client_count in self._split_to_groups(transport):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.defenders_side, flying_type),
-                side=self.conflict.defenders_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.defenders_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -495,8 +690,8 @@ class AircraftConflictGenerator:
     def generate_interception(self, interceptors: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for flying_type, count, client_count in self._split_to_groups(interceptors, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
-                side=self.conflict.attackers_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, flying_type),
+                side=self.conflict.attackers_country,
                 unit_type=flying_type,
                 count=count,
                 client_count=client_count,
@@ -517,8 +712,8 @@ class AircraftConflictGenerator:
     def generate_passenger_transport(self, helis: db.HeliDict, clients: db.HeliDict, at: db.StartingPosition):
         for heli_type, count, client_count in self._split_to_groups(helis, clients):
             group = self._generate_group(
-                name=namegen.next_unit_name(self.conflict.attackers_side, heli_type),
-                side=self.conflict.attackers_side,
+                name=namegen.next_unit_name(self.conflict.attackers_country, self.conflict.from_cp.id, heli_type),
+                side=self.conflict.attackers_country,
                 unit_type=heli_type,
                 count=count,
                 client_count=client_count,
@@ -527,3 +722,5 @@ class AircraftConflictGenerator:
 
             self._add_radio_waypoint(group, self.conflict.position, HELI_ALT)
             self._setup_group(group, Transport, client_count)
+
+

gen/airsupportgen.py

@@ -32,13 +32,13 @@ class AirSupportConflictGenerator:
     def generate(self, is_awacs_enabled):
         player_cp = self.conflict.from_cp if self.conflict.from_cp.captured else self.conflict.to_cp
 
-        for i, tanker_unit_type in enumerate(db.find_unittype(Refueling, self.conflict.attackers_side.name)):
+        for i, tanker_unit_type in enumerate(db.find_unittype(Refueling, self.conflict.attackers_side)):
             self.generated_tankers.append(db.unit_type_name(tanker_unit_type))
             tanker_heading = self.conflict.to_cp.position.heading_between_point(self.conflict.from_cp.position) + TANKER_HEADING_OFFSET * i
             tanker_position = player_cp.position.point_from_heading(tanker_heading, TANKER_DISTANCE)
             tanker_group = self.mission.refuel_flight(
-                country=self.mission.country(self.game.player),
-                name=namegen.next_tanker_name(self.mission.country(self.game.player)),
+                country=self.mission.country(self.game.player_country),
+                name=namegen.next_tanker_name(self.mission.country(self.game.player_country)),
                 airport=None,
                 plane_type=tanker_unit_type,
                 position=tanker_position,
@@ -53,10 +53,10 @@ class AirSupportConflictGenerator:
             tanker_group.points[0].tasks.append(SetImmortalCommand(True))
 
         if is_awacs_enabled:
-            awacs_unit = db.find_unittype(AWACS, self.conflict.attackers_side.name)[0]
+            awacs_unit = db.find_unittype(AWACS, self.conflict.attackers_side)[0]
             awacs_flight = self.mission.awacs_flight(
-                country=self.mission.country(self.game.player),
-                name=namegen.next_awacs_name(self.mission.country(self.game.player)),
+                country=self.mission.country(self.game.player_country),
+                name=namegen.next_awacs_name(self.mission.country(self.game.player_country)),
                 plane_type=awacs_unit,
                 altitude=AWACS_ALT,
                 airport=None,

gen/armor.py

@@ -1,131 +1,316 @@
-import logging
-
-from random import randint
-from itertools import zip_longest
-
-from game import db
-from .conflictgen import *
-from .naming import *
-
-from dcs.mission import *
-from dcs.unittype import *
-from dcs.point import *
 from dcs.task import *
-from dcs.country import *
+
+from gen import namegen
+from gen.ground_forces.ai_ground_planner import CombatGroupRole, DISTANCE_FROM_FRONTLINE
+from .conflictgen import *
 
 SPREAD_DISTANCE_FACTOR = 0.1, 0.3
 SPREAD_DISTANCE_SIZE_FACTOR = 0.1
 
-FRONTLINE_CAS_FIGHTS_COUNT = 4, 8
+FRONTLINE_CAS_FIGHTS_COUNT = 16, 24
 FRONTLINE_CAS_GROUP_MIN = 1, 2
 FRONTLINE_CAS_PADDING = 12000
 
+RETREAT_DISTANCE = 20000
+BREAKTHROUGH_OFFENSIVE_DISTANCE = 35000
+AGGRESIVE_MOVE_DISTANCE = 16000
+
 FIGHT_DISTANCE = 3500
 
+class GroundConflictGenerator:
 
-class ArmorConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict):
+    def __init__(self, mission: Mission, conflict: Conflict, game, player_planned_combat_groups, enemy_planned_combat_groups, player_stance):
         self.m = mission
         self.conflict = conflict
+        self.enemy_planned_combat_groups = enemy_planned_combat_groups
+        self.player_planned_combat_groups = player_planned_combat_groups
+        self.player_stance = CombatStance(player_stance)
+        self.enemy_stance = random.choice([CombatStance.AGGRESIVE, CombatStance.AGGRESIVE, CombatStance.AGGRESIVE, CombatStance.ELIMINATION, CombatStance.BREAKTHROUGH]) if len(enemy_planned_combat_groups) > len(player_planned_combat_groups) else random.choice([CombatStance.DEFENSIVE, CombatStance.DEFENSIVE, CombatStance.DEFENSIVE, CombatStance.AMBUSH, CombatStance.AGGRESIVE])
+        self.game = game
 
     def _group_point(self, point) -> Point:
         distance = randint(
                 int(self.conflict.size * SPREAD_DISTANCE_FACTOR[0]),
                 int(self.conflict.size * SPREAD_DISTANCE_FACTOR[1]),
                 )
-
         return point.random_point_within(distance, self.conflict.size * SPREAD_DISTANCE_SIZE_FACTOR)
 
-    def _generate_group(self, side: Country, unit: VehicleType, count: int, at: Point, to: Point = None, move_formation: PointAction = PointAction.OffRoad):
-        for c in range(count):
-            logging.info("armorgen: {} for {}".format(unit, side.id))
-            group = self.m.vehicle_group(
-                    side,
-                    namegen.next_unit_name(side, unit),
-                    unit,
-                    position=self._group_point(at),
-                    group_size=1,
-                    move_formation=move_formation)
+    def generate(self):
 
-            vehicle: Vehicle = group.units[0]
+        player_groups = []
+        enemy_groups = []
+
+        combat_width = self.conflict.distance/2
+        if combat_width > 500000:
+            combat_width = 500000
+        if combat_width < 35000:
+            combat_width = 35000
+
+        position = Conflict.frontline_position(self.game.theater, self.conflict.from_cp, self.conflict.to_cp)
+
+        # Create player groups at random position
+        for group in self.player_planned_combat_groups:
+            if group.role == CombatGroupRole.ARTILLERY:
+                distance_from_frontline = self.get_artilery_group_distance_from_frontline(group)
+            else:
+                distance_from_frontline = DISTANCE_FROM_FRONTLINE[group.role]
+            final_position = self.get_valid_position_for_group(position, True, combat_width, distance_from_frontline)
+
+            if final_position is not None:
+                g = self._generate_group(
+                    side=self.m.country(self.game.player_country),
+                    unit=group.units[0],
+                    heading=self.conflict.heading+90,
+                    count=len(group.units),
+                    at=final_position)
+                g.set_skill(self.game.settings.player_skill)
+                player_groups.append((g,group))
+
+                self.gen_infantry_group_for_group(g, True, self.m.country(self.game.player_country), self.conflict.heading + 90)
+
+        # Create enemy groups at random position
+        for group in self.enemy_planned_combat_groups:
+            if group.role == CombatGroupRole.ARTILLERY:
+                distance_from_frontline = self.get_artilery_group_distance_from_frontline(group)
+            else:
+                distance_from_frontline = DISTANCE_FROM_FRONTLINE[group.role]
+            final_position = self.get_valid_position_for_group(position, False, combat_width, distance_from_frontline)
+
+            if final_position is not None:
+                g = self._generate_group(
+                    side=self.m.country(self.game.enemy_country),
+                    unit=group.units[0],
+                    heading=self.conflict.heading - 90,
+                    count=len(group.units),
+                    at=final_position)
+                g.set_skill(self.game.settings.enemy_vehicle_skill)
+                enemy_groups.append((g, group))
+
+                self.gen_infantry_group_for_group(g, False, self.m.country(self.game.enemy_country), self.conflict.heading - 90)
+
+
+        # Plan combat actions for groups
+        self.plan_action_for_groups(self.player_stance, player_groups, enemy_groups, self.conflict.heading + 90, self.conflict.from_cp, self.conflict.to_cp)
+        self.plan_action_for_groups(self.enemy_stance, enemy_groups, player_groups, self.conflict.heading - 90, self.conflict.to_cp, self.conflict.from_cp)
+
+
+
+    def gen_infantry_group_for_group(self, group, is_player, side:Country, forward_heading):
+        infantry_position = group.points[0].position.random_point_within(250, 50)
+
+        if side == self.conflict.attackers_country:
+            cp = self.conflict.from_cp
+        else:
+            cp = self.conflict.to_cp
+
+        if is_player:
+            faction = self.game.player_name
+        else:
+            faction = self.game.enemy_name
+
+        possible_infantry_units = db.find_infantry(faction)
+        if len(possible_infantry_units) == 0:
+            return
+
+        u = random.choice(possible_infantry_units)
+        self.m.vehicle_group(
+                side,
+                namegen.next_infantry_name(side, cp, u), u,
+                position=infantry_position,
+                group_size=1,
+                heading=forward_heading,
+                move_formation=PointAction.OffRoad)
+
+        for i in range(randint(3, 10)):
+            u = random.choice(possible_infantry_units)
+            position = infantry_position.random_point_within(55, 5)
+            self.m.vehicle_group(
+                side,
+                namegen.next_infantry_name(side, cp, u), u,
+                position=position,
+                group_size=1,
+                heading=forward_heading,
+                move_formation=PointAction.OffRoad)
+
+
+    def plan_action_for_groups(self, stance, ally_groups, enemy_groups, forward_heading, from_cp, to_cp):
+
+        for dcs_group, group in ally_groups:
+            if group.role == CombatGroupRole.ARTILLERY:
+                # Fire on any ennemy in range
+                target = self.get_artillery_target_in_range(dcs_group, group, enemy_groups)
+                if target is not None:
+                    dcs_group.points[0].tasks.append(FireAtPoint(target, len(group.units) * 10, 100))
+            elif group.role in [CombatGroupRole.TANK, CombatGroupRole.IFV]:
+                if stance == CombatStance.AGGRESIVE:
+                    # Attack nearest enemy if any
+                    # Then move forward OR Attack enemy base if it is not too far away
+                    target = self.find_nearest_enemy_group(dcs_group, enemy_groups)
+                    if target is not None:
+                        rand_offset = Point(random.randint(-50, 50), random.randint(-50, 50))
+                        dcs_group.add_waypoint(target.points[0].position + rand_offset, PointAction.OffRoad)
+                        dcs_group.points[1].tasks.append(AttackGroup(target.id))
+
+                    if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
+                        attack_point = to_cp.position.random_point_within(500, 0)
+                    else:
+                        attack_point = self.find_offensive_point(dcs_group, forward_heading, AGGRESIVE_MOVE_DISTANCE)
+                    dcs_group.add_waypoint(attack_point, PointAction.OnRoad)
+                elif stance == CombatStance.BREAKTHROUGH:
+                    # In breakthrough mode, the units will move forward
+                    # If the enemy base is close enough, the units will attack the base
+                    if to_cp.position.distance_to_point(
+                            dcs_group.points[0].position) <= BREAKTHROUGH_OFFENSIVE_DISTANCE:
+                        attack_point = to_cp.position.random_point_within(500, 0)
+                    else:
+                        attack_point = self.find_offensive_point(dcs_group, forward_heading, BREAKTHROUGH_OFFENSIVE_DISTANCE)
+                    dcs_group.add_waypoint(attack_point, PointAction.OnRoad)
+                elif stance == CombatStance.ELIMINATION:
+                    # In elimination mode, the units focus on destroying as much enemy groups as possible
+                    targets = self.find_n_nearest_enemy_groups(dcs_group, enemy_groups, 3)
+                    i = 1
+                    for target in targets:
+                        rand_offset = Point(random.randint(-50, 50), random.randint(-50, 50))
+                        dcs_group.add_waypoint(target.points[0].position+rand_offset,PointAction.OffRoad)
+                        dcs_group.points[i].tasks.append(AttackGroup(target.id))
+                        i = i + 1
+                    if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
+                        attack_point = to_cp.position.random_point_within(500, 0)
+                        dcs_group.add_waypoint(attack_point)
+            elif group.role in [CombatGroupRole.APC, CombatGroupRole.ATGM]:
+
+                if stance in [CombatStance.AGGRESIVE, CombatStance.BREAKTHROUGH, CombatStance.ELIMINATION]:
+                    # APC & ATGM will never move too much forward, but will follow along any offensive
+                    if to_cp.position.distance_to_point(dcs_group.points[0].position) <= AGGRESIVE_MOVE_DISTANCE:
+                        attack_point = to_cp.position.random_point_within(500, 0)
+                    else:
+                        attack_point = self.find_offensive_point(dcs_group, forward_heading, AGGRESIVE_MOVE_DISTANCE)
+                    dcs_group.add_waypoint(attack_point, PointAction.OnRoad)
+
+            if stance == CombatStance.RETREAT:
+                # In retreat mode, the units will fall back
+                # If the ally base is close enough, the units will even regroup there
+                if from_cp.position.distance_to_point(dcs_group.points[0].position) <= RETREAT_DISTANCE:
+                    retreat_point = from_cp.position.random_point_within(500, 250)
+                else:
+                    retreat_point = self.find_retreat_point(dcs_group, forward_heading)
+                reposition_point = retreat_point.point_from_heading(forward_heading, 10)  # Another point to make the unit face the enemy
+                dcs_group.add_waypoint(retreat_point, PointAction.OnRoad)
+                dcs_group.add_waypoint(reposition_point, PointAction.OffRoad)
+
+
+    def find_retreat_point(self, dcs_group, frontline_heading):
+        """
+        Find a point to retreat to
+        :param dcs_group: DCS mission group we are searching a retreat point for
+        :param frontline_heading: Heading of the frontline
+        :return: dcs.mapping.Point object with the desired position
+        """
+        return dcs_group.points[0].position.point_from_heading(frontline_heading-180, RETREAT_DISTANCE)
+
+    def find_offensive_point(self, dcs_group, frontline_heading, distance):
+        """
+        Find a point to attack
+        :param dcs_group:  DCS mission group we are searching an attack point for
+        :param frontline_heading: Heading of the frontline
+        :param distance: Distance of the offensive (how far unit should move)
+        :return: dcs.mapping.Point object with the desired position
+        """
+        return dcs_group.points[0].position.point_from_heading(frontline_heading, distance)
+
+    def find_n_nearest_enemy_groups(self, player_group, enemy_groups, n):
+        """
+        Return the neaarest enemy group for the player group
+        @param group Group for which we should find the nearest ennemies
+        @param enemy_groups Potential enemy groups
+        @param n number of nearby groups to take
+        """
+        targets = []
+        sorted_list = sorted(enemy_groups, key=lambda group: player_group.points[0].position.distance_to_point(group[0].points[0].position))
+        for i in range(n):
+            if len(sorted_list) <= i:
+                break
+            else:
+                targets.append(sorted_list[i][0])
+        return targets
+
+
+    def find_nearest_enemy_group(self, player_group, enemy_groups):
+        """
+        Search the enemy groups for a potential target suitable to armored assault
+        @param group Group for which we should find the nearest ennemy
+        @param enemy_groups Potential enemy groups
+        """
+        min_distance = 99999999
+        target = None
+        for dcs_group, group in enemy_groups:
+            dist = player_group.points[0].position.distance_to_point(dcs_group.points[0].position)
+            if dist < min_distance:
+                min_distance = dist
+                target = dcs_group
+        return target
+
+
+    def get_artillery_target_in_range(self, dcs_group, group, enemy_groups):
+        """
+        Search the enemy groups for a potential target suitable to an artillery unit
+        """
+        rng = group.units[0].threat_range
+        if len(enemy_groups) == 0:
+            return None
+        for o in range(10):
+            potential_target = random.choice(enemy_groups)[0]
+            distance_to_target = dcs_group.points[0].position.distance_to_point(potential_target.points[0].position)
+            if distance_to_target < rng:
+                return potential_target.points[0].position
+        return None
+
+
+    def get_artilery_group_distance_from_frontline(self, group):
+        """
+        For artilery group, decide the distance from frontline with the range of the unit
+        """
+        rg = group.units[0].threat_range - 7500
+        if rg > DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY]:
+            rg = DISTANCE_FROM_FRONTLINE[CombatGroupRole.ARTILLERY]
+        if rg < DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK]:
+            rg = DISTANCE_FROM_FRONTLINE[CombatGroupRole.TANK] + 100
+        return rg
+
+
+    def get_valid_position_for_group(self, conflict_position, isplayer, combat_width, distance_from_frontline):
+        i = 0
+        while i < 25: # 25 attempt for valid position
+            heading_diff = -90 if isplayer else 90
+            shifted = conflict_position[0].point_from_heading(self.conflict.heading,
+                                                     random.randint((int)(-combat_width / 2), (int)(combat_width / 2)))
+            final_position = shifted.point_from_heading(self.conflict.heading + heading_diff, distance_from_frontline)
+
+            if self.conflict.theater.is_on_land(final_position):
+                return final_position
+            else:
+                i = i + 1
+                continue
+        return None
+
+    def _generate_group(self, side: Country, unit: VehicleType, count: int, at: Point, move_formation: PointAction = PointAction.OffRoad, heading=0):
+
+        if side == self.conflict.attackers_country:
+            cp = self.conflict.from_cp
+        else:
+            cp = self.conflict.to_cp
+
+        logging.info("armorgen: {} for {}".format(unit, side.id))
+        group = self.m.vehicle_group(
+                side,
+                namegen.next_unit_name(side, cp.id, unit), unit,
+                position=self._group_point(at),
+                group_size=count,
+                heading=heading,
+                move_formation=move_formation)
+
+        for c in range(count):
+            vehicle: Vehicle = group.units[c]
             vehicle.player_can_drive = True
 
-            if not to:
-                to = self.conflict.position.point_from_heading(0, 500)
-
-            wayp = group.add_waypoint(self._group_point(to), move_formation=move_formation)
-            wayp.tasks = []
-
-    def _generate_fight_at(self, attackers: db.ArmorDict, defenders: db.ArmorDict, position: Point):
-        if attackers:
-            attack_pos = position.point_from_heading(self.conflict.heading - 90, FIGHT_DISTANCE)
-            attack_dest = position.point_from_heading(self.conflict.heading + 90, FIGHT_DISTANCE * 2)
-            for type, count in attackers.items():
-                self._generate_group(
-                    side=self.conflict.attackers_side,
-                    unit=type,
-                    count=count,
-                    at=attack_pos,
-                    to=attack_dest,
-                )
-
-        if defenders:
-            def_pos = position.point_from_heading(self.conflict.heading + 90, FIGHT_DISTANCE)
-            def_dest = position.point_from_heading(self.conflict.heading - 90, FIGHT_DISTANCE * 2)
-            for type, count in defenders.items():
-                self._generate_group(
-                    side=self.conflict.defenders_side,
-                    unit=type,
-                    count=count,
-                    at=def_pos,
-                    to=def_dest,
-                )
-
-    def generate(self, attackers: db.ArmorDict, defenders: db.ArmorDict):
-        for type, count in attackers.items():
-            self._generate_group(
-                side=self.conflict.attackers_side,
-                unit=type,
-                count=count,
-                at=self.conflict.ground_attackers_location)
-
-        for type, count in defenders.items():
-            self._generate_group(
-                side=self.conflict.defenders_side,
-                unit=type,
-                count=count,
-                at=self.conflict.ground_defenders_location)
-
-    def generate_vec(self, attackers: db.ArmorDict, defenders: db.ArmorDict):
-        fights_count = randint(*FRONTLINE_CAS_FIGHTS_COUNT)
-        single_fight_defenders_count = min(int(sum(defenders.values()) / fights_count), randint(*FRONTLINE_CAS_GROUP_MIN))
-        defender_groups = list(db.unitdict_split(defenders, single_fight_defenders_count))
-
-        single_fight_attackers_count = min(int(sum(attackers.values()) / len(defender_groups)), randint(*FRONTLINE_CAS_GROUP_MIN))
-        attacker_groups = list(db.unitdict_split(attackers, single_fight_attackers_count))
-
-        for attacker_group_dict, target_group_dict in zip_longest(attacker_groups, defender_groups):
-            position = self.conflict.position.point_from_heading(self.conflict.heading,
-                                                                 random.randint(0, self.conflict.distance))
-            self._generate_fight_at(attacker_group_dict, target_group_dict, position)
-
-    def generate_convoy(self, units: db.ArmorDict):
-        for type, count in units.items():
-            self._generate_group(
-                side=self.conflict.defenders_side,
-                unit=type,
-                count=count,
-                at=self.conflict.ground_defenders_location,
-                to=self.conflict.position,
-                move_formation=PointAction.OnRoad)
-
-    def generate_passengers(self, count: int):
-        unit_type = random.choice(db.find_unittype(Nothing, self.conflict.attackers_side.name))
-
-        self.m.vehicle_group(
-            country=self.conflict.attackers_side,
-            name=namegen.next_unit_name(self.conflict.attackers_side, unit_type),
-            _type=unit_type,
-            position=self.conflict.ground_attackers_location,
-            group_size=count
-        )
+        return group

gen/briefinggen.py

@@ -18,6 +18,7 @@ class BriefingGenerator:
         self.m = mission
         self.conflict = conflict
         self.game = game
+        self.description = ""
 
         self.freqs = []
         self.targets = []
@@ -32,32 +33,56 @@ class BriefingGenerator:
     def append_waypoint(self, description: str):
         self.waypoints.append(description)
 
+    def add_flight_description(self, flight):
+
+        if flight.client_count <= 0:
+            return
+
+        flight_unit_name = db.unit_type_name(flight.unit_type)
+        self.description += 2 * "\n" + "-" * 50 + "\n"
+        self.description += flight_unit_name + " x " + str(flight.count) + 2 * "\n"
+
+        self.description += "#0 -- TAKEOFF : Take off\n"
+        for i, wpt in enumerate(flight.points):
+            self.description += "#" + str(1+i) + " -- " + wpt.name + " : " + wpt.description + "\n"
+        self.description += "#" + str(len(flight.points) + 1) + " -- RTB\n"
+
+        self.description += "-" * 50 + "\n"
+
     def generate(self):
-        self.waypoints.insert(0, "INITIAL")
-        self.waypoints.append("RTB")
-        self.waypoints.append("RTB Landing")
 
-        description = ""
+        self.description = ""
 
-        if self.title:
-            description += self.title
+        self.description += "DCS Liberation turn #" + str(self.game.turn) + "\n"
+        self.description += "-"*50 + "\n"
 
-        if self.description:
-            description += "\n\n" + self.description
+        for planner in self.game.planners.values():
+            for flight in planner.cap_flights:
+                self.add_flight_description(flight)
+            for flight in planner.cas_flights:
+                self.add_flight_description(flight)
+            for flight in planner.sead_flights:
+                self.add_flight_description(flight)
 
         if self.freqs:
-            description += "\n\nCOMMS:"
+            self.description += "\n\nComms Frequencies:\n"
+            self.description += "-" * 50 + "\n"
             for name, freq in self.freqs:
-                description += "\n{}: {}".format(name, freq)
+                self.description += "\n{}: {}".format(name, freq)
 
-        if self.targets:
-            description += "\n\nTARGETS:"
-            for i, (name, tp) in enumerate(self.targets):
-                description += "\n#{} {} {}".format(i+1, name, "(TP {})".format(tp) if tp else "")
+        for cp in self.game.theater.controlpoints:
+            if cp.captured and cp.cptype in [ControlPointType.LHA_GROUP, ControlPointType.AIRCRAFT_CARRIER_GROUP]:
+                self.description += "\n"
+                self.description += cp.name + " TACAN : "
+
+                self.description += str(cp.tacanN)
+                if cp.tacanY:
+                    self.description += "Y"
+                else:
+                    self.description += "X"
+                self.description += " " + str(cp.tacanI) + "\n"
+
+
+        self.m.set_description_text(self.description)
 
-        if self.waypoints:
-            description += "\n\nWAYPOINTS:"
-            for i, descr in enumerate(self.waypoints):
-                description += "\n#{}: {}".format(i, descr)
 
-        self.m.set_description_text(description)

gen/conflictgen.py

@@ -27,7 +27,7 @@ STRIKE_AIR_DEFENDERS_DISTANCE = 25000
 CAP_CAS_DISTANCE = 10000, 120000
 
 GROUND_INTERCEPT_SPREAD = 5000
-GROUND_DISTANCE_FACTOR = 1
+GROUND_DISTANCE_FACTOR = 1.4
 GROUND_DISTANCE = 2000
 
 GROUND_ATTACK_DISTANCE = 25000, 13000
@@ -65,8 +65,10 @@ def _heading_sum(h, a) -> int:
 
 
 class Conflict:
-    attackers_side = None  # type: Country
-    defenders_side = None  # type: Country
+    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
@@ -85,8 +87,10 @@ class Conflict:
                  theater: ConflictTheater,
                  from_cp: ControlPoint,
                  to_cp: ControlPoint,
-                 attackers_side: Country,
-                 defenders_side: Country,
+                 attackers_side: str,
+                 defenders_side: str,
+                 attackers_country: Country,
+                 defenders_country: Country,
                  position: Point,
                  heading=None,
                  distance=None,
@@ -94,8 +98,12 @@ class Conflict:
                  ground_defenders_location: Point = None,
                  air_attackers_location: Point = None,
                  air_defenders_location: Point = None):
+
         self.attackers_side = attackers_side
         self.defenders_side = defenders_side
+        self.attackers_country = attackers_country
+        self.defenders_country = defenders_country
+
         self.from_cp = from_cp
         self.to_cp = to_cp
         self.theater = theater
@@ -264,7 +272,7 @@ class Conflict:
         return initial
 
     @classmethod
-    def capture_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def capture_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         position = to_cp.position
         attack_raw_heading = to_cp.position.heading_between_point(from_cp.position)
         attack_heading = to_cp.find_radial(attack_raw_heading)
@@ -282,8 +290,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=attackers_location,
             ground_defenders_location=defenders_location,
             air_attackers_location=position.point_from_heading(attack_raw_heading, CAPTURE_AIR_ATTACKERS_DISTANCE),
@@ -291,7 +301,7 @@ class Conflict:
         )
 
     @classmethod
-    def strike_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def strike_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         position = to_cp.position
         attack_raw_heading = to_cp.position.heading_between_point(from_cp.position)
         attack_heading = to_cp.find_radial(attack_raw_heading)
@@ -309,8 +319,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=attackers_location,
             ground_defenders_location=defenders_location,
             air_attackers_location=position.point_from_heading(attack_raw_heading, STRIKE_AIR_ATTACKERS_DISTANCE),
@@ -325,15 +337,17 @@ class Conflict:
         return from_cp.position.point_from_heading(heading, distance)
 
     @classmethod
-    def intercept_conflict(cls, attacker: Country, defender: Country, position: Point, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def intercept_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, position: Point, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         heading = from_cp.position.heading_between_point(position)
         return cls(
             position=position.point_from_heading(position.heading_between_point(to_cp.position), INTERCEPT_CONFLICT_DISTANCE),
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=None,
             ground_defenders_location=None,
             air_attackers_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, INTERCEPT_ATTACKERS_DISTANCE),
@@ -341,7 +355,7 @@ class Conflict:
         )
 
     @classmethod
-    def ground_attack_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def ground_attack_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         heading = random.choice(to_cp.radials)
         initial_location = to_cp.position.random_point_within(*GROUND_ATTACK_DISTANCE)
         position = Conflict._find_ground_position(initial_location, GROUND_INTERCEPT_SPREAD, _heading_sum(heading, 180), theater)
@@ -354,8 +368,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=position,
             ground_defenders_location=None,
             air_attackers_location=None,
@@ -363,7 +379,7 @@ class Conflict:
         )
 
     @classmethod
-    def convoy_strike_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def convoy_strike_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         frontline_position, frontline_heading, frontline_length = Conflict.frontline_vector(from_cp, to_cp, theater)
         if not frontline_position:
             assert False
@@ -383,8 +399,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=None,
             ground_defenders_location=starting_position,
             air_attackers_location=starting_position.point_from_heading(_opposite_heading(heading), AIR_DISTANCE),
@@ -392,7 +410,7 @@ class Conflict:
         )
 
     @classmethod
-    def frontline_cas_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def frontline_cas_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         assert cls.has_frontline_between(from_cp, to_cp)
         position, heading, distance = cls.frontline_vector(from_cp, to_cp, theater)
 
@@ -403,8 +421,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=None,
             ground_defenders_location=None,
             air_attackers_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, AIR_DISTANCE),
@@ -412,7 +432,7 @@ class Conflict:
         )
 
     @classmethod
-    def frontline_cap_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def frontline_cap_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         assert cls.has_frontline_between(from_cp, to_cp)
 
         position, heading, distance = cls.frontline_vector(from_cp, to_cp, theater)
@@ -427,14 +447,16 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             air_attackers_location=attackers_position,
             air_defenders_location=defenders_position,
         )
 
     @classmethod
-    def ground_base_attack(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def ground_base_attack(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         position = to_cp.position
         attack_heading = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
         defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
@@ -448,8 +470,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=None,
             ground_defenders_location=defenders_location,
             air_attackers_location=position.point_from_heading(attack_heading, AIR_DISTANCE),
@@ -470,15 +494,17 @@ class Conflict:
         return position
 
     @classmethod
-    def naval_intercept_conflict(cls, attacker: Country, defender: Country, position: Point, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def naval_intercept_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, position: Point, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         attacker_heading = from_cp.position.heading_between_point(to_cp.position)
         return cls(
             position=position,
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=None,
             ground_defenders_location=position,
             air_attackers_location=position.point_from_heading(attacker_heading, AIR_DISTANCE),
@@ -486,7 +512,7 @@ class Conflict:
         )
 
     @classmethod
-    def transport_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def transport_conflict(cls, attacker_name: str, defender_name: str, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         frontline_position, heading = cls.frontline_position(theater, from_cp, to_cp)
         initial_dest = frontline_position.point_from_heading(heading, TRANSPORT_FRONTLINE_DIST)
         dest = cls._find_ground_position(initial_dest, from_cp.position.distance_to_point(to_cp.position) / 3, heading, theater)
@@ -499,8 +525,10 @@ class Conflict:
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            attackers_side=attacker_name,
+            defenders_side=defender_name,
+            attackers_country=attacker,
+            defenders_country=defender,
             ground_attackers_location=from_cp.position,
             ground_defenders_location=frontline_position,
             air_attackers_location=from_cp.position.point_from_heading(0, 100),

gen/defenses/armor_group_generator.py

@@ -0,0 +1,24 @@
+import random
+
+from dcs.vehicles import Armor
+
+from game import db
+from gen.defenses.armored_group_generator import ArmoredGroupGenerator
+
+
+def generate_armor_group(faction:str, game, ground_object):
+    """
+    This generate a group of ground units
+    :param parentCp: The parent control point
+    :param ground_object: The ground object which will own the group
+    :param country: Owner country
+    :return: Generated group
+    """
+
+    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)
+        generator = ArmoredGroupGenerator(game, ground_object, unit_type)
+        generator.generate()
+        return generator.get_generated_group()
+    return None

gen/defenses/armored_group_generator.py

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

gen/environmentgen.py

@@ -51,19 +51,27 @@ class EnviromentGenerator:
         self.conflict = conflict
         self.game = game
 
-    def _gen_random_time(self):
-        start_time = datetime.strptime('May 25 2018 12:00AM', '%b %d %Y %I:%M%p')
+    def _gen_time(self):
 
-        time_range = None
-        for k, v in RANDOM_TIME.items():
-            if self.game.settings.night_disabled and k == "night":
-                continue
+        start_time = self.game.current_day
 
-            if random.randint(0, 100) <= v:
-                time_range = self.game.theater.daytime_map[k]
-                break
+        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 == "noon":
+                time_range = (10, 12)
+            elif daytime == "dusk":
+                time_range = (12, 14)
+            elif daytime == "night":
+                time_range = (14, 17)
+        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),
@@ -132,7 +140,7 @@ class EnviromentGenerator:
             self._generate_wind(1)
 
     def generate(self) -> EnvironmentSettings:
-        self._gen_random_time()
+        self._gen_time()
         self._gen_random_weather()
 
         settings = EnvironmentSettings()

gen/fleet/carrier_group.py

@@ -0,0 +1,33 @@
+import random
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class CarrierGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(CarrierGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        # Add 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
+        dd_type = random.choice(self.faction["destroyer"])
+        self.add_unit(dd_type, "DD1", self.position.x + 250, self.position.y + 450, self.heading)
+        self.add_unit(dd_type, "DD2", self.position.x + 250, self.position.y - 450, self.heading)
+
+        self.add_unit(dd_type, "DD3", self.position.x + 450, self.position.y + 850, self.heading)
+        self.add_unit(dd_type, "DD4", self.position.x + 450, self.position.y - 850, self.heading)
+
+        self.get_generated_group().points[0].speed = 20

gen/fleet/lha_group.py

@@ -0,0 +1,25 @@
+import random
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class LHAGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(LHAGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        # Add 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 "destroyer" in self.faction.keys():
+            dd_type = random.choice(self.faction["destroyer"])
+            self.add_unit(dd_type, "DD1", self.position.x + 250, self.position.y + 450, self.heading)
+            self.add_unit(dd_type, "DD2", self.position.x + 250, self.position.y - 450, self.heading)
+
+        self.get_generated_group().points[0].speed = 20

gen/fleet/ship_group_generator.py

@@ -0,0 +1,29 @@
+from game import db
+from gen.fleet.carrier_group import CarrierGroupGenerator
+from gen.fleet.lha_group import LHAGroupGenerator
+
+
+def generate_carrier_group(faction:str, game, ground_object):
+    """
+    This generate a carrier group
+    :param parentCp: The parent control point
+    :param ground_object: The ground object which will own the ship group
+    :param country: Owner country
+    :return: Nothing, but put the group reference inside the ground object
+    """
+    generator = CarrierGroupGenerator(game, ground_object, db.FACTIONS[faction])
+    generator.generate()
+    return generator.get_generated_group()
+
+
+def generate_lha_group(faction:str, game, ground_object):
+    """
+    This generate a lha carrier group
+    :param parentCp: The parent control point
+    :param ground_object: The ground object which will own the ship group
+    :param country: Owner country
+    :return: Nothing, but put the group reference inside the ground object
+    """
+    generator = LHAGroupGenerator(game, ground_object, db.FACTIONS[faction])
+    generator.generate()
+    return generator.get_generated_group()

gen/flights/ai_flight_planner.py

@@ -0,0 +1,349 @@
+import math
+import operator
+import typing
+import random
+
+from game import db
+from gen import Conflict
+from gen.flights.ai_flight_planner_db import INTERCEPT_CAPABLE, CAP_CAPABLE, CAS_CAPABLE, SEAD_CAPABLE
+from gen.flights.flight import Flight, FlightType, FlightWaypoint
+
+# TODO : Ideally should be based on the aircraft type instead / Availability of fuel
+STRIKE_MAX_RANGE = 1500000
+SEAD_MAX_RANGE = 1500000
+
+MAX_NUMBER_OF_INTERCEPTION_GROUP = 3
+MISSION_DURATION = 120 # in minutes
+CAP_EVERY_X_MINUTES = 20
+CAS_EVERY_X_MINUTES = 30
+SEAD_EVERY_X_MINUTES = 40
+
+
+class FlightPlanner:
+
+    def __init__(self, from_cp, game):
+        # TODO : have the flight planner depend on a 'stance' setting : [Defensive, Aggresive... etc] and faction doctrine
+        # TODO : the flight planner should plan package and operations
+        self.from_cp = from_cp
+        self.game = game
+        self.aircraft_inventory = {} # local copy of the airbase inventory
+
+    def reset(self):
+        """
+        Reset the planned flights and available units
+        """
+        self.aircraft_inventory = dict({k: v for k, v in self.from_cp.base.aircraft.items()})
+        self.interceptor_flights = []
+        self.cap_flights = []
+        self.cas_flights = []
+        self.strike_flights = []
+        self.sead_flights = []
+        self.custom_flights = []
+        self.flights = []
+        self.potential_sead_targets = []
+        self.potential_strike_targets = []
+
+    def plan_flights(self):
+
+        self.reset()
+        self.compute_sead_targets()
+        self.compute_strike_targets()
+
+        # The priority is to assign air-superiority fighter or interceptor to interception roles, so they can scramble if there is an attacker
+        #self.commision_interceptors()
+
+        # Then some CAP patrol for the next 2 hours
+        self.commision_barcap()
+
+        # Then setup cas
+        self.commision_cas()
+
+        # Then prepare some sead flights if required
+        self.commision_sead()
+
+        # TODO : commision STRIKE / ANTISHIP
+
+    def remove_flight(self, index):
+        try:
+            flight = self.flights[index]
+            if flight in self.interceptor_flights: self.interceptor_flights.remove(flight)
+            if flight in self.cap_flights: self.cap_flights.remove(flight)
+            if flight in self.cas_flights: self.cas_flights.remove(flight)
+            if flight in self.strike_flights: self.strike_flights.remove(flight)
+            if flight in self.sead_flights: self.sead_flights.remove(flight)
+            if flight in self.custom_flights: self.custom_flights.remove(flight)
+            self.flights.remove(flight)
+        except IndexError:
+            return
+
+
+    def commision_interceptors(self):
+        """
+        Pick some aircraft to assign them to interception roles
+        """
+
+        # At least try to generate one interceptor group
+        number_of_interceptor_groups = min(max(sum([v for k, v in self.aircraft_inventory.items()]) / 4, MAX_NUMBER_OF_INTERCEPTION_GROUP), 1)
+        possible_interceptors = [k for k in self.aircraft_inventory.keys() if k in INTERCEPT_CAPABLE]
+
+        if len(possible_interceptors) <= 0:
+            possible_interceptors = [k for k,v in self.aircraft_inventory.items() if k in CAP_CAPABLE and v >= 2]
+
+        if number_of_interceptor_groups > 0:
+            inventory = dict({k: v for k, v in self.aircraft_inventory.items() if k in possible_interceptors})
+            for i in range(number_of_interceptor_groups):
+                try:
+                    unit = random.choice([k for k,v in inventory.items() if v >= 2])
+                except IndexError:
+                    break
+                inventory[unit] = inventory[unit] - 2
+                flight = Flight(unit, 2, self.from_cp, FlightType.INTERCEPTION)
+                flight.points = []
+
+                self.interceptor_flights.append(flight)
+                self.flights.append(flight)
+
+            # Update inventory
+            for k, v in inventory.items():
+                self.aircraft_inventory[k] = v
+
+    def commision_barcap(self):
+        """
+        Pick some aircraft to assign them to defensive CAP roles (BARCAP)
+        """
+
+        possible_aircraft = [k for k, v in self.aircraft_inventory.items() if k in CAP_CAPABLE and v >= 2]
+        inventory = dict({k: v for k, v in self.aircraft_inventory.items() if k in possible_aircraft})
+
+        offset = random.randint(0,5)
+        for i in range(int(MISSION_DURATION/CAP_EVERY_X_MINUTES)):
+
+            try:
+                unit = random.choice([k for k, v in inventory.items() if v >= 2])
+            except IndexError:
+                break
+
+            inventory[unit] = inventory[unit] - 2
+            flight = Flight(unit, 2, self.from_cp, FlightType.BARCAP)
+
+            # Flight path : fly over each ground object (TODO : improve)
+            flight.points = []
+            flight.scheduled_in = offset + i*random.randint(CAP_EVERY_X_MINUTES-5, CAP_EVERY_X_MINUTES+5)
+
+            patrol_alt = random.randint(3600, 7000)
+
+            patrolled = []
+            for ground_object in self.from_cp.ground_objects:
+                if ground_object.group_id not in patrolled and not ground_object.airbase_group:
+                    point = FlightWaypoint(ground_object.position.x, ground_object.position.y, patrol_alt)
+                    point.name = "Patrol point"
+                    point.description = "Patrol #" + str(len(flight.points))
+                    point.pretty_name = "Patrol #" + str(len(flight.points))
+                    flight.points.append(point)
+                    patrolled.append(ground_object.group_id)
+
+            if len(flight.points) == 0:
+                for i in range(3):
+                    pos = self.from_cp.position.point_from_heading(random.randint(0,360), random.randint(30000, 80000))
+                    point = FlightWaypoint(pos.x, pos.y, patrol_alt)
+                    point.name = "Patrol point"
+                    point.description = "Patrol #" + str(len(flight.points))
+                    point.pretty_name = "Patrol #" + str(len(flight.points))
+                    flight.points.append(point)
+
+            self.cap_flights.append(flight)
+            self.flights.append(flight)
+
+        # Update inventory
+        for k, v in inventory.items():
+            self.aircraft_inventory[k] = v
+
+    def commision_cas(self):
+        """
+        Pick some aircraft to assign them to CAS
+        """
+
+        possible_aircraft = [k for k, v in self.aircraft_inventory.items() if k in CAS_CAPABLE and v >= 2]
+        inventory = dict({k: v for k, v in self.aircraft_inventory.items() if k in possible_aircraft})
+        cas_location = self._get_cas_locations()
+
+        if len(cas_location) > 0:
+
+            offset = random.randint(0,5)
+            for i in range(int(MISSION_DURATION/CAS_EVERY_X_MINUTES)):
+
+                try:
+                    unit = random.choice([k for k, v in inventory.items() if v >= 2])
+                except IndexError:
+                    break
+
+                inventory[unit] = inventory[unit] - 2
+                flight = Flight(unit, 2, self.from_cp, FlightType.CAS)
+
+                flight.points = []
+                flight.scheduled_in = offset + i*random.randint(CAS_EVERY_X_MINUTES-5, CAS_EVERY_X_MINUTES+5)
+
+                location = random.choice(cas_location)
+                ingress, heading, distance = Conflict.frontline_vector(self.from_cp, location, self.game.theater)
+                center = ingress.point_from_heading(heading, distance/2)
+                egress = ingress.point_from_heading(heading, distance)
+
+                flight.targets.append(center)
+
+                ingress_point = FlightWaypoint(ingress.x, ingress.y, 1000)
+                ingress_point.name = "INGRESS"
+                ingress_point.pretty_name = "INGRESS"
+                ingress_point.description = "Ingress into CAS area"
+                flight.points.append(ingress_point)
+
+                center_point = FlightWaypoint(center.x, center.y, 1000)
+                center_point.description = "Provide CAS"
+                center_point.name = "CAS"
+                center_point.pretty_name = "INGRESS"
+                flight.points.append(center_point)
+
+                egress_point = FlightWaypoint(egress.x, egress.y, 1000)
+                egress_point.description = "Egress from CAS area"
+                egress_point.name = "EGRESS"
+                egress_point.pretty_name = "EGRESS"
+                flight.points.append(egress_point)
+
+                self.cas_flights.append(flight)
+                self.flights.append(flight)
+
+            # Update inventory
+            for k, v in inventory.items():
+                self.aircraft_inventory[k] = v
+
+    def commision_sead(self):
+        """
+        Pick some aircraft to assign them to SEAD tasks
+        """
+
+        possible_aircraft = [k for k, v in self.aircraft_inventory.items() if k in SEAD_CAPABLE and v >= 2]
+        inventory = dict({k: v for k, v in self.aircraft_inventory.items() if k in possible_aircraft})
+
+        if len(self.potential_sead_targets) > 0:
+
+            offset = random.randint(0,5)
+            for i in range(int(MISSION_DURATION/SEAD_EVERY_X_MINUTES)):
+
+                if len(self.potential_sead_targets) <= 0:
+                    break
+
+                try:
+                    unit = random.choice([k for k, v in inventory.items() if v >= 2])
+                except IndexError:
+                    break
+
+                inventory[unit] = inventory[unit] - 2
+                flight = Flight(unit, 2, self.from_cp, random.choice([FlightType.SEAD, FlightType.DEAD]))
+
+                flight.points = []
+                flight.scheduled_in = offset + i*random.randint(SEAD_EVERY_X_MINUTES-5, SEAD_EVERY_X_MINUTES+5)
+
+                location = self.potential_sead_targets[0][0]
+                self.potential_sead_targets.pop(0)
+
+                point = FlightWaypoint(location.position.x, location.position.y, 1000)
+                point.description = "SEAD"
+                point.pretty_name = "SEAD"
+                point.targets.append(location)
+                flight.points.append(point)
+
+                self.sead_flights.append(flight)
+                self.flights.append(flight)
+
+            # Update inventory
+            for k, v in inventory.items():
+                self.aircraft_inventory[k] = v
+
+    def _get_cas_locations(self):
+        cas_locations = []
+        for cp in self.from_cp.connected_points:
+            if cp.captured != self.from_cp.captured:
+                cas_locations.append(cp)
+        return cas_locations
+
+    def compute_strike_targets(self):
+        """
+        @return a list of potential strike targets in range
+        """
+
+        # target, distance
+        self.potential_strike_targets = []
+
+        for cp in [c for c in self.game.theater.controlpoints if c.captured != self.from_cp.captured]:
+
+            # Compute distance to current cp
+            distance = math.hypot(cp.position.x - self.from_cp.position.x,
+                                  cp.position.y - self.from_cp.position.y)
+
+            if distance > 2*STRIKE_MAX_RANGE:
+                # Then it's unlikely any child ground object is in range
+                return
+
+            added_group = []
+            for g in cp.ground_objects:
+                if g.group_id in added_group: continue
+
+                # Compute distance to current cp
+                distance = math.hypot(cp.position.x - self.from_cp.position.x,
+                                      cp.position.y - self.from_cp.position.y)
+
+                if distance < SEAD_MAX_RANGE:
+                    self.potential_strike_targets.append((g, distance))
+                    added_group.append(g)
+
+        self.potential_strike_targets.sort(key=operator.itemgetter(1))
+
+    def compute_sead_targets(self):
+        """
+        @return a list of potential sead targets in range
+        """
+
+        # target, distance
+        self.potential_sead_targets = []
+
+        for cp in [c for c in self.game.theater.controlpoints if c.captured != self.from_cp.captured]:
+
+            # Compute distance to current cp
+            distance = math.hypot(cp.position.x - self.from_cp.position.x,
+                                  cp.position.y - self.from_cp.position.y)
+
+            # Then it's unlikely any ground object is range
+            if distance > 2*SEAD_MAX_RANGE:
+                return
+
+            for g in cp.ground_objects:
+
+                if g.dcs_identifier == "AA":
+
+                    # Check that there is at least one unit with a radar in the ground objects unit groups
+                    number_of_units = sum([len([r for r in group.units if hasattr(db.unit_type_from_name(r.type), "detection_range")
+                                                and db.unit_type_from_name(r.type).detection_range > 1000]) for group in g.groups])
+                    if number_of_units <= 0:
+                        continue
+
+                    # Compute distance to current cp
+                    distance = math.hypot(cp.position.x - self.from_cp.position.x,
+                                          cp.position.y - self.from_cp.position.y)
+
+                    if distance < SEAD_MAX_RANGE:
+                        self.potential_sead_targets.append((g, distance))
+
+        self.potential_sead_targets.sort(key=operator.itemgetter(1))
+
+    def __repr__(self):
+        return "-"*40 + "\n" + self.from_cp.name + " planned flights :\n"\
+               + "-"*40 + "\n" + "\n".join([repr(f) for f in self.flights]) + "\n" + "-"*40
+
+    def get_available_aircraft(self):
+        base_aircraft_inventory = dict({k: v for k, v in self.from_cp.base.aircraft.items()})
+        for f in self.flights:
+            if f.unit_type in base_aircraft_inventory.keys():
+                base_aircraft_inventory[f.unit_type] = base_aircraft_inventory[f.unit_type] - f.count
+                if base_aircraft_inventory[f.unit_type] <= 0:
+                    del base_aircraft_inventory[f.unit_type]
+        return base_aircraft_inventory
+

gen/flights/ai_flight_planner_db.py

@@ -0,0 +1,185 @@
+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
+INTERCEPT_CAPABLE = [
+    MiG_21Bis,
+    MiG_25PD,
+    MiG_31,
+
+    M_2000C,
+    Mirage_2000_5,
+
+    F_14B,
+    F_15C,
+
+]
+
+# Used for CAP, Escort, and intercept if there is not a specialised aircraft available
+CAP_CAPABLE = [
+    MiG_15bis,
+    MiG_19P,
+    MiG_21Bis,
+    MiG_23MLD,
+    MiG_29A,
+    MiG_29G,
+    MiG_29S,
+
+    Su_27,
+    J_11A,
+    JF_17,
+    Su_30,
+    Su_33,
+
+    M_2000C,
+    Mirage_2000_5,
+
+    F_86F_Sabre,
+    F_4E,
+    F_5E_3,
+    F_14B,
+    F_15C,
+    F_16C_50,
+    FA_18C_hornet,
+
+    C_101CC,
+    L_39ZA,
+
+    P_51D_30_NA,
+    P_51D,
+
+    SpitfireLFMkIXCW,
+    SpitfireLFMkIX,
+
+    Bf_109K_4,
+    FW_190D9,
+    FW_190A8,
+]
+
+# USed for CAS (Close air support) and BAI (Battlefield Interdiction)
+CAS_CAPABLE = [
+
+    MiG_15bis,
+    MiG_29A,
+    MiG_27K,
+    MiG_29S,
+
+    Su_17M4,
+    Su_24M,
+    Su_24MR,
+    Su_25,
+    Su_25T,
+    Su_25TM,
+    Su_34,
+
+    JF_17,
+
+    M_2000C,
+
+    A_10A,
+    A_10C,
+    AV8BNA,
+
+    F_86F_Sabre,
+    F_5E_3,
+    F_14B,
+    F_16C_50,
+    FA_18C_hornet,
+
+    C_101CC,
+    L_39ZA,
+    AJS37,
+
+    SA342M,
+    SA342L,
+
+    AH_64A,
+    AH_64D,
+
+    UH_1H,
+
+    Mi_8MT,
+    Mi_28N,
+    Mi_24V,
+    Ka_50,
+
+    P_51D_30_NA,
+    P_51D,
+
+    SpitfireLFMkIXCW,
+    SpitfireLFMkIX,
+
+    Bf_109K_4,
+    FW_190D9,
+    FW_190A8,
+]
+
+# Aircraft used for SEAD / DEAD tasks
+SEAD_CAPABLE = [
+    F_4E,
+    FA_18C_hornet,
+    F_16C_50,
+    AV8BNA,
+    JF_17,
+
+    Su_24M,
+    Su_25T,
+    Su_25TM,
+    Su_17M4,
+    Su_30,
+    Su_34,
+    MiG_27K,
+]
+
+# Aircraft used for Strike mission
+STRIKE_CAPABLE = [
+    MiG_15bis,
+    MiG_29A,
+    MiG_27K,
+    MiG_29S,
+
+    Su_17M4,
+    Su_24M,
+    Su_24MR,
+    Su_25,
+    Su_25T,
+    Su_34,
+
+    JF_17,
+
+    M_2000C,
+
+    A_10A,
+    A_10C,
+    AV8BNA,
+
+    F_86F_Sabre,
+    F_5E_3,
+    F_14B,
+    F_16C_50,
+    FA_18C_hornet,
+
+    C_101CC,
+    L_39ZA,
+    AJS37,
+
+    M_2000C,
+
+    P_51D_30_NA,
+    P_51D,
+
+    SpitfireLFMkIXCW,
+    SpitfireLFMkIX,
+
+    Bf_109K_4,
+    FW_190D9,
+    FW_190A8,
+]
+
+ANTISHIP_CAPABLE = [
+    Su_24M,
+    F_A_18C,
+    AV8BNA,
+    JF_17
+]

gen/flights/flight.py

@@ -0,0 +1,85 @@
+from enum import Enum
+from typing import List
+
+from dcs.mission import StartType
+from dcs.unittype import UnitType
+
+from game import db
+
+
+class FlightType(Enum):
+    CAP = 0
+    TARCAP = 1
+    BARCAP = 2
+    CAS = 3
+    INTERCEPTION = 4
+    STRIKE = 5
+    ANTISHIP = 6
+    SEAD = 7
+    DEAD = 8
+    ESCORT = 9
+    BAI = 10
+
+    # Helos
+    TROOP_TRANSPORT = 11
+    LOGISTICS = 12
+    EVAC = 13
+
+    ELINT = 14
+    RECON = 15
+    EWAR = 16
+
+
+class FlightWaypoint():
+
+    def __init__(self, x: float, y: float, alt=0):
+        self.x = x
+        self.y = y
+        self.alt = alt
+        self.name = ""
+        self.description = ""
+        self.targets = []
+        self.obj_name = ""
+        self.pretty_name = ""
+
+
+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"
+
+    # 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 = []
+        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) \
+               + " in " + str(self.scheduled_in) + " minutes (" + str(len(self.points)) + " wpt)"
+
+
+# Test
+if __name__ == '__main__':
+    from 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/ground_forces/ai_ground_planner.py

@@ -0,0 +1,275 @@
+import random
+from enum import Enum
+
+from dcs.vehicles import *
+
+from gen import Conflict
+from gen.ground_forces.combat_stance import CombatStance
+from theater import ControlPoint
+
+TYPE_TANKS = [
+    Armor.MBT_T_55,
+    Armor.MBT_T_72B,
+    Armor.MBT_T_80U,
+    Armor.MBT_T_90,
+    Armor.MBT_Leopard_2,
+    Armor.MBT_Leopard_1A3,
+    Armor.MBT_Leclerc,
+    Armor.MBT_Challenger_II,
+    Armor.MBT_M1A2_Abrams,
+    Armor.MBT_M60A3_Patton,
+    Armor.MBT_Merkava_Mk__4,
+    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.MT_M4_Sherman,
+    Armor.MT_M4A4_Sherman_Firefly,
+    Armor.StuG_IV,
+    Armor.ZTZ_96B
+]
+
+TYPE_ATGM = [
+    Armor.ATGM_M1045_HMMWV_TOW,
+    Armor.ATGM_M1134_Stryker,
+    Armor.IFV_BMP_2,
+]
+
+TYPE_IFV = [
+    Armor.IFV_BMP_3,
+    Armor.IFV_BMP_2,
+    Armor.IFV_BMP_1,
+    Armor.IFV_Marder,
+    Armor.IFV_MCV_80,
+    Armor.IFV_LAV_25,
+    Armor.IFV_Sd_Kfz_234_2_Puma,
+    Armor.IFV_M2A2_Bradley,
+    Armor.IFV_BMD_1,
+    Armor.ZBD_04A,
+    Armor.APC_Sd_Kfz_251,
+    Armor.IFV_Sd_Kfz_234_2_Puma,
+]
+
+TYPE_APC = [
+    Armor.APC_M1043_HMMWV_Armament,
+    Armor.APC_M1126_Stryker_ICV,
+    Armor.APC_M113,
+    Armor.APC_BTR_80,
+    Armor.APC_MTLB,
+    Armor.APC_M2A1,
+    Armor.APC_Cobra,
+    Armor.APC_Sd_Kfz_251,
+    Armor.APC_AAV_7,
+    Armor.TPz_Fuchs,
+    Armor.ARV_BRDM_2,
+    Armor.ARV_BTR_RD,
+    Armor.ARV_MTLB_U_BOMAN,
+    Armor.M30_Cargo_Carrier,
+    Armor.APC_M2A1,
+]
+
+TYPE_ARTILLERY = [
+    Artillery.MLRS_9A52_Smerch,
+    Artillery.SPH_2S1_Gvozdika,
+    Artillery.SPH_2S3_Akatsia,
+    Artillery.MLRS_BM_21_Grad,
+    Artillery.MLRS_9K57_Uragan_BM_27,
+    Artillery.SPH_M109_Paladin,
+    Artillery.MLRS_M270,
+    Artillery.SPH_2S9_Nona,
+    Artillery.SpGH_Dana,
+    Artillery.SPH_2S19_Msta,
+    Artillery.M12_GMC,
+    Artillery.MLRS_FDDM,
+    Artillery.Sturmpanzer_IV_Brummbär
+]
+
+TYPE_LOGI = [
+    Unarmed.Transport_M818,
+    Unarmed.Transport_KAMAZ_43101,
+    Unarmed.Transport_Ural_375,
+    Unarmed.Transport_GAZ_66,
+    Unarmed.Transport_GAZ_3307,
+    Unarmed.Transport_GAZ_3308,
+    Unarmed.Transport_Ural_4320_31_Armored,
+    Unarmed.Transport_Ural_4320T,
+    Unarmed.Blitz_3_6_6700A,
+    Unarmed.Kübelwagen_82,
+    Unarmed.Sd_Kfz_7,
+    Unarmed.Sd_Kfz_2,
+    Unarmed.Willys_MB,
+    Unarmed.Land_Rover_109_S3,
+    Unarmed.Land_Rover_101_FC,
+]
+
+TYPE_INFANTRY = [
+    Infantry.Infantry_Soldier_Insurgents,
+    Infantry.Soldier_AK,
+    Infantry.Infantry_M1_Garand,
+    Infantry.Infantry_Mauser_98,
+    Infantry.Infantry_SMLE_No_4_Mk_1,
+    Infantry.Georgian_soldier_with_M4,
+    Infantry.Infantry_Soldier_Rus,
+    Infantry.Paratrooper_AKS,
+    Infantry.Paratrooper_RPG_16,
+    Infantry.Soldier_M249,
+    Infantry.Infantry_M4,
+    Infantry.Soldier_RPG,
+]
+
+MAX_COMBAT_GROUP_PER_CP = 10
+
+class CombatGroupRole(Enum):
+    TANK = 1
+    APC = 2
+    IFV = 3
+    ARTILLERY = 4
+    SHORAD = 5
+    LOGI = 6
+    INFANTRY = 7
+    ATGM = 8
+
+
+DISTANCE_FROM_FRONTLINE = {
+    CombatGroupRole.TANK:2800,
+    CombatGroupRole.APC:7000,
+    CombatGroupRole.IFV:3000,
+    CombatGroupRole.ARTILLERY:14000,
+    CombatGroupRole.SHORAD:12000,
+    CombatGroupRole.LOGI:18000,
+    CombatGroupRole.INFANTRY:2800,
+    CombatGroupRole.ATGM:5500
+}
+
+GROUP_SIZES_BY_COMBAT_STANCE = {
+    CombatStance.DEFENSIVE: [2, 4, 6],
+    CombatStance.AGGRESIVE: [2, 4, 6],
+    CombatStance.RETREAT: [2, 4, 6, 8],
+    CombatStance.BREAKTHROUGH: [4, 6, 6, 8],
+    CombatStance.ELIMINATION: [2, 4, 4, 4, 6],
+    CombatStance.AMBUSH: [1, 1, 2, 2, 2, 2, 4]
+}
+
+
+class CombatGroup:
+
+    def __init__(self, role:CombatGroupRole):
+        self.units = []
+        self.role = role
+        self.assigned_enemy_cp = None
+        self.start_position = None
+
+    def __str__(self):
+        s = ""
+        s += "ROLE : " + str(self.role) + "\n"
+        if len(self.units) > 0:
+            s += "UNITS " + self.units[0].name + " * " + str(len(self.units))
+        return s
+
+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 = []
+        self.apc_group = []
+        self.ifv_group = []
+        self.art_group = []
+        self.atgm_group = []
+        self.logi_groups = []
+        self.shorad_groups = []
+
+        self.units_per_cp = {}
+        for cp in self.connected_enemy_cp:
+            self.units_per_cp[cp.id] = []
+        self.reserve = []
+
+
+    def plan_groundwar(self):
+
+        if hasattr(self.cp, 'stance'):
+            group_size_choice = GROUP_SIZES_BY_COMBAT_STANCE[self.cp.stance]
+        else:
+            self.cp.stance = CombatStance.DEFENSIVE
+            group_size_choice = GROUP_SIZES_BY_COMBAT_STANCE[CombatStance.DEFENSIVE]
+
+        # Create combat groups and assign them randomly to each enemy CP
+        for key in self.cp.base.armor.keys():
+
+            role = None
+            collection = None
+            if key in TYPE_TANKS:
+                collection = self.tank_groups
+                role = CombatGroupRole.TANK
+            elif key in TYPE_APC:
+                collection = self.apc_group
+                role = CombatGroupRole.APC
+            elif key in TYPE_ARTILLERY:
+                collection = self.art_group
+                role = CombatGroupRole.ARTILLERY
+            elif key in TYPE_IFV:
+                collection = self.ifv_group
+                role = CombatGroupRole.IFV
+            elif key in TYPE_LOGI:
+                collection = self.logi_groups
+                role = CombatGroupRole.LOGI
+            elif key in TYPE_ATGM:
+                collection = self.atgm_group
+                role = CombatGroupRole.ATGM
+            else:
+                print("Warning unit type not handled by ground generator")
+                print(key)
+                continue
+
+            available = self.cp.base.armor[key]
+            while available > 0:
+                n = random.choice(group_size_choice)
+                if n > available:
+                    if available >= 2:
+                        n = 2
+                    else:
+                        n = 1
+                available -= n
+
+                group = CombatGroup(role)
+                if len(self.connected_enemy_cp) > 0:
+                    enemy_cp = random.choice(self.connected_enemy_cp).id
+                    self.units_per_cp[enemy_cp].append(group)
+                    group.assigned_enemy_cp = enemy_cp
+                else:
+                    self.reserve.append(group)
+                    group.assigned_enemy_cp = "__reserve__"
+
+                for i in range(n):
+                    group.units.append(key)
+                collection.append(group)
+
+        print("------------------")
+        print("Ground Planner : ")
+        print(self.cp.name)
+        print("------------------")
+        for key in self.units_per_cp.keys():
+            print("For : #" + str(key))
+            for group in self.units_per_cp[key]:
+                print(str(group))
+
+
+
+
+
+
+
+
+

gen/ground_forces/combat_stance.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class CombatStance(Enum):
+    DEFENSIVE = 0    # Unit will adopt defensive stance with medium group of units
+    AGGRESIVE = 1    # Unit will attempt to make progress with medium sized group of units
+    RETREAT = 2      # Unit will retreat
+    BREAKTHROUGH = 3 # Unit will attempt a breakthrough, rushing forward very aggresively with big group of armored units, and even less armored units will move aggresively
+    ELIMINATION = 4  # Unit will progress aggresively toward anemy units, attempting to eliminate the ennemy force
+    AMBUSH = 5       # Units will adopt a defensive stance a bit different from 'DEFENSIVE', ATGM & INFANTRY with RPG will be located on frontline with the armored units. (The groups of units will be smaller)
+

gen/groundobjectsgen.py

@@ -1,6 +1,7 @@
 import logging
 
 from game import db
+from game.db import unit_type_from_name
 from .conflictgen import *
 from .naming import *
 
@@ -36,57 +37,126 @@ class GroundObjectsGenerator:
             position = position.point_from_heading(0, i * 275)
 
             yield self.m.farp(
-                country=self.m.country(self.game.player),
+                country=self.m.country(self.game.player_country),
                 name="FARP",
                 position=position,
             )
 
     def generate(self):
-        side = self.m.country(self.game.enemy)
 
         cp = None  # type: ControlPoint
-        if self.conflict.attackers_side.name == self.game.player:
+        if self.conflict.attackers_country.name == self.game.player_country:
             cp = self.conflict.to_cp
         else:
             cp = self.conflict.from_cp
 
-        for ground_object in cp.ground_objects:
-            if ground_object.dcs_identifier == "AA":
-                if ground_object.position.distance_to_point(self.conflict.from_cp.position) < AA_CP_MIN_DISTANCE:
-                    continue
+        consumed_farps = set()
 
-                if ground_object.is_dead:
-                    continue
 
-                unit_type = random.choice(self.game.commision_unit_types(cp, AirDefence))
-                assert unit_type is not None, "Cannot find unit type for GroundObject defense ({})!".format(cp)
+        for cp in self.game.theater.controlpoints:
 
-                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 defense object identifier {} with mission id {}".format(group.name, group.id))
+            if cp.captured:
+                country = self.game.player_country
             else:
-                if ground_object.dcs_identifier in warehouse_map:
-                    static_type = warehouse_map[ground_object.dcs_identifier]
+                country = self.game.enemy_country
+            side = self.m.country(country)
+
+            for ground_object in cp.ground_objects:
+                if ground_object.dcs_identifier == "AA":
+                    for g in ground_object.groups:
+                        if len(g.units) > 0:
+
+                            utype = unit_type_from_name(g.units[0].type)
+
+                            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)
+                            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
+                                    vg.add_unit(vehicle)
+                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)
+                            sg = self.m.ship_group(side, g.name, utype, position=g.position, heading=g.units[0].heading)
+
+                            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
+                                    sg.add_unit(ship)
+
+                            # TODO : make sure the point is not on Land
+                            sg.add_waypoint(sg.points[0].position.point_from_heading(g.units[0].heading, 100000))
+
+                            # SET UP TACAN
+                            modeChannel = "X" if not cp.tacanY else "Y"
+                            sg.points[0].tasks.append(ActivateBeaconCommand(channel=cp.tacanN, modechannel=modeChannel, callsign=cp.tacanI, unit_id=sg.units[0].id))
+
                 else:
-                    static_type = fortification_map[ground_object.dcs_identifier]
+                    if ground_object.dcs_identifier in warehouse_map:
+                        static_type = warehouse_map[ground_object.dcs_identifier]
+                    else:
+                        static_type = fortification_map[ground_object.dcs_identifier]
 
-                if not static_type:
-                    print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
-                    continue
+                    if not static_type:
+                        print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
+                        continue
 
-                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,
-                )
+                    if ground_object.group_id not in consumed_farps:
+                        consumed_farps.add(ground_object.group_id)
+                        if random.randint(0, 100) > 50:
+                            farp_aa(
+                                self.m,
+                                side,
+                                ground_object.string_identifier,
+                                ground_object.position,
+                            )
+
+                    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))
+
+
+def farp_aa(mission_obj, country, name, position: mapping.Point):
+    """
+    Add AAA to a FARP :)
+    :param mission_obj:
+    :param country:
+    :param name:
+    :param position:
+    :return:
+    """
+    vg = unitgroup.VehicleGroup(mission_obj.next_group_id(), mission_obj.string(name))
+
+    units = [
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.AAA_ZU_23_Closed,
+    ]
+
+    v = mission_obj.vehicle(name + "_AAA", random.choice(units))
+    v.position.x = position.x - random.randint(5, 30)
+    v.position.y = position.y - random.randint(5, 30)
+    v.heading = random.randint(0, 359)
+    vg.add_unit(v)
+
+    wp = vg.add_waypoint(vg.units[0].position, PointAction.OffRoad, 0)
+    wp.ETA_locked = True
+
+    country.add_vehicle_group(vg)
+    return vg
 
-                logging.info("generated {}object identifier {} with mission id {}".format("dead " if ground_object.is_dead else "", group.name, group.id))

gen/naming.py

@@ -1,12 +1,55 @@
 from game import db
+import random
 
+ALPHA_MILITARY = ["Alpha","Bravo","Charlie","Delta","Echo","Foxtrot",
+                  "Golf","Hotel","India","Juliet","Kilo","Lima","Mike",
+                  "November","Oscar","Papa","Quebec","Romeo","Sierra",
+                  "Tango","Uniform","Victor","Whisky","XRay","Yankee",
+                  "Zulu","Zero"]
 
 class NameGenerator:
     number = 0
 
-    def next_unit_name(self, country, unit_type):
+    ANIMALS = [
+        "SHARK", "TORTOISE", "BAT", "PANGOLIN", "AARDWOLF",
+        "MONKEY", "BUFFALO", "DOG", "BOBCAT", "LYNX", "PANTHER", "TIGER",
+        "LION", "OWL", "BUTTERFLY", "BISON", "DUCK", "COBRA", "MAMBA",
+        "DOLPHIN", "PHEASANT", "ARMADILLLO", "RACOON", "ZEBRA", "COW", "COYOTE", "FOX",
+        "LIGHTFOOT", "COTTONMOUTH", "TAURUS", "VIPER", "CASTOR", "GIRAFFE", "SNAKE",
+        "MONSTER", "ALBATROSS", "HAWK", "DOVE", "MOCKINGBIRD", "GECKO", "ORYX", "GORILLA",
+        "HARAMBE", "GOOSE", "MAVERICK", "HARE", "JACKAL", "LEOPARD", "CAT", "MUSK", "ORCA",
+        "OCELOT", "BEAR", "PANDA", "GULL", "PENGUIN", "PYTHON", "RAVEN", "DEER", "MOOSE",
+        "REINDEER", "SHEEP", "GAZELLE", "INSECT", "VULTURE", "WALLABY", "KANGAROO", "KOALA",
+        "KIWI", "WHALE", "FISH", "RHINO", "HIPPO", "RAT", "WOODPECKER", "WORM", "BABOON",
+        "YAK", "SCORPIO", "HORSE", "POODLE", "CENTIPEDE", "CHICKEN", "CHEETAH", "CHAMELEON",
+        "CATFISH", "CATERPILLAR", "CARACAL", "CAMEL", "CAIMAN", "BARRACUDA", "BANDICOOT",
+        "ALLIGATOR", "BONGO", "CORAL", "ELEPHANT", "ANTELOPE", "CRAB", "DACHSHUND", "DODO",
+        "FLAMINGO", "FERRET", "FALCON", "BULLDOG", "DONKEY", "IGUANA", "TAMARIN", "HARRIER",
+        "GRIZZLY", "GREYHOUND", "GRASSHOPPER", "JAGUAR", "LADYBUG", "KOMODO", "DRAGON", "LIZARD",
+        "LLAMA", "LOBSTER", "OCTOPUS", "MANATEE", "MAGPIE", "MACAW", "OSTRICH", "OYSTER",
+        "MOLE", "MULE", "MOTH", "MONGOOSE", "MOLLY", "MEERKAT", "MOUSE", "PEACOCK", "PIKE", "ROBIN",
+        "RAGDOLL", "PLATYPUS", "PELICAN", "PARROT", "PORCUPINE", "PIRANHA", "PUMA", "PUG", "TAPIR",
+        "TERMITE", "URCHIN", "SHRIMP", "TURKEY", "TOUCAN", "TETRA", "HUSKY", "STARFISH", "SWAN",
+        "FROG", "SQUIRREL", "WALRUS", "WARTHOG", "CORGI", "WEASEL", "WOMBAT", "WOLVERINE", "MAMMOTH",
+        "TOAD", "WOLF", "ZEBU", "SEAL", "SKATE", "JELLYFISH", "MOSQUITO", "LOCUST", "SLUG", "SNAIL",
+        "HEDGEHOG", "PIGLET", "FENNEC", "BADGER", "ALPACA"
+    ]
+
+    def __init__(self):
+        self.number = 0
+        self.ANIMALS = NameGenerator.ANIMALS.copy()
+
+    def reset(self):
+        self.number = 0
+        self.ANIMALS = NameGenerator.ANIMALS.copy()
+
+    def next_unit_name(self, country, parent_base_id, unit_type):
         self.number += 1
-        return "unit|{}|{}|{}|".format(country.id, self.number, db.unit_type_name(unit_type))
+        return "unit|{}|{}|{}|{}|".format(country.id, self.number, parent_base_id, db.unit_type_name(unit_type))
+
+    def next_infantry_name(self, country, parent_base_id, unit_type):
+        self.number += 1
+        return "infantry|{}|{}|{}|{}|".format(country.id, self.number, parent_base_id, db.unit_type_name(unit_type))
 
     def next_basedefense_name(self):
         return "basedefense_aa|0|0|"
@@ -23,6 +66,16 @@ class NameGenerator:
         self.number += 1
         return "carrier|{}|{}|0|".format(country.id, self.number)
 
+    def random_objective_name(self):
+        if len(self.ANIMALS) == 0:
+            return random.choice(ALPHA_MILITARY).upper() + "#" + str(random.randint(0, 100))
+        else:
+            animal = random.choice(self.ANIMALS)
+            self.ANIMALS.remove(animal)
+            return animal
+
 
 namegen = NameGenerator()
 
+
+

gen/sam/aaa_bofors.py

@@ -0,0 +1,25 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class BoforsGenerator(GroupGenerator):
+    """
+    This generate a Bofors flak artillery group
+    """
+
+    def generate(self):
+        grid_x = random.randint(2, 4)
+        grid_y = random.randint(2, 4)
+
+        spacing = random.randint(10,40)
+
+        index = 0
+        for i in range(grid_x):
+            for j in range(grid_y):
+                index = index+1
+                self.add_unit(AirDefence.AAA_Bofors_40mm, "AAA#" + str(index),
+                              self.position.x + spacing*i,
+                              self.position.y + spacing*j, self.heading)

gen/sam/aaa_flak.py

@@ -0,0 +1,39 @@
+import random
+
+from dcs.vehicles import AirDefence, Unarmed
+
+from gen.sam.group_generator import GroupGenerator
+
+GFLAK = [AirDefence.AAA_Flak_Vierling_38, AirDefence.AAA_Flak_Vierling_38, AirDefence.AAA_Flak_18, AirDefence.AAA_Flak_36, AirDefence.AAA_Flak_37, AirDefence.AAA_Flak_38]
+
+class FlakGenerator(GroupGenerator):
+    """
+    This generate a German flak artillery group
+    """
+
+    def generate(self):
+        grid_x = random.randint(2, 4)
+        grid_y = random.randint(2, 4)
+
+        spacing = random.randint(10,40)
+
+        index = 0
+        mixed = random.choice([True, False])
+        unit_type = random.choice(GFLAK)
+
+        for i in range(grid_x):
+            for j in range(grid_y):
+                index = index+1
+                self.add_unit(unit_type, "AAA#" + str(index),
+                              self.position.x + spacing*i,
+                              self.position.y + spacing*j, self.heading)
+
+                if(mixed):
+                    unit_type = random.choice(GFLAK)
+
+        # Enough Opel truck to transport the guns
+        for i in range(grid_x):
+            for j in range(grid_y):
+                self.add_unit(Unarmed.Blitz_3_6_6700A, "AAA#" + str(index),
+                              self.position.x + 200 + 9*i,
+                              self.position.y + 9*j, 90)

gen/sam/aaa_zu23_insurgent.py

@@ -0,0 +1,25 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class ZU23InsurgentGenerator(GroupGenerator):
+    """
+    This generate a ZU23 insurgent flak artillery group
+    """
+
+    def generate(self):
+        grid_x = random.randint(2, 4)
+        grid_y = random.randint(2, 4)
+
+        spacing = random.randint(10,40)
+
+        index = 0
+        for i in range(grid_x):
+            for j in range(grid_y):
+                index = index+1
+                self.add_unit(AirDefence.AAA_ZU_23_Insurgent_Closed, "AAA#" + str(index),
+                              self.position.x + spacing*i,
+                              self.position.y + spacing*j, self.heading)

gen/sam/group_generator.py

@@ -0,0 +1,73 @@
+import math
+import random
+
+from dcs import unitgroup
+from dcs.point import PointAction
+from dcs.unit import Vehicle
+
+
+class GroupGenerator():
+
+    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.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
+
+    def generate(self):
+        raise NotImplementedError
+
+    def get_generated_group(self):
+        return self.vg
+
+    def add_unit(self, unit_type, name, pos_x, pos_y, heading):
+
+        nn = "cgroup|" + str(self.go.cp_id) + '|' + str(self.go.group_id) + '|' + str(self.go.group_identifier) + "|" + name
+
+        unit = Vehicle(self.game.next_unit_id(),
+                       nn, unit_type.id)
+        unit.position.x = pos_x
+        unit.position.y = pos_y
+        unit.heading = heading
+        self.vg.add_unit(unit)
+        return unit
+
+    def get_circular_position(self, num_units, launcher_distance, coverage=90):
+        """
+        Given a position on the map, array a group of units in a circle a uniform distance from the unit
+        :param num_units:
+            number of units to play on the circle
+        :param launcher_distance:
+            distance the units should be from the center unit
+        :param coverage:
+            0-360
+        :return:
+            list of tuples representing each unit location
+                [(pos_x, pos_y, heading), ...]
+        """
+        if coverage == 360:
+            # one of the positions is shared :'(
+            outer_offset = coverage / num_units
+        else:
+            outer_offset = coverage / (num_units - 1)
+
+        positions = []
+
+        if num_units % 2 == 0:
+            current_offset = self.heading - ((coverage / (num_units - 1)) / 2)
+        else:
+            current_offset = self.heading
+        current_offset -= outer_offset * (math.ceil(num_units / 2) - 1)
+        for x in range(1, num_units + 1):
+            positions.append((
+                self.position.x + launcher_distance * math.cos(math.radians(current_offset)),
+                self.position.y + launcher_distance * math.sin(math.radians(current_offset)),
+                current_offset,
+            ))
+            current_offset += outer_offset
+        return positions
+

gen/sam/sam_avenger.py

@@ -0,0 +1,19 @@
+import random
+
+from dcs.vehicles import AirDefence, Unarmed
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class AvengerGenerator(GroupGenerator):
+    """
+    This generate an Avenger group
+    """
+
+    def generate(self):
+        num_launchers = random.randint(2, 3)
+
+        self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x, self.position.y, self.heading)
+        positions = self.get_circular_position(num_launchers, launcher_distance=110, coverage=180)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_Avenger_M1097, "SPAA#" + str(i), position[0], position[1], position[2])

gen/sam/sam_chaparral.py

@@ -0,0 +1,19 @@
+import random
+
+from dcs.vehicles import AirDefence, Unarmed
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class ChaparralGenerator(GroupGenerator):
+    """
+    This generate a Chaparral group
+    """
+
+    def generate(self):
+        num_launchers = random.randint(2, 4)
+
+        self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x, self.position.y, self.heading)
+        positions = self.get_circular_position(num_launchers, launcher_distance=110, coverage=180)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_Chaparral_M48, "SPAA#" + str(i), position[0], position[1], position[2])

gen/sam/sam_gepard.py

@@ -0,0 +1,18 @@
+import random
+
+from dcs.vehicles import AirDefence, Unarmed
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class GepardGenerator(GroupGenerator):
+    """
+    This generate a Gepard group
+    """
+
+    def generate(self):
+        self.add_unit(AirDefence.SPAAA_Gepard, "SPAAA", self.position.x, self.position.y, self.heading)
+        if random.randint(0, 1) == 1:
+            self.add_unit(AirDefence.SPAAA_Gepard, "SPAAA2", self.position.x, self.position.y, self.heading)
+        self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x + 80, self.position.y, self.heading)
+

gen/sam/sam_group_generator.py

@@ -0,0 +1,100 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+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.sam_avenger import AvengerGenerator
+from gen.sam.sam_chaparral import ChaparralGenerator
+from gen.sam.sam_gepard import GepardGenerator
+from gen.sam.sam_hawk import HawkGenerator
+from gen.sam.sam_hq7 import HQ7Generator
+from gen.sam.sam_linebacker import LinebackerGenerator
+from gen.sam.sam_patriot import PatriotGenerator
+from gen.sam.sam_rapier import RapierGenerator
+from gen.sam.sam_roland import RolandGenerator
+from gen.sam.sam_sa10 import SA10Generator
+from gen.sam.sam_sa11 import SA11Generator
+from gen.sam.sam_sa13 import SA13Generator
+from gen.sam.sam_sa15 import SA15Generator
+from gen.sam.sam_sa19 import SA19Generator
+from gen.sam.sam_sa2 import SA2Generator
+from gen.sam.sam_sa3 import SA3Generator
+from gen.sam.sam_sa6 import SA6Generator
+from gen.sam.sam_sa8 import SA8Generator
+from gen.sam.sam_sa9 import SA9Generator
+from gen.sam.sam_vulcan import VulcanGenerator
+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
+
+SAM_MAP = {
+    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_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
+}
+
+def generate_anti_air_group(game, parent_cp, ground_object, faction:str):
+    """
+    This generate a SAM group
+    :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 = [u for u in db.FACTIONS[faction]["units"] if u in AirDefence.__dict__.values()]
+    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, 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, parent_cp, ground_object, faction)
+
+
+
+
+
+
+

gen/sam/sam_hawk.py

@@ -0,0 +1,25 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class HawkGenerator(GroupGenerator):
+    """
+    This generate an HAWK group
+    """
+
+    def generate(self):
+        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
+        self.add_unit(AirDefence.AAA_Vulcan_M163, "AAA", self.position.x + 20, self.position.y+30, self.heading)
+
+        num_launchers = random.randint(3, 6)
+        positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=180)
+
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_Hawk_LN_M192, "LN#" + str(i), position[0], position[1], position[2])

gen/sam/sam_hq7.py

@@ -0,0 +1,25 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class HQ7Generator(GroupGenerator):
+    """
+    This generate an HQ7 group
+    """
+
+    def generate(self):
+        self.add_unit(AirDefence.HQ_7_Self_Propelled_STR, "STR", self.position.x, self.position.y, self.heading)
+        self.add_unit(AirDefence.HQ_7_Self_Propelled_LN, "LN", self.position.x + 20, self.position.y, self.heading)
+
+        # Triple A for close range defense
+        self.add_unit(AirDefence.AAA_ZU_23_on_Ural_375, "AAA1", self.position.x + 20, self.position.y+30, self.heading)
+        self.add_unit(AirDefence.AAA_ZU_23_on_Ural_375, "AAA2", self.position.x - 20, self.position.y-30, self.heading)
+
+        num_launchers = random.randint(0, 3)
+        if num_launchers > 0:
+            positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
+            for i, position in enumerate(positions):
+                self.add_unit(AirDefence.HQ_7_Self_Propelled_LN, "LN#" + str(i), position[0], position[1], position[2])

gen/sam/sam_linebacker.py

@@ -0,0 +1,19 @@
+import random
+
+from dcs.vehicles import AirDefence, Unarmed
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class LinebackerGenerator(GroupGenerator):
+    """
+    This generate an m6 linebacker group
+    """
+
+    def generate(self):
+        num_launchers = random.randint(2, 4)
+
+        self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x, self.position.y, self.heading)
+        positions = self.get_circular_position(num_launchers, launcher_distance=110, coverage=180)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_Linebacker_M6, "M6#" + str(i), position[0], position[1], position[2])

gen/sam/sam_patriot.py

@@ -0,0 +1,30 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class PatriotGenerator(GroupGenerator):
+    """
+    This generate a Patriot group
+    """
+
+    def generate(self):
+        # Command Post
+        self.add_unit(AirDefence.SAM_Patriot_AMG_AN_MRC_137, "MRC", self.position.x, self.position.y, self.heading)
+        self.add_unit(AirDefence.SAM_Patriot_ECS_AN_MSQ_104, "MSQ", self.position.x + 30, self.position.y, self.heading)
+        self.add_unit(AirDefence.SAM_Patriot_ICC, "ICC", self.position.x + 60, self.position.y, self.heading)
+        self.add_unit(AirDefence.SAM_Patriot_EPP_III, "EPP", self.position.x, self.position.y + 30, self.heading)
+        self.add_unit(AirDefence.SAM_Patriot_STR_AN_MPQ_53, "ICC", self.position.x + 30, self.position.y + 30, self.heading)
+
+        num_launchers = random.randint(2, 4)
+        positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_Patriot_LN_M901, "LN#" + str(i), position[0], position[1], position[2])
+
+        # Short range protection for high value site
+        num_launchers = random.randint(2, 4)
+        positions = self.get_circular_position(num_launchers, launcher_distance=300, coverage=360)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.AAA_Vulcan_M163, "SPAAA#" + str(i), position[0], position[1], position[2])

gen/sam/sam_rapier.py

@@ -0,0 +1,21 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class RapierGenerator(GroupGenerator):
+    """
+    This generate a Rapier Group
+    """
+
+    def generate(self):
+        self.add_unit(AirDefence.Rapier_FSA_Blindfire_Tracker, "BT", self.position.x, self.position.y, self.heading)
+        self.add_unit(AirDefence.Rapier_FSA_Optical_Tracker, "OT", self.position.x + 20, self.position.y, self.heading)
+
+        num_launchers = random.randint(3, 6)
+        positions = self.get_circular_position(num_launchers, launcher_distance=80, coverage=240)
+
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.Rapier_FSA_Launcher, "LN#" + str(i), position[0], position[1], position[2])

gen/sam/sam_roland.py

@@ -0,0 +1,15 @@
+from dcs.vehicles import AirDefence, Unarmed
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class RolandGenerator(GroupGenerator):
+    """
+    This generate a Roland group
+    """
+
+    def generate(self):
+        self.add_unit(AirDefence.SAM_Roland_ADS, "ADS", self.position.x, self.position.y, self.heading)
+        self.add_unit(AirDefence.SAM_Roland_EWR, "EWR", self.position.x + 40, self.position.y, self.heading)
+        self.add_unit(Unarmed.Transport_M818, "TRUCK", self.position.x + 80, self.position.y, self.heading)
+

gen/sam/sam_sa10.py

@@ -0,0 +1,43 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class SA10Generator(GroupGenerator):
+    """
+    This generate a SA-10 group
+    """
+
+    def generate(self):
+        # Command Post
+        self.add_unit(AirDefence.SAM_SA_10_S_300PS_CP_54K6, "CP", self.position.x, self.position.y, self.heading)
+
+        # Search Radar
+        self.add_unit(AirDefence.SAM_SA_10_S_300PS_SR_5N66M, "SR1", self.position.x, self.position.y + 40, self.heading)
+
+        # Search radar for missiles (optionnal)
+        self.add_unit(AirDefence.SAM_SA_10_S_300PS_SR_64H6E, "SR2", self.position.x - 40, self.position.y, self.heading)
+
+        # 2 different launcher type (C & D)
+        num_launchers = random.randint(6, 8)
+        positions = self.get_circular_position(num_launchers, launcher_distance=120, coverage=360)
+        for i, position in enumerate(positions):
+            if i%2 == 0:
+                self.add_unit(AirDefence.SAM_SA_10_S_300PS_LN_5P85C, "LN#" + str(i), position[0], position[1], position[2])
+            else:
+                self.add_unit(AirDefence.SAM_SA_10_S_300PS_LN_5P85D, "LN#" + str(i), position[0], position[1], position[2])
+
+        # Then let's add short range protection to this high value site
+        # Sa-13 Strela are great for that
+        num_launchers = random.randint(2, 4)
+        positions = self.get_circular_position(num_launchers, launcher_distance=300, coverage=360)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_SA_13_Strela_10M3_9A35M3, "IR#" + str(i), position[0], position[1], position[2])
+
+        # And even some AA
+        num_launchers = random.randint(6, 8)
+        positions = self.get_circular_position(num_launchers, launcher_distance=350, coverage=360)
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.AAA_ZU_23_Emplacement, "AA#" + str(i), position[0], position[1], position[2])

gen/sam/sam_sa11.py

@@ -0,0 +1,21 @@
+import random
+
+from dcs.vehicles import AirDefence
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class SA11Generator(GroupGenerator):
+    """
+    This generate a SA-11 group
+    """
+
+    def generate(self):
+        self.add_unit(AirDefence.SAM_SA_11_Buk_CC_9S470M1, "CC", self.position.x, self.position.y, self.heading)
+        self.add_unit(AirDefence.SAM_SA_11_Buk_SR_9S18M1, "SR", self.position.x+20, self.position.y, self.heading)
+
+        num_launchers = random.randint(2, 4)
+        positions = self.get_circular_position(num_launchers, launcher_distance=140, coverage=180)
+
+        for i, position in enumerate(positions):
+            self.add_unit(AirDefence.SAM_SA_11_Buk_LN_9A310M1, "LN#" + str(i), position[0], position[1], position[2])