Changelog update

Fix activation trigger using wrong coalition when playing REDFOR side.

.gitignore

@@ -1,12 +1,13 @@
 *.pyc
 __pycache__
-build/*
+build/**
+resources/payloads/*.lua
+venv
 logs.txt
 .DS_Store
+dist/**
+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,6 +1,25 @@
-WIP [DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player liberation dynamic campaign. 
+![Logo](https://i.imgur.com/c2k18E1.png)
+
+[DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player semi dynamic campaign. 
+
+DCS Liberation uses [pydcs](http://github.com/pydcs/dcs) for mission generation
+and [Mist](https://github.com/mrSkortch/MissionScriptingTools) for mission scripting
+
+## Resources
+
+* [Getting Started](https://github.com/Khopa/dcs_liberation/wiki/Getting-started)
+
+* [Tutorials](https://github.com/Khopa/dcs_liberation/wiki/Tutorial-01-:-UI)
+
+## Development Guide (WIP)
+
+Develop is the main development branch which is updated regularly.
+Master branch will be updated less regularly and on release on new version. 
+
+Other branch might be used for feature development.
+
+**Note :**
+If you have errors with pydcs object not being defined, please check that you have the latest version installed. Sometimes the dev branch will use an even more recent version of pydcs that has not been published yet, so you might want to download pydcs directly from the pydcs repository, and copy it in your Python (or virtual env) ./Libs/site-package directory.
 
-Inspired by *ARMA Liberation* mission.
 
-Uses [pydcs](http://github.com/pydcs/dcs) for mission generation.
 

__init__.py

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

changelog.md

@@ -0,0 +1,99 @@
+# 2.0 RC 8
+
+## Fixed issues :
+* **[Mission Generator]** Frequency for P-47D-30 changed to 124Mhz (Generated mission with 251Mhz would not work)
+* **[Mission Generator]** Reduced the maximum number of uboat per generated group
+* **[Mission Generator]** Fixed an issue with the WW2 LST groups (superposed units).
+* **[UI]** Fixed issue with the zoom
+
+# 2.0 RC 7
+
+## Features/Improvements :
+
+* **[Units/Factions]** Added P-47D-30 for factions allies_1944
+* **[Units/Factions]** Added factions : Bluefor Coldwar, Germany 1944 Easy
+
+* **[Campaign/Map]** Added a campaign in the Channel map
+* **[Campaign/Map]** Changed the Normandy campaign map
+* **[Campaign/Map]** Added new campaign Normandy Small
+
+* **[Mission Generator]** AI Flight generator has been reworked
+* **[Mission Generator]** Add PP points for JF-17 on STRIKE missions
+* **[Mission Generator]** Add ST point for F-14B on STRIKE missions
+* **[Mission Generator]** Flights with client slots will never be delayed
+* **[Mission Generator]** AI units can start from parking (With a new setting in Settings Window to disable it)
+* **[Mission Generator]** Tacan for carrier will only be in Mode X from now
+* **[Mission Generator]** RTB waypoints for autogenerated flights
+
+* **[Flight Planner]** Added CAS mission generator
+* **[Flight Planner]** Added CAP mission generator
+* **[Flight Planner]** Added SEAD mission generator
+* **[Flight Planner]** Added STRIKE mission generator
+* **[Flight Planner]** Added buttons to add autogenerated waypoints (ASCEND, DESCEND, RTB)
+* **[Flight Planner]** Improved waypoint list
+* **[Flight Planner]** WW2 factions uses different parameters for flight planning.
+
+* **[Settings]** Added settings to disallow external views
+* **[Settings]** Added settings to choose F10 Map mode (All, Allies only, Player only, Fog of War, Map Only)
+* **[Settings]** Added settings to choose whether to auto-generate objective marks on the F10 map
+
+* **[Info Panel]** Added information about destroyed buildings in info panel
+* **[Info Panel]** Added information about destroyed units at SAM site in info panel
+* **[Debriefing]** Added information about units destroyed outside the frontline in the debriefing window
+* **[Debriefing]** Added destroyed buildings in the debriefing window
+
+* **[Map]** Tooltip now contains the list of building for Strike targets on the map
+* **[Map]** Added "Oil derrick" building
+* **[Map]** Added "ww2 bunker" building (WW2)
+* **[Map]** Added "ally camp" building (WW2)
+* **[Map]** Added "V1 Site" (WW2)
+
+* **[Misc]** Made it possible to setup DCS Saved Games directory and DCS installation directory manually at first start
+* **[Misc]** Added culling performance settings 
+
+## Fixed issues :
+
+* **[Units/Factions]** Replaced S3-B Tanker by KC130 for most factions (More fuel)
+* **[Units/Factions]** WW2 factions will not have offshore oil station and other modern buildings generated. No more third-reich operated offshore stations will spawn on normandy's coast. 
+* **[Units/Factions]** Aircraft carrier will try to move in the wind direction
+* **[Units/Factions]** Missing icons added for some aircraft
+
+* **[Mission Generator]** When playing as RED the activation trigger would not be properly generated
+* **[Mission Generator]** FW-190A8 is now properly considered as a flyable aircraft
+* **[Mission Generator]** Changed "strike" payload for Su-24M that was ineffective
+* **[Mission Generator]** Changed "strike" payload for JF-17 to use LS-6 bombs instead of GBU
+* **[Mission Generator]** Change power station template. (Buildings could end up superposed).
+
+* **[Maps/Campaign]** Now using Vasiani airbase instead of Soganlung airport in Caucasus campaigns (more parking slot)
+* **[Info Panel]** Message displayed on base capture event stated that the enemy captured an airbase, while it was the player who captured it.
+* **[Map View]** Graphical glitch on map when one building of an objective was destroyed, but not the others 
+* **[Mission Planner]** The list of flights was not updated on departure time change. 
+
+
+# 2.0 RC 6
+
+Saves file from RC5 are not compatible with the new version. 
+Sorry :(
+
+## Features/Improvements :
+* **[Units/Factions]** Supercarrier support (You have to go to settings to enable it, if you have the supercarrier module)
+* **[Units/Factions]** Added 'Modern Bluefor' factions, containing all most popular DCS flyable units
+* **[Units/Factions]** Factions US 2005 / 1990 will now sometimes have Arleigh Burke class ships instead of Perry as carrier escorts 
+* **[Units/Factions]** Added support for newest WW2 Units
+* **[Campaign logic]** When a base is captured, refill the "base defenses" group with units for the new owner.
+* **[Mission Generator]** Carrier ICLS channel will now be configured (check your briefing)
+* **[Mission Generator]** SAM units will spawn on RED Alarm state
+* **[Mission Generator]** AI Flight planner now creates its own STRIKE flights
+* **[Mission Generator]** AI units assigned to Strike flight will now actually engage the buildings they have been assigned.
+* **[Mission Generator]** Added performance settings to allow disabling : smoke, artillery strike, moving units, infantry, SAM Red alert mode.
+* **[Mission Generator]** Using Late Activation & Trigger in attempt to improve performance & reduce stutter (Previously they were spawned through 'ETA' feature)
+* **[UX]** : Improved flight selection behaviour in the Mission Planning Window
+ 
+## Fixed issues :
+* **[Mission Generator]** Payloads were not correctly assigned in the release version. 
+* **[Mission Generator]** Game generation does not work when "no night mission" settings was selected and the current time was "day"
+* **[Mission Generator]** Game generation does not work when the player selected faction has no AWACS
+* **[Mission Generator]** Planned flights will spawn even if their home base has been captured or is being contested by enemy ground units. 
+* **[Campaign Generator]** Base defenses would not be generated on Normandy map and in some rare cases on others maps as well
+* **[Mission Planning]** CAS waypoints created from the "Predefined waypoint selector" would not be at the exact location of the frontline
+* **[Naming]** CAP mission flown from airbase are not named BARCAP anymore (CAP from carrier is still named BARCAP)

dcs

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

game/data/aaa_db.py

@@ -0,0 +1,21 @@
+from dcs.vehicles import AirDefence
+
+AAA_UNITS = [
+    AirDefence.SPAAA_Gepard,
+    AirDefence.SPAAA_ZSU_23_4_Shilka,
+    AirDefence.AAA_Vulcan_M163,
+    AirDefence.AAA_ZU_23_Closed,
+    AirDefence.AAA_ZU_23_Emplacement,
+    AirDefence.AAA_ZU_23_on_Ural_375,
+    AirDefence.AAA_ZU_23_Insurgent_Closed,
+    AirDefence.AAA_ZU_23_Insurgent_on_Ural_375,
+    AirDefence.AAA_ZU_23_Insurgent,
+    AirDefence.AAA_8_8cm_Flak_18,
+    AirDefence.AAA_Flak_38,
+    AirDefence.AAA_8_8cm_Flak_36,
+    AirDefence.AAA_8_8cm_Flak_37,
+    AirDefence.AAA_Flak_Vierling_38,
+    AirDefence.AAA_Kdo_G_40,
+    AirDefence.AAA_8_8cm_Flak_41,
+    AirDefence.AAA_Bofors_40mm
+]

game/data/building_data.py

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

game/data/doctrine.py

@@ -0,0 +1,95 @@
+from game.utils import nm_to_meter, feet_to_meter
+
+MODERN_DOCTRINE = {
+
+    "GENERATORS": {
+        "CAS": True,
+        "CAP": True,
+        "SEAD": True,
+        "STRIKE": True,
+        "ANTISHIP": True,
+    },
+
+    "STRIKE_MAX_RANGE": 1500000,
+    "SEAD_MAX_RANGE": 1500000,
+
+    "CAP_EVERY_X_MINUTES": 20,
+    "CAS_EVERY_X_MINUTES": 30,
+    "SEAD_EVERY_X_MINUTES": 40,
+    "STRIKE_EVERY_X_MINUTES": 40,
+
+    "INGRESS_EGRESS_DISTANCE": nm_to_meter(45),
+    "INGRESS_ALT": feet_to_meter(20000),
+    "EGRESS_ALT": feet_to_meter(20000),
+    "PATROL_ALT_RANGE": (feet_to_meter(15000), feet_to_meter(33000)),
+    "PATTERN_ALTITUDE": feet_to_meter(5000),
+
+    "CAP_PATTERN_LENGTH": (nm_to_meter(15), nm_to_meter(40)),
+    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(6), nm_to_meter(15)),
+    "CAP_DISTANCE_FROM_CP": (nm_to_meter(10), nm_to_meter(40)),
+
+    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
+}
+
+COLDWAR_DOCTRINE = {
+
+    "GENERATORS": {
+        "CAS": True,
+        "CAP": True,
+        "SEAD": True,
+        "STRIKE": True,
+        "ANTISHIP": True,
+    },
+
+    "STRIKE_MAX_RANGE": 1500000,
+    "SEAD_MAX_RANGE": 1500000,
+
+    "CAP_EVERY_X_MINUTES": 20,
+    "CAS_EVERY_X_MINUTES": 30,
+    "SEAD_EVERY_X_MINUTES": 40,
+    "STRIKE_EVERY_X_MINUTES": 40,
+
+    "INGRESS_EGRESS_DISTANCE": nm_to_meter(30),
+    "INGRESS_ALT": feet_to_meter(18000),
+    "EGRESS_ALT": feet_to_meter(18000),
+    "PATROL_ALT_RANGE": (feet_to_meter(10000), feet_to_meter(24000)),
+    "PATTERN_ALTITUDE": feet_to_meter(5000),
+
+    "CAP_PATTERN_LENGTH": (nm_to_meter(12), nm_to_meter(24)),
+    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(2), nm_to_meter(8)),
+    "CAP_DISTANCE_FROM_CP": (nm_to_meter(8), nm_to_meter(25)),
+
+    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
+}
+
+WWII_DOCTRINE = {
+
+    "GENERATORS": {
+        "CAS": True,
+        "CAP": True,
+        "SEAD": False,
+        "STRIKE": True,
+        "ANTISHIP": True,
+    },
+
+    "STRIKE_MAX_RANGE": 1500000,
+    "SEAD_MAX_RANGE": 1500000,
+
+    "CAP_EVERY_X_MINUTES": 20,
+    "CAS_EVERY_X_MINUTES": 30,
+    "SEAD_EVERY_X_MINUTES": 40,
+    "STRIKE_EVERY_X_MINUTES": 40,
+
+    "INGRESS_EGRESS_DISTANCE": nm_to_meter(7),
+    "INGRESS_ALT": feet_to_meter(8000),
+    "EGRESS_ALT": feet_to_meter(8000),
+    "PATROL_ALT_RANGE": (feet_to_meter(4000), feet_to_meter(15000)),
+    "PATTERN_ALTITUDE": feet_to_meter(5000),
+
+    "CAP_PATTERN_LENGTH": (nm_to_meter(8), nm_to_meter(18)),
+    "FRONTLINE_CAP_DISTANCE_FROM_FRONTLINE": (nm_to_meter(1), nm_to_meter(6)),
+    "CAP_DISTANCE_FROM_CP": (nm_to_meter(0), nm_to_meter(5)),
+
+    "MAX_NUMBER_OF_INTERCEPTION_GROUP": 3,
+
+}

game/data/radar_db.py

@@ -0,0 +1,54 @@
+from dcs.vehicles import AirDefence
+from dcs.ships import *
+
+UNITS_WITH_RADAR = [
+
+    # Radars
+    AirDefence.SAM_SA_15_Tor_9A331,
+    AirDefence.SAM_SA_11_Buk_CC_9S470M1,
+    AirDefence.SAM_Patriot_AMG_AN_MRC_137,
+    AirDefence.SAM_Patriot_ECS_AN_MSQ_104,
+    AirDefence.SPAAA_Gepard,
+    AirDefence.AAA_Vulcan_M163,
+    AirDefence.SPAAA_ZSU_23_4_Shilka,
+    AirDefence.EWR_1L13,
+    AirDefence.SAM_SA_6_Kub_STR_9S91,
+    AirDefence.SAM_SA_10_S_300PS_TR_30N6,
+    AirDefence.SAM_SA_10_S_300PS_SR_5N66M,
+    AirDefence.EWR_55G6,
+    AirDefence.SAM_SA_10_S_300PS_SR_64H6E,
+    AirDefence.SAM_SA_11_Buk_SR_9S18M1,
+    AirDefence.CP_9S80M1_Sborka,
+    AirDefence.SAM_Hawk_TR_AN_MPQ_46,
+    AirDefence.SAM_Hawk_SR_AN_MPQ_50,
+    AirDefence.SAM_Patriot_STR_AN_MPQ_53,
+    AirDefence.SAM_Hawk_CWAR_AN_MPQ_55,
+    AirDefence.SAM_SR_P_19,
+    AirDefence.SAM_Roland_EWR,
+    AirDefence.SAM_SA_3_S_125_TR_SNR,
+    AirDefence.SAM_SA_2_TR_SNR_75_Fan_Song,
+    AirDefence.HQ_7_Self_Propelled_STR,
+
+    # Ships
+    CVN_70_Carl_Vinson,
+    Oliver_Hazzard_Perry_class,
+    Ticonderoga_class,
+    FFL_1124_4_Grisha,
+    CV_1143_5_Admiral_Kuznetsov,
+    FSG_1241_1MP_Molniya,
+    CG_1164_Moskva,
+    FFG_11540_Neustrashimy,
+    CGN_1144_2_Pyotr_Velikiy,
+    FF_1135M_Rezky,
+    CV_1143_5_Admiral_Kuznetsov_2017,
+    CVN_74_John_C__Stennis,
+    CVN_71_Theodore_Roosevelt,
+    CVN_72_Abraham_Lincoln,
+    CVN_73_George_Washington,
+    USS_Arleigh_Burke_IIa,
+    LHA_1_Tarawa,
+    Type_052B_Destroyer,
+    Type_054A_Frigate,
+    Type_052C_Destroyer,
+    Type_093,
+]

game/event/__init__.py

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

game/event/antiaastrike.py

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

game/event/capture.py

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

game/event/event.py

@@ -1,92 +1,397 @@
+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
+from game.db import assigned_units_from, unitdict_from
+from theater.start_generator import generate_airbase_defense_group
 
 from userdata.debriefing import Debriefing
 from userdata import persistency
 
-DIFFICULTY_LOG_BASE = 1.1
+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
     is_awacs_enabled = False
+    ca_slots = 0
+
+    game = None  # type: Game
+    location = None  # type: Point
+    from_cp = None  # type: ControlPoint
+    departure_cp = None  # type: ControlPoint
+    to_cp = None  # type: ControlPoint
+
     operation = None  # type: Operation
     difficulty = 1  # type: int
-    game = None  # type: Game
     environment_settings = None  # type: EnvironmentSettings
     BONUS_BASE = 5
 
-    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
+    def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str, defender_name: str):
+        self.game = game
+        self.departure_cp = None
+        self.from_cp = from_cp
+        self.to_cp = target_cp
+        self.location = location
         self.attacker_name = attacker_name
         self.defender_name = defender_name
-        self.to_cp = to_cp
-        self.from_cp = from_cp
-        self.game = game
 
     @property
     def is_player_attacking(self) -> bool:
-        return self.attacker_name == self.game.player
+        return self.attacker_name == self.game.player_name
 
     @property
     def enemy_cp(self) -> ControlPoint:
-        if self.attacker_name == self.game.player:
+        if self.attacker_name == self.game.player_name:
             return self.to_cp
         else:
-            return self.from_cp
+            return self.departure_cp
 
     @property
     def threat_description(self) -> str:
         return ""
 
+    def flight_name(self, for_task: typing.Type[typing.Type[Task]]) -> str:
+        return "Flight"
+
+    @property
+    def tasks(self) -> typing.Collection[typing.Type[Task]]:
+        return []
+
+    @property
+    def ai_banned_tasks(self) -> typing.Collection[typing.Type[Task]]:
+        return []
+
+    @property
+    def player_banned_tasks(self) -> typing.Collection[typing.Type[Task]]:
+        return []
+
+    @property
+    def global_cp_available(self) -> bool:
+        return False
+
+    def is_departure_available_from(self, cp: ControlPoint) -> bool:
+        if not cp.captured:
+            return False
+
+        if self.location.distance_to_point(cp.position) > EVENT_DEPARTURE_MAX_DISTANCE:
+            return False
+
+        if cp.is_global and not self.global_cp_available:
+            return False
+
+        return True
+
     def bonus(self) -> int:
         return int(math.log(self.to_cp.importance + 1, DIFFICULTY_LOG_BASE) * self.BONUS_BASE)
 
     def is_successfull(self, debriefing: Debriefing) -> bool:
         return self.operation.is_successfull(debriefing)
 
+    def player_attacking(self, cp: ControlPoint, flights: db.TaskForceDict):
+        if self.is_player_attacking:
+            self.departure_cp = cp
+        else:
+            self.to_cp = cp
+
+    def player_defending(self, cp: ControlPoint, flights: db.TaskForceDict):
+        if self.is_player_attacking:
+            self.departure_cp = cp
+        else:
+            self.to_cp = cp
+
     def generate(self):
         self.operation.is_awacs_enabled = self.is_awacs_enabled
+        self.operation.ca_slots = self.ca_slots
 
         self.operation.prepare(self.game.theater.terrain, is_quick=False)
         self.operation.generate()
-        self.operation.mission.save(persistency.mission_path_for("liberation_nextturn.miz"))
+        self.operation.current_mission.save(persistency.mission_path_for("liberation_nextturn.miz"))
         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.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.from_cp
-            else:
-                cp = self.to_cp
 
-            cp.base.commit_losses(losses)
+        logging.info("Commiting mission results")
+
+        # ------------------------------
+        # 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(destroyed_ground_unit_name):
+                        logging.info("cp {} killing ground object {}".format(cp, ground_object.string_identifier))
+                        cp.ground_objects[i].is_dead = True
+
+                        info = Information("Building destroyed",
+                                           ground_object.dcs_identifier + " has been destroyed at location " + ground_object.obj_name,
+                                           self.game.turn)
+                        self.game.informations.append(info)
+
+
+                # -- AA Site groups
+                destroyed_units = 0
+                info = Information("Units destroyed at " + ground_object.obj_name,
+                                   "",
+                                   self.game.turn)
+                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)
+                                    destroyed_units = destroyed_units + 1
+                                    info.text = u.type
+                        ucount = sum([len(g.units) for g in ground_object.groups])
+                        if ucount == 0:
+                            ground_object.is_dead = True
+                if destroyed_units > 0:
+                    self.game.informations.append(info)
+
+        # ------------------------------
+        # Captured bases
+        if self.game.player_country in db.BLUEFOR_FACTIONS:
+            coalition = 2 # Value in DCS mission event for BLUE
+        else:
+            coalition = 1 # Value in DCS mission event for RED
+
+        for captured in debriefing.base_capture_events:
+            try:
+                id = int(captured.split("||")[0])
+                new_owner_coalition = int(captured.split("||")[1])
+
+                captured_cps = []
+                for cp in self.game.theater.controlpoints:
+                    if cp.id == id:
+
+                        if cp.captured and new_owner_coalition != coalition:
+                            cp.captured = False
+                            info = Information(cp.name + " lost !", "The ennemy took control of " + cp.name + "\nShame on us !", self.game.turn)
+                            self.game.informations.append(info)
+                            pname = self.game.enemy_name
+                            captured_cps.append(cp)
+                        elif not(cp.captured) and new_owner_coalition == coalition:
+                            cp.captured = True
+                            info = Information(cp.name + " captured !", "We took control of " + cp.name + "! Great job !", self.game.turn)
+                            self.game.informations.append(info)
+                            pname = self.game.player_name
+                            captured_cps.append(cp)
+                        else:
+                            continue
+
+                        cp.base.aircraft = {}
+                        cp.base.armor = {}
+
+                        airbase_def_id = 0
+                        for g in cp.ground_objects:
+                            g.groups = []
+                            if g.airbase_group and pname != "":
+                                generate_airbase_defense_group(airbase_def_id, g, pname, self.game, cp)
+                                airbase_def_id = airbase_def_id + 1
+
+                for cp in captured_cps:
+                    logging.info("Will run redeploy for " + cp.name)
+                    self.redeploy_units(cp)
+
+
+            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)
+
+                player_aggresive = cp.stances[enemy_cp.id] in [CombatStance.AGGRESIVE, CombatStance.ELIMINATION, CombatStance.BREAKTHROUGH]
+
+                if ally_units_alive == 0:
+                    player_won = False
+                    delta = STRONG_DEFEAT_INFLUENCE
+                elif enemy_units_alive == 0:
+                    player_won = True
+                    delta = STRONG_DEFEAT_INFLUENCE
+                elif cp.stances[enemy_cp.id] == CombatStance.RETREAT:
+                    player_won = False
+                    delta = STRONG_DEFEAT_INFLUENCE
+                else:
+                    if enemy_casualties > ally_casualties:
+                        player_won = True
+                        if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
+                            delta = STRONG_DEFEAT_INFLUENCE
+                        else:
+                            if ratio > 3:
+                                delta = STRONG_DEFEAT_INFLUENCE
+                            elif ratio < 1.5:
+                                delta = MINOR_DEFEAT_INFLUENCE
+                            else:
+                                delta = DEFEAT_INFLUENCE
+                    elif ally_casualties > enemy_casualties:
+
+                        if ally_units_alive > 2*enemy_units_alive and player_aggresive:
+                            # Even with casualties if the enemy is overwhelmed, they are going to lose ground
+                            player_won = True
+                            delta = MINOR_DEFEAT_INFLUENCE
+                        elif ally_units_alive > 3*enemy_units_alive and player_aggresive:
+                            player_won = True
+                            delta = STRONG_DEFEAT_INFLUENCE
+                        else:
+                            # But is the enemy is not outnumbered, we lose
+                            player_won = False
+                            if cp.stances[enemy_cp.id] == CombatStance.BREAKTHROUGH:
+                                delta = STRONG_DEFEAT_INFLUENCE
+                            else:
+                                delta = STRONG_DEFEAT_INFLUENCE
+
+                    # No progress with defensive strategies
+                    if player_won and cp.stances[enemy_cp.id] in [CombatStance.DEFENSIVE, CombatStance.AMBUSH]:
+                        print("Defensive stance, progress is limited")
+                        delta = MINOR_DEFEAT_INFLUENCE
+
+                if player_won:
+                    print(cp.name + " won !  factor > " + str(delta))
+                    cp.base.affect_strength(delta)
+                    enemy_cp.base.affect_strength(-delta)
+                    info = Information("Frontline Report",
+                                       "Our ground forces from " + cp.name + " are making progress toward " + enemy_cp.name,
+                                       self.game.turn)
+                    self.game.informations.append(info)
+                else:
+                    print(cp.name + " lost !  factor > " + str(delta))
+                    enemy_cp.base.affect_strength(delta)
+                    cp.base.affect_strength(-delta)
+                    info = Information("Frontline Report",
+                                       "Our ground forces from " + cp.name + " are losing ground against the enemy forces from " + enemy_cp.name,
+                                       self.game.turn)
+                    self.game.informations.append(info)
 
     def skip(self):
         pass
 
+    def redeploy_units(self, cp):
+        """"
+        Auto redeploy units to newly captured base
+        """
+
+        ally_connected_cps = [ocp for ocp in cp.connected_points if cp.captured == ocp.captured]
+        enemy_connected_cps = [ocp for ocp in cp.connected_points if cp.captured != ocp.captured]
+
+        # If the newly captured cp does not have enemy connected cp,
+        # then it is not necessary to redeploy frontline units there.
+        if len(enemy_connected_cps) == 0:
+            return
+        else:
+            # From each ally cp, send reinforcements
+            for ally_cp in ally_connected_cps:
+                total_units_redeployed = 0
+                own_enemy_cp = [ocp for ocp in ally_cp.connected_points if ally_cp.captured != ocp.captured]
+
+                moved_units = {}
+
+                # If the connected base, does not have any more enemy cp connected.
+                # Or if it is not the opponent redeploying forces there (enemy AI will never redeploy all their forces at once)
+                if len(own_enemy_cp) > 0 or not cp.captured:
+                    for frontline_unit, count in ally_cp.base.armor.items():
+                        moved_units[frontline_unit] = int(count/2)
+                        total_units_redeployed = total_units_redeployed + int(count/2)
+                else: # So if the old base, does not have any more enemy cp connected, or if it is an enemy base
+                    for frontline_unit, count in ally_cp.base.armor.items():
+                        moved_units[frontline_unit] = count
+                        total_units_redeployed = total_units_redeployed + count
+
+                cp.base.commision_units(moved_units)
+                ally_cp.base.commit_losses(moved_units)
+
+                if total_units_redeployed > 0:
+                    info = Information("Units redeployed", "", self.game.turn)
+                    info.text = str(total_units_redeployed) + " units have been redeployed from " + ally_cp.name + " to " + cp.name
+                    self.game.informations.append(info)
+                    logging.info(info.text)
+
+
 
 class UnitsDeliveryEvent(Event):
     informational = True
     units = None  # type: typing.Dict[UnitType, int]
 
     def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
-        super(UnitsDeliveryEvent, self).__init__(attacker_name=attacker_name,
-                                                 defender_name=defender_name,
+        super(UnitsDeliveryEvent, self).__init__(game=game,
+                                                 location=to_cp.position,
                                                  from_cp=from_cp,
-                                                 to_cp=to_cp,
-                                                 game=game)
+                                                 target_cp=to_cp,
+                                                 attacker_name=attacker_name,
+                                                 defender_name=defender_name)
 
         self.units = {}
 
@@ -98,4 +403,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

@@ -0,0 +1,110 @@
+from game.event import *
+from game.operation.frontlineattack import FrontlineAttackOperation
+from userdata.debriefing import Debriefing
+
+
+class FrontlineAttackEvent(Event):
+    TARGET_VARIETY = 2
+    TARGET_AMOUNT_FACTOR = 0.5
+    ATTACKER_AMOUNT_FACTOR = 0.4
+    ATTACKER_DEFENDER_FACTOR = 0.7
+    STRENGTH_INFLUENCE = 0.3
+    SUCCESS_FACTOR = 1.5
+
+    @property
+    def threat_description(self):
+        return "{} vehicles".format(self.to_cp.base.assemble_count())
+
+    @property
+    def tasks(self) -> typing.Collection[typing.Type[Task]]:
+        if self.is_player_attacking:
+            return [CAS, CAP]
+        else:
+            return [CAP]
+
+    @property
+    def global_cp_available(self) -> bool:
+        return True
+
+    def flight_name(self, for_task: typing.Type[Task]) -> str:
+        if for_task == CAS:
+            return "CAS flight"
+        elif for_task == CAP:
+            return "CAP flight"
+        elif for_task == PinpointStrike:
+            return "Ground attack"
+
+    def __str__(self):
+        return "Frontline attack"
+
+    def is_successfull(self, debriefing: Debriefing):
+
+        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:
+            return not attackers_success
+
+    def commit(self, debriefing: Debriefing):
+        super(FrontlineAttackEvent, self).commit(debriefing)
+
+    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"
+
+        op = FrontlineAttackOperation(game=self.game,
+                                      attacker_name=self.attacker_name,
+                                      defender_name=self.defender_name,
+                                      from_cp=self.from_cp,
+                                      departure_cp=self.departure_cp,
+                                      to_cp=self.to_cp)
+
+        defenders = self.to_cp.base.assemble_attack()
+        max_attackers = int(math.ceil(sum(defenders.values()) * self.ATTACKER_DEFENDER_FACTOR))
+        attackers = db.unitdict_restrict_count(self.from_cp.base.assemble_attack(), max_attackers)
+        op.setup(defenders=defenders,
+                 attackers=attackers,
+                 strikegroup=flights[CAS],
+                 escort=flights[CAP],
+                 interceptors=assigned_units_from(self.to_cp.base.scramble_interceptors(1)))
+
+        self.operation = op
+
+    def player_defending(self, flights: db.TaskForceDict):
+        # assert CAP in flights and len(flights) == 1, "Invalid flights"
+
+        op = FrontlineAttackOperation(game=self.game,
+                                      attacker_name=self.attacker_name,
+                                      defender_name=self.defender_name,
+                                      from_cp=self.from_cp,
+                                      departure_cp=self.departure_cp,
+                                      to_cp=self.to_cp)
+
+        defenders = self.to_cp.base.assemble_attack()
+
+        max_attackers = int(math.ceil(sum(defenders.values())))
+        attackers = db.unitdict_restrict_count(self.from_cp.base.assemble_attack(), max_attackers)
+
+        op.setup(defenders=defenders,
+                 attackers=attackers,
+                 strikegroup=assigned_units_from(self.from_cp.base.scramble_cas(1)),
+                 escort=assigned_units_from(self.from_cp.base.scramble_sweep(1)),
+                 interceptors=flights[CAP])
+
+        self.operation = op
+

game/event/groundattack.py

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

game/event/groundintercept.py

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

game/event/infantrytransport.py

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

game/event/intercept.py

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

game/event/navalintercept.py

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

game/factions/bluefor_coldwar.py

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

game/factions/bluefor_modern.py

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

game/factions/china_2000.py

@@ -0,0 +1,65 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles 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",
+    ], "boat":[
+        "ChineseNavyGroupGenerator", "Type54GroupGenerator"
+    ]
+}

game/factions/france_1995.py

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

game/factions/france_2005.py

@@ -0,0 +1,61 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+France_2005 = {
+    "country": "France",
+    "side": "blue",
+    "units":[
+        M_2000C,
+        Mirage_2000_5,
+        FA_18C_hornet, # Standing as Rafale M
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        SA342M,
+        SA342L,
+
+        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"
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ]
+}

game/factions/germany_1944.py

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

game/factions/germany_1944_easy.py

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

game/factions/germany_1990.py

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

game/factions/india_2010.py

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

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

game/factions/israel_2000.py

@@ -0,0 +1,39 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Israel_2000 = {
+    "country": "Israel",
+    "side": "blue",
+    "units":[
+        F_16C_50,
+        F_15C,
+        F_4E,
+
+        KC_135,
+        KC130,
+        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
+    ], "boat": [
+        "ArleighBurkeGroupGenerator"
+    ]
+}

game/factions/italy_1990.py

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

game/factions/libya_2011.py

@@ -0,0 +1,49 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.vehicles 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.FDDM_Grad,
+        Armor.ARV_BRDM_2,
+        Armor.MBT_T_55,
+        Armor.MBT_T_72B,
+        Artillery.MLRS_BM_21_Grad,
+
+        Unarmed.Transport_Ural_375,
+        Unarmed.Transport_UAZ_469,
+
+        Infantry.Paratrooper_RPG_16,
+        Infantry.Infantry_Soldier_Insurgents
+
+    ],
+    "shorad":[
+        AirDefence.HQ_7_Self_Propelled_LN,
+        AirDefence.SAM_SA_8_Osa_9A33,
+    ], "boat": [
+        "GrishaGroupGenerator", "MolniyaGroupGenerator"
+    ]
+}

game/factions/netherlands_1990.py

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

game/factions/north_korea_2000.py

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

game/factions/pakistan_2015.py

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

game/factions/russia_1955.py

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

game/factions/russia_1965.py

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

game/factions/russia_1975.py

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

game/factions/russia_1990.py

@@ -0,0 +1,70 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+Russia_1990 = {
+    "country": "Russia",
+    "side": "red",
+    "units": [
+
+        MiG_23MLD,
+        MiG_25PD,
+        MiG_29A,
+        MiG_29S,
+        MiG_31,
+        Su_27,
+
+        Su_24M,
+        Su_25,
+
+        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,
+    ], "boat":[
+        "RussianNavyGroupGenerator", "KiloSubGroupGenerator"
+    ]
+}

game/factions/russia_2010.py

@@ -0,0 +1,69 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles 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,
+    ], "boat": [
+        "RussianNavyGroupGenerator", "KiloSubGroupGenerator"
+    ]
+}

game/factions/spain_1990.py

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

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

game/factions/uae_2005.py

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

game/factions/uk_1990.py

@@ -0,0 +1,52 @@
+from dcs.helicopters import *
+from dcs.planes import *
+from dcs.ships import *
+from dcs.vehicles import *
+
+UnitedKingdom_1990 = {
+    "country": "UK",
+    "side": "blue",
+    "units":[
+        AV8BNA, # Standing as BAE Harrier 2
+        Tornado_GR4,
+        F_4E,
+
+        KC_135,
+        KC130,
+        C_130,
+        E_3A,
+
+        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",
+    ], "boat":[
+        "ArleighBurkeGroupGenerator", "OliverHazardPerryGroupGenerator"
+    ]
+}

game/factions/ukraine_2010.py

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

game/factions/usa_1944.py

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

game/factions/usa_1955.py

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

game/factions/usa_1960.py

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

game/factions/usa_1965.py

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

game/factions/usa_1990.py

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

game/factions/usa_2005.py

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

game/game.py

@@ -1,16 +1,11 @@
-import typing
-import random
-import math
+from datetime import datetime, timedelta
 
-from dcs.task import *
-from dcs.vehicles import *
-
-from userdata.debriefing import Debriefing
-from theater import *
-
-from . import db
-from .settings import Settings
+from game.db import REWARDS, PLAYER_BUDGET_BASE, sys
+from game.game_stats import GameStats
+from gen.flights.ai_flight_planner import FlightPlanner
+from gen.ground_forces.ai_ground_planner import GroundPlanner
 from .event import *
+from .settings import Settings
 
 COMMISION_UNIT_VARIETY = 4
 COMMISION_LIMITS_SCALE = 1.5
@@ -18,53 +13,33 @@ COMMISION_LIMITS_FACTORS = {
     PinpointStrike: 10,
     CAS: 5,
     CAP: 8,
-    AirDefence: 2,
+    AirDefence: 8,
 }
 
 COMMISION_AMOUNTS_SCALE = 1.5
 COMMISION_AMOUNTS_FACTORS = {
-    PinpointStrike: 2,
+    PinpointStrike: 3,
     CAS: 1,
     CAP: 2,
-    AirDefence: 0.3,
+    AirDefence: 0.8,
 }
 
-PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE = 25
+PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE = 30
 PLAYER_INTERCEPT_GLOBAL_PROBABILITY_LOG = 2
+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:
-* CaptureEvent - capture base
-* InterceptEvent - air intercept
-* GroundInterceptEvent - frontline CAS
-* GroundAttackEvent - destroy insurgents
-* NavalInterceptEvent - naval intercept
-* AntiAAStrikeEvent - anti-AA strike
-* InfantryTransportEvent - helicopter infantry transport
-"""
-EVENT_PROBABILITIES = {
-    CaptureEvent: [100, 8],
-    InterceptEvent: [25, 12],
-    GroundInterceptEvent: [25, 12],
-    GroundAttackEvent: [0, 12],
-    NavalInterceptEvent: [25, 12],
-    AntiAAStrikeEvent: [25, 12],
-    InfantryTransportEvent: [25, 0],
-}
-
-# amount of strength captures bases recover for the turn
+# amount of strength player bases recover for the turn
 PLAYER_BASE_STRENGTH_RECOVERY = 0.2
 
+# amount of strength enemy bases recover for the turn
+ENEMY_BASE_STRENGTH_RECOVERY = 0.05
+
 # cost of AWACS for single operation
 AWACS_BUDGET_COST = 4
 
 # Initial budget value
-PLAYER_BUDGET_INITIAL = 120
-# Base post-turn bonus value
-PLAYER_BUDGET_BASE = 10
+PLAYER_BUDGET_INITIAL = 650
+
 # Bonus multiplier logarithm base
 PLAYER_BUDGET_IMPORTANCE_LOG = 2
 
@@ -75,100 +50,89 @@ 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))
+        self.__culling_points = self.compute_conflicts_position()
+
+
+    @property
+    def player_faction(self):
+        return db.FACTIONS[self.player_name]
+
+    @property
+    def enemy_faction(self):
+        return db.FACTIONS[self.enemy_name]
 
     def _roll(self, prob, mult):
-        return random.randint(1, 100) <= prob * mult
+        if self.settings.version == "dev":
+            # always generate all events for dev
+            return 100
+        else:
+            return random.randint(1, 100) <= prob * mult
 
-    def _generate_globalinterceptions(self):
-        global_count = len([x for x in self.theater.player_points() if x.is_global])
-        for from_cp in [x for x in self.theater.player_points() if x.is_global]:
-            probability_base = max(PLAYER_INTERCEPT_GLOBAL_PROBABILITY_BASE / global_count, 1)
-            probability = probability_base * math.log(len(self.theater.player_points()) + 1, PLAYER_INTERCEPT_GLOBAL_PROBABILITY_LOG)
-            if self._roll(probability, from_cp.base.strength):
-                to_cp = random.choice([x for x in self.theater.enemy_points() if x not in self.theater.conflicts()])
-                self.events.append(InterceptEvent(attacker_name=self.player,
-                                                  defender_name=self.enemy,
-                                                  from_cp=from_cp,
-                                                  to_cp=to_cp,
-                                                  game=self))
-                break
+    def _generate_player_event(self, event_class, player_cp, enemy_cp):
+        self.events.append(event_class(self, player_cp, enemy_cp, enemy_cp.position, self.player_name, self.enemy_name))
 
     def _generate_events(self):
-        enemy_cap_generated = False
-        enemy_generated_types = []
-
         for player_cp, enemy_cp in self.theater.conflicts(True):
-            if player_cp.is_global or enemy_cp.is_global:
-                continue
-
-            for event_class, (player_probability, enemy_probability) in EVENT_PROBABILITIES.items():
-                if self._roll(player_probability, player_cp.base.strength):
-                    if event_class == NavalInterceptEvent:
-                        if enemy_cp.radials == LAND:
-                            continue
-
-                    self.events.append(event_class(self.player, self.enemy, player_cp, enemy_cp, self))
-                elif self._roll(enemy_probability, enemy_cp.base.strength):
-                    if event_class in enemy_generated_types:
-                        continue
-
-                    if player_cp in self.ignored_cps:
-                        continue
-
-                    if enemy_cp.base.total_planes == 0:
-                        continue
-
-                    if event_class == NavalInterceptEvent:
-                        if player_cp.radials == LAND:
-                            continue
-                    elif event_class == CaptureEvent:
-                        if enemy_cap_generated:
-                            continue
-                        if enemy_cp.base.total_armor == 0:
-                            continue
-                        enemy_cap_generated = True
-                    elif event_class == AntiAAStrikeEvent:
-                        if player_cp.base.total_aa == 0:
-                            continue
-
-                    enemy_generated_types.append(event_class)
-                    self.events.append(event_class(self.enemy, self.player, enemy_cp, player_cp, self))
+            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}
-                    print("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
@@ -177,8 +141,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)
@@ -190,12 +154,12 @@ class Game:
             self.events.remove(event)
 
     def initiate_event(self, event: Event):
-        assert event in self.events
-
+        #assert event in self.events
+        logging.info("Generating {} (regular)".format(event))
         event.generate()
-        event.generate_quick()
 
     def finish_event(self, event: Event, debriefing: Debriefing):
+        logging.info("Finishing event {}".format(event))
         event.commit(debriefing)
         if event.is_successfull(debriefing):
             self.budget += event.bonus()
@@ -203,21 +167,50 @@ class Game:
         if event in self.events:
             self.events.remove(event)
         else:
-            print("finish_event: event not in the events!")
+            logging.info("finish_event: event not in the events!")
 
-    def is_player_attack(self, event: Event):
-        return event.attacker_name == self.player
+    def is_player_attack(self, event):
+        if isinstance(event, Event):
+            return event.attacker_name == self.player_name
+        else:
+            return event.name == self.player_name
+
+    def get_player_coalition_id(self):
+        if self.player_country in db.BLUEFOR_FACTIONS:
+            return 2
+        else:
+            return 1
+
+    def get_enemy_coalition_id(self):
+        if self.get_player_coalition_id() == 1:
+            return 2
+        else:
+            return 1
+
+    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
 
-    def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint]=None):
         for event in self.events:
-            event.skip()
+            if self.settings.version == "dev":
+                # don't damage player CPs in by skipping in dev mode
+                if isinstance(event, UnitsDeliveryEvent):
+                    event.skip()
+            else:
+                event.skip()
 
-        if not no_action:
-            self._budget_player()
-            for cp in self.theater.enemy_points():
-                self._commision_units(cp)
+        self._enemy_reinforcement()
+        self._budget_player()
+
+        if not no_action and self.turn > 1:
             for cp in self.theater.player_points():
                 cp.base.affect_strength(+PLAYER_BASE_STRENGTH_RECOVERY)
+        else:
+            for cp in self.theater.player_points():
+                if not cp.is_carrier and not cp.is_lha:
+                    cp.base.affect_strength(-PLAYER_BASE_STRENGTH_RECOVERY)
 
         self.ignored_cps = []
         if ignored_cps:
@@ -225,5 +218,160 @@ 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.__culling_points = self.compute_conflicts_position()
+        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):
+        """
+        Compute and commision reinforcement for enemy bases
+        """
+
+        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
+
+    def compute_conflicts_position(self):
+        """
+        Compute the current conflict center position(s), mainly used for culling calculation
+        :return: List of points of interests
+        """
+        points = []
+
+        # By default, use the existing frontline conflict position
+        for conflict in self.theater.conflicts():
+            points.append(Conflict.frontline_position(self.theater, conflict[0], conflict[1])[0])
+
+        # If there is no conflict take the center point between the two nearest opposing bases
+        if len(points) == 0:
+            cpoint = None
+            min_distance = sys.maxsize
+            for cp in self.theater.player_points():
+                for cp2 in self.theater.enemy_points():
+                    d = cp.position.distance_to_point(cp2.position)
+                    if d < min_distance:
+                        min_distance = d
+                        cpoint = Point((cp.position.x + cp2.position.x) / 2, (cp.position.y + cp2.position.y) / 2)
+            if cpoint is not None:
+                points.append(cpoint)
+
+        # Else 0,0, since we need a default value
+        # (in this case this means the whole map is owned by the same player, so it is not an issue)
+        if len(points) == 0:
+            points.append(Point(0, 0))
+
+        return points
+
+    def position_culled(self, pos):
+        """
+        Check if unit can be generated at given position depending on culling performance settings
+        :param pos: Position you are tryng to spawn stuff at
+        :return: True if units can not be added at given position
+        """
+        if self.settings.perf_culling == False:
+            return False
+        else:
+            for c in self.__culling_points:
+                if c.distance_to_point(pos) < self.settings.perf_culling_distance * 1000:
+                    return False
+            return True
 

game/game_stats.py

@@ -0,0 +1,56 @@
+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.vehicles_count += sum(cp.base.armor.values())
+            else:
+                turn_data.enemy_units.aircraft_count += sum(cp.base.aircraft.values())
+                turn_data.enemy_units.vehicles_count += sum(cp.base.armor.values())
+
+        self.data_per_turn.append(turn_data)
+

game/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/antiaastrike.py

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

game/operation/capture.py

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

game/operation/frontlineattack.py

@@ -0,0 +1,77 @@
+from game.db import assigned_units_split
+
+from .operation import *
+
+
+MAX_DISTANCE_BETWEEN_GROUPS = 12000
+
+
+class FrontlineAttackOperation(Operation):
+    interceptors = None  # type: db.AssignedUnitsDict
+    escort = None  # type: db.AssignedUnitsDict
+    strikegroup = None  # type: db.AssignedUnitsDict
+
+    attackers = None  # type: db.ArmorDict
+    defenders = None  # type: db.ArmorDict
+
+    def setup(self,
+              defenders: db.ArmorDict,
+              attackers: db.ArmorDict,
+              strikegroup: db.AssignedUnitsDict,
+              escort: db.AssignedUnitsDict,
+              interceptors: db.AssignedUnitsDict):
+        self.strikegroup = strikegroup
+        self.escort = escort
+        self.interceptors = interceptors
+
+        self.defenders = defenders
+        self.attackers = attackers
+
+    def prepare(self, terrain: Terrain, is_quick: bool):
+        super(FrontlineAttackOperation, self).prepare(terrain, is_quick)
+        if self.defender_name == self.game.player_name:
+            self.attackers_starting_position = None
+            self.defenders_starting_position = None
+
+        conflict = Conflict.frontline_cas_conflict(
+            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
+        )
+
+        self.initialize(mission=self.current_mission,
+                        conflict=conflict)
+
+    def generate(self):
+        #if self.is_player_attack:
+        #    self.prepare_carriers(db.unitdict_from(self.strikegroup))
+
+        # ground units
+        # 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)
+
+        #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_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."
+        self.briefinggen.append_waypoint("CAS AREA IP")
+        self.briefinggen.append_waypoint("CAS AREA EGRESS")
+        super(FrontlineAttackOperation, self).generate()

game/operation/groundattack.py

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

game/operation/groundintercept.py

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

game/operation/infantrytransport.py

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

game/operation/intercept.py

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

game/operation/navalintercept.py

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

game/operation/operation.py

@@ -1,103 +1,203 @@
+from dcs.countries import country_dict
+from dcs.lua.parse import loads
 from dcs.terrain import Terrain
 
+from gen import *
 from userdata.debriefing import *
 
-from theater import *
-from gen import *
+TANKER_CALLSIGNS = ["Texaco", "Arco", "Shell"]
 
 
 class Operation:
     attackers_starting_position = None  # type: db.StartingPosition
     defenders_starting_position = None  # type: db.StartingPosition
-    mission = None  # type: dcs.Mission
+
+    current_mission = None  # type: dcs.Mission
+    regular_mission = None  # type: dcs.Mission
+    quick_mission = None  # type: dcs.Mission
     conflict = None  # type: Conflict
     armorgen = None  # type: ArmorConflictGenerator
     airgen = None  # type: AircraftConflictGenerator
-    aagen = None  # type: AAConflictGenerator
-    extra_aagen = None  # type: ExtraAAConflictGenerator
     shipgen = None  # type: ShipGenerator
     triggersgen = None  # type: TriggersGenerator
-    awacsgen = None  # type: AWACSConflictGenerator
+    airsupportgen = None  # type: AirSupportConflictGenerator
     visualgen = None  # type: VisualGenerator
     envgen = None  # type: EnvironmentGenerator
+    groundobjectgen = None  # type: GroundObjectsGenerator
+    briefinggen = None  # type: BriefingGenerator
+    forcedoptionsgen = None  # type: ForcedOptionsGenerator
 
     environment_settings = None
     trigger_radius = TRIGGER_RADIUS_MEDIUM
     is_quick = None
     is_awacs_enabled = False
+    ca_slots = 0
 
     def __init__(self,
                  game,
                  attacker_name: str,
                  defender_name: str,
-                 attacker_clients: db.PlaneDict,
-                 defender_clients: db.PlaneDict,
                  from_cp: ControlPoint,
+                 departure_cp: ControlPoint,
                  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.attacker_clients = attacker_clients
-        self.defender_clients = defender_clients
+        self.defender_country = db.FACTIONS[defender_name]["country"]
+        print(self.defender_country, self.attacker_country)
         self.from_cp = from_cp
+        self.departure_cp = departure_cp
         self.to_cp = to_cp
         self.is_quick = False
 
-    def initialize(self, mission: Mission, conflict: Conflict):
-        self.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.awacsgen = AWACSConflictGenerator(mission, conflict, self.game)
-        self.triggersgen = TriggersGenerator(mission, conflict, self.game)
-        self.visualgen = VisualGenerator(mission, conflict, self.game)
-        self.envgen = EnviromentGenerator(mission, conflict, self.game)
-
-        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)
-
-    def prepare(self, terrain: Terrain, is_quick: bool):
-        self.mission = dcs.Mission(terrain)
-        self.is_quick = is_quick
-
-        if is_quick:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
-        else:
-            self.attackers_starting_position = self.from_cp.at
-            self.defenders_starting_position = self.to_cp.at
-
-    def generate(self):
-        self.visualgen.generate()
-
-        if self.is_awacs_enabled:
-            self.awacsgen.generate()
-
-        self.extra_aagen.generate()
-        self.triggersgen.generate(self.is_quick, self.trigger_radius)
-
-        if self.environment_settings is None:
-            self.environment_settings = self.envgen.generate()
-        else:
-            self.envgen.load(self.environment_settings)
-
-        for global_cp in self.game.theater.controlpoints:
-            if not global_cp.is_global:
-                continue
-
-            ship = self.shipgen.generate_carrier(type=db.find_unittype(Carriage, self.game.player)[0],
-                                                 country=self.game.player,
-                                                 at=global_cp.at)
-
-            if global_cp == self.from_cp and not self.is_quick:
-                self.attackers_starting_position = ship
-
     def units_of(self, country_name: str) -> typing.Collection[UnitType]:
         return []
 
     def is_successfull(self, debriefing: Debriefing) -> bool:
         return True
+
+    @property
+    def is_player_attack(self) -> bool:
+        return self.from_cp.captured
+
+    def initialize(self, mission: Mission, conflict: Conflict):
+        self.current_mission = mission
+        self.conflict = conflict
+        self.airgen = AircraftConflictGenerator(mission, conflict, self.game.settings, self.game)
+        self.shipgen = ShipGenerator(mission, conflict)
+        self.airsupportgen = AirSupportConflictGenerator(mission, conflict, self.game)
+        self.triggersgen = TriggersGenerator(mission, conflict, self.game)
+        self.visualgen = VisualGenerator(mission, conflict, self.game)
+        self.envgen = EnviromentGenerator(mission, conflict, self.game)
+        self.forcedoptionsgen = ForcedOptionsGenerator(mission, conflict, self.game)
+        self.groundobjectgen = GroundObjectsGenerator(mission, conflict, self.game)
+        self.briefinggen = BriefingGenerator(mission, conflict, self.game)
+
+        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:
+            self.regular_mission = self.current_mission
+
+        self.current_mission.options.load_from_dict(options_dict)
+        self.is_quick = is_quick
+
+        if is_quick:
+            self.attackers_starting_position = None
+            self.defenders_starting_position = None
+        else:
+            self.attackers_starting_position = self.departure_cp.at
+            self.defenders_starting_position = self.to_cp.at
+
+    def generate(self):
+
+        # Generate meteo
+        if self.environment_settings is None:
+            self.environment_settings = self.envgen.generate()
+        else:
+            self.envgen.load(self.environment_settings)
+
+        # Generate ground object first
+        self.groundobjectgen.generate()
+
+        # Air Support (Tanker & Awacs)
+        self.airsupportgen.generate(self.is_awacs_enabled)
+
+        # 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])
+
+        # 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_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
+
+        # triggers
+        if self.game.is_player_attack(self.conflict.attackers_country):
+            cp = self.conflict.from_cp
+        else:
+            cp = self.conflict.to_cp
+        self.triggersgen.generate()
+
+        # options
+        self.forcedoptionsgen.generate()
+
+        # Generate Visuals Smoke Effects
+        if self.game.settings.perf_smoke_gen:
+            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")
+
+        # Generate the briefing
+        self.briefinggen.generate()
+
+
+

game/settings.py

@@ -1,8 +1,32 @@
 
 class Settings:
+
+    # Difficulty settings
     player_skill = "Good"
     enemy_skill = "Average"
-    only_player_takeoff = False
+    enemy_vehicle_skill = "Average"
+    map_coalition_visibility = "All Units"
+    labels = "Full"
+    only_player_takeoff = True  # Legacy parameter do not use
     night_disabled = False
+    external_views_allowed = True
+    supercarrier = False
     multiplier = 1
-    sams = True
+    generate_marks = True
+    sams = True # Legacy parameter do not use
+    cold_start = False # Legacy parameter do not use
+    version = None
+
+    # Performance oriented
+    perf_red_alert_state = True
+    perf_smoke_gen = True
+    perf_artillery = True
+    perf_moving_units = True
+    perf_infantry = True
+    perf_ai_parking_start = True
+
+    # Performance culling
+    perf_culling = False
+    perf_culling_distance = 100
+
+

game/utils.py

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

gen/__init__.py

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

gen/aaa.py

@@ -1,55 +1,26 @@
-from game import *
-
-from theater.conflicttheater import ConflictTheater
 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 = 35000
+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_ground_group_name(),
-                    _type=unit_type,
-                    position=self.conflict.ground_defenders_location.random_point_within(100, 100),
-                    group_size=1)
-
-    def generate(self, units: db.AirDefenseDict):
-        for type, count in units.items():
-            for _, radial in zip(range(count), self.conflict.radials):
-                distance = randint(self.conflict.size * DISTANCE_FACTOR[0], self.conflict.size * DISTANCE_FACTOR[1])
-                p = self.conflict.position.point_from_heading(radial, distance)
-
-                self.m.vehicle_group(
-                        country=self.conflict.defenders_side,
-                        name=namegen.next_ground_group_name(),
-                        _type=type,
-                        position=p,
-                        group_size=1)
-
-
 class ExtraAAConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game, player_name: Country, enemy_name: Country):
+    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:
@@ -61,14 +32,20 @@ class ExtraAAConflictGenerator:
             if cp.position.distance_to_point(self.conflict.from_cp.position) < EXTRA_AA_MIN_DISTANCE:
                 continue
 
-            country_name = cp.captured and self.player_name or self.enemy_name
+            if cp.position.distance_to_point(self.conflict.to_cp.position) < EXTRA_AA_MIN_DISTANCE:
+                continue
+
+            if cp.position.distance_to_point(self.conflict.position) > EXTRA_AA_MAX_DISTANCE:
+                continue
+
+            country_name = cp.captured and self.player_country or self.enemy_country
             position = cp.position.point_from_heading(0, EXTRA_AA_POSITION_FROM_CP)
 
             self.mission.vehicle_group(
                 country=self.mission.country(country_name),
-                name=namegen.next_ground_group_name(),
+                name=namegen.next_basedefense_name(),
                 _type=db.EXTRA_AA[country_name],
                 position=position,
-                group_size=2
+                group_size=1
             )
 

gen/aircraft.py

@@ -1,81 +1,64 @@
-from game import db
+from dcs.action import ActivateGroup, AITaskPush
+from dcs.condition import TimeAfter, CoalitionHasAirdrome
+from dcs.helicopters import UH_1H
+from dcs.terrain.terrain import NoParkingSlotError
+from dcs.triggers import TriggerOnce, Event
+
 from game.settings import Settings
+from gen.flights.ai_flight_planner import FlightPlanner
+from gen.flights.flight import Flight, FlightType, FlightWaypointType
 from .conflictgen import *
 from .naming import *
-from .triggergen import TRIGGER_WAYPOINT_OFFSET
-
-from dcs.mission import *
-from dcs.unitgroup import *
-from dcs.unittype import *
-from dcs.task import *
-from dcs.terrain.terrain import NoParkingSlotError
-
-SPREAD_DISTANCE_FACTOR = 1, 2
-ESCORT_ENGAGEMENT_MAX_DIST = 100000
-WORKAROUND_WAYP_DIST = 1000
 
+WARM_START_HELI_AIRSPEED = 120
+WARM_START_HELI_ALT = 500
 WARM_START_ALTITUDE = 3000
 WARM_START_AIRSPEED = 550
 
-INTERCEPTION_ALT = 3000
-INTERCEPTION_AIRSPEED = 1000
+CAP_DURATION = 30 # minutes
 
-ATTACK_CIRCLE_ALT = 5000
-ATTACK_CIRCLE_DURATION = 15
-
-CAS_ALTITUDE = 1000
-RTB_ALTITUDE = 1000
-HELI_ALT = 900
-
-TRANSPORT_LANDING_ALT = 1000
-
-DEFENCE_ENGAGEMENT_MAX_DISTANCE = 60000
-INTERCEPT_MAX_DISTANCE = 200000
+RTB_ALTITUDE = 800
+RTB_DISTANCE = 5000
+HELI_ALT = 500
 
 
 class AircraftConflictGenerator:
-    escort_targets = [] # type: typing.List[typing.Tuple[PlaneGroup, int]]
+    escort_targets = [] # type: typing.List[typing.Tuple[FlyingGroup, int]]
 
-    def __init__(self, mission: Mission, conflict: Conflict, settings: Settings):
+    def __init__(self, mission: Mission, conflict: Conflict, settings: Settings, game):
         self.m = mission
+        self.game = game
         self.settings = settings
         self.conflict = conflict
         self.escort_targets = []
 
-    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_FACTOR[0])
+    def _start_type(self) -> StartType:
+        return self.settings.cold_start and StartType.Cold or StartType.Warm
 
-    def _split_to_groups(self, dict: db.PlaneDict, clients: db.PlaneDict = None) -> typing.Collection[typing.Tuple[FlyingType, int, int]]:
-        for flying_type, count in dict.items():
-            if clients:
-                client_count = clients.get(flying_type, 0)
-            else:
-                client_count = 0
 
-            while count > 0:
-                group_size = min(count, 4)
-                client_size = max(min(client_count, 4), 0)
-
-                yield (flying_type, group_size, client_size)
-                count -= group_size
-                client_count -= client_size
-
-    def _setup_group(self, group: FlyingGroup, for_task: Task, client_count: int):
+    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
+
         if unit_type in db.PLANE_PAYLOAD_OVERRIDES:
             override_loadout = db.PLANE_PAYLOAD_OVERRIDES[unit_type]
             if type(override_loadout) == dict:
+
+                # Clear pylons
+                for p in group.units:
+                    p.pylons.clear()
+
+                # Now load loadout
                 if for_task in db.PLANE_PAYLOAD_OVERRIDES[unit_type]:
-                    group.load_loadout(db.PLANE_PAYLOAD_OVERRIDES[unit_type][for_task])
+                    payload_name = db.PLANE_PAYLOAD_OVERRIDES[unit_type][for_task]
+                    group.load_loadout(payload_name)
                     did_load_loadout = True
+                    logging.info("Loaded overridden payload for {} - {} for task {}".format(unit_type, payload_name, for_task))
                 elif "*" in db.PLANE_PAYLOAD_OVERRIDES[unit_type]:
-                    group.load_loadout(db.PLANE_PAYLOAD_OVERRIDES[unit_type]["*"])
+                    payload_name = db.PLANE_PAYLOAD_OVERRIDES[unit_type]["*"]
+                    group.load_loadout(payload_name)
                     did_load_loadout = True
+                    logging.info("Loaded overridden payload for {} - {} for task {}".format(unit_type, payload_name, for_task))
             elif issubclass(override_loadout, MainTask):
                 group.load_task_default_loadout(override_loadout)
                 did_load_loadout = True
@@ -94,19 +77,40 @@ 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))
 
-    def _generate_at_airport(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, airport: Airport = None) -> FlyingGroup:
+        if unit_type in helicopters.helicopter_map.values() and unit_type not in [UH_1H]:
+            group.set_frequency(127.5)
+        else:
+            if unit_type not in [P_51D_30_NA, P_51D, SpitfireLFMkIX, SpitfireLFMkIXCW, FW_190A8, FW_190D9, Bf_109K_4, P_47D_30]:
+                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, 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,
             name=name,
             aircraft_type=unit_type,
             airport=self.m.terrain.airport_by_id(airport.id),
             maintask=None,
-            start_type=StartType.Warm,
+            start_type=start_type,
             group_size=count,
             parking_slots=None)
 
@@ -114,41 +118,54 @@ class AircraftConflictGenerator:
         assert count > 0
         assert unit is not None
 
-        alt = WARM_START_ALTITUDE + random.randint(50, 200)
-        pos = Point(at.x + random.randint(100, 200), at.y + random.randint(100, 200))
+        if unit_type in helicopters.helicopter_map.values():
+            alt = WARM_START_HELI_ALT
+            speed = WARM_START_HELI_AIRSPEED
+        else:
+            alt = WARM_START_ALTITUDE
+            speed = WARM_START_AIRSPEED
 
-        return self.m.flight_group(
+        pos = Point(at.x + random.randint(100, 1000), at.y + random.randint(100, 1000))
+
+        logging.info("airgen: {} for {} at {} at {}".format(unit_type, side.id, alt, speed))
+        group = self.m.flight_group(
             country=side,
             name=name,
             aircraft_type=unit_type,
             airport=None,
             position=pos,
             altitude=alt,
-            speed=WARM_START_AIRSPEED,
+            speed=speed,
             maintask=None,
-            start_type=StartType.Warm,
+            start_type=self._start_type(),
             group_size=count)
 
-    def _generate_at_carrier(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, at: ShipGroup) -> FlyingGroup:
+        group.points[0].alt_type = "RADIO"
+        return group
+
+    def _generate_at_group(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, at: typing.Union[ShipGroup, StaticGroup]) -> FlyingGroup:
         assert count > 0
         assert unit is not None
 
+        logging.info("airgen: {} for {} at unit {}".format(unit_type, side.id, at))
         return self.m.flight_group_from_unit(
             country=side,
             name=name,
             aircraft_type=unit_type,
             pad_group=at,
             maintask=None,
-            start_type=StartType.Warm,
+            start_type=self._start_type(),
             group_size=count)
 
     def _generate_group(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, at: db.StartingPosition):
         if isinstance(at, Point):
             return self._generate_inflight(name, side, unit_type, count, client_count, at)
-        elif isinstance(at, ShipGroup):
+        elif isinstance(at, Group):
             takeoff_ban = unit_type in db.CARRIER_TAKEOFF_BAN
-            if not takeoff_ban:
-                return self._generate_at_carrier(name, side, unit_type, count, client_count, at)
+            ai_ban = client_count == 0 and self.settings.only_player_takeoff
+
+            if not takeoff_ban and not ai_ban:
+                return self._generate_at_group(name, side, unit_type, count, client_count, at)
             else:
                 return self._generate_inflight(name, side, unit_type, count, client_count, at.position)
         elif issubclass(at, Airport):
@@ -164,6 +181,27 @@ class AircraftConflictGenerator:
         else:
             assert False
 
+    def _add_radio_waypoint(self, group: FlyingGroup, position, altitude: int, airspeed: int = 600):
+        point = group.add_waypoint(position, altitude, airspeed)
+        point.alt_type = "RADIO"
+        return point
+
+    def _rtb_for(self, group: FlyingGroup, cp: ControlPoint, at: db.StartingPosition = None):
+        if not at:
+            at = cp.at
+        position = at if isinstance(at, Point) else at.position
+
+        last_waypoint = group.points[-1]
+        if last_waypoint is not None:
+            heading = position.heading_between_point(last_waypoint.position)
+            tod_location = position.point_from_heading(heading, RTB_DISTANCE)
+            self._add_radio_waypoint(group, tod_location, last_waypoint.alt)
+
+        destination_waypoint = self._add_radio_waypoint(group, position, RTB_ALTITUDE)
+        if isinstance(at, Airport):
+            group.land_at(at)
+        return destination_waypoint
+
     def _at_position(self, at) -> Point:
         if isinstance(at, Point):
             return at
@@ -174,181 +212,251 @@ 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):
-        groups = []
-        for flying_type, count, client_count in self._split_to_groups(units, clients):
+
+    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.flights:
+
+            if flight.client_count == 0 and self.game.position_culled(flight.from_cp.position):
+                logging.info("Flight not generated : culled")
+                continue
+
+            group = self.generate_planned_flight(cp, country, flight)
+            if flight.flight_type == FlightType.INTERCEPTION:
+                self.setup_group_as_intercept_flight(group, flight)
+                self._setup_custom_payload(flight, group)
+            else:
+                self.setup_flight_group(group, flight, flight.flight_type)
+            self.setup_group_activation_trigger(flight, group)
+
+
+    def setup_group_activation_trigger(self, flight, group):
+        if flight.scheduled_in > 0 and flight.client_count == 0:
+
+            if flight.start_type != "In Flight" and flight.from_cp.cptype not in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP]:
+                group.late_activation = False
+                group.uncontrolled = True
+
+                activation_trigger = TriggerOnce(Event.NoEvent, "LiberationControlTriggerForGroup" + str(group.id))
+                activation_trigger.add_condition(TimeAfter(seconds=flight.scheduled_in * 60))
+                if (flight.from_cp.cptype == ControlPointType.AIRBASE):
+                    if flight.from_cp.captured:
+                        activation_trigger.add_condition(
+                            CoalitionHasAirdrome(self.game.get_player_coalition_id(), flight.from_cp.id))
+                    else:
+                        activation_trigger.add_condition(
+                            CoalitionHasAirdrome(self.game.get_enemy_coalition_id(), flight.from_cp.id))
+
+                group.add_trigger_action(StartCommand())
+                activation_trigger.add_action(AITaskPush(group.id, len(group.tasks)))
+                self.m.triggerrules.triggers.append(activation_trigger)
+            else:
+                group.late_activation = True
+                activation_trigger = TriggerOnce(Event.NoEvent, "LiberationActivationTriggerForGroup" + str(group.id))
+                activation_trigger.add_condition(TimeAfter(seconds=flight.scheduled_in*60))
+
+                if(flight.from_cp.cptype == ControlPointType.AIRBASE):
+                    if flight.from_cp.captured:
+                        activation_trigger.add_condition(CoalitionHasAirdrome(self.game.get_player_coalition_id(), flight.from_cp.id))
+                    else:
+                        activation_trigger.add_condition(CoalitionHasAirdrome(self.game.get_enemy_coalition_id(), flight.from_cp.id))
+
+                activation_trigger.add_action(ActivateGroup(group.id))
+                self.m.triggerrules.triggers.append(activation_trigger)
+
+    def generate_planned_flight(self, cp, country, flight:Flight):
+        try:
+            if flight.client_count == 0 and self.game.settings.perf_ai_parking_start:
+                flight.start_type = "Warm"
+
+            if flight.start_type == "In Flight":
+                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
+            flight.start_type = "In Flight"
             group = self._generate_group(
-                name=namegen.next_escort_group_name(),
-                side=side,
-                unit_type=flying_type,
-                count=count,
-                client_count=client_count,
-                at=at)
+                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.task = Escort.name
+        return group
 
-            heading = group.position.heading_between_point(self.conflict.position)
-            position = group.position  # type: Point
-            wayp = group.add_waypoint(position.point_from_heading(heading, WORKAROUND_WAYP_DIST), CAS_ALTITUDE, WARM_START_AIRSPEED)
-            self._setup_group(group, CAP, client_count)
+    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)
 
-            for escorted_group, waypoint_index in self.escort_targets:
-                waypoint_index += 1
-                if not is_quick:
-                    waypoint_index += TRIGGER_WAYPOINT_OFFSET
 
-                wayp.tasks.append(EscortTaskAction(escorted_group.id, engagement_max_dist=ESCORT_ENGAGEMENT_MAX_DIST, lastwpt=waypoint_index))
+    def setup_flight_group(self, group, flight, flight_type):
 
-            if should_orbit:
-                orbit_task = ControlledTask(OrbitAction(ATTACK_CIRCLE_ALT, pattern=OrbitAction.OrbitPattern.Circle))
-                orbit_task.stop_after_duration(ATTACK_CIRCLE_DURATION * 60)
-
-                orbit_waypoint = group.add_waypoint(self.conflict.position, CAS_ALTITUDE)
-                orbit_waypoint.tasks.append(orbit_task)
-                orbit_waypoint.tasks.append(EngageTargets(max_distance=DEFENCE_ENGAGEMENT_MAX_DISTANCE))
-
-            groups.append(group)
-        return groups
-
-    def generate_cas_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
-        assert 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_cas_group_name(),
-                    side=self.conflict.attackers_side,
-                    unit_type=flying_type,
-                    count=count,
-                    client_count=client_count,
-                    at=at and at or self._group_point(self.conflict.air_attackers_location))
-
-            waypoint = group.add_waypoint(self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
+        if flight_type in [FlightType.CAP, FlightType.BARCAP, FlightType.TARCAP]:
+            group.task = CAP.name
+            self._setup_group(group, CAP, flight.client_count)
+            # group.points[0].tasks.clear()
+            # group.tasks.clear()
+            # group.tasks.append(EngageTargets(max_distance=40, targets=[Targets.All.Air]))
+            # group.tasks.append(EngageTargets(max_distance=nm_to_meter(120), targets=[Targets.All.Air]))
+            pass
+        elif flight_type in [FlightType.CAS, FlightType.BAI]:
             group.task = CAS.name
-            self._setup_group(group, CAS, client_count)
-            self.escort_targets.append((group, group.points.index(waypoint)))
-
-            group.add_waypoint(self.conflict.from_cp.position, RTB_ALTITUDE)
-            group.land_at(self.conflict.from_cp.at)
-
-    def generate_ship_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, target_groups: typing.Collection[ShipGroup], at: db.StartingPosition = None):
-        assert 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_cas_group_name(),
-                side=self.conflict.attackers_side,
-                unit_type=flying_type,
-                count=count,
-                client_count=client_count,
-                at=at and at or self._group_point(self.conflict.air_attackers_location))
-
-            wayp = group.add_waypoint(self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
-            for target_group in target_groups:
-                wayp.tasks.append(AttackGroup(target_group.id))
-
+            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))
+        elif flight_type in [FlightType.SEAD, FlightType.DEAD]:
+            group.task = SEAD.name
+            self._setup_group(group, SEAD, flight.client_count)
+            group.points[0].tasks.clear()
+            group.points[0].tasks.append(NoTask())
+            group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+            group.points[0].tasks.append(OptROE(OptROE.Values.OpenFire))
+            group.points[0].tasks.append(OptRestrictJettison(True))
+        elif flight_type in [FlightType.STRIKE]:
+            group.task = PinpointStrike.name
+            self._setup_group(group, GroundAttack, flight.client_count)
+            group.points[0].tasks.clear()
+            group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+            group.points[0].tasks.append(OptROE(OptROE.Values.OpenFire))
+            group.points[0].tasks.append(OptRestrictJettison(True))
+        elif flight_type in [FlightType.ANTISHIP]:
             group.task = AntishipStrike.name
-            self._setup_group(group, AntishipStrike, client_count)
-            self.escort_targets.append((group, group.points.index(wayp)))
+            self._setup_group(group, AntishipStrike, flight.client_count)
+            group.points[0].tasks.clear()
+            group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
+            group.points[0].tasks.append(OptROE(OptROE.Values.OpenFire))
+            group.points[0].tasks.append(OptRestrictJettison(True))
 
-            group.add_waypoint(self.conflict.from_cp.position, RTB_ALTITUDE)
-            group.land_at(self.conflict.from_cp.at)
+        for i, point in enumerate(flight.points):
+            if not point.only_for_player or (point.only_for_player and flight.client_count > 0):
+                pt = group.add_waypoint(Point(point.x, point.y), point.alt)
+                if point.waypoint_type == FlightWaypointType.PATROL_TRACK:
+                    action = ControlledTask(OrbitAction(altitude=pt.alt, pattern=OrbitAction.OrbitPattern.RaceTrack))
+                    action.stop_after_duration(CAP_DURATION * 60)
+                    #for tgt in point.targets:
+                    #    if hasattr(tgt, "position"):
+                    #        engagetgt = EngageTargetsInZone(tgt.position, radius=CAP_DEFAULT_ENGAGE_DISTANCE, targets=[Targets.All.Air])
+                    #        pt.tasks.append(engagetgt)
+                elif point.waypoint_type == FlightWaypointType.LANDING_POINT:
+                    pt.type = "Land"
+                elif point.waypoint_type == FlightWaypointType.INGRESS_STRIKE:
 
-    def generate_strikegroup_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
-        for g in self._generate_escort(
-                side=self.conflict.attackers_side,
-                units=attackers,
-                clients=clients,
-                at=at and at or self._group_point(self.conflict.air_attackers_location),
-                is_quick=at is None,
-                should_orbit=True):
-            g.add_waypoint(self.conflict.position, WARM_START_ALTITUDE)
-            g.land_at(self.conflict.from_cp.at)
+                    if group.units[0].unit_type == B_17G:
+                        if len(point.targets) > 0:
+                            bcenter = Point(0,0)
+                            for j, t in enumerate(point.targets):
+                                bcenter.x += t.position.x
+                                bcenter.y += t.position.y
+                            bcenter.x = bcenter.x / len(point.targets)
+                            bcenter.y = bcenter.y / len(point.targets)
+                            bombing = Bombing(bcenter)
+                            bombing.params["expend"] = "All"
+                            bombing.params["attackQtyLimit"] = False
+                            bombing.params["directionEnabled"] = False
+                            bombing.params["altitudeEnabled"] = False
+                            bombing.params["weaponType"] = 2032
+                            bombing.params["groupAttack"] = True
+                            pt.tasks.append(bombing)
+                    else:
+                        for j, t in enumerate(point.targets):
+                            print(t.position)
+                            pt.tasks.append(Bombing(t.position))
+                            if group.units[0].unit_type == JF_17 and j < 4:
+                                group.add_nav_target_point(t.position, "PP" + str(j + 1))
+                            if group.units[0].unit_type == F_14B and j == 0:
+                                group.add_nav_target_point(t.position, "ST")
+                elif point.waypoint_type == FlightWaypointType.INGRESS_SEAD:
 
-    def generate_transport_escort(self, escort: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
-        for g in self._generate_escort(
-                side=self.conflict.defenders_side,
-                units=escort,
-                clients=clients,
-                at=at and at or self._group_point(self.conflict.air_defenders_location),
-                is_quick=at is None,
-                should_orbit=False):
-            g.add_waypoint(self.conflict.to_cp.position, RTB_ALTITUDE)
-            g.land_at(self.conflict.to_cp.at)
+                    tgroup = self.m.find_group(point.targetGroup.group_identifier)
+                    if tgroup is not None:
+                        task = AttackGroup(tgroup.id)
+                        task.params["expend"] = "All"
+                        task.params["attackQtyLimit"] = False
+                        task.params["directionEnabled"] = False
+                        task.params["altitudeEnabled"] = False
+                        task.params["weaponType"] = 268402702 # Guided Weapons
+                        task.params["groupAttack"] = True
+                        pt.tasks.append(task)
 
-    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_intercept_group_name(),
-                side=self.conflict.defenders_side,
-                unit_type=flying_type,
-                count=count,
-                client_count=client_count,
-                at=at and at or self._group_point(self.conflict.air_defenders_location))
+                    for j, t in enumerate(point.targets):
+                        if group.units[0].unit_type == JF_17 and j < 4:
+                            group.add_nav_target_point(t.position, "PP" + str(j + 1))
+                        if group.units[0].unit_type == F_14B and j == 0:
+                            group.add_nav_target_point(t.position, "ST")
 
-            group.task = CAP.name
-            wayp = group.add_waypoint(self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
-            wayp.tasks.append(dcs.task.EngageTargets(max_distance=DEFENCE_ENGAGEMENT_MAX_DISTANCE))
-            wayp.tasks.append(dcs.task.OrbitAction(ATTACK_CIRCLE_ALT, pattern=OrbitAction.OrbitPattern.Circle))
-            self._setup_group(group, CAP, client_count)
+                if pt is not None:
+                    pt.alt_type = point.alt_type
+                    pt.name = String(point.name)
 
-            group.add_waypoint(self.conflict.to_cp.position, RTB_ALTITUDE)
-            group.land_at(self.conflict.to_cp.at)
+        self._setup_custom_payload(flight, group)
 
-    def generate_transport(self, transport: db.PlaneDict, destination: Airport):
-        assert len(self.escort_targets) == 0
 
-        for flying_type, count, client_count in self._split_to_groups(transport):
-            group = self._generate_group(
-                name=namegen.next_transport_group_name(),
-                side=self.conflict.defenders_side,
-                unit_type=flying_type,
-                count=count,
-                client_count=client_count,
-                at=self._group_point(self.conflict.air_defenders_location))
+    def setup_group_as_antiship_flight(self, group, flight):
+        group.task = AntishipStrike.name
+        self._setup_group(group, AntishipStrike, flight.client_count)
 
-            waypoint = group.add_waypoint(destination.position.random_point_within(0, 0), TRANSPORT_LANDING_ALT)
-            self.escort_targets.append((group, group.points.index(waypoint)))
+        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))
 
-            group.task = Transport.name
-            group.land_at(destination)
+        for point in flight.points:
+            group.add_waypoint(Point(point.x,point.y), point.alt)
 
-    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_intercept_group_name(),
-                side=self.conflict.attackers_side,
-                unit_type=flying_type,
-                count=count,
-                client_count=client_count,
-                at=at and at or self._group_point(self.conflict.air_attackers_location))
 
-            group.task = CAP.name
-
-            heading = group.position.heading_between_point(self.conflict.position)
-            initial_wayp = group.add_waypoint(group.position.point_from_heading(heading, WORKAROUND_WAYP_DIST), INTERCEPTION_ALT, INTERCEPTION_AIRSPEED)
-            initial_wayp.tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
-
-            wayp = group.add_waypoint(self.conflict.position, WARM_START_ALTITUDE, INTERCEPTION_AIRSPEED)
-            wayp.tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
-            self._setup_group(group, CAP, client_count)
-
-            group.add_waypoint(self.conflict.from_cp.position, RTB_ALTITUDE)
-            group.land_at(self.conflict.from_cp.at)
-
-    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_transport_group_name(),
-                side=self.conflict.attackers_side,
-                unit_type=heli_type,
-                count=count,
-                client_count=client_count,
-                at=at and at or self._group_point(self.conflict.air_attackers_location)
-            )
-
-            group.add_waypoint(
-                pos=self.conflict.position,
-                altitude=HELI_ALT,
-            )
-
-            self._setup_group(group, Transport, client_count)

gen/airsupportgen.py

@@ -0,0 +1,72 @@
+from game import db
+from .conflictgen import *
+from .naming import *
+
+from dcs.mission import *
+from dcs.unitgroup import *
+from dcs.unittype import *
+from dcs.task import *
+from dcs.terrain.terrain import NoParkingSlotError
+
+TANKER_DISTANCE = 15000
+TANKER_ALT = 4572
+TANKER_HEADING_OFFSET = 45
+
+AWACS_DISTANCE = 150000
+AWACS_ALT = 13000
+
+
+class AirSupportConflictGenerator:
+    generated_tankers = None  # type: typing.List[str]
+
+    def __init__(self, mission: Mission, conflict: Conflict, game):
+        self.mission = mission
+        self.conflict = conflict
+        self.game = game
+        self.generated_tankers = []
+
+    @classmethod
+    def support_tasks(cls) -> typing.Collection[typing.Type[MainTask]]:
+        return [Refueling, AWACS]
+
+    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)):
+            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_country),
+                name=namegen.next_tanker_name(self.mission.country(self.game.player_country)),
+                airport=None,
+                plane_type=tanker_unit_type,
+                position=tanker_position,
+                altitude=TANKER_ALT,
+                frequency=130 + i,
+                start_type=StartType.Warm,
+                tacanchannel="{}X".format(97 + i),
+            )
+
+            tanker_group.points[0].tasks.append(ActivateBeaconCommand(channel=97 + i, unit_id=tanker_group.id, aa=False))
+            tanker_group.points[0].tasks.append(SetInvisibleCommand(True))
+            tanker_group.points[0].tasks.append(SetImmortalCommand(True))
+
+        if is_awacs_enabled:
+            try:
+                awacs_unit = db.find_unittype(AWACS, self.conflict.attackers_side)[0]
+                awacs_flight = self.mission.awacs_flight(
+                    country=self.mission.country(self.game.player_country),
+                    name=namegen.next_awacs_name(self.mission.country(self.game.player_country)),
+                    plane_type=awacs_unit,
+                    altitude=AWACS_ALT,
+                    airport=None,
+                    position=self.conflict.position.random_point_within(AWACS_DISTANCE, AWACS_DISTANCE),
+                    frequency=133,
+                    start_type=StartType.Warm,
+                )
+                awacs_flight.points[0].tasks.append(SetInvisibleCommand(True))
+                awacs_flight.points[0].tasks.append(SetImmortalCommand(True))
+            except:
+                print("No AWACS for faction")
+

gen/armor.py

@@ -1,64 +1,325 @@
-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 = 16, 24
+FRONTLINE_CAS_GROUP_MIN = 1, 2
+FRONTLINE_CAS_PADDING = 12000
 
-class ArmorConflictGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict):
+RETREAT_DISTANCE = 20000
+BREAKTHROUGH_OFFENSIVE_DISTANCE = 35000
+AGGRESIVE_MOVE_DISTANCE = 16000
+
+FIGHT_DISTANCE = 3500
+
+class GroundConflictGenerator:
+
+    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):
-        for c in range(count):
-            group = self.m.vehicle_group(
-                    side,
-                    namegen.next_armor_group_name(),
-                    unit,
-                    position=self._group_point(at),
-                    group_size=1,
-                    move_formation=PointAction.OffRoad)
-            wayp = group.add_waypoint(self.conflict.position.point_from_heading(0, 500))
-            wayp.tasks = []
+    def generate(self):
 
-    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)
+        player_groups = []
+        enemy_groups = []
 
-        for type, count in defenders.items():
-            self._generate_group(
-                    side=self.conflict.defenders_side,
-                    unit=type,
-                    count=count,
-                    at=self.conflict.ground_defenders_location)
+        combat_width = self.conflict.distance/2
+        if combat_width > 500000:
+            combat_width = 500000
+        if combat_width < 35000:
+            combat_width = 35000
 
-    def generate_passengers(self, count: int):
-        unit_type = random.choice(db.find_unittype(Nothing, self.conflict.attackers_side.name))
+        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):
+
+        # Disable infantry unit gen if disabled
+        if not self.game.settings.perf_infantry:
+            return
+
+        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(
-            country=self.conflict.attackers_side,
-            name=namegen.next_passenger_group_name(),
-            _type=unit_type,
-            position=self.conflict.ground_attackers_location,
-            group_size=count
-        )
+                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):
+
+        if not self.game.settings.perf_moving_units:
+            return
+
+        for dcs_group, group in ally_groups:
+            if group.role == CombatGroupRole.ARTILLERY:
+                # Fire on any ennemy in range
+                if self.game.settings.perf_artillery:
+                    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
+
+        return group

gen/awacsgen.py

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

gen/briefinggen.py

@@ -0,0 +1,110 @@
+import logging
+
+from game import db
+from .conflictgen import *
+from .naming import *
+
+from dcs.mission import *
+
+
+class BriefingGenerator:
+    freqs = None  # type: typing.List[typing.Tuple[str, str]]
+    title = ""  # type: str
+    description = ""  # type: str
+    targets = None  # type: typing.List[typing.Tuple[str, str]]
+    waypoints = None  # type: typing.List[str]
+
+    def __init__(self, mission: Mission, conflict: Conflict, game):
+        self.m = mission
+        self.conflict = conflict
+        self.game = game
+        self.description = ""
+
+        self.freqs = []
+        self.targets = []
+        self.waypoints = []
+
+    def append_frequency(self, name: str, frequency: str):
+        self.freqs.append((name, frequency))
+
+    def append_target(self, description: str, markpoint: str = None):
+        self.targets.append((description, markpoint))
+
+    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 += "-" * 50 + "\n"
+        self.description += flight_unit_name + " x " + str(flight.count) + 2 * "\n"
+
+        self.description += "#0 -- TAKEOFF : Take off from " + flight.from_cp.name + "\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 add_ally_flight_description(self, flight):
+        if flight.client_count == 0:
+            flight_unit_name = db.unit_type_name(flight.unit_type)
+            self.description += flight.flight_type.name + " " + flight_unit_name + " x " + str(flight.count) + ", departing in " + str(flight.scheduled_in) + " minutes \n"
+
+
+    def generate(self):
+
+        self.description = ""
+
+        self.description += "DCS Liberation turn #" + str(self.game.turn) + "\n"
+        self.description += "=" * 15 + "\n\n"
+
+        self.description += "Current situation:\n"
+        self.description += "=" * 15 + "\n\n"
+
+        self.description += "\n"*2
+        self.description += "Your flights:" + "\n"
+        self.description += "=" * 15 + "\n\n"
+
+        for planner in self.game.planners.values():
+            for flight in planner.flights:
+                self.add_flight_description(flight)
+
+        self.description += "\n"*2
+        self.description += "Planned ally flights:" + "\n"
+        self.description += "=" * 15 + "\n"
+        for planner in self.game.planners.values():
+            if planner.from_cp.captured and len(planner.flights) > 0:
+                self.description += "\nFrom " + planner.from_cp.full_name + " \n"
+                self.description += "-" * 50 + "\n\n"
+                for flight in planner.flights:
+                    self.add_ally_flight_description(flight)
+
+        if self.freqs:
+            self.description += "\n\nComms Frequencies:\n"
+            self.description += "=" * 15 + "\n"
+            for name, freq in self.freqs:
+                self.description += "{}: {}\n".format(name, freq)
+        self.description += ("-" * 50) + "\n"
+        for cp in self.game.theater.controlpoints:
+            if cp.captured and cp.cptype in [ControlPointType.LHA_GROUP, ControlPointType.AIRCRAFT_CARRIER_GROUP]:
+                self.description += cp.name + "\n"
+                self.description += "TACAN : "
+
+                self.description += str(cp.tacanN)
+                if cp.tacanY:
+                    self.description += "Y"
+                else:
+                    self.description += "X"
+                self.description += " " + str(cp.tacanI) + "\n"
+
+                if cp.cptype == ControlPointType.AIRCRAFT_CARRIER_GROUP and hasattr(cp, "icls"):
+                    self.description += "ICLS Channel : " + str(cp.icls) + "\n"
+                self.description += "-" * 50 + "\n"
+
+        self.m.set_description_text(self.description)
+
+

gen/conflictgen.py

@@ -1,3 +1,4 @@
+import logging
 import typing
 import pdb
 import dcs
@@ -18,10 +19,20 @@ from theater import *
 
 AIR_DISTANCE = 40000
 
+CAPTURE_AIR_ATTACKERS_DISTANCE = 25000
+CAPTURE_AIR_DEFENDERS_DISTANCE = 60000
+STRIKE_AIR_ATTACKERS_DISTANCE = 45000
+STRIKE_AIR_DEFENDERS_DISTANCE = 25000
 
-GROUND_DISTANCE_FACTOR = 1
-GROUNDINTERCEPT_DISTANCE_FACTOR = 6
-AIR_DISTANCE = 32000
+CAP_CAS_DISTANCE = 10000, 120000
+
+GROUND_INTERCEPT_SPREAD = 5000
+GROUND_DISTANCE_FACTOR = 1.4
+GROUND_DISTANCE = 2000
+
+GROUND_ATTACK_DISTANCE = 25000, 13000
+
+TRANSPORT_FRONTLINE_DIST = 1800
 
 INTERCEPT_ATTACKERS_HEADING = -45, 45
 INTERCEPT_DEFENDERS_HEADING = -10, 10
@@ -30,10 +41,14 @@ INTERCEPT_ATTACKERS_DISTANCE = 100000
 INTERCEPT_MAX_DISTANCE = 160000
 INTERCEPT_MIN_DISTANCE = 100000
 
-NAVAL_INTERCEPT_DISTANCE_FACTOR = 0.4
+NAVAL_INTERCEPT_DISTANCE_FACTOR = 1
 NAVAL_INTERCEPT_DISTANCE_MAX = 40000
 NAVAL_INTERCEPT_STEP = 5000
 
+FRONTLINE_LENGTH = 80000
+FRONTLINE_MIN_CP_DISTANCE = 5000
+FRONTLINE_DISTANCE_STRENGTH_FACTOR = 0.7
+
 
 def _opposite_heading(h):
     return h+180
@@ -50,36 +65,51 @@ 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
     size = None  # type: int
     radials = None  # type: typing.List[int]
 
+    heading = None  # type: int
+    distance = None  # type: int
+
     ground_attackers_location = None  # type: Point
     ground_defenders_location = None  # type: Point
     air_attackers_location = None  # type: Point
     air_defenders_location = None  # type: Point
 
     def __init__(self,
-                 position: Point,
                  theater: ConflictTheater,
                  from_cp: ControlPoint,
                  to_cp: ControlPoint,
-                 attackers_side: Country,
-                 defenders_side: Country,
-                 ground_attackers_location: Point,
-                 ground_defenders_location: Point,
-                 air_attackers_location: Point,
-                 air_defenders_location: Point):
+                 attackers_side: str,
+                 defenders_side: str,
+                 attackers_country: Country,
+                 defenders_country: Country,
+                 position: Point,
+                 heading=None,
+                 distance=None,
+                 ground_attackers_location: Point = None,
+                 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
         self.position = position
+        self.heading = heading
+        self.distance = distance
         self.size = to_cp.size
         self.radials = to_cp.radials
         self.ground_attackers_location = ground_attackers_location
@@ -87,41 +117,176 @@ class Conflict:
         self.air_attackers_location = air_attackers_location
         self.air_defenders_location = air_defenders_location
 
+    @property
+    def center(self) -> Point:
+        return self.position.point_from_heading(self.heading, self.distance / 2)
+
+    @property
+    def tail(self) -> Point:
+        return self.position.point_from_heading(self.heading, self.distance)
+
+    @property
+    def is_vector(self) -> bool:
+        return self.heading is not None
+
+    @property
+    def opposite_heading(self) -> int:
+        return _heading_sum(self.heading, 180)
+
+    @property
+    def to_size(self):
+        return self.to_cp.size * GROUND_DISTANCE_FACTOR
+
+    def find_insertion_point(self, other_point: Point) -> Point:
+        if self.is_vector:
+            dx = self.position.x - self.tail.x
+            dy = self.position.y - self.tail.y
+            dr2 = float(dx ** 2 + dy ** 2)
+
+            lerp = ((other_point.x - self.tail.x) * dx + (other_point.y - self.tail.y) * dy) / dr2
+            if lerp < 0:
+                lerp = 0
+            elif lerp > 1:
+                lerp = 1
+
+            x = lerp * dx + self.tail.x
+            y = lerp * dy + self.tail.y
+            return Point(x, y)
+        else:
+            return self.position
+
+    def find_ground_position(self, at: Point, heading: int, max_distance: int = 40000) -> typing.Optional[Point]:
+        return Conflict._find_ground_position(at, max_distance, heading, self.theater)
+
     @classmethod
-    def _find_ground_location(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> Point:
-        for _ in range(0, int(max_distance), 800):
-            for _ in range(3):
-                if theater.is_on_land(initial):
-                    return initial
+    def has_frontline_between(cls, from_cp: ControlPoint, to_cp: ControlPoint) -> bool:
+        return from_cp.has_frontline and to_cp.has_frontline
 
-                initial = initial.random_point_within(1000, 1000)
+    @classmethod
+    def frontline_position(cls, theater: ConflictTheater, from_cp: ControlPoint, to_cp: ControlPoint) -> typing.Optional[typing.Tuple[Point, int]]:
+        attack_heading = from_cp.position.heading_between_point(to_cp.position)
+        attack_distance = from_cp.position.distance_to_point(to_cp.position)
+        middle_point = from_cp.position.point_from_heading(attack_heading, attack_distance / 2)
 
-            initial = initial.point_from_heading(heading, 800)
+        strength_delta = (from_cp.base.strength - to_cp.base.strength) / 1.0
+        position = middle_point.point_from_heading(attack_heading, strength_delta * attack_distance / 2 - FRONTLINE_MIN_CP_DISTANCE)
+        return position, _opposite_heading(attack_heading)
+
+
+    @classmethod
+    def frontline_vector(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> typing.Optional[typing.Tuple[Point, int, int]]:
+        initial, heading = cls.frontline_position(theater, from_cp, to_cp)
+
+        """
+        probe_end_point = initial.point_from_heading(heading, FRONTLINE_LENGTH)
+        probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y) ])
+        intersection = probe.intersection(theater.land_poly)
+
+        if isinstance(intersection, geometry.LineString):
+            intersection = intersection
+        elif isinstance(intersection, geometry.MultiLineString):
+            intersection = intersection.geoms[0]
+        else:
+            print(intersection)
+            return None
+
+        return Point(*intersection.xy[0]), _heading_sum(heading, 90), intersection.length
+        """
+        frontline = cls.frontline_position(theater, from_cp, to_cp)
+        if not frontline:
+            return None
+
+        center_position, heading = frontline
+        left_position, right_position = None, None
+
+        if not theater.is_on_land(center_position):
+            pos = cls._find_ground_position(center_position, FRONTLINE_LENGTH, _heading_sum(heading, -90), theater)
+            if pos:
+                right_position = pos
+                center_position = pos
+            else:
+                pos = cls._find_ground_position(center_position, FRONTLINE_LENGTH, _heading_sum(heading, +90), theater)
+                if pos:
+                    left_position = pos
+                    center_position = pos
+
+        if left_position is None:
+            left_position = cls._extend_ground_position(center_position, int(FRONTLINE_LENGTH/2), _heading_sum(heading, -90), theater)
+
+        if right_position is None:
+            right_position = cls._extend_ground_position(center_position, int(FRONTLINE_LENGTH/2), _heading_sum(heading, 90), theater)
+
+        return left_position, _heading_sum(heading, 90), int(right_position.distance_to_point(left_position))
+
+    @classmethod
+    def _extend_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> Point:
+        pos = initial
+        for offset in range(0, int(max_distance), 500):
+            new_pos = initial.point_from_heading(heading, offset)
+            if theater.is_on_land(new_pos):
+                pos = new_pos
+            else:
+                return pos
+        return pos
+
+        """
+        probe_end_point = initial.point_from_heading(heading, max_distance)
+        probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y)])
+
+        intersection = probe.intersection(theater.land_poly)
+        if intersection is geometry.LineString:
+            return Point(*intersection.xy[1])
+        elif intersection is geometry.MultiLineString:
+            return Point(*intersection.geoms[0].xy[1])
 
-        print("Didn't find ground position!")
         return None
+        """
 
     @classmethod
-    def capture_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def _find_ground_position(cls, initial: Point, max_distance: int, heading: int, theater: ConflictTheater) -> typing.Optional[Point]:
+        pos = initial
+        for _ in range(0, int(max_distance), 500):
+            if theater.is_on_land(pos):
+                return pos
+
+            pos = pos.point_from_heading(heading, 500)
+        """
+        probe_end_point = initial.point_from_heading(heading, max_distance)
+        probe = geometry.LineString([(initial.x, initial.y), (probe_end_point.x, probe_end_point.y) ])
+
+        intersection = probe.intersection(theater.land_poly)
+        if isinstance(intersection, geometry.LineString):
+            return Point(*intersection.xy[1])
+        elif isinstance(intersection, geometry.MultiLineString):
+            return Point(*intersection.geoms[0].xy[1])
+        """
+
+        logging.error("Didn't find ground position ({})!".format(initial))
+        return initial
+
+    @classmethod
+    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)
         defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
 
-        distance = to_cp.size * GROUND_DISTANCE_FACTOR
+        distance = GROUND_DISTANCE
         attackers_location = position.point_from_heading(attack_heading, distance)
-        attackers_location = Conflict._find_ground_location(attackers_location, distance * 2, _heading_sum(attack_heading, 180), theater)
+        attackers_location = Conflict._find_ground_position(attackers_location, distance * 2, attack_heading, theater)
 
-        defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_location(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
+        defenders_location = position.point_from_heading(defense_heading, 0)
+        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, defense_heading, theater)
 
         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=attackers_location,
             ground_defenders_location=defenders_location,
             air_attackers_location=position.point_from_heading(attack_raw_heading, CAPTURE_AIR_ATTACKERS_DISTANCE),
@@ -129,20 +294,53 @@ class Conflict:
         )
 
     @classmethod
-    def intercept_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)
+        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
+
+        distance = to_cp.size * GROUND_DISTANCE_FACTOR
+        attackers_location = position.point_from_heading(attack_heading, distance)
+        attackers_location = Conflict._find_ground_position(attackers_location, distance * 2, _heading_sum(attack_heading, 180), theater)
+
+        defenders_location = position.point_from_heading(defense_heading, distance)
+        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
+
+        return cls(
+            position=position,
+            theater=theater,
+            from_cp=from_cp,
+            to_cp=to_cp,
+            attackers_side=attacker_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),
+            air_defenders_location=position.point_from_heading(_opposite_heading(attack_raw_heading), STRIKE_AIR_DEFENDERS_DISTANCE)
+        )
+
+    @classmethod
+    def intercept_position(cls, from_cp: ControlPoint, to_cp: ControlPoint) -> Point:
         raw_distance = from_cp.position.distance_to_point(to_cp.position) * 1.5
         distance = max(min(raw_distance, INTERCEPT_MAX_DISTANCE), INTERCEPT_MIN_DISTANCE)
-
         heading = _heading_sum(from_cp.position.heading_between_point(to_cp.position), random.choice([-1, 1]) * random.randint(60, 100))
-        position = from_cp.position.point_from_heading(heading, distance)
+        return from_cp.position.point_from_heading(heading, distance)
 
+    @classmethod
+    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),
@@ -150,10 +348,10 @@ 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_location(initial_location, GROUND_INTERCEPT_SPREAD, _heading_sum(heading, 180), theater)
+        position = Conflict._find_ground_position(initial_location, GROUND_INTERCEPT_SPREAD, _heading_sum(heading, 180), theater)
         if not position:
             heading = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
             position = to_cp.position.point_from_heading(heading, to_cp.size * GROUND_DISTANCE_FACTOR)
@@ -163,8 +361,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,
@@ -172,42 +372,101 @@ class Conflict:
         )
 
     @classmethod
-    def ground_intercept_conflict(cls, attacker: Country, defender: Country, heading: int, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        heading = random.choice(to_cp.radials)
-        initial_location = to_cp.position.point_from_heading(heading, to_cp.size * GROUNDINTERCEPT_DISTANCE_FACTOR)
-        max_distance = to_cp.size * GROUNDINTERCEPT_DISTANCE_FACTOR
-        ground_location = Conflict._find_ground_location(initial_location, max_distance, _heading_sum(heading, 180), theater)
+    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
+
+        heading = frontline_heading
+        starting_position = Conflict._find_ground_position(frontline_position.point_from_heading(heading, 7000),
+                                                           GROUND_INTERCEPT_SPREAD,
+                                                           _opposite_heading(heading), theater)
+        if not starting_position:
+            starting_position = frontline_position
+            destination_position = frontline_position
+        else:
+            destination_position = frontline_position
 
         return cls(
-            position=position,
+            position=destination_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(random.randint(*INTERCEPT_ATTACKERS_HEADING) + heading, AIR_DISTANCE),
-            air_defenders_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + _opposite_heading(heading), AIR_DISTANCE)
+            ground_defenders_location=starting_position,
+            air_attackers_location=starting_position.point_from_heading(_opposite_heading(heading), AIR_DISTANCE),
+            air_defenders_location=starting_position.point_from_heading(heading, AIR_DISTANCE),
         )
 
     @classmethod
-    def ground_base_attack(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)
+
+        return cls(
+            position=position,
+            heading=heading,
+            distance=distance,
+            theater=theater,
+            from_cp=from_cp,
+            to_cp=to_cp,
+            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),
+            air_defenders_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + _opposite_heading(heading), AIR_DISTANCE),
+        )
+
+    @classmethod
+    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)
+        attack_position = position.point_from_heading(heading, randint(0, int(distance)))
+        attackers_position = attack_position.point_from_heading(heading - 90, AIR_DISTANCE)
+        defenders_position = attack_position.point_from_heading(heading + 90, random.randint(*CAP_CAS_DISTANCE))
+
+        return cls(
+            position=position,
+            heading=heading,
+            distance=distance,
+            theater=theater,
+            from_cp=from_cp,
+            to_cp=to_cp,
+            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_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)
 
         distance = to_cp.size * GROUND_DISTANCE_FACTOR
         defenders_location = position.point_from_heading(defense_heading, distance)
-        defenders_location = Conflict._find_ground_location(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
+        defenders_location = Conflict._find_ground_position(defenders_location, distance * 2, _heading_sum(defense_heading, 180), theater)
 
         return cls(
             position=position,
             theater=theater,
             from_cp=from_cp,
             to_cp=to_cp,
-            attackers_side=attacker,
-            defenders_side=defender,
+            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),
@@ -215,25 +474,30 @@ class Conflict:
         )
 
     @classmethod
-    def naval_intercept_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def naval_intercept_position(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         radial = random.choice(to_cp.sea_radials)
 
         initial_distance = min(int(from_cp.position.distance_to_point(to_cp.position) * NAVAL_INTERCEPT_DISTANCE_FACTOR), NAVAL_INTERCEPT_DISTANCE_MAX)
-        position = to_cp.position.point_from_heading(radial, initial_distance)
+        initial_position = to_cp.position.point_from_heading(radial, initial_distance)
         for offset in range(0, initial_distance, NAVAL_INTERCEPT_STEP):
-            position = to_cp.position.point_from_heading(_opposite_heading(radial), initial_distance - offset)
+            position = initial_position.point_from_heading(_opposite_heading(radial), offset)
 
             if not theater.is_on_land(position):
                 break
+        return position
 
+    @classmethod
+    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),
@@ -241,11 +505,10 @@ class Conflict:
         )
 
     @classmethod
-    def transport_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        frontline_position = cls._frontline_position(from_cp, to_cp)
-        heading = to_cp.position.heading_between_point(from_cp.position)
+    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_location(initial_dest, from_cp.position.distance_to_point(to_cp.position) / 3, heading, theater)
+        dest = cls._find_ground_position(initial_dest, from_cp.position.distance_to_point(to_cp.position) / 3, heading, theater)
         if not dest:
             radial = to_cp.find_radial(to_cp.position.heading_between_point(from_cp.position))
             dest = to_cp.position.point_from_heading(radial, to_cp.size * GROUND_DISTANCE_FACTOR)
@@ -255,8 +518,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

@@ -1,3 +1,4 @@
+import logging
 import typing
 import random
 from datetime import datetime, timedelta, time
@@ -18,21 +19,24 @@ from gen import *
 WEATHER_CLOUD_BASE = 2000, 3000
 WEATHER_CLOUD_DENSITY = 1, 8
 WEATHER_CLOUD_THICKNESS = 100, 400
-WEATHER_CLOUD_BASE_MIN = 1200
+WEATHER_CLOUD_BASE_MIN = 1600
+
+WEATHER_FOG_CHANCE = 20
+WEATHER_FOG_VISIBILITY = 2500, 5000
+WEATHER_FOG_THICKNESS = 100, 500
 
 RANDOM_TIME = {
-    "night": 5,
-    "dusk": 30,
-    "dawn": 30,
+    "night": 7,
+    "dusk": 40,
+    "dawn": 40,
     "day": 100,
 }
 
 RANDOM_WEATHER = {
-    1: 5,  # heavy rain
-    2: 15,  # rain
-    3: 25,  # dynamic
-    4: 35,  # clear
-    5: 100,  # random
+    1: 0,  # thunderstorm
+    2: 20,  # rain
+    3: 80,  # clouds
+    4: 100,  # clear
 }
 
 
@@ -47,20 +51,59 @@ class EnviromentGenerator:
         self.conflict = conflict
         self.game = game
 
-    def _gen_random_time(self):
-        start_time = datetime.combine(datetime.today(), time())
-        time_range = None
-        for k, v in RANDOM_TIME.items():
-            if self.game.settings.night_disabled and k == "night":
-                continue
+    def _gen_time(self):
 
-            if random.randint(0, 100) <= v:
-                time_range = self.game.theater.daytime_map[k]
-                break
+        start_time = self.game.current_day
+
+        daytime = self.game.current_turn_daytime
+        logging.info("Mission time will be {}".format(daytime))
+        if self.game.settings.night_disabled:
+            logging.info("Skip Night mission due to user settings")
+            if daytime == "dawn":
+                time_range = (8, 9)
+            elif daytime == "day":
+                time_range = (10, 12)
+            elif daytime == "dusk":
+                time_range = (12, 14)
+            elif daytime == "night":
+                time_range = (14, 17)
+            else:
+                time_range = (10, 12)
+        else:
+            time_range = self.game.theater.daytime_map[daytime]
 
         start_time += timedelta(hours=random.randint(*time_range))
+
+        logging.info("time - {}, slot - {}, night skipped - {}".format(
+            str(start_time),
+            str(time_range),
+            self.game.settings.night_disabled))
+
         self.mission.start_time = start_time
 
+    def _generate_wind(self, wind_speed, wind_direction=None):
+        # wind
+        if not wind_direction:
+            wind_direction = random.randint(0, 360)
+
+        self.mission.weather.wind_at_ground = Wind(wind_direction, wind_speed)
+        self.mission.weather.wind_at_2000 = Wind(wind_direction, wind_speed * 2)
+        self.mission.weather.wind_at_8000 = Wind(wind_direction, wind_speed * 3)
+
+    def _generate_base_weather(self):
+        # clouds
+        self.mission.weather.clouds_base = random.randint(*WEATHER_CLOUD_BASE)
+        self.mission.weather.clouds_density = random.randint(*WEATHER_CLOUD_DENSITY)
+        self.mission.weather.clouds_thickness = random.randint(*WEATHER_CLOUD_THICKNESS)
+
+        # wind
+        self._generate_wind(random.randint(0, 4))
+
+        # fog
+        if random.randint(0, 100) < WEATHER_FOG_CHANCE:
+            self.mission.weather.fog_visibility = random.randint(*WEATHER_FOG_VISIBILITY)
+            self.mission.weather.fog_thickness = random.randint(*WEATHER_FOG_THICKNESS)
+
     def _gen_random_weather(self):
         weather_type = None
         for k, v in RANDOM_WEATHER.items():
@@ -68,32 +111,38 @@ class EnviromentGenerator:
                 weather_type = k
                 break
 
-        print("generated weather {}".format(weather_type))
+        logging.info("generated weather {}".format(weather_type))
         if weather_type == 1:
-            self.mission.weather.heavy_rain()
-        elif weather_type == 2:
-            self.mission.weather.heavy_rain()
-            self.mission.weather.enable_fog = False
-        elif weather_type == 3:
-            self.mission.weather.random(self.mission.start_time, self.conflict.theater.terrain)
-        elif weather_type == 4:
-            pass
-        elif weather_type == 5:
-            self.mission.weather.clouds_base = random.randint(*WEATHER_CLOUD_BASE)
-            self.mission.weather.clouds_density = random.randint(*WEATHER_CLOUD_DENSITY)
-            self.mission.weather.clouds_thickness = random.randint(*WEATHER_CLOUD_THICKNESS)
+            # thunderstorm
+            self._generate_base_weather()
+            self._generate_wind(random.randint(0, 8))
 
-            wind_direction = random.randint(0, 360)
-            wind_speed = random.randint(0, 13)
-            self.mission.weather.wind_at_ground = Wind(wind_direction, wind_speed)
-            self.mission.weather.wind_at_2000 = Wind(wind_direction, wind_speed * 2)
-            self.mission.weather.wind_at_8000 = Wind(wind_direction, wind_speed * 3)
+            self.mission.weather.clouds_density = random.randint(9, 10)
+            self.mission.weather.clouds_iprecptns = Weather.Preceptions.Thunderstorm
+        elif weather_type == 2:
+            # rain
+            self._generate_base_weather()
+            self.mission.weather.clouds_density = random.randint(5, 8)
+            self.mission.weather.clouds_iprecptns = Weather.Preceptions.Rain
+
+            self._generate_wind(random.randint(0, 6))
+        elif weather_type == 3:
+            # clouds
+            self._generate_base_weather()
+        elif weather_type == 4:
+            # clear
+            pass
 
         if self.mission.weather.clouds_density > 0:
+            # sometimes clouds are randomized way too low and need to be fixed
             self.mission.weather.clouds_base = max(self.mission.weather.clouds_base, WEATHER_CLOUD_BASE_MIN)
 
+        if self.mission.weather.wind_at_ground.speed == 0:
+            # frontline smokes look silly w/o any wind
+            self._generate_wind(1)
+
     def generate(self) -> EnvironmentSettings:
-        self._gen_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/cn_dd_group.py

@@ -0,0 +1,42 @@
+import random
+
+from gen.fleet.dd_group import DDGroupGenerator
+from gen.sam.group_generator import GroupGenerator
+from dcs.ships import *
+
+
+class ChineseNavyGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(ChineseNavyGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        include_frigate = random.choice([True, True, False])
+        include_dd = random.choice([True, False])
+
+        if include_dd:
+            include_cc = random.choice([True, False])
+        else:
+            include_cc = False
+
+        if include_frigate:
+            self.add_unit(Type_054A_Frigate, "FF1", self.position.x + 1200, self.position.y + 900, self.heading)
+            self.add_unit(Type_054A_Frigate, "FF2", self.position.x + 1200, self.position.y - 900, self.heading)
+
+        if include_dd:
+            dd_type = random.choice([Type_052C_Destroyer, Type_052B_Destroyer])
+            self.add_unit(dd_type, "FF1", self.position.x + 2400, self.position.y + 900, self.heading)
+            self.add_unit(dd_type, "FF2", self.position.x + 2400, self.position.y - 900, self.heading)
+
+        if include_cc:
+            cc_type = random.choice([Type_093, CGN_1144_2_Pyotr_Velikiy])
+            self.add_unit(cc_type, "CC1", self.position.x, self.position.y, self.heading)
+
+        self.get_generated_group().points[0].speed = 20
+
+
+class Type54GroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(Type54GroupGenerator, self).__init__(game, ground_object, faction, Type_054A_Frigate)

gen/fleet/dd_group.py

@@ -0,0 +1,27 @@
+import random
+
+from gen.sam.group_generator import GroupGenerator
+from dcs.ships import *
+
+
+class DDGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction, ddtype):
+        super(DDGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+        self.ddtype = ddtype
+
+    def generate(self):
+        self.add_unit(self.ddtype, "DD1", self.position.x + 500, self.position.y + 900, self.heading)
+        self.add_unit(self.ddtype, "DD2", self.position.x + 500, self.position.y - 900, self.heading)
+        self.get_generated_group().points[0].speed = 20
+
+
+class OliverHazardPerryGroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(OliverHazardPerryGroupGenerator, self).__init__(game, ground_object, faction, Oliver_Hazzard_Perry_class)
+
+
+class ArleighBurkeGroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(ArleighBurkeGroupGenerator, self).__init__(game, ground_object, faction, USS_Arleigh_Burke_IIa)

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/ru_dd_group.py

@@ -0,0 +1,59 @@
+import random
+
+from gen.fleet.dd_group import DDGroupGenerator
+from gen.sam.group_generator import GroupGenerator
+from dcs.ships import *
+
+
+class RussianNavyGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(RussianNavyGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        include_frigate = random.choice([True, True, False])
+        include_dd = random.choice([True, False])
+
+        if include_dd:
+            include_cc = random.choice([True, False])
+        else:
+            include_cc = False
+
+        if include_frigate:
+            frigate_type = random.choice([FFL_1124_4_Grisha, FSG_1241_1MP_Molniya])
+            self.add_unit(frigate_type, "FF1", self.position.x + 1200, self.position.y + 900, self.heading)
+            self.add_unit(frigate_type, "FF2", self.position.x + 1200, self.position.y - 900, self.heading)
+
+        if include_dd:
+            dd_type = random.choice([FFG_11540_Neustrashimy, FF_1135M_Rezky])
+            self.add_unit(dd_type, "FF1", self.position.x + 2400, self.position.y + 900, self.heading)
+            self.add_unit(dd_type, "FF2", self.position.x + 2400, self.position.y - 900, self.heading)
+
+        if include_cc:
+            cc_type = random.choice([CG_1164_Moskva, CGN_1144_2_Pyotr_Velikiy])
+            self.add_unit(cc_type, "CC1", self.position.x, self.position.y, self.heading)
+
+        self.get_generated_group().points[0].speed = 20
+
+
+class GrishaGroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(GrishaGroupGenerator, self).__init__(game, ground_object, faction, FFL_1124_4_Grisha)
+
+
+class MolniyaGroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(MolniyaGroupGenerator, self).__init__(game, ground_object, faction, MolniyaGroupGenerator)
+
+
+class KiloSubGroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(KiloSubGroupGenerator, self).__init__(game, ground_object, faction, SSK_877)
+
+
+class TangoSubGroupGenerator(DDGroupGenerator):
+    def __init__(self, game, ground_object, faction):
+        super(TangoSubGroupGenerator, self).__init__(game, ground_object, faction, SSK_641B)
+

gen/fleet/schnellboot.py

@@ -0,0 +1,19 @@
+import random
+
+from dcs.ships import Schnellboot_type_S130
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class SchnellbootGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(SchnellbootGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        for i in range(random.randint(2, 4)):
+            self.add_unit(Schnellboot_type_S130, "Schnellboot" + str(i), self.position.x + i * random.randint(100, 250), self.position.y + (random.randint(100, 200)-100), self.heading)
+
+        self.get_generated_group().points[0].speed = 20

gen/fleet/ship_group_generator.py

@@ -0,0 +1,73 @@
+import logging
+import random
+
+from game import db
+from gen.fleet.carrier_group import CarrierGroupGenerator
+from gen.fleet.cn_dd_group import ChineseNavyGroupGenerator, Type54GroupGenerator
+from gen.fleet.dd_group import ArleighBurkeGroupGenerator, OliverHazardPerryGroupGenerator
+from gen.fleet.lha_group import LHAGroupGenerator
+from gen.fleet.ru_dd_group import RussianNavyGroupGenerator, GrishaGroupGenerator, MolniyaGroupGenerator, \
+    KiloSubGroupGenerator, TangoSubGroupGenerator
+from gen.fleet.schnellboot import SchnellbootGroupGenerator
+from gen.fleet.uboat import UBoatGroupGenerator
+from gen.fleet.ww2lst import WW2LSTGroupGenerator
+
+SHIP_MAP = {
+    "SchnellbootGroupGenerator": SchnellbootGroupGenerator,
+    "WW2LSTGroupGenerator": WW2LSTGroupGenerator,
+    "UBoatGroupGenerator": UBoatGroupGenerator,
+    "OliverHazardPerryGroupGenerator": OliverHazardPerryGroupGenerator,
+    "ArleighBurkeGroupGenerator": ArleighBurkeGroupGenerator,
+    "RussianNavyGroupGenerator": RussianNavyGroupGenerator,
+    "ChineseNavyGroupGenerator": ChineseNavyGroupGenerator,
+    "GrishaGroupGenerator": GrishaGroupGenerator,
+    "MolniyaGroupGenerator": MolniyaGroupGenerator,
+    "KiloSubGroupGenerator": KiloSubGroupGenerator,
+    "TangoSubGroupGenerator": TangoSubGroupGenerator,
+    "Type54GroupGenerator": Type54GroupGenerator
+}
+
+
+def generate_ship_group(game, ground_object, faction:str):
+    """
+    This generate a ship group
+    :return: Nothing, but put the group reference inside the ground object
+    """
+    faction = db.FACTIONS[faction]
+    if "boat" in faction.keys():
+        generators = faction["boat"]
+        if len(generators) > 0:
+            gen = random.choice(generators)
+            if gen in SHIP_MAP.keys():
+                generator = SHIP_MAP[gen](game, ground_object, faction)
+                generator.generate()
+                return generator.get_generated_group()
+            else:
+                logging.info("Unable to generate ship group, generator : " + str(gen) + "does not exists")
+    return None
+
+
+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/fleet/uboat.py

@@ -0,0 +1,19 @@
+import random
+
+from dcs.ships import Uboat_VIIC_U_flak
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class UBoatGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(UBoatGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        for i in range(random.randint(1, 4)):
+            self.add_unit(Uboat_VIIC_U_flak, "Uboat" + str(i), self.position.x + i * random.randint(100, 250), self.position.y + (random.randint(100, 200)-100), self.heading)
+
+        self.get_generated_group().points[0].speed = 20

gen/fleet/ww2lst.py

@@ -0,0 +1,22 @@
+import random
+
+from dcs.ships import LS_Samuel_Chase, LST_Mk_II
+
+from gen.sam.group_generator import GroupGenerator
+
+
+class WW2LSTGroupGenerator(GroupGenerator):
+
+    def __init__(self, game, ground_object, faction):
+        super(WW2LSTGroupGenerator, self).__init__(game, ground_object)
+        self.faction = faction
+
+    def generate(self):
+
+        # Add LS Samuel Chase
+        self.add_unit(LS_Samuel_Chase, "SamuelChase", self.position.x, self.position.y, self.heading)
+
+        for i in range(1, random.randint(3, 4)):
+            self.add_unit(LST_Mk_II, "LST" + str(i), self.position.x + i * random.randint(800, 1200), self.position.y, self.heading)
+
+        self.get_generated_group().points[0].speed = 20

gen/flights/ai_flight_planner.py

@@ -0,0 +1,698 @@
+import math
+import operator
+import random
+
+from game import db
+from game.data.doctrine import MODERN_DOCTRINE
+from game.data.radar_db import UNITS_WITH_RADAR
+from game.utils import meter_to_feet, nm_to_meter
+from gen import Conflict
+from gen.flights.ai_flight_planner_db import INTERCEPT_CAPABLE, CAP_CAPABLE, CAS_CAPABLE, SEAD_CAPABLE, STRIKE_CAPABLE
+from gen.flights.flight import Flight, FlightType, FlightWaypoint, FlightWaypointType
+
+
+MISSION_DURATION = 80
+
+
+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
+
+        if from_cp.captured:
+            self.faction = self.game.player_faction
+        else:
+            self.faction = self.game.enemy_faction
+
+        if "doctrine" in self.faction.keys():
+            self.doctrine = self.faction["doctrine"]
+        else:
+            self.doctrine = MODERN_DOCTRINE
+
+
+    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_cap()
+
+        # Then setup cas
+        self.commision_cas()
+
+        # Then prepare some sead flights if required
+        self.commision_sead()
+
+        self.commision_strike()
+
+        # TODO : commision 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, self.doctrine["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_cap(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/self.doctrine["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.CAP)
+
+            flight.points = []
+            flight.scheduled_in = offset + i*random.randint(self.doctrine["CAP_EVERY_X_MINUTES"] - 5, self.doctrine["CAP_EVERY_X_MINUTES"] + 5)
+
+            if len(self._get_cas_locations()) > 0:
+                enemy_cp = random.choice(self._get_cas_locations())
+                self.generate_frontline_cap(flight, flight.from_cp, enemy_cp)
+            else:
+                self.generate_barcap(flight, flight.from_cp)
+
+            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/self.doctrine["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(self.doctrine["CAS_EVERY_X_MINUTES"] - 5, self.doctrine["CAS_EVERY_X_MINUTES"] + 5)
+                location = random.choice(cas_location)
+
+                self.generate_cas(flight, flight.from_cp, location)
+
+                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/self.doctrine["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(self.doctrine["SEAD_EVERY_X_MINUTES"] - 5, self.doctrine["SEAD_EVERY_X_MINUTES"] + 5)
+
+                location = self.potential_sead_targets[0][0]
+                self.potential_sead_targets.pop(0)
+
+                self.generate_sead(flight, location, [])
+
+                self.sead_flights.append(flight)
+                self.flights.append(flight)
+
+            # Update inventory
+            for k, v in inventory.items():
+                self.aircraft_inventory[k] = v
+
+
+    def commision_strike(self):
+        """
+        Pick some aircraft to assign them to STRIKE tasks
+        """
+        possible_aircraft = [k for k, v in self.aircraft_inventory.items() if k in STRIKE_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_strike_targets) > 0:
+
+            offset = random.randint(0,5)
+            for i in range(int(MISSION_DURATION/self.doctrine["STRIKE_EVERY_X_MINUTES"])):
+
+                if len(self.potential_strike_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, FlightType.STRIKE)
+
+                flight.points = []
+                flight.scheduled_in = offset + i*random.randint(self.doctrine["STRIKE_EVERY_X_MINUTES"] - 5, self.doctrine["STRIKE_EVERY_X_MINUTES"] + 5)
+
+                location = self.potential_strike_targets[0][0]
+                self.potential_strike_targets.pop(0)
+
+                self.generate_strike(flight, location)
+
+                self.strike_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):
+        return self._get_cas_locations_for_cp(self.from_cp)
+
+    def _get_cas_locations_for_cp(self, for_cp):
+        cas_locations = []
+        for cp in for_cp.connected_points:
+            if cp.captured != for_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*self.doctrine["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 or g.is_dead: 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 < self.doctrine["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*self.doctrine["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 db.unit_type_from_name(r.type) in UNITS_WITH_RADAR]) 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 < self.doctrine["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
+
+
+    def generate_strike(self, flight, location):
+
+        flight.flight_type = FlightType.STRIKE
+        ascend = self.generate_ascend_point(flight.from_cp)
+        flight.points.append(ascend)
+
+        heading = flight.from_cp.position.heading_between_point(location.position)
+        ingress_heading = heading - 180 + 25
+        egress_heading = heading - 180 - 25
+
+        ingress_pos = location.position.point_from_heading(ingress_heading, self.doctrine["INGRESS_EGRESS_DISTANCE"])
+        ingress_point = FlightWaypoint(ingress_pos.x, ingress_pos.y, self.doctrine["INGRESS_ALT"])
+        ingress_point.pretty_name = "INGRESS on " + location.obj_name
+        ingress_point.description = "INGRESS on " + location.obj_name
+        ingress_point.name = "INGRESS"
+        ingress_point.waypoint_type = FlightWaypointType.INGRESS_STRIKE
+        flight.points.append(ingress_point)
+
+        if len(location.groups) > 0 and location.dcs_identifier == "AA":
+            for g in location.groups:
+                for j, u in enumerate(g.units):
+                    point = FlightWaypoint(u.position.x, u.position.y, 0)
+                    point.description = "STRIKE " + "[" + str(location.obj_name) + "] : " + u.type + " #" + str(j)
+                    point.pretty_name = "STRIKE " + "[" + str(location.obj_name) + "] : " + u.type + " #" + str(j)
+                    point.name = location.obj_name + "#" + str(j)
+                    point.only_for_player = True
+                    ingress_point.targets.append(location)
+                    flight.points.append(point)
+        else:
+            if hasattr(location, "obj_name"):
+                buildings = self.game.theater.find_ground_objects_by_obj_name(location.obj_name)
+                print(buildings)
+                for building in buildings:
+                    print("BUILDING " + str(building.is_dead) + " " + str(building.dcs_identifier))
+                    if building.is_dead:
+                        continue
+
+                    point = FlightWaypoint(building.position.x, building.position.y, 0)
+                    point.description = "STRIKE on " + building.obj_name + " " + building.category + " [" + str(building.dcs_identifier) + " ]"
+                    point.pretty_name = "STRIKE on " + building.obj_name + " " + building.category + " [" + str(building.dcs_identifier) + " ]"
+                    point.name = building.obj_name
+                    point.only_for_player = True
+                    ingress_point.targets.append(building)
+                    flight.points.append(point)
+            else:
+                point = FlightWaypoint(location.position.x, location.position.y, 0)
+                point.description = "STRIKE on " + location.obj_name
+                point.pretty_name = "STRIKE on " + location.obj_name
+                point.name = location.obj_name
+                point.only_for_player = True
+                ingress_point.targets.append(location)
+                flight.points.append(point)
+
+        egress_pos = location.position.point_from_heading(egress_heading, self.doctrine["INGRESS_EGRESS_DISTANCE"])
+        egress_point = FlightWaypoint(egress_pos.x, egress_pos.y, self.doctrine["EGRESS_ALT"])
+        egress_point.name = "EGRESS"
+        egress_point.pretty_name = "EGRESS from " + location.obj_name
+        egress_point.description = "EGRESS from " + location.obj_name
+        egress_point.waypoint_type = FlightWaypointType.EGRESS
+        flight.points.append(egress_point)
+
+        descend = self.generate_descend_point(flight.from_cp)
+        flight.points.append(descend)
+
+        rtb = self.generate_rtb_waypoint(flight.from_cp)
+        flight.points.append(rtb)
+
+    def generate_barcap(self, flight, for_cp):
+        """
+        Generate a barcap flight at a given location
+        :param flight: Flight to setup
+        :param for_cp: CP to protect
+        """
+        flight.flight_type = FlightType.BARCAP if for_cp.is_carrier else FlightType.CAP
+        patrol_alt = random.randint(self.doctrine["PATROL_ALT_RANGE"][0], self.doctrine["PATROL_ALT_RANGE"][1])
+
+        if len(for_cp.ground_objects) > 0:
+            loc = random.choice(for_cp.ground_objects)
+            hdg = for_cp.position.heading_between_point(loc.position)
+            radius = random.randint(self.doctrine["CAP_PATTERN_LENGTH"][0], self.doctrine["CAP_PATTERN_LENGTH"][1])
+            orbit0p = loc.position.point_from_heading(hdg - 90, radius)
+            orbit1p = loc.position.point_from_heading(hdg + 90, radius)
+        else:
+            loc = for_cp.position.point_from_heading(random.randint(0, 360), random.randint(self.doctrine["CAP_DISTANCE_FROM_CP"][0], self.doctrine["CAP_DISTANCE_FROM_CP"][1]))
+            hdg = for_cp.position.heading_between_point(loc)
+            radius = random.randint(self.doctrine["CAP_PATTERN_LENGTH"][0], self.doctrine["CAP_PATTERN_LENGTH"][1])
+            orbit0p = loc.point_from_heading(hdg - 90, radius)
+            orbit1p = loc.point_from_heading(hdg + 90, radius)
+
+        # Create points
+        ascend = self.generate_ascend_point(flight.from_cp)
+        flight.points.append(ascend)
+
+        orbit0 = FlightWaypoint(orbit0p.x, orbit0p.y, patrol_alt)
+        orbit0.name = "ORBIT 0"
+        orbit0.description = "Standby between this point and the next one"
+        orbit0.pretty_name = "Race-track start"
+        orbit0.waypoint_type = FlightWaypointType.PATROL_TRACK
+        flight.points.append(orbit0)
+
+        orbit1 = FlightWaypoint(orbit1p.x, orbit1p.y, patrol_alt)
+        orbit1.name = "ORBIT 1"
+        orbit1.description = "Standby between this point and the previous one"
+        orbit1.pretty_name = "Race-track end"
+        orbit1.waypoint_type = FlightWaypointType.PATROL
+        flight.points.append(orbit1)
+
+        orbit0.targets.append(for_cp)
+        obj_added = []
+        for ground_object in for_cp.ground_objects:
+            if ground_object.obj_name not in obj_added and not ground_object.airbase_group:
+                orbit0.targets.append(ground_object)
+                obj_added.append(ground_object.obj_name)
+
+        descend = self.generate_descend_point(flight.from_cp)
+        flight.points.append(descend)
+
+        rtb = self.generate_rtb_waypoint(flight.from_cp)
+        flight.points.append(rtb)
+
+
+    def generate_frontline_cap(self, flight, ally_cp, enemy_cp):
+        """
+        Generate a cap flight for the frontline between ally_cp and enemy cp in order to ensure air superiority and
+        protect friendly CAP airbase
+        :param flight: Flight to setup
+        :param ally_cp: CP to protect
+        :param enemy_cp: Enemy connected cp
+        """
+        flight.flight_type = FlightType.CAP
+        patrol_alt = random.randint(self.doctrine["PATROL_ALT_RANGE"][0], self.doctrine["PATROL_ALT_RANGE"][1])
+
+        # Find targets waypoints
+        ingress, heading, distance = Conflict.frontline_vector(ally_cp, enemy_cp, self.game.theater)
+        center = ingress.point_from_heading(heading, distance / 2)
+        orbit_center = center.point_from_heading(heading - 90, random.randint(nm_to_meter(6), nm_to_meter(15)))
+
+        combat_width = distance / 2
+        if combat_width > 500000:
+            combat_width = 500000
+        if combat_width < 35000:
+            combat_width = 35000
+
+        radius = combat_width*1.25
+        orbit0p = orbit_center.point_from_heading(heading, radius)
+        orbit1p = orbit_center.point_from_heading(heading + 180, radius)
+
+        # Create points
+        ascend = self.generate_ascend_point(flight.from_cp)
+        flight.points.append(ascend)
+
+        orbit0 = FlightWaypoint(orbit0p.x, orbit0p.y, patrol_alt)
+        orbit0.name = "ORBIT 0"
+        orbit0.description = "Standby between this point and the next one"
+        orbit0.pretty_name = "Race-track start"
+        orbit0.waypoint_type = FlightWaypointType.PATROL_TRACK
+        flight.points.append(orbit0)
+
+        orbit1 = FlightWaypoint(orbit1p.x, orbit1p.y, patrol_alt)
+        orbit1.name = "ORBIT 1"
+        orbit1.description = "Standby between this point and the previous one"
+        orbit1.pretty_name = "Race-track end"
+        orbit1.waypoint_type = FlightWaypointType.PATROL
+        flight.points.append(orbit1)
+
+        # Note : Targets of a PATROL TRACK waypoints are the points to be defended
+        orbit0.targets.append(flight.from_cp)
+        orbit0.targets.append(center)
+
+        descend = self.generate_descend_point(flight.from_cp)
+        flight.points.append(descend)
+
+        rtb = self.generate_rtb_waypoint(flight.from_cp)
+        flight.points.append(rtb)
+
+
+    def generate_sead(self, flight, location, custom_targets = []):
+        """
+        Generate a sead flight at a given location
+        :param flight: Flight to setup
+        :param location: Location of the SEAD target
+        :param custom_targets: Custom targets if any
+        """
+        flight.points = []
+        flight.flight_type = random.choice([FlightType.SEAD, FlightType.DEAD])
+
+        ascend = self.generate_ascend_point(flight.from_cp)
+        flight.points.append(ascend)
+
+        heading = flight.from_cp.position.heading_between_point(location.position)
+        ingress_heading = heading - 180 + 25
+        egress_heading = heading - 180 - 25
+
+        ingress_pos = location.position.point_from_heading(ingress_heading, self.doctrine["INGRESS_EGRESS_DISTANCE"])
+        ingress_point = FlightWaypoint(ingress_pos.x, ingress_pos.y, self.doctrine["INGRESS_ALT"])
+        ingress_point.name = "INGRESS"
+        ingress_point.pretty_name = "INGRESS on " + location.obj_name
+        ingress_point.description = "INGRESS on " + location.obj_name
+        ingress_point.waypoint_type = FlightWaypointType.INGRESS_SEAD
+        flight.points.append(ingress_point)
+
+        if len(custom_targets) > 0:
+            for target in custom_targets:
+                point = FlightWaypoint(target.position.x, target.position.y, 0)
+                point.alt_type = "RADIO"
+                if flight.flight_type == FlightType.DEAD:
+                    point.description = "SEAD on " + target.type
+                    point.pretty_name = "SEAD on " + location.obj_name
+                    point.only_for_player = True
+                else:
+                    point.description = "DEAD on " + location.obj_name
+                    point.pretty_name = "DEAD on " + location.obj_name
+                    point.only_for_player = True
+            ingress_point.targets.append(location)
+            ingress_point.targetGroup = location
+            flight.points.append(point)
+        else:
+            point = FlightWaypoint(location.position.x, location.position.y, 0)
+            point.alt_type = "RADIO"
+            if flight.flight_type == FlightType.DEAD:
+                point.description = "SEAD on " + location.obj_name
+                point.pretty_name = "SEAD on " + location.obj_name
+                point.only_for_player = True
+            else:
+                point.description = "DEAD on " + location.obj_name
+                point.pretty_name = "DEAD on " + location.obj_name
+                point.only_for_player = True
+            ingress_point.targets.append(location)
+            ingress_point.targetGroup = location
+            flight.points.append(point)
+
+        egress_pos = location.position.point_from_heading(egress_heading, self.doctrine["INGRESS_EGRESS_DISTANCE"])
+        egress_point = FlightWaypoint(egress_pos.x, egress_pos.y, self.doctrine["EGRESS_ALT"])
+        egress_point.name = "EGRESS"
+        egress_point.pretty_name = "EGRESS from " + location.obj_name
+        egress_point.description = "EGRESS from " + location.obj_name
+        egress_point.waypoint_type = FlightWaypointType.EGRESS
+        flight.points.append(egress_point)
+
+        descend = self.generate_descend_point(flight.from_cp)
+        flight.points.append(descend)
+
+        rtb = self.generate_rtb_waypoint(flight.from_cp)
+        flight.points.append(rtb)
+
+
+    def generate_cas(self, flight, from_cp, location):
+        """
+        Generate a CAS flight at a given location
+        :param flight: Flight to setup
+        :param location: Location of the CAS targets
+        """
+
+        flight.points = []
+        flight.flight_type = FlightType.CAS
+
+        ingress, heading, distance = Conflict.frontline_vector(from_cp, location, self.game.theater)
+        center = ingress.point_from_heading(heading, distance / 2)
+        egress = ingress.point_from_heading(heading, distance)
+
+        ascend = self.generate_ascend_point(flight.from_cp)
+        flight.points.append(ascend)
+
+        ingress_point = FlightWaypoint(ingress.x, ingress.y, 1000)
+        ingress_point.alt_type = "RADIO"
+        ingress_point.name = "INGRESS"
+        ingress_point.pretty_name = "INGRESS"
+        ingress_point.description = "Ingress into CAS area"
+        ingress_point.waypoint_type = FlightWaypointType.INGRESS_CAS
+        flight.points.append(ingress_point)
+
+        center_point = FlightWaypoint(center.x, center.y, 1000)
+        center_point.alt_type = "RADIO"
+        center_point.description = "Provide CAS"
+        center_point.name = "CAS"
+        center_point.pretty_name = "CAS"
+        center_point.waypoint_type = FlightWaypointType.CAS
+        flight.points.append(center_point)
+
+        egress_point = FlightWaypoint(egress.x, egress.y, 1000)
+        egress_point.alt_type = "RADIO"
+        egress_point.description = "Egress from CAS area"
+        egress_point.name = "EGRESS"
+        egress_point.pretty_name = "EGRESS"
+        egress_point.waypoint_type = FlightWaypointType.EGRESS
+        flight.points.append(egress_point)
+
+        descend = self.generate_descend_point(flight.from_cp)
+        flight.points.append(descend)
+
+        rtb = self.generate_rtb_waypoint(flight.from_cp)
+        flight.points.append(rtb)
+
+
+    def generate_ascend_point(self, from_cp):
+        """
+        Generate ascend point
+        :param from_cp: Airport you're taking off from
+        :return:
+        """
+        ascend_heading = from_cp.heading
+        pos_ascend = from_cp.position.point_from_heading(ascend_heading, 10000)
+        ascend = FlightWaypoint(pos_ascend.x, pos_ascend.y, self.doctrine["PATTERN_ALTITUDE"])
+        ascend.name = "ASCEND"
+        ascend.alt_type = "RADIO"
+        ascend.description = "Ascend"
+        ascend.pretty_name = "Ascend"
+        ascend.waypoint_type = FlightWaypointType.ASCEND_POINT
+        return ascend
+
+
+    def generate_descend_point(self, from_cp):
+        """
+        Generate approach/descend point
+        :param from_cp: Airport you're landing at
+        :return:
+        """
+        ascend_heading = from_cp.heading
+        descend = from_cp.position.point_from_heading(ascend_heading - 180, 10000)
+        descend = FlightWaypoint(descend.x, descend.y, self.doctrine["PATTERN_ALTITUDE"])
+        descend.name = "DESCEND"
+        descend.alt_type = "RADIO"
+        descend.description = "Descend to pattern alt"
+        descend.pretty_name = "Descend to pattern alt"
+        descend.waypoint_type = FlightWaypointType.DESCENT_POINT
+        return descend
+
+
+    def generate_rtb_waypoint(self, from_cp):
+        """
+        Generate RTB landing point
+        :param from_cp: Airport you're landing at
+        :return:
+        """
+        rtb = from_cp.position
+        rtb = FlightWaypoint(rtb.x, rtb.y, 0)
+        rtb.name = "LANDING"
+        rtb.alt_type = "RADIO"
+        rtb.description = "RTB"
+        rtb.pretty_name = "RTB"
+        rtb.waypoint_type = FlightWaypointType.LANDING_POINT
+        return rtb

gen/flights/ai_flight_planner_db.py

@@ -0,0 +1,196 @@
+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,
+    P_47D_30,
+
+    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,
+    P_47D_30,
+    A_20G,
+
+    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, Not yet
+    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,
+
+    P_51D_30_NA,
+    P_51D,
+    P_47D_30,
+    A_20G,
+    B_17G,
+
+    SpitfireLFMkIXCW,
+    SpitfireLFMkIX,
+
+    Bf_109K_4,
+    FW_190D9,
+    FW_190A8,
+
+]
+
+ANTISHIP_CAPABLE = [
+    Su_24M,
+    Su_17M4,
+    F_A_18C,
+    AV8BNA,
+    JF_17,
+    F_16C_50,
+    A_10C,
+    A_10A,
+
+    Ju_88A4,
+]

gen/flights/flight.py

@@ -0,0 +1,121 @@
+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 FlightWaypointType(Enum):
+    TAKEOFF = 0             # Take off point
+    ASCEND_POINT = 1        # Ascension point after take off
+    PATROL = 2              # Patrol point
+    PATROL_TRACK = 3        # Patrol race track
+    NAV = 4                 # Nav point
+    INGRESS_STRIKE = 5      # Ingress strike (For generator, means that this should have bombing on next TARGET_POINT points)
+    INGRESS_SEAD = 6        # Ingress sead (For generator, means that this should attack groups on TARGET_GROUP_LOC points)
+    INGRESS_CAS = 7         # Ingress cas (should start CAS task)
+    CAS = 8                 # Should do CAS there
+    EGRESS = 9              # Should stop attack
+    DESCENT_POINT = 10       # Should start descending to pattern alt
+    LANDING_POINT = 11      # Should land there
+    TARGET_POINT = 12       # A target building or static object, position
+    TARGET_GROUP_LOC = 13   # A target group approximate location
+    TARGET_SHIP = 14        # A target ship known location
+    CUSTOM = 15             # User waypoint (no specific behaviour)
+
+
+class PredefinedWaypointCategory(Enum):
+    NOT_PREDEFINED = 0
+    ALLY_CP = 1
+    ENEMY_CP = 2
+    FRONTLINE = 3
+    ENEMY_BUILDING = 4
+    ENEMY_UNIT = 5
+    ALLY_BUILDING = 6
+    ALLY_UNIT = 7
+
+
+class FlightWaypoint:
+
+    def __init__(self, x: float, y: float, alt=0):
+        self.x = x
+        self.y = y
+        self.alt = alt
+        self.alt_type = "BARO"
+        self.name = ""
+        self.description = ""
+        self.targets = []
+        self.targetGroup = None
+        self.obj_name = ""
+        self.pretty_name = ""
+        self.waypoint_type = FlightWaypointType.TAKEOFF  # type: FlightWaypointType
+        self.category = PredefinedWaypointCategory.NOT_PREDEFINED# type: PredefinedWaypointCategory
+        self.only_for_player = False
+        self.data = None
+
+
+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/forcedoptionsgen.py

@@ -0,0 +1,55 @@
+import logging
+import typing
+from enum import IntEnum
+
+from dcs.mission import Mission
+from dcs.forcedoptions import ForcedOptions
+
+from .conflictgen import *
+
+
+class Labels(IntEnum):
+    Off = 0
+    Full = 1
+    Abbreviated = 2
+    Dot = 3
+
+
+class ForcedOptionsGenerator:
+    def __init__(self, mission: Mission, conflict: Conflict, game):
+        self.mission = mission
+        self.conflict = conflict
+        self.game = game
+
+    def _set_options_view(self):
+
+        if self.game.settings.map_coalition_visibility == ForcedOptions.Views.All:
+            self.mission.forced_options.options_view = ForcedOptions.Views.All
+        elif self.game.settings.map_coalition_visibility == ForcedOptions.Views.Allies:
+            self.mission.forced_options.options_view = ForcedOptions.Views.Allies
+        elif self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyAllies:
+            self.mission.forced_options.options_view = ForcedOptions.Views.OnlyAllies
+        elif self.game.settings.map_coalition_visibility == ForcedOptions.Views.MyAircraft:
+            self.mission.forced_options.options_view = ForcedOptions.Views.MyAircraft
+        elif self.game.settings.map_coalition_visibility == ForcedOptions.Views.OnlyMap:
+            self.mission.forced_options.options_view = ForcedOptions.Views.OnlyMap
+
+    def _set_external_views(self):
+        if not self.game.settings.external_views_allowed:
+            self.mission.forced_options.external_views = self.game.settings.external_views_allowed
+
+    def _set_labels(self):
+        if self.game.settings.labels == "Abbreviated":
+            self.mission.forced_options.labels = int(Labels.Abbreviated)
+        elif self.game.settings.labels == "Dot Only":
+            self.mission.forced_options.labels = int(Labels.Dot)
+        elif self.game.settings.labels == "Off":
+            self.mission.forced_options.labels = int(Labels.Off)
+
+    def generate(self):
+        self._set_options_view()
+        self._set_external_views()
+        self._set_labels()
+
+
+        

gen/ground_forces/ai_ground_planner.py

@@ -0,0 +1,292 @@
+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.ZTZ_96B,
+
+    # WW2
+    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.ST_Centaur_IV,
+    Armor.CT_Cromwell_IV,
+    Armor.HIT_Churchill_VII,
+]
+
+TYPE_ATGM = [
+    Armor.ATGM_M1045_HMMWV_TOW,
+    Armor.ATGM_M1134_Stryker,
+    Armor.IFV_BMP_2,
+
+    # WW2 (Tank Destroyers)
+    Armor.M30_Cargo_Carrier,
+    Armor.TD_Jagdpanzer_IV,
+    Armor.TD_Jagdpanther_G1,
+    Armor.TD_M10_GMC,
+]
+
+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,
+
+    # WW2
+    Armor.IFV_Sd_Kfz_234_2_Puma,
+    Armor.LAC_M8_Greyhound,
+]
+
+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.FDDM_Grad,
+
+    # WW2
+    Armor.APC_M2A1,
+    Armor.APC_Sd_Kfz_251,
+]
+
+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.MLRS_FDDM,
+
+    # WW2
+    Artillery.Sturmpanzer_IV_Brummbär,
+    Artillery.M12_GMC
+]
+
+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

@@ -0,0 +1,177 @@
+import logging
+
+from game import db
+from game.data.building_data import FORTIFICATION_UNITS_ID, FORTIFICATION_UNITS
+from game.db import unit_type_from_name
+from .conflictgen import *
+from .naming import *
+
+from dcs.mission import *
+from dcs.statics import *
+
+FARP_FRONTLINE_DISTANCE = 10000
+AA_CP_MIN_DISTANCE = 40000
+
+
+class GroundObjectsGenerator:
+    FARP_CAPACITY = 4
+
+    def __init__(self, mission: Mission, conflict: Conflict, game):
+        self.m = mission
+        self.conflict = conflict
+        self.game = game
+
+    def generate_farps(self, number_of_units=1) -> typing.Collection[StaticGroup]:
+        if self.conflict.is_vector:
+            center = self.conflict.center
+            heading = self.conflict.heading - 90
+        else:
+            center, heading = self.conflict.frontline_position(self.conflict.theater, self.conflict.from_cp, self.conflict.to_cp)
+            heading -= 90
+
+        initial_position = center.point_from_heading(heading, FARP_FRONTLINE_DISTANCE)
+        position = self.conflict.find_ground_position(initial_position, heading)
+        if not position:
+            position = initial_position
+
+        for i, _ in enumerate(range(0, number_of_units, self.FARP_CAPACITY)):
+            position = position.point_from_heading(0, i * 275)
+
+            yield self.m.farp(
+                country=self.m.country(self.game.player_country),
+                name="FARP",
+                position=position,
+            )
+
+    def generate(self):
+
+        cp = None  # type: ControlPoint
+        if self.conflict.attackers_country.name == self.game.player_country:
+            cp = self.conflict.to_cp
+        else:
+            cp = self.conflict.from_cp
+
+        for cp in self.game.theater.controlpoints:
+
+            if cp.captured:
+                country = self.game.player_country
+            else:
+                country = self.game.enemy_country
+            side = self.m.country(country)
+
+            for ground_object in cp.ground_objects:
+                if ground_object.dcs_identifier == "AA":
+
+                    if self.game.position_culled(ground_object.position):
+                        continue
+
+                    for g in ground_object.groups:
+                        if len(g.units) > 0:
+                            utype = unit_type_from_name(g.units[0].type)
+
+                            if not ground_object.sea_object:
+                                vg = self.m.vehicle_group(side, g.name, utype, position=g.position, heading=g.units[0].heading)
+                                vg.units[0].name = self.m.string(g.units[0].name)
+                                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)
+                            else:
+                                vg = self.m.ship_group(side, g.name, utype, position=g.position,
+                                                          heading=g.units[0].heading)
+                                vg.units[0].name = self.m.string(g.units[0].name)
+                                for i, u in enumerate(g.units):
+                                    utype = unit_type_from_name(u.type)
+                                    if i > 0:
+                                        ship = Ship(self.m.next_unit_id(), self.m.string(u.name), utype)
+                                        ship.position.x = u.position.x
+                                        ship.position.y = u.position.y
+                                        ship.heading = u.heading
+                                        vg.add_unit(ship)
+
+                            if self.game.settings.perf_red_alert_state:
+                                vg.points[0].tasks.append(OptAlarmState(2))
+                            else:
+                                vg.points[0].tasks.append(OptAlarmState(1))
+
+
+                elif ground_object.dcs_identifier in ["CARRIER", "LHA"]:
+                    for g in ground_object.groups:
+                        if len(g.units) > 0:
+
+                            utype = unit_type_from_name(g.units[0].type)
+                            if ground_object.dcs_identifier == "CARRIER" and self.game.settings.supercarrier == True:
+                                utype = db.upgrade_to_supercarrier(utype, cp.name)
+
+                            sg = self.m.ship_group(side, g.name, utype, position=g.position, heading=g.units[0].heading)
+                            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)
+
+                            # Find carrier direction (In the wind)
+                            found_carrier_destination = False
+                            attempt = 0
+                            while not found_carrier_destination and attempt < 5:
+                                point = sg.points[0].position.point_from_heading(self.m.weather.wind_at_ground.direction, 100000-attempt*20000)
+                                if self.game.theater.is_in_sea(point):
+                                    found_carrier_destination = True
+                                    sg.add_waypoint(point)
+                                else:
+                                    attempt = attempt + 1
+
+                            # Set UP TACAN and ICLS
+                            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))
+                            if ground_object.dcs_identifier == "CARRIER" and hasattr(cp, "icls"):
+                                sg.points[0].tasks.append(ActivateICLSCommand(cp.icls, unit_id=sg.units[0].id))
+
+                else:
+
+                    if self.game.position_culled(ground_object.position):
+                        continue
+
+                    static_type = None
+                    if ground_object.dcs_identifier in warehouse_map:
+                        static_type = warehouse_map[ground_object.dcs_identifier]
+                    elif ground_object.dcs_identifier in fortification_map:
+                        static_type = fortification_map[ground_object.dcs_identifier]
+                    elif ground_object.dcs_identifier in FORTIFICATION_UNITS_ID:
+                        for f in FORTIFICATION_UNITS:
+                            if f.id == ground_object.dcs_identifier:
+                                unit_type = f
+                                break
+                    else:
+                        print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
+                        continue
+
+                    if static_type is None:
+                        if not ground_object.is_dead:
+                            group = self.m.vehicle_group(
+                                country=side,
+                                name=ground_object.string_identifier,
+                                _type=unit_type,
+                                position=ground_object.position,
+                                heading=ground_object.heading,
+                            )
+                            logging.info("generated {}object identifier {} with mission id {}".format(
+                                "dead " if ground_object.is_dead else "", group.name, group.id))
+                    else:
+                        group = self.m.static_group(
+                            country=side,
+                            name=ground_object.string_identifier,
+                            _type=static_type,
+                            position=ground_object.position,
+                            heading=ground_object.heading,
+                            dead=ground_object.is_dead,
+                        )
+
+                        logging.info("generated {}object identifier {} with mission id {}".format("dead " if ground_object.is_dead else "", group.name, group.id))

gen/missiles/missiles_group_generator.py

@@ -0,0 +1,27 @@
+import logging
+import random
+from game import db
+from gen.missiles.v1_group import V1GroupGenerator
+
+MISSILES_MAP = {
+    "V1GroupGenerator": V1GroupGenerator,
+}
+
+
+def generate_missile_group(game, ground_object, faction:str):
+    """
+    This generate a ship group
+    :return: Nothing, but put the group reference inside the ground object
+    """
+    faction = db.FACTIONS[faction]
+    if "missiles" in faction.keys():
+        generators = faction["missiles"]
+        if len(generators) > 0:
+            gen = random.choice(generators)
+            if gen in MISSILES_MAP.keys():
+                generator = MISSILES_MAP[gen](game, ground_object, faction)
+                generator.generate()
+                return generator.get_generated_group()
+            else:
+                logging.info("Unable to generate missile group, generator : " + str(gen) + "does not exists")
+    return None