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

Replace mission planning UI.

Browse Source 
Mission planning has been completely redone. Missions are now planned
by right clicking the target area and choosing "New package".

A package can include multiple flights for the same objective. Right
now the automatic flight planner is only fragging single-flight
packages in the same manner that it used to, but that can be improved
now.

The air tasking order (ATO) is now the left bar of the main UI. This
shows every fragged package, and the flights in the selected package.
The info bar that was previously on the left is now a smaller bar at
the bottom of the screen. The old "Mission Planning" button is now
just the "Take Off" button.

The flight plan display no longer shows enemy flight plans. That could
be re-added if needed, probably with a difficulty/cheat option.

Aircraft inventories have been disassociated from the Planner class.
Aircraft inventories are now stored globally in the Game object.

Save games made prior to this update will not be compatible do to the
changes in how aircraft inventories and planned flights are stored.
This commit is contained in:
Dan Albert
2020-09-13 14:32:47 -07:00
parent 0eee5747af
commit ff083942e8
38 changed files with 1807 additions and 695 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
qt_ui/windows/QLiberationWindow.py
View File

@@ -1,22 +1,36 @@
import logging
import sys
import webbrowser
from typing import Optional
from PySide2.QtCore import Qt
from PySide2.QtGui import QIcon
from PySide2.QtWidgets import QWidget, QVBoxLayout, QMainWindow, QAction, QMessageBox, QDesktopWidget, \
QSplitter, QFileDialog
from PySide2.QtWidgets import (
QAction,
QDesktopWidget,
QFileDialog,
QMainWindow,
QMessageBox,
QSplitter,
QVBoxLayout,
QWidget,
)
import qt_ui.uiconstants as CONST
from game import Game
from game.inventory import GlobalAircraftInventory
from qt_ui.dialogs import Dialog
from qt_ui.models import GameModel
from qt_ui.uiconstants import URLS
from qt_ui.widgets.QTopPanel import QTopPanel
from qt_ui.widgets.ato import QAirTaskingOrderPanel
from qt_ui.widgets.map.QLiberationMap import QLiberationMap
from qt_ui.windows.GameUpdateSignal import GameUpdateSignal, DebriefingSignal
from qt_ui.windows.GameUpdateSignal import DebriefingSignal, GameUpdateSignal
from qt_ui.windows.QDebriefingWindow import QDebriefingWindow
from qt_ui.windows.newgame.QNewGameWizard import NewGameWizard
from qt_ui.windows.infos.QInfoPanel import QInfoPanel
from qt_ui.windows.preferences.QLiberationPreferencesWindow import QLiberationPreferencesWindow
from qt_ui.windows.newgame.QNewGameWizard import NewGameWizard
from qt_ui.windows.preferences.QLiberationPreferencesWindow import \
QLiberationPreferencesWindow
from userdata import persistency
@@ -25,6 +39,10 @@ class QLiberationWindow(QMainWindow):
def __init__(self):
super(QLiberationWindow, self).__init__()
self.game: Optional[Game] = None
self.game_model = GameModel()
Dialog.set_game(self.game_model)
self.ato_panel = None
self.info_panel = None
self.setGame(persistency.restore_game())
@@ -44,16 +62,19 @@ class QLiberationWindow(QMainWindow):
self.setGeometry(0, 0, screen.width(), screen.height())
self.setWindowState(Qt.WindowMaximized)
def initUi(self):
self.liberation_map = QLiberationMap(self.game)
self.ato_panel = QAirTaskingOrderPanel(self.game_model)
self.liberation_map = QLiberationMap(self.game_model)
self.info_panel = QInfoPanel(self.game)
hbox = QSplitter(Qt.Horizontal)
hbox.addWidget(self.info_panel)
hbox.addWidget(self.liberation_map)
hbox.setSizes([2, 8])
vbox = QSplitter(Qt.Vertical)
hbox.addWidget(self.ato_panel)
hbox.addWidget(vbox)
vbox.addWidget(self.liberation_map)
vbox.addWidget(self.info_panel)
hbox.setSizes([100, 600])
vbox.setSizes([600, 100])
vbox = QVBoxLayout()
vbox.setMargin(0)
@@ -210,10 +231,11 @@ class QLiberationWindow(QMainWindow):
def exit(self):
sys.exit(0)
def setGame(self, game: Game):
def setGame(self, game: Optional[Game]):
self.game = game
if self.info_panel:
self.info_panel.setGame(game)
self.game_model.set(self.game)
def showAboutDialog(self):
text = "<h3>DCS Liberation " + CONST.VERSION_STRING + "</h3>" + \

17
qt_ui/windows/basemenu/QBaseMenu2.py
View File

@@ -1,9 +1,9 @@
from PySide2.QtCore import Qt
from PySide2.QtGui import QCloseEvent, QPixmap
from PySide2.QtWidgets import QHBoxLayout, QLabel, QWidget, QDialog, QGridLayout
from PySide2.QtWidgets import QDialog, QGridLayout, QHBoxLayout, QLabel, QWidget
from game import Game
from game.event import ControlPointType
from qt_ui.models import GameModel
from qt_ui.uiconstants import EVENT_ICONS
from qt_ui.windows.GameUpdateSignal import GameUpdateSignal
from qt_ui.windows.basemenu.QBaseMenuTabs import QBaseMenuTabs
@@ -13,19 +13,20 @@ from theater import ControlPoint
class QBaseMenu2(QDialog):
def __init__(self, parent, cp: ControlPoint, game: Game):
def __init__(self, parent, cp: ControlPoint, game_model: GameModel):
super(QBaseMenu2, self).__init__(parent)
# Attrs
self.cp = cp
self.game = game
self.game_model = game_model
self.is_carrier = self.cp.cptype in [ControlPointType.AIRCRAFT_CARRIER_GROUP, ControlPointType.LHA_GROUP]
self.objectName = "menuDialogue"
# Widgets
self.qbase_menu_tab = QBaseMenuTabs(cp, game)
self.qbase_menu_tab = QBaseMenuTabs(cp, self.game_model)
try:
game = self.game_model.game
self.airport = game.theater.terrain.airport_by_id(self.cp.id)
except:
self.airport = None
@@ -70,7 +71,9 @@ class QBaseMenu2(QDialog):
self.mainLayout.addWidget(header, 0, 0)
self.mainLayout.addWidget(self.topLayoutWidget, 1, 0)
self.mainLayout.addWidget(self.qbase_menu_tab, 2, 0)
totalBudget = QLabel(QRecruitBehaviour.BUDGET_FORMAT.format(self.game.budget))
totalBudget = QLabel(
QRecruitBehaviour.BUDGET_FORMAT.format(self.game_model.game.budget)
)
totalBudget.setObjectName("budgetField")
totalBudget.setAlignment(Qt.AlignRight | Qt.AlignBottom)
totalBudget.setProperty("style", "budget-label")
@@ -78,7 +81,7 @@ class QBaseMenu2(QDialog):
self.setLayout(self.mainLayout)
def closeEvent(self, closeEvent:QCloseEvent):
GameUpdateSignal.get_instance().updateGame(self.game)
GameUpdateSignal.get_instance().updateGame(self.game_model.game)
def get_base_image(self):
if self.cp.cptype == ControlPointType.AIRCRAFT_CARRIER_GROUP:

