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

configure client slots on scramble + fixes

Browse Source
This commit is contained in:
Vasyl Horbachenko 2018-06-05 04:14:39 +03:00
parent 0f569d43b0
commit fb377cb6ca
14 changed files with 183 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/dcs_pmcliberation.iml generated
View File

@ -4,7 +4,7 @@
<content url="file://$MODULE_DIR$">
<excludeFolder url="file://$MODULE_DIR$/venv" />
</content>
<orderEntry type="jdk" jdkName="Python 3.6" jdkType="Python SDK" />
<orderEntry type="jdk" jdkName="Python 3.6 (venv)" jdkType="Python SDK" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
<component name="TestRunnerService">

2
.idea/misc.xml generated
View File

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.6" project-jdk-type="Python SDK" />
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.6 (venv)" project-jdk-type="Python SDK" />
</project>

3
__init__.py
View File

@ -10,6 +10,7 @@ import ui.window
import ui.mainmenu
from game.game import Game
from theater import start_generator
from theater.controlpoint import *
from dcs.planes import *
@ -17,6 +18,8 @@ from dcs.vehicles import *
m = dcs.Mission()
theater = theater.caucasus.CaucasusTheater()
start_generator.generate_initial(theater, "Russia")
theater.kutaisi.base.aircraft = {
F_15C: 4,
A_10C: 2,

20
game/event.py
View File

@ -71,7 +71,7 @@ class GroundInterceptEvent(Event):
else:
pass
def player_attacking(self, position: Point, strikegroup: typing.Dict[PlaneType, int]):
def player_attacking(self, position: Point, strikegroup: db.PlaneDict, clients: db.PlaneDict):
suitable_unittypes = db.find_unittype(CAP, self.defender.name)
random.shuffle(suitable_unittypes)
unittypes = suitable_unittypes[:self.TARGET_VARIETY]
@ -81,6 +81,8 @@ class GroundInterceptEvent(Event):
self.operation = GroundInterceptOperation(mission=self.mission,
attacker=self.attacker,
defender=self.defender,
attacker_clients=clients,
defender_clients={},
position=position,
target=targets,
strikegroup=strikegroup)
@ -105,7 +107,7 @@ class InterceptEvent(Event):
if self.to_cp.captured:
self.to_cp.base.affect_strength(-self.STRENGTH_INFLUENCE)
def player_attacking(self, interceptors: typing.Dict[PlaneType, int]):
def player_attacking(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
escort = self.to_cp.base.scramble_sweep(self.to_cp)
transport_unit = random.choice(db.find_unittype(Transport, self.defender.name))
assert transport_unit is not None
@ -113,13 +115,15 @@ class InterceptEvent(Event):
self.operation = InterceptOperation(mission=self.mission,
attacker=self.attacker,
defender=self.defender,
attacker_clients=clients,
defender_clients={},
destination=self.to_cp,
destination_port=self.to_cp.airport,
escort=escort,
transport={transport_unit: 1},
interceptors=interceptors)
def player_defending(self, escort: typing.Dict[PlaneType, int]):
def player_defending(self, escort: db.PlaneDict, clients: db.PlaneDict):
interceptors = self.from_cp.base.scramble_interceptors_count(self.difficulty * self.ESCORT_AMOUNT_FACTOR)
transport_unit = random.choice(db.find_unittype(Transport, self.defender.name))
assert transport_unit is not None
@ -127,6 +131,8 @@ class InterceptEvent(Event):
self.operation = InterceptOperation(mission=self.mission,
attacker=self.attacker,
defender=self.defender,
attacker_clients={},
defender_clients=clients,
destination=self.to_cp,
destination_port=self.to_cp.airport,
escort=escort,
@ -156,7 +162,7 @@ class CaptureEvent(Event):
if self.to_cp.captured:
self.to_cp.captured = False
def player_defending(self, interceptors: typing.Dict[PlaneType, int]):
def player_defending(self, interceptors: db.PlaneDict, clients: db.PlaneDict):
cas = self.from_cp.base.scramble_cas(self.to_cp)
escort = self.from_cp.base.scramble_sweep(self.to_cp)
attackers = self.from_cp.base.assemble_cap(self.to_cp)
@ -164,6 +170,8 @@ class CaptureEvent(Event):
self.operation = CaptureOperation(mission=self.mission,
attacker=self.attacker,
defender=self.defender,
attacker_clients={},
defender_clients=clients,
from_cp=self.from_cp,
to_cp=self.to_cp,
cas=cas,
@ -173,12 +181,14 @@ class CaptureEvent(Event):
defense=self.to_cp.base.armor,
aa=self.to_cp.base.aa)
def player_attacking(self, cas: typing.Dict[PlaneType, int], escort: typing.Dict[PlaneType, int], armor: typing.Dict[Armor, int]):
def player_attacking(self, cas: db.PlaneDict, escort: db.PlaneDict, armor: db.ArmorDict, clients: db.PlaneDict):
interceptors = self.to_cp.base.scramble_sweep(for_target=self.to_cp)
self.operation = CaptureOperation(mission=self.mission,
attacker=self.attacker,
defender=self.defender,
attacker_clients=clients,
defender_clients={},
from_cp=self.from_cp,
to_cp=self.to_cp,
cas=cas,

47
game/operation.py
View File

@ -8,6 +8,7 @@ from dcs.vehicles import *
from theater.controlpoint import *
from theater.conflicttheater import *
from theater.base import *
from shop import *
from gen.armor import *
from gen.aircraft import *
@ -38,19 +39,23 @@ class CaptureOperation(Operation):
mission: Mission,
attacker: Country,
defender: Country,
attacker_clients: db.PlaneDict,
defender_clients: db.PlaneDict,
from_cp: ControlPoint,
to_cp: ControlPoint,
cas: typing.Dict[PlaneType, int],
escort: typing.Dict[PlaneType, int],
attack: typing.Dict[Armor, int],
intercept: typing.Dict[PlaneType, int],
defense: typing.Dict[Armor, int],
aa: typing.Dict[AirDefence, int]):
cas: db.PlaneDict,
escort: db.PlaneDict,
attack: db.ArmorDict,
intercept: db.PlaneDict,
defense: db.ArmorDict,
aa: db.AADict):
conflict = to_cp.conflict_attack(from_cp, attacker, defender)
super(CaptureOperation, self).__init__(mission, conflict)
self.from_cp = from_cp
self.to_cp = to_cp
self.attacker_clients = attacker_clients
self.defender_clients = defender_clients
self.cas = cas
self.escort = escort
self.intercept = intercept
@ -62,9 +67,9 @@ class CaptureOperation(Operation):
def generate(self):
self.armorgen.generate(self.attack, self.defense)
self.airgen.generate_cas(self.cas)
self.airgen.generate_cas_escort(self.escort)
self.airgen.generate_defense(self.intercept)
self.airgen.generate_cas(self.cas, clients=self.attacker_clients)
self.airgen.generate_cas_escort(self.escort, clients=self.attacker_clients)
self.airgen.generate_defense(self.intercept, clients=self.defender_clients)
self.aagen.generate(self.aa)
@ -73,11 +78,13 @@ class InterceptOperation(Operation):
mission: Mission,
attacker: Country,
defender: Country,
attacker_clients: db.PlaneDict,
defender_clients: db.PlaneDict,
destination: ControlPoint,
destination_port: Airport,
escort: typing.Dict[PlaneType, int],
transport: typing.Dict[PlaneType, int],
interceptors: typing.Dict[PlaneType, int]):
escort: db.PlaneDict,
transport: db.PlaneDict,
interceptors: db.PlaneDict):
conflict = Conflict.intercept_conflict(
attacker=attacker,
defender=defender,
@ -88,14 +95,16 @@ class InterceptOperation(Operation):
super(InterceptOperation, self).__init__(mission, conflict)
self.destination_port = destination_port
self.attacker_clients = attacker_clients
self.defender_clients = defender_clients
self.escort = escort
self.transport = transport
self.interceptors = interceptors
def generate(self):
self.airgen.generate_transport(self.transport, self.destination_port)
self.airgen.generate_transport_escort(self.escort)
self.airgen.generate_interception(self.interceptors)
self.airgen.generate_transport_escort(self.escort, clients=self.defender_clients)
self.airgen.generate_interception(self.interceptors, clients=self.attacker_clients)
class GroundInterceptOperation(Operation):
@ -103,9 +112,11 @@ class GroundInterceptOperation(Operation):
mission: Mission,
attacker: Country,
defender: Country,
attacker_clients: db.PlaneDict,
defender_clients: db.PlaneDict,
position: Point,
target: typing.Dict[VehicleType, int],
strikegroup: typing.Dict[PlaneType, int]):
target: db.ArmorDict,
strikegroup: db.PlaneDict):
conflict = Conflict.ground_intercept_conflict(
attacker=attacker,
defender=defender,
@ -115,10 +126,12 @@ class GroundInterceptOperation(Operation):
)
super(GroundInterceptOperation, self).__init__(mission, conflict)
self.attacker_clients = attacker_clients
self.defender_clients = defender_clients
self.strikegroup = strikegroup
self.target = target
def generate(self):
self.airgen.generate_cas(self.strikegroup)
self.airgen.generate_cas(self.strikegroup, clients=self.attacker_clients)
self.armorgen.generate({}, self.target)

