weyne/dcs-retribution
1
0
Fork 0
mirror of https://github.com/dcs-retribution/dcs-retribution.git synced 2025-11-10 15:41:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

naval intercept operation; package refactoring

Browse Source
This commit is contained in:
Vasyl Horbachenko 2018-06-18 23:57:02 +03:00
parent 3e2f3c6f89
commit e2dbaa100f
33 changed files with 974 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
game/__init__.py
View File

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

15
game/db.py
View File

@ -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]]

320
game/event.py
View File

@ -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)

5
game/event/__init__.py Normal file
View File

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

98
game/event/capture.py Normal file
View File

@ -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

93
game/event/event.py Normal file
View File

@ -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)

68
game/event/groundintercept.py Normal file
View File

@ -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

98
game/event/intercept.py Normal file
View File

@ -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

102
game/event/navalintercept.py Normal file
View File

@ -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

8
game/event_results.py
View File

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

29
game/game.py
View File

@ -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()

221
game/operation.py
View File

@ -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()

0
game/operation/__init__.py Normal file
View File

63
game/operation/capture.py Normal file
View File

@ -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()

39
game/operation/groundintercept.py Normal file
View File

@ -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()

49
game/operation/intercept.py Normal file
View File

@ -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()

49
game/operation/navalintercept.py Normal file
View File

@ -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)

93
game/operation/operation.py Normal file
View File

@ -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

11
gen/__init__.py
View File

@ -1,2 +1,11 @@
import dcs
from .aaa import *
from .aircraft import *
from .armor import *
from .awacsgen import *
from .conflictgen import *
from .shipgen import *
from .visualgen import *
from .settingsgen import *
from . import naming

2
gen/aaa.py
View File

@ -1,4 +1,4 @@
from game import db
from game import *
from theater.conflicttheater import ConflictTheater
from .conflictgen import *

23
gen/aircraft.py
View File