18
qt_ui/windows/basemenu/QBaseMenuTabs.py
View File

@@ -1,6 +1,6 @@
from PySide2.QtWidgets import QTabWidget, QFrame, QGridLayout, QLabel
from PySide2.QtWidgets import QFrame, QGridLayout, QLabel, QTabWidget
from game import Game
from qt_ui.models import GameModel
from qt_ui.windows.basemenu.airfield.QAirfieldCommand import QAirfieldCommand
from qt_ui.windows.basemenu.base_defenses.QBaseDefensesHQ import QBaseDefensesHQ
from qt_ui.windows.basemenu.ground_forces.QGroundForcesHQ import QGroundForcesHQ
@@ -10,29 +10,29 @@ from theater import ControlPoint
class QBaseMenuTabs(QTabWidget):
def __init__(self, cp: ControlPoint, game: Game):
def __init__(self, cp: ControlPoint, game_model: GameModel):
super(QBaseMenuTabs, self).__init__()
self.cp = cp
if cp:
if not cp.captured:
self.intel = QIntelInfo(cp, game)
self.intel = QIntelInfo(cp, game_model.game)
self.addTab(self.intel, "Intel")
if not cp.is_carrier:
self.base_defenses_hq = QBaseDefensesHQ(cp, game)
self.base_defenses_hq = QBaseDefensesHQ(cp, game_model.game)
self.addTab(self.base_defenses_hq, "Base Defenses")
else:
if cp.has_runway():
self.airfield_command = QAirfieldCommand(cp, game)
self.airfield_command = QAirfieldCommand(cp, game_model)
self.addTab(self.airfield_command, "Airfield Command")
if not cp.is_carrier:
self.ground_forces_hq = QGroundForcesHQ(cp, game)
self.ground_forces_hq = QGroundForcesHQ(cp, game_model)
self.addTab(self.ground_forces_hq, "Ground Forces HQ")
self.base_defenses_hq = QBaseDefensesHQ(cp, game)
self.base_defenses_hq = QBaseDefensesHQ(cp, game_model.game)
self.addTab(self.base_defenses_hq, "Base Defenses")
else:
self.base_defenses_hq = QBaseDefensesHQ(cp, game)
self.base_defenses_hq = QBaseDefensesHQ(cp, game_model.game)
self.addTab(self.base_defenses_hq, "Fleet")
else:

40
qt_ui/windows/basemenu/QRecruitBehaviour.py
View File

@@ -1,25 +1,34 @@
from PySide2.QtWidgets import QLabel, QPushButton, \
QSizePolicy, QSpacerItem, QGroupBox, QHBoxLayout
from PySide2.QtWidgets import (
QGroupBox,
QHBoxLayout,
QLabel,
QPushButton,
QSizePolicy,
QSpacerItem,
)
from dcs.unittype import UnitType
from theater import db
class QRecruitBehaviour:
game = None
cp = None
deliveryEvent = None
existing_units_labels = None
bought_amount_labels = None
class QRecruitBehaviour:
BUDGET_FORMAT = "Available Budget: <b>${}M</b>"
def __init__(self):
def __init__(self) -> None:
self.deliveryEvent = None
self.bought_amount_labels = {}
self.existing_units_labels = {}
self.update_available_budget()
def add_purchase_row(self, unit_type, layout, row):
@property
def budget(self) -> int:
return self.game_model.game.budget
@budget.setter
def budget(self, value: int) -> None:
self.game_model.game.budget = value
def add_purchase_row(self, unit_type, layout, row):
exist = QGroupBox()
exist.setProperty("style", "buy-box")
exist.setMaximumHeight(36)
@@ -98,27 +107,28 @@ class QRecruitBehaviour:
parent = parent.parent()
for child in parent.children():
if child.objectName() == "budgetField":
child.setText(QRecruitBehaviour.BUDGET_FORMAT.format(self.game.budget))
child.setText(
QRecruitBehaviour.BUDGET_FORMAT.format(self.budget))
def buy(self, unit_type):
price = db.PRICES[unit_type]
if self.game.budget >= price:
if self.budget >= price:
self.deliveryEvent.deliver({unit_type: 1})
self.game.budget -= price
self.budget -= price
self._update_count_label(unit_type)
self.update_available_budget()
def sell(self, unit_type):
if self.deliveryEvent.units.get(unit_type, 0) > 0:
price = db.PRICES[unit_type]
self.game.budget += price
self.budget += price
self.deliveryEvent.units[unit_type] = self.deliveryEvent.units[unit_type] - 1
if self.deliveryEvent.units[unit_type] == 0:
del self.deliveryEvent.units[unit_type]
elif self.cp.base.total_units_of_type(unit_type) > 0:
price = db.PRICES[unit_type]
self.game.budget += price
self.budget += price
self.cp.base.commit_losses({unit_type: 1})
self._update_count_label(unit_type)

35
qt_ui/windows/basemenu/airfield/QAircraftRecruitmentMenu.py
View File

