Further improve split/join positioning.

gen/flights/flightplan.py

@@ -655,8 +655,8 @@ class FlightPlanBuilder:
     def regenerate_package_waypoints(self) -> None:
         ingress_point = self._ingress_point()
         egress_point = self._egress_point()
-        join_point = self._join_point(ingress_point)
+        join_point = self._rendezvous_point(ingress_point)
-        split_point = self._split_point(egress_point)
+        split_point = self._rendezvous_point(egress_point)
 
         from gen.ato import PackageWaypoints
         self.package.waypoints = PackageWaypoints(
@@ -1106,31 +1106,41 @@ class FlightPlanBuilder:
             land=land
         )
 
-    def _join_point(self, ingress_point: Point) -> Point:
+    def _retreating_rendezvous_point(self, attack_transition: Point) -> Point:
-        ingress_distance = self._distance_to_package_airfield(ingress_point)
+        """Creates a rendezvous point that retreats from the origin airfield."""
-        if ingress_distance < self.doctrine.join_distance:
+        return attack_transition.point_from_heading(
-            # If the ingress point is close to the origin, plan the join point
+            self.package.target.position.heading_between_point(
-            # farther back.
+                self.package_airfield().position),
-            return ingress_point.point_from_heading(
+            self.doctrine.join_distance)
-                self.package.target.position.heading_between_point(
-                    self.package_airfield().position),
-                self.doctrine.join_distance)
-        heading = self._heading_to_package_airfield(ingress_point)
-        return ingress_point.point_from_heading(heading,
-                                                -self.doctrine.join_distance)
 
-    def _split_point(self, egress_point: Point) -> Point:
+    def _advancing_rendezvous_point(self, attack_transition: Point) -> Point:
-        egress_distance = self._distance_to_package_airfield(egress_point)
+        """Creates a rendezvous point that advances toward the target."""
-        if egress_distance < self.doctrine.split_distance:
+        heading = self._heading_to_package_airfield(attack_transition)
-            # If the ingress point is close to the origin, plan the split point
+        return attack_transition.point_from_heading(heading,
-            # farther back.
+                                                    -self.doctrine.join_distance)
-            return egress_point.point_from_heading(
+
-                self.package.target.position.heading_between_point(
+    def _rendezvous_should_retreat(self, attack_transition: Point) -> bool:
-                    self.package_airfield().position),
+        transition_target_distance = attack_transition.distance_to_point(
-                self.doctrine.split_distance)
+            self.package.target.position
-        heading = self._heading_to_package_airfield(egress_point)
+        )
-        return egress_point.point_from_heading(heading,
+        origin_target_distance = self._distance_to_package_airfield(
-                                               -self.doctrine.split_distance)
+            self.package.target.position
+        )
+
+        # If the origin point is closer to the target than the ingress point,
+        # the rendezvous point should be positioned in a position that retreats
+        # from the origin airfield.
+        return origin_target_distance < transition_target_distance
+
+    def _rendezvous_point(self, attack_transition: Point) -> Point:
+        """Returns the position of the rendezvous point.
+
+        Args:
+            attack_transition: The ingress or egress point for this rendezvous.
+        """
+        if self._rendezvous_should_retreat(attack_transition):
+            return self._retreating_rendezvous_point(attack_transition)
+        return self._advancing_rendezvous_point(attack_transition)
 
     def _ingress_point(self) -> Point:
         heading = self._target_heading_to_package_airfield()