naval intercept operation; package refactoring

game/__init__.py

@@ -0,0 +1,2 @@
+from .game import Game
+from . import db

game/db.py

@@ -71,6 +71,9 @@ PRICES = {
     # ship
     CV_1143_5_Admiral_Kuznetsov: 100,
     CVN_74_John_C__Stennis: 100,
+
+    Bulk_cargo_ship_Yakushev: 100,
+    Dry_cargo_ship_Ivanov: 100,
 }
 
 UNIT_BY_TASK = {
@@ -130,7 +133,9 @@ UNIT_BY_TASK = {
         AirDefence.SAM_SA_19_Tunguska_2S6,
         AirDefence.SAM_SA_8_Osa_9A33,
     ],
+
     Carriage: [CVN_74_John_C__Stennis, CV_1143_5_Admiral_Kuznetsov, ],
+    CargoTransportation: [Dry_cargo_ship_Ivanov, Bulk_cargo_ship_Yakushev],
 }
 
 SAM_BAN = [
@@ -185,7 +190,10 @@ UNIT_BY_COUNTRY = {
         Armor.MBT_T_90,
         Armor.MBT_T_80U,
         Armor.MBT_T_55,
-        CV_1143_5_Admiral_Kuznetsov],
+        CV_1143_5_Admiral_Kuznetsov,
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
+    ],
 
     "USA": [
         F_15C,
@@ -212,6 +220,9 @@ UNIT_BY_COUNTRY = {
         AirDefence.SAM_Patriot_ICC,
 
         CVN_74_John_C__Stennis,
+        # TODO: verify or find out proper USA cargo ship
+        Bulk_cargo_ship_Yakushev,
+        Dry_cargo_ship_Ivanov,
     ],
 }
 
@@ -220,6 +231,7 @@ PLANE_PAYLOAD_OVERRIDES = {
         "*": "AIM-9M*6, AIM-7M*2, FUEL*3",
     },
 