@@ -1,27 +1,35 @@
from PySide2.QtCore import Qt
from PySide2.QtWidgets import QVBoxLayout, QGridLayout, QGroupBox, QScrollArea, QFrame, QWidget
from typing import Optional
from game.event import UnitsDeliveryEvent
from PySide2.QtCore import Qt
from PySide2.QtWidgets import (
QFrame,
QGridLayout,
QScrollArea,
QVBoxLayout,
QWidget,
)
from game.event.event import UnitsDeliveryEvent
from qt_ui.models import GameModel
from qt_ui.windows.basemenu.QRecruitBehaviour import QRecruitBehaviour
from theater import ControlPoint, CAP, CAS, db
from game import Game
from theater import CAP, CAS, ControlPoint, db
class QAircraftRecruitmentMenu(QFrame, QRecruitBehaviour):
def __init__(self, cp:ControlPoint, game:Game):
def __init__(self, cp: ControlPoint, game_model: GameModel) -> None:
QFrame.__init__(self)
self.cp = cp
self.game = game
self.game_model = game_model
self.deliveryEvent: Optional[UnitsDeliveryEvent] = None
self.bought_amount_labels = {}
self.existing_units_labels = {}
for event in self.game.events:
for event in self.game_model.game.events:
if event.__class__ == UnitsDeliveryEvent and event.from_cp == self.cp:
self.deliveryEvent = event
if not self.deliveryEvent:
self.deliveryEvent = self.game.units_delivery_event(self.cp)
self.deliveryEvent = self.game_model.game.units_delivery_event(self.cp)
self.init_ui()
@@ -29,8 +37,8 @@ class QAircraftRecruitmentMenu(QFrame, QRecruitBehaviour):
main_layout = QVBoxLayout()
units = {
CAP: db.find_unittype(CAP, self.game.player_name),
CAS: db.find_unittype(CAS, self.game.player_name),
CAP: db.find_unittype(CAP, self.game_model.game.player_name),
CAS: db.find_unittype(CAS, self.game_model.game.player_name),
}
scroll_content = QWidget()
@@ -39,7 +47,8 @@ class QAircraftRecruitmentMenu(QFrame, QRecruitBehaviour):
for task_type in units.keys():
units_column = list(set(units[task_type]))
if len(units_column) == 0: continue
if len(units_column) == 0:
continue
units_column.sort(key=lambda x: db.PRICES[x])
for unit_type in units_column:
if self.cp.is_carrier and not unit_type in db.CARRIER_CAPABLE:

19
qt_ui/windows/basemenu/airfield/QAirfieldCommand.py
View File

@@ -1,27 +1,30 @@
from PySide2.QtWidgets import QFrame, QGridLayout, QLabel, QHBoxLayout, QGroupBox, QVBoxLayout
from game import Game
from qt_ui.widgets.base.QAirportInformation import QAirportInformation
from qt_ui.windows.basemenu.airfield.QAircraftRecruitmentMenu import QAircraftRecruitmentMenu
from PySide2.QtWidgets import QFrame, QGridLayout, QGroupBox, QVBoxLayout
from qt_ui.models import GameModel
from qt_ui.windows.basemenu.airfield.QAircraftRecruitmentMenu import \
QAircraftRecruitmentMenu
from qt_ui.windows.mission.QPlannedFlightsView import QPlannedFlightsView
from theater import ControlPoint
class QAirfieldCommand(QFrame):
def __init__(self, cp:ControlPoint, game:Game):
def __init__(self, cp:ControlPoint, game_model: GameModel):
super(QAirfieldCommand, self).__init__()
self.cp = cp
self.game = game
self.game_model = game_model
self.init_ui()
def init_ui(self):
layout = QGridLayout()
layout.addWidget(QAircraftRecruitmentMenu(self.cp, self.game), 0, 0)
layout.addWidget(QAircraftRecruitmentMenu(self.cp, self.game_model), 0, 0)
try:
planned = QGroupBox("Planned Flights")
planned_layout = QVBoxLayout()
planned_layout.addWidget(QPlannedFlightsView(self.game.planners[self.cp.id]))
planned_layout.addWidget(
QPlannedFlightsView(self.game_model, self.cp)
)
planned.setLayout(planned_layout)
layout.addWidget(planned, 0, 1)
except:

21
qt_ui/windows/basemenu/ground_forces/QArmorRecruitmentMenu.py
View File

@@ -1,27 +1,33 @@
from PySide2.QtCore import Qt
from PySide2.QtWidgets import QVBoxLayout, QGridLayout, QGroupBox, QFrame, QWidget, QScrollArea
from PySide2.QtWidgets import (
QFrame,
QGridLayout,
QScrollArea,
QVBoxLayout,
QWidget,
)
from game import Game
from game.event import UnitsDeliveryEvent
from qt_ui.models import GameModel
from qt_ui.windows.basemenu.QRecruitBehaviour import QRecruitBehaviour
from theater import ControlPoint, PinpointStrike, db
class QArmorRecruitmentMenu(QFrame, QRecruitBehaviour):
def __init__(self, cp:ControlPoint, game:Game):
def __init__(self, cp: ControlPoint, game_model: GameModel):
QFrame.__init__(self)
self.cp = cp
self.game = game
self.game_model = game_model
self.bought_amount_labels = {}
self.existing_units_labels = {}
for event in self.game.events:
for event in self.game_model.game.events:
if event.__class__ == UnitsDeliveryEvent and event.from_cp == self.cp:
self.deliveryEvent = event
if not self.deliveryEvent:
self.deliveryEvent = self.game.units_delivery_event(self.cp)
self.deliveryEvent = self.game_model.game.units_delivery_event(self.cp)
self.init_ui()
@@ -29,7 +35,8 @@ class QArmorRecruitmentMenu(QFrame, QRecruitBehaviour):
main_layout = QVBoxLayout()
units = {
PinpointStrike: db.find_unittype(PinpointStrike, self.game.player_name),
PinpointStrike: db.find_unittype(PinpointStrike,
self.game_model.game.player_name),
}
scroll_content = QWidget()

17
qt_ui/windows/basemenu/ground_forces/QGroundForcesHQ.py
View File

@@ -1,21 +1,24 @@
from PySide2.QtWidgets import QFrame, QGridLayout
from game import Game
from qt_ui.windows.basemenu.ground_forces.QArmorRecruitmentMenu import QArmorRecruitmentMenu
from qt_ui.windows.basemenu.ground_forces.QGroundForcesStrategy import QGroundForcesStrategy
from qt_ui.models import GameModel
from qt_ui.windows.basemenu.ground_forces.QArmorRecruitmentMenu import \
QArmorRecruitmentMenu
from qt_ui.windows.basemenu.ground_forces.QGroundForcesStrategy import \
QGroundForcesStrategy
from theater import ControlPoint
class QGroundForcesHQ(QFrame):
def __init__(self, cp:ControlPoint, game:Game):
def __init__(self, cp: ControlPoint, game_model: GameModel) -> None:
super(QGroundForcesHQ, self).__init__()
self.cp = cp
self.game = game
self.game_model = game_model
self.init_ui()
def init_ui(self):
layout = QGridLayout()
layout.addWidget(QArmorRecruitmentMenu(self.cp, self.game), 0, 0)
layout.addWidget(QGroundForcesStrategy(self.cp, self.game), 0, 1)
layout.addWidget(QArmorRecruitmentMenu(self.cp, self.game_model), 0, 0)
layout.addWidget(QGroundForcesStrategy(self.cp, self.game_model.game),
0, 1)
self.setLayout(layout)

