mirror of
https://github.com/dcs-retribution/dcs-retribution.git
synced 2025-11-10 15:41:24 +00:00
54777a9045
* Helicopter waypoint altitude configurable Added a new option in Settings: Helicopter waypoint altitude (feet AGL). It sets the waypoint altitude for helicopters in feet AGL. In campaigns in more mountainous areas, you might want to increase this setting to avoid the AI flying into the terrain. * black? * Distinguish cruise/combat altitudes for helicopters Also includes a refactor for WaypointBuilder so it doesn't need a coalition. It can already reference the coalition from the flight. * Update changelog.md --------- Co-authored-by: Raffson <Raffson@users.noreply.github.com>
240 lines
9.3 KiB
Python
240 lines
9.3 KiB
Python
import logging
|
|
from typing import Iterable, List, Optional
|
|
|
|
from PySide2.QtCore import Signal, Qt, QModelIndex
|
|
from PySide2.QtWidgets import (
|
|
QFrame,
|
|
QGridLayout,
|
|
QLabel,
|
|
QMessageBox,
|
|
QPushButton,
|
|
QVBoxLayout,
|
|
QWidget,
|
|
)
|
|
|
|
from game import Game
|
|
from game.ato.flight import Flight
|
|
from game.ato.flightplans.custom import CustomFlightPlan
|
|
from game.ato.flightplans.formationattack import FormationAttackFlightPlan
|
|
from game.ato.flightplans.planningerror import PlanningError
|
|
from game.ato.flightplans.waypointbuilder import WaypointBuilder
|
|
from game.ato.flighttype import FlightType
|
|
from game.ato.flightwaypoint import FlightWaypoint
|
|
from game.ato.loadouts import Loadout
|
|
from game.ato.package import Package
|
|
from qt_ui.windows.mission.flight.waypoints.QFlightWaypointList import (
|
|
QFlightWaypointList,
|
|
)
|
|
from qt_ui.windows.mission.flight.waypoints.QPredefinedWaypointSelectionWindow import (
|
|
QPredefinedWaypointSelectionWindow,
|
|
)
|
|
|
|
|
|
class QFlightWaypointTab(QFrame):
|
|
loadout_changed = Signal()
|
|
|
|
def __init__(self, game: Game, package: Package, flight: Flight):
|
|
super(QFlightWaypointTab, self).__init__()
|
|
self.game = game
|
|
self.coalition = game.coalition_for(player=True)
|
|
self.package = package
|
|
self.flight = flight
|
|
|
|
self.flight_waypoint_list: Optional[QFlightWaypointList] = None
|
|
self.rtb_waypoint: Optional[QPushButton] = None
|
|
self.delete_selected: Optional[QPushButton] = None
|
|
self.add_nav_waypoint: Optional[QPushButton] = None
|
|
self.open_fast_waypoint_button: Optional[QPushButton] = None
|
|
self.recreate_buttons: List[QPushButton] = []
|
|
self.init_ui()
|
|
|
|
def init_ui(self):
|
|
layout = QGridLayout()
|
|
|
|
self.flight_waypoint_list = QFlightWaypointList(self.package, self.flight)
|
|
layout.addWidget(self.flight_waypoint_list, 0, 0)
|
|
|
|
rlayout = QVBoxLayout()
|
|
layout.addLayout(rlayout, 0, 1)
|
|
|
|
rlayout.addWidget(QLabel("<strong>Generator :</strong>"))
|
|
rlayout.addWidget(QLabel("<small>AI compatible</small>"))
|
|
|
|
self.recreate_buttons.clear()
|
|
for task in self.package.target.mission_types(for_player=True):
|
|
if task == FlightType.AIR_ASSAULT and not self.game.settings.plugin_option(
|
|
"ctld"
|
|
):
|
|
# Only add Air Assault if ctld plugin is enabled
|
|
continue
|
|
|
|
def make_closure(arg):
|
|
def closure():
|
|
return self.confirm_recreate(arg)
|
|
|
|
return closure
|
|
|
|
button = QPushButton(f"Recreate as {task}")
|
|
button.clicked.connect(make_closure(task))
|
|
rlayout.addWidget(button)
|
|
self.recreate_buttons.append(button)
|
|
|
|
self.add_nav_waypoint = QPushButton("Insert NAV point")
|
|
self.add_nav_waypoint.clicked.connect(self.on_add_nav)
|
|
rlayout.addWidget(self.add_nav_waypoint)
|
|
|
|
rlayout.addWidget(QLabel("<strong>Advanced : </strong>"))
|
|
rlayout.addWidget(QLabel("<small>Do not use for AI flights</small>"))
|
|
|
|
self.rtb_waypoint = QPushButton("Add RTB Waypoint")
|
|
self.rtb_waypoint.clicked.connect(self.on_rtb_waypoint)
|
|
rlayout.addWidget(self.rtb_waypoint)
|
|
|
|
self.delete_selected = QPushButton("Delete Selected")
|
|
self.delete_selected.clicked.connect(self.on_delete_waypoint)
|
|
rlayout.addWidget(self.delete_selected)
|
|
|
|
self.open_fast_waypoint_button = QPushButton("Add Waypoint")
|
|
self.open_fast_waypoint_button.clicked.connect(self.on_fast_waypoint)
|
|
rlayout.addWidget(self.open_fast_waypoint_button)
|
|
rlayout.addStretch()
|
|
self.setLayout(layout)
|
|
|
|
def on_add_nav(self):
|
|
selected = self.flight_waypoint_list.selectedIndexes()
|
|
if not selected:
|
|
return
|
|
index: QModelIndex = selected[0]
|
|
self.flight_waypoint_list.setCurrentIndex(index)
|
|
wpt: FlightWaypoint = self.flight_waypoint_list.model.data(index, Qt.UserRole)
|
|
next_wpt: Optional[FlightWaypoint] = None
|
|
if index.row() + 1 < self.flight_waypoint_list.model.rowCount():
|
|
next_wpt = self.flight_waypoint_list.model.data(
|
|
index.siblingAtRow(index.row() + 1), Qt.UserRole
|
|
)
|
|
if not self.flight.flight_plan.layout.add_waypoint(wpt, next_wpt):
|
|
QMessageBox.critical(
|
|
QWidget(),
|
|
"Failed to add NAV waypoint",
|
|
"Could not insert a new waypoint given the currently selected waypoint.\n"
|
|
"Please select a different waypoint to insert the new NAV waypoint.",
|
|
)
|
|
else:
|
|
self.flight_waypoint_list.model.insertRow(
|
|
self.flight_waypoint_list.model.rowCount()
|
|
)
|
|
self.on_change()
|
|
|
|
def on_delete_waypoint(self):
|
|
waypoints = []
|
|
selection = self.flight_waypoint_list.selectionModel()
|
|
for selected_row in selection.selectedIndexes():
|
|
if selected_row.row() > 0:
|
|
waypoints.append(self.flight.flight_plan.waypoints[selected_row.row()])
|
|
for waypoint in waypoints:
|
|
self.delete_waypoint(waypoint)
|
|
self.on_change()
|
|
|
|
def delete_waypoint(self, waypoint: FlightWaypoint) -> None:
|
|
# Need to degrade to a custom flight plan and remove the waypoint.
|
|
# If the waypoint is a target waypoint and is not the last target
|
|
# waypoint, we don't need to degrade.
|
|
fp = self.flight.flight_plan
|
|
if isinstance(fp, FormationAttackFlightPlan):
|
|
is_target = waypoint in fp.target_area_waypoint.targets
|
|
count = len(fp.target_area_waypoint.targets)
|
|
if is_target and count > 1:
|
|
fp.target_area_waypoint.targets.remove(waypoint)
|
|
return
|
|
model = self.flight_waypoint_list.model
|
|
if fp.layout.delete_waypoint(waypoint):
|
|
model.removeRow(model.rowCount() - 1)
|
|
return
|
|
|
|
if not self.flight.flight_plan.is_custom:
|
|
confirmed = self.confirm_degrade()
|
|
if not confirmed:
|
|
return
|
|
model.removeRow(model.rowCount() - 1)
|
|
self.degrade_to_custom_flight_plan()
|
|
assert isinstance(self.flight.flight_plan, CustomFlightPlan)
|
|
self.flight.flight_plan.layout.custom_waypoints.remove(waypoint)
|
|
|
|
def confirm_degrade(self) -> bool:
|
|
result = QMessageBox.warning(
|
|
self,
|
|
"Degrade flight-plan?",
|
|
"Deleting the selected waypoint(s) will require degradation to a custom flight-plan. "
|
|
"A custom flight-plan will no longer respect the TOTs of the package.<br><br>"
|
|
"<b>Are you sure you wish to continue?</b>",
|
|
QMessageBox.Yes,
|
|
QMessageBox.No,
|
|
)
|
|
return result == QMessageBox.Yes
|
|
|
|
def on_fast_waypoint(self):
|
|
self.subwindow = QPredefinedWaypointSelectionWindow(
|
|
self.game, self.flight, self.flight_waypoint_list
|
|
)
|
|
self.subwindow.waypoints_added.connect(self.on_waypoints_added)
|
|
self.subwindow.show()
|
|
|
|
def on_waypoints_added(self, waypoints: Iterable[FlightWaypoint]) -> None:
|
|
if not waypoints:
|
|
return
|
|
if not self.flight.flight_plan.is_custom:
|
|
confirmed = self.confirm_degrade()
|
|
if not confirmed:
|
|
return
|
|
self.degrade_to_custom_flight_plan()
|
|
assert isinstance(self.flight.flight_plan, CustomFlightPlan)
|
|
self.flight.flight_plan.layout.custom_waypoints.extend(waypoints)
|
|
rc = self.flight_waypoint_list.model.rowCount()
|
|
self.flight_waypoint_list.model.insertRows(rc, len(list(waypoints)))
|
|
self.on_change()
|
|
|
|
def on_rtb_waypoint(self):
|
|
rtb = WaypointBuilder(self.flight).land(self.flight.arrival)
|
|
self.degrade_to_custom_flight_plan()
|
|
assert isinstance(self.flight.flight_plan, CustomFlightPlan)
|
|
self.flight.flight_plan.layout.custom_waypoints.append(rtb)
|
|
self.on_change()
|
|
|
|
def degrade_to_custom_flight_plan(self) -> None:
|
|
if not isinstance(self.flight.flight_plan, CustomFlightPlan):
|
|
self.flight.degrade_to_custom_flight_plan()
|
|
|
|
def confirm_recreate(self, task: FlightType) -> None:
|
|
result = QMessageBox.question(
|
|
self,
|
|
"Regenerate flight?",
|
|
(
|
|
"Changing the flight type will reset its flight plan. Do you want "
|
|
"to continue?"
|
|
),
|
|
QMessageBox.No,
|
|
QMessageBox.Yes,
|
|
)
|
|
original_task = self.flight.flight_type
|
|
if result == QMessageBox.Yes:
|
|
self.flight.set_flight_type(task)
|
|
try:
|
|
self.flight.recreate_flight_plan()
|
|
except PlanningError as ex:
|
|
self.flight.set_flight_type(original_task)
|
|
logging.exception("Could not recreate flight")
|
|
QMessageBox.critical(
|
|
self, "Could not recreate flight", str(ex), QMessageBox.Ok
|
|
)
|
|
for member in self.flight.iter_members():
|
|
if not member.loadout.is_custom:
|
|
member.loadout = Loadout.default_for(self.flight)
|
|
self.loadout_changed.emit()
|
|
self.flight_waypoint_list.update_list()
|
|
self.on_change()
|
|
|
|
def on_change(self):
|
|
self.flight_waypoint_list.update_list()
|
|
self.flight_waypoint_list.on_changed()
|
|
self.update()
|