69
gen/aircraft.py
View File

@ -6,6 +6,7 @@ from random import randint
import globals
from shop import db
from .conflictgen import *
from .naming import *
@ -48,38 +49,44 @@ class AircraftConflictGenerator:
self,
name: str,
side: Country,
unit: UnitType,
unit: PlaneType,
count: int,
client_count: int,
at: Point = None,
airport: Airport = None) -> PlaneGroup:
starttype = airport == None and StartType.Warm or StartType.Cold
print("generating {} ({}) at {} {}".format(unit, count, at, airport, side))
airport: Airport = None) -> FlyingGroup:
starttype = airport is None and StartType.Warm or StartType.Cold
assert count > 0
return self.m.flight_group(
country=side,
name=name,
aircraft_type=unit,
airport=airport,
position=at,
altitude=WARM_START_ALTITUDE,
speed=WARM_START_AIRSPEED,
maintask=None,
start_type=starttype,
group_size=count)
group = self.m.flight_group(
country=side,
name=name,
aircraft_type=unit,
airport=airport,
position=at,
altitude=WARM_START_ALTITUDE,
speed=WARM_START_AIRSPEED,
maintask=None,
start_type=starttype,
group_size=count)
def _generate_escort(self, units: typing.Dict[PlaneType, int], airport: Airport, side: Country, location: Point):
for idx in range(client_count):
group.units[idx].set_client()
return group
def _generate_escort(self, units: db.PlaneDict, clients: db.PlaneDict, airport: Airport, side: Country, location: Point):
if len(self.escort_targets) == 0:
return
for type, count in units.items():
group = self._generate_group(
name=namegen.next_escort_group_name(),
side=side,
unit=type,
count=count,
at=location,
airport=airport)
name=namegen.next_escort_group_name(),
side=side,
unit=type,
count=count,
client_count=clients.get(type, 0),
at=location,
airport=airport)
group.task = Escort.name
group.load_task_default_loadout(dcs.task.Escort)
@ -91,7 +98,7 @@ class AircraftConflictGenerator:
for group in self.escort_targets:
wayp.tasks.append(EscortTaskAction(group.id, engagement_max_dist=ESCORT_MAX_DIST))
def generate_cas(self, attackers: typing.Dict[PlaneType, int], airport: Airport = None):
def generate_cas(self, attackers: db.PlaneDict, clients: db.PlaneDict, airport: Airport = None):
assert len(self.escort_targets) == 0
for type, count in attackers.items():
@ -100,6 +107,7 @@ class AircraftConflictGenerator:
side=self.conflict.attackers_side,
unit=type,
count=count,
client_count=clients.get(type, 0),
at=airport is None and self._group_point(self.conflict.air_attackers_location) or None,
airport=airport)
self.escort_targets.append(group)
@ -108,29 +116,32 @@ class AircraftConflictGenerator:
group.task = CAS.name
group.load_task_default_loadout(CAS)
def generate_cas_escort(self, attackers: typing.Dict[PlaneType, int], airport: Airport = None):
def generate_cas_escort(self, attackers: db.PlaneDict, clients: db.PlaneDict, airport: Airport = None):
self._generate_escort(
units=attackers,
clients=clients,
airport=airport,
side=self.conflict.attackers_side,
location=airport is None and self._group_point(self.conflict.air_attackers_location) or None
)
def generate_transport_escort(self, escort: typing.Dict[PlaneType, int], airport: Airport = None):
def generate_transport_escort(self, escort: db.PlaneDict, clients: db.PlaneDict, airport: Airport = None):
self._generate_escort(
units=escort,
clients=clients,
airport=airport,
side=self.conflict.defenders_side,
location=airport is None and self._group_point(self.conflict.air_defenders_location) or None
)
def generate_defense(self, defenders: typing.Dict[PlaneType, int], airport: Airport = None):
def generate_defense(self, defenders: db.PlaneDict, clients: db.PlaneDict, airport: Airport = None):
for type, count in defenders.items():
group = self._generate_group(
name=namegen.next_intercept_group_name(),
side=self.conflict.defenders_side,
unit=type,
count=count,
client_count=clients.get(type, 0),
at=airport is None and self._group_point(self.conflict.air_defenders_location) or None,
airport=airport)
@ -140,7 +151,7 @@ class AircraftConflictGenerator:
wayp.tasks.append(dcs.task.EngageTargets(max_distance=self.conflict.size * INTERCEPT_MAX_DISTANCE_FACTOR))
wayp.tasks.append(dcs.task.OrbitAction())
def generate_transport(self, transport: typing.Dict[PlaneType, int], destination: Airport):
def generate_transport(self, transport: db.PlaneDict, destination: Airport):
assert len(self.escort_targets) == 0
for type, count in transport.items():
@ -149,6 +160,7 @@ class AircraftConflictGenerator:
side=self.conflict.defenders_side,
unit=type,
count=count,
client_count=0,
at=self._group_point(self.conflict.air_defenders_location),
airport=None
)
@ -158,13 +170,14 @@ class AircraftConflictGenerator:
self.escort_targets.append(group)
group.land_at(destination)
def generate_interception(self, interceptors: typing.Dict[PlaneType, int], airport: Airport = None):
def generate_interception(self, interceptors: db.PlaneDict, clients: db.PlaneDict, airport: Airport = None):
for type, count in interceptors.items():
group = self._generate_group(
name=namegen.next_intercept_group_name(),
side=self.conflict.attackers_side,
unit=type,
count=count,
client_count=clients.get(type, 0),
at=airport is None and self._group_point(self.conflict.air_attackers_location) or None,
airport=airport
)

