Merge 'upstream/develop' into new-plugin-system

gen/aircraft.py

@@ -419,6 +419,7 @@ class SCR522RadioChannelAllocator(RadioChannelAllocator):
 
         # TODO : Some GCI on Channel 4 ?
 
+
 @dataclass(frozen=True)
 class AircraftData:
     """Additional aircraft data not exposed by pydcs."""
@@ -442,7 +443,9 @@ class AircraftData:
 AIRCRAFT_DATA: Dict[str, AircraftData] = {
     "A-10C": AircraftData(
         inter_flight_radio=get_radio("AN/ARC-164"),
-        intra_flight_radio=get_radio("AN/ARC-164"), # VHF for intraflight is not accepted anymore by DCS (see https://forums.eagle.ru/showthread.php?p=4499738)
+        # VHF for intraflight is not accepted anymore by DCS
+        # (see https://forums.eagle.ru/showthread.php?p=4499738).
+        intra_flight_radio=get_radio("AN/ARC-164"),
         channel_allocator=WarthogRadioChannelAllocator()
     ),
 
@@ -532,6 +535,7 @@ AIRCRAFT_DATA: Dict[str, AircraftData] = {
         channel_namer=SCR522ChannelNamer
     ),
 }
+AIRCRAFT_DATA["A-10C_2"] = AIRCRAFT_DATA["A-10C"]
 AIRCRAFT_DATA["P-51D-30-NA"] = AIRCRAFT_DATA["P-51D"]
 AIRCRAFT_DATA["P-47D-30"] = AIRCRAFT_DATA["P-51D"]
 
@@ -793,6 +797,8 @@ class AircraftConflictGenerator:
         self.clear_parking_slots()
 
         for package in ato.packages:
+            if not package.flights:
+                continue
             timing = PackageWaypointTiming.for_package(package)
             for flight in package.flights:
                 culled = self.game.position_culled(flight.from_cp.position)
@@ -996,7 +1002,7 @@ class AircraftConflictGenerator:
                            flight: Flight, timing: PackageWaypointTiming,
                            dynamic_runways: Dict[str, RunwayData]) -> None:
         flight_type = flight.flight_type
-        if flight_type in [FlightType.CAP, FlightType.BARCAP, FlightType.TARCAP,
+        if flight_type in [FlightType.BARCAP, FlightType.TARCAP,
                            FlightType.INTERCEPTION]:
             self.configure_cap(group, flight, dynamic_runways)
         elif flight_type in [FlightType.CAS, FlightType.BAI]:
@@ -1135,7 +1141,7 @@ class HoldPointBuilder(PydcsWaypointBuilder):
             pattern=OrbitAction.OrbitPattern.Circle
         ))
         loiter.stop_after_time(
-            self.timing.push_time(self.flight, waypoint.position))
+            self.timing.push_time(self.flight, self.waypoint))
         waypoint.add_task(loiter)
         return waypoint
 

gen/briefinggen.py

@@ -129,6 +129,11 @@ class BriefingGenerator(MissionInfoGenerator):
         self.description += "DCS Liberation turn #" + str(self.game.turn) + "\n"
         self.description += "=" * 15 + "\n\n"
 
+        self.description += (
+            "Most briefing information, including communications and flight "
+            "plan information, can be found on your kneeboard.\n\n"
+        )
+
         self.generate_ongoing_war_text()
 
         self.description += "\n"*2

gen/environmentgen.py

@@ -1,147 +1,36 @@
-import logging
-import random
-from datetime import timedelta
+from typing import Optional
 
 from dcs.mission import Mission
-from dcs.weather import Weather, Wind
 
-from .conflictgen import Conflict
-
-WEATHER_CLOUD_BASE = 2000, 3000
-WEATHER_CLOUD_DENSITY = 1, 8
-WEATHER_CLOUD_THICKNESS = 100, 400
-WEATHER_CLOUD_BASE_MIN = 1600
-
-WEATHER_FOG_CHANCE = 20
-WEATHER_FOG_VISIBILITY = 2500, 5000
-WEATHER_FOG_THICKNESS = 100, 500
-
-RANDOM_TIME = {
-    "night": 7,
-    "dusk": 40,
-    "dawn": 40,
-    "day": 100,
-}
-
-RANDOM_WEATHER = {
-    1: 0,  # thunderstorm
-    2: 20,  # rain
-    3: 80,  # clouds
-    4: 100,  # clear
-}
+from game.weather import Clouds, Fog, Conditions, WindConditions
 
 
-class EnvironmentSettings:
-    weather_dict = None
-    start_time = None
-
-
-class EnviromentGenerator:
-    def __init__(self, mission: Mission, conflict: Conflict, game):
+class EnvironmentGenerator:
+    def __init__(self, mission: Mission, conditions: Conditions) -> None:
         self.mission = mission