29
qt_ui/windows/mission/QEditFlightDialog.py Normal file
View File

@@ -0,0 +1,29 @@
"""Dialog window for editing flights."""
from PySide2.QtWidgets import (
QDialog,
QVBoxLayout,
)
from game import Game
from gen.flights.flight import Flight
from qt_ui.uiconstants import EVENT_ICONS
from qt_ui.windows.mission.flight.QFlightPlanner import QFlightPlanner
class QEditFlightDialog(QDialog):
"""Dialog window for editing flight plans and loadouts."""
def __init__(self, game: Game, flight: Flight) -> None:
super().__init__()
self.game = game
self.setWindowTitle("Create flight")
self.setWindowIcon(EVENT_ICONS["strike"])
layout = QVBoxLayout()
self.flight_planner = QFlightPlanner(flight, game)
layout.addWidget(self.flight_planner)
self.setLayout(layout)

159
qt_ui/windows/mission/QMissionPlanning.py
View File

@@ -1,159 +0,0 @@
from PySide2.QtCore import Qt, Slot, QItemSelectionModel, QPoint
from PySide2.QtWidgets import QDialog, QGridLayout, QScrollArea, QVBoxLayout, QPushButton, QHBoxLayout, QMessageBox
from game import Game
from game.event import CAP, CAS, FrontlineAttackEvent
from qt_ui.uiconstants import EVENT_ICONS
from qt_ui.windows.QWaitingForMissionResultWindow import QWaitingForMissionResultWindow
from qt_ui.windows.mission.QPlannedFlightsView import QPlannedFlightsView
from qt_ui.windows.mission.QChooseAirbase import QChooseAirbase
from qt_ui.windows.mission.flight.QFlightCreator import QFlightCreator
from qt_ui.windows.mission.flight.QFlightPlanner import QFlightPlanner
class QMissionPlanning(QDialog):
def __init__(self, game: Game):
super(QMissionPlanning, self).__init__()
self.game = game
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.setMinimumSize(1000, 440)
self.setWindowTitle("Mission Preparation")
self.setWindowIcon(EVENT_ICONS["strike"])
self.init_ui()
print("DONE")
def init_ui(self):
self.captured_cp = [cp for cp in self.game.theater.controlpoints if cp.captured]
self.layout = QGridLayout()
self.left_bar_layout = QVBoxLayout()
self.select_airbase = QChooseAirbase(self.game)
self.select_airbase.selected_airbase_changed.connect(self.on_departure_cp_changed)
self.planned_flight_view = QPlannedFlightsView(None)
self.available_aircraft_at_selected_location = {}
if self.captured_cp[0].id in self.game.planners.keys():
self.planner = self.game.planners[self.captured_cp[0].id]
self.planned_flight_view.set_flight_planner(self.planner)
self.selected_cp = self.captured_cp[0]
self.available_aircraft_at_selected_location = self.planner.get_available_aircraft()
self.planned_flight_view.selectionModel().setCurrentIndex(self.planned_flight_view.indexAt(QPoint(1, 1)), QItemSelectionModel.Rows)
self.planned_flight_view.selectionModel().selectionChanged.connect(self.on_flight_selection_change)
if len(self.planned_flight_view.flight_planner.flights) > 0:
self.flight_planner = QFlightPlanner(self.planned_flight_view.flight_planner.flights[0], self.game, self.planned_flight_view.flight_planner, 0)
self.flight_planner.on_planned_flight_changed.connect(self.update_planned_flight_view)
else:
self.flight_planner = QFlightPlanner(None, self.game, self.planned_flight_view.flight_planner, 0)
self.flight_planner.on_planned_flight_changed.connect(self.update_planned_flight_view)
self.add_flight_button = QPushButton("Add Flight")
self.add_flight_button.clicked.connect(self.on_add_flight)
self.delete_flight_button = QPushButton("Delete Selected")
self.delete_flight_button.setProperty("style", "btn-danger")
self.delete_flight_button.clicked.connect(self.on_delete_flight)
self.button_layout = QHBoxLayout()
self.button_layout.addStretch()
self.button_layout.addWidget(self.delete_flight_button)
self.button_layout.addWidget(self.add_flight_button)
self.mission_start_button = QPushButton("Take Off")
self.mission_start_button.setProperty("style", "start-button")
self.mission_start_button.clicked.connect(self.on_start)
self.left_bar_layout.addWidget(self.select_airbase)
self.left_bar_layout.addWidget(self.planned_flight_view)
self.left_bar_layout.addLayout(self.button_layout)
self.layout.addLayout(self.left_bar_layout, 0, 0)
self.layout.addWidget(self.flight_planner, 0, 1)
self.layout.addWidget(self.mission_start_button, 1, 1, alignment=Qt.AlignRight)
self.setLayout(self.layout)
@Slot(str)
def on_departure_cp_changed(self, cp_name):
cps = [cp for cp in self.game.theater.controlpoints if cp.name == cp_name]
print(cps)
if len(cps) == 1:
self.selected_cp = cps[0]
self.planner = self.game.planners[cps[0].id]
self.available_aircraft_at_selected_location = self.planner.get_available_aircraft()
self.planned_flight_view.set_flight_planner(self.planner)
else:
self.available_aircraft_at_selected_location = {}
self.planned_flight_view.set_flight_planner(None)
def on_flight_selection_change(self):
print("On flight selection change")
index = self.planned_flight_view.selectionModel().currentIndex().row()
self.planned_flight_view.repaint()
if self.flight_planner is not None:
self.flight_planner.on_planned_flight_changed.disconnect()
self.flight_planner.clearTabs()
try:
flight = self.planner.flights[index]
except IndexError:
flight = None
self.flight_planner = QFlightPlanner(flight, self.game, self.planner, self.flight_planner.currentIndex())
self.flight_planner.on_planned_flight_changed.connect(self.update_planned_flight_view)
self.layout.addWidget(self.flight_planner, 0, 1)
def update_planned_flight_view(self):
self.planned_flight_view.update_content()
def on_add_flight(self):
possible_aircraft_type = list(self.selected_cp.base.aircraft.keys())
if len(possible_aircraft_type) == 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("No more aircraft are available on " + self.selected_cp.name + " airbase.")
msg.setWindowTitle("No more aircraft")
msg.setStandardButtons(QMessageBox.Ok)
msg.setWindowFlags(Qt.WindowStaysOnTopHint)
msg.exec_()
else:
self.subwindow = QFlightCreator(self.game, self.selected_cp, possible_aircraft_type, self.planned_flight_view)
self.subwindow.show()
def on_delete_flight(self):
index = self.planned_flight_view.selectionModel().currentIndex().row()
self.planner.remove_flight(index)
self.planned_flight_view.set_flight_planner(self.planner, index)
def on_start(self):
# TODO : refactor this nonsense
self.gameEvent = None
for event in self.game.events:
if isinstance(event, FrontlineAttackEvent) and event.is_player_attacking:
self.gameEvent = event
if self.gameEvent is None:
self.gameEvent = FrontlineAttackEvent(self.game, self.game.theater.controlpoints[0], self.game.theater.controlpoints[0],
self.game.theater.controlpoints[0].position, self.game.player_name, self.game.enemy_name)
#if self.awacs_checkbox.isChecked() == 1:
# self.gameEvent.is_awacs_enabled = True
# self.game.awacs_expense_commit()
#else:
# self.gameEvent.is_awacs_enabled = False
self.gameEvent.is_awacs_enabled = True
self.gameEvent.ca_slots = 1
self.gameEvent.departure_cp = self.game.theater.controlpoints[0]
self.gameEvent.player_attacking({CAS:{}, CAP:{}})
self.gameEvent.depart_from = self.game.theater.controlpoints[0]
self.game.initiate_event(self.gameEvent)
waiting = QWaitingForMissionResultWindow(self.gameEvent, self.game)
waiting.show()
self.close()