@ -176,7 +176,7 @@ class AircraftConflictGenerator:
groups.append(group)
return groups
def generate_cas(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
def generate_cas_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
assert len(self.escort_targets) == 0
for flying_type, count, client_count in self._split_to_groups(attackers, clients):
@ -195,7 +195,26 @@ class AircraftConflictGenerator:
group.add_waypoint(self.conflict.from_cp.position, RTB_ALTITUDE)
def generate_cas_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
def generate_ship_strikegroup(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
assert len(self.escort_targets) == 0
for flying_type, count, client_count in self._split_to_groups(attackers, clients):
group = self._generate_group(
name=namegen.next_cas_group_name(),
side=self.conflict.attackers_side,
unit_type=flying_type,
count=count,
client_count=client_count,
at=at and at or self._group_point(self.conflict.air_attackers_location))
self.escort_targets.append(group)
group.add_waypoint(self.conflict.position, CAS_ALTITUDE, WARM_START_AIRSPEED)
group.task = AntishipStrike.name
self._setup_group(group, AntishipStrike, clients)
group.add_waypoint(self.conflict.from_cp.position, RTB_ALTITUDE)
def generate_strikegroup_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, at: db.StartingPosition = None):
for g in self._generate_escort(
side=self.conflict.attackers_side,
units=attackers,

34
gen/conflictgen.py
View File

@ -14,6 +14,9 @@ from dcs.point import *
from dcs.task import *
from dcs.country import *
from theater import *
GROUND_DISTANCE_FACTOR = 0.8
GROUNDINTERCEPT_DISTANCE_FACTOR = 3
AIR_DISTANCE = 32000
@ -25,6 +28,9 @@ INTERCEPT_DEFENDERS_DISTANCE = 30000
INTERCEPT_MAX_DISTANCE = 80000
INTERCEPT_MIN_DISTANCE = 45000
NAVAL_INTERCEPT_DISTANCE_FACTOR = 1.3
NAVAL_INTERCEPT_STEP = 3000
def _opposite_heading(h):
return h+180
@ -119,3 +125,31 @@ class Conflict:
instance.ground_defenders_location = instance.position.point_from_heading(random.choice(to_cp.radials), instance.size * GROUNDINTERCEPT_DISTANCE_FACTOR)
return instance
@classmethod
def naval_intercept_conflict(cls, attacker: Country, defender: Country, theater: ConflictTheater, from_cp: ControlPoint, to_cp: ControlPoint):
radial = random.choice(to_cp.sea_radials)
initial_distance = int(from_cp.position.distance_to_point(to_cp.position) * NAVAL_INTERCEPT_DISTANCE_FACTOR)
position = to_cp.position.point_from_heading(radial, initial_distance)
for offset in range(0, initial_distance, NAVAL_INTERCEPT_STEP):
if theater.is_on_land(position):
break
else:
position = to_cp.position.point_from_heading(radial, offset)
instance = cls()
instance.from_cp = from_cp
instance.to_cp = to_cp
instance.attackers_side = attacker
instance.defenders_side = defender
instance.position = position
instance.size = SIZE_REGULAR
instance.radials = to_cp.radials
attacker_heading = from_cp.position.heading_between_point(to_cp.position)
instance.air_attackers_location = instance.position.point_from_heading(attacker_heading, AIR_DISTANCE)
instance.air_defenders_location = instance.position.point_from_heading(_opposite_heading(attacker_heading), AIR_DISTANCE)
return instance

4
gen/settingsgen.py
View File

@ -9,8 +9,8 @@ from dcs.action import *
from dcs.unit import Skill
from game import db
from theater.weatherforecast import WeatherForecast
from theater.conflicttheater import Conflict
from theater import *
from gen import *
ACTIVATION_TRIGGER_SIZE = 40000
ACTIVATION_TRIGGER_MIN_DISTANCE = 5000

21
gen/shipgen.py
View File

@ -1,3 +1,4 @@
from game import db
from .conflictgen import *
from .naming import *
@ -5,15 +6,33 @@ from dcs.mission import *
from dcs.unitgroup import *
from dcs.task import *
SHIP_RANDOM_SPREAD = 300
class ShipGenerator:
def __init__(self, mission: Mission, conflict: Conflict):
self.m = mission
self.conflict = conflict
def generate(self, type: ShipType, country: str, at: Point) -> ShipGroup:
def generate_carrier(self, type: ShipType, country: str, at: Point) -> ShipGroup:
return self.m.ship_group(
country=self.m.country(country),
name=namegen.next_transport_group_name(),
_type=type,
position=at)
def generate_cargo(self, units: db.ShipDict) -> typing.Collection[ShipGroup]:
groups = []
for unit_type, unit_count in units.items():
group = self.m.ship_group(
country=self.conflict.defenders_side,
name=namegen.next_transport_group_name(),
_type=unit_type,
position=self.conflict.position.random_point_within(SHIP_RANDOM_SPREAD, SHIP_RANDOM_SPREAD),
group_size=unit_count,
)
group.add_waypoint(self.conflict.to_cp.position)
groups.append(group)
return groups

3
gen/visualgen.py
View File

@ -6,7 +6,8 @@ from dcs.mission import Mission
from dcs.statics import *
from dcs.unit import Static
from theater.conflicttheater import Conflict
from theater import *
from .conflictgen import *
#from game.game import Game

3
theater/__init__.py
View File

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

7
theater/base.py
View File

@ -88,13 +88,6 @@ class Base:
total_scrambled += PLANES_IN_GROUP
yield total_scrambled < total_planes and PLANES_IN_GROUP or total_planes - total_scrambled
def _group_sizes_for(self, target: ControlPoint) -> typing.List[int]:
total_planes = target.importance * PLANES_IMPORTANCE_FACTOR
total_scrambled = 0
for _ in range(math.ceil(total_planes / PLANES_IN_GROUP)):
total_scrambled += PLANES_IN_GROUP
yield PLANES_IN_GROUP and total_scrambled < total_planes or total_planes - total_scrambled
def append_commision_points(self, for_type, points: float) -> int:
self.commision_points[for_type] = self.commision_points.get(for_type, 0) + points
points = self.commision_points[for_type]

3
theater/conflicttheater.py
View File

@ -2,9 +2,10 @@ import typing
import itertools
import dcs
from dcs.mapping import Point
from .landmap import ray_tracing
from .controlpoint import *
from .controlpoint import ControlPoint
SIZE_TINY = 150
SIZE_SMALL = 600

24
theater/controlpoint.py
View File

@ -5,8 +5,6 @@ from dcs.mapping import *
from dcs.country import *
from dcs.terrain import Airport
from gen.conflictgen import Conflict
class ControlPoint:
connected_points = [] # type: typing.List[ControlPoint]
@ -47,6 +45,16 @@ class ControlPoint:
def is_global(self):
return not self.connected_points
@property
def sea_radials(self) -> typing.Collection[int]:
# TODO: fix imports
all_radials = [0, 45, 90, 135, 180, 225, 270, 315, ]
result = []
for r in all_radials:
if r not in self.radials:
result.append(r)
return result
def connect(self, to):
self.connected_points.append(to)
@ -64,15 +72,3 @@ class ControlPoint:
return closest_radial
def conflict_attack(self, from_cp, attacker: Country, defender: Country) -> Conflict:
attack_radial = self.find_radial(self.position.heading_between_point(from_cp.position))
defense_radial = self.find_radial(from_cp.position.heading_between_point(self.position), ignored_radial=attack_radial)
pos = self.position.point_from_heading(0, 1000)
return Conflict.capture_conflict(attacker=attacker,
attack_heading=attack_radial,
defender=defender,
defense_heading=defense_radial,
position=pos,
size=self.size,
radials=self.radials)

7
theater/landmap.py
View File

@ -2,8 +2,11 @@ import pickle
def load_poly(filename: str):
with open(filename, "rb") as f:
return pickle.load(f)
try:
with open(filename, "rb") as f:
return pickle.load(f)
except:
return None
def ray_tracing(x, y, poly):

79
ui/eventmenu.py
View File

@ -1,7 +1,7 @@
from ui.eventresultsmenu import *
from game.game import *
from game import event, db
from game import *
from game.event import *
class EventMenu(Menu):
@ -40,33 +40,37 @@ class EventMenu(Menu):
def scrable_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=10)
scramble_entry.grid(column=1, row=row)
scramble_entry = Entry(self.frame, width=2)
scramble_entry.grid(column=1, row=row, sticky=W)
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)
client_entry = Entry(self.frame, width=10)
client_entry.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=10)
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
Label(self.frame, text="{}. {}".format(self.event, self.event.threat_description)).grid(row=row, column=0, columnspan=3)
Label(self.frame, text="{}. {}".format(self.event, self.event.threat_description)).grid(row=row, column=0, columnspan=5)
row += 1
Button(self.frame, text="Commit", command=self.start).grid(column=1, row=row, sticky=E)
Button(self.frame, text="Back", command=self.dismiss).grid(column=2, row=row, sticky=E)
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)
@ -75,8 +79,8 @@ class EventMenu(Menu):
label("Aircraft")
if self.base.aircraft:
label("Amount", row, 1)
label("Client slots", row, 2)
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():
@ -92,6 +96,43 @@ class EventMenu(Menu):
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]
else:
entry = self.armor_scramble_entries[unit_type]
total_count = self.base.armor[unit_type]
existing_count = int(entry.get())
entry.delete(0, END)
entry.insert(0, "{}".format(int(existing_count + math.ceil(total_count/2))))
return action
def client_one(self, unit_type: UnitType) -> typing.Callable:
def action():
entry = self.aircraft_client_entries[unit_type] # type: Entry
amount = int(entry.get())
entry.delete(0, END)
entry.insert(0, str(amount+1))
return action
def start(self):
if self.awacs.get() == 1:
self.event.is_awacs_enabled = True
@ -103,9 +144,8 @@ class EventMenu(Menu):
scrambled_sweep = {}
scrambled_cas = {}
for unit_type, field in self.aircraft_scramble_entries.items():
value = field.get()
if value and int(value) > 0:
amount = min(int(value), self.base.aircraft[unit_type])
amount = self._scrambled_aircraft_count(unit_type)
if amount > 0:
task = db.unit_task(unit_type)
scrambled_aircraft[unit_type] = amount
@ -123,9 +163,9 @@ class EventMenu(Menu):
scrambled_armor = {}
for unit_type, field in self.armor_scramble_entries.items():
value = field.get()
if value and int(value) > 0:
scrambled_armor[unit_type] = int(value)
amount = self._scrambled_armor_count(unit_type)
if amount > 0:
scrambled_armor[unit_type] = amount
if type(self.event) is CaptureEvent:
e = self.event # type: CaptureEvent
@ -148,6 +188,9 @@ class EventMenu(Menu):
elif type(self.event) is GroundInterceptEvent:
e = self.event # type: GroundInterceptEvent
e.player_attacking(strikegroup=scrambled_aircraft, clients=scrambled_clients)
elif type(self.event) is NavalInterceptEvent:
e = self.event # type: NavalInterceptEvent
e.player_attacking(strikegroup=scrambled_aircraft, clients=scrambled_clients)
self.game.initiate_event(self.event)
EventResultsMenu(self.window, self.parent, self.game, self.event).display()

1
ui/eventresultsmenu.py
View File

@ -2,6 +2,7 @@ from tkinter.ttk import *
from ui.window import *
from game.game import *
from userdata.debriefing import *
class EventResultsMenu(Menu):

2
ui/overviewcanvas.py
View File

@ -1,3 +1,5 @@
import os
from tkinter import *
from tkinter.ttk import *