-        self.conflict = conflict
-        self.game = game
+        self.conditions = conditions
 
-    def _gen_time(self):
+    def set_clouds(self, clouds: Optional[Clouds]) -> None:
+        if clouds is None:
+            return
+        self.mission.weather.clouds_base = clouds.base
+        self.mission.weather.clouds_thickness = clouds.thickness
+        self.mission.weather.clouds_density = clouds.density
+        self.mission.weather.clouds_iprecptns = clouds.precipitation
 
-        start_time = self.game.current_day
+    def set_fog(self, fog: Optional[Fog]) -> None:
+        if fog is None:
+            return
+        self.mission.weather.fog_visibility = fog.visibility
+        self.mission.weather.fog_thickness = fog.thickness
 
-        daytime = self.game.current_turn_daytime
-        logging.info("Mission time will be {}".format(daytime))
-        if self.game.settings.night_disabled:
-            logging.info("Skip Night mission due to user settings")
-            if daytime == "dawn":
-                time_range = (8, 9)
-            elif daytime == "day":
-                time_range = (10, 12)
-            elif daytime == "dusk":
-                time_range = (12, 14)
-            elif daytime == "night":
-                time_range = (14, 17)
-            else:
-                time_range = (10, 12)
-        else:
-            time_range = self.game.theater.daytime_map[daytime]
-
-        start_time += timedelta(hours=random.randint(*time_range))
-
-        logging.info("time - {}, slot - {}, night skipped - {}".format(
-            str(start_time),
-            str(time_range),
-            self.game.settings.night_disabled))
-
-        self.mission.start_time = start_time
-
-    def _generate_wind(self, wind_speed, wind_direction=None):
-        # wind
-        if not wind_direction:
-            wind_direction = random.randint(0, 360)
-
-        self.mission.weather.wind_at_ground = Wind(wind_direction, wind_speed)
-        self.mission.weather.wind_at_2000 = Wind(wind_direction, wind_speed * 2)
-        self.mission.weather.wind_at_8000 = Wind(wind_direction, wind_speed * 3)
-
-    def _generate_base_weather(self):
-        # clouds
-        self.mission.weather.clouds_base = random.randint(*WEATHER_CLOUD_BASE)
-        self.mission.weather.clouds_density = random.randint(*WEATHER_CLOUD_DENSITY)
-        self.mission.weather.clouds_thickness = random.randint(*WEATHER_CLOUD_THICKNESS)
-
-        # wind
-        self._generate_wind(random.randint(0, 4))
-
-        # fog
-        if random.randint(0, 100) < WEATHER_FOG_CHANCE:
-            self.mission.weather.fog_visibility = random.randint(*WEATHER_FOG_VISIBILITY)
-            self.mission.weather.fog_thickness = random.randint(*WEATHER_FOG_THICKNESS)
-
-    def _gen_random_weather(self):
-        weather_type = None
-        for k, v in RANDOM_WEATHER.items():
-            if random.randint(0, 100) <= v:
-                weather_type = k
-                break
-
-        logging.info("generated weather {}".format(weather_type))
-        if weather_type == 1:
-            # thunderstorm
-            self._generate_base_weather()
-            self._generate_wind(random.randint(0, 8))
-
-            self.mission.weather.clouds_density = random.randint(9, 10)
-            self.mission.weather.clouds_iprecptns = Weather.Preceptions.Thunderstorm
-        elif weather_type == 2:
-            # rain
-            self._generate_base_weather()
-            self.mission.weather.clouds_density = random.randint(5, 8)
-            self.mission.weather.clouds_iprecptns = Weather.Preceptions.Rain
-
-            self._generate_wind(random.randint(0, 6))
-        elif weather_type == 3:
-            # clouds
-            self._generate_base_weather()
-        elif weather_type == 4:
-            # clear
-            pass
-
-        if self.mission.weather.clouds_density > 0:
-            # sometimes clouds are randomized way too low and need to be fixed
-            self.mission.weather.clouds_base = max(self.mission.weather.clouds_base, WEATHER_CLOUD_BASE_MIN)
-
-        if self.mission.weather.wind_at_ground.speed == 0:
-            # frontline smokes look silly w/o any wind
-            self._generate_wind(1)
-
-    def generate(self) -> EnvironmentSettings:
-        self._gen_time()
-        self._gen_random_weather()
-
-        settings = EnvironmentSettings()
-        settings.start_time = self.mission.start_time
-        settings.weather_dict = self.mission.weather.dict()
-        return settings
-
-    def load(self, settings: EnvironmentSettings):
-        self.mission.start_time = settings.start_time
-        self.mission.weather.load_from_dict(settings.weather_dict)
+    def set_wind(self, wind: WindConditions) -> None:
+        self.mission.weather.wind_at_ground = wind.at_0m
+        self.mission.weather.wind_at_2000 = wind.at_2000m
+        self.mission.weather.wind_at_8000 = wind.at_8000m
 
