readme upd

Combined arms slots

.gitignore

@@ -2,6 +2,7 @@
 __pycache__
 build/*
 resources/payloads/*.lua
+venv
 logs.txt
 .DS_Store
 # User-specific stuff

README.md

@@ -1,8 +1,29 @@
-[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.
 
+## Installation
+1. Download and install **Python 3.6.0** package from https://www.python.org/downloads/release/python-360/ (look at the bottom under *Files*; any option will do if it matches your architecture) with default set of options (you need to have *Install launcher for all users (recommended)* checked)
+1. Download archived release (https://github.com/shdwp/dcs_liberation/releases; **not source code zip**, file should be named **dcs_liberation_xx.zip**)
+1. Unzip the archive somewhere. Path does not matter. **Application will not work** if you start it without extracting
+1. Run **start.bat**
+1. If **"Windows protected your PC"** popup appears on your computer (windows blocks any application unknown to it), you can click on **"More info"** and **"Run anyway"**
+
+## 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.
+
+* [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,7 +1,9 @@
 #!/usr/bin/env python3
 import os
+import re
 import sys
 import dcs
+import logging
 
 import theater.caucasus
 import theater.persiangulf
@@ -14,50 +16,16 @@ import ui.corruptedsavemenu
 
 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,10 +33,29 @@ 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:
+    if not game or not is_version_compatible(game.settings.version):
         new_game_menu = None  # type: NewGameMenu
 
         def start_new_game(player_name: str, enemy_name: str, terrain: str, sams: bool, midgame: bool, multiplier: float):
@@ -83,13 +70,15 @@ try:
                 for i in range(0, int(len(conflicttheater.controlpoints) / 2)):
                     conflicttheater.controlpoints[i].captured = True
 
-            start_generator.generate_initial(conflicttheater, enemy_name, sams, multiplier)
+            start_generator.generate_inital_units(conflicttheater, enemy_name, sams, multiplier)
+            start_generator.generate_groundobjects(conflicttheater)
             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
+            game.settings.version = VERSION_STRING
 
             if midgame:
                 game.budget = game.budget * 4 * len(list(conflicttheater.conflicts()))
@@ -99,8 +88,10 @@ try:
         new_game_menu = ui.newgamemenu.NewGameMenu(w, start_new_game)
         new_game_menu.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()

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
@@ -37,11 +40,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: 18,
+    Su_27: 20,
+    Su_33: 22,
+    MiG_29A: 23,
+    MiG_29S: 25,
 
     F_5E_3: 6,
     MiG_15bis: 5,
@@ -51,7 +54,7 @@ PRICES = {
     AV8BNA: 13,
     M_2000C: 13,
     FA_18C_hornet: 18,
-    F_15C: 24,
+    F_15C: 20,
 
     # 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,6 +77,8 @@ PRICES = {
     An_30M: 13,
     Yak_40: 13,
     S_3B_Tanker: 13,
+    IL_78M: 13,
+    KC_135: 13,
 
     A_50: 8,
     E_3A: 8,
@@ -97,20 +103,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,
 }
@@ -134,8 +139,8 @@ Following tasks are present:
 UNIT_BY_TASK = {
     CAP: [
         C_101CC,
-        AJS37,
         F_5E_3,
+        MiG_23MLD,
         Su_27,
         Su_33,
         MiG_21Bis,
@@ -149,12 +154,14 @@ UNIT_BY_TASK = {
         MiG_15bis,
         L_39ZA,
         AV8BNA,
+        AJS37,
         A_10A,
         A_10C,
         Su_25,
         Su_25T,
         Su_34,
         Ka_50,
+        SA342M,
     ],
 
     Transport: [
@@ -163,10 +170,15 @@ 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, ],
@@ -174,35 +186,32 @@ UNIT_BY_TASK = {
         # 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,
 ]
 
@@ -224,8 +233,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,
 }
 
 """
@@ -236,6 +245,7 @@ UNIT_BY_COUNTRY = {
     "Russia": [
         C_101CC,
         AJS37,
+        MiG_23MLD,
         F_5E_3,
         Su_25,
         Su_27,
@@ -251,19 +261,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,6 +290,7 @@ UNIT_BY_COUNTRY = {
     ],
 
     "USA": [
+        F_5E_3,
         F_15C,
         FA_18C_hornet,
         AJS37,
@@ -290,11 +302,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 +319,23 @@ 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,
+    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 +354,21 @@ 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",
+        PinpointStrike: "MK-82*8,AIM-9*2,AIM-7,FLIR Pod,Fuel",
+        AntishipStrike: "MK-82*8,AIM-9*2,AIM-7,FLIR Pod,Fuel",
+    },
+
+    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",
+    },
+
+    AJS37: {
+        CAS: "CAS (75 GUN): RB-75*2, AKAN",
     },
 
     AV8BNA: {
@@ -344,18 +377,21 @@ 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",
+        GroundAttack: "MK-82S Heavy Strike",
     },
 
     MiG_21Bis: {
-        "*": "Patrol, medium range",
+        CAP: "Patrol, medium range",
     }
 }
 
@@ -381,7 +417,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 +451,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"
@@ -432,6 +481,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,9 @@
 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 .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

@@ -1,22 +1,28 @@
-import math
-import random
+from game.operation.baseattack import BaseAttackOperation
 
-from dcs.task import *
-
-from game import db
-from game.operation.capture import CaptureOperation
-from userdata.debriefing import Debriefing
-
-from .event import Event
+from .event import *
+from game.db import assigned_units_from
 
 
-class CaptureEvent(Event):
+class BaseAttackEvent(Event):
     silent = True
     BONUS_BASE = 15
     STRENGTH_RECOVERY = 0.55
 
     def __str__(self):
-        return "Attack from {} to {}".format(self.from_cp, self.to_cp)
+        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[self.attacker_name].items() if db.unit_task(k) == PinpointStrike])
@@ -28,10 +34,11 @@ class CaptureEvent(Event):
             return not attackers_success
 
     def commit(self, debriefing: Debriefing):
-        super(CaptureEvent, self).commit(debriefing)
+        super(BaseAttackEvent, self).commit(debriefing)
         if self.is_successfull(debriefing):
             if self.from_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)
@@ -44,44 +51,44 @@ class CaptureEvent(Event):
         if not self.is_player_attacking and self.to_cp.captured:
             self.to_cp.captured = False
 
-    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 scrambled flights"
+
         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 = BaseAttackOperation(game=self.game,
+                                 attacker_name=self.attacker_name,
+                                 defender_name=self.defender_name,
+                                 from_cp=self.from_cp,
+                                 to_cp=self.to_cp)
 
-        op.setup(cas=cas,
-                 escort=escort,
+        op.setup(cas=assigned_units_from(cas),
+                 escort=assigned_units_from(escort),
+                 intercept=flights[CAP],
                  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)
+    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,
+                                 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,
+        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())
 

game/event/event.py

@@ -1,8 +1,15 @@
+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 game.db import assigned_units_from, unitdict_from
 
 from userdata.debriefing import Debriefing
 from userdata import persistency
@@ -14,6 +21,7 @@ class Event:
     silent = False
     informational = False
     is_awacs_enabled = False
+    ca_slots = 0
     operation = None  # type: Operation
     difficulty = 1  # type: int
     game = None  # type: Game
@@ -42,18 +50,36 @@ class Event:
     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 []
+
     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, flights: db.TaskForceDict):
+        assert False
+
+    def player_defending(self, flights: db.TaskForceDict):
+        assert False
+
     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,7 +88,7 @@ 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():
@@ -71,8 +97,22 @@ class Event:
             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
 

game/event/frontlineattack.py

@@ -0,0 +1,82 @@
+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
+
+    defenders = None  # type: db.ArmorDict
+
+    @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, PinpointStrike]
+        else:
+            return [CAP, PinpointStrike]
+
+    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[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(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 PinpointStrike in flights and len(flights) == 2, "Invalid flights"
+
+        self.defenders = self.to_cp.base.assemble_attack()
+
+        op = FrontlineAttackOperation(game=self.game,
+                                      attacker_name=self.attacker_name,
+                                      defender_name=self.defender_name,
+                                      from_cp=self.from_cp,
+                                      to_cp=self.to_cp)
+
+        armor = unitdict_from(flights[PinpointStrike])
+        op.setup(target=self.defenders,
+                 attackers=db.unitdict_restrict_count(armor, sum(self.defenders.values())),
+                 strikegroup=flights[CAS])
+
+        self.operation = op
+

game/event/frontlinepatrol.py

@@ -0,0 +1,76 @@
+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, PinpointStrike]
+
+    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 PinpointStrike in flights and len(flights) == 2, "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,
+                                      to_cp=self.to_cp)
+
+        defenders = self.to_cp.base.assemble_attack()
+        op.setup(cas=assigned_units_from(self.cas),
+                 escort=assigned_units_from(self.escort),
+                 interceptors=flights[CAP],
+                 armor_attackers=db.unitdict_restrict_count(db.unitdict_from(flights[PinpointStrike]), sum(defenders.values())),
+                 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
@@ -29,19 +37,19 @@ class InfantryTransportEvent(Event):
         else:
             self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
 
-    def player_attacking(self, transport: db.HeliDict, clients: db.HeliDict):
+    def player_attacking(self, flights: db.TaskForceDict):
+        assert Embarking in flights and len(flights) == 1, "Invalid flights"
+
         op = InfantryTransportOperation(
             game=self.game,
             attacker_name=self.attacker_name,
             defender_name=self.defender_name,
-            attacker_clients=clients,
-            defender_clients={},
             from_cp=self.from_cp,
             to_cp=self.to_cp
         )
 
         air_defense = db.find_unittype(AirDefence, self.defender_name)[0]
-        op.setup(transport=transport,
+        op.setup(transport=flights[Embarking],
                  aa={air_defense: 2})
 
         self.operation = op

game/event/insurgentattack.py

@@ -0,0 +1,64 @@
+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,
+                                      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):
@@ -20,11 +11,26 @@ class InterceptEvent(Event):
     transport_unit = None  # type: FlyingType
 
     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.from_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))
 
     def is_successfull(self, debriefing: Debriefing):
         units_destroyed = debriefing.destroyed_units[self.defender_name].get(self.transport_unit, 0)
@@ -53,8 +59,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 +71,19 @@ 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,
                                 to_cp=self.to_cp)
 
-        op.setup(escort=escort,
+        op.setup(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 +92,12 @@ 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,
                                 to_cp=self.to_cp)
 
-        op.setup(escort=escort,
+        op.setup(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):
@@ -19,12 +10,25 @@ class NavalInterceptEvent(Event):
     targets = None  # type: db.ShipDict
 
     def _targets_count(self) -> int:
-        from gen.conflictgen import IMPORTANCE_LOW, IMPORTANCE_HIGH
-        factor = (self.to_cp.importance - IMPORTANCE_LOW) * 10
+        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):
@@ -64,7 +68,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 +79,19 @@ 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,
             to_cp=self.to_cp
         )
 
-        op.setup(strikegroup=strikegroup,
+        op.setup(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 +100,13 @@ 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,
             to_cp=self.to_cp
         )
 
         strikegroup = self.from_cp.base.scramble_cas(self.game.settings.multiplier)
-        op.setup(strikegroup=strikegroup,
-                 interceptors=interceptors,
+        op.setup(strikegroup=assigned_units_from(strikegroup),
+                 interceptors=flights[CAP],
                  targets=self.targets)
 
         self.operation = op

game/event/strike.py

@@ -0,0 +1,61 @@
+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"
+
+    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]
+        else:
+            return [CAP]
+
+    @property
+    def ai_banned_tasks(self):
+        return [CAS]
+
+    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 == 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 len(flights) == 2, "Invalid flights"
+
+        op = StrikeOperation(
+            self.game,
+            attacker_name=self.attacker_name,
+            defender_name=self.defender_name,
+            from_cp=self.from_cp,
+            to_cp=self.to_cp
+        )
+
+        interceptors = self.to_cp.base.scramble_interceptors(self.game.settings.multiplier)
+        op.setup(strikegroup=flights[CAS],
+                 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
+* FrontlineCAPEvent - 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],
+    # events always present; only for the player
+    FrontlineAttackEvent: [100, 0],
+    FrontlinePatrolEvent: [100, 0],
+    StrikeEvent: [100, 0],
+
+    # events randomly present; only for the player
     InfantryTransportEvent: [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
 
@@ -103,45 +116,82 @@ class Game:
                                                   game=self))
                 break
 
-    def _generate_events(self):
-        enemy_cap_generated = False
-        enemy_generated_types = []
+    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:
+            # 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, self.enemy, player_cp, enemy_cp, self))
+
+    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, self.player, enemy_cp, player_cp, self))
+
+    def _generate_events(self):
         for player_cp, enemy_cp in self.theater.conflicts(True):
-            if player_cp.is_global or enemy_cp.is_global:
+            if 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]:
+                    # skip events requiring frontline
+                    if not Conflict.has_frontline_between(player_cp, enemy_cp):
                         continue
 
-                    if player_cp in self.ignored_cps:
+                if player_cp.is_global:
+                    # skip events requiring ground CP
+                    if event_class not in [InterceptEvent, StrikeEvent, NavalInterceptEvent]:
                         continue
 
-                    if enemy_cp.base.total_planes == 0:
-                        continue
+                if player_probability == 100 or self._roll(player_probability, player_cp.base.strength):
+                    self._generate_player_event(event_class, player_cp, 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 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 +211,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 +244,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,12 +258,16 @@ 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()
 

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

@@ -0,0 +1,58 @@
+from game.db import assigned_units_split
+
+from .operation import *
+
+
+MAX_DISTANCE_BETWEEN_GROUPS = 12000
+
+
+class FrontlineAttackOperation(Operation):
+    strikegroup = None  # type: db.AssignedUnitsDict
+    attackers = None  # type: db.ArmorDict
+    target = None  # type: db.ArmorDict
+
+    def setup(self,
+              target: db.ArmorDict,
+              attackers: db.ArmorDict,
+              strikegroup: db.AssignedUnitsDict):
+        self.strikegroup = strikegroup
+        self.target = target
+        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):
+        self.armorgen.generate_vec(self.attackers, self.target)
+
+        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.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,56 @@
+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):
+        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,21 @@
-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
+    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,
+              escort: db.AssignedUnitsDict,
               transport: db.PlaneDict,
               airdefense: db.AirDefenseDict,
-              interceptors: db.PlaneDict):
+              interceptors: db.AssignedUnitsDict):
         self.escort = escort
         self.transport = transport
         self.airdefense = airdefense
@@ -29,31 +28,33 @@ 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),
             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
+        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,18 +1,17 @@
-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
+    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,
+              strikegroup: db.AssignedUnitsDict,
+              interceptors: db.AssignedUnitsDict,
               targets: db.ShipDict):
         self.strikegroup = strikegroup
         self.interceptors = interceptors
@@ -24,30 +23,40 @@ 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),
             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()
+        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,50 @@ 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
 
     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,
                  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.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
+
+    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.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,8 +74,13 @@ 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:
@@ -76,22 +90,61 @@ class Operation:
             self.attackers_starting_position = self.from_cp.at
             self.defenders_starting_position = self.to_cp.at
 
+    def prepare_carriers(self, for_units: db.UnitsDict):
+        for global_cp in self.game.theater.controlpoints:
+            if not global_cp.is_global:
+                continue
+
+            ship = self.shipgen.generate_carrier(for_units=[t for t, c in for_units.items() if c > 0],
+                                                 country=self.game.player,
+                                                 at=global_cp.at)
+
+            if global_cp == self.from_cp and not self.is_quick:
+                self.attackers_starting_position = ship
+
     def 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 []
+        # main frequencies
+        self.briefinggen.append_frequency("Flight", "251 MHz AM")
+        if self.conflict.from_cp.is_global or self.conflict.to_cp.is_global:
+            self.briefinggen.append_frequency("Carrier", "20X/ICLS CHAN1")
 
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return True
+        # briefing
+        self.briefinggen.generate()

game/operation/strike.py

@@ -0,0 +1,79 @@
+from game.db import assigned_units_split
+
+from .operation import *
+
+
+class StrikeOperation(Operation):
+    strikegroup = 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,
+              escort: db.AssignedUnitsDict,
+              interceptors: db.AssignedUnitsDict):
+        self.strikegroup = strikegroup
+        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]]
+        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])
+            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)
+
+        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,11 @@
 class Settings:
     player_skill = "Good"
     enemy_skill = "Average"
-    only_player_takeoff = False
+    enemy_vehicle_skill = "Average"
+    only_player_takeoff = True
     night_disabled = False
+
     multiplier = 1
     sams = True
+    cold_start = False
+    version = None

gen/__init__.py

@@ -1,12 +1,14 @@
 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 . 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,7 +16,7 @@ SPREAD_DISTANCE_FACTOR = 1, 2
 ESCORT_ENGAGEMENT_MAX_DIST = 100000
 WORKAROUND_WAYP_DIST = 1000
 
-WARM_START_HELI_AIRSPEED = 200
+WARM_START_HELI_AIRSPEED = 120
 WARM_START_HELI_ALT = 1000
 
 WARM_START_ALTITUDE = 3000
@@ -22,6 +24,7 @@ WARM_START_AIRSPEED = 550
 
 INTERCEPTION_ALT = 3000
 INTERCEPTION_AIRSPEED = 1000
+BARCAP_RACETRACK_DISTANCE = 20000
 
 ATTACK_CIRCLE_ALT = 5000
 ATTACK_CIRCLE_DURATION = 15
@@ -35,16 +38,23 @@ TRANSPORT_LANDING_ALT = 1000
 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]),
@@ -67,18 +77,22 @@ class AircraftConflictGenerator:
                 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 +113,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,15 +138,17 @@ 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))
 
+        logging.info("airgen: {} for {} at {} at {}".format(unit_type, side.id, alt, speed))
         return self.m.flight_group(
             country=side,
             name=name,
@@ -135,29 +158,30 @@ 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:
+    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)
+                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):
@@ -174,14 +198,16 @@ class AircraftConflictGenerator:
             assert False
 
     def _rtb_for(self, group: FlyingGroup, cp: ControlPoint, at: db.StartingPosition = None):
-        group.add_waypoint(cp.position, RTB_ALTITUDE)
+        if not at:
+            at = cp.at
 
-        if isinstance(cp.at, Point):
-            pass
-        elif isinstance(cp.at, ShipGroup):
-            pass
-        elif issubclass(cp.at, Airport):
-            group.land_at(cp.at)
+        if isinstance(at, Point):
+            group.add_waypoint(at, RTB_ALTITUDE)
+        elif isinstance(at, Group):
+            group.add_waypoint(at.position, RTB_ALTITUDE)
+        elif issubclass(at, Airport):
+            group.add_waypoint(at.position, RTB_ALTITUDE)
+            group.land_at(at)
 
     def _at_position(self, at) -> Point:
         if isinstance(at, Point):
@@ -205,10 +231,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,7 +238,7 @@ 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))
@@ -229,8 +251,8 @@ class AircraftConflictGenerator:
             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(
@@ -242,13 +264,68 @@ class AircraftConflictGenerator:
                     at=at and at or self._group_point(self.conflict.air_attackers_location))
 
             waypoint = group.add_waypoint(self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
+            if self.conflict.is_vector:
+                group.add_waypoint(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))
+                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_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 = group.add_waypoint(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)
+                group.add_waypoint(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(
@@ -265,10 +342,11 @@ class AircraftConflictGenerator:
 
             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 +356,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,
@@ -305,8 +383,50 @@ class AircraftConflictGenerator:
             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 = group.add_waypoint(self.conflict.position, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+            if self.conflict.is_vector:
+                group.add_waypoint(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 = group.add_waypoint(self.conflict.position, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+            if self.conflict.is_vector:
+                group.add_waypoint(self.conflict.tail, WARM_START_ALTITUDE, WARM_START_AIRSPEED)
+            else:
+                heading = group.position.heading_between_point(self.conflict.position)
+                waypoint = group.add_waypoint(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(
@@ -318,8 +438,8 @@ class AircraftConflictGenerator:
                 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)))
-
+            if escort:
+                self.escort_targets.append((group, group.points.index(waypoint)))
             group.task = Transport.name
             group.land_at(destination)
 
@@ -334,13 +454,14 @@ class AircraftConflictGenerator:
                 at=at and at or self._group_point(self.conflict.air_attackers_location))
 
             group.task = CAP.name
-
-            heading = group.position.heading_between_point(self.conflict.position)
-            initial_wayp = group.add_waypoint(group.position.point_from_heading(heading, WORKAROUND_WAYP_DIST), INTERCEPTION_ALT, INTERCEPTION_AIRSPEED)
-            initial_wayp.tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
+            group.points[0].tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
 
             wayp = group.add_waypoint(self.conflict.position, WARM_START_ALTITUDE, INTERCEPTION_AIRSPEED)
             wayp.tasks.append(EngageTargets(max_distance=INTERCEPT_MAX_DISTANCE))
+            
+            if self.conflict.is_vector:
+                group.add_waypoint(self.conflict.tail, CAS_ALTITUDE, WARM_START_ALTITUDE)
+
             self._setup_group(group, CAP, client_count)
             self._rtb_for(group, self.conflict.from_cp, at)
 

gen/airsupportgen.py

@@ -0,0 +1,64 @@
+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))
+
+        if is_awacs_enabled:
+            awacs_unit = 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=awacs_unit,
+                altitude=AWACS_ALT,
+                airport=None,
+                position=self.conflict.position.random_point_within(AWACS_DISTANCE, AWACS_DISTANCE),
+                frequency=133,
+                start_type=StartType.Warm,
+            )

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 = 1500
+
 
 class ArmorConflictGenerator:
     def __init__(self, mission: Mission, conflict: Conflict):
@@ -25,8 +36,9 @@ 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):
         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),
@@ -34,24 +46,68 @@ class ArmorConflictGenerator:
                     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))
+
+            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))
             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_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 = 4000
+
 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,28 +109,117 @@ 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)
+        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)
 
-        print("Didn't find ground position!")
+
+    @classmethod
+    def frontline_vector(cls, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater) -> typing.Optional[typing.Tuple[Point, int, int]]:
+        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
+
+    @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)
+
+        logging.info("Didn't find ground position!")
         return None
 
     @classmethod
@@ -125,12 +229,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,
@@ -145,6 +249,33 @@ class Conflict:
             air_defenders_location=position.point_from_heading(_opposite_heading(attack_raw_heading), CAPTURE_AIR_DEFENDERS_DISTANCE)
         )
 
+    @classmethod
+    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_conflict(cls, attacker: Country, defender: Country, from_cp: ControlPoint, to_cp: ControlPoint, theater: ConflictTheater):
         raw_distance = from_cp.position.distance_to_point(to_cp.position) * 1.5
@@ -170,7 +301,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 +320,45 @@ 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 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=position,
+            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 +369,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,
@@ -261,10 +412,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,7 +19,11 @@ 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,
@@ -28,11 +33,10 @@ RANDOM_TIME = {
 }
 
 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/groundobjectsgen.py

@@ -0,0 +1,91 @@
+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
+
+        position = self.conflict.find_ground_position(center.point_from_heading(heading, FARP_FRONTLINE_DISTANCE), heading)
+        if not position:
+            return
+
+        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,16 +16,27 @@ 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 = []
         for unit_type, unit_count in units.items():
+            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),

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,16 @@ 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)
+        """
 
-        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 +72,53 @@ 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)
+                        if player_cp.position.distance_to_point(group.position) > PUSH_TRIGGER_SIZE * 3:
+                            continue
 
-                        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)
+                        push_by_trigger.append(group)
 
-                        plane_group.points.remove(w1)
-                        plane_group.points.remove(w2)
+                        if not group.units[0].is_human():
+                            regroup_heading = self.conflict.to_cp.position.heading_between_point(player_cp.position)
 
-                        plane_group.points.insert(1, w2)
-                        plane_group.points.insert(1, w1)
+                            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)
 
-                        w1.tasks.append(Silence(True))
+                            group.points.remove(w1)
+                            group.points.remove(w2)
 
-                        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))
+                            group.points.insert(1, w2)
+                            group.points.insert(1, w1)
 
-                        plane_group.add_trigger_action(SwitchWaypoint(to_waypoint=4))
-                        push_by_trigger.append(plane_group)
+                            w1.tasks.append(Silence(True))
+
+                            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 +133,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,12 +143,12 @@ 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"
 
@@ -148,6 +160,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

@@ -62,7 +62,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 +98,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():

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,14 @@
+import os
 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 +29,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,52 @@
+import os
+
+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
+
+    archieve = ZipFile(path, "w")
+    archieve.writestr("start.bat", "py.exe __init__.py \"%UserProfile%\\Saved Games\" \"{}\"".format(VERSION))
+    _zip_dir(archieve, ".")
+    os.chdir("submodules\\dcs")
+    _zip_dir(archieve, "dcs")
+
+
+_mk_archieve()

start.bat

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

theater/__init__.py

@@ -1,3 +1,3 @@
 from .controlpoint import *
 from .conflicttheater import *
-from .base import *
+from .base import *

theater/base.py

@@ -1,18 +1,21 @@
+import logging
 import typing
 import math
 import itertools
 
-from game import db
-from theater.controlpoint import ControlPoint
-
 from dcs.planes import *
 from dcs.vehicles import *
 from dcs.task import *
 
+from game import db
+
 STRENGTH_AA_ASSEMBLE_MIN = 0.2
-PLANES_SCRAMBLE_MIN_BASE = 4
+PLANES_SCRAMBLE_MIN_BASE = 2
 PLANES_SCRAMBLE_MAX_BASE = 8
-PLANES_SCRAMBLE_FACTOR = 0.6
+PLANES_SCRAMBLE_FACTOR = 0.3
+
+BASE_MAX_STRENGTH = 1
+BASE_MIN_STRENGTH = 0
 
 
 class Base:
@@ -53,7 +56,7 @@ class Base:
 
     def _find_best_unit(self, dict, for_type: Task, count: int) -> typing.Dict:
         if count <= 0:
-            print("{}: no units for {}".format(self, for_type))
+            logging.info("{}: no units for {}".format(self, for_type))
             return {}
 
         sorted_units = [key for key in dict.keys() if key in db.UNIT_BY_TASK[for_type]]
@@ -74,7 +77,7 @@ class Base:
             assert result_unit_count > 0
             result[unit_type] = result.get(unit_type, 0) + result_unit_count
 
-        print("{} for {} ({}): {}".format(self, for_type, count, result))
+        logging.info("{} for {} ({}): {}".format(self, for_type, count, result))
         return result
 
     def _find_best_planes(self, for_type: Task, count: int) -> typing.Dict[PlaneType, int]:
@@ -124,9 +127,11 @@ class Base:
             elif unit_type in self.aa:
                 target_array = self.aa
             else:
+                print("Base didn't find event type {}".format(unit_type))
                 continue
 
             if unit_type not in target_array:
+                print("Base didn't find event type {}".format(unit_type))
                 continue
                 
             target_array[unit_type] = max(target_array[unit_type] - count, 0)
@@ -135,10 +140,10 @@ class Base:
 
     def affect_strength(self, amount):
         self.strength += amount
-        if self.strength > 1:
-            self.strength = 1
-        elif self.strength < 0:
-            self.strength = 0.001
+        if self.strength > BASE_MAX_STRENGTH:
+            self.strength = BASE_MAX_STRENGTH
+        elif self.strength <= 0:
+            self.strength = BASE_MIN_STRENGTH
 
     def scramble_count(self, multiplier: float, task: Task = None) -> int:
         if task:
@@ -150,7 +155,7 @@ class Base:
         return min(min(max(count, PLANES_SCRAMBLE_MIN_BASE), int(PLANES_SCRAMBLE_MAX_BASE * multiplier)), count)
 
     def assemble_count(self):
-        return int(self.total_armor * min(self.strength + 0.5, 1))
+        return int(self.total_armor * 0.5)
 
     def assemble_aa_count(self) -> int:
         if self.strength > STRENGTH_AA_ASSEMBLE_MIN:
@@ -167,11 +172,12 @@ class Base:
     def scramble_interceptors(self, multiplier: float) -> typing.Dict[PlaneType, int]:
         return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
 
-    def assemble_cap(self) -> typing.Dict[Armor, int]:
+    def assemble_attack(self) -> typing.Dict[Armor, int]:
         return self._find_best_armor(PinpointStrike, self.assemble_count())
 
     def assemble_defense(self) -> typing.Dict[Armor, int]:
-        return self._find_best_armor(PinpointStrike, self.assemble_count())
+        count = int(self.total_armor * min(self.strength + 0.5, 1))
+        return self._find_best_armor(PinpointStrike, count)
 
     def assemble_aa(self, count=None) -> typing.Dict[AirDefence, int]:
         return self._find_best_unit(self.aa, AirDefence, count and min(count, self.total_aa) or self.assemble_aa_count())

theater/caucasus.py

@@ -11,13 +11,13 @@ from .base import *
 class CaucasusTheater(ConflictTheater):
     terrain = caucasus.Caucasus()
     overview_image = "caumap.gif"
-    reference_points = {(-317948.32727306, 635639.37385346): (282.5, 319),
-                        (-355692.3067714, 617269.96285781): (269, 352), }
-    landmap_poly = load_poly("resources\\caulandmap.p")
+    reference_points = {(-317948.32727306, 635639.37385346): (278.5, 319),
+                        (-355692.3067714, 617269.96285781): (263, 352), }
+    landmap = load_landmap("resources\\caulandmap.p")
     daytime_map = {
         "dawn": (6, 9),
         "day": (9, 18),
-        "dusk": (18, 21),
+        "dusk": (18, 20),
         "night": (0, 5),
     }
 
@@ -33,7 +33,6 @@ class CaucasusTheater(ConflictTheater):
     gelendzhik = ControlPoint.from_airport(caucasus.Gelendzhik, COAST_DR_E, SIZE_BIG, 1.1)
     maykop = ControlPoint.from_airport(caucasus.Maykop_Khanskaya, LAND, SIZE_LARGE, IMPORTANCE_HIGH)
     krasnodar = ControlPoint.from_airport(caucasus.Krasnodar_Center, LAND, SIZE_LARGE, IMPORTANCE_HIGH)
-    novorossiysk = ControlPoint.from_airport(caucasus.Novorossiysk, COAST_DR_E, SIZE_BIG, 1.2)
     krymsk = ControlPoint.from_airport(caucasus.Krymsk, LAND, SIZE_LARGE, 1.2)
     anapa = ControlPoint.from_airport(caucasus.Anapa_Vityazevo, LAND, SIZE_LARGE, IMPORTANCE_HIGH)
 
@@ -44,9 +43,12 @@ class CaucasusTheater(ConflictTheater):
 
     carrier_1 = ControlPoint.carrier("Carrier", mapping.Point(-305810.6875, 406399.1875))
 
-    def __init__(self):
+    def __init__(self, load_ground_objects=True):
         super(CaucasusTheater, self).__init__()
 
+        self.soganlug.frontline_offset = 0.5
+        self.soganlug.base.strength = 1
+
         self.add_controlpoint(self.soganlug, connected_to=[self.kutaisi, self.beslan])
         self.add_controlpoint(self.beslan, connected_to=[self.soganlug, self.mozdok, self.nalchik])
         self.add_controlpoint(self.nalchik, connected_to=[self.beslan, self.mozdok, self.mineralnye])
@@ -74,6 +76,6 @@ class CaucasusTheater(ConflictTheater):
         self.soganlug.captured = True
 
     def add_controlpoint(self, point: ControlPoint, connected_to: typing.Collection[ControlPoint] = []):
-        point.name = " ".join(re.split(r" |-", point.name)[:1])
+        point.name = " ".join(re.split(r"[ -]", point.name)[:1])
 
-        super(CaucasusTheater, self).add_controlpoint(point, connected_to=connected_to)
+        super(CaucasusTheater, self).add_controlpoint(point, connected_to=connected_to)

theater/conflicttheater.py

@@ -4,8 +4,9 @@ import itertools
 import dcs
 from dcs.mapping import Point
 
-from .landmap import ray_tracing
+from .landmap import Landmap, poly_contains
 from .controlpoint import ControlPoint
+from .theatergroundobject import TheaterGroundObject
 
 SIZE_TINY = 150
 SIZE_SMALL = 600
@@ -17,6 +18,8 @@ IMPORTANCE_LOW = 1
 IMPORTANCE_MEDIUM = 1.2
 IMPORTANCE_HIGH = 1.4
 
+GLOBAL_CP_CONFLICT_DISTANCE_MIN = 340000
+
 """
 ALL_RADIALS = [0, 45, 90, 135, 180, 225, 270, 315, ]
 COAST_NS_E = [45, 90, 135, ]
@@ -48,9 +51,10 @@ COAST_DR_W = [135, 180, 225, 315]
 class ConflictTheater:
     terrain = None  # type: dcs.terrain.Terrain
     controlpoints = None  # type: typing.Collection[ControlPoint]
+
     reference_points = None  # type: typing.Dict
     overview_image = None  # type: str
-    landmap_poly = None
+    landmap = None  # type: landmap.Landmap
     daytime_map = None  # type: typing.Dict[str, typing.Tuple[int, int]]
 
     def __init__(self):
@@ -62,15 +66,33 @@ class ConflictTheater:
 
         self.controlpoints.append(point)
 
+    def is_in_sea(self, point: Point) -> bool:
+        if not self.landmap:
+            return False
+
+        for inclusion_zone in self.landmap[0]:
+            if poly_contains(point.x, point.y, inclusion_zone):
+                return False
+
+        return True
+
     def is_on_land(self, point: Point) -> bool:
-        if not self.landmap_poly:
+        if not self.landmap:
             return True
 
-        for poly in self.landmap_poly:
-            if ray_tracing(point.x, point.y, poly):
-                return True
+        is_point_included = False
+        for inclusion_zone in self.landmap[0]:
+            if poly_contains(point.x, point.y, inclusion_zone):
+                is_point_included = True
 
-        return False
+        if not is_point_included:
+            return False
+
+        for exclusion_zone in self.landmap[1]:
+            if poly_contains(point.x, point.y, exclusion_zone):
+                return False
+
+        return True
 
     def player_points(self) -> typing.Collection[ControlPoint]:
         return [point for point in self.controlpoints if point.captured]
@@ -80,5 +102,9 @@ class ConflictTheater:
             for connected_point in [x for x in cp.connected_points if x.captured != from_player]:
                 yield (cp, connected_point)
 
+                for global_cp in [x for x in self.controlpoints if x.is_global and x.captured == from_player]:
+                    if global_cp.position.distance_to_point(connected_point.position) < GLOBAL_CP_CONFLICT_DISTANCE_MIN:
+                        yield (global_cp, connected_point)
+
     def enemy_points(self) -> typing.Collection[ControlPoint]:
         return [point for point in self.controlpoints if not point.captured]

theater/controlpoint.py

@@ -5,38 +5,51 @@ from dcs.mapping import *
 from dcs.country import *
 from dcs.terrain import Airport
 
+from .theatergroundobject import TheaterGroundObject
+
 
 class ControlPoint:
-    connected_points = []  # type: typing.List[ControlPoint]
+    id = 0
     position = None  # type: Point
-    captured = False
-    base: None  # type: theater.base.Base
-    at: None  # type: db.StartPosition
+    name = None  # type: str
+    full_name = None  # type: str
+    base = None  # type: theater.base.Base
+    at = None  # type: db.StartPosition
 
-    def __init__(self, name: str, position: Point, at, radials: typing.Collection[int], size: int, importance: int):
+    connected_points = None  # type: typing.List[ControlPoint]
+    ground_objects = None  # type: typing.List[TheaterGroundObject]
+
+    captured = False
+    has_frontline = True
+    frontline_offset = 0.0
+
+    def __init__(self, id: int, name: str, position: Point, at, radials: typing.Collection[int], size: int, importance: float, has_frontline=True):
         import theater.base
 
+        self.id = id
         self.name = " ".join(re.split(r" |-", name)[:2])
         self.full_name = name
         self.position = position
         self.at = at
+        self.ground_objects = []
 
         self.size = size
         self.importance = importance
         self.captured = False
+        self.has_frontline = has_frontline
         self.radials = radials
         self.connected_points = []
         self.base = theater.base.Base()
 
     @classmethod
-    def from_airport(cls, airport: Airport, radials: typing.Collection[int], size: int, importance: int):
+    def from_airport(cls, airport: Airport, radials: typing.Collection[int], size: int, importance: float, has_frontline=True):
         assert airport
-        return cls(airport.name, airport.position, airport, radials, size, importance)
+        return cls(airport.id, airport.name, airport.position, airport, radials, size, importance, has_frontline)
 
     @classmethod
     def carrier(cls, name: str, at: Point):
         import theater.conflicttheater
-        return cls(name, at, at, theater.conflicttheater.LAND, theater.conflicttheater.SIZE_SMALL, 1)
+        return cls(0, name, at, at, theater.conflicttheater.LAND, theater.conflicttheater.SIZE_SMALL, 1, has_frontline=False)
 
     def __str__(self):
         return self.name

theater/landmap.py

@@ -1,7 +1,11 @@
 import pickle
+import typing
+
+Zone = typing.Collection[typing.Tuple[float, float]]
+Landmap = typing.Tuple[typing.Collection[Zone], typing.Collection[Zone]]
 
 
-def load_poly(filename: str):
+def load_landmap(filename: str) -> Landmap:
     try:
         with open(filename, "rb") as f:
             return pickle.load(f)
@@ -9,7 +13,7 @@ def load_poly(filename: str):
         return None
 
 
-def ray_tracing(x, y, poly):
+def poly_contains(x, y, poly):
     n = len(poly)
     inside = False
     xints = 0.0
@@ -25,3 +29,11 @@ def ray_tracing(x, y, poly):
                         inside = not inside
         p1x, p1y = p2x, p2y
     return inside
+
+def poly_centroid(poly) -> typing.Tuple[float, float]:
+    x_list = [vertex[0] for vertex in poly]
+    y_list = [vertex[1] for vertex in poly]
+    x = sum(x_list) / len(poly)
+    y = sum(y_list) / len(poly)
+    return (x, y)
+

theater/nevada.py

@@ -1,6 +1,7 @@
 from dcs.terrain import nevada
 from dcs import mapping
 
+from .landmap import *
 from .conflicttheater import *
 from .base import *
 
@@ -10,10 +11,11 @@ class NevadaTheater(ConflictTheater):
     overview_image = "nevada.gif"
     reference_points = {(nevada.Mina_Airport_3Q0.position.x, nevada.Mina_Airport_3Q0.position.y): (45, -360),
                         (nevada.Laughlin_Airport.position.x, nevada.Laughlin_Airport.position.y): (440, 80), }
+    landmap = load_landmap("resources\\nev_landmap.p")
     daytime_map = {
         "dawn": (4, 6),
         "day": (6, 17),
-        "dusk": (17, 19),
+        "dusk": (17, 18),
         "night": (0, 5),
     }
 

theater/persiangulf.py

@@ -3,15 +3,15 @@ from dcs import mapping
 
 from .conflicttheater import *
 from .base import *
-from .landmap import load_poly
+from .landmap import load_landmap
 
 
 class PersianGulfTheater(ConflictTheater):
     terrain = dcs.terrain.PersianGulf()
     overview_image = "persiangulf.gif"
-    reference_points = {(persiangulf.Sir_Abu_Nuayr.position.x, persiangulf.Sir_Abu_Nuayr.position.y): (351, 115),
-                        (persiangulf.Sirri_Island.position.x, persiangulf.Sirri_Island.position.y): (389, 22), }
-    landmap_poly = load_poly("resources\\gulflandmap.p")
+    reference_points = {(persiangulf.Sir_Abu_Nuayr.position.x, persiangulf.Sir_Abu_Nuayr.position.y): (321, 145),
+                        (persiangulf.Sirri_Island.position.x, persiangulf.Sirri_Island.position.y): (347, 82), }
+    landmap = load_landmap("resources\\gulflandmap.p")
     daytime_map = {
         "dawn": (6, 8),
         "day": (8, 16),
@@ -21,31 +21,38 @@ class PersianGulfTheater(ConflictTheater):
 
     al_dhafra = ControlPoint.from_airport(persiangulf.Al_Dhafra_AB, LAND, SIZE_BIG, IMPORTANCE_LOW)
     al_maktoum = ControlPoint.from_airport(persiangulf.Al_Maktoum_Intl, LAND, SIZE_BIG, IMPORTANCE_LOW)
-    al_minhad = ControlPoint.from_airport(persiangulf.Al_Minhad_AB, LAND, SIZE_REGULAR, IMPORTANCE_LOW)
-    sir_abu_nuayr = ControlPoint.from_airport(persiangulf.Sir_Abu_Nuayr, [0, 330], SIZE_SMALL, 1.1)
+    al_minhad = ControlPoint.from_airport(persiangulf.Al_Minhad_AB, LAND, SIZE_REGULAR, 1.1)
+    sir_abu_nuayr = ControlPoint.from_airport(persiangulf.Sir_Abu_Nuayr, [0, 330], SIZE_SMALL, 1.1, has_frontline=False)
 
-    dubai = ControlPoint.from_airport(persiangulf.Dubai_Intl, COAST_DL_E, SIZE_LARGE, 1.3)
-    sharjah = ControlPoint.from_airport(persiangulf.Sharjah_Intl, LAND, SIZE_BIG, 1.2)
-    fujairah = ControlPoint.from_airport(persiangulf.Fujairah_Intl, COAST_V_W, SIZE_REGULAR, 1.3)
-    khasab = ControlPoint.from_airport(persiangulf.Khasab, LAND, SIZE_SMALL, 1.3)
+    dubai = ControlPoint.from_airport(persiangulf.Dubai_Intl, COAST_DL_E, SIZE_LARGE, IMPORTANCE_MEDIUM)
+    sharjah = ControlPoint.from_airport(persiangulf.Sharjah_Intl, LAND, SIZE_BIG, 1.0)
+    fujairah = ControlPoint.from_airport(persiangulf.Fujairah_Intl, COAST_V_W, SIZE_REGULAR, 1.0)
+    khasab = ControlPoint.from_airport(persiangulf.Khasab, LAND, SIZE_SMALL, IMPORTANCE_MEDIUM)
 
-    sirri = ControlPoint.from_airport(persiangulf.Sirri_Island, COAST_DL_W, SIZE_REGULAR, 1.2)
-    abu_musa = ControlPoint.from_airport(persiangulf.Abu_Musa_Island_Airport, LAND, SIZE_SMALL, 1.0)
-    tunb_island = ControlPoint.from_airport(persiangulf.Tunb_Island_AFB, [0, 270, 330], SIZE_REGULAR, 1.1)
-    tunb_kochak = ControlPoint.from_airport(persiangulf.Tunb_Kochak, [135, 180], SIZE_SMALL, IMPORTANCE_HIGH)
+    sirri = ControlPoint.from_airport(persiangulf.Sirri_Island, COAST_DL_W, SIZE_REGULAR, IMPORTANCE_LOW, has_frontline=False)
+    abu_musa = ControlPoint.from_airport(persiangulf.Abu_Musa_Island_Airport, LAND, SIZE_SMALL, IMPORTANCE_MEDIUM, has_frontline=False)
+    tunb_island = ControlPoint.from_airport(persiangulf.Tunb_Island_AFB, [0, 270, 330], SIZE_SMALL, IMPORTANCE_MEDIUM, has_frontline=False)
+    tunb_kochak = ControlPoint.from_airport(persiangulf.Tunb_Kochak, [135, 180], SIZE_SMALL, 1.1, has_frontline=False)
 
     bandar_lengeh = ControlPoint.from_airport(persiangulf.Bandar_Lengeh, [270, 315, 0, 45], SIZE_SMALL, IMPORTANCE_HIGH)
-    qeshm = ControlPoint.from_airport(persiangulf.Qeshm_Island, [270, 315, 0, 45, 90, 135, 180], SIZE_SMALL, 1.1)
+    qeshm = ControlPoint.from_airport(persiangulf.Qeshm_Island, [270, 315, 0, 45, 90, 135, 180], SIZE_SMALL, 1.1, has_frontline=False)
 
     havadarya = ControlPoint.from_airport(persiangulf.Havadarya, COAST_DL_W, SIZE_REGULAR, IMPORTANCE_HIGH)
     bandar_abbas = ControlPoint.from_airport(persiangulf.Bandar_Abbas_Intl, LAND, SIZE_BIG, IMPORTANCE_HIGH)
     lar = ControlPoint.from_airport(persiangulf.Lar_Airbase, LAND, SIZE_REGULAR, IMPORTANCE_HIGH)
+    shiraz = ControlPoint.from_airport(persiangulf.Shiraz_International_Airport, LAND, SIZE_BIG, IMPORTANCE_HIGH)
+    kerman = ControlPoint.from_airport(persiangulf.Kerman_Airport, LAND, SIZE_BIG, IMPORTANCE_HIGH)
 
-    west_carrier = ControlPoint.carrier("East carrier", Point(-100531.972946, 60939.275818))
+    west_carrier = ControlPoint.carrier("West carrier", Point(-69043.813952358, -159916.65947136))
+    east_carrier = ControlPoint.carrier("East carrier", Point(59514.324335475, 28165.517980635))
 
     def __init__(self):
         super(PersianGulfTheater, self).__init__()
 
+        self.add_controlpoint(self.shiraz, connected_to=[self.lar, self.kerman])
+        self.add_controlpoint(self.kerman, connected_to=[self.lar, self.shiraz])
+        self.add_controlpoint(self.lar, connected_to=[self.bandar_lengeh, self.qeshm, self.havadarya, self.shiraz, self.kerman])
+
         self.add_controlpoint(self.al_dhafra, connected_to=[self.sir_abu_nuayr, self.al_maktoum])
         self.add_controlpoint(self.al_maktoum, connected_to=[self.al_dhafra, self.al_minhad, self.sir_abu_nuayr])
         self.add_controlpoint(self.al_minhad, connected_to=[self.al_maktoum, self.dubai])
@@ -61,23 +68,13 @@ class PersianGulfTheater(ConflictTheater):
 
         self.add_controlpoint(self.tunb_island, connected_to=[self.khasab, self.qeshm, self.tunb_kochak])
         self.add_controlpoint(self.bandar_lengeh, connected_to=[self.tunb_island, self.lar, self.qeshm])
-        self.add_controlpoint(self.qeshm, connected_to=[self.bandar_lengeh, self.havadarya, self.tunb_island])
+        self.add_controlpoint(self.qeshm, connected_to=[self.bandar_lengeh, self.havadarya, self.tunb_island, self.lar])
         self.add_controlpoint(self.havadarya, connected_to=[self.lar, self.qeshm, self.bandar_abbas])
         self.add_controlpoint(self.bandar_abbas, connected_to=[self.havadarya])
-        self.add_controlpoint(self.lar, connected_to=[self.bandar_lengeh, self.qeshm, self.havadarya])
 
         self.add_controlpoint(self.west_carrier)
+        self.add_controlpoint(self.east_carrier)
 
         self.west_carrier.captured = True
+        self.east_carrier.captured = True
         self.al_dhafra.captured = True
-
-        """
-        Mid game: 
-        self.al_maktoum.captured = True
-        self.al_minhad.captured = True
-        self.dubai.captured = True
-        self.sharjah.captured = True
-        self.fujairah.captured = True
-        self.khasab.captured = True
-        self.sir_abu_nuayr.captured = True
-        """

theater/start_generator.py

@@ -1,4 +1,8 @@
 import math
+import pickle
+import random
+import typing
+import logging
 
 from theater.base import *
 from theater.conflicttheater import *
@@ -15,7 +19,7 @@ COUNT_BY_TASK = {
 }
 
 
-def generate_initial(theater: ConflictTheater, enemy: str, sams: bool, multiplier: float):
+def generate_inital_units(theater: ConflictTheater, enemy: str, sams: bool, multiplier: float):
     for cp in theater.enemy_points():
         if cp.captured:
             continue
@@ -35,5 +39,73 @@ def generate_initial(theater: ConflictTheater, enemy: str, sams: bool, multiplie
             count = max(COUNT_BY_TASK[task] * multiplier * (1+count_log), 1)
             count_per_type = max(int(float(count) / len(unittypes)), 1)
             for unit_type in unittypes:
-                print("{} - {} {}".format(cp.name, db.unit_type_name(unit_type), count_per_type))
+                logging.info("{} - {} {}".format(cp.name, db.unit_type_name(unit_type), count_per_type))
                 cp.base.commision_units({unit_type: count_per_type})
+
+
+def generate_groundobjects(theater: ConflictTheater):
+    with open("resources/groundobject_templates.p", "rb") as f:
+        tpls = pickle.load(f)
+
+    def find_location(on_ground, near, theater, min, max) -> typing.Optional[Point]:
+        point = None
+        for _ in range(1000):
+            p = near.random_point_within(max, min)
+            if on_ground and theater.is_on_land(p):
+                point = p
+            elif not on_ground and theater.is_in_sea(p):
+                point = p
+
+            if point:
+                for angle in range(0, 360, 45):
+                    p = point.point_from_heading(angle, 2500)
+                    if on_ground and not theater.is_on_land(p):
+                        point = None
+                        break
+                    elif not on_ground and not theater.is_in_sea(p):
+                        point = None
+                        break
+
+            if point:
+                return point
+
+        return None
+
+    group_id = 0
+    for cp in theater.enemy_points():
+        for _ in range(0, random.randrange(2, 4)):
+            available_categories = list(tpls) + ["aa", "aa"]
+            tpl_category = random.choice(available_categories)
+
+            tpl = random.choice(list(tpls[tpl_category].values()))
+
+            point = find_location(tpl_category != "oil", cp.position, theater, 15000, 80000)
+
+            if point is None:
+                print("Couldn't find point for {}".format(cp))
+                continue
+
+            """
+            dist = point.distance_to_point(cp.position) - 15000
+            for another_cp in theater.enemy_points():
+                if another_cp.position.distance_to_point(point) < dist:
+                    cp = another_cp
+            """
+
+            group_id += 1
+            object_id = 0
+
+            logging.info("generated {} for {}".format(tpl_category, cp))
+            for object in tpl:
+                object_id += 1
+
+                g = TheaterGroundObject()
+                g.group_id = group_id
+                g.object_id = object_id
+                g.cp_id = cp.id
+
+                g.dcs_identifier = object["type"]
+                g.heading = object["heading"]
+                g.position = Point(point.x + object["offset"].x, point.y + object["offset"].y)
+
+                cp.ground_objects.append(g)

theater/theatergroundobject.py

@@ -0,0 +1,81 @@
+import typing
+
+from dcs.mapping import Point
+from dcs.statics import *
+
+NAME_BY_CATEGORY = {
+    "power": "Power plant",
+    "ammo": "Ammo depot",
+    "fuel": "Fuel depot",
+    "aa": "AA Defense Site",
+    "warehouse": "Warehouse",
+    "farp": "FARP",
+    "fob": "FOB",
+    "factory": "Factory",
+    "comms": "Comms. tower",
+    "oil": "Oil platform"
+}
+
+ABBREV_NAME = {
+    "power": "PLANT",
+    "ammo": "AMMO",
+    "fuel": "FUEL",
+    "aa": "AA",
+    "warehouse": "WARE",
+    "farp": "FARP",
+    "fob": "FOB",
+    "factory": "FACTORY",
+    "comms": "COMMST",
+    "oil": "OILP"
+}
+
+
+CATEGORY_MAP = {
+    "aa": ["AA"],
+    "power": ["Workshop A", "Electric power box", "Garage small A"],
+    "warehouse": ["Warehouse", "Hangar A"],
+    "fuel": ["Tank", "Tank 2", "Tank 3", "Fuel tank"],
+    "ammo": [".Ammunition depot", "Hangar B"],
+    "farp": ["FARP Tent", "FARP Ammo Dump Coating", "FARP Fuel Depot", "FARP Command Post", "FARP CP Blindage"],
+    "fob": ["Bunker 2", "Bunker 1", "Garage small B", ".Command Center", "Barracks 2"],
+    "factory": ["Tech combine", "Tech hangar A"],
+    "comms": ["TV tower", "Comms tower M"],
+    "oil": ["Oil platform"],
+}
+
+
+class TheaterGroundObject:
+    cp_id = 0
+    group_id = 0
+    object_id = 0
+
+    dcs_identifier = None  # type: str
+    is_dead = False
+
+    heading = 0
+    position = None  # type: Point
+
+    @property
+    def category(self) -> str:
+        for k, v in CATEGORY_MAP.items():
+            if self.dcs_identifier in v:
+                return k
+        assert False, "Identifier not found in mapping: {}".format(self.dcs_identifier)
+
+    @property
+    def string_identifier(self):
+        return "{}|{}|{}|{}".format(self.category, self.cp_id, self.group_id, self.object_id)
+
+    @property
+    def group_identifier(self) -> str:
+        return "{}|{}".format(self.category, self.group_id)
+
+    @property
+    def name_abbrev(self) -> str:
+        return ABBREV_NAME[self.category]
+
+    def __str__(self):
+        return NAME_BY_CATEGORY[self.category]
+
+    def matches_string_identifier(self, id):
+        return self.string_identifier == id

ui/basemenu.py

@@ -1,6 +1,7 @@
 from ui.eventmenu import *
 
 from game.game import *
+from .styles import STYLES
 
 
 class BaseMenu(Menu):
@@ -9,7 +10,6 @@ class BaseMenu(Menu):
 
     def __init__(self, window: Window, parent, game: Game, cp: ControlPoint):
         super(BaseMenu, self).__init__(window, parent, game)
-
         self.cp = cp
         self.base = cp.base
         self.frame = window.right_pane
@@ -18,45 +18,60 @@ class BaseMenu(Menu):
 
     def display(self):
         self.window.clear_right_pane()
-        row = 0
-
-        def purchase_row(unit_type, unit_price):
-            nonlocal row
-
-            existing_units = self.base.total_units_of_type(unit_type)
-            scheduled_units = self.event.units.get(unit_type, 0)
-
-            Label(self.frame, text="{}".format(db.unit_type_name(unit_type))).grid(row=row, sticky=W)
-
-            label = Label(self.frame, text="({})".format(existing_units))
-            label.grid(column=1, row=row)
-            self.bought_amount_labels[unit_type] = label
-
-            Label(self.frame, text="{}m".format(unit_price)).grid(column=2, row=row)
-            Button(self.frame, text="+", command=self.buy(unit_type)).grid(column=3, row=row)
-            Button(self.frame, text="-", command=self.sell(unit_type)).grid(column=4, row=row)
-            row += 1
-
         units = {
-            PinpointStrike: db.find_unittype(PinpointStrike, self.game.player),
-            Embarking: db.find_unittype(Embarking, self.game.player),
-            CAS: db.find_unittype(CAS, self.game.player),
             CAP: db.find_unittype(CAP, self.game.player),
+            Embarking: db.find_unittype(Embarking, self.game.player),
             AirDefence: db.find_unittype(AirDefence, self.game.player),
+            CAS: db.find_unittype(CAS, self.game.player),
+            PinpointStrike: db.find_unittype(PinpointStrike, self.game.player),
         }
 
-        self.budget_label = Label(self.frame, text="Budget: {}m".format(self.game.budget))
-        self.budget_label.grid(row=row, sticky=W)
-        Button(self.frame, text="Back", command=self.dismiss).grid(column=4, row=row)
-        row += 1
+        # Header
+        head = Frame(self.frame, **STYLES["header"])
+        head.grid(row=0, column=0, columnspan=99, sticky=NSEW, pady=5)
+        Label(head, text=self.cp.name, **STYLES["title"]).grid(row=0, column=0, sticky=NW+S)
+        units_title = "{}/{}/{}".format(self.cp.base.total_planes, self.cp.base.total_armor, self.cp.base.total_aa)
+        Label(head, text=units_title, **STYLES["strong-grey"]).grid(row=0, column=1, sticky=NE+S)
 
-        for task_type, units in units.items():
-            Label(self.frame, text="{}".format(db.task_name(task_type))).grid(row=row, columnspan=5); row += 1
+        self.budget_label = Label(self.frame, text="Budget: {}m".format(self.game.budget), **STYLES["widget"])
+        self.budget_label.grid(row=1, sticky=W)
+        Button(self.frame, text="Back", command=self.dismiss, **STYLES["btn-primary"]).grid(column=9, row=1, padx=(0,15), pady=(0,5))
 
-            units = list(set(units))
-            units.sort(key=lambda x: db.PRICES[x])
-            for unit_type in units:
-                purchase_row(unit_type, db.PRICES[unit_type])
+        tasks = list(units.keys())
+        tasks_per_column = 3
+
+        column = 0
+        for i, tasks_column in [(i, tasks[idx:idx+tasks_per_column]) for i, idx in enumerate(range(0, len(tasks), tasks_per_column))]:
+            row = 2
+
+            def purchase_row(unit_type, unit_price):
+                nonlocal row
+                nonlocal column
+
+                existing_units = self.base.total_units_of_type(unit_type)
+                scheduled_units = self.event.units.get(unit_type, 0)
+
+                Label(self.frame, text="{}".format(db.unit_type_name(unit_type)), **STYLES["widget"]).grid(row=row, column=column, sticky=W)
+
+                label = Label(self.frame, text="({})               ".format(existing_units), **STYLES["widget"])
+                label.grid(column=column + 1, row=row)
+                self.bought_amount_labels[unit_type] = label
+
+                Label(self.frame, text="{}m".format(unit_price), **STYLES["widget"]).grid(column=column + 2, row=row, sticky=E)
+                Button(self.frame, text="+", command=self.buy(unit_type), **STYLES["btn-primary"]).grid(column=column + 3, row=row, padx=(10,0))
+                Button(self.frame, text="-", command=self.sell(unit_type), **STYLES["btn-warning"]).grid(column=column + 4, row=row, padx=(10,5))
+                row += 1
+
+            for task_type in tasks_column:
+                Label(self.frame, text="{}".format(db.task_name(task_type)), **STYLES["strong"]).grid(row=row, column=column, columnspan=5, sticky=NSEW)
+                row += 1
+
+                units_column = list(set(units[task_type]))
+                units_column.sort(key=lambda x: db.PRICES[x])
+                for unit_type in units_column:
+                    purchase_row(unit_type, db.PRICES[unit_type])
+
+            column += 5
 
     def dismiss(self):
         if sum([x for x in self.event.units.values()]) == 0:

ui/configurationmenu.py

@@ -1,6 +1,10 @@
+import webbrowser
+
 from tkinter import *
 from tkinter.ttk import *
+from .styles import STYLES
 
+from userdata.logging import ShowLogsException
 from ui.window import *
 
 
@@ -14,33 +18,90 @@ class ConfigurationMenu(Menu):
         self.enemy_skill_var = StringVar()
         self.enemy_skill_var.set(self.game.settings.enemy_skill)
 
+        self.enemy_vehicle_var = StringVar()
+        self.enemy_vehicle_var.set(self.game.settings.enemy_vehicle_skill)
+
         self.takeoff_var = BooleanVar()
         self.takeoff_var.set(self.game.settings.only_player_takeoff)
 
         self.night_var = BooleanVar()
         self.night_var.set(self.game.settings.night_disabled)
 
+        self.cold_start_var = BooleanVar()
+        self.cold_start_var.set(self.game.settings.cold_start)
+
     def dismiss(self):
         self.game.settings.player_skill = self.player_skill_var.get()
         self.game.settings.enemy_skill = self.enemy_skill_var.get()
+        self.game.settings.enemy_vehicle_skill = self.enemy_vehicle_var.get()
         self.game.settings.only_player_takeoff = self.takeoff_var.get()
         self.game.settings.night_disabled = self.night_var.get()
+        self.game.settings.cold_start = self.cold_start_var.get()
         super(ConfigurationMenu, self).dismiss()
 
     def display(self):
         self.window.clear_right_pane()
 
-        Label(self.frame, text="Player coalition skill").grid(row=0, column=0)
-        Label(self.frame, text="Enemy coalition skill").grid(row=1, column=0)
+        # Header
+        head = Frame(self.frame, **STYLES["header"])
+        head.grid(row=0, column=0, sticky=NSEW)
+        head.grid_columnconfigure(0, weight=100)
+        Label(head, text="Configuration", **STYLES["title"]).grid(row=0, sticky=W)
+        Button(head, text="Back", command=self.dismiss, **STYLES["btn-primary"]).grid(row=0, column=1, sticky=E)
 
-        OptionMenu(self.frame, self.player_skill_var, "Average", "Good", "High", "Excellent").grid(row=0, column=1)
-        OptionMenu(self.frame, self.enemy_skill_var, "Average", "Good", "High", "Excellent").grid(row=1, column=1)
+        # Body
+        body = Frame(self.frame, **STYLES["body"])
+        body.grid(row=1, column=0, sticky=NSEW)
+        row = 0
 
-        Checkbutton(self.frame, text="Takeoff only for player group", variable=self.takeoff_var).grid(row=2, column=0, columnspan=2)
-        Checkbutton(self.frame, text="Disable night missions", variable=self.night_var).grid(row=3, column=0, columnspan=2)
+        Label(body, text="Player coalition skill", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        p_skill = OptionMenu(body, self.player_skill_var, "Average", "Good", "High", "Excellent")
+        p_skill.grid(row=row, column=1, sticky=E, pady=5)
+        p_skill.configure(**STYLES["btn-primary"])
+        row += 1
 
-        Button(self.frame, text="Back", command=self.dismiss).grid(row=4, column=0, columnspan=1)
-        Button(self.frame, text="Cheat +200m", command=self.cheat_money).grid(row=5, column=0)
+        Label(body, text="Enemy coalition skill", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        e_skill = OptionMenu(body, self.enemy_skill_var, "Average", "Good", "High", "Excellent")
+        e_skill.grid(row=row, column=1, sticky=E)
+        e_skill.configure(**STYLES["btn-primary"])
+        row += 1
+
+        Label(body, text="Enemy AA and vehicle skill", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        e_skill = OptionMenu(body, self.enemy_vehicle_var, "Average", "Good", "High", "Excellent")
+        e_skill.grid(row=row, column=1, sticky=E)
+        e_skill.configure(**STYLES["btn-primary"])
+        row += 1
+
+        Label(body, text="Aircraft cold start", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        Checkbutton(body, variable=self.cold_start_var, **STYLES["radiobutton"]).grid(row=row, column=1, sticky=E)
+        row += 1
+
+        Label(body, text="Takeoff only for player group", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        Checkbutton(body, variable=self.takeoff_var, **STYLES["radiobutton"]).grid(row=row, column=1, sticky=E)
+        row += 1
+
+        Label(body, text="Disable night missions", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        Checkbutton(body, variable=self.night_var, **STYLES["radiobutton"]).grid(row=row, column=1, sticky=E)
+        row += 1
+
+        Button(body, text="Display logs", command=self.display_logs, **STYLES["btn-primary"]).grid(row=row, column=1, sticky=E, pady=30)
+        row += 1
+
+        Label(body, text="Contributors: ", **STYLES["strong"]).grid(row=row, column=0, columnspan=2, sticky=EW)
+        row += 1
+
+        Label(body, text="shdwp - author, maintainer", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        Button(body, text="[github]", command=lambda: webbrowser.open_new_tab("http://github.com/shdwp"), **STYLES["widget"]).grid(row=row, column=1, sticky=E)
+        row += 1
+
+        Label(body, text="Khopa - contributions", **STYLES["widget"]).grid(row=row, column=0, sticky=W)
+        Button(body, text="[github]", command=lambda: webbrowser.open_new_tab("http://github.com/Khopa"), **STYLES["widget"]).grid(row=row, column=1, sticky=E)
+        row += 1
+
+        Button(body, text="Cheat +200m", command=self.cheat_money, **STYLES["btn-danger"]).grid(row=row, column=1, pady=30)
+
+    def display_logs(self):
+        raise ShowLogsException()
 
     def cheat_money(self):
         self.game.budget += 200

ui/corruptedsavemenu.py

@@ -1,5 +1,6 @@
 from tkinter import *
 from tkinter.ttk import *
+from .styles import STYLES
 
 from ui.window import *
 
@@ -12,6 +13,6 @@ class CorruptedSaveMenu(Menu):
     def display(self):
         self.window.clear_right_pane()
 
-        Label(text="Your save game was corrupted!").grid(row=0, column=0)
-        Label(text="Please restore it by replacing \"liberation_save\" file with \"liberation_save_tmp\" to restore last saved copy.").grid(row=1, column=0)
-        Label(text="You can find those files under user DCS directory.").grid(row=2, column=0)
+        Label(text="Your save game is either incompatible or was corrupted!", **STYLES["widget"]).grid(row=0, column=0)
+        Label(text="Please restore it by replacing \"liberation_save\" file with \"liberation_save_tmp\" to restore last saved copy.", **STYLES["widget"]).grid(row=1, column=0)
+        Label(text="You can find those files under user Saved Games\\DCS directory.", **STYLES["widget"]).grid(row=2, column=0)

ui/eventmenu.py

@@ -1,22 +1,23 @@
+from dcs.helicopters import helicopter_map
+
 from ui.eventresultsmenu import *
 
 from game import *
 from game.event import *
+from .styles import STYLES, RED
 
 
 class EventMenu(Menu):
-    aircraft_scramble_entries = None  # type: typing.Dict[PlaneType , Entry]
-    aircraft_client_entries = None  # type: typing.Dict[PlaneType, Entry]
-    armor_scramble_entries = None  # type: typing.Dict[VehicleType, Entry]
+    scramble_entries = None  # type: typing.Dict[typing.Type[Task], typing.Dict[typing.Type[UnitType], typing.Tuple[Entry, Entry]]]
+    ca_slot_entry = None  # type: Entry
+    error_label = None  # type: Label
     awacs = None  # type: IntVar
 
     def __init__(self, window: Window, parent, game: Game, event: event.Event):
         super(EventMenu, self).__init__(window, parent, game)
 
         self.event = event
-        self.aircraft_scramble_entries = {}
-        self.armor_scramble_entries = {}
-        self.aircraft_client_entries = {}
+        self.scramble_entries = {k: {} for k in self.event.tasks}
 
         if self.event.attacker_name == self.game.player:
             self.base = self.event.from_cp.base
@@ -30,108 +31,111 @@ class EventMenu(Menu):
         self.window.clear_right_pane()
         row = 0
 
-        def label(text, _row=None, _column=None, sticky=None):
+        def header(text, style="strong"):
             nonlocal row
-            Label(self.frame, text=text).grid(row=_row and _row or row, column=_column and _column or 0, sticky=sticky)
+            head = Frame(self.frame, **STYLES["header"])
+            head.grid(row=row, column=0, sticky=N+EW, columnspan=5)
+            Label(head, text=text, **STYLES[style]).grid()
+            row += 1
+
+        def label(text, _row=None, _column=None, columnspan=None, sticky=None):
+            nonlocal row
+            new_label = Label(self.frame, text=text, **STYLES["widget"])
+            new_label.grid(row=_row and _row or row, column=_column and _column or 0, columnspan=columnspan, sticky=sticky)
 
             if _row is None:
                 row += 1
 
-        def scrable_row(unit_type, unit_count):
+            return new_label
+
+        def scrable_row(task_type, unit_type, unit_count, client_slots: bool):
             nonlocal row
-            Label(self.frame, text="{} ({})".format(db.unit_type_name(unit_type), unit_count)).grid(row=row, sticky=W)
+            Label(self.frame, text="{} ({})".format(db.unit_type_name(unit_type), unit_count), **STYLES["widget"]).grid(row=row, sticky=W)
 
             scramble_entry = Entry(self.frame, width=2)
-            scramble_entry.grid(column=1, row=row, sticky=W)
+            scramble_entry.grid(column=1, row=row, sticky=E, padx=5)
             scramble_entry.insert(0, "0")
-            self.aircraft_scramble_entries[unit_type] = scramble_entry
-            Button(self.frame, text="+", command=self.scramble_half(True, unit_type)).grid(column=2, row=row)
+            Button(self.frame, text="+", command=self.scramble_half(task_type, unit_type), **STYLES["btn-primary"]).grid(column=2, row=row)
 
-            client_entry = Entry(self.frame, width=2)
-            client_entry.grid(column=3, row=row, sticky=E)
-            client_entry.insert(0, "0")
-            self.aircraft_client_entries[unit_type] = client_entry
-            Button(self.frame, text="+", command=self.client_one(unit_type)).grid(column=4, row=row)
-
-            row += 1
-
-        def scramble_armor_row(unit_type, unit_count):
-            nonlocal row
-            Label(self.frame, text="{} ({})".format(db.unit_type_name(unit_type), unit_count)).grid(row=row, sticky=W)
-            scramble_entry = Entry(self.frame, width=2)
-            scramble_entry.insert(0, "0")
-            scramble_entry.grid(column=1, row=row)
-            self.armor_scramble_entries[unit_type] = scramble_entry
-            Button(self.frame, text="+", command=self.scramble_half(False, unit_type)).grid(column=2, row=row)
-
-            row += 1
-
-        threat_descr = self.event.threat_description
-        if threat_descr:
-            threat_descr = "Approx. {}".format(threat_descr)
-
-        Label(self.frame, text="{}. {}".format(self.event, threat_descr)).grid(row=row, column=0, columnspan=5)
-        row += 1
-
-        Button(self.frame, text="Commit", command=self.start).grid(column=3, row=row, sticky=E)
-        Button(self.frame, text="Back", command=self.dismiss).grid(column=4, row=row, sticky=E)
-
-        awacs_enabled = self.game.budget >= AWACS_BUDGET_COST and NORMAL or DISABLED
-        Checkbutton(self.frame, text="AWACS ({}m)".format(AWACS_BUDGET_COST), var=self.awacs, state=awacs_enabled).grid(row=row, column=0, sticky=W)
-        row += 1
-
-        label("Aircraft")
-
-        if self.base.aircraft:
-            Label(self.frame, text="Amount").grid(row=row, column=1, columnspan=2)
-            Label(self.frame, text="Client slots").grid(row=row, column=3, columnspan=2)
-            row += 1
-
-        for unit_type, count in self.base.aircraft.items():
-            scrable_row(unit_type, count)
-
-        if not self.base.total_planes:
-            label("None", sticky=W)
-
-        label("Armor")
-        for unit_type, count in self.base.armor.items():
-            scramble_armor_row(unit_type, count)
-
-        if not self.base.total_armor:
-            label("None", sticky=W)
-
-    def _scrambled_aircraft_count(self, unit_type: UnitType) -> int:
-        value = self.aircraft_scramble_entries[unit_type].get()
-        if value and int(value) > 0:
-            return min(int(value), self.base.aircraft[unit_type])
-        return 0
-
-    def _scrambled_armor_count(self, unit_type: UnitType) -> int:
-        value = self.armor_scramble_entries[unit_type].get()
-        if value and int(value) > 0:
-            return min(int(value), self.base.armor[unit_type])
-        return 0
-
-    def scramble_half(self, aircraft: bool, unit_type: UnitType) -> typing.Callable:
-        def action():
-            entry = None  # type: Entry
-            total_count = 0
-            if aircraft:
-                entry = self.aircraft_scramble_entries[unit_type]
-                total_count = self.base.aircraft[unit_type]
+            if client_slots:
+                client_entry = Entry(self.frame, width=2)
+                client_entry.grid(column=3, row=row, sticky=E, padx=5)
+                client_entry.insert(0, "0")
+                Button(self.frame, text="+", command=self.client_one(task_type, unit_type), **STYLES["btn-primary"]).grid(column=4, row=row)
             else:
-                entry = self.armor_scramble_entries[unit_type]
-                total_count = self.base.armor[unit_type]
+                client_entry = None
 
-            existing_count = int(entry.get())
+            self.scramble_entries[task_type][unit_type] = scramble_entry, client_entry
+
+            row += 1
+
+        # Header
+        header("Mission Menu", "title")
+
+        # Mission Description
+        Label(self.frame, text="{}".format(self.event), **STYLES["mission-preview"]).grid(row=row, column=0, columnspan=5, sticky=S+EW, padx=5, pady=5)
+        row += 1
+
+        Label(self.frame, text="Amount", **STYLES["widget"]).grid(row=row, column=1, columnspan=2)
+        Label(self.frame, text="Client slots", **STYLES["widget"]).grid(row=row, column=3, columnspan=2)
+        row += 1
+
+        for flight_task in self.event.tasks:
+            header("{}:".format(self.event.flight_name(flight_task)))
+            if flight_task == PinpointStrike:
+                if not self.base.armor:
+                    label("No units")
+                for t, c in self.base.armor.items():
+                    scrable_row(flight_task, t, c, client_slots=False)
+            else:
+                if not self.base.aircraft:
+                    label("No units")
+                for t, c in self.base.aircraft.items():
+                    scrable_row(flight_task, t, c, client_slots=True)
+
+        header("Support:")
+        # Options
+        awacs_enabled = self.game.budget >= AWACS_BUDGET_COST and NORMAL or DISABLED
+        Label(self.frame, text="AWACS ({}m)".format(AWACS_BUDGET_COST), **STYLES["widget"]).grid(row=row, column=0, sticky=W, pady=5)
+        Checkbutton(self.frame, var=self.awacs, state=awacs_enabled,  **STYLES["radiobutton"]).grid(row=row, column=4, sticky=E)
+        row += 1
+
+        Label(self.frame, text="Combined Arms Slots", **STYLES["widget"]).grid(row=row, sticky=W)
+        self.ca_slot_entry = Entry(self.frame,  width=2)
+        self.ca_slot_entry.insert(0, "0")
+        self.ca_slot_entry.grid(column=3, row=row, sticky=E, padx=5)
+        Button(self.frame, text="+", command=self.add_ca_slot, **STYLES["btn-primary"]).grid(column=4, row=row, padx=5, sticky=W)
+        row += 1
+
+        header("Ready?")
+        self.error_label = label("", columnspan=4)
+        self.error_label["fg"] = RED
+        Button(self.frame, text="Commit", command=self.start, **STYLES["btn-primary"]).grid(column=0, row=row, sticky=E, padx=5, pady=(10,10))
+        Button(self.frame, text="Back", command=self.dismiss, **STYLES["btn-warning"]).grid(column=3, row=row, sticky=E, padx=5, pady=(10,10))
+        row += 1
+
+    def scramble_half(self, task: typing.Type[UnitType], unit_type: UnitType) -> typing.Callable:
+        def action():
+            entry = self.scramble_entries[task][unit_type][0]  # type: Entry
+            value = entry.get()
+
+            total_units = self.base.total_units_of_type(unit_type)
+
+            amount = int(value and value or "0")
             entry.delete(0, END)
-            entry.insert(0, "{}".format(int(existing_count + math.ceil(total_count/2))))
+            entry.insert(0, str(amount + int(math.ceil(total_units/2))))
 
         return action
 
-    def client_one(self, unit_type: UnitType) -> typing.Callable:
+    def add_ca_slot(self):
+        value = self.ca_slot_entry.get()
+        amount = int(value and value or "0")
+        self.ca_slot_entry.delete(0, END)
+        self.ca_slot_entry.insert(0, str(amount+1))
+
+    def client_one(self, task: typing.Type[Task], unit_type: UnitType) -> typing.Callable:
         def action():
-            entry = self.aircraft_client_entries[unit_type]  # type: Entry
+            entry = self.scramble_entries[task][unit_type][1]  # type: Entry
             value = entry.get()
             amount = int(value and value or "0")
             entry.delete(0, END)
@@ -145,82 +149,61 @@ class EventMenu(Menu):
         else:
             self.event.is_awacs_enabled = False
 
-        scrambled_aircraft = {}
-        scrambled_sweep = {}
-        scrambled_cas = {}
-        for unit_type, field in self.aircraft_scramble_entries.items():
-            amount = self._scrambled_aircraft_count(unit_type)
-            if amount > 0:
-                task = db.unit_task(unit_type)
+        ca_slot_entry_value = self.ca_slot_entry.get()
+        try:
+            ca_slots = int(ca_slot_entry_value and ca_slot_entry_value or "0")
+        except:
+            ca_slots = 0
+        self.event.ca_slots = ca_slots
 
-                scrambled_aircraft[unit_type] = amount
-                if task == CAS:
-                    scrambled_cas[unit_type] = amount
-                elif task == CAP:
-                    scrambled_sweep[unit_type] = amount
+        flights = {k: {} for k in self.event.tasks}  # type: db.TaskForceDict
+        units_scramble_counts = {}  # type: typing.Dict[typing.Type[UnitType], int]
+        tasks_scramble_counts = {}  # type: typing.Dict[typing.Type[Task], int]
+        tasks_clients_counts = {}  # type: typing.Dict[typing.Type[Task], int]
 
-        scrambled_clients = {}
-        for unit_type, field in self.aircraft_client_entries.items():
-            value = field.get()
-            if value and int(value) > 0:
-                amount = int(value)
-                scrambled_clients[unit_type] = amount
+        def dampen_count(for_task: typing.Type[Task], unit_type: typing.Type[UnitType], count: int) -> int:
+            nonlocal units_scramble_counts
+            total_count = self.base.total_units_of_type(unit_type)
 
-        scrambled_armor = {}
-        for unit_type, field in self.armor_scramble_entries.items():
-            amount = self._scrambled_armor_count(unit_type)
-            if amount > 0:
-                scrambled_armor[unit_type] = amount
+            total_scrambled = units_scramble_counts.get(unit_type, 0)
+            dampened_value = count if count + total_scrambled < total_count else total_count - total_scrambled
+            units_scramble_counts[unit_type] = units_scramble_counts.get(unit_type, 0) + dampened_value
 
-        if type(self.event) is CaptureEvent:
-            e = self.event  # type: CaptureEvent
-            if self.game.is_player_attack(self.event):
-                e.player_attacking(cas=scrambled_cas,
-                                   escort=scrambled_sweep,
-                                   armor=scrambled_armor,
-                                   clients=scrambled_clients)
-            else:
-                e.player_defending(interceptors=scrambled_aircraft,
-                                   clients=scrambled_clients)
-        elif type(self.event) is InterceptEvent:
-            e = self.event  # type: InterceptEvent
-            if self.game.is_player_attack(self.event):
-                e.player_attacking(interceptors=scrambled_aircraft,
-                                   clients=scrambled_clients)
-            else:
-                e.player_defending(escort=scrambled_aircraft,
-                                   clients=scrambled_clients)
-        elif type(self.event) is GroundInterceptEvent:
-            e = self.event  # type: GroundInterceptEvent
-            if self.game.is_player_attack(self.event):
-                e.player_attacking(strikegroup=scrambled_aircraft, clients=scrambled_clients)
-            else:
-                e.player_defending(interceptors=scrambled_aircraft, clients=scrambled_clients)
-        elif type(self.event) is NavalInterceptEvent:
-            e = self.event  # type: NavalInterceptEvent
+            return dampened_value
 
-            if self.game.is_player_attack(self.event):
-                e.player_attacking(strikegroup=scrambled_aircraft, clients=scrambled_clients)
-            else:
-                e.player_defending(interceptors=scrambled_aircraft, clients=scrambled_clients)
-        elif type(self.event) is AntiAAStrikeEvent:
-            e = self.event  # type: AntiAAStrikeEvent
-            if self.game.is_player_attack(self.event):
-                e.player_attacking(strikegroup=scrambled_aircraft, clients=scrambled_clients)
-            else:
-                e.player_defending(interceptors=scrambled_aircraft, clients=scrambled_clients)
-        elif type(self.event) is GroundAttackEvent:
-            e = self.event  # type: GroundAttackEvent
-            if self.game.is_player_attack(self.event):
-                assert False
-            else:
-                e.player_defending(strikegroup=scrambled_aircraft, clients=scrambled_clients)
-        elif type(self.event) is InfantryTransportEvent:
-            e = self.event  # type: InfantryTransportEvent
-            if self.game.is_player_attack(self.event):
-                e.player_attacking(transport=scrambled_aircraft, clients=scrambled_clients)
-            else:
-                assert False
+        for task_type, dict in self.scramble_entries.items():
+            for unit_type, (count_entry, clients_entry) in dict.items():
+                try:
+                    count = int(count_entry.get())
+                except:
+                    count = 0
+
+                try:
+                    clients_count = int(clients_entry and clients_entry.get() or 0)
+                except:
+                    clients_count = 0
+
+                dampened_count = dampen_count(task_type, unit_type, count)
+                tasks_clients_counts[task_type] = tasks_clients_counts.get(task_type, 0) + clients_count
+                tasks_scramble_counts[task_type] = tasks_scramble_counts.get(task_type, 0) + dampened_count
+
+                flights[task_type][unit_type] = dampened_count, clients_count
+
+        for task in self.event.ai_banned_tasks:
+            if tasks_clients_counts.get(task, 0) == 0 and tasks_scramble_counts.get(task, 0) > 0:
+                self.error_label["text"] = "Need at least one player in flight {}".format(self.event.flight_name(task))
+                return
+
+        if isinstance(self.event, FrontlineAttackEvent) or isinstance(self.event, FrontlinePatrolEvent):
+            if tasks_scramble_counts.get(PinpointStrike, 0) == 0:
+                self.error_label["text"] = "No ground vehicles assigned to attack!"
+                return
+
+
+        if self.game.is_player_attack(self.event):
+            self.event.player_attacking(flights)
+        else:
+            self.event.player_defending(flights)
 
         self.game.initiate_event(self.event)
         EventResultsMenu(self.window, self.parent, self.game, self.event).display()

ui/eventresultsmenu.py

@@ -3,6 +3,7 @@ from ui.window import *
 
 from game.game import *
 from userdata.debriefing import *
+from .styles import STYLES
 
 
 class EventResultsMenu(Menu):
@@ -13,6 +14,7 @@ class EventResultsMenu(Menu):
     def __init__(self, window: Window, parent, game: Game, event: Event):
         super(EventResultsMenu, self).__init__(window, parent, game)
         self.frame = window.right_pane
+        self.frame.grid_rowconfigure(0, weight=0)
         self.event = event
         self.finished = False
 
@@ -21,51 +23,92 @@ class EventResultsMenu(Menu):
     def display(self):
         self.window.clear_right_pane()
 
+        row = 0
+
+        def header(text, style="strong"):
+            nonlocal row
+            head = Frame(self.frame, **STYLES["header"])
+            head.grid(row=row, column=0, sticky=N + EW, columnspan=2, pady=(0, 10))
+            Label(head, text=text, **STYLES[style]).grid()
+            row += 1
+
+        def label(text, style="widget"):
+            nonlocal row
+            Label(self.frame, text=text, **STYLES[style]).grid(row=row, column=0, sticky=NW, columnspan=2)
+            row += 1
+
         if not self.finished:
+
+            header("You are clear for takeoff!")
+
+            label("In DCS, open and play the mission:")
+            label("liberation_nextturn", "italic")
+            label("or")
+            label("liberation_nextturn_quick", "italic")
+            header("Then save the debriefing to the folder:")
+            label(debriefing_directory_location(), "italic")
+            header("Waiting for results...")
+
+            pg = Progressbar(self.frame, orient="horizontal", length=200, mode="determinate")
+            pg.grid(row=row, column=0, columnspan=2, sticky=EW, pady=5, padx=5)
+            pg.start(10)
+            row += 1
+
             """
-            For debugging purposes
-            
-            Button(self.frame, text="no losses, succ", command=self.simulate_result(0, 1)).grid()
-            Button(self.frame, text="no losses, fail", command=self.simulate_result(0, 1)).grid(row=1, column=1)
+            Label(self.frame, text="Cheat operation results: ", **STYLES["strong"]).grid(column=0, row=row,
+                                                                                         columnspan=2, sticky=NSEW,
+                                                                                         pady=5)
 
-            Button(self.frame, text="half losses, succ", command=self.simulate_result(0.5, 0.5)).grid(row=2, )
-            Button(self.frame, text="half losses, fail", command=self.simulate_result(0.5, 0.5)).grid(row=2, column=1)
-
-            Button(self.frame, text="full losses, succ", command=self.simulate_result(1, 0)).grid(row=3, )
-            Button(self.frame, text="full losses, fail", command=self.simulate_result(1, 0)).grid(row=3, column=1)
+            row += 1
+            Button(self.frame, text="full enemy losses", command=self.simulate_result(0, 1),
+                   **STYLES["btn-warning"]).grid(column=0, row=row, padx=5, pady=5)
+            Button(self.frame, text="full player losses", command=self.simulate_result(1, 0),
+                   **STYLES["btn-warning"]).grid(column=1, row=row, padx=5, pady=5)
+            row += 1
+            Button(self.frame, text="some enemy losses", command=self.simulate_result(0, 0.8),
+                   **STYLES["btn-warning"]).grid(column=0, row=row, padx=5, pady=5)
+            Button(self.frame, text="some player losses", command=self.simulate_result(0.8, 0),
+                   **STYLES["btn-warning"]).grid(column=1, row=row, padx=5, pady=5)
+            row += 1
             """
 
-            Label(self.frame, text="Play the mission and save debriefing to").grid(row=0, column=0)
-            Label(self.frame, text=debriefing_directory_location()).grid(row=1, column=0)
         else:
             row = 0
             if self.event.is_successfull(self.debriefing):
-                Label(self.frame, text="Operation success").grid(row=row, columnspan=1); row += 1
+                header("Operation success", "title-green")
             else:
-                Label(self.frame, text="Operation failed").grid(row=row, columnspan=1); row += 1
+                header("Operation failed", "title-red")
+
+            header("Player losses")
 
-            Separator(self.frame, orient='horizontal').grid(row=row, columnspan=1, sticky=NE); row += 1
-            Label(self.frame, text="Player losses").grid(row=row, columnspan=1); row += 1
             for unit_type, count in self.player_losses.items():
-                Label(self.frame, text=db.unit_type_name(unit_type)).grid(row=row)
-                Label(self.frame, text="{}".format(count)).grid(column=1, row=row)
+                Label(self.frame, text=db.unit_type_name(unit_type), **STYLES["widget"]).grid(row=row)
+                Label(self.frame, text="{}".format(count), **STYLES["widget"]).grid(column=1, row=row)
+                row += 1
+
+            header("Enemy losses")
+
+            if self.debriefing.destroyed_objects:
+                Label(self.frame, text="Ground assets", **STYLES["widget"]).grid(row=row)
+                Label(self.frame, text="{}".format(len(self.debriefing.destroyed_objects)), **STYLES["widget"]).grid(column=1, row=row)
                 row += 1
 
-            Separator(self.frame, orient='horizontal').grid(row=row, columnspan=1, sticky=NE); row += 1
-            Label(self.frame, text="Enemy losses").grid(columnspan=1, row=row); row += 1
             for unit_type, count in self.enemy_losses.items():
                 if count == 0:
                     continue
 
-                Label(self.frame, text=db.unit_type_name(unit_type)).grid(row=row)
-                Label(self.frame, text="{}".format(count)).grid(column=1, row=row)
+                Label(self.frame, text=db.unit_type_name(unit_type), **STYLES["widget"]).grid(row=row)
+                Label(self.frame, text="{}".format(count), **STYLES["widget"]).grid(column=1, row=row)
                 row += 1
 
-            Button(self.frame, text="Okay", command=self.dismiss).grid(columnspan=1, row=row); row += 1
+            Button(self.frame, text="Okay", command=self.dismiss, **STYLES["btn-primary"]).grid(columnspan=1, row=row)
+            row += 1
 
     def process_debriefing(self, debriefing: Debriefing):
         self.debriefing = debriefing
-        debriefing.calculate_units(mission=self.event.operation.mission,
+
+        debriefing.calculate_units(regular_mission=self.event.operation.regular_mission,
+                                   quick_mission=self.event.operation.quick_mission,
                                    player_name=self.game.player,
                                    enemy_name=self.game.enemy)
 
@@ -81,27 +124,55 @@ class EventResultsMenu(Menu):
         def action():
             debriefing = Debriefing({})
 
-            def count_planes(groups: typing.List[FlyingGroup], mult: float) -> typing.Dict[UnitType, int]:
+            def count(country: Country) -> typing.Dict[UnitType, int]:
                 result = {}
-                for group in groups:
+                for g in country.plane_group + country.vehicle_group + country.helicopter_group + country.ship_group:
+                    group = g  # type: Group
                     for unit in group.units:
-                        result[unit.unit_type] = result.get(unit.unit_type, 0) + 1 * mult
+                        unit_type = None
+                        if isinstance(unit, Vehicle):
+                            unit_type = vehicle_map[unit.type]
+                        elif isinstance(unit, Ship):
+                            unit_type = ship_map[unit.type]
+                        else:
+                            unit_type = unit.unit_type
 
-                return {x: math.ceil(y) for x, y in result.items() if y >= 1}
+                        if unit_type in db.EXTRA_AA.values():
+                            continue
 
-            player_planes = self.event.operation.mission.country(self.game.player).plane_group
-            enemy_planes = self.event.operation.mission.country(self.game.enemy).plane_group
+                        result[unit_type] = result.get(unit_type, 0) + 1
 
-            self.player_losses = count_planes(player_planes, player_factor)
-            self.enemy_losses = count_planes(enemy_planes, enemy_factor)
+                return result
+
+            player = self.event.operation.mission.country(self.game.player)
+            enemy = self.event.operation.mission.country(self.game.enemy)
+
+            alive_player_units = count(player)
+            alive_enemy_units = count(enemy)
+
+            destroyed_player_units = db.unitdict_restrict_count(alive_player_units, math.ceil(
+                sum(alive_player_units.values()) * player_factor))
+            destroyed_enemy_units = db.unitdict_restrict_count(alive_enemy_units, math.ceil(
+                sum(alive_enemy_units.values()) * enemy_factor))
+
+            alive_player_units = {k: v - destroyed_player_units.get(k, 0) for k, v in alive_player_units.items()}
+            alive_enemy_units = {k: v - destroyed_enemy_units.get(k, 0) for k, v in alive_enemy_units.items()}
+
+            debriefing.alive_units = {
+                enemy.name: alive_enemy_units,
+                player.name: alive_player_units,
+            }
 
             debriefing.destroyed_units = {
-                self.game.player: self.player_losses,
-                self.game.enemy: self.enemy_losses,
+                player.name: destroyed_player_units,
+                enemy.name: destroyed_enemy_units,
             }
 
             self.finished = True
             self.debriefing = debriefing
+            self.player_losses = debriefing.destroyed_units.get(self.game.player, {})
+            self.enemy_losses = debriefing.destroyed_units.get(self.game.enemy, {})
+
             self.game.finish_event(self.event, debriefing)
             self.display()
             self.game.pass_turn()

ui/mainmenu.py

@@ -1,11 +1,13 @@
-import pickle
-
-from ui.basemenu import *
-from ui.overviewcanvas import *
-from ui.configurationmenu import *
-
 from game.game import *
+from ui.basemenu import *
+from ui.configurationmenu import *
+from ui.overviewcanvas import *
 from userdata import persistency
+from .styles import STYLES
+
+
+import tkinter as tk
+from tkinter import ttk
 
 
 class MainMenu(Menu):
@@ -18,39 +20,86 @@ class MainMenu(Menu):
         self.upd.update()
 
         self.frame = self.window.right_pane
-        self.frame.grid_columnconfigure(0, weight=1)
+        self.frame.rowconfigure(0, weight=0)
+        self.frame.rowconfigure(1, weight=1)
 
     def display(self):
         persistency.save_game(self.game)
 
         self.window.clear_right_pane()
         self.upd.update()
-        row = 1
+
+        # Header :
+        header = Frame(self.frame, **STYLES["header"])
+        Button(header, text="Configuration", command=self.configuration_menu, **STYLES["btn-primary"]).grid(column=0, row=0, sticky=NW)
+        Label(header, text="Budget: {}m (+{}m)".format(self.game.budget, self.game.budget_reward_amount), **STYLES["strong"]).grid(column=1, row=0, sticky=N+EW, padx=50)
+        Button(header, text="Pass turn", command=self.pass_turn, **STYLES["btn-primary"]).grid(column=2, row=0, sticky=NE)
+        header.grid(column=0, row=0, sticky=N+EW)
+
+        content = Frame(self.frame, **STYLES["body"])
+        content.grid(column=0, row=1, sticky=NSEW)
+        column = 0
+        row = 0
 
         def label(text):
-            nonlocal row
-            Label(self.frame, text=text).grid(row=row, sticky=NW)
+            nonlocal row, body
+            frame = LabelFrame(body, **STYLES["label-frame"])
+            frame.grid(row=row, sticky=N+EW, columnspan=2)
+            Label(frame, text=text, **STYLES["widget"]).grid(row=row, sticky=NS)
             row += 1
 
         def event_button(event):
-            nonlocal row
-            Message(self.frame, text="{}{}".format(
-                event.defender_name == self.game.player and "Enemy attacking: " or "",
+            nonlocal row, body
+            frame = LabelFrame(body, **STYLES["label-frame"])
+            frame.grid(row=row, sticky=N+EW)
+            Message(frame, text="{}".format(
                 event
-            ), aspect=1600).grid(column=0, row=row, sticky=NW)
-            Button(self.frame, text=">", command=self.start_event(event)).grid(column=0, row=row, sticky=NE+S)
+            ), aspect=1600, **STYLES["widget"]).grid(column=0, row=0, sticky=N+EW)
+            Button(body, text=">", command=self.start_event(event), **STYLES["btn-primary"]).grid(column=1, row=row, sticky=E)
             row += 1
-            Separator(self.frame, orient='horizontal').grid(row=row, sticky=EW); row += 1
 
-        Button(self.frame, text="Configuration", command=self.configuration_menu).grid(column=0, row=0, sticky=NE)
-        Button(self.frame, text="Pass turn", command=self.pass_turn).grid(column=0, row=0, sticky=NW)
-        Label(self.frame, text="Budget: {}m (+{}m)".format(self.game.budget, self.game.budget_reward_amount)).grid(column=0, row=0, sticky=N)
-        Separator(self.frame, orient='horizontal').grid(row=row, sticky=EW); row += 1
+        def departure_header(text, style="strong"):
+            nonlocal row, body
+            Label(body, text=text, **STYLES[style]).grid(column=0, columnspan=2, row=row, sticky=N+EW, pady=(0, 5))
+            row += 1
+
+        def destination_header(text):
+            nonlocal row, body
+            Label(body, text=text, **STYLES["substrong"]).grid(column=0, columnspan=2, row=row, sticky=N+EW)
+            row += 1
 
         events = self.game.events
-        events.sort(key=lambda x: x.informational and 2 or (self.game.is_player_attack(x) and 1 or 0))
+        events.sort(key=lambda x: x.to_cp.name)
+        events.sort(key=lambda x: x.from_cp.name)
+        events.sort(key=lambda x: x.informational and 1 or (self.game.is_player_attack(x) and 2 or 0))
+
+        destination = None
+        departure = None
 
         for event in events:
+            if event.informational:
+                new_departure = "Deliveries"
+            elif not self.game.is_player_attack(event):
+                new_departure = "Enemy attack"
+            else:
+                new_departure = event.from_cp.name
+
+            if new_departure != departure:
+                body = Frame(content, **STYLES["body"])
+                body.grid(column=column, row=1, sticky=N+EW)
+                row = 0
+                column += 1
+
+                departure = new_departure
+                departure_header(new_departure, style="strong" if self.game.is_player_attack(event) else "supstrong")
+                destination = None
+
+            if not event.informational:
+                new_destination = "At {}".format(event.to_cp.name)
+                if destination != new_destination:
+                    destination_header(new_destination)
+                    destination = new_destination
+
             if event.informational:
                 label(str(event))
             else:
@@ -76,3 +125,7 @@ class MainMenu(Menu):
 
         self.basemenu = BaseMenu(self.window, self, self.game, cp)
         self.basemenu.display()
+
+
+
+

ui/newgamemenu.py

@@ -1,7 +1,9 @@
+import os
 from tkinter import *
 from tkinter.ttk import *
 
 from ui.window import *
+from .styles import STYLES
 
 
 class NewGameMenu(Menu):
@@ -14,6 +16,7 @@ class NewGameMenu(Menu):
     def __init__(self, window: Window, callback: typing.Callable):
         super(NewGameMenu, self).__init__(window, None, None)
         self.frame = window.right_pane
+        window.left_pane.configure(background="black")
         self.callback = callback
 
         self.selected_country = IntVar()
@@ -57,23 +60,69 @@ class NewGameMenu(Menu):
     def display(self):
         self.window.clear_right_pane()
 
-        Label(self.frame, text="Player country").grid(row=0, column=0)
-        Radiobutton(self.frame, text="USA", variable=self.selected_country, value=0).grid(row=1, column=0)
-        Radiobutton(self.frame, text="Russia", variable=self.selected_country, value=1).grid(row=2, column=0)
+        # Header
+        head = Frame(self.frame, **STYLES["header"])
+        head.grid(row=0, column=0, sticky=NSEW)
+        Label(head, text="Start a new game", **STYLES["title"]).grid()
 
-        Label(self.frame, text="Terrain").grid(row=0, column=1)
-        Radiobutton(self.frame, text="Caucasus", variable=self.selected_terrain, value=0).grid(row=1, column=1)
-        Radiobutton(self.frame, text="Nevada", variable=self.selected_terrain, value=1).grid(row=2, column=1)
-        Radiobutton(self.frame, text="Persian Gulf", variable=self.selected_terrain, value=2).grid(row=3, column=1)
+        # Body
+        body = Frame(self.frame, **STYLES["body"])
+        body.grid(row=1, column=0, sticky=NSEW)
 
-        Label(self.frame, text="Options").grid(row=1, column=2)
-        Checkbutton(self.frame, text="SAMs", variable=self.sams).grid(row=1, column=2)
-        Checkbutton(self.frame, text="Mid game", variable=self.midgame).grid(row=2, column=2)
+        # Country Selection
+        country = LabelFrame(body, text="Player Side", **STYLES["label-frame"])
+        country.grid(row=0, column=0, sticky=NW, padx=5)
+        Radiobutton(country, variable=self.selected_country, value=0, **STYLES["radiobutton"]).grid(row=0, column=0,
+                                                                                                    sticky=W)
+        Label(country, text="USA", **STYLES["widget"]).grid(row=0, column=1, sticky=W)
+        Radiobutton(country, variable=self.selected_country, value=1, **STYLES["radiobutton"]).grid(row=1, column=0,
+                                                                                                    sticky=W)
+        Label(country, text="Russia", **STYLES["widget"]).grid(row=1, column=1, sticky=W)
 
-        Label(self.frame, text="Multiplier").grid(row=0, column=3)
-        Entry(self.frame, textvariable=self.multiplier).grid(row=1, column=3)
+        # Terrain Selection
+        terrain = LabelFrame(body, text="Terrain", **STYLES["label-frame"])
+        terrain.grid(row=0, column=1, sticky=N, padx=5)
 
-        Button(self.frame, text="Proceed", command=self.proceed).grid(row=5, column=0, columnspan=4)
+        Radiobutton(terrain, variable=self.selected_terrain, value=0, **STYLES["radiobutton"]) \
+            .grid(row=0, column=0, sticky=W)
+        Label(terrain, text="Caucasus", **STYLES["widget"]).grid(row=0, column=1, sticky=W)
+        self.create_label_image(terrain, "terrain_caucasus.gif").grid(row=0, column=2, padx=5)
+
+        Radiobutton(terrain, variable=self.selected_terrain, value=1, **STYLES["radiobutton"]) \
+            .grid(row=1, column=0, sticky=W)
+        Label(terrain, text="Nevada", **STYLES["widget"]).grid(row=1, column=1, sticky=W)
+        self.create_label_image(terrain, "terrain_nevada.gif").grid(row=1, column=2, padx=5)
+
+        Radiobutton(terrain, variable=self.selected_terrain, value=2, **STYLES["radiobutton"]) \
+            .grid(row=2, column=0, sticky=W)
+        Label(terrain, text="Persian Gulf", **STYLES["widget"]).grid(row=2, column=1, sticky=W)
+        self.create_label_image(terrain, "terrain_pg.gif").grid(row=2, column=2, padx=5)
+
+        # Misc Options
+        options = LabelFrame(body, text="Misc Options", **STYLES["label-frame"])
+        options.grid(row=0, column=2, sticky=NE, padx=5)
+
+        Checkbutton(options, variable=self.sams, **STYLES["radiobutton"]).grid(row=0, column=0, sticky=W)
+        Label(options, text="SAMs", **STYLES["widget"]).grid(row=0, column=1, sticky=W)
+
+        Checkbutton(options, variable=self.midgame, **STYLES["radiobutton"]).grid(row=1, column=0, sticky=W)
+        Label(options, text="Mid Game", **STYLES["widget"]).grid(row=1, column=1, sticky=W)
+
+        Label(options, text="Multiplier", **STYLES["widget"]).grid(row=2, column=0, sticky=W)
+        Entry(options, textvariable=self.multiplier).grid(row=2, column=1, sticky=W)
+
+        # Footer with Proceed Button
+        footer = Frame(self.frame, **STYLES["header"])
+        footer.grid(row=2, sticky=N + E + W)
+        Button(footer, text="Proceed", command=self.proceed, **STYLES["btn-primary"]).grid(row=0, column=0, sticky=SE,
+                                                                                           padx=5, pady=5)
+
+    @staticmethod
+    def create_label_image(parent, image):
+        im = PhotoImage(file=os.path.join("resources", "ui", image))
+        label = Label(parent, image=im)
+        label.image = im
+        return label
 
     def proceed(self):
         self.callback(self.player_country_name,

ui/overviewcanvas.py

@@ -6,6 +6,7 @@ from tkinter.ttk import *
 from ui.window import *
 
 from game.game import *
+from gen.conflictgen import Conflict
 from theater.conflicttheater import *
 
 
@@ -20,36 +21,40 @@ class OverviewCanvas:
         self.canvas = Canvas(frame, width=self.image.width(), height=self.image.height())
         self.canvas.grid(column=0, row=0, sticky=NSEW)
 
-    def transform_point(self, p: Point) -> (int, int):
+    def transform_point(self, p: Point, treshold=30) -> (int, int):
         point_a = list(self.game.theater.reference_points.keys())[0]
         point_a_img = self.game.theater.reference_points[point_a]
 
         point_b = list(self.game.theater.reference_points.keys())[1]
         point_b_img = self.game.theater.reference_points[point_b]
 
-        x_dist = point_a_img[0] - point_b_img[0]
+        Y_dist = point_a_img[0] - point_b_img[0]
         lon_dist = point_a[1] - point_b[1]
 
-        y_dist = point_a_img[1] - point_b_img[1]
+        X_dist = point_a_img[1] - point_b_img[1]
         lat_dist = point_b[0] - point_a[0]
 
-        x_scale = float(x_dist) / float(lon_dist)
-        y_scale = float(y_dist) / float(lat_dist)
+        Y_scale = float(Y_dist) / float(lon_dist)
+        X_scale = float(X_dist) / float(lat_dist)
 
         # ---
-        x_offset = p.x - point_a[0]
-        y_offset = p.y - point_a[1]
+        Y_offset = p.x - point_a[0]
+        X_offset = p.y - point_a[1]
 
-        return point_b_img[1] + y_offset * y_scale, point_a_img[0] - x_offset * x_scale
+        X = point_b_img[1] + X_offset * X_scale
+        Y = point_a_img[0] - Y_offset * Y_scale
+
+        return X > treshold and X or treshold, Y > treshold and Y or treshold
 
     def create_cp_title(self, coords, cp: ControlPoint):
         title = cp.name
-        font = ("Helvetica", 13)
+        font = ("Helvetica", 10)
+
+        id = self.canvas.create_text(coords[0], coords[1], text=title, font=font)
+        self.canvas.tag_bind(id, "<Button-1>", self.display(cp))
 
         id = self.canvas.create_text(coords[0]+1, coords[1]+1, text=title, fill='white', font=font)
         self.canvas.tag_bind(id, "<Button-1>", self.display(cp))
-        id = self.canvas.create_text(coords[0], coords[1], text=title, font=font)
-        self.canvas.tag_bind(id, "<Button-1>", self.display(cp))
 
     def _player_color(self):
         return self.game.player == "USA" and "blue" or "red"
@@ -62,6 +67,14 @@ class OverviewCanvas:
         self.canvas.create_image((self.image.width()/2, self.image.height()/2), image=self.image)
 
         for cp in self.game.theater.controlpoints:
+            for ground_object in cp.ground_objects:
+                x, y = self.transform_point(ground_object.position)
+                self.canvas.create_text(x,
+                                        y,
+                                        text=".",
+                                        fill="black" if ground_object.is_dead else self._enemy_color(),
+                                        font=("Helvetica", 18))
+
             coords = self.transform_point(cp.position)
             for connected_cp in cp.connected_points:
                 connected_coords = self.transform_point(connected_cp.position)
@@ -74,9 +87,24 @@ class OverviewCanvas:
 
                 self.canvas.create_line((coords[0], coords[1], connected_coords[0], connected_coords[1]), width=2, fill=color)
 
+                if cp.captured and not connected_cp.captured and Conflict.has_frontline_between(cp, connected_cp):
+                    frontline = Conflict.frontline_vector(cp, connected_cp, self.game.theater)
+                    if not frontline:
+                        continue
+
+                    frontline_pos, heading, distance = frontline
+                    if distance < 10000:
+                        frontline_pos = frontline_pos.point_from_heading(heading + 180, 5000)
+                        distance = 10000
+
+                    start_coords = self.transform_point(frontline_pos, treshold=10)
+                    end_coords = self.transform_point(frontline_pos.point_from_heading(heading, distance), treshold=60)
+
+                    self.canvas.create_line((*start_coords, *end_coords), width=2, fill=color)
+
         for cp in self.game.theater.controlpoints:
             coords = self.transform_point(cp.position)
-            arc_size = 22 * math.pow(cp.importance, 1)
+            arc_size = 16 * math.pow(cp.importance, 1)
             extent = max(cp.base.strength * 180, 10)
             start = (180 - extent) / 2
 
@@ -86,7 +114,7 @@ class OverviewCanvas:
                 color = self._enemy_color()
 
             cp_id = self.canvas.create_arc((coords[0] - arc_size/2, coords[1] - arc_size/2),
-                                           (coords[0]+arc_size/2, coords[1]+arc_size/2),
+                                           (coords[0] + arc_size/2, coords[1] + arc_size/2),
                                            fill=color,
                                            style=PIESLICE,
                                            start=start,
@@ -105,7 +133,8 @@ class OverviewCanvas:
             self.create_cp_title((coords[0] + arc_size/4, coords[1] + arc_size/4), cp)
 
             units_title = "{}/{}/{}".format(cp.base.total_planes, cp.base.total_armor, cp.base.total_aa)
-            self.canvas.create_text(coords[0], coords[1] - arc_size / 1.5, text=units_title, font=("Helvetica", 10))
+            self.canvas.create_text(coords[0]+1, coords[1] - arc_size / 1.5 +1, text=units_title, font=("Helvetica", 8), fill=color)
+            self.canvas.create_text(coords[0], coords[1] - arc_size / 1.5, text=units_title, font=("Helvetica", 8), fill="white")
 
     def display(self, cp: ControlPoint):
         def action(_):

ui/styles.py

@@ -0,0 +1,49 @@
+# Style for UI
+
+# Padding
+PADDING_X = 5
+PADDING_Y = 5
+
+# Colors
+FG_COLOR = "white"
+FG_COLOR_LIGHT = "#dddddd"
+BG_COLOR = "#4E5760"
+GREEN = "#699245"
+YELLOW = "#BF9A46"
+RED = "#D0232E"
+BG_TITLE_COLOR = "#2D3E50"
+BG_SUBTITLE_COLOR = "#3E4F61"
+
+# Fonts
+FONT_FAMILY = "Trebuchet MS"
+DEFAULT_FONT = (FONT_FAMILY, 8)
+ITALIC = (FONT_FAMILY, 8, "italic")
+BOLD_FONT = (FONT_FAMILY, 10, "bold italic")
+TITLE_FONT = (FONT_FAMILY, 16, "bold italic")
+
+# List of styles
+STYLES = {}
+STYLES["label-frame"] = {"font": BOLD_FONT, "bg": BG_COLOR, "fg": FG_COLOR}
+STYLES["frame-wrapper"] = {"bg": BG_COLOR, "relief":"sunken"}
+
+STYLES["body"] = {"bg": BG_COLOR, "padx": 10, "pady": 10}
+STYLES["strong"] = {"font": BOLD_FONT, "bg": BG_TITLE_COLOR, "fg": FG_COLOR}
+STYLES["substrong"] = {"font": BOLD_FONT, "bg": BG_SUBTITLE_COLOR, "fg": FG_COLOR}
+STYLES["supstrong"] = {"font": BOLD_FONT, "bg": RED, "fg": FG_COLOR}
+STYLES["strong-grey"] = {"font": BOLD_FONT, "bg": BG_TITLE_COLOR, "fg": FG_COLOR_LIGHT}
+
+STYLES["mission-preview"] = {"font": BOLD_FONT, "bg": YELLOW, "fg": FG_COLOR}
+
+STYLES["widget"] = {"bg": BG_COLOR, "fg": FG_COLOR, "padx": PADDING_X, "pady": PADDING_Y, "font": DEFAULT_FONT}
+STYLES["italic"] = {"bg": BG_COLOR, "fg": FG_COLOR, "padx": PADDING_X, "pady": PADDING_Y, "font": ITALIC}
+STYLES["radiobutton"] = {"bg": BG_COLOR, "fg": "black", "padx": PADDING_X, "pady": PADDING_Y, "font": DEFAULT_FONT,
+                         "activebackground": BG_COLOR, "highlightbackground": BG_COLOR, "selectcolor": "white"}
+STYLES["title"] = {"bg": BG_TITLE_COLOR, "fg": FG_COLOR, "padx": PADDING_X, "pady": PADDING_Y, "font": TITLE_FONT}
+STYLES["title-green"] = {"bg": GREEN, "fg": FG_COLOR, "padx": PADDING_X, "pady": PADDING_Y, "font": TITLE_FONT}
+STYLES["title-red"] = {"bg": RED, "fg": FG_COLOR, "padx": PADDING_X, "pady": PADDING_Y, "font": TITLE_FONT}
+STYLES["header"] = {"bg": BG_TITLE_COLOR}
+STYLES["subheader"] = {"bg": BG_SUBTITLE_COLOR}
+
+STYLES["btn-primary"] = {"bg": GREEN, "fg": FG_COLOR, "padx": PADDING_X, "pady": 2, "font": DEFAULT_FONT}
+STYLES["btn-danger"] = {"bg": RED, "fg": FG_COLOR, "padx": PADDING_X, "pady": 2, "font": DEFAULT_FONT}
+STYLES["btn-warning"] = {"bg": YELLOW, "fg": FG_COLOR, "padx": PADDING_X, "pady": 2, "font": DEFAULT_FONT}

ui/window.py

@@ -1,6 +1,6 @@
 from tkinter import *
 from game.game import *
-
+from .styles import BG_COLOR,BG_TITLE_COLOR
 
 class Window:
     image = None
@@ -9,26 +9,33 @@ class Window:
 
     def __init__(self):
         self.tk = Tk()
+        self.tk.title("DCS Liberation")
+        self.tk.iconbitmap("icon.ico")
+        self.tk.resizable(False, False)
         self.tk.grid_columnconfigure(0, weight=1)
         self.tk.grid_rowconfigure(0, weight=1)
 
-        self.frame = Frame(self.tk)
+        self.frame = Frame(self.tk, bg=BG_COLOR)
         self.frame.grid(column=0, row=0, sticky=NSEW)
-        self.frame.grid_columnconfigure(0, minsize=300)
-        self.frame.grid_columnconfigure(1, minsize=400)
+        self.frame.grid_columnconfigure(0)
+        self.frame.grid_columnconfigure(1)
 
         self.frame.grid_columnconfigure(0, weight=0)
         self.frame.grid_columnconfigure(1, weight=1)
         self.frame.grid_rowconfigure(0, weight=1)
 
-        self.left_pane = Frame(self.frame)
+        self.left_pane = Frame(self.frame, bg=BG_TITLE_COLOR)
         self.left_pane.grid(row=0, column=0, sticky=NSEW)
-        self.right_pane = Frame(self.frame)
+        self.right_pane = Frame(self.frame, bg=BG_COLOR)
         self.right_pane.grid(row=0, column=1, sticky=NSEW)
 
         self.tk.focus()
 
     def clear_right_pane(self):
+        for i in range(100):
+            self.right_pane.grid_columnconfigure(1, weight=0)
+            self.right_pane.grid_rowconfigure(1, weight=0)
+
         for x in self.right_pane.winfo_children():
             x.grid_remove()
 

userdata/debriefing.py

@@ -1,3 +1,4 @@
+import logging
 import typing
 import re
 import threading
@@ -16,6 +17,7 @@ from dcs.unit import UnitType
 from game import db
 
 from .persistency import base_path
+from theater.theatergroundobject import CATEGORY_MAP
 
 DEBRIEFING_LOG_EXTENSION = "log"
 
@@ -58,14 +60,33 @@ def parse_mutliplayer_debriefing(contents: str):
 
 
 class Debriefing:
-    def __init__(self, dead_units):
+    def __init__(self, dead_units, trigger_state):
         self.destroyed_units = {}  # type: typing.Dict[str, typing.Dict[UnitType, int]]
         self.alive_units = {}  # type: typing.Dict[str, typing.Dict[UnitType, int]]
+        self.destroyed_objects = []  # type: typing.List[str]
 
+        self._trigger_state = trigger_state
         self._dead_units = dead_units
 
     @classmethod
     def parse(cls, path: str):
+        dead_units = []
+
+        def append_dead_object(object_mission_id_str):
+            nonlocal dead_units
+            object_mission_id = int(object_mission_id_str)
+            if object_mission_id in dead_units:
+                logging.info("debriefing: failed to append_dead_object {}: already exists!".format(object_mission_id))
+                return
+
+            dead_units.append(object_mission_id)
+
+        def parse_dead_object(event):
+            try:
+                append_dead_object(event["initiatorMissionID"])
+            except Exception as e:
+                logging.error(e)
+
         with open(path, "r") as f:
             table_string = f.read()
             try:
@@ -74,51 +95,21 @@ class Debriefing:
                 table = parse_mutliplayer_debriefing(table_string)
 
             events = table.get("debriefing", {}).get("events", {})
-            dead_units = {}
-
             for event in events.values():
                 event_type = event.get("type", None)
-                if event_type != "crash" and event_type != "dead":
-                    continue
+                if event_type in ["crash", "dead"]:
+                    parse_dead_object(event)
 
-                try:
-                    components = event["initiator"].split("|")
-                    print(components)
-                    category, country_id, group_id, unit_type = components[0], int(components[1]), int(components[2]), db.unit_type_from_name(components[3])
-                    if unit_type is None:
-                        print("Skipped due to no unit type")
-                        continue
+            trigger_state = table.get("debriefing", {}).get("triggers_state", {})
 
-                    if category != "unit":
-                        print("Skipped due to category")
-                        continue
-                except Exception as e:
-                    print(e)
-                    continue
+        return Debriefing(dead_units, trigger_state)
 
-                if country_id not in dead_units:
-                    dead_units[country_id] = {}
-
-                if unit_type not in dead_units[country_id]:
-                    dead_units[country_id][unit_type] = 0
-
-                dead_units[country_id][unit_type] += 1
-
-        return Debriefing(dead_units)
-
-    def calculate_units(self, mission: Mission, player_name: str, enemy_name: str):
+    def calculate_units(self, regular_mission: Mission, quick_mission: Mission, player_name: str, enemy_name: str):
         def count_groups(groups: typing.List[UnitType]) -> typing.Dict[UnitType, int]:
             result = {}
             for group in groups:
                 for unit in group.units:
-                    unit_type = None
-                    if isinstance(unit, Vehicle):
-                        unit_type = vehicle_map[unit.type]
-                    elif isinstance(unit, Ship):
-                        unit_type = ship_map[unit.type]
-                    else:
-                        unit_type = unit.unit_type
-
+                    unit_type = db.unit_type_of(unit)
                     if unit_type in db.EXTRA_AA.values():
                         continue
 
@@ -126,6 +117,8 @@ class Debriefing:
 
             return result
 
+        mission = regular_mission if len(self._trigger_state) else quick_mission
+
         player = mission.country(player_name)
         enemy = mission.country(enemy_name)
         
@@ -133,10 +126,40 @@ class Debriefing:
         enemy_units = count_groups(enemy.plane_group + enemy.vehicle_group + enemy.ship_group)
 
         self.destroyed_units = {
-            player.name: self._dead_units.get(player.id, {}),
-            enemy.name: self._dead_units.get(enemy.id, {}),
+            player.name: {},
+            enemy.name: {},
         }
 
+        all_groups = {
+            player.name: player.plane_group + player.helicopter_group + player.vehicle_group + player.ship_group,
+            enemy.name: enemy.plane_group + enemy.helicopter_group + enemy.vehicle_group + enemy.ship_group,
+        }
+
+        static_groups = enemy.static_group
+
+        for country_name, country_groups in all_groups.items():
+            for group in country_groups:
+                for unit in group.units:
+                    if unit.id in self._dead_units:
+                        unit_type = db.unit_type_of(unit)
+                        logging.info("debriefing: found dead unit {} ({}, {})".format(str(unit.name), unit.id, unit_type))
+
+                        assert country_name
+                        assert unit_type
+                        self.destroyed_units[country_name][unit_type] = self.destroyed_units[country_name].get(unit_type, 0) + 1
+                        self._dead_units.remove(unit.id)
+
+        for group in static_groups:
+            identifier = group.units[0].id
+            if identifier in self._dead_units:
+                logging.info("debriefing: found dead static {} ({})".format(str(group.name), identifier))
+
+                assert str(group.name)
+                self.destroyed_objects.append(str(group.name))
+                self._dead_units.remove(identifier)
+
+        logging.info("debriefing: unsatistied ids: {}".format(self._dead_units))
+
         self.alive_units = {
             player.name: {k: v - self.destroyed_units[player.name].get(k, 0) for k, v in player_units.items()},
             enemy.name: {k: v - self.destroyed_units[enemy.name].get(k, 0) for k, v in enemy_units.items()},

userdata/logging.py

@@ -0,0 +1,45 @@
+import logging
+import traceback
+import sys
+
+from io import StringIO
+from tkinter import *
+from tkinter.scrolledtext import *
+
+_version_string = None
+
+
+class ShowLogsException(Exception):
+    pass
+
+
+def _error_prompt(oops=True):
+    tk = Tk()
+    if oops:
+        Label(tk, text="Oops, something went wrong.").grid(row=0)
+    Label(tk, text="Please send following text to the developer:").grid(row=1)
+
+    text = ScrolledText(tk)
+    text.insert("0.0", log_stream.getvalue())
+    text.grid(row=2, sticky=NSEW)
+    tk.focus()
+
+
+def _handle_exception(self, exception: BaseException, *args):
+    logging.exception(exception)
+    _error_prompt(isinstance(exception, ShowLogsException))
+
+
+def setup_version_string(str):
+    global _version_string
+    _version_string = str
+
+
+if "--stdout" in sys.argv:
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+else:
+    log_stream = StringIO()
+    logging.basicConfig(stream=log_stream, level=logging.INFO)
+    Tk.report_callback_exception = _handle_exception
+
+logging.info("DCS Libration {}".format(_version_string))

userdata/persistency.py

@@ -1,6 +1,8 @@
+import logging
 import typing
 import pickle
 import os
+import sys
 import shutil
 
 _user_folder = None  # type: str
@@ -15,11 +17,11 @@ def base_path() -> str:
     global _user_folder
     assert _user_folder
 
-    openbeta_path = os.path.join(_user_folder, "Saved Games", "DCS.openbeta")
-    if os.path.exists(openbeta_path):
+    openbeta_path = os.path.join(_user_folder, "DCS.openbeta")
+    if "--force-stable-DCS" not in sys.argv and os.path.exists(openbeta_path):
         return openbeta_path
     else:
-        return os.path.join(_user_folder, "Saved Games" , "DCS")
+        return os.path.join(_user_folder, "DCS")
 
 
 def _save_file() -> str:
@@ -42,11 +44,8 @@ def restore_game():
     if not _save_file_exists():
         return None
 
-    try:
-        with open(_save_file(), "rb") as f:
-            return pickle.load(f)
-    except Exception as e:
-        raise e
+    with open(_save_file(), "rb") as f:
+        return pickle.load(f)
 
 
 def save_game(game) -> bool:
@@ -56,5 +55,5 @@ def save_game(game) -> bool:
         shutil.copy(_temporary_save_file(), _save_file())
         return True
     except Exception as e:
-        print(e)
+        logging.error(e)
         return False