6
gen/armor.py
View File

@ -6,6 +6,7 @@ from random import randint
import globals
from shop import db
from .conflictgen import *
from .naming import *
@ -21,6 +22,7 @@ from dcs.country import *
SPREAD_DISTANCE_FACTOR = 0.1, 0.3
SPREAD_DISTANCE_SIZE_FACTOR = 0.1
class ArmorConflictGenerator:
def __init__(self, mission: Mission, conflict: Conflict):
self.m = mission
@ -34,7 +36,7 @@ class ArmorConflictGenerator:
return point.random_point_within(distance, self.conflict.size * SPREAD_DISTANCE_SIZE_FACTOR)
def _generate_group(self, side: Country, unit: UnitType, count: int, at: Point):
def _generate_group(self, side: Country, unit: VehicleType, count: int, at: Point):
for c in range(count):
group = self.m.vehicle_group(
side,
@ -46,7 +48,7 @@ class ArmorConflictGenerator:
wayp = group.add_waypoint(self.conflict.position)
wayp.tasks = []
def generate(self, attackers: typing.Dict[UnitType, int], defenders: typing.Dict[UnitType, int]):
def generate(self, attackers: db.ArmorDict, defenders: db.ArmorDict):
for type, count in attackers.items():
self._generate_group(
side=self.conflict.attackers_side,

2
gen/conflictgen.py
View File

@ -39,7 +39,7 @@ class Conflict:
air_defenders_location = None # type: Point
@classmethod
def capture_conflict(self, attacker: Country, attack_heading: int, defender: Country, defense_heading: int, position: Point, size: int, radials: typing.List[int]):
def capture_conflict(self, attacker: Country, attack_heading: int, defender: Country, defense_heading: int, position: Point, size: int, radials: typing.Collection[int]):
instance = self()
instance.attackers_side = attacker
instance.defenders_side = defender

11
shop/db.py
View File

@ -40,21 +40,28 @@ PRICES = {
Armor.ATGM_M1134_Stryker: 6,
Armor.APC_BTR_80: 6,
AirDefence.AAA_ZU_23_on_Ural_375: 4,
}
UNIT_BY_TASK = {
FighterSweep: [Su_27, Su_33, Su_25, F_15C, MiG_15bis, MiG_21Bis, MiG_29A, ],
CAS: [Su_25T, A_10A, A_10C, ],
CAP: [Armor.MBT_T_90, Armor.MBT_T_80U, Armor.MBT_T_55, Armor.MBT_M1A2_Abrams, Armor.MBT_M60A3_Patton, Armor.ATGM_M1134_Stryker, Armor.APC_BTR_80, ],
AirDefence: [AirDefence.AAA_ZU_23_on_Ural_375, ],
AirDefence: [AirDefence.AAA_ZU_23_on_Ural_375, ],
Transport: [IL_76MD, S_3B_Tanker, ],
}
UNIT_BY_COUNTRY = {
"Russia": [Su_25T, A_10C, Su_27, Su_33, Su_25, MiG_15bis, MiG_21Bis, MiG_29A, AirDefence.AAA_ZU_23_on_Ural_375, Armor.APC_BTR_80, Armor.MBT_T_90, Armor.MBT_T_80U, Armor.MBT_T_55, IL_76MD, ],
"Russia": [Su_25T, Su_27, Su_33, Su_25, MiG_15bis, MiG_21Bis, MiG_29A, AirDefence.AAA_ZU_23_on_Ural_375, Armor.APC_BTR_80, Armor.MBT_T_90, Armor.MBT_T_80U, Armor.MBT_T_55, IL_76MD, ],
"USA": [F_15C, A_10C, Armor.MBT_M1A2_Abrams, Armor.MBT_M60A3_Patton, Armor.ATGM_M1134_Stryker, S_3B_Tanker],
}
UnitsDict = typing.Dict[UnitType, int]
PlaneDict = typing.Dict[PlaneType, int]
ArmorDict = typing.Dict[VehicleType, int]
AADict = typing.Dict[AirDefence, int]
def unit_task(unit: UnitType) -> Task:
for task, units in UNIT_BY_TASK.items():

1
theater/caucasus.py
View File

@ -3,6 +3,7 @@ from dcs.terrain import caucasus
from .conflicttheater import *
from .base import *
class CaucasusTheater(ConflictTheater):
kutaisi = ControlPoint(caucasus.Kutaisi, ALL_RADIALS, SIZE_SMALL, IMPORTANCE_LOW)
senaki = ControlPoint(caucasus.Senaki, ALL_RADIALS, SIZE_REGULAR, IMPORTANCE_LOW)

28
theater/start_generator.py
View File

@ -3,9 +3,33 @@ import random
import dcs
from shop import db
from theater.controlpoint import *
from theater.base import *
from theater.conflicttheater import *
def generate_initial(theater: ConflictTheater):
pass
UNIT_VARIETY = 2
UNIT_AMOUNT_FACTOR = 1
def generate_initial(theater: ConflictTheater, enemy: str):
for cp in theater.enemy_bases():
if cp.captured:
continue
for task in [CAP, FighterSweep, CAS, AirDefence]:
suitable_unittypes = db.find_unittype(task, enemy)
suitable_unittypes.sort(key=lambda x: db.PRICES[x])
importance = cp.importance * 10 - 10
units_idx_start = int(importance * UNIT_VARIETY)
units_idx_end = units_idx_start + UNIT_VARIETY
range_start = min(len(suitable_unittypes)-1, units_idx_start)
range_end = min(len(suitable_unittypes), units_idx_end)
unittypes = suitable_unittypes[range_start:range_end]
typecount = max(math.floor(importance * UNIT_AMOUNT_FACTOR), 1)
units = {unittype: typecount for unittype in unittypes}
print("{} - {}".format(cp.name, units))
cp.base.commision_units(units)

6
ui/basemenu.py
View File

@ -62,7 +62,11 @@ class BaseMenu(Menu):
def sell(self, unit_type):
def action():
if self.base.total_units_of_type(unit_type) > 0:
if self.event.units.get(unit_type, 0) > 0:
price = db.PRICES[unit_type]
self.game.budget += price
self.event.units[unit_type] = self.event.units[unit_type] - 1
elif self.base.total_units_of_type(unit_type) > 0:
price = db.PRICES[unit_type]
self.game.budget += price
self.base.commit_losses({unit_type: 1})

57
ui/eventmenu.py
View File

@ -2,13 +2,15 @@ from tkinter import *
from ui.window import *
from ui.eventresultsmenu import *
from shop import db
from game.game import *
from game import event
class EventMenu(Menu):
aircraft_scramble_entries = None # type: typing.Dict[PlaneType, Entry]
armor_scramble_entries = None # type: typing.Dict[Armor, Entry]
aircraft_scramble_entries = None # type: typing.Dict[PlaneType , Entry]
aircraft_client_entries = None # type: typing.Dict[PlaneType, Entry]
armor_scramble_entries = None # type: typing.Dict[VehicleType, Entry]
def __init__(self, window: Window, parent, game: Game, event: event.Event):
super(EventMenu, self).__init__(window, parent, game)
@ -16,6 +18,7 @@ class EventMenu(Menu):
self.event = event
self.aircraft_scramble_entries = {}
self.armor_scramble_entries = {}
self.aircraft_client_entries = {}
self.frame = self.window.right_pane
@ -31,11 +34,24 @@ class EventMenu(Menu):
def scrable_row(unit_type, unit_count):
nonlocal row
Label(self.frame, text="{} ({})".format(unit_type.id and unit_type.id or unit_type.name, unit_count)).grid(row=row)
e = Entry(self.frame)
e.grid(column=1, row=row)
Label(self.frame, text="{} ({})".format(db.unit_type_name(unit_type), unit_count)).grid(row=row)
scramble_entry = Entry(self.frame)
scramble_entry.grid(column=1, row=row)
self.aircraft_scramble_entries[unit_type] = scramble_entry
client_entry = Entry(self.frame)
client_entry.grid(column=2, row=row)
self.aircraft_client_entries[unit_type] = client_entry
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)
scramble_entry = Entry(self.frame)
scramble_entry.grid(column=1, row=row)
self.armor_scramble_entries[unit_type] = scramble_entry
self.aircraft_scramble_entries[unit_type] = e
row += 1
base = None # type: Base
@ -48,8 +64,12 @@ class EventMenu(Menu):
for unit_type, count in base.aircraft.items():
scrable_row(unit_type, count)
Button(self.frame, text="Commit", command=self.start).grid(row=row)
Button(self.frame, text="Back", command=self.dismiss).grid(row=row)
label("Armor")
for unit_type, count in base.armor.items():
scramble_armor_row(unit_type, count)
Button(self.frame, text="Commit", command=self.start).grid(column=0, row=row)
Button(self.frame, text="Back", command=self.dismiss).grid(column=2, row=row)
def start(self):
scrambled_aircraft = {}
@ -67,6 +87,13 @@ class EventMenu(Menu):
elif task == FighterSweep:
scrambled_sweep[unit_type] = amount
scrambled_clients = {}
for unit_type, field in self.aircraft_client_entries.items():
value = field.get()
if value and int(value) > 0:
amount = int(value)
scrambled_clients[unit_type] = amount
scrambled_armor = {}
for unit_type, field in self.armor_scramble_entries.items():
value = field.get()
@ -78,18 +105,22 @@ class EventMenu(Menu):
if self.game.is_player_attack(self.event):
e.player_attacking(cas=scrambled_cas,
escort=scrambled_sweep,
armor=scrambled_armor)
armor=scrambled_armor,
clients=scrambled_clients)
else:
e.player_defending(interceptors=scrambled_aircraft)
e.player_defending(interceptors=scrambled_aircraft,
clients=scrambled_clients)
elif type(self.event) is InterceptEvent:
e = self.event # type: InterceptEvent
if self.game.is_player_attack(self.event):
e.player_attacking(interceptors=scrambled_aircraft)
e.player_attacking(interceptors=scrambled_aircraft,
clients=scrambled_clients)
else:
e.player_defending(escort=scrambled_aircraft)
e.player_defending(escort=scrambled_aircraft,
clients=scrambled_clients)
elif type(self.event) is GroundInterceptEvent:
e = self.event # type: GroundInterceptEvent
e.player_attacking(e.to_cp.position.random_point_within(30000), strikegroup=scrambled_aircraft)
e.player_attacking(e.to_cp.position.random_point_within(30000), strikegroup=scrambled_aircraft, clients=scrambled_clients)
self.game.initiate_event(self.event)
EventResultsMenu(self.window, self.parent, self.game, self.event).display()

6
ui/mainmenu.py
View File

@ -44,12 +44,10 @@ class MainMenu(Menu):
Button(self.frame, text=title, command=self.go_cp(cp)).grid(row=row, sticky=NW)
row += 1
statusbar = Frame(self.frame).grid(column=0, row=row, sticky=NSEW)
Label(self.frame, text="Budget: {}m".format(self.game.budget)).grid(column=0, row=0, sticky=NW)
Button(self.frame, text="Pass turn", command=self.pass_turn).grid(column=1, row=0, sticky=NE)
row += 1
Label(statusbar, text="Budget: {}m".format(self.game.budget)).grid(column=0, row=0, sticky=NW)
Button(statusbar, text="Pass turn", command=self.pass_turn).grid(column=1, row=0, sticky=NE)
for event in self.game.events:
if not event.informational:
continue