+    # TODO: figure out a way to setup su33 loadout
     Su_33: FighterSweep,
 
     M_2000C: {
@@ -238,6 +250,7 @@ PLANE_LIVERY_OVERRIDES = {
 UnitsDict = typing.Dict[UnitType, int]
 PlaneDict = typing.Dict[FlyingType, int]
 ArmorDict = typing.Dict[VehicleType, int]
+ShipDict = typing.Dict[ShipType, int]
 AirDefenseDict = typing.Dict[AirDefence, int]
 StartingPosition = typing.Optional[typing.Union[ShipGroup, Airport, Point]]
 

game/event.py

@@ -1,320 +0,0 @@
-from game.operation import *
-
-DIFFICULTY_LOG_BASE = 1.5
-
-
-class Event:
-    silent = False
-    informational = False
-    is_awacs_enabled = False
-    operation = None  # type: Operation
-    difficulty = 1  # type: int
-    BONUS_BASE = 0
-
-    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
-        self.attacker_name = attacker_name
-        self.defender_name = defender_name
-        self.to_cp = to_cp
-        self.from_cp = from_cp
-        self.game = game
-
-    @property
-    def is_player_attacking(self) -> bool:
-        return self.attacker_name == self.game.player
-
-    @property
-    def enemy_cp(self) -> ControlPoint:
-        if self.attacker_name == self.game.player:
-            return self.to_cp
-        else:
-            return self.from_cp
-
-    @property
-    def threat_description(self) -> str:
-        return ""
-
-    def bonus(self) -> int:
-        return math.ceil(math.log(self.difficulty, DIFFICULTY_LOG_BASE) * self.BONUS_BASE)
-
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return self.operation.is_successfull(debriefing)
-
-    def generate(self):
-        self.operation.is_awacs_enabled = self.is_awacs_enabled
-        self.operation.prepare(self.game.theater.terrain, is_quick=False)
-        self.operation.generate()
-        self.operation.mission.save("build/nextturn.miz")
-
-    def generate_quick(self):
-        self.operation.is_awacs_enabled = self.is_awacs_enabled
-        self.operation.prepare(self.game.theater.terrain, is_quick=True)
-        self.operation.generate()
-        self.operation.mission.save('build/nextturn_quick.miz')
-
-    def commit(self, debriefing: Debriefing):
-        for country, losses in debriefing.destroyed_units.items():
-            if country == self.attacker_name:
-                cp = self.from_cp
-            else:
-                cp = self.to_cp
-
-            cp.base.commit_losses(losses)
-
-    def skip(self):
-        pass
-
-
-class GroundInterceptEvent(Event):
-    BONUS_BASE = 3
-    TARGET_AMOUNT_FACTOR = 2
-    TARGET_VARIETY = 2
-    STRENGTH_INFLUENCE = 0.3
-    SUCCESS_TARGETS_HIT_PERCENTAGE = 0.5
-
-    targets = None  # type: db.ArmorDict
-
-    def __str__(self):
-        return "Ground intercept 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
-
-        return (float(destroyed_targets) / float(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:
-            assert False
-
-    def skip(self):
-        if not self.to_cp.captured:
-            self.to_cp.base.affect_strength(+0.1)
-        else:
-            pass
-
-    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}
-
-        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)
-
-        self.operation = op
-
-
-class InterceptEvent(Event):
-    BONUS_BASE = 5
-    STRENGTH_INFLUENCE = 0.3
-    GLOBAL_STRENGTH_INFLUENCE = 0.3
-    AIRDEFENSE_COUNT = 3
-
-    transport_unit = None  # type: FlyingType
-
-    def __str__(self):
-        return "Intercept from {} at {}".format(self.from_cp, self.to_cp)
-
-    @property
-    def threat_description(self):
-        return "{} aircraft".format(self.enemy_cp.base.scramble_count())
-
-    def is_successfull(self, debriefing: Debriefing):
-        units_destroyed = debriefing.destroyed_units[self.defender_name].get(self.transport_unit, 0)
-        if self.from_cp.captured:
-            return units_destroyed > 0
-        else:
-            return units_destroyed == 0
-
-    def commit(self, debriefing: Debriefing):
-        super(InterceptEvent, self).commit(debriefing)
-
-        if self.attacker_name == self.game.player:
-            if self.is_successfull(debriefing):
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-        else:
-            # enemy attacking
-            if self.is_successfull(debriefing):
-                self.from_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-            else:
-                self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
-
-    def player_attacking(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        escort = self.to_cp.base.scramble_sweep()
-
-        self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
-        assert self.transport_unit is not None
-
-        airdefense_unit = db.find_unittype(AirDefence, self.defender_name)[-1]
-        op = InterceptOperation(game=self.game,
-                                attacker_name=self.attacker_name,
-                                defender_name=self.defender_name,
-                                attacker_clients=clients,
-                                defender_clients={},
-                                from_cp=self.from_cp,
-                                to_cp=self.to_cp)
-
-        op.setup(escort=escort,
-                 transport={self.transport_unit: 1},
-                 airdefense={airdefense_unit: self.AIRDEFENSE_COUNT},
-                 interceptors=interceptors)
-
-        self.operation = op
-
-    def player_defending(self, escort: db.PlaneDict, clients: db.PlaneDict):
-        interceptors = self.from_cp.base.scramble_interceptors()
-
-        self.transport_unit = random.choice(db.find_unittype(Transport, self.defender_name))
-        assert self.transport_unit is not None
-
-        op = InterceptOperation(game=self.game,
-                                attacker_name=self.attacker_name,
-                                defender_name=self.defender_name,
-                                attacker_clients={},
-                                defender_clients=clients,
-                                from_cp=self.from_cp,
-                                to_cp=self.to_cp)
-
-        op.setup(escort=escort,
-                 transport={self.transport_unit: 1},
-                 interceptors=interceptors,
-                 airdefense={})
-
-        self.operation = op
-
-
-class CaptureEvent(Event):
-    silent = True
-    BONUS_BASE = 7
-    STRENGTH_RECOVERY = 0.35
-
-    def __str__(self):
-        return "Attack from {} to {}".format(self.from_cp, self.to_cp)
-
-    @property
-    def threat_description(self):
-        descr = "{} aircraft + CAS, {} vehicles".format(
-            self.enemy_cp.base.scramble_count(),
-            self.enemy_cp.base.assemble_count()
-        )
-
-        if self.is_player_attacking:
-            descr += ", {} AA".format(self.enemy_cp.base.assemble_aa_count())
-
-        return descr
-
-    def is_successfull(self, debriefing: Debriefing):
-        alive_attackers = sum(debriefing.alive_units[self.attacker_name].values())
-        alive_defenders = sum(debriefing.alive_units[self.defender_name].values())
-        attackers_success = alive_attackers > alive_defenders
-        if self.from_cp.captured:
-            return attackers_success
-        else:
-            return not attackers_success
-
-    def commit(self, debriefing: Debriefing):
-        super(CaptureEvent, self).commit(debriefing)
-        if self.is_successfull(debriefing):
-            if self.from_cp.captured:
-                self.to_cp.captured = True
-                self.to_cp.base.filter_units(db.UNIT_BY_COUNTRY[self.attacker_name])
-
-            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
-        else:
-            if not self.from_cp.captured:
-                self.to_cp.captured = False
-            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
-
-    def skip(self):
-        if self.to_cp.captured:
-            self.to_cp.captured = False
-
-    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
-        cas = self.from_cp.base.scramble_cas()
-        escort = self.from_cp.base.scramble_sweep()
-        attackers = self.from_cp.base.assemble_cap()
-
-        op = CaptureOperation(game=self.game,
-                              attacker_name=self.attacker_name,
-                              defender_name=self.defender_name,
-                              attacker_clients={},
-                              defender_clients=clients,
-                              from_cp=self.from_cp,
-                              to_cp=self.to_cp)
-
-        op.setup(cas=cas,
-                 escort=escort,
-                 attack=attackers,
-                 intercept=interceptors,
-                 defense=self.to_cp.base.armor,
-                 aa=self.to_cp.base.aa)
-
-        self.operation = op
-
-    def player_attacking(self, cas: db.PlaneDict, escort: db.PlaneDict, armor: db.ArmorDict, clients: db.PlaneDict):
-        interceptors = self.to_cp.base.scramble_sweep()
-
-        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)
-
-        op.setup(cas=cas,
-                 escort=escort,
-                 attack=armor,
-                 intercept=interceptors,
-                 defense=self.to_cp.base.armor,
-                 aa=self.to_cp.base.assemble_aa())
-
-        self.operation = op
-
-
-class UnitsDeliveryEvent(Event):
-    informational = True
-    units = None  # type: typing.Dict[UnitType, int]
-
-    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
-        super(UnitsDeliveryEvent, self).__init__(attacker_name=attacker_name,
-                                                 defender_name=defender_name,
-                                                 from_cp=from_cp,
-                                                 to_cp=to_cp,
-                                                 game=game)
-
-        self.units = {}
-
-    def __str__(self):
-        return "Pending delivery to {}".format(self.to_cp)
-
-    def deliver(self, units: typing.Dict[UnitType, int]):
-        for k, v in units.items():
-            self.units[k] = self.units.get(k, 0) + v
-
-    def skip(self):
-        self.to_cp.base.commision_units(self.units)

game/event/__init__.py

@@ -0,0 +1,5 @@
+from .event import *
+from .groundintercept import *
+from .intercept import *
+from .capture import *
+from .navalintercept import *

game/event/capture.py

@@ -0,0 +1,98 @@
+import math
+import random
+
+from game import db
+from game.operation.capture import CaptureOperation
+from userdata.debriefing import Debriefing
+
+from .event import Event
+
+
+class CaptureEvent(Event):
+    silent = True
+    BONUS_BASE = 7
+    STRENGTH_RECOVERY = 0.35
+
+    def __str__(self):
+        return "Attack from {} to {}".format(self.from_cp, self.to_cp)
+
+    @property
+    def threat_description(self):
+        descr = "{} aircraft + CAS, {} vehicles".format(
+            self.enemy_cp.base.scramble_count(),
+            self.enemy_cp.base.assemble_count()
+        )
+
+        if self.is_player_attacking:
+            descr += ", {} AA".format(self.enemy_cp.base.assemble_aa_count())
+
+        return descr
+
+    def is_successfull(self, debriefing: Debriefing):
+        alive_attackers = sum(debriefing.alive_units[self.attacker_name].values())
+        alive_defenders = sum(debriefing.alive_units[self.defender_name].values())
+        attackers_success = alive_attackers > alive_defenders
+        if self.from_cp.captured:
+            return attackers_success
+        else:
+            return not attackers_success
+
+    def commit(self, debriefing: Debriefing):
+        super(CaptureEvent, self).commit(debriefing)
+        if self.is_successfull(debriefing):
+            if self.from_cp.captured:
+                self.to_cp.captured = True
+                self.to_cp.base.filter_units(db.UNIT_BY_COUNTRY[self.attacker_name])
+
+            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
+        else:
+            if not self.from_cp.captured:
+                self.to_cp.captured = False
+            self.to_cp.base.affect_strength(+self.STRENGTH_RECOVERY)
+
+    def skip(self):
+        if self.to_cp.captured:
+            self.to_cp.captured = False
+
+    def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
+        cas = self.from_cp.base.scramble_cas()
+        escort = self.from_cp.base.scramble_sweep()
+        attackers = self.from_cp.base.assemble_cap()
+
+        op = CaptureOperation(game=self.game,
+                              attacker_name=self.attacker_name,
+                              defender_name=self.defender_name,
+                              attacker_clients={},
+                              defender_clients=clients,
+                              from_cp=self.from_cp,
+                              to_cp=self.to_cp)
+
+        op.setup(cas=cas,
+                 escort=escort,
+                 attack=attackers,
+                 intercept=interceptors,
+                 defense=self.to_cp.base.armor,
+                 aa=self.to_cp.base.aa)
+
+        self.operation = op
+
+    def player_attacking(self, cas: db.PlaneDict, escort: db.PlaneDict, armor: db.ArmorDict, clients: db.PlaneDict):
+        interceptors = self.to_cp.base.scramble_sweep()
+
+        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)
+
+        op.setup(cas=cas,
+                 escort=escort,
+                 attack=armor,
+                 intercept=interceptors,
+                 defense=self.to_cp.base.armor,
+                 aa=self.to_cp.base.assemble_aa())
+
+        self.operation = op
+

game/event/event.py

@@ -0,0 +1,93 @@
+from dcs.unittype import UnitType
+
+from game import *
+from theater import *
+
+from userdata.debriefing import Debriefing
+
+DIFFICULTY_LOG_BASE = 1.5
+
+
+class Event:
+    silent = False
+    informational = False
+    is_awacs_enabled = False
+    operation = None  # type: Operation
+    difficulty = 1  # type: int
+    BONUS_BASE = 0
+
+    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
+        self.attacker_name = attacker_name
+        self.defender_name = defender_name
+        self.to_cp = to_cp
+        self.from_cp = from_cp
+        self.game = game
+
+    @property
+    def is_player_attacking(self) -> bool:
+        return self.attacker_name == self.game.player
+
+    @property
+    def enemy_cp(self) -> ControlPoint:
+        if self.attacker_name == self.game.player:
+            return self.to_cp
+        else:
+            return self.from_cp
+
+    @property
+    def threat_description(self) -> str:
+        return ""
+
+    def bonus(self) -> int:
+        return math.ceil(math.log(self.difficulty, DIFFICULTY_LOG_BASE) * self.BONUS_BASE)
+
+    def is_successfull(self, debriefing: Debriefing) -> bool:
+        return self.operation.is_successfull(debriefing)
+
+    def generate(self):
+        self.operation.is_awacs_enabled = self.is_awacs_enabled
+        self.operation.prepare(self.game.theater.terrain, is_quick=False)
+        self.operation.generate()
+        self.operation.mission.save("build/nextturn.miz")
+
+    def generate_quick(self):
+        self.operation.is_awacs_enabled = self.is_awacs_enabled
+        self.operation.prepare(self.game.theater.terrain, is_quick=True)
+        self.operation.generate()
+        self.operation.mission.save('build/nextturn_quick.miz')
+
+    def commit(self, debriefing: Debriefing):
+        for country, losses in debriefing.destroyed_units.items():
+            if country == self.attacker_name:
+                cp = self.from_cp
+            else:
+                cp = self.to_cp
+
+            cp.base.commit_losses(losses)
+
+    def skip(self):
+        pass
+
+
+class UnitsDeliveryEvent(Event):
+    informational = True
+    units = None  # type: typing.Dict[UnitType, int]
+
+    def __init__(self, attacker_name: str, defender_name: str, from_cp: ControlPoint, to_cp: ControlPoint, game):
+        super(UnitsDeliveryEvent, self).__init__(attacker_name=attacker_name,
+                                                 defender_name=defender_name,
+                                                 from_cp=from_cp,
+                                                 to_cp=to_cp,
+                                                 game=game)
+
+        self.units = {}
+
+    def __str__(self):
+        return "Pending delivery to {}".format(self.to_cp)
+
+    def deliver(self, units: typing.Dict[UnitType, int]):
+        for k, v in units.items():
+            self.units[k] = self.units.get(k, 0) + v
+
+    def skip(self):
+        self.to_cp.base.commision_units(self.units)

game/event/groundintercept.py

@@ -0,0 +1,68 @@
+import math
+import random
+
+from dcs.task import *
+
+from game import *
+from game.event import *
+from userdata.debriefing import Debriefing
+
+
+class GroundInterceptEvent(Event):
+    BONUS_BASE = 3
+    TARGET_AMOUNT_FACTOR = 2
+    TARGET_VARIETY = 2
+    STRENGTH_INFLUENCE = 0.3
+    SUCCESS_TARGETS_HIT_PERCENTAGE = 0.5
+
+    targets = None  # type: db.ArmorDict
+
+    def __str__(self):
+        return "Ground intercept 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
+
+        return (float(destroyed_targets) / float(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:
+            assert False
+
+    def skip(self):
+        if not self.to_cp.captured:
+            self.to_cp.base.affect_strength(+0.1)
+        else:
+            pass
+
+    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}
+
+        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)
+
+        self.operation = op
+
+

game/event/intercept.py

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

game/event/navalintercept.py

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

game/event_results.py

@@ -1,8 +0,0 @@
-import typing
-import dcs
-
-from game.event import  *
-
-
-
-

game/game.py

@@ -1,4 +1,15 @@
-from game.event import *
+import typing
+import random
+import math
+
+from dcs.task import *
+from dcs.vehicles import *
+
+from userdata.debriefing import Debriefing
+from theater import *
+
+from . import db
+from .event import *
 
 COMMISION_LIMITS_SCALE = 2
 COMMISION_LIMITS_FACTORS = {
@@ -124,6 +135,19 @@ class Game:
                                                         game=self))
                 break
 