198
qt_ui/windows/mission/QPackageDialog.py Normal file
View File

@@ -0,0 +1,198 @@
"""Dialogs for creating and editing ATO packages."""
import logging
from typing import Optional
from PySide2.QtCore import QItemSelection, Signal
from PySide2.QtWidgets import (
QDialog,
QHBoxLayout,
QLabel,
QPushButton,
QVBoxLayout,
)
from game.game import Game
from gen.ato import Package
from gen.flights.flight import Flight
from qt_ui.models import AtoModel, PackageModel
from qt_ui.uiconstants import EVENT_ICONS
from qt_ui.widgets.ato import QFlightList
from qt_ui.windows.mission.flight.QFlightCreator import QFlightCreator
from theater.missiontarget import MissionTarget
class QPackageDialog(QDialog):
"""Base package management dialog.
The dialogs for creating a new package and editing an existing dialog are
very similar, and this implements the shared behavior.
"""
#: Emitted when a change is made to the package.
package_changed = Signal()
#: Emitted when a flight is added to the package.
flight_added = Signal(Flight)
#: Emitted when a flight is removed from the package.
flight_removed = Signal(Flight)
def __init__(self, game: Game, model: PackageModel) -> None:
super().__init__()
self.game = game
self.package_model = model
self.add_flight_dialog: Optional[QFlightCreator] = None
self.setMinimumSize(1000, 440)
self.setWindowTitle(
f"Mission Package: {self.package_model.mission_target.name}"
)
self.setWindowIcon(EVENT_ICONS["strike"])
self.layout = QVBoxLayout()
self.summary_row = QHBoxLayout()
self.layout.addLayout(self.summary_row)
self.package_type_label = QLabel("Package Type:")
self.package_type_text = QLabel(self.package_model.description)
# noinspection PyUnresolvedReferences
self.package_changed.connect(lambda: self.package_type_text.setText(
self.package_model.description
))
self.summary_row.addWidget(self.package_type_label)
self.summary_row.addWidget(self.package_type_text)
self.package_view = QFlightList(self.package_model)
self.package_view.selectionModel().selectionChanged.connect(
self.on_selection_changed
)
self.layout.addWidget(self.package_view)
self.button_layout = QHBoxLayout()
self.layout.addLayout(self.button_layout)
self.add_flight_button = QPushButton("Add Flight")
self.add_flight_button.clicked.connect(self.on_add_flight)
self.button_layout.addWidget(self.add_flight_button)
self.delete_flight_button = QPushButton("Delete Selected")
self.delete_flight_button.setProperty("style", "btn-danger")
self.delete_flight_button.clicked.connect(self.on_delete_flight)
self.delete_flight_button.setEnabled(False)
self.button_layout.addWidget(self.delete_flight_button)
self.button_layout.addStretch()
self.setLayout(self.layout)
def on_selection_changed(self, selected: QItemSelection,
_deselected: QItemSelection) -> None:
"""Updates the state of the delete button."""
self.delete_flight_button.setEnabled(not selected.empty())
def on_add_flight(self) -> None:
"""Opens the new flight dialog."""
self.add_flight_dialog = QFlightCreator(
self.game, self.package_model.package
)
self.add_flight_dialog.created.connect(self.add_flight)
self.add_flight_dialog.show()
def add_flight(self, flight: Flight) -> None:
"""Adds the new flight to the package."""
self.package_model.add_flight(flight)
# noinspection PyUnresolvedReferences
self.package_changed.emit()
# noinspection PyUnresolvedReferences
self.flight_added.emit(flight)
def on_delete_flight(self) -> None:
"""Removes the selected flight from the package."""
flight = self.package_view.selected_item
if flight is None:
logging.error(f"Cannot delete flight when no flight is selected.")
return
self.package_model.delete_flight(flight)
# noinspection PyUnresolvedReferences
self.package_changed.emit()
# noinspection PyUnresolvedReferences
self.flight_removed.emit(flight)
class QNewPackageDialog(QPackageDialog):
"""Dialog window for creating a new package.
New packages do not affect the ATO model until they are saved.
"""
def __init__(self, game: Game, model: AtoModel,
target: MissionTarget) -> None:
super().__init__(game, PackageModel(Package(target)))
self.ato_model = model
self.save_button = QPushButton("Save")
self.save_button.setProperty("style", "start-button")
self.save_button.clicked.connect(self.on_save)
self.button_layout.addWidget(self.save_button)
self.delete_flight_button.clicked.connect(self.on_delete_flight)
def on_save(self) -> None:
"""Saves the created package.
Empty packages may be created. They can be modified later, and will have
no effect if empty when the mission is generated.
"""
self.ato_model.add_package(self.package_model.package)
for flight in self.package_model.package.flights:
self.game.aircraft_inventory.claim_for_flight(flight)
self.close()
class QEditPackageDialog(QPackageDialog):
"""Dialog window for editing an existing package.
Changes to existing packages occur immediately.
"""
def __init__(self, game: Game, model: AtoModel,
package: PackageModel) -> None:
super().__init__(game, package)
self.ato_model = model
self.delete_button = QPushButton("Delete package")
self.delete_button.setProperty("style", "btn-danger")
self.delete_button.clicked.connect(self.on_delete)
self.button_layout.addWidget(self.delete_button)
self.done_button = QPushButton("Done")
self.done_button.setProperty("style", "start-button")
self.done_button.clicked.connect(self.on_done)
self.button_layout.addWidget(self.done_button)
# noinspection PyUnresolvedReferences
self.flight_added.connect(self.on_flight_added)
# noinspection PyUnresolvedReferences
self.flight_removed.connect(self.on_flight_removed)
# TODO: Make the new package dialog do this too, return on cancel.
# Not claiming the aircraft when they are added to the planner means that
# inventory counts are not updated until after the new package is updated,
# so you can add an infinite number of aircraft to a new package in the UI,
# which will crash when the flight package is saved.
def on_flight_added(self, flight: Flight) -> None:
self.game.aircraft_inventory.claim_for_flight(flight)
def on_flight_removed(self, flight: Flight) -> None:
self.game.aircraft_inventory.return_from_flight(flight)
def on_done(self) -> None:
"""Closes the window."""
self.close()
def on_delete(self) -> None:
"""Removes the viewed package from the ATO."""
# The ATO model returns inventory for us when deleting a package.
self.ato_model.delete_package(self.package_model.package)
self.close()