+    def generate(self):
+        self.mission.start_time = self.conditions.start_time
+        self.set_clouds(self.conditions.weather.clouds)
+        self.set_fog(self.conditions.weather.fog)
+        self.set_wind(self.conditions.weather.wind)

gen/flights/ai_flight_planner.py

@@ -131,7 +131,7 @@ class AircraftAllocator:
 
     @staticmethod
     def preferred_aircraft_for_task(task: FlightType) -> List[Type[FlyingType]]:
-        cap_missions = (FlightType.BARCAP, FlightType.CAP, FlightType.TARCAP)
+        cap_missions = (FlightType.BARCAP, FlightType.TARCAP)
         if task in cap_missions:
             return CAP_PREFERRED
         elif task == FlightType.CAS:
@@ -147,7 +147,7 @@ class AircraftAllocator:
 
     @staticmethod
     def capable_aircraft_for_task(task: FlightType) -> List[Type[FlyingType]]:
-        cap_missions = (FlightType.BARCAP, FlightType.CAP, FlightType.TARCAP)
+        cap_missions = (FlightType.BARCAP, FlightType.TARCAP)
         if task in cap_missions:
             return CAP_CAPABLE
         elif task == FlightType.CAS:
@@ -404,7 +404,7 @@ class CoalitionMissionPlanner:
         # Find friendly CPs within 100 nmi from an enemy airfield, plan CAP.
         for cp in self.objective_finder.vulnerable_control_points():
             yield ProposedMission(cp, [
-                ProposedFlight(FlightType.CAP, 2, self.MAX_CAP_RANGE),
+                ProposedFlight(FlightType.BARCAP, 2, self.MAX_CAP_RANGE),
             ])
 
         # Find front lines, plan CAP.
@@ -493,11 +493,7 @@ class CoalitionMissionPlanner:
                 error = random.randint(-margin, margin)
                 yield max(0, time + error)
 
-        dca_types = (
-            FlightType.BARCAP,
-            FlightType.CAP,
-            FlightType.INTERCEPTION,
-        )
+        dca_types = (FlightType.BARCAP, FlightType.INTERCEPTION)
 
         non_dca_packages = [p for p in self.ato.packages if
                             p.primary_task not in dca_types]

gen/flights/ai_flight_planner_db.py