+    def _generate_navalinterceptions(self):
+        for from_cp, to_cp in self.theater.conflicts(True):
+            if to_cp.radials == ALL_RADIALS:
+                continue
+
+            if self._roll(100, from_cp.base.strength):
+                self.events.append(NavalInterceptEvent(attacker_name=self.player,
+                                                       defender_name=self.enemy,
+                                                       from_cp=from_cp,
+                                                       to_cp=to_cp,
+                                                       game=self))
+                break
+
     def _generate_globalinterceptions(self):
         global_count = len([x for x in self.theater.player_points() if x.is_global])
         for from_cp in [x for x in self.theater.player_points() if x.is_global]:
@@ -205,8 +229,9 @@ class Game:
 
         self.events = []  # type: typing.List[Event]
         self._fill_cap_events()
-        self._generate_enemy_caps(ignored_cps=ignored_cps)
+        #self._generate_enemy_caps(ignored_cps=ignored_cps)
         self._generate_interceptions()
         self._generate_globalinterceptions()
         self._generate_groundinterceptions()
+        self._generate_navalinterceptions()
 

game/operation.py

@@ -1,221 +0,0 @@
-from userdata.debriefing import *
-from theater.conflicttheater import *
-from theater.base import *
-
-from gen.armor import *
-from gen.aircraft import *
-from gen.aaa import *
-from gen.shipgen import *
-from gen.conflictgen import *
-from gen.settingsgen import *
-from gen.awacsgen import *
-from gen.visualgen import *
-
-
-class Operation:
-    attackers_starting_position = None  # type: db.StartingPosition
-    defenders_starting_position = None  # type: db.StartingPosition
-    mission = None  # type: dcs.Mission
-    conflict = None  # type: Conflict
-    armorgen = None  # type: ArmorConflictGenerator
-    airgen = None  # type: AircraftConflictGenerator
-    aagen = None  # type: AAConflictGenerator
-    extra_aagen = None  # type: ExtraAAConflictGenerator
-    shipgen = None  # type: ShipGenerator
-    envgen = None  # type: SettingsGenerator
-    awacsgen = None  # type: AWACSConflictGenerator
-    visualgen = None  # type: VisualGenerator
-
-    is_awacs_enabled = False
-
-    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
-
-        self.armorgen = ArmorConflictGenerator(mission, conflict)
-        self.airgen = AircraftConflictGenerator(mission, conflict)
-        self.aagen = AAConflictGenerator(mission, conflict)
-        self.shipgen = ShipGenerator(mission, conflict)
-        self.awacsgen = AWACSConflictGenerator(mission, conflict, self.game)
-        self.envgen = SettingsGenerator(mission, conflict, self.game)
-        self.visualgen = VisualGenerator(mission, conflict, self.game)
-
-        player_name = self.from_cp.captured and self.attacker_name or self.defender_name
-        enemy_name = self.from_cp.captured and self.defender_name or self.attacker_name
-        self.extra_aagen = ExtraAAConflictGenerator(mission, conflict, self.game, player_name, enemy_name)
-
-    def prepare(self, terrain: dcs.terrain.Terrain, is_quick: bool):
-        self.mission = dcs.Mission(terrain)
-        self.is_quick = is_quick
-
-        if is_quick:
-            self.attackers_starting_position = None
-            self.defenders_starting_position = None
-        else:
-            self.attackers_starting_position = self.from_cp.at
-            self.defenders_starting_position = self.to_cp.at
-
-    def generate(self):
-        self.visualgen.generate()
-
-        if self.is_awacs_enabled:
-            self.awacsgen.generate()
-
-        self.extra_aagen.generate()
-        self.envgen.generate(self.is_quick)
-
-        for global_cp in self.game.theater.controlpoints:
-            if not global_cp.is_global:
-                continue
-
-            ship = self.shipgen.generate(type=db.find_unittype(Carriage, self.game.player)[0],
-                                         country=self.game.player,
-                                         at=global_cp.at)
-
-            if global_cp == self.from_cp and not self.is_quick:
-                self.attackers_starting_position = ship
-
-    def units_of(self, country_name: str) -> typing.Collection[UnitType]:
-        return []
-
-    def is_successfull(self, debriefing: Debriefing) -> bool:
-        return True
-
-
-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
-
-    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
-        )
-        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(self.cas, clients=self.attacker_clients, at=self.attackers_starting_position)
-        self.airgen.generate_cas_escort(self.escort, clients=self.attacker_clients, at=self.attackers_starting_position)
-
-        self.visualgen.generate_target_smokes(self.to_cp)
-        super(CaptureOperation, self).generate()
-
-
-class InterceptOperation(Operation):
-    escort = None  # type: db.PlaneDict
-    transport = None  # type: db.PlaneDict
-    interceptors = None  # type: db.PlaneDict
-    airdefense = None  # type: db.AirDefenseDict
-
-    def setup(self,
-              escort: db.PlaneDict,
-              transport: db.PlaneDict,
-              airdefense: db.AirDefenseDict,
-              interceptors: db.PlaneDict):
-        self.escort = escort
-        self.transport = transport
-        self.airdefense = airdefense
-        self.interceptors = interceptors
-
-    def prepare(self, terrain: dcs.terrain.Terrain, is_quick: bool):
-        super(InterceptOperation, self).prepare(terrain, is_quick)
-        self.defenders_starting_position = None
-        if self.defender_name == self.game.player:
-            self.attackers_starting_position = None
-
-        conflict = Conflict.intercept_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_transport(self.transport, self.to_cp.at)
-        self.airgen.generate_transport_escort(self.escort, clients=self.defender_clients)
-
-        if self.from_cp.is_global:
-            super(InterceptOperation, self).generate()
-            self.airgen.generate_interception(self.interceptors, clients=self.attacker_clients, at=self.attackers_starting_position)
-        else:
-            self.airgen.generate_interception(self.interceptors, clients=self.attacker_clients, at=self.attackers_starting_position)
-            super(InterceptOperation, self).generate()
-
-
-class GroundInterceptOperation(Operation):
-    def setup(self,
-              target: db.ArmorDict,
-              strikegroup: db.PlaneDict):
-        self.strikegroup = strikegroup
-        self.target = target
-
-    def prepare(self, terrain: dcs.terrain.Terrain, is_quick: bool):
-        super(GroundInterceptOperation, self).prepare(terrain, is_quick)
-        conflict = Conflict.ground_intercept_conflict(
-            attacker=self.mission.country(self.attacker_name),
-            defender=self.mission.country(self.defender_name),
-            heading=self.to_cp.position.heading_between_point(self.from_cp.position),
-            from_cp=self.from_cp,
-            to_cp=self.to_cp
-        )
-
-        self.initialize(mission=self.mission,
-                        conflict=conflict)
-
-    def generate(self):
-        self.airgen.generate_cas(self.strikegroup, clients=self.attacker_clients, at=self.attackers_starting_position)
-        self.armorgen.generate({}, self.target)
-
-        super(GroundInterceptOperation, self).generate()