45
qt_ui/windows/mission/QPlannedFlightsView.py
View File

@@ -1,37 +1,36 @@
from PySide2.QtCore import QSize, QItemSelectionModel, QPoint
from PySide2.QtCore import QItemSelectionModel, QSize
from PySide2.QtGui import QStandardItemModel
from PySide2.QtWidgets import QListView, QAbstractItemView
from PySide2.QtWidgets import QAbstractItemView, QListView
from gen.flights.ai_flight_planner import FlightPlanner
from qt_ui.models import GameModel
from qt_ui.windows.mission.QFlightItem import QFlightItem
from theater.controlpoint import ControlPoint
class QPlannedFlightsView(QListView):
def __init__(self, flight_planner: FlightPlanner):
def __init__(self, game_model: GameModel, cp: ControlPoint) -> None:
super(QPlannedFlightsView, self).__init__()
self.game_model = game_model
self.cp = cp
self.model = QStandardItemModel(self)
self.setModel(self.model)
self.flightitems = []
self.flight_items = []
self.setIconSize(QSize(91, 24))
self.setSelectionBehavior(QAbstractItemView.SelectItems)
if flight_planner:
self.set_flight_planner(flight_planner)
self.set_flight_planner()
def update_content(self):
for i, f in enumerate(self.flight_planner.flights):
self.flightitems[i].update(f)
def setup_content(self):
self.flight_items = []
for package in self.game_model.ato_model.packages:
for flight in package.flights:
if flight.from_cp == self.cp:
item = QFlightItem(flight)
self.model.appendRow(item)
self.flight_items.append(item)
self.set_selected_flight(0)
def setup_content(self, row=0):
self.flightitems = []
for i, f in enumerate(self.flight_planner.flights):
item = QFlightItem(f)
self.model.appendRow(item)
self.flightitems.append(item)
self.setSelectedFlight(row)
self.repaint()
def setSelectedFlight(self, row):
def set_selected_flight(self, row):
self.selectionModel().clearSelection()
index = self.model.index(row, 0)
if not index.isValid():
@@ -42,8 +41,6 @@ class QPlannedFlightsView(QListView):
def clear_layout(self):
self.model.removeRows(0, self.model.rowCount())
def set_flight_planner(self, flight_planner: FlightPlanner, row=0):
def set_flight_planner(self) -> None:
self.clear_layout()
self.flight_planner = flight_planner
if self.flight_planner:
self.setup_content(row)
self.setup_content()

239
qt_ui/windows/mission/flight/QFlightCreator.py
View File

