Merge pull request #66 from shdwp/develop

Develop

.gitignore

@@ -1,9 +1,14 @@
 *.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/modules.xml

@@ -3,7 +3,6 @@
   <component name="ProjectModuleManager">
     <modules>
       <module fileurl="file://$PROJECT_DIR$/.idea/dcs_pmcliberation.iml" filepath="$PROJECT_DIR$/.idea/dcs_pmcliberation.iml" />
-      <module fileurl="file://$PROJECT_DIR$/.idea/dcs_pmcliberation.iml" filepath="$PROJECT_DIR$/.idea/dcs_pmcliberation.iml" />
     </modules>
   </component>
 </project>

README.md

@@ -1,8 +1,26 @@
-[DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player liberation dynamic campaign. 
+![Logo](https://i.imgur.com/c2k18E1.png)
 
-[Installation instructions/Manual](https://github.com/shdwp/dcs_liberation/wiki)
-
-Inspired by *ARMA Liberation* mission.
+[DCS World](https://www.digitalcombatsimulator.com/en/products/world/) single-player dynamic campaign. 
 
 Uses [pydcs](http://github.com/pydcs/dcs) for mission generation.
 
+## Tutorials
+* [Manual](https://github.com/shdwp/dcs_liberation/wiki/Manual)
+
+You should start with the manual, it covers everything you need to know before playing the campaign.
+
+* [Strike objectives reference images](https://imgur.com/a/vCSHa9f)
+
+If you can't find the strike objective you can see here how it's supposed to look.
+
+* [Troubleshooting](https://github.com/shdwp/dcs_liberation/wiki/Troubleshooting)
+
+You could also briefly check the troubleshooting page to get familiar with the known issues that you could probably fix by yourself.
+
+* [Modding tutorial](https://github.com/shdwp/dcs_liberation/wiki/Modding-tutorial)
+
+Modding tutorial will cover how to change default loadouts, configure which planes are present in the campaign (or add new altogether) and more. Check this out if you find that something is not going for your liking, there could be a tutorial for changing that. Although be aware that it would require changing source files and could easily result in non functioning application.
+
+* [Development guide](https://github.com/shdwp/dcs_liberation/wiki/Development-guide)
+
+If you want to contribute to the project, this will give you a brief overview and on how to actually run it from source files.

__init__.py

@@ -1,63 +1,26 @@
 #!/usr/bin/env python3
+import logging
 import os
+import re
 import sys
+
 import dcs
 
-import theater.caucasus
-import theater.persiangulf
-import theater.nevada
-
-import ui.window
+import ui.corruptedsavemenu
 import ui.mainmenu
 import ui.newgamemenu
-import ui.corruptedsavemenu
-
+import ui.window
 from game.game import Game
-from theater import start_generator
-from userdata import persistency
+from userdata import persistency, logging as logging_module
 
-
-"""
-from dcs.lua.parse import *
-a = loads(open("build/mission", "r").read())
-b = loads(open("build/mission_workin.lua", "r").read())
-
-
-def get(a, k):
-    b = a
-    for x in k.strip().split(" "):
-        if isinstance(a, dict):
-            y = a
-            a = a.get(x, None)
-            if a is None:
-                try:
-                    a = y.get(int(x), None)
-                except:
-                    pass
-        else:
-            break
-    if a is None:
-        pass
-    return a
-
-def cycle(kk, ref, v):
-    if isinstance(v, dict):
-        for k, v in v.items():
-            cycle(kk + " " + str(k), ref, v)
-    elif isinstance(v, list):
-        for i, v in enumerate(v):
-            cycle(kk + " " + str(i), ref, v)
-    else:
-        if get(ref, kk) != v:
-            print(kk, v)
-            print(get(ref, kk))
-
-cycle("", a, b)
-sys.exit(0)
-"""
+assert len(sys.argv) >= 3, "__init__.py should be started with two mandatory arguments: %UserProfile% location and application version"
 
 persistency.setup(sys.argv[1])
-dcs.planes.FlyingType.payload_dirs.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "resources\\payloads"))
+dcs.planes.FlyingType.payload_dirs = [os.path.join(os.path.dirname(os.path.realpath(__file__)), "resources\\payloads")]
+
+VERSION_STRING = sys.argv[2]
+logging_module.setup_version_string(VERSION_STRING)
+logging.info("Using {} as userdata folder".format(persistency.base_path()))
 
 
 def proceed_to_main_menu(game: Game):
@@ -65,42 +28,36 @@ def proceed_to_main_menu(game: Game):
     m.display()
 
 
+def is_version_compatible(save_version):
+    current_version_components = re.split(r"[\._]", VERSION_STRING)
+    save_version_components = re.split(r"[\._]", save_version)
+
+    if "--ignore-save" in sys.argv:
+        return False
+
+    if current_version_components == save_version_components:
+        return True
+
+    if save_version in ["1.4_rc1", "1.4_rc2", "1.4_rc3", "1.4_rc4", "1.4_rc5", "1.4_rc6"]:
+        return False
+
+    if current_version_components[:2] == save_version_components[:2]:
+        return True
+
+    return False
+
+
 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()
+    if not game or not is_version_compatible(game.settings.version):
+        ui.newgamemenu.NewGameMenu(w, w.start_new_game).display()
     else:
+        game.settings.version = VERSION_STRING
         proceed_to_main_menu(game)
 except Exception as e:
+    logging.exception(e)
     ui.corruptedsavemenu.CorruptedSaveMenu(w).display()
 
 w.run()

a.py

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

game/db.py

@@ -1,12 +1,15 @@
 import typing
+import enum
 
 from dcs.vehicles import *
-from dcs.unitgroup import *
 from dcs.ships import *
 from dcs.planes import *
 from dcs.helicopters import *
+
 from dcs.task import *
+from dcs.unit import *
 from dcs.unittype import *
+from dcs.unitgroup import *
 
 """
 ---------- BEGINNING OF CONFIGURATION SECTION
@@ -36,12 +39,11 @@ and prioritization for the enemy (i.e. less important bases will receive units w
 """
 PRICES = {
     # fighter
-    C_101CC: 8,
-    MiG_23MLD: 20,
-    Su_27: 24,
-    Su_33: 25,
-    MiG_29A: 22,
-    MiG_29S: 26,
+    MiG_23MLD: 13,
+    Su_27: 18,
+    Su_33: 22,
+    MiG_29A: 18,
+    MiG_29S: 20,
 
     F_5E_3: 6,
     MiG_15bis: 5,
@@ -51,7 +53,8 @@ PRICES = {
     AV8BNA: 13,
     M_2000C: 13,
     FA_18C_hornet: 18,
-    F_15C: 24,
+    F_15C: 20,
+    F_14B: 14,
 
     # bomber
     Su_25: 15,
@@ -64,7 +67,8 @@ PRICES = {
 
     # heli
     Ka_50: 13,
-    UH_1H: 5,
+    SA342M: 8,
+    UH_1H: 4,
     Mi_8MT: 5,
 
     # special
@@ -73,21 +77,22 @@ PRICES = {
     An_30M: 13,
     Yak_40: 13,
     S_3B_Tanker: 13,
+    IL_78M: 13,
+    KC_135: 13,
 
     A_50: 8,
     E_3A: 8,
     C_130: 8,
 
     # armor
-    Armor.MBT_T_55: 4,
-    Armor.MBT_T_80U: 8,
-    Armor.MBT_T_90: 10,
+    Armor.APC_BTR_80: 16,
+    Armor.MBT_T_55: 22,
+    Armor.MBT_T_80U: 28,
+    Armor.MBT_T_90: 35,
 
-    Armor.MBT_M60A3_Patton: 6,
-    Armor.MBT_M1A2_Abrams: 9,
-
-    Armor.ATGM_M1134_Stryker: 6,
-    Armor.APC_BTR_80: 6,
+    Armor.ATGM_M1134_Stryker: 18,
+    Armor.MBT_M60A3_Patton: 24,
+    Armor.MBT_M1A2_Abrams: 35,
 
     Unarmed.Transport_UAZ_469: 3,
     Unarmed.Transport_Ural_375: 3,
@@ -97,20 +102,19 @@ PRICES = {
     Unarmed.Transport_M818: 3,
 
     AirDefence.AAA_Vulcan_M163: 5,
-    AirDefence.SAM_Avenger_M1097: 10,
-    AirDefence.SAM_Patriot_ICC: 15,
+    AirDefence.SAM_Linebacker_M6: 10,
 
-    AirDefence.AAA_ZU_23_on_Ural_375: 5,
-    AirDefence.SAM_SA_18_Igla_S_MANPADS: 8,
-    AirDefence.SAM_SA_19_Tunguska_2S6: 15,
-    AirDefence.SAM_SA_8_Osa_9A33: 13,
+    AirDefence.SPAAA_ZSU_23_4_Shilka: 8,
+    AirDefence.SAM_SA_9_Strela_1_9P31: 13,
+    AirDefence.SAM_SA_8_Osa_9A33: 18,
 
     # ship
     CV_1143_5_Admiral_Kuznetsov: 100,
     CVN_74_John_C__Stennis: 100,
+    LHA_1_Tarawa: 50,
 
-    LHA_1_Tarawa: 30,
     Bulk_cargo_ship_Yakushev: 10,
+    Armed_speedboat: 10,
     Dry_cargo_ship_Ivanov: 10,
     Tanker_Elnya_160: 10,
 }
@@ -133,9 +137,8 @@ Following tasks are present:
 """
 UNIT_BY_TASK = {
     CAP: [
-        C_101CC,
-        AJS37,
         F_5E_3,
+        MiG_23MLD,
         Su_27,
         Su_33,
         MiG_21Bis,
@@ -143,18 +146,21 @@ UNIT_BY_TASK = {
         MiG_29S,
         FA_18C_hornet,
         F_15C,
+        F_14B,
         M_2000C,
     ],
     CAS: [
         MiG_15bis,
         L_39ZA,
         AV8BNA,
+        AJS37,
         A_10A,
         A_10C,
         Su_25,
         Su_25T,
         Su_34,
         Ka_50,
+        SA342M,
     ],
 
     Transport: [
@@ -163,46 +169,65 @@ UNIT_BY_TASK = {
         An_30M,
         Yak_40,
 
-        S_3B_Tanker,
         C_130,
     ],
 
+    Refueling: [
+        IL_78M,
+        KC_135,
+        S_3B_Tanker,
+    ],
+
     AWACS: [E_3A, A_50, ],
 
-    PinpointStrike: [Armor.MBT_T_90, Armor.MBT_T_80U, Armor.MBT_T_55, Armor.MBT_M1A2_Abrams, Armor.MBT_M60A3_Patton, Armor.ATGM_M1134_Stryker, Armor.APC_BTR_80, ],
+    PinpointStrike: [
+        Armor.APC_BTR_80,
+        Armor.APC_BTR_80,
+        Armor.APC_BTR_80,
+        Armor.MBT_T_55,
+        Armor.MBT_T_55,
+        Armor.MBT_T_55,
+        Armor.MBT_T_80U,
+        Armor.MBT_T_80U,
+        Armor.MBT_T_90,
+
+        Armor.ATGM_M1134_Stryker,
+        Armor.ATGM_M1134_Stryker,
+        Armor.MBT_M60A3_Patton,
+        Armor.MBT_M60A3_Patton,
+        Armor.MBT_M60A3_Patton,
+        Armor.MBT_M1A2_Abrams,
+    ],
     AirDefence: [
         # those are listed multiple times here to balance prioritization more into lower tier AAs
         AirDefence.AAA_Vulcan_M163,
         AirDefence.AAA_Vulcan_M163,
-        AirDefence.SAM_Avenger_M1097,
-        AirDefence.SAM_Avenger_M1097,
-        AirDefence.SAM_Avenger_M1097,
-        AirDefence.SAM_Patriot_ICC,
+        AirDefence.AAA_Vulcan_M163,
+        AirDefence.SAM_Linebacker_M6,
 
-        AirDefence.AAA_ZU_23_on_Ural_375,
-        AirDefence.AAA_ZU_23_on_Ural_375,
-        AirDefence.AAA_ZU_23_on_Ural_375,
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.SAM_SA_9_Strela_1_9P31,
+        AirDefence.SAM_SA_9_Strela_1_9P31,
         AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_19_Tunguska_2S6,
     ],
 
     Reconnaissance: [Unarmed.Transport_M818, Unarmed.Transport_Ural_375, Unarmed.Transport_UAZ_469],
     Nothing: [Infantry.Infantry_M4, Infantry.Soldier_AK, ],
     Embarking: [UH_1H, Mi_8MT, ],
 
-    Carriage: [CVN_74_John_C__Stennis, CV_1143_5_Admiral_Kuznetsov, ],
-    CargoTransportation: [Dry_cargo_ship_Ivanov, Bulk_cargo_ship_Yakushev, Tanker_Elnya_160, LHA_1_Tarawa],
+    Carriage: [CVN_74_John_C__Stennis, LHA_1_Tarawa, CV_1143_5_Admiral_Kuznetsov, ],
+    CargoTransportation: [Dry_cargo_ship_Ivanov, Bulk_cargo_ship_Yakushev, Tanker_Elnya_160, Armed_speedboat, ],
 }
 
 """
 Units from AirDefense category of UNIT_BY_TASK that will be removed from use if "No SAM" option is checked at the start of the game
 """
 SAM_BAN = [
-    AirDefence.SAM_Avenger_M1097,
-    AirDefence.SAM_Patriot_ICC,
+    AirDefence.SAM_Linebacker_M6,
 
-    AirDefence.SAM_SA_19_Tunguska_2S6,
+    AirDefence.SAM_SA_9_Strela_1_9P31,
     AirDefence.SAM_SA_8_Osa_9A33,
 ]
 
@@ -210,7 +235,6 @@ SAM_BAN = [
 Units that will always be spawned in the air
 """
 TAKEOFF_BAN = [
-    AV8BNA,  # AI takeoff currently bugged attempting VTOL with no regards for the total weight
 ]
 
 """
@@ -224,8 +248,8 @@ CARRIER_TAKEOFF_BAN = [
 AirDefense units that will be spawned at control points not related to the current operation
 """
 EXTRA_AA = {
-    "Russia": AirDefence.SAM_SA_9_Strela_1_9P31,
-    "USA": AirDefence.SAM_Patriot_EPP_III,
+    "Russia": AirDefence.SAM_SA_19_Tunguska_2S6,
+    "USA": AirDefence.SAM_Linebacker_M6,
 }
 
 """
@@ -234,8 +258,8 @@ Be advised that putting unit to the country that have not access to the unit in
 """
 UNIT_BY_COUNTRY = {
     "Russia": [
-        C_101CC,
         AJS37,
+        MiG_23MLD,
         F_5E_3,
         Su_25,
         Su_27,
@@ -251,19 +275,20 @@ UNIT_BY_COUNTRY = {
         L_39ZA,
 
         IL_76MD,
+        IL_78M,
         An_26B,
         An_30M,
         Yak_40,
         A_50,
 
         Ka_50,
+        SA342M,
         UH_1H,
         Mi_8MT,
 
-        AirDefence.AAA_ZU_23_on_Ural_375,
-        AirDefence.SAM_SA_18_Igla_S_MANPADS,
+        AirDefence.SPAAA_ZSU_23_4_Shilka,
+        AirDefence.SAM_SA_9_Strela_1_9P31,
         AirDefence.SAM_SA_8_Osa_9A33,
-        AirDefence.SAM_SA_19_Tunguska_2S6,
 
         Armor.APC_BTR_80,
         Armor.MBT_T_90,
@@ -279,7 +304,9 @@ UNIT_BY_COUNTRY = {
     ],
 
     "USA": [
+        F_5E_3,
         F_15C,
+        F_14B,
         FA_18C_hornet,
         AJS37,
         M_2000C,
@@ -290,11 +317,13 @@ UNIT_BY_COUNTRY = {
         A_10C,
         AV8BNA,
 
+        KC_135,
         S_3B_Tanker,
         C_130,
         E_3A,
 
         Ka_50,
+        SA342M,
         UH_1H,
         Mi_8MT,
 
@@ -305,14 +334,24 @@ UNIT_BY_COUNTRY = {
         Infantry.Infantry_M4,
 
         AirDefence.AAA_Vulcan_M163,
-        AirDefence.SAM_Avenger_M1097,
-        AirDefence.SAM_Patriot_ICC,
+        AirDefence.SAM_Linebacker_M6,
 
         CVN_74_John_C__Stennis,
         LHA_1_Tarawa,
+        Armed_speedboat,
     ],
 }
 
+CARRIER_TYPE_BY_PLANE = {
+    FA_18C_hornet: CVN_74_John_C__Stennis,
+    F_14B: CVN_74_John_C__Stennis,
+    Ka_50: LHA_1_Tarawa,
+    SA342M: LHA_1_Tarawa,
+    UH_1H: LHA_1_Tarawa,
+    Mi_8MT: LHA_1_Tarawa,
+    AV8BNA: LHA_1_Tarawa,
+}
+
 """
 Aircraft payload overrides. Usually default loadout for the task is loaded during the mission generation.
 Syntax goes as follows:
@@ -331,11 +370,30 @@ Payload will be used for operation of following type, "*" category will be used
 """
 PLANE_PAYLOAD_OVERRIDES = {
     FA_18C_hornet: {
-        "*": "AIM-9M*6, AIM-7M*2, FUEL*3",
+        CAP: "AIM-120*4,AIM-9*2,AIM-7*2,Fuel",
+        Escort: "AIM-120*4,AIM-9*2,AIM-7*2,Fuel",
+        PinpointStrike: "MK-82*8,AIM-9*2,AIM-7,FLIR Pod,Fuel",
+        AntishipStrike: "MK-82*8,AIM-9*2,AIM-7,FLIR Pod,Fuel",
+    },
+
+    F_14B: {
+        CAP: "AIM-54A-MK47*4, AIM-7M*2, AIM-9M*2, XT*2",
+        Escort: "AIM-54A-MK47*4, AIM-7M*2, AIM-9M*2, XT*2",
+        CAS: "AIM-54A-MK60*1, AIM-7M*1, AIM-9M*2, XT*2, Mk-82*2, LANTIRN",
+        GroundAttack: "AIM54, AIM-9M*2, XT*2, GBU-12*4, LANTIRN",
+    },
+
+    Su_25T: {
+        CAS: "APU-8 Vikhr-M*2,Kh-25ML,R-73*2,SPPU-22*2,Mercury LLTV Pod,MPS-410",
     },
 
     Su_33: {
-        "*": "R-73*4,R-27R*2,R-27ER*6",
+        CAP: "R-73*4,R-27R*2,R-27ER*6",
+        Escort: "R-73*4,R-27R*2,R-27ER*6",
+    },
+
+    AJS37: {
+        CAS: "CAS (75 GUN): RB-75*2, AKAN",
     },
 
     AV8BNA: {
@@ -344,18 +402,22 @@ PLANE_PAYLOAD_OVERRIDES = {
 
     A_10C: {
         CAS: "AGM-65D*2,AGM-65H*2,GBU-12*2,GBU-38*2,AIM-9*2,TGP,ECM,MK151*7",
+        GroundAttack: "AGM-65K*2,GBU-12*8,AIM-9M*2.ECM,TGP",
     },
 
     Ka_50: {
-      "*": "12x9A4172, 40xS-8",
+        CAS: "12x9A4172, 40xS-8",
+        GroundAttack: "12x9A4172, 40xS-8",
     },
 
     M_2000C: {
-        "*": "Combat Air Patrol",
+        CAP: "Combat Air Patrol",
+        Escort: "Combat Air Patrol",
+        GroundAttack: "MK-82S Heavy Strike",
     },
 
     MiG_21Bis: {
-        "*": "Patrol, medium range",
+        CAP: "Patrol, medium range",
     }
 }
 
@@ -381,7 +443,11 @@ HeliDict = typing.Dict[HelicopterType, int]
 ArmorDict = typing.Dict[VehicleType, int]
 ShipDict = typing.Dict[ShipType, int]
 AirDefenseDict = typing.Dict[AirDefence, int]
-StartingPosition = typing.Optional[typing.Union[ShipGroup, Airport, Point]]
+
+AssignedUnitsDict = typing.Dict[typing.Type[UnitType], typing.Tuple[int, int]]
+TaskForceDict = typing.Dict[typing.Type[Task], AssignedUnitsDict]
+
+StartingPosition = typing.Optional[typing.Union[ShipGroup, StaticGroup, Airport, Point]]
 
 
 def unit_task(unit: UnitType) -> Task:
@@ -411,6 +477,15 @@ def unit_type_from_name(name: str) -> UnitType:
         return None
 
 
+def unit_type_of(unit: Unit) -> UnitType:
+    if isinstance(unit, Vehicle):
+        return vehicle_map[unit.type]
+    elif isinstance(unit, Ship):
+        return ship_map[unit.type]
+    else:
+        return unit.unit_type
+
+
 def task_name(task) -> str:
     if task == AirDefence:
         return "AirDefence"
@@ -422,6 +497,7 @@ def task_name(task) -> str:
 
 def choose_units(for_task: Task, factor: float, count: int, country: str) -> typing.Collection[UnitType]:
     suitable_unittypes = find_unittype(for_task, country)
+    suitable_unittypes = [x for x in suitable_unittypes if x not in helicopter_map.values()]
     suitable_unittypes.sort(key=lambda x: PRICES[x])
 
     idx = int(len(suitable_unittypes) * factor)
@@ -432,6 +508,75 @@ def choose_units(for_task: Task, factor: float, count: int, country: str) -> typ
     return list(set(suitable_unittypes[index_start:index_end]))
 
 
+def unitdict_append(unit_dict: UnitsDict, unit_type: UnitType, count: int):
+    unit_dict[unit_type] = unit_dict.get(unit_type, 0) + 1
+
+
+def unitdict_merge(a: UnitsDict, b: UnitsDict) -> UnitsDict:
+    b = b.copy()
+    for k, v in a.items():
+        b[k] = b.get(k, 0) + v
+
+    return b
+
+
+def unitdict_split(unit_dict: UnitsDict, count: int):
+    buffer_dict = {}
+    for unit_type, unit_count in unit_dict.items():
+        for _ in range(unit_count):
+            unitdict_append(buffer_dict, unit_type, 1)
+            if sum(buffer_dict.values()) >= count:
+                yield buffer_dict
+                buffer_dict = {}
+
+    if len(buffer_dict):
+        yield buffer_dict
+
+
+def unitdict_restrict_count(unit_dict: UnitsDict, total_count: int) -> UnitsDict:
+    if total_count == 0:
+        return {}
+
+    groups = list(unitdict_split(unit_dict, total_count))
+    if len(groups) > 0:
+        return groups[0]
+    else:
+        return {}
+
+
+def assigned_units_split(fd: AssignedUnitsDict) -> typing.Tuple[PlaneDict, PlaneDict]:
+    return {k: v1 for k, (v1, v2) in fd.items()}, {k: v2 for k, (v1, v2) in fd.items()},
+
+
+def assigned_units_from(d: PlaneDict) -> AssignedUnitsDict:
+    return {k: (v, 0) for k, v in d.items()}
+
+
+def assignedunits_split_to_count(dict: AssignedUnitsDict, count: int):
+    buffer_dict = {}
+    for unit_type, (unit_count, client_count) in dict.items():
+        for _ in range(unit_count):
+            new_count, new_client_count = buffer_dict.get(unit_type, (0, 0))
+
+            new_count += 1
+
+            if client_count > 0:
+                new_client_count += 1
+                client_count -= 1
+
+            buffer_dict[unit_type] = new_count, new_client_count
+            if new_count >= count:
+                yield buffer_dict
+                buffer_dict = {}
+
+    if len(buffer_dict):
+        yield buffer_dict
+
+
+def unitdict_from(fd: AssignedUnitsDict) -> Dict:
+    return {k: v1 for k, (v1, v2) in fd.items()}
+
+
 def _validate_db():
     # check unit by task uniquity
     total_set = set()

game/event/__init__.py

@@ -1,8 +1,10 @@
 from .event import *
-from .groundintercept import *
+from .frontlineattack import *
+from .frontlinepatrol import *
 from .intercept import *
-from .capture import *
+from .baseattack import *
 from .navalintercept import *
-from .antiaastrike import *
-from .groundattack import *
+from .insurgentattack import *
+from .convoystrike import *
 from .infantrytransport import *
+from .strike 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/baseattack.py

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

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

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

game/event/event.py

@@ -1,31 +1,49 @@
+import typing
+import logging
+
+from dcs.unittype import UnitType
+from dcs.task import *
+from dcs.vehicles import AirDefence
 from dcs.unittype import UnitType
 
 from game import *
 from theater import *
 from gen.environmentgen import EnvironmentSettings
+from gen.conflictgen import Conflict
+from game.db import assigned_units_from, unitdict_from
 
 from userdata.debriefing import Debriefing
 from userdata import persistency
 
 DIFFICULTY_LOG_BASE = 1.1
+EVENT_DEPARTURE_MAX_DISTANCE = 340000
 
 
 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:
@@ -36,24 +54,68 @@ class Event:
         if self.attacker_name == self.game.player:
             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):
@@ -62,17 +124,31 @@ class Event:
 
         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"))
+        self.operation.current_mission.save(persistency.mission_path_for("liberation_nextturn_quick.miz"))
 
     def commit(self, debriefing: Debriefing):
         for country, losses in debriefing.destroyed_units.items():
             if country == self.attacker_name:
-                cp = self.from_cp
+                cp = self.departure_cp
             else:
                 cp = self.to_cp
 
+            logging.info("base {} commit losses {}".format(cp.base, losses))
             cp.base.commit_losses(losses)
 
+        for object_identifier in debriefing.destroyed_objects:
+            for cp in self.game.theater.controlpoints:
+                if not cp.ground_objects:
+                    continue
+
+                for i, ground_object in enumerate(cp.ground_objects):
+                    if ground_object.is_dead:
+                        continue
+
+                    if ground_object.matches_string_identifier(object_identifier):
+                        logging.info("cp {} killing ground object {}".format(cp, ground_object.string_identifier))
+                        cp.ground_objects[i].is_dead = True
+
     def skip(self):
         pass
 
@@ -82,11 +158,12 @@ class UnitsDeliveryEvent(Event):
     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 = {}
 

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):
+        alive_attackers = sum([v for k, v in debriefing.alive_units.get(self.attacker_name, {}).items() if db.unit_task(k) == PinpointStrike])
+        alive_defenders = sum([v for k, v in debriefing.alive_units.get(self.defender_name, {}).items() if db.unit_task(k) == PinpointStrike])
+        attackers_success = (float(alive_attackers) / (alive_defenders + 0.01)) > self.SUCCESS_FACTOR
+        if self.from_cp.captured:
+            return attackers_success
+        else:
+            return not attackers_success
+
+    def commit(self, debriefing: Debriefing):
+        super(FrontlineAttackEvent, self).commit(debriefing)
+
+        if self.from_cp.captured:
+            if self.is_successfull(debriefing):
+                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
+            else:
+                self.to_cp.base.affect_strength(+self.STRENGTH_INFLUENCE)
+        else:
+            if self.is_successfull(debriefing):
+                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
+            else:
+                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
+
+    def skip(self):
+        if self.to_cp.captured:
+            self.to_cp.base.affect_strength(-0.1)
+
+    def player_attacking(self, flights: db.TaskForceDict):
+        assert CAS in flights and CAP in flights and len(flights) == 2, "Invalid flights"
+
+        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/frontlinepatrol.py

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

game/event/groundattack.py

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

game/event/groundintercept.py

@@ -1,106 +0,0 @@
-import math
-import random
-
-from dcs.task import *
-from dcs.vehicles import AirDefence
-
-from game import *
-from game.event import *
-from game.operation.groundintercept import GroundInterceptOperation
-from userdata.debriefing import Debriefing
-
-
-class GroundInterceptEvent(Event):
-    TARGET_AMOUNT_FACTOR = 2
-    TARGET_VARIETY = 2
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_TARGETS_HIT_PERCENTAGE = 0.5
-
-    targets = None  # type: db.ArmorDict
-
-    @property
-    def threat_description(self):
-        if not self.game.is_player_attack(self):
-            return "{} aicraft".format(self.from_cp.base.scramble_count(self.game.settings.multiplier, CAS))
-        else:
-            return super(GroundInterceptEvent, self).threat_description
-
-    def __str__(self):
-        return "Frontline 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

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

game/event/insurgentattack.py

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

game/event/intercept.py

@@ -1,15 +1,6 @@
-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
+from .event import *
 
 
 class InterceptEvent(Event):
@@ -19,15 +10,39 @@ class InterceptEvent(Event):
 
     transport_unit = None  # type: FlyingType
 
+    def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str,
+                 defender_name: str):
+        super().__init__(game, from_cp, target_cp, location, attacker_name, defender_name)
+        self.location = Conflict.intercept_position(self.from_cp, self.to_cp)
+
     def __str__(self):
-        return "Intercept from {} at {}".format(self.from_cp, self.to_cp)
+        return "Air Intercept"
+
+    @property
+    def tasks(self):
+        return [CAP]
+
+    def flight_name(self, for_task: typing.Type[Task]) -> str:
+        if for_task == CAP:
+            if self.is_player_attacking:
+                return "Intercept flight"
+            else:
+                return "Escort flight"
+
+    def _enemy_scramble_multiplier(self) -> float:
+        is_global = self.departure_cp.is_global or self.to_cp.is_global
+        return self.game.settings.multiplier * is_global and 0.5 or 1
 
     @property
     def threat_description(self):
-        return "{} aircraft".format(self.enemy_cp.base.scramble_count(self.game.settings.multiplier, CAP))
+        return "{} aircraft".format(self.enemy_cp.base.scramble_count(self._enemy_scramble_multiplier(), CAP))
+
+    @property
+    def global_cp_available(self) -> bool:
+        return True
 
     def is_successfull(self, debriefing: Debriefing):
-        units_destroyed = debriefing.destroyed_units[self.defender_name].get(self.transport_unit, 0)
+        units_destroyed = debriefing.destroyed_units.get(self.defender_name, {}).get(self.transport_unit, 0)
         if self.from_cp.captured:
             return units_destroyed > 0
         else:
@@ -53,8 +68,10 @@ class InterceptEvent(Event):
         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)
+    def player_attacking(self, flights: db.TaskForceDict):
+        assert CAP in flights and len(flights) == 1, "Invalid flights"
+
+        escort = self.to_cp.base.scramble_sweep(self._enemy_scramble_multiplier())
 
         self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
         assert self.transport_unit is not None
@@ -63,20 +80,21 @@ class InterceptEvent(Event):
         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,
+                                departure_cp=self.departure_cp,
                                 to_cp=self.to_cp)
 
-        op.setup(escort=escort,
+        op.setup(location=self.location,
+                 escort=assigned_units_from(escort),
                  transport={self.transport_unit: 1},
                  airdefense={airdefense_unit: self.AIRDEFENSE_COUNT},
-                 interceptors=interceptors)
+                 interceptors=flights[CAP])
 
         self.operation = op
 
-    def player_defending(self, escort: db.PlaneDict, clients: db.PlaneDict):
-        # TODO: even not quick mission is too quick
+    def player_defending(self, flights: db.TaskForceDict):
+        assert CAP in flights and len(flights) == 1, "Invalid flights"
+
         interceptors = self.from_cp.base.scramble_interceptors(self.game.settings.multiplier)
 
         self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
@@ -85,14 +103,14 @@ class InterceptEvent(Event):
         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,
+                                departure_cp=self.departure_cp,
                                 to_cp=self.to_cp)
 
-        op.setup(escort=escort,
+        op.setup(location=self.location,
+                 escort=flights[CAP],
                  transport={self.transport_unit: 1},
-                 interceptors=interceptors,
+                 interceptors=assigned_units_from(interceptors),
                  airdefense={})
 
         self.operation = op

game/event/navalintercept.py

@@ -1,15 +1,6 @@
-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
+from .event import *
 
 
 class NavalInterceptEvent(Event):
@@ -18,29 +9,51 @@ class NavalInterceptEvent(Event):
 
     targets = None  # type: db.ShipDict
 
+    def __init__(self, game, from_cp: ControlPoint, target_cp: ControlPoint, location: Point, attacker_name: str,
+                 defender_name: str):
+        super().__init__(game, from_cp, target_cp, location, attacker_name, defender_name)
+        self.location = Conflict.naval_intercept_position(from_cp, target_cp, game.theater)
+
     def _targets_count(self) -> int:
-        from gen.conflictgen import IMPORTANCE_LOW, IMPORTANCE_HIGH
-        factor = (self.to_cp.importance - IMPORTANCE_LOW) * 10
+        from gen.conflictgen import IMPORTANCE_LOW
+        factor = (self.to_cp.importance - IMPORTANCE_LOW + 0.1) * 20
         return max(int(factor), 1)
 
     def __str__(self) -> str:
-        return "Naval intercept at {}".format(self.to_cp)
+        return "Naval intercept"
+
+    @property
+    def tasks(self):
+        if self.is_player_attacking:
+            return [CAS]
+        else:
+            return [CAP]
+
+    def flight_name(self, for_task: typing.Type[Task]) -> str:
+        if for_task == CAS:
+            return "Naval intercept flight"
+        elif for_task == CAP:
+            return "CAP flight"
 
     @property
     def threat_description(self):
         s = "{} ship(s)".format(self._targets_count())
-        if not self.from_cp.captured:
-            s += ", {} aircraft".format(self.from_cp.base.scramble_count(self.game.settings.multiplier))
+        if not self.departure_cp.captured:
+            s += ", {} aircraft".format(self.departure_cp.base.scramble_count(self.game.settings.multiplier))
         return s
 
+    @property
+    def global_cp_available(self) -> bool:
+        return True
+
     def is_successfull(self, debriefing: Debriefing):
         total_targets = sum(self.targets.values())
         destroyed_targets = 0
-        for unit, count in debriefing.destroyed_units[self.defender_name].items():
+        for unit, count in debriefing.destroyed_units.get(self.defender_name, {}).items():
             if unit in self.targets:
                 destroyed_targets += count
 
-        if self.from_cp.captured:
+        if self.departure_cp.captured:
             return math.ceil(float(destroyed_targets) / total_targets) > self.SUCCESS_RATE
         else:
             return math.ceil(float(destroyed_targets) / total_targets) < self.SUCCESS_RATE
@@ -52,11 +65,11 @@ class NavalInterceptEvent(Event):
             if self.is_successfull(debriefing):
                 self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
             else:
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
+                self.departure_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
         else:
             # enemy attacking
             if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
+                self.departure_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
             else:
                 self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
 
@@ -64,7 +77,9 @@ class NavalInterceptEvent(Event):
         if self.to_cp.captured:
             self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
 
-    def player_attacking(self, strikegroup: db.PlaneDict, clients: db.PlaneDict):
+    def player_attacking(self, flights: db.TaskForceDict):
+        assert CAS in flights and len(flights) == 1, "Invalid flights"
+
         self.targets = {
             random.choice(db.find_unittype(CargoTransportation, self.defender_name)): self._targets_count(),
         }
@@ -73,19 +88,21 @@ class NavalInterceptEvent(Event):
             self.game,
             attacker_name=self.attacker_name,
             defender_name=self.defender_name,
-            attacker_clients=clients,
-            defender_clients={},
             from_cp=self.from_cp,
+            departure_cp=self.departure_cp,
             to_cp=self.to_cp
         )
 
-        op.setup(strikegroup=strikegroup,
+        op.setup(location=self.location,
+                 strikegroup=flights[CAS],
                  interceptors={},
                  targets=self.targets)
 
         self.operation = op
 
-    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
+    def player_defending(self, flights: db.TaskForceDict):
+        assert CAP in flights and len(flights) == 1, "Invalid flights"
+
         self.targets = {
             random.choice(db.find_unittype(CargoTransportation, self.defender_name)): self._targets_count(),
         }
@@ -94,15 +111,14 @@ class NavalInterceptEvent(Event):
             self.game,
             attacker_name=self.attacker_name,
             defender_name=self.defender_name,
-            attacker_clients={},
-            defender_clients=clients,
             from_cp=self.from_cp,
+            departure_cp=self.departure_cp,
             to_cp=self.to_cp
         )
 
-        strikegroup = self.from_cp.base.scramble_cas(self.game.settings.multiplier)
-        op.setup(strikegroup=strikegroup,
-                 interceptors=interceptors,
+        strikegroup = self.departure_cp.base.scramble_cas(self.game.settings.multiplier)
+        op.setup(strikegroup=assigned_units_from(strikegroup),
+                 interceptors=flights[CAP],
                  targets=self.targets)
 
         self.operation = op

game/event/strike.py

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

game/game.py

@@ -1,3 +1,4 @@
+import logging
 import typing
 import random
 import math
@@ -5,6 +6,7 @@ import math
 from dcs.task import *
 from dcs.vehicles import *
 
+from gen.conflictgen import Conflict
 from userdata.debriefing import Debriefing
 from theater import *
 
@@ -23,36 +25,47 @@ COMMISION_LIMITS_FACTORS = {
 
 COMMISION_AMOUNTS_SCALE = 1.5
 COMMISION_AMOUNTS_FACTORS = {
-    PinpointStrike: 2,
+    PinpointStrike: 3,
     CAS: 1,
     CAP: 2,
     AirDefence: 0.3,
 }
 
-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
+* BaseAttackEvent - capture base
 * InterceptEvent - air intercept
-* GroundInterceptEvent - frontline CAS
-* GroundAttackEvent - destroy insurgents
+* FrontlineAttackEvent - frontline attack
 * NavalInterceptEvent - naval intercept
-* AntiAAStrikeEvent - anti-AA strike
+* StrikeEvent - strike event
 * InfantryTransportEvent - helicopter infantry transport
 """
 EVENT_PROBABILITIES = {
-    CaptureEvent: [100, 10],
-    InterceptEvent: [25, 10],
-    GroundInterceptEvent: [25, 10],
-    GroundAttackEvent: [0, 10],
-    NavalInterceptEvent: [25, 10],
-    AntiAAStrikeEvent: [25, 10],
-    InfantryTransportEvent: [25, 0],
+    # events always present; only for the player
+    FrontlineAttackEvent: [100, 9],
+    #FrontlinePatrolEvent: [100, 0],
+    StrikeEvent: [100, 0],
+
+    # events randomly present; only for the player
+    #InfantryTransportEvent: [25, 0],
+    ConvoyStrikeEvent: [25, 0],
+
+    # events conditionally present; for both enemy and player
+    BaseAttackEvent: [100, 9],
+
+    # events randomly present; for both enemy and player
+    InterceptEvent: [25, 9],
+    NavalInterceptEvent: [25, 9],
+
+    # events randomly present; only for the enemy
+    InsurgentAttackEvent: [0, 6],
 }
 
 # amount of strength player bases recover for the turn
@@ -65,9 +78,9 @@ ENEMY_BASE_STRENGTH_RECOVERY = 0.05
 AWACS_BUDGET_COST = 4
 
 # Initial budget value
-PLAYER_BUDGET_INITIAL = 120
+PLAYER_BUDGET_INITIAL = 170
 # Base post-turn bonus value
-PLAYER_BUDGET_BASE = 10
+PLAYER_BUDGET_BASE = 14
 # Bonus multiplier logarithm base
 PLAYER_BUDGET_IMPORTANCE_LOG = 2
 
@@ -87,61 +100,95 @@ class Game:
         self.enemy = 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):
+        if event_class == NavalInterceptEvent and enemy_cp.radials == LAND:
+            # skip naval events for non-coastal CPs
+            return
+
+        if event_class == BaseAttackEvent and enemy_cp.base.strength > PLAYER_BASEATTACK_THRESHOLD and self.settings.version != "dev":
+            # skip base attack events for CPs yet too strong
+            return
+
+        if event_class == StrikeEvent and not enemy_cp.ground_objects:
+            # skip strikes in case of no targets
+            return
+
+        self.events.append(event_class(self, player_cp, enemy_cp, enemy_cp.position, self.player, self.enemy))
+
+    def _generate_enemy_event(self, event_class, player_cp, enemy_cp):
+        if event_class in [type(x) for x in self.events if not self.is_player_attack(x)]:
+            # skip already generated enemy event types
+            return
+
+        if player_cp in self.ignored_cps:
+            # skip attacks against ignored CPs (for example just captured ones)
+            return
+
+        if enemy_cp.base.total_planes == 0:
+            # skip event if there's no planes on the base
+            return
+
+        if player_cp.is_global:
+            # skip carriers
+            return
+
+        if event_class == NavalInterceptEvent:
+            if player_cp.radials == LAND:
+                # skip naval events for non-coastal CPs
+                return
+        elif event_class == StrikeEvent:
+            if not player_cp.ground_objects:
+                # skip strikes if there's no ground objects
+                return
+        elif event_class == BaseAttackEvent:
+            if BaseAttackEvent in [type(x) for x in self.events]:
+                # skip base attack event if there's another one going on
+                return
+
+            if enemy_cp.base.total_armor == 0:
+                # skip base attack if there's no armor
+                return
+
+            if player_cp.base.strength > PLAYER_BASEATTACK_THRESHOLD:
+                # skip base attack if strength is too high
+                return
+
+        self.events.append(event_class(self, enemy_cp, player_cp, player_cp.position, self.enemy, self.player))
 
     def _generate_events(self):
-        enemy_cap_generated = False
-        enemy_generated_types = []
+        strikes_generated_for = set()
+        base_attack_generated_for = set()
 
         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 and enemy_cp.radials == LAND:
-                        pass
-                    else:
-                        self.events.append(event_class(self.player, self.enemy, player_cp, enemy_cp, self))
-                elif self._roll(enemy_probability, enemy_cp.base.strength):
-                    if event_class in enemy_generated_types:
+                if event_class in [FrontlineAttackEvent, FrontlinePatrolEvent, InfantryTransportEvent, ConvoyStrikeEvent]:
+                    # skip events requiring frontline
+                    if not Conflict.has_frontline_between(player_cp, enemy_cp):
                         continue
 
-                    if player_cp in self.ignored_cps:
+                # don't generate multiple 100% events from each attack direction
+                if event_class is StrikeEvent:
+                    if enemy_cp in strikes_generated_for:
+                        continue
+                if event_class is BaseAttackEvent:
+                    if enemy_cp in base_attack_generated_for:
                         continue
 
-                    if enemy_cp.base.total_planes == 0:
-                        continue
+                if player_probability == 100 or player_probability > 0 and self._roll(player_probability, player_cp.base.strength):
+                    self._generate_player_event(event_class, player_cp, enemy_cp)
+                    if event_class is StrikeEvent:
+                        strikes_generated_for.add(enemy_cp)
+                    if event_class is BaseAttackEvent:
+                        base_attack_generated_for.add(enemy_cp)
 
-                    if 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))
+                if enemy_probability == 100 or  enemy_probability > 0 and self._roll(enemy_probability, enemy_cp.base.strength):
+                    self._generate_enemy_event(event_class, player_cp, enemy_cp)
 
     def commision_unit_types(self, cp: ControlPoint, for_task: Task) -> typing.Collection[UnitType]:
         importance_factor = (cp.importance - IMPORTANCE_LOW) / (IMPORTANCE_HIGH - IMPORTANCE_LOW)
@@ -161,7 +208,7 @@ class Game:
                 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))
+                    logging.info("Commision {}: {}".format(cp, d))
                     cp.base.commision_units(d)
 
     @property
@@ -194,10 +241,13 @@ class Game:
     def initiate_event(self, event: Event):
         assert event in self.events
 
+        logging.info("Generating {} (regular)".format(event))
         event.generate()
+        logging.info("Generating {} (quick)".format(event))
         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()
@@ -205,14 +255,23 @@ 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
+        else:
+            return event.name == self.player
 
     def pass_turn(self, no_action=False, ignored_cps: typing.Collection[ControlPoint]=None):
+        logging.info("Pass turn")
         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()
@@ -229,5 +288,5 @@ class Game:
 
         self.events = []  # type: typing.List[Event]
         self._generate_events()
-        self._generate_globalinterceptions()
+        #self._generate_globalinterceptions()
 

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

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

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

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

game/operation/frontlineattack.py

@@ -0,0 +1,75 @@
+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:
+            self.attackers_starting_position = None
+            self.defenders_starting_position = None
+
+        conflict = Conflict.frontline_cas_conflict(
+            attacker=self.current_mission.country(self.attacker_name),
+            defender=self.current_mission.country(self.defender_name),
+            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/frontlinepatrol.py

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

game/operation/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,23 +1,13 @@
-from dcs.terrain import Terrain
+from game.db import assigned_units_split
 
-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
+from .operation import *
 
 
 class InfantryTransportOperation(Operation):
-    transport = None  # type: db.HeliDict
+    transport = None  # type: db.AssignedUnitsDict
     aa = None  # type: db.AirDefenseDict
 
-    def setup(self, transport: db.HeliDict, aa: db.AirDefenseDict):
+    def setup(self, transport: db.AssignedUnitsDict, aa: db.AirDefenseDict):
         self.transport = transport
         self.aa = aa
 
@@ -25,22 +15,18 @@ class InfantryTransportOperation(Operation):
         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),
+            attacker=self.current_mission.country(self.attacker_name),
+            defender=self.current_mission.country(self.defender_name),
             from_cp=self.from_cp,
             to_cp=self.to_cp,
             theater=self.game.theater
         )
 
-        self.initialize(mission=self.mission,
+        self.initialize(mission=self.current_mission,
                         conflict=conflict)
 
     def generate(self):
-        self.airgen.generate_passenger_transport(
-            helis=self.transport,
-            clients=self.attacker_clients,
-            at=self.attackers_starting_position
-        )
+        self.airgen.generate_passenger_transport(*assigned_units_split(self.transport), at=self.attackers_starting_position)
 
         self.armorgen.generate_passengers(count=6)
         self.aagen.generate_at_defenders_location(self.aa)
@@ -48,6 +34,10 @@ class InfantryTransportOperation(Operation):
         self.visualgen.generate_transportation_marker(self.conflict.ground_attackers_location)
         self.visualgen.generate_transportation_destination(self.conflict.position)
 
+        self.briefinggen.title = "Infantry transport"
+        self.briefinggen.description = "Helicopter operation to transport infantry troops from the base to the front line. Lowers target strength"
+        self.briefinggen.append_waypoint("DROP POINT")
+
         # TODO: horrible, horrible hack
         # this will disable vehicle activation triggers,
         # which aren't needed on this type of missions

game/operation/insurgentattack.py

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

game/operation/intercept.py

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

game/operation/navalintercept.py

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

game/operation/operation.py

@@ -1,16 +1,19 @@
-from dcs.terrain import Terrain
 from dcs.lua.parse import loads
 
 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
@@ -18,44 +21,58 @@ class Operation:
     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.defender_name = defender_name
-        self.attacker_clients = attacker_clients
-        self.defender_clients = defender_clients
         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
+    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.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.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_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
@@ -65,33 +82,84 @@ class Operation:
         with open("resources/default_options.lua", "r") as f:
             options_dict = loads(f.read())["options"]
 
-        self.mission = dcs.Mission(terrain)
-        self.mission.options.load_from_dict(options_dict)
+        self.current_mission = dcs.Mission(terrain)
+        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.from_cp.at
+            self.attackers_starting_position = self.departure_cp.at
             self.defenders_starting_position = self.to_cp.at
 
+    def prepare_carriers(self, for_units: db.UnitsDict):
+        if not self.departure_cp.is_global:
+            return
+
+        ship = self.shipgen.generate_carrier(for_units=[t for t, c in for_units.items() if c > 0],
+                                             country=self.game.player,
+                                             at=self.departure_cp.at)
+
+        if not self.is_quick:
+            if not self.to_cp.captured:
+                self.attackers_starting_position = ship
+            else:
+                self.defenders_starting_position = ship
+
     def generate(self):
-        self.visualgen.generate()
+        # air support
+        self.airsupportgen.generate(self.is_awacs_enabled)
+        for i, tanker_type in enumerate(self.airsupportgen.generated_tankers):
+            self.briefinggen.append_frequency("Tanker {} ({})".format(TANKER_CALLSIGNS[i], tanker_type), "{}X/{} MHz AM".format(97+i, 130+i))
 
         if self.is_awacs_enabled:
-            self.awacsgen.generate()
+            self.briefinggen.append_frequency("AWACS", "133 MHz AM")
 
+        # combined arms
+        self.current_mission.groundControl.pilot_can_control_vehicles = self.ca_slots > 0
+        if self.game.player in [country.name for country in self.current_mission.coalition["blue"].countries.values()]:
+            self.current_mission.groundControl.blue_tactical_commander = self.ca_slots
+        else:
+            self.current_mission.groundControl.red_tactical_commander = self.ca_slots
+
+        # ground infrastructure
+        self.groundobjectgen.generate()
         self.extra_aagen.generate()
-        self.triggersgen.generate(self.is_quick, self.trigger_radius)
 
+        # triggers
+        if self.game.is_player_attack(self.conflict.attackers_side):
+            cp = self.conflict.from_cp
+        else:
+            cp = self.conflict.to_cp
+
+        self.triggersgen.generate(player_cp=cp,
+                                  is_quick=self.is_quick,
+                                  activation_trigger_radius=self.trigger_radius,
+                                  awacs_enabled=self.is_awacs_enabled)
+
+        # env settings
         if self.environment_settings is None:
             self.environment_settings = self.envgen.generate()
         else:
             self.envgen.load(self.environment_settings)
 
-    def units_of(self, country_name: str) -> typing.Collection[UnitType]:
-        return []
+        # options
+        self.forcedoptionsgen.generate()
+
+        # main frequencies
+        self.briefinggen.append_frequency("Flight", "251 MHz AM")
+        if self.departure_cp.is_global or self.conflict.to_cp.is_global:
+            self.briefinggen.append_frequency("Carrier", "20X/ICLS CHAN1")
+
+        # briefing
+        self.briefinggen.generate()
+
+        # visuals
+        self.visualgen.generate()
 
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return True

game/operation/strike.py

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

game/settings.py

@@ -2,7 +2,13 @@
 class 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
     night_disabled = False
+
     multiplier = 1
     sams = True
+    cold_start = False
+    version = None

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,13 +1,11 @@
-from game import *
-
-from theater.conflicttheater import ConflictTheater
 from .conflictgen import *
 from .naming import *
 
 from dcs.mission import *
 
 DISTANCE_FACTOR = 0.5, 1
-EXTRA_AA_MIN_DISTANCE = 35000
+EXTRA_AA_MIN_DISTANCE = 50000
+EXTRA_AA_MAX_DISTANCE = 150000
 EXTRA_AA_POSITION_FROM_CP = 550
 
 
@@ -61,6 +59,12 @@ class ExtraAAConflictGenerator:
             if cp.position.distance_to_point(self.conflict.from_cp.position) < EXTRA_AA_MIN_DISTANCE:
                 continue
 
+            if cp.position.distance_to_point(self.conflict.to_cp.position) < EXTRA_AA_MIN_DISTANCE:
+                continue
+
+            if cp.position.distance_to_point(self.conflict.position) > EXTRA_AA_MAX_DISTANCE:
+                continue
+
             country_name = cp.captured and self.player_name or self.enemy_name
             position = cp.position.point_from_heading(0, EXTRA_AA_POSITION_FROM_CP)
 
@@ -69,6 +73,6 @@ class ExtraAAConflictGenerator:
                 name=namegen.next_basedefense_name(),
                 _type=db.EXTRA_AA[country_name],
                 position=position,
-                group_size=2
+                group_size=1
             )
 

gen/aircraft.py

@@ -1,3 +1,5 @@
+import logging
+
 from game import db
 from game.settings import Settings
 from .conflictgen import *
@@ -14,37 +16,45 @@ SPREAD_DISTANCE_FACTOR = 1, 2
 ESCORT_ENGAGEMENT_MAX_DIST = 100000
 WORKAROUND_WAYP_DIST = 1000
 
-WARM_START_HELI_AIRSPEED = 200
-WARM_START_HELI_ALT = 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
+BARCAP_RACETRACK_DISTANCE = 20000
 
-ATTACK_CIRCLE_ALT = 5000
+ATTACK_CIRCLE_ALT = 1000
 ATTACK_CIRCLE_DURATION = 15
 
-CAS_ALTITUDE = 1000
-RTB_ALTITUDE = 1000
-HELI_ALT = 900
+CAS_ALTITUDE = 800
+RTB_ALTITUDE = 800
+RTB_DISTANCE = 5000
+HELI_ALT = 500
 
-TRANSPORT_LANDING_ALT = 1000
+TRANSPORT_LANDING_ALT = 2000
 
 DEFENCE_ENGAGEMENT_MAX_DISTANCE = 60000
 INTERCEPT_MAX_DISTANCE = 200000
 
+GROUP_VERTICAL_OFFSET = 300
+
 
 class AircraftConflictGenerator:
-    escort_targets = [] # type: typing.List[typing.Tuple[PlaneGroup, int]]
+    escort_targets = [] # type: typing.List[typing.Tuple[FlyingGroup, int]]
+    vertical_offset = None  # type: int
 
     def __init__(self, mission: Mission, conflict: Conflict, settings: Settings):
         self.m = mission
         self.settings = settings
         self.conflict = conflict
+        self.vertical_offset = 0
         self.escort_targets = []
 
+    def _start_type(self) -> StartType:
+        return self.settings.cold_start and StartType.Cold or StartType.Warm
+
     def _group_point(self, point) -> Point:
         distance = randint(
                 int(self.conflict.size * SPREAD_DISTANCE_FACTOR[0]),
@@ -59,26 +69,36 @@ class AircraftConflictGenerator:
             else:
                 client_count = 0
 
+            if flying_type == F_14B:
+                # workaround since 2 and 3 tomcat collide on carrier
+                group_size = 2
+            else:
+                group_size = 4
+
             while count > 0:
-                group_size = min(count, 4)
-                client_size = max(min(client_count, 4), 0)
+                group_size = min(count, group_size)
+                client_size = max(min(client_count, group_size), 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:
                 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
@@ -99,17 +119,24 @@ class AircraftConflictGenerator:
 
         group.points[0].tasks.append(OptReactOnThreat(OptReactOnThreat.Values.EvadeFire))
 
+        if unit_type in helicopters.helicopter_map.values():
+            print(unit_type)
+            group.set_frequency(127.5)
+        else:
+            group.set_frequency(251.0)
+
     def _generate_at_airport(self, name: str, side: Country, unit_type: FlyingType, count: int, client_count: int, airport: Airport = None) -> FlyingGroup:
         assert count > 0
         assert unit is not None
 
+        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=self._start_type(),
             group_size=count,
             parking_slots=None)
 
@@ -117,16 +144,18 @@ class AircraftConflictGenerator:
         assert count > 0
         assert unit is not None
 
-        if unit_type in helicopters.helicopter_map:
-            alt = WARM_START_HELI_ALT + random.randint(50, 200)
+        self.vertical_offset += GROUP_VERTICAL_OFFSET
+        if unit_type in helicopters.helicopter_map.values():
+            alt = WARM_START_HELI_ALT + self.vertical_offset
             speed = WARM_START_HELI_AIRSPEED
         else:
-            alt = WARM_START_ALTITUDE + random.randint(50, 200)
+            alt = WARM_START_ALTITUDE + self.vertical_offset
             speed = WARM_START_AIRSPEED
 
-        pos = Point(at.x + random.randint(100, 200), at.y + random.randint(100, 200))
+        pos = Point(at.x + random.randint(100, 1000), at.y + random.randint(100, 1000))
 
-        return self.m.flight_group(
+        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,
@@ -135,29 +164,35 @@ class AircraftConflictGenerator:
             altitude=alt,
             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):
@@ -173,15 +208,26 @@ class AircraftConflictGenerator:
         else:
             assert False
 
-    def _rtb_for(self, group: FlyingGroup, cp: ControlPoint, at: db.StartingPosition = None):
-        group.add_waypoint(cp.position, RTB_ALTITUDE)
+    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
 
-        if isinstance(cp.at, Point):
-            pass
-        elif isinstance(cp.at, ShipGroup):
-            pass
-        elif issubclass(cp.at, Airport):
-            group.land_at(cp.at)
+    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):
@@ -205,10 +251,6 @@ class AircraftConflictGenerator:
                 at=at)
 
             group.task = Escort.name
-
-            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)
 
             for escorted_group, waypoint_index in self.escort_targets:
@@ -216,21 +258,21 @@ class AircraftConflictGenerator:
                 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))
+                group.points[0].tasks.append(EscortTaskAction(escorted_group.id, engagement_max_dist=ESCORT_ENGAGEMENT_MAX_DIST, lastwpt=waypoint_index))
 
             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 = self._add_radio_waypoint(group, 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
+    def generate_cas_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None, escort=True):
+        assert not escort or len(self.escort_targets) == 0
 
         for flying_type, count, client_count in self._split_to_groups(attackers, clients):
             group = self._generate_group(
@@ -241,14 +283,96 @@ class AircraftConflictGenerator:
                     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)
+            waypoint = self._add_radio_waypoint(group, self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
+            if self.conflict.is_vector:
+                self._add_radio_waypoint(group, self.conflict.tail, CAS_ALTITUDE, WARM_START_AIRSPEED)
+
             group.task = CAS.name
             self._setup_group(group, CAS, client_count)
-            self.escort_targets.append((group, group.points.index(waypoint)))
+            if escort:
+                self.escort_targets.append((group, group.points.index(waypoint)))
             self._rtb_for(group, 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
+    def generate_ground_attack_strikegroup(self, strikegroup: db.PlaneDict, clients: db.PlaneDict, targets: typing.List[typing.Tuple[str, Point]], at: db.StartingPosition = None, escort=True):
+        assert not escort or len(self.escort_targets) == 0
+
+        for flying_type, count, client_count in self._split_to_groups(strikegroup, clients):
+            group = self._generate_group(
+                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
+                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))
+
+            escort_until_waypoint = None
+
+            for name, pos in targets:
+                waypoint = group.add_waypoint(pos, 0, WARM_START_AIRSPEED, self.m.translation.create_string(name))
+                waypoint.tasks.append(Bombing(pos, attack_qty=2))
+                if escort_until_waypoint is None:
+                    escort_until_waypoint = waypoint
+
+            group.task = GroundAttack.name
+            self._setup_group(group, GroundAttack, client_count)
+            if escort:
+                self.escort_targets.append((group, group.points.index(escort_until_waypoint)))
+            self._rtb_for(group, self.conflict.from_cp, at)
+
+    def generate_sead_strikegroup(self, strikegroup: db.PlaneDict, clients: db.PlaneDict, targets: typing.List[typing.Tuple[str, Point]], at: db.StartingPosition, escort=True):
+        assert not escort or len(self.escort_targets) == 0
+
+        for flying_type, count, client_count in self._split_to_groups(strikegroup, clients):
+            group = self._generate_group(
+                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
+                side=self.conflict.attackers_side,
+                unit_type=flying_type,
+                count=count,
+                client_count=client_count,
+                at=at and at or self._group_point(self.conflict.air_attackers_location))
+
+            escort_until_waypoint = None
+
+            for name, pos in targets:
+                waypoint = group.add_waypoint(pos, 0, WARM_START_AIRSPEED, self.m.translation.create_string(name))
+                if escort_until_waypoint is None:
+                    escort_until_waypoint = waypoint
+
+            group.task = SEAD.name
+            self._setup_group(group, SEAD, client_count)
+            if escort:
+                self.escort_targets.append((group, group.points.index(escort_until_waypoint)))
+
+            self._rtb_for(group, self.conflict.from_cp, at)
+
+    def generate_defenders_cas(self, defenders: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None, escort=True):
+        assert not escort or len(self.escort_targets) == 0
+
+        for flying_type, count, client_count in self._split_to_groups(defenders, clients):
+            group = self._generate_group(
+                name=namegen.next_unit_name(self.conflict.defenders_side, flying_type),
+                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))
+
+            location = self._group_point(self.conflict.air_defenders_location)
+            insertion_point = self.conflict.find_insertion_point(location)
+            waypoint = self._add_radio_waypoint(group, insertion_point, CAS_ALTITUDE, WARM_START_AIRSPEED)
+
+            if self.conflict.is_vector:
+                destination_tail = self.conflict.tail.distance_to_point(insertion_point) > self.conflict.position.distance_to_point(insertion_point)
+                self._add_radio_waypoint(group, destination_tail and self.conflict.tail or self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
+
+            group.task = CAS.name
+            self._setup_group(group, CAS, client_count)
+            if escort:
+                self.escort_targets.append((group, group.points.index(waypoint)))
+            self._rtb_for(group, self.conflict.to_cp, at)
+
+    def generate_ship_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, target_groups: typing.Collection[ShipGroup], at: db.StartingPosition = None, escort=True):
+        assert not escort or len(self.escort_targets) == 0
 
         for flying_type, count, client_count in self._split_to_groups(attackers, clients):
             group = self._generate_group(
@@ -259,16 +383,17 @@ class AircraftConflictGenerator:
                 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)
+            wayp = self._add_radio_waypoint(group, self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
             for target_group in target_groups:
                 wayp.tasks.append(AttackGroup(target_group.id))
 
             group.task = AntishipStrike.name
             self._setup_group(group, AntishipStrike, client_count)
-            self.escort_targets.append((group, group.points.index(wayp)))
+            if escort:
+                self.escort_targets.append((group, group.points.index(wayp)))
             self._rtb_for(group, self.conflict.from_cp, at)
 
-    def generate_strikegroup_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
+    def generate_attackers_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for g in self._generate_escort(
                 side=self.conflict.attackers_side,
                 units=attackers,
@@ -278,7 +403,7 @@ class AircraftConflictGenerator:
                 should_orbit=True):
             self._rtb_for(g, self.conflict.from_cp, at)
 
-    def generate_transport_escort(self, escort: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
+    def generate_defenders_escort(self, escort: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
         for g in self._generate_escort(
                 side=self.conflict.defenders_side,
                 units=escort,
@@ -299,14 +424,56 @@ class AircraftConflictGenerator:
                 at=at and at or self._group_point(self.conflict.air_defenders_location))
 
             group.task = CAP.name
-            wayp = group.add_waypoint(self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
+            wayp = self._add_radio_waypoint(group, 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)
             self._rtb_for(group, self.conflict.to_cp, at)
 
-    def generate_transport(self, transport: db.PlaneDict, destination: Airport):
-        assert len(self.escort_targets) == 0
+    def generate_migcap(self, patrol: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
+        for flying_type, count, client_count in self._split_to_groups(patrol, clients):
+            group = self._generate_group(
+                name=namegen.next_unit_name(self.conflict.attackers_side, flying_type),
+                side=self.conflict.attackers_side,
+                unit_type=flying_type,
+                count=count,
+                client_count=client_count,
+                at=at and at or self._group_point(self.conflict.air_attackers_location))
+
+            waypoint = self._add_radio_waypoint(group, self.conflict.position, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+            if self.conflict.is_vector:
+                self._add_radio_waypoint(group, self.conflict.tail, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+
+            group.task = CAP.name
+            self._setup_group(group, CAP, client_count)
+            self._rtb_for(group, self.conflict.from_cp, at)
+
+    def generate_barcap(self, patrol: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
+        for flying_type, count, client_count in self._split_to_groups(patrol, clients):
+            group = self._generate_group(
+                name=namegen.next_unit_name(self.conflict.defenders_side, flying_type),
+                side=self.conflict.defenders_side,
+                unit_type=flying_type,
+                count=count,
+                client_count=client_count,
+                at=at and at or self._group_point(self.conflict.air_defenders_location))
+
+            waypoint = self._add_radio_waypoint(group, self.conflict.position, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+            if self.conflict.is_vector:
+                self._add_radio_waypoint(group, self.conflict.tail, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+            else:
+                heading = group.position.heading_between_point(self.conflict.position)
+                waypoint = self._add_radio_waypoint(group, self.conflict.position.point_from_heading(heading, BARCAP_RACETRACK_DISTANCE),
+                                                    WARM_START_ALTITUDE,
+                                                    WARM_START_AIRSPEED)
+                waypoint.tasks.append(OrbitAction(WARM_START_ALTITUDE, WARM_START_AIRSPEED))
+
+            group.task = CAP.name
+            self._setup_group(group, CAP, client_count)
+            self._rtb_for(group, self.conflict.to_cp, at)
+
+    def generate_transport(self, transport: db.PlaneDict, destination: Airport, escort=True):
+        assert not escort or len(self.escort_targets) == 0
 
         for flying_type, count, client_count in self._split_to_groups(transport):
             group = self._generate_group(
@@ -317,9 +484,11 @@ class AircraftConflictGenerator:
                 client_count=client_count,
                 at=self._group_point(self.conflict.air_defenders_location))
 
-            waypoint = group.add_waypoint(destination.position.random_point_within(0, 0), TRANSPORT_LANDING_ALT)
-            self.escort_targets.append((group, group.points.index(waypoint)))
+            waypoint = self._rtb_for(group, self.conflict.to_cp)
+            if escort:
+                self.escort_targets.append((group, group.points.index(waypoint)))
 
+            self._add_radio_waypoint(group, destination.position, RTB_ALTITUDE)
             group.task = Transport.name
             group.land_at(destination)
 
@@ -334,13 +503,14 @@ class AircraftConflictGenerator:
                 at=at and at or self._group_point(self.conflict.air_attackers_location))
 
             group.task = CAP.name
+            group.points[0].tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
 
-            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 = self._add_radio_waypoint(group, self.conflict.position, WARM_START_ALTITUDE, INTERCEPTION_AIRSPEED)
             wayp.tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
+            
+            if self.conflict.is_vector:
+                self._add_radio_waypoint(group, self.conflict.tail, CAS_ALTITUDE, WARM_START_ALTITUDE)
+
             self._setup_group(group, CAP, client_count)
             self._rtb_for(group, self.conflict.from_cp, at)
 
@@ -355,9 +525,5 @@ class AircraftConflictGenerator:
                 at=at and at or self._group_point(self.conflict.air_attackers_location)
             )
 
-            group.add_waypoint(
-                pos=self.conflict.position,
-                altitude=HELI_ALT,
-            )
-
+            self._add_radio_waypoint(group, self.conflict.position, HELI_ALT)
             self._setup_group(group, Transport, client_count)

gen/airsupportgen.py

@@ -0,0 +1,69 @@
+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.name)):
+            self.generated_tankers.append(db.unit_type_name(tanker_unit_type))
+            tanker_heading = self.conflict.to_cp.position.heading_between_point(self.conflict.from_cp.position) + TANKER_HEADING_OFFSET * i
+            tanker_position = player_cp.position.point_from_heading(tanker_heading, TANKER_DISTANCE)
+            tanker_group = self.mission.refuel_flight(
+                country=self.mission.country(self.game.player),
+                name=namegen.next_tanker_name(self.mission.country(self.game.player)),
+                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:
+            awacs_unit = db.find_unittype(AWACS, self.conflict.attackers_side.name)[0]
+            awacs_flight = self.mission.awacs_flight(
+                country=self.mission.country(self.game.player),
+                name=namegen.next_awacs_name(self.mission.country(self.game.player)),
+                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))

gen/armor.py

@@ -1,3 +1,8 @@
+import logging
+
+from random import randint
+from itertools import zip_longest
+
 from game import db
 from .conflictgen import *
 from .naming import *
@@ -11,6 +16,12 @@ from dcs.country import *
 SPREAD_DISTANCE_FACTOR = 0.1, 0.3
 SPREAD_DISTANCE_SIZE_FACTOR = 0.1
 
+FRONTLINE_CAS_FIGHTS_COUNT = 4, 8
+FRONTLINE_CAS_GROUP_MIN = 1, 2
+FRONTLINE_CAS_PADDING = 12000
+
+FIGHT_DISTANCE = 3500
+
 
 class ArmorConflictGenerator:
     def __init__(self, mission: Mission, conflict: Conflict):
@@ -25,33 +36,88 @@ class ArmorConflictGenerator:
 
         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):
+    def _generate_group(self, side: Country, unit: VehicleType, count: int, at: Point, to: Point = None, move_formation: PointAction = PointAction.OffRoad):
         for c in range(count):
+            logging.info("armorgen: {} for {}".format(unit, side.id))
             group = self.m.vehicle_group(
                     side,
                     namegen.next_unit_name(side, unit),
                     unit,
                     position=self._group_point(at),
                     group_size=1,
-                    move_formation=PointAction.OffRoad)
-            initial_position = self.conflict.position.point_from_heading(0, 500)
-            wayp = group.add_waypoint(self._group_point(initial_position))
+                    move_formation=move_formation)
+
+            vehicle: Vehicle = group.units[0]
+            vehicle.player_can_drive = True
+
+            if not to:
+                to = self.conflict.position.point_from_heading(0, 500)
+
+            wayp = group.add_waypoint(self._group_point(to), move_formation=move_formation)
             wayp.tasks = []
 
+    def _generate_fight_at(self, attackers: db.ArmorDict, defenders: db.ArmorDict, position: Point):
+        if attackers:
+            attack_pos = position.point_from_heading(self.conflict.heading - 90, FIGHT_DISTANCE)
+            attack_dest = position.point_from_heading(self.conflict.heading + 90, FIGHT_DISTANCE * 2)
+            for type, count in attackers.items():
+                self._generate_group(
+                    side=self.conflict.attackers_side,
+                    unit=type,
+                    count=count,
+                    at=attack_pos,
+                    to=attack_dest,
+                )
+
+        if defenders:
+            def_pos = position.point_from_heading(self.conflict.heading + 90, FIGHT_DISTANCE)
+            def_dest = position.point_from_heading(self.conflict.heading - 90, FIGHT_DISTANCE * 2)
+            for type, count in defenders.items():
+                self._generate_group(
+                    side=self.conflict.defenders_side,
+                    unit=type,
+                    count=count,
+                    at=def_pos,
+                    to=def_dest,
+                )
+
     def generate(self, attackers: db.ArmorDict, defenders: db.ArmorDict):
         for type, count in attackers.items():
             self._generate_group(
-                    side=self.conflict.attackers_side,
-                    unit=type,
-                    count=count,
-                    at=self.conflict.ground_attackers_location)
+                side=self.conflict.attackers_side,
+                unit=type,
+                count=count,
+                at=self.conflict.ground_attackers_location)
 
         for type, count in defenders.items():
             self._generate_group(
-                    side=self.conflict.defenders_side,
-                    unit=type,
-                    count=count,
-                    at=self.conflict.ground_defenders_location)
+                side=self.conflict.defenders_side,
+                unit=type,
+                count=count,
+                at=self.conflict.ground_defenders_location)
+
+    def generate_vec(self, attackers: db.ArmorDict, defenders: db.ArmorDict):
+        fights_count = randint(*FRONTLINE_CAS_FIGHTS_COUNT)
+        single_fight_defenders_count = min(int(sum(defenders.values()) / fights_count), randint(*FRONTLINE_CAS_GROUP_MIN))
+        defender_groups = list(db.unitdict_split(defenders, single_fight_defenders_count))
+
+        single_fight_attackers_count = min(int(sum(attackers.values()) / len(defender_groups)), randint(*FRONTLINE_CAS_GROUP_MIN))
+        attacker_groups = list(db.unitdict_split(attackers, single_fight_attackers_count))
+
+        for attacker_group_dict, target_group_dict in zip_longest(attacker_groups, defender_groups):
+            position = self.conflict.position.point_from_heading(self.conflict.heading,
+                                                                 random.randint(0, self.conflict.distance))
+            self._generate_fight_at(attacker_group_dict, target_group_dict, position)
+
+    def generate_convoy(self, units: db.ArmorDict):
+        for type, count in units.items():
+            self._generate_group(
+                side=self.conflict.defenders_side,
+                unit=type,
+                count=count,
+                at=self.conflict.ground_defenders_location,
+                to=self.conflict.position,
+                move_formation=PointAction.OnRoad)
 
     def generate_passengers(self, count: int):
         unit_type = random.choice(db.find_unittype(Nothing, self.conflict.attackers_side.name))

gen/awacsgen.py

@@ -1,32 +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_name(self.mission.country(self.game.player),),
-            plane_type=plane,
-            altitude=AWACS_ALT,
-            airport=None,
-            position=self.conflict.position.random_point_within(AWACS_DISTANCE, AWACS_DISTANCE),
-            frequency=251
-        )

gen/briefinggen.py

@@ -0,0 +1,63 @@
+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.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 generate(self):
+        self.waypoints.insert(0, "INITIAL")
+        self.waypoints.append("RTB")
+        self.waypoints.append("RTB Landing")
+
+        description = ""
+
+        if self.title:
+            description += self.title
+
+        if self.description:
+            description += "\n\n" + self.description
+
+        if self.freqs:
+            description += "\n\nCOMMS:"
+            for name, freq in self.freqs:
+                description += "\n{}: {}".format(name, freq)
+
+        if self.targets:
+            description += "\n\nTARGETS:"
+            for i, (name, tp) in enumerate(self.targets):
+                description += "\n#{} {} {}".format(i+1, name, "(TP {})".format(tp) if tp else "")
+
+        if self.waypoints:
+            description += "\n\nWAYPOINTS:"
+            for i, descr in enumerate(self.waypoints):
+                description += "\n#{}: {}".format(i, descr)
+
+        self.m.set_description_text(description)

gen/conflictgen.py

@@ -1,3 +1,4 @@
+import logging
 import typing
 import pdb
 import dcs
@@ -20,9 +21,15 @@ AIR_DISTANCE = 40000
 
 CAPTURE_AIR_ATTACKERS_DISTANCE = 25000
 CAPTURE_AIR_DEFENDERS_DISTANCE = 60000
+STRIKE_AIR_ATTACKERS_DISTANCE = 45000
+STRIKE_AIR_DEFENDERS_DISTANCE = 25000
+
+CAP_CAS_DISTANCE = 10000, 120000
 
 GROUND_INTERCEPT_SPREAD = 5000
 GROUND_DISTANCE_FACTOR = 1
+GROUND_DISTANCE = 2000
+
 GROUND_ATTACK_DISTANCE = 25000, 13000
 
 TRANSPORT_FRONTLINE_DIST = 1800
@@ -38,8 +45,9 @@ NAVAL_INTERCEPT_DISTANCE_FACTOR = 1
 NAVAL_INTERCEPT_DISTANCE_MAX = 40000
 NAVAL_INTERCEPT_STEP = 5000
 
-FRONT_SMOKE_MIN_DISTANCE = 5000
-FRONT_SMOKE_DISTANCE_FACTOR = 0.5
+FRONTLINE_LENGTH = 80000
+FRONTLINE_MIN_CP_DISTANCE = 5000
+FRONTLINE_DISTANCE_STRENGTH_FACTOR = 0.7
 
 
 def _opposite_heading(h):
@@ -65,28 +73,35 @@ class Conflict:
     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):
+                 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.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
@@ -94,29 +109,159 @@ 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
 
-    @classmethod
-    def frontline_position(cls, from_cp: ControlPoint, to_cp: ControlPoint):
-        distance = max(from_cp.position.distance_to_point(to_cp.position) * FRONT_SMOKE_DISTANCE_FACTOR * to_cp.base.strength, FRONT_SMOKE_MIN_DISTANCE)
-        heading = to_cp.position.heading_between_point(from_cp.position)
-        return to_cp.position.point_from_heading(heading, distance)
+    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)
+
+        ground_position = cls._find_ground_position(position, attack_distance / 2 - FRONTLINE_MIN_CP_DISTANCE, attack_heading, theater)
+        if ground_position:
+            return ground_position, _opposite_heading(attack_heading)
+        else:
+            logging.warning("Coudn't find frontline position between {} and {}!".format(from_cp, to_cp))
+            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 _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: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
@@ -125,12 +270,12 @@ class Conflict:
         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,
@@ -146,13 +291,42 @@ class Conflict:
         )
 
     @classmethod
-    def intercept_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+    def strike_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
+        position = to_cp.position
+        attack_raw_heading = to_cp.position.heading_between_point(from_cp.position)
+        attack_heading = to_cp.find_radial(attack_raw_heading)
+        defense_heading = to_cp.find_radial(from_cp.position.heading_between_point(to_cp.position), ignored_radial=attack_heading)
+
+        distance = to_cp.size * GROUND_DISTANCE_FACTOR
+        attackers_location = position.point_from_heading(attack_heading, distance)
+        attackers_location = Conflict._find_ground_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,
+            defenders_side=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: 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,
@@ -170,7 +344,7 @@ class Conflict:
     def ground_attack_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         heading = random.choice(to_cp.radials)
         initial_location = to_cp.position.random_point_within(*GROUND_ATTACK_DISTANCE)
-        position = Conflict._find_ground_location(initial_location, GROUND_INTERCEPT_SPREAD, _heading_sum(heading, 180), theater)
+        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)
@@ -189,25 +363,74 @@ class Conflict:
         )
 
     @classmethod
-    def ground_intercept_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
-        heading = to_cp.position.heading_between_point(from_cp.position)
-        initial_location = cls.frontline_position(from_cp, to_cp).random_point_within(GROUND_INTERCEPT_SPREAD)
-        position = Conflict._find_ground_location(initial_location, GROUND_INTERCEPT_SPREAD, heading, 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)
+    def convoy_strike_conflict(cls, 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,
             ground_attackers_location=None,
-            ground_defenders_location=position,
+            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 frontline_cas_conflict(cls, 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,
+            defenders_side=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)
+            air_defenders_location=position.point_from_heading(random.randint(*INTERCEPT_ATTACKERS_HEADING) + _opposite_heading(heading), AIR_DISTANCE),
+        )
+
+    @classmethod
+    def frontline_cap_conflict(cls, 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,
+            defenders_side=defender,
+            air_attackers_location=attackers_position,
+            air_defenders_location=defenders_position,
         )
 
     @classmethod
@@ -218,7 +441,7 @@ class Conflict:
 
         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,
@@ -234,7 +457,7 @@ 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)
@@ -244,7 +467,10 @@ class Conflict:
 
             if not theater.is_on_land(position):
                 break
+        return position
 
+    @classmethod
+    def naval_intercept_conflict(cls, 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,
@@ -261,10 +487,9 @@ 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)
+        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)

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
 }
 
 
@@ -48,7 +52,8 @@ class EnviromentGenerator:
         self.game = game
 
     def _gen_random_time(self):
-        start_time = datetime.combine(datetime.today(), time())
+        start_time = datetime.strptime('May 25 2018 12:00AM', '%b %d %Y %I:%M%p')
+
         time_range = None
         for k, v in RANDOM_TIME.items():
             if self.game.settings.night_disabled and k == "night":
@@ -59,8 +64,36 @@ class EnviromentGenerator:
                 break
 
         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,30 +101,36 @@ 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(8, 12))
 
-            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(4, 8))
+        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_random_weather()

gen/forcedoptionsgen.py

@@ -0,0 +1,45 @@
+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 == "All Units":
+            self.mission.forced_options.options_view = ForcedOptions.Views.All
+        elif self.game.settings.map_coalition_visibility == "Allied Units":
+            self.mission.forced_options.options_view = ForcedOptions.Views.Allies
+        elif self.game.settings.map_coalition_visibility == "Own Aircraft":
+            self.mission.forced_options.options_view = ForcedOptions.Views.MyAircraft
+        elif self.game.settings.map_coalition_visibility == "None":
+            self.mission.forced_options.options_view = ForcedOptions.Views.OnlyMap
+
+    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_labels()
+        

gen/groundobjectsgen.py

@@ -0,0 +1,92 @@
+import logging
+
+from game import db
+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),
+                name="FARP",
+                position=position,
+            )
+
+    def generate(self):
+        side = self.m.country(self.game.enemy)
+
+        cp = None  # type: ControlPoint
+        if self.conflict.attackers_side.name == self.game.player:
+            cp = self.conflict.to_cp
+        else:
+            cp = self.conflict.from_cp
+
+        for ground_object in cp.ground_objects:
+            if ground_object.dcs_identifier == "AA":
+                if ground_object.position.distance_to_point(self.conflict.from_cp.position) < AA_CP_MIN_DISTANCE:
+                    continue
+
+                if ground_object.is_dead:
+                    continue
+
+                unit_type = random.choice(self.game.commision_unit_types(cp, AirDefence))
+                assert unit_type is not None, "Cannot find unit type for GroundObject defense ({})!".format(cp)
+
+                group = self.m.vehicle_group(
+                    country=side,
+                    name=ground_object.string_identifier,
+                    _type=unit_type,
+                    position=ground_object.position,
+                    heading=ground_object.heading,
+                )
+
+                logging.info("generated defense object identifier {} with mission id {}".format(group.name, group.id))
+            else:
+                if ground_object.dcs_identifier in warehouse_map:
+                    static_type = warehouse_map[ground_object.dcs_identifier]
+                else:
+                    static_type = fortification_map[ground_object.dcs_identifier]
+
+                if not static_type:
+                    print("Didn't find {} in static _map(s)!".format(ground_object.dcs_identifier))
+                    continue
+
+                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/naming.py

@@ -15,6 +15,10 @@ class NameGenerator:
         self.number += 1
         return "awacs|{}|{}|0|".format(country.id, self.number)
 
+    def next_tanker_name(self, country):
+        self.number += 1
+        return "tanker|{}|{}|0|".format(country.id, self.number)
+
     def next_carrier_name(self, country):
         self.number += 1
         return "carrier|{}|{}|0|".format(country.id, self.number)

gen/shipgen.py

@@ -1,3 +1,5 @@
+import logging
+
 from game import db
 from .conflictgen import *
 from .naming import *
@@ -14,25 +16,38 @@ class ShipGenerator:
         self.m = mission
         self.conflict = conflict
 
-    def generate_carrier(self, type: ShipType, country: str, at: Point) -> ShipGroup:
-        return self.m.ship_group(
+    def generate_carrier(self, for_units: typing.Collection[UnitType], country: str, at: Point) -> ShipGroup:
+        type = db.find_unittype(Carriage, country)[0]
+        for unit_type in for_units:
+            if unit_type in db.CARRIER_TYPE_BY_PLANE:
+                type = db.CARRIER_TYPE_BY_PLANE[unit_type]
+                break
+
+        group = self.m.ship_group(
             country=self.m.country(country),
             name=namegen.next_carrier_name(self.m.country(country)),
             _type=type,
             position=at)
 
+        group.points[0].tasks.append(ActivateBeaconCommand(unit_id=group.id, channel=20, callsign="SHDW", aa=False))
+        group.points[0].tasks.append(ActivateICLSCommand(unit_id=group.id, channel=1))
+        return group
+
     def generate_cargo(self, units: db.ShipDict) -> typing.Collection[ShipGroup]:
         groups = []
+        offset = 0
         for unit_type, unit_count in units.items():
-            group = self.m.ship_group(
-                country=self.conflict.defenders_side,
-                name=namegen.next_unit_name(self.conflict.defenders_side, unit_type),
-                _type=unit_type,
-                position=self.conflict.ground_defenders_location.random_point_within(SHIP_RANDOM_SPREAD, SHIP_RANDOM_SPREAD),
-                group_size=unit_count,
-            )
+            for _ in range(unit_count):
+                offset += 1
+                logging.info("shipgen: {} ({}) for {}".format(unit_type, unit_count, self.conflict.defenders_side))
+                group = self.m.ship_group(
+                    country=self.conflict.defenders_side,
+                    name=namegen.next_unit_name(self.conflict.defenders_side, unit_type),
+                    _type=unit_type,
+                    position=self.conflict.ground_defenders_location.random_point_within(SHIP_RANDOM_SPREAD, SHIP_RANDOM_SPREAD).point_from_heading(0, offset * SHIP_RANDOM_SPREAD)
+                )
 
-            group.add_waypoint(self.conflict.to_cp.position)
-            groups.append(group)
+                group.add_waypoint(self.conflict.to_cp.position)
+                groups.append(group)
 
         return groups

gen/triggergen.py

@@ -12,20 +12,23 @@ from dcs.action import *
 
 from game import db
 from theater import *
+from gen.airsupportgen import AirSupportConflictGenerator
 from gen import *
 
 PUSH_TRIGGER_SIZE = 3000
+PUSH_TRIGGER_ACTIVATION_AGL = 25
 
 REGROUP_ZONE_DISTANCE = 12000
 REGROUP_ALT = 5000
 
 TRIGGER_WAYPOINT_OFFSET = 2
 TRIGGER_MIN_DISTANCE_FROM_START = 10000
-TRIGGER_RADIUS_MINIMUM = 25000
+TRIGGER_RADIUS_MINIMUM = 20000
 
-TRIGGER_RADIUS_SMALL = 30000
+TRIGGER_RADIUS_SMALL = 50000
 TRIGGER_RADIUS_MEDIUM = 100000
 TRIGGER_RADIUS_LARGE = 150000
+TRIGGER_RADIUS_ALL_MAP = 3000000
 
 
 class Silence(Option):
@@ -38,7 +41,7 @@ class TriggersGenerator:
         self.conflict = conflict
         self.game = game
 
-    def _gen_activation_trigger(self, radius: int, player_coalition: str, enemy_coalition: str):
+    def _gen_activation_trigger(self, radius: int, player_cp: ControlPoint, player_coalition: str, enemy_coalition: str):
         activate_by_trigger = []
         for coalition_name, coalition in self.mission.coalition.items():
             for country in coalition.countries.values():
@@ -51,14 +54,14 @@ class TriggersGenerator:
                     vehicle_group.late_activation = True
                     activate_by_trigger.append(vehicle_group)
 
-        conflict_distance = self.conflict.from_cp.position.distance_to_point(self.conflict.position)
+        conflict_distance = player_cp.position.distance_to_point(self.conflict.position)
         minimum_radius = max(conflict_distance - TRIGGER_MIN_DISTANCE_FROM_START, TRIGGER_RADIUS_MINIMUM)
         if minimum_radius < 0:
             minimum_radius = 0
 
-        result_radius = min(minimum_radius, radius)
+        radius = min(minimum_radius, radius)
 
-        activation_trigger_zone = self.mission.triggers.add_triggerzone(self.conflict.position, result_radius, name="Activation zone")
+        activation_trigger_zone = self.mission.triggers.add_triggerzone(self.conflict.position, radius, name="Activation zone")
         activation_trigger = TriggerOnce(Event.NoEvent, "Activation trigger")
         activation_trigger.add_condition(PartOfCoalitionInZone(player_coalition, activation_trigger_zone.id))
         activation_trigger.add_condition(FlagIsTrue())
@@ -67,46 +70,50 @@ class TriggersGenerator:
 
         self.mission.triggerrules.triggers.append(activation_trigger)
 
-    def _gen_push_trigger(self, player_coalition: str):
+    def _gen_push_trigger(self, player_cp: ControlPoint, player_coalition: str):
         push_by_trigger = []
         for coalition_name, coalition in self.mission.coalition.items():
             for country in coalition.countries.values():
                 if coalition_name == player_coalition:
-                    for plane_group in country.plane_group + country.helicopter_group:
-                        if plane_group.task == AWACS.name:
+                    for group in country.plane_group + country.helicopter_group:
+                        if group.task == AWACS.name or group.task == Refueling.name:
                             continue
 
-                        regroup_heading = self.conflict.to_cp.position.heading_between_point(self.conflict.from_cp.position)
+                        push_by_trigger.append(group)
 
-                        pos1 = plane_group.position.point_from_heading(regroup_heading, REGROUP_ZONE_DISTANCE)
-                        pos2 = plane_group.position.point_from_heading(regroup_heading, REGROUP_ZONE_DISTANCE+5000)
-                        w1 = plane_group.add_waypoint(pos1, REGROUP_ALT)
-                        w2 = plane_group.add_waypoint(pos2, REGROUP_ALT)
+                        if not group.units[0].is_human():
+                            regroup_heading = self.conflict.to_cp.position.heading_between_point(player_cp.position)
 
-                        plane_group.points.remove(w1)
-                        plane_group.points.remove(w2)
+                            pos1 = group.position.point_from_heading(regroup_heading, REGROUP_ZONE_DISTANCE)
+                            pos2 = group.position.point_from_heading(regroup_heading, REGROUP_ZONE_DISTANCE+5000)
+                            w1 = group.add_waypoint(pos1, REGROUP_ALT)
+                            w2 = group.add_waypoint(pos2, REGROUP_ALT)
 
-                        plane_group.points.insert(1, w2)
-                        plane_group.points.insert(1, w1)
+                            group.points.remove(w1)
+                            group.points.remove(w2)
 
-                        w1.tasks.append(Silence(True))
+                            group.points.insert(1, w2)
+                            group.points.insert(1, w1)
 
-                        switch_waypoint_task = ControlledTask(SwitchWaypoint(from_waypoint=3, to_waypoint=2))
-                        switch_waypoint_task.start_if_user_flag(1, False)
-                        w2.tasks.append(switch_waypoint_task)
-                        plane_group.points[3].tasks.append(Silence(False))
+                            w1.tasks.append(Silence(True))
 
-                        plane_group.add_trigger_action(SwitchWaypoint(to_waypoint=4))
-                        push_by_trigger.append(plane_group)
+                            switch_waypoint_task = ControlledTask(SwitchWaypoint(from_waypoint=3, to_waypoint=2))
+                            switch_waypoint_task.start_if_user_flag(1, False)
+                            w2.tasks.append(switch_waypoint_task)
+                            group.points[3].tasks.append(Silence(False))
+
+                            group.add_trigger_action(SwitchWaypoint(to_waypoint=4))
 
-        push_trigger_zone = self.mission.triggers.add_triggerzone(self.conflict.from_cp.position, PUSH_TRIGGER_SIZE, name="Push zone")
         push_trigger = TriggerOnce(Event.NoEvent, "Push trigger")
 
         for group in push_by_trigger:
-            push_trigger.add_condition(AllOfGroupOutsideZone(group.id, push_trigger_zone.id))
-            push_trigger.add_action(AITaskPush(group.id, 1))
+            for unit in group.units:
+                push_trigger.add_condition(UnitAltitudeHigherAGL(unit.id, PUSH_TRIGGER_ACTIVATION_AGL))
 
-        message_string = self.mission.string("Task force is in the air, proceed with the objective (activate waypoint 3).")
+            if not group.units[0].is_human():
+                push_trigger.add_action(AITaskPush(group.id, 1))
+
+        message_string = self.mission.string("Task force is in the air, proceed with the objective.")
         push_trigger.add_action(MessageToAll(message_string, clearview=True))
         push_trigger.add_action(SetFlagValue())
 
@@ -121,9 +128,9 @@ class TriggersGenerator:
     def _set_skill(self, player_coalition: str, enemy_coalition: str):
         for coalition_name, coalition in self.mission.coalition.items():
             if coalition_name == player_coalition:
-                skill_level = self.game.settings.player_skill
+                skill_level = self.game.settings.player_skill, self.game.settings.player_skill
             elif coalition_name == enemy_coalition:
-                skill_level = self.game.settings.enemy_skill
+                skill_level = self.game.settings.enemy_skill, self.game.settings.enemy_vehicle_skill
             else:
                 continue
 
@@ -131,19 +138,15 @@ class TriggersGenerator:
                 for plane_group in country.plane_group:
                     for plane_unit in plane_group.units:
                         if plane_unit.skill != Skill.Client and plane_unit.skill != Skill.Player:
-                            plane_unit.skill = Skill(skill_level)
+                            plane_unit.skill = Skill(skill_level[0])
 
                 for vehicle_group in country.vehicle_group:
-                    vehicle_group.set_skill(Skill(skill_level))
+                    vehicle_group.set_skill(Skill(skill_level[1]))
 
-    def generate(self, is_quick: bool, activation_trigger_radius: int):
+    def generate(self, player_cp: ControlPoint, is_quick: bool, activation_trigger_radius: int, awacs_enabled: bool):
         player_coalition = self.game.player == "USA" and "blue" or "red"
         enemy_coalition = player_coalition == "blue" and "red" or "blue"
 
-        # dcs require at least some slots on both sides for the mission to start
-        self.mission.groundControl.red_observer = 1
-        self.mission.groundControl.blue_observer = 1
-
         self.mission.coalition[player_coalition].bullseye = {"x": self.conflict.position.x,
                                                              "y": self.conflict.position.y}
 
@@ -152,6 +155,6 @@ class TriggersGenerator:
 
         if not is_quick:
             # TODO: waypoint parts of this should not be post-hacked but added in airgen
-            self._gen_activation_trigger(activation_trigger_radius, player_coalition, enemy_coalition)
-            self._gen_push_trigger(player_coalition)
+            self._gen_activation_trigger(activation_trigger_radius, player_cp, player_coalition, enemy_coalition)
+            self._gen_push_trigger(player_cp, player_coalition)
 

gen/visualgen.py

@@ -9,6 +9,7 @@ from dcs.unit import Static
 from theater import *
 from .conflictgen import *
 #from game.game import Game
+from game import db
 
 
 class MarkerSmoke(unittype.StaticType):
@@ -62,7 +63,6 @@ def __monkey_static_dict(self: Static):
 __original_static_dict = Static.dict
 Static.dict = __monkey_static_dict
 
-FRONT_SMOKE_LENGTH = 80000
 FRONT_SMOKE_SPACING = 800
 FRONT_SMOKE_RANDOM_SPREAD = 4000
 FRONT_SMOKE_TYPE_CHANCES = {
@@ -99,11 +99,17 @@ class VisualGenerator:
 
     def _generate_frontline_smokes(self):
         for from_cp, to_cp in self.game.theater.conflicts():
-            heading = to_cp.position.heading_between_point(from_cp.position)
-            point = Conflict.frontline_position(from_cp, to_cp)
-            plane_start = point.point_from_heading(turn_heading(heading, 90), FRONT_SMOKE_LENGTH / 2)
+            if from_cp.is_global or to_cp.is_global:
+                continue
 
-            for offset in range(0, FRONT_SMOKE_LENGTH, FRONT_SMOKE_SPACING):
+            frontline = Conflict.frontline_position(self.game.theater, from_cp, to_cp)
+            if not frontline:
+                continue
+
+            point, heading = frontline
+            plane_start = point.point_from_heading(turn_heading(heading, 90), FRONTLINE_LENGTH / 2)
+
+            for offset in range(0, FRONTLINE_LENGTH, FRONT_SMOKE_SPACING):
                 position = plane_start.point_from_heading(turn_heading(heading, - 90), offset)
 
                 for k, v in FRONT_SMOKE_TYPE_CHANCES.items():
@@ -119,6 +125,17 @@ class VisualGenerator:
                             position=pos)
                         break
 
+    def _generate_stub_planes(self):
+        mission_units = set()
+        for coalition_name, coalition in self.mission.coalition.items():
+            for country in coalition.countries.values():
+                for group in country.plane_group + country.helicopter_group + country.vehicle_group:
+                    for unit in group.units:
+                        mission_units.add(db.unit_type_of(unit))
+
+        for unit_type in mission_units:
+            self.mission.static_group(self.mission.country("USA"), "a", unit_type, Point(0, 300000), hidden=True)
+
     def generate_target_smokes(self, target):
         spread = target.size * DESTINATION_SMOKE_DISTANCE_FACTOR
         for _ in range(0, int(target.size * DESTINATION_SMOKE_AMOUNT_FACTOR * (1.1 - target.base.strength))):
@@ -154,3 +171,4 @@ class VisualGenerator:
 
     def generate(self):
         self._generate_frontline_smokes()
+        self._generate_stub_planes()

pyinstaller.spec

@@ -0,0 +1,40 @@
+# -*- mode: python -*-
+
+block_cipher = None
+
+
+a = Analysis(['__init__.py'],
+             pathex=['C:\\Users\\shdwp\\PycharmProjects\\dcs_liberation'],
+             binaries=[],
+             datas=[
+             ('resources', 'resources'),
+             ('submodules/dcs/dcs/terrain/caucasus.p', 'dcs/terrain/'),
+             ('submodules/dcs/dcs/terrain/nevada.p', 'dcs/terrain/'),
+             ],
+             hookspath=[],
+             runtime_hooks=[],
+             excludes=[],
+             win_no_prefer_redirects=False,
+             win_private_assemblies=False,
+             cipher=block_cipher,
+             noarchive=False)
+pyz = PYZ(a.pure, a.zipped_data,
+             cipher=block_cipher)
+exe = EXE(pyz,
+          a.scripts,
+          [],
+          icon="resources/icon.ico",
+          exclude_binaries=True,
+          name='liberation_main',
+          debug=False,
+          bootloader_ignore_signals=False,
+          strip=False,
+          upx=True,
+          console=True )
+coll = COLLECT(exe,
+               a.binaries,
+               a.zipfiles,
+               a.datas,
+               strip=False,
+               upx=True,
+               name='dcs_liberation')

resources/tools/dcs

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

resources/tools/generate_example_groundobjects.py

@@ -0,0 +1,38 @@
+import typing
+
+from dcs.mission import *
+from dcs.terrain import *
+
+from theater.nevada import *
+from theater.persiangulf import *
+from theater.caucasus import *
+from theater.controlpoint import *
+
+def find_ground_location(near, theater, max, min) -> typing.Optional[Point]:
+    for _ in range(500):
+        p = near.random_point_within(max, min)
+        if theater.is_on_land(p):
+            return p
+
+    return None
+
+
+mission = Mission(Nevada())
+theater = NevadaTheater()
+
+for cp in theater.enemy_points():
+    for _ in range(0, random.randrange(3, 6)):
+        p = find_ground_location(cp.position, theater, 120000, 5000)
+        if not p:
+            print("Didn't find ground location for {}".format(cp))
+            continue
+
+        mission.flight_group_inflight(
+            mission.country("USA"),
+            "",
+            A_10C,
+            p,
+            10000
+        )
+
+mission.save("resources/tools/ground_objects_example.miz")

resources/tools/generate_groundobject_templates.py

@@ -0,0 +1,50 @@
+import pickle
+import typing
+
+from dcs.mission import Mission
+from dcs.mapping import Point
+from dcs.unit import *
+from dcs.statics import warehouse_map, fortification_map
+
+
+def load_templates():
+    temp_mis = Mission()
+    temp_mis.load_file("resources/tools/groundobject_templates.miz")
+
+    groups = {}  # type: typing.Dict[str, typing.Dict[int, typing.List[Static]]]
+
+    for static_group in temp_mis.country("USA").static_group:
+        for static in static_group.units:
+            static_name = str(static.name).split()[0]
+            tpl_name, tpl_idx = static_name[:-1], int(static_name[-1])
+
+            groups[tpl_name] = groups.get(tpl_name, {})
+            groups[tpl_name][tpl_idx] = groups[tpl_name].get(tpl_idx, [])
+            groups[tpl_name][tpl_idx].append(static)
+
+    tpls = {name: {idx: [] for idx in groups[name].keys()} for name in groups.keys()}
+    for category_name, category_groups in groups.items():
+        for idx, static_groups in category_groups.items():
+            dist = -1
+            a, b = None, None
+            for aa in static_groups:
+                for bb in static_groups:
+                    if aa.position.distance_to_point(bb.position) > dist:
+                        dist = aa.position.distance_to_point(bb.position)
+                        a = aa
+                        b = bb
+
+            center = a.position.point_from_heading(a.position.heading_between_point(b.position), dist / 2)
+            for static in static_groups:
+                tpls[category_name][idx].append({
+                    "type": static.type,
+                    "offset": Point(center.x - static.position.x, center.y - static.position.y),
+                    "heading": static.heading,
+                })
+
+    tpls["aa"] = {0: [{"type": "AA", "offset": Point(0, 0), "heading": 0}]}
+    return tpls
+
+
+with open("resources/groundobject_templates.p", "wb") as f:
+    pickle.dump(load_templates(), f)

resources/tools/generate_groundobjectsmap.py

@@ -0,0 +1,108 @@
+import pickle
+import typing
+
+from dcs.mission import Mission
+from dcs.mapping import Point
+from dcs.terrain import *
+from dcs.unitgroup import VehicleGroup, StaticGroup
+from dcs import vehicles
+from dcs.unit import *
+from dcs.statics import warehouse_map, fortification_map
+
+from game import db
+from gen.groundobjectsgen import TheaterGroundObject
+from theater.caucasus import CaucasusTheater
+from theater.persiangulf import PersianGulfTheater
+from theater.nevada import NevadaTheater
+
+m = Mission()
+m.load_file("resources/tools/cau_groundobjects.miz")
+
+if isinstance(m.terrain, Caucasus):
+    theater = CaucasusTheater(load_ground_objects=False)
+elif isinstance(m.terrain, PersianGulf):
+    theater = PersianGulfTheater(load_ground_objects=False)
+elif isinstance(m.terrain, Nevada):
+    theater = NevadaTheater(load_ground_objects=False)
+else:
+    assert False
+
+
+def closest_cp(location: Point) -> (int, float):
+    global theater
+    min_distance, min_cp = None, None
+
+    for cp in theater.controlpoints:
+        if not min_distance or location.distance_to_point(cp.position) < min_distance:
+            min_distance = location.distance_to_point(cp.position)
+            min_cp = cp.id
+
+    assert min_cp is not None
+    return min_cp
+
+
+if __name__ == "__main__":
+    theater_objects = []
+
+    for group in m.country("Russia").static_group + m.country("Russia").vehicle_group:
+        for unit in group.units:
+            theater_object = TheaterGroundObject()
+            theater_object.object_id = len(theater_objects) + 1
+
+            theater_object.position = unit.position
+            theater_object.heading = unit.heading
+
+            if isinstance(unit, Vehicle) and unit.type in vehicles.AirDefence.__dict__.values():
+                theater_object.dcs_identifier = "AA"
+            else:
+                theater_object.dcs_identifier = unit.type
+
+            assert theater_object.dcs_identifier
+            assert theater_object.object_id
+
+            theater_objects.append(theater_object)
+
+    group_ids = 1
+    for object_a in theater_objects:
+        for object_b in theater_objects:
+            if object_a.position.distance_to_point(object_b.position) < 2000:
+                if object_a.group_id and object_b.group_id:
+                    continue
+                elif object_a.group_id:
+                    object_b.group_id = object_a.group_id
+                    object_b.cp_id = object_a.cp_id
+                elif object_b.group_id:
+                    object_a.group_id = object_b.group_id
+                    object_a.cp_id = object_b.cp_id
+                else:
+                    object_a.group_id = group_ids
+                    object_b.group_id = group_ids
+                    object_a.cp_id = closest_cp(object_a.position)
+                    object_b.cp_id = object_a.cp_id
+                    group_ids += 1
+
+                assert object_a.cp_id == object_b.cp_id, "Object {} and {} are placed in group with different airports!".format(object_a.string_identifier, object_b.string_identifier)
+
+    for a in theater_objects:
+        if not a.group_id:
+            a.group_id = group_ids
+            a.cp_id = closest_cp(a.position)
+            group_ids += 1
+
+    with open("resources/cau_groundobjects.p", "wb") as f:
+        result = {}
+        for theater_object in theater_objects:
+            assert theater_object.cp_id
+            assert theater_object.group_id
+            assert theater_object.object_id
+
+            if theater_object.cp_id not in result:
+                result[theater_object.cp_id] = []
+            result[theater_object.cp_id].append(theater_object)
+
+        print("Total {} objects".format(len(theater_objects)))
+        for cp_id, objects in result.items():
+            print("{}: total {} objects".format(m.terrain.airport_by_id(cp_id), len(objects)))
+
+        pickle.dump(result, f)
+

resources/tools/generate_landmap.py

@@ -1,14 +1,26 @@
 import pickle
 
 from dcs.mission import Mission
-from dcs.terrain import PersianGulf
+from dcs.planes import A_10C
 
-m = Mission()
-m.load_file("tools/cau_terrain.miz")
+for terrain in ["cau", "gulf", "nev"]:
+    m = Mission()
+    m.load_file("./{}_terrain.miz".format(terrain))
 
-landmap = []
-for plane_group in m.country("USA").plane_group:
-    landmap.append([(x.position.x, x.position.y) for x in plane_group.points])
+    inclusion_zones = []
+    exclusion_zones = []
+    for plane_group in m.country("USA").plane_group:
+        zone = [(x.position.x, x.position.y) for x in plane_group.points]
 
-with open("./caulandmap.p", "wb") as f:
-    pickle.dump(landmap, f)
+        if terrain == "cau" and inclusion_zones:
+            # legacy
+            exclusion_zones.append(zone)
+        else:
+            if plane_group.units[0].type == "F-15C":
+                exclusion_zones.append(zone)
+            else:
+                inclusion_zones.append(zone)
+
+    with open("../{}landmap.p".format(terrain), "wb") as f:
+        print(len(inclusion_zones), len(exclusion_zones))
+        pickle.dump((inclusion_zones, exclusion_zones), f)

resources/tools/generate_loadout_check.py

@@ -1,10 +1,15 @@
+import os
+import sys
 import dcs
 
-from gen.aircraft import AircraftConflictGenerator
 from game import db
+from gen.aircraft import AircraftConflictGenerator
+
+dcs.planes.FlyingType.payload_dirs = [os.path.join(os.path.dirname(os.path.realpath(__file__)), "..\\payloads")]
+
 mis = dcs.Mission(dcs.terrain.PersianGulf())
 pos = dcs.terrain.PersianGulf().khasab().position
-airgen = AircraftConflictGenerator(mis, None)
+airgen = AircraftConflictGenerator(mis, None, None)
 
 for t, uts in db.UNIT_BY_TASK.items():
     if t != dcs.task.CAP and t != dcs.task.CAS:
@@ -25,6 +30,6 @@ for t, uts in db.UNIT_BY_TASK.items():
                 altitude=10000
             )
             g.task = t.name
-            airgen._setup_group(g, t)
+            airgen._setup_group(g, t, 0)
 
 mis.save("loadout_test.miz")

resources/tools/miz_diff.py

@@ -0,0 +1,42 @@
+import sys
+
+from dcs.lua.parse import *
+from dcs.lua.serialize import *
+
+a = loads(open(sys.argv[1], "r").read())
+b = loads(open(sys.argv[2], "r").read())
+
+
+def get(a, k):
+    b = a
+    for x in k.strip().split(" "):
+        if isinstance(a, dict):
+            y = a
+            a = a.get(x, None)
+            if a is None:
+                try:
+                    a = y.get(int(x), None)
+                except:
+                    pass
+        else:
+            break
+    if a is None:
+        pass
+    return a
+
+
+def cycle(kk, ref, v):
+    if isinstance(v, dict):
+        for k, v in v.items():
+            cycle(kk + " " + str(k), ref, v)
+    elif isinstance(v, list):
+        for i, v in enumerate(v):
+            cycle(kk + " " + str(i), ref, v)
+    else:
+        if get(ref, kk) != v:
+            print(kk)
+            print(v)
+            print(get(ref, kk))
+
+
+cycle("", a, b)

resources/tools/mkrelease.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+
+from zipfile import *
+
+
+IGNORED_PATHS = [
+    "__pycache__",
+    ".gitignore",
+    ".gitmodules",
+    ".git",
+    ".idea",
+    ".DS_Store",
+    "submodules",
+
+    "build",
+    "venv",
+]
+
+VERSION = input("version str:")
+
+
+def _zip_dir(archieve, path):
+    for path, directories, files in os.walk(path):
+        is_ignored = False
+        for ignored_path in IGNORED_PATHS:
+            if ignored_path in path:
+                is_ignored = True
+                break
+
+        if is_ignored:
+            continue
+
+        for file in files:
+            if file in IGNORED_PATHS:
+                continue
+            archieve.write(os.path.join(path, file))
+
+
+def _mk_archieve():
+    path = os.path.join("build", "dcs_liberation_{}.zip".format(VERSION))
+    if os.path.exists(path):
+        print("version already exists")
+        return
+
+    shutil.rmtree("./dist")
+
+    os.system("pyinstaller.exe pyinstaller.spec")
+
+    archieve = ZipFile(path, "w")
+    archieve.writestr("dcs_liberation.bat", "cd dist\\dcs_liberation\r\nliberation_main \"%UserProfile%\\Saved Games\" \"{}\"".format(VERSION))
+    _zip_dir(archieve, "./dist/dcs_liberation")
+
+
+_mk_archieve()

start.bat

@@ -1 +0,0 @@
-py.exe __init__.py %UserProfile% > logs.txt 2>&1