game/operation/capture.py

@@ -0,0 +1,63 @@
+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.settingsgen 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
+
+    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
+        )
+        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/groundintercept.py

@@ -0,0 +1,39 @@
+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.settingsgen import *
+from gen.awacsgen import *
+from gen.visualgen import *
+from gen.conflictgen import Conflict
+
+from .operation import Operation
+
+class GroundInterceptOperation(Operation):
+    def setup(self,
+              target: db.ArmorDict,
+              strikegroup: db.PlaneDict):
+        self.strikegroup = strikegroup
+        self.target = target
+
+    def prepare(self, terrain: Terrain, is_quick: bool):
+        super(GroundInterceptOperation, self).prepare(terrain, is_quick)
+        conflict = Conflict.ground_intercept_conflict(
+            attacker=self.mission.country(self.attacker_name),
+            defender=self.mission.country(self.defender_name),
+            heading=self.to_cp.position.heading_between_point(self.from_cp.position),
+            from_cp=self.from_cp,
+            to_cp=self.to_cp
+        )
+
+        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)
+        self.armorgen.generate({}, self.target)
+
+        super(GroundInterceptOperation, self).generate()

game/operation/intercept.py

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

game/operation/navalintercept.py

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

game/operation/operation.py

@@ -0,0 +1,93 @@
+from dcs.terrain import Terrain
+
+from userdata.debriefing import *
+
+from theater import *
+from gen import *
+
+
+class Operation:
+    attackers_starting_position = None  # type: db.StartingPosition
+    defenders_starting_position = None  # type: db.StartingPosition
+    mission = None  # type: dcs.Mission
+    conflict = None  # type: Conflict
+    armorgen = None  # type: ArmorConflictGenerator
+    airgen = None  # type: AircraftConflictGenerator
+    aagen = None  # type: AAConflictGenerator
+    extra_aagen = None  # type: ExtraAAConflictGenerator
+    shipgen = None  # type: ShipGenerator
+    envgen = None  # type: SettingsGenerator
+    awacsgen = None  # type: AWACSConflictGenerator
+    visualgen = None  # type: VisualGenerator
+
+    is_awacs_enabled = False
+
+    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
+
+        self.armorgen = ArmorConflictGenerator(mission, conflict)
+        self.airgen = AircraftConflictGenerator(mission, conflict)
+        self.aagen = AAConflictGenerator(mission, conflict)
+        self.shipgen = ShipGenerator(mission, conflict)
+        self.awacsgen = AWACSConflictGenerator(mission, conflict, self.game)
+        self.envgen = SettingsGenerator(mission, conflict, self.game)
+        self.visualgen = VisualGenerator(mission, conflict, self.game)
+
+        player_name = self.from_cp.captured and self.attacker_name or self.defender_name
+        enemy_name = self.from_cp.captured and self.defender_name or self.attacker_name
+        self.extra_aagen = ExtraAAConflictGenerator(mission, conflict, self.game, player_name, enemy_name)
+
+    def prepare(self, terrain: Terrain, is_quick: bool):
+        self.mission = dcs.Mission(terrain)
+        self.is_quick = is_quick
+
+        if is_quick:
+            self.attackers_starting_position = None
+            self.defenders_starting_position = None
+        else:
+            self.attackers_starting_position = self.from_cp.at
+            self.defenders_starting_position = self.to_cp.at
+
+    def generate(self):
+        self.visualgen.generate()
+
+        if self.is_awacs_enabled:
+            self.awacsgen.generate()
+
+        self.extra_aagen.generate()
+        self.envgen.generate(self.is_quick)
+
+        for global_cp in self.game.theater.controlpoints:
+            if not global_cp.is_global:
+                continue
+
+            ship = self.shipgen.generate_carrier(type=db.find_unittype(Carriage, self.game.player)[0],
+                                                 country=self.game.player,
+                                                 at=global_cp.at)
+
+            if global_cp == self.from_cp and not self.is_quick:
+                self.attackers_starting_position = ship
+
+    def units_of(self, country_name: str) -> typing.Collection[UnitType]:
+        return []
+
+    def is_successfull(self, debriefing: Debriefing) -> bool:
+        return True