@@ -1,122 +1,169 @@
from typing import List
import logging
from typing import Optional
from PySide2.QtCore import Qt
from PySide2.QtWidgets import QDialog, QGridLayout, QLabel, QComboBox, QHBoxLayout, QVBoxLayout, QPushButton, QSpinBox, \
QMessageBox
from dcs import Point
from dcs.unittype import UnitType
from PySide2.QtCore import Qt, Signal
from PySide2.QtWidgets import (
QDialog,
QMessageBox,
QPushButton,
QVBoxLayout,
)
from dcs.planes import PlaneType
from game import Game
from gen.ato import Package
from gen.flights.ai_flight_planner import FlightPlanner
from gen.flights.flight import Flight, FlightWaypoint, FlightType
from gen.flights.flight import Flight, FlightType
from qt_ui.uiconstants import EVENT_ICONS
from qt_ui.windows.mission.flight.waypoints.QFlightWaypointInfoBox import QFlightWaypointInfoBox
from theater import ControlPoint
PREDEFINED_WAYPOINT_CATEGORIES = [
"Frontline (CAS AREA)",
"Building",
"Units",
"Airbase"
]
from qt_ui.widgets.QFlightSizeSpinner import QFlightSizeSpinner
from qt_ui.widgets.QLabeledWidget import QLabeledWidget
from qt_ui.widgets.combos.QAircraftTypeSelector import QAircraftTypeSelector
from qt_ui.widgets.combos.QFlightTypeComboBox import QFlightTypeComboBox
from qt_ui.widgets.combos.QOriginAirfieldSelector import QOriginAirfieldSelector
from theater import ControlPoint, TheaterGroundObject
class QFlightCreator(QDialog):
created = Signal(Flight)
def __init__(self, game: Game, package: Package) -> None:
super().__init__()
def __init__(self, game: Game, from_cp:ControlPoint, possible_aircraft_type:List[UnitType], flight_view=None):
super(QFlightCreator, self).__init__()
self.game = game
self.from_cp = from_cp
self.flight_view = flight_view
self.planner = self.game.planners[from_cp.id]
self.available = self.planner.get_available_aircraft()
self.package = package
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.setModal(True)
self.setWindowTitle("Create flight")
self.setWindowIcon(EVENT_ICONS["strike"])
self.select_type_aircraft = QComboBox()
for aircraft_type in self.planner.get_available_aircraft().keys():
print(aircraft_type)
print(aircraft_type.name)
if self.available[aircraft_type] > 0:
self.select_type_aircraft.addItem(aircraft_type.id, userData=aircraft_type)
self.select_type_aircraft.setCurrentIndex(0)
self.select_flight_type = QComboBox()
self.select_flight_type.addItem("CAP [Combat Air Patrol]", userData=FlightType.CAP)
self.select_flight_type.addItem("BARCAP [Barrier Combat Air Patrol]", userData=FlightType.BARCAP)
self.select_flight_type.addItem("TARCAP [Target Combat Air Patrol]", userData=FlightType.TARCAP)
self.select_flight_type.addItem("INTERCEPT [Interception]", userData=FlightType.INTERCEPTION)
self.select_flight_type.addItem("CAS [Close Air Support]", userData=FlightType.CAS)
self.select_flight_type.addItem("BAI [Battlefield Interdiction]", userData=FlightType.BAI)
self.select_flight_type.addItem("SEAD [Suppression of Enemy Air Defenses]", userData=FlightType.SEAD)
self.select_flight_type.addItem("DEAD [Destruction of Enemy Air Defenses]", userData=FlightType.DEAD)
self.select_flight_type.addItem("STRIKE [Strike]", userData=FlightType.STRIKE)
self.select_flight_type.addItem("ANTISHIP [Antiship Attack]", userData=FlightType.ANTISHIP)
self.select_flight_type.setCurrentIndex(0)
self.select_count_of_aircraft = QSpinBox()
self.select_count_of_aircraft.setMinimum(1)
self.select_count_of_aircraft.setMaximum(4)
self.select_count_of_aircraft.setValue(2)
aircraft_type = self.select_type_aircraft.currentData()
if aircraft_type is not None:
self.select_count_of_aircraft.setValue(min(self.available[aircraft_type], 2))
self.select_count_of_aircraft.setMaximum(min(self.available[aircraft_type], 4))
self.add_button = QPushButton("Add")
self.add_button.clicked.connect(self.create_flight)
self.init_ui()
def init_ui(self):
layout = QVBoxLayout()
type_layout = QHBoxLayout()
type_layout.addWidget(QLabel("Type of Aircraft : "))
type_layout.addStretch()
type_layout.addWidget(self.select_type_aircraft, alignment=Qt.AlignRight)
# TODO: Limit task selection to those valid for the target type.
self.task_selector = QFlightTypeComboBox()
self.task_selector.setCurrentIndex(0)
layout.addLayout(QLabeledWidget("Task:", self.task_selector))
count_layout = QHBoxLayout()
count_layout.addWidget(QLabel("Count : "))
count_layout.addStretch()
count_layout.addWidget(self.select_count_of_aircraft, alignment=Qt.AlignRight)
self.aircraft_selector = QAircraftTypeSelector(
self.game.aircraft_inventory.available_types_for_player
)
self.aircraft_selector.setCurrentIndex(0)
self.aircraft_selector.currentIndexChanged.connect(
self.on_aircraft_changed)
layout.addLayout(QLabeledWidget("Aircraft:", self.aircraft_selector))
flight_type_layout = QHBoxLayout()
flight_type_layout.addWidget(QLabel("Task : "))
flight_type_layout.addStretch()
flight_type_layout.addWidget(self.select_flight_type, alignment=Qt.AlignRight)
self.airfield_selector = QOriginAirfieldSelector(
self.game.aircraft_inventory,
[cp for cp in game.theater.controlpoints if cp.captured],
self.aircraft_selector.currentData()
)
layout.addLayout(QLabeledWidget("Airfield:", self.airfield_selector))
self.flight_size_spinner = QFlightSizeSpinner()
layout.addLayout(QLabeledWidget("Count:", self.flight_size_spinner))
layout.addLayout(type_layout)
layout.addLayout(count_layout)
layout.addLayout(flight_type_layout)
layout.addStretch()
layout.addWidget(self.add_button, alignment=Qt.AlignRight)
self.create_button = QPushButton("Create")
self.create_button.clicked.connect(self.create_flight)
layout.addWidget(self.create_button, alignment=Qt.AlignRight)
self.setLayout(layout)
def create_flight(self):
aircraft_type = self.select_type_aircraft.currentData()
count = self.select_count_of_aircraft.value()
def verify_form(self) -> Optional[str]:
aircraft: PlaneType = self.aircraft_selector.currentData()
origin: ControlPoint = self.airfield_selector.currentData()
size: int = self.flight_size_spinner.value()
if not origin.captured:
return f"{origin.name} is not owned by your coalition."
available = origin.base.aircraft.get(aircraft, 0)
if not available:
return f"{origin.name} has no {aircraft.id} available."
if size > available:
return f"{origin.name} has only {available} {aircraft.id} available."
return None
if self.available[aircraft_type] < count:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Not enough aircraft of this type are available. Only " + str(self.available[aircraft_type]) + " available.")
msg.setWindowTitle("Not enough aircraft")
msg.setStandardButtons(QMessageBox.Ok)
msg.setWindowFlags(Qt.WindowStaysOnTopHint)
msg.exec_()
def create_flight(self) -> None:
error = self.verify_form()
if error is not None:
self.error_box("Could not create flight", error)
return
else:
flight = Flight(aircraft_type, count, self.from_cp, self.select_flight_type.currentData())
self.planner.flights.append(flight)
self.planner.custom_flights.append(flight)
if self.flight_view is not None:
self.flight_view.set_flight_planner(self.planner, len(self.planner.flights)-1)
self.close()
task = self.task_selector.currentData()
aircraft = self.aircraft_selector.currentData()
origin = self.airfield_selector.currentData()
size = self.flight_size_spinner.value()
flight = Flight(aircraft, size, origin, task)
self.populate_flight_plan(flight, task)
# noinspection PyUnresolvedReferences
self.created.emit(flight)
self.close()
def on_aircraft_changed(self, index: int) -> None:
new_aircraft = self.aircraft_selector.itemData(index)
self.airfield_selector.change_aircraft(new_aircraft)
@property
def planner(self) -> FlightPlanner:
return self.game.planners[self.airfield_selector.currentData().id]
def populate_flight_plan(self, flight: Flight, task: FlightType) -> None:
# TODO: Flesh out mission types.
# Probably most important to add, since it's a regression, is CAS. Right
# now it's not possible to frag a package on a front line though, and
# that's the only location where CAS missions are valid.
if task == FlightType.ANTISHIP:
logging.error("Anti-ship flight plan generation not implemented")
elif task == FlightType.BAI:
logging.error("BAI flight plan generation not implemented")
elif task == FlightType.BARCAP:
self.generate_cap(flight)
elif task == FlightType.CAP:
self.generate_cap(flight)
elif task == FlightType.CAS:
logging.error("CAS flight plan generation not implemented")
elif task == FlightType.DEAD:
self.generate_sead(flight)
elif task == FlightType.ELINT:
logging.error("ELINT flight plan generation not implemented")
elif task == FlightType.EVAC:
logging.error("Evac flight plan generation not implemented")
elif task == FlightType.EWAR:
logging.error("EWar flight plan generation not implemented")
elif task == FlightType.INTERCEPTION:
logging.error("Intercept flight plan generation not implemented")
elif task == FlightType.LOGISTICS:
logging.error("Logistics flight plan generation not implemented")
elif task == FlightType.RECON:
logging.error("Recon flight plan generation not implemented")
elif task == FlightType.SEAD:
self.generate_sead(flight)
elif task == FlightType.STRIKE:
self.generate_strike(flight)
elif task == FlightType.TARCAP:
self.generate_cap(flight)
elif task == FlightType.TROOP_TRANSPORT:
logging.error(
"Troop transport flight plan generation not implemented"
)
def generate_cap(self, flight: Flight) -> None:
if not isinstance(self.package.target, ControlPoint):
logging.error(
"Could not create flight plan: CAP missions for strike targets "
"not implemented"
)
return
self.planner.generate_barcap(flight, self.package.target)
def generate_sead(self, flight: Flight) -> None:
self.planner.generate_sead(flight, self.package.target)
def generate_strike(self, flight: Flight) -> None:
if not isinstance(self.package.target, TheaterGroundObject):
logging.error(
"Could not create flight plan: strike missions for capture "
"points not implemented"
)
return
self.planner.generate_strike(flight, self.package.target)