@@ -326,7 +326,7 @@ SEAD_CAPABLE = [
     F_4E,
     FA_18C_hornet,
     F_15E,
-    # F_16C_50, Not yet
+    F_16C_50,
     AV8BNA,
     JF_17,
 

gen/flights/flight.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Dict, Optional
+from typing import Dict, Iterable, Optional
 
 from game import db
 from dcs.unittype import UnitType
@@ -8,7 +8,7 @@ from theater.controlpoint import ControlPoint, MissionTarget
 
 
 class FlightType(Enum):
-    CAP = 0
+    CAP = 0  # Do not use. Use BARCAP or TARCAP.
     TARCAP = 1
     BARCAP = 2
     CAS = 3
@@ -152,6 +152,14 @@ class Flight:
         return self.flight_type.name + " | " + str(self.count) + "x" + db.unit_type_name(self.unit_type) \
                + " (" + str(len(self.points)) + " wpt)"
 
+    def waypoint_with_type(
+            self,
+            types: Iterable[FlightWaypointType]) -> Optional[FlightWaypoint]:
+        for waypoint in self.points:
+            if waypoint.waypoint_type in types:
+                return waypoint
+        return None
+
 
 # Test
 if __name__ == '__main__':

gen/flights/flightplan.py

@@ -69,8 +69,6 @@ class FlightPlanBuilder:
                 logging.error("BAI flight plan generation not implemented")
             elif task == FlightType.BARCAP:
                 self.generate_barcap(flight)
-            elif task == FlightType.CAP:
-                self.generate_barcap(flight)
             elif task == FlightType.CAS:
                 self.generate_cas(flight)
             elif task == FlightType.DEAD:
@@ -103,8 +101,10 @@ class FlightPlanBuilder:
                 logging.error(
                     "Troop transport flight plan generation not implemented"
                 )
-        except InvalidObjectiveLocation as ex:
-            logging.error(f"Could not create flight plan: {ex}")
+            else:
+                logging.error(f"Unsupported task type: {task.name}")
+        except InvalidObjectiveLocation:
+            logging.exception(f"Could not create flight plan")
 
     def regenerate_package_waypoints(self) -> None:
         ingress_point = self._ingress_point()
@@ -424,7 +424,6 @@ class FlightPlanBuilder:
     def _heading_to_package_airfield(self, point: Point) -> int:
         return self.package_airfield().position.heading_between_point(point)
 
-    # TODO: Set ingress/egress/join/split points in the Package.
     def package_airfield(self) -> ControlPoint:
         # We'll always have a package, but if this is being planned via the UI
         # it could be the first flight in the package.

gen/flights/traveltime.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import logging
+import math
 from dataclasses import dataclass
 from typing import Iterable, Optional
 
 from dcs.mapping import Point
+from dcs.unittype import FlyingType
 
 from game.utils import meter_to_nm
 from gen.ato import Package
@@ -17,25 +19,101 @@ from gen.flights.flight import (
 
 
 CAP_DURATION = 30  # Minutes
-CAP_TYPES = (FlightType.BARCAP, FlightType.CAP)
+
+INGRESS_TYPES = {
+    FlightWaypointType.INGRESS_CAS,
+    FlightWaypointType.INGRESS_SEAD,
+    FlightWaypointType.INGRESS_STRIKE,
+}
+
+IP_TYPES = {
+    FlightWaypointType.INGRESS_CAS,
+    FlightWaypointType.INGRESS_SEAD,
+    FlightWaypointType.INGRESS_STRIKE,
+    FlightWaypointType.PATROL_TRACK,
+}
 
 
 class GroundSpeed:
-    @classmethod
-    def for_package(cls, package: Package) -> int:
-        speeds = []
-        for flight in package.flights:
-            speeds.append(cls.for_flight(flight))
-        return min(speeds)  # knots
-
     @staticmethod
-    def for_flight(_flight: Flight) -> int:
-        # TODO: Gather data so this is useful.
+    def mission_speed(package: Package) -> int:
+        speeds = set()
+        for flight in package.flights:
+            waypoint = flight.waypoint_with_type(IP_TYPES)
+            if waypoint is None:
+                logging.error(f"Could not find ingress point for {flight}.")
+                if flight.points:
+                    logging.warning(
+                        "Using first waypoint for mission altitude.")
+                    waypoint = flight.points[0]
+                else:
+                    logging.warning(
+                        "Flight has no waypoints. Assuming mission altitude "
+                        "of 25000 feet.")
+                    waypoint = FlightWaypoint(FlightWaypointType.NAV, 0, 0,
+                                              25000)
+            speeds.add(GroundSpeed.for_flight(flight, waypoint.alt))
+        return min(speeds)
+
+    @classmethod
+    def for_flight(cls, flight: Flight, altitude: int) -> int:
+        if not issubclass(flight.unit_type, FlyingType):
+            raise TypeError("Flight has non-flying unit")
+
         # TODO: Expose both a cruise speed and target speed.
         # The cruise speed can be used for ascent, hold, join, and RTB to save
         # on fuel, but mission speed will be fast enough to keep the flight
         # safer.
-        return 400  # knots
+
+        c_sound_sea_level = 661.5
+
+        # DCS's max speed is in kph at 0 MSL. Convert to knots.
+        max_speed = flight.unit_type.max_speed * 0.539957
+        if max_speed > c_sound_sea_level:
+            # Aircraft is supersonic. Limit to mach 0.8 to conserve fuel and
+            # account for heavily loaded jets.
+            return int(cls.from_mach(0.8, altitude))
+
+        # For subsonic aircraft, assume the aircraft can reasonably perform at
+        # 80% of its maximum, and that it can maintain the same mach at altitude
+        # as it can at sea level. This probably isn't great assumption, but
+        # might. be sufficient given the wiggle room. We can come up with
+        # another heuristic if needed.
+        mach = max_speed * 0.8 / c_sound_sea_level
+        return int(cls.from_mach(mach, altitude))  # knots
+
+    @staticmethod
+    def from_mach(mach: float, altitude: int) -> float:
+        """Returns the ground speed in knots for the given mach and altitude.
+
+        Args:
+            mach: The mach number to convert to ground speed.
+            altitude: The altitude in feet.
+
+        Returns:
+            The ground speed corresponding to the given altitude and mach number
+            in knots.
+        """
+        # https://www.grc.nasa.gov/WWW/K-12/airplane/atmos.html
+        if altitude <= 36152:
+            temperature_f = 59 - 0.00356 * altitude
+        else:
+            # There's another formula for altitudes over 82k feet, but we better
+            # not be planning waypoints that high...
+            temperature_f = -70
+
+        temperature_k = (temperature_f + 459.67) * (5 / 9)
+
+        # https://www.engineeringtoolbox.com/specific-heat-ratio-d_602.html
+        # Dependent on temperature, but varies very little (+/-0.001)
+        # between -40F and 180F.
+        heat_capacity_ratio = 1.4
+
+        # https://www.grc.nasa.gov/WWW/K-12/airplane/sound.html
+        gas_constant = 286  # m^2/s^2/K
+        c_sound = math.sqrt(heat_capacity_ratio * gas_constant * temperature_k)
+        # c_sound is in m/s, convert to knots.
+        return (c_sound * 1.944) * mach
 
 
 class TravelTime:
@@ -72,7 +150,7 @@ class TotEstimator:
             # Takeoff immediately.
             return 0
 
-        if self.package.primary_task in CAP_TYPES:
+        if self.package.primary_task == FlightType.BARCAP:
             start_time = self.timing.race_track_start
         else:
             start_time = self.timing.join
@@ -97,13 +175,7 @@ class TotEstimator:
             The earliest possible TOT for the given flight in seconds. Returns 0
             if an ingress point cannot be found.
         """
-        stop_types = {
-            FlightWaypointType.PATROL_TRACK,
-            FlightWaypointType.INGRESS_CAS,
-            FlightWaypointType.INGRESS_SEAD,
-            FlightWaypointType.INGRESS_STRIKE,
-        }
-        time_to_ingress = self.estimate_waypoints_to_target(flight, stop_types)
+        time_to_ingress = self.estimate_waypoints_to_target(flight, IP_TYPES)
         if time_to_ingress is None:
             logging.warning(
                 f"Found no ingress types. Cannot estimate TOT for {flight}")
@@ -111,7 +183,7 @@ class TotEstimator:
             # the package.
             return 0
 
-        if self.package.primary_task in CAP_TYPES:
+        if self.package.primary_task == FlightType.BARCAP:
             # The racetrack start *is* the target. The package target is the
             # protected objective.
             time_to_target = 0
@@ -119,7 +191,7 @@ class TotEstimator:
             assert self.package.waypoints is not None
             time_to_target = TravelTime.between_points(
                 self.package.waypoints.ingress, self.package.target.position,
-                GroundSpeed.for_package(self.package))
+                GroundSpeed.mission_speed(self.package))
         return sum([
             self.estimate_startup(flight),
             self.estimate_ground_ops(flight),
@@ -146,30 +218,38 @@ class TotEstimator:
             self, flight: Flight,
             stop_types: Iterable[FlightWaypointType]) -> Optional[int]:
         total = 0
+        # TODO: This is AGL. We want MSL.
+        previous_altitude = 0
         previous_position = flight.from_cp.position
         for waypoint in flight.points:
             position = Point(waypoint.x, waypoint.y)
             total += TravelTime.between_points(
                 previous_position, position,
-                self.speed_to_waypoint(flight, waypoint)
+                self.speed_to_waypoint(flight, waypoint, previous_altitude)
             )
             previous_position = position
+            previous_altitude = waypoint.alt
             if waypoint.waypoint_type in stop_types:
                 return total
 
         return None
 
-    def speed_to_waypoint(self, flight: Flight,
-                          waypoint: FlightWaypoint) -> int:
+    def speed_to_waypoint(self, flight: Flight, waypoint: FlightWaypoint,
+                          from_altitude: int) -> int:
+        # TODO: Adjust if AGL.
+        # We don't have an exact heightmap, but we should probably be performing
+        # *some* adjustment for NTTR since the minimum altitude of the map is
+        # near 2000 ft MSL.
+        alt_for_speed = min(from_altitude, waypoint.alt)
         pre_join = (FlightWaypointType.LOITER, FlightWaypointType.JOIN)
         if waypoint.waypoint_type == FlightWaypointType.ASCEND_POINT:
             # Flights that start airborne already have some altitude and a good
             # amount of speed.
             factor = 1.0 if flight.start_type == "In Flight" else 0.5
-            return int(GroundSpeed.for_flight(flight) * factor)
+            return int(GroundSpeed.for_flight(flight, alt_for_speed) * factor)
         elif waypoint.waypoint_type in pre_join:
-            return GroundSpeed.for_flight(flight)
-        return GroundSpeed.for_package(self.package)
+            return GroundSpeed.for_flight(flight, alt_for_speed)
+        return GroundSpeed.mission_speed(self.package)
 
 
 @dataclass(frozen=True)
@@ -197,24 +277,24 @@ class PackageWaypointTiming:
 
     @property
     def race_track_start(self) -> int:
-        if self.package.primary_task in CAP_TYPES:
+        if self.package.primary_task == FlightType.BARCAP:
             return self.package.time_over_target
         else:
             return self.ingress
 
     @property
     def race_track_end(self) -> int:
-        if self.package.primary_task in CAP_TYPES:
+        if self.package.primary_task == FlightType.BARCAP:
             return self.target + CAP_DURATION * 60
         else:
             return self.egress
 
-    def push_time(self, flight: Flight, hold_point: Point) -> int:
+    def push_time(self, flight: Flight, hold_point: FlightWaypoint) -> int:
         assert self.package.waypoints is not None
         return self.join - TravelTime.between_points(
-            hold_point,
+            Point(hold_point.x, hold_point.y),
             self.package.waypoints.join,
-            GroundSpeed.for_flight(flight)
+            GroundSpeed.for_flight(flight, hold_point.alt)
         )
 
     def tot_for_waypoint(self, waypoint: FlightWaypoint) -> Optional[int]:
@@ -224,15 +304,9 @@ class PackageWaypointTiming:
             FlightWaypointType.TARGET_SHIP,
         )
 
-        ingress_types = (
-            FlightWaypointType.INGRESS_CAS,
-            FlightWaypointType.INGRESS_SEAD,
-            FlightWaypointType.INGRESS_STRIKE,
-        )
-
         if waypoint.waypoint_type == FlightWaypointType.JOIN:
             return self.join
-        elif waypoint.waypoint_type in ingress_types:
+        elif waypoint.waypoint_type in INGRESS_TYPES:
             return self.ingress
         elif waypoint.waypoint_type in target_types:
             return self.target
@@ -247,7 +321,7 @@ class PackageWaypointTiming:
     def depart_time_for_waypoint(self, waypoint: FlightWaypoint,
                                  flight: Flight) -> Optional[int]:
         if waypoint.waypoint_type == FlightWaypointType.LOITER:
-            return self.push_time(flight, Point(waypoint.x, waypoint.y))
+            return self.push_time(flight, waypoint)
         elif waypoint.waypoint_type == FlightWaypointType.PATROL:
             return self.race_track_end
         return None
@@ -256,7 +330,17 @@ class PackageWaypointTiming:
     def for_package(cls, package: Package) -> PackageWaypointTiming:
         assert package.waypoints is not None
 
-        group_ground_speed = GroundSpeed.for_package(package)
+        # TODO: Plan similar altitudes for the in-country leg of the mission.
+        # Waypoint altitudes for a given flight *shouldn't* differ too much
+        # between the join and split points, so we don't need speeds for each
+        # leg individually since they should all be fairly similar. This doesn't
+        # hold too well right now since nothing is stopping each waypoint from
+        # jumping 20k feet each time, but that's a huge waste of energy we
+        # should be avoiding anyway.
+        if not package.flights:
+            raise ValueError("Cannot plan TOT for package with no flights")
+
+        group_ground_speed = GroundSpeed.mission_speed(package)
 
         ingress = package.time_over_target - TravelTime.between_points(
             package.waypoints.ingress,

gen/flights/waypointbuilder.py

@@ -267,12 +267,6 @@ class WaypointBuilder:
         waypoint.pretty_name = "Race-track start"
         self.waypoints.append(waypoint)
 
-        # TODO: Does this actually do anything?
-        # orbit0.targets.append(location)
-        # Note: Targets of PATROL TRACK waypoints are the points to be defended.
-        # orbit0.targets.append(flight.from_cp)
-        # orbit0.targets.append(center)
-
     def race_track_end(self, position: Point, altitude: int) -> None:
         """Creates a racetrack end waypoint.