53
qt_ui/windows/mission/flight/QFlightPlanner.py
View File

@@ -1,42 +1,31 @@
from PySide2.QtCore import Signal
from PySide2.QtWidgets import QTabWidget, QFrame, QGridLayout, QLabel
from PySide2.QtWidgets import QTabWidget
from gen.flights.flight import Flight
from game import Game
from qt_ui.windows.mission.flight.payload.QFlightPayloadTab import QFlightPayloadTab
from qt_ui.windows.mission.flight.settings.QGeneralFlightSettingsTab import QGeneralFlightSettingsTab
from qt_ui.windows.mission.flight.waypoints.QFlightWaypointTab import QFlightWaypointTab
from gen.flights.flight import Flight
from qt_ui.windows.mission.flight.payload.QFlightPayloadTab import \
QFlightPayloadTab
from qt_ui.windows.mission.flight.settings.QGeneralFlightSettingsTab import \
QGeneralFlightSettingsTab
from qt_ui.windows.mission.flight.waypoints.QFlightWaypointTab import \
QFlightWaypointTab
class QFlightPlanner(QTabWidget):
on_planned_flight_changed = Signal()
def __init__(self, flight: Flight, game: Game, planner, selected_tab):
super(QFlightPlanner, self).__init__()
def __init__(self, flight: Flight, game: Game):
super().__init__()
print(selected_tab)
self.tabCount = 0
if flight:
self.general_settings_tab = QGeneralFlightSettingsTab(flight, game, planner)
self.general_settings_tab.on_flight_settings_changed.connect(lambda: self.on_planned_flight_changed.emit())
self.payload_tab = QFlightPayloadTab(flight, game)
self.waypoint_tab = QFlightWaypointTab(game, flight)
self.waypoint_tab.on_flight_changed.connect(lambda: self.on_planned_flight_changed.emit())
self.addTab(self.general_settings_tab, "General Flight settings")
self.addTab(self.payload_tab, "Payload")
self.addTab(self.waypoint_tab, "Waypoints")
self.tabCount = 3
self.setCurrentIndex(selected_tab)
else:
tabError = QFrame()
l = QGridLayout()
l.addWidget(QLabel("No flight selected"))
tabError.setLayout(l)
self.addTab(tabError, "No flight")
self.tabCount = 1
def clearTabs(self):
for i in range(self.tabCount):
self.removeTab(i)
self.general_settings_tab = QGeneralFlightSettingsTab(game, flight)
self.general_settings_tab.on_flight_settings_changed.connect(
lambda: self.on_planned_flight_changed.emit())
self.payload_tab = QFlightPayloadTab(flight, game)
self.waypoint_tab = QFlightWaypointTab(game, flight)
self.waypoint_tab.on_flight_changed.connect(
lambda: self.on_planned_flight_changed.emit())
self.addTab(self.general_settings_tab, "General Flight settings")
self.addTab(self.payload_tab, "Payload")
self.addTab(self.waypoint_tab, "Waypoints")
self.setCurrentIndex(0)

8
qt_ui/windows/mission/flight/settings/QFlightSlotEditor.py
View File

@@ -6,12 +6,14 @@ class QFlightSlotEditor(QGroupBox):
changed = Signal()
def __init__(self, flight, game, planner):
def __init__(self, flight, game):
super(QFlightSlotEditor, self).__init__("Slots")
self.flight = flight
self.game = game
self.planner = planner
self.available = self.planner.get_available_aircraft()
inventory = self.game.aircraft_inventory.for_control_point(
flight.from_cp
)
self.available = inventory.all_aircraft
if self.flight.unit_type not in self.available:
max = self.flight.count
else:

13
qt_ui/windows/mission/flight/settings/QGeneralFlightSettingsTab.py
View File

@@ -12,18 +12,15 @@ from qt_ui.windows.mission.flight.settings.QFlightTypeTaskInfo import QFlightTyp
class QGeneralFlightSettingsTab(QFrame):
on_flight_settings_changed = Signal()
def __init__(self, flight: Flight, game: Game, planner):
def __init__(self, game: Game, flight: Flight):
super(QGeneralFlightSettingsTab, self).__init__()
self.flight = flight
self.game = game
self.planner = planner
self.init_ui()
def init_ui(self):
layout = QGridLayout()
flight_info = QFlightTypeTaskInfo(self.flight)
flight_departure = QFlightDepartureEditor(self.flight)
flight_slots = QFlightSlotEditor(self.flight, self.game, self.planner)
flight_slots = QFlightSlotEditor(self.flight, self.game)
flight_start_type = QFlightStartType(self.flight)
layout.addWidget(flight_info, 0, 0)
layout.addWidget(flight_departure, 1, 0)
@@ -35,5 +32,7 @@ class QGeneralFlightSettingsTab(QFrame):
self.setLayout(layout)
flight_start_type.setEnabled(self.flight.client_count > 0)
flight_slots.changed.connect(lambda: flight_start_type.setEnabled(self.flight.client_count > 0))
flight_departure.changed.connect(lambda: self.on_flight_settings_changed.emit())
flight_slots.changed.connect(
lambda: flight_start_type.setEnabled(self.flight.client_count > 0))
flight_departure.changed.connect(
lambda: self.on_flight_settings_changed.emit())