Allow targeting flags, landed vessels (#167)

andymac-2 · Andrew Pritchard · web-flow · commit dfc9858f5cc7 · 2025-10-06T07:25:20.000-04:00
Co-authored-by: Andrew Pritchard &lt;noreply@example.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,7 @@ Please always post your [KSP.log file](https://gist.github.com/JonnyOThan/04c207
 ### New Features
 
 - Add support for scrolling through orbit patches on the MFD (thanks @andymac-2)
+- Allow targeting flags and landed vessels (thanks @andymac-2)
 
 ### Bug Fixes
 
@@ -300,4 +301,4 @@ Many thanks to Manul and Zorkinian on the KSP forums for pinpointing the root ca
 
 ### Changes
 
-- Updated for KSP 1.8.X
+- Updated for KSP 1.8.X
diff --git a/RasterPropMonitor/Core/RPMCEvaluators.cs b/RasterPropMonitor/Core/RPMCEvaluators.cs
@@ -1714,21 +1714,21 @@ internal NumericVariableEvaluator GetNumericEvaluator(string input, out Variable
                 case "TIMETOANWITHTARGETSECS":
                     return (RPMVesselComputer comp) =>
                     {
-                        if (comp.target == null || comp.targetOrbit == null)
+                        if (comp.target == null)
                             return double.NaN;
-                        return vessel.GetOrbit().TimeOfAscendingNode(comp.targetOrbit, Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();
+                        return vessel.GetOrbit().TimeOfAscendingNode(comp.target.GetOrbit(), Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();
                     };
                 case "TIMETODNWITHTARGETSECS":
                     return (RPMVesselComputer comp) =>
                     {
-                        if (comp.target == null || comp.targetOrbit == null)
+                        if (comp.target == null)
                             return double.NaN;
-                        return vessel.GetOrbit().TimeOfDescendingNode(comp.targetOrbit, Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();
+                        return vessel.GetOrbit().TimeOfDescendingNode(comp.target.GetOrbit(), Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();
                     };
                 case "TARGETCLOSESTAPPROACHTIME":
                     return (RPMVesselComputer comp) =>
                     {
-                        if (comp.target == null || comp.targetOrbit == null || orbitSensibility == false)
+                        if (comp.target == null || orbitSensibility == false)
                         {
                             return double.NaN;
                         }
@@ -1742,7 +1742,7 @@ internal NumericVariableEvaluator GetNumericEvaluator(string input, out Variable
                 case "TARGETCLOSESTAPPROACHDISTANCE":
                     return (RPMVesselComputer comp) =>
                     {
-                        if (comp.target == null || comp.targetOrbit == null || orbitSensibility == false)
+                        if (comp.target == null || orbitSensibility == false)
                         {
                             return double.NaN;
                         }
diff --git a/RasterPropMonitor/Core/UtilityFunctions.cs b/RasterPropMonitor/Core/UtilityFunctions.cs
@@ -1112,41 +1112,19 @@ public static string CurrentBiome(this Vessel thatVessel)
             return "Space over " + thatVessel.mainBody.bodyName;
         }
 
-
-        // Pseudo-orbit for closest approach to a landed object
-        public static Orbit OrbitFromSurfacePos(CelestialBody body, double lat, double lon, double alt, double UT)
+        public static Vector3d ClosestApproachSrfOrbit(Orbit vesselOrbit, Vessel target, out double UT, out double distance)
         {
-            double t0 = Planetarium.GetUniversalTime();
-            double angle = body.rotates ? (UT - t0) * 360.0 / body.rotationPeriod : 0;
-
-            double LAN = (lon + body.rotationAngle + angle - 90.0) % 360.0;
-            Orbit orbit = new Orbit(lat, 0, body.Radius + alt, LAN, 90.0, 0, UT, body);
+            CelestialBody body = target.mainBody;
 
-            orbit.pos = orbit.getRelativePositionAtT(0);
-            if (body.rotates)
-                orbit.vel = Vector3d.Cross(body.zUpAngularVelocity, -orbit.pos);
-            else
-                orbit.vel = orbit.getOrbitalVelocityAtObT(Time.fixedDeltaTime);
-            orbit.h = Vector3d.Cross(orbit.pos, orbit.vel);
-
-            orbit.StartUT = t0;
-            orbit.EndUT = UT + orbit.period;
-            if (body.rotates)
-                orbit.period = body.rotationPeriod;
-            orbit.patchEndTransition = Orbit.PatchTransitionType.FINAL;
-            return orbit;
-        }
+            // longitude and latitude calculations are offset by a different amount every
+            // time we load the scene. We can use a zero latitude/longitude to find out what
+            // that offset is.
+            Vector3d zeroPos = body.GetRelSurfacePosition(0, 0, 0);
+            body.GetLatLonAltOrbital(zeroPos, out var zeroLat, out var zeroLon, out var _);
 
-        public static Orbit ClosestApproachSrfOrbit(Orbit vesselOrbit, Vessel target, out double UT, out double distance)
-        {
-            return ClosestApproachSrfOrbit(vesselOrbit, target.mainBody, target.latitude, target.longitude, target.altitude, out UT, out distance);
-        }
-
-        public static Orbit ClosestApproachSrfOrbit(Orbit vesselOrbit, CelestialBody body, double lat, double lon, double alt, out double UT, out double distance)
-        {
-            Vector3d pos = body.GetRelSurfacePosition(lat, lon, alt);
+            Vector3d pos = body.GetRelSurfacePosition(target.latitude - zeroLat, target.longitude - zeroLon, target.altitude);
             distance = GetClosestApproach(vesselOrbit, body, pos, out UT);
-            return OrbitFromSurfacePos(body, lat, lon, alt, UT);
+            return pos;
         }
 
         public static double GetClosestApproach(Orbit vesselOrbit, ITargetable target, out double timeAtClosestApproach)
@@ -1171,7 +1149,7 @@ public static double GetClosestApproach(Orbit vesselOrbit, ITargetable target, o
                 if (targetVessel.LandedOrSplashed)
                 {
                     double closestApproach;
-                    Orbit targetOrbit = JUtil.ClosestApproachSrfOrbit(vesselOrbit, targetVessel, out timeAtClosestApproach, out closestApproach);
+                    ClosestApproachSrfOrbit(vesselOrbit, targetVessel, out timeAtClosestApproach, out closestApproach);
                     return closestApproach;
                 }
                 else
diff --git a/RasterPropMonitor/Handlers/JSIOrbitDisplay.cs b/RasterPropMonitor/Handlers/JSIOrbitDisplay.cs
@@ -186,7 +186,7 @@ private static void DrawOrbitSegment(
             Vector3 midStraight = (startVertex + endVertex) * 0.5f;
             // Debug.Log($"startTA: {startTA}, endTA: {endTA}, startVertex: {startVertex}, endVertex: {endVertex}, midVertex: {midVertex}, midStraight: {midStraight}");
 
-            if (Math.Abs(startTA - endTA) <  0.01 || (midStraight - midVertex).sqrMagnitude < 9.0)
+            if (Math.Abs(startTA - endTA) <  0.01 || (midStraight - midVertex).sqrMagnitude < 16.0)
             {
                 GL.Vertex3(startVertex.x, startVertex.y, 0.0f);
                 GL.Vertex3(midVertex.x, midVertex.y, 0.0f);
@@ -569,29 +569,31 @@ public bool RenderOrbit(RenderTexture screen, float cameraAspect)
             {
                 var orbit = (targetVessel != null) ? targetVessel.GetOrbit() : targetBody.GetOrbit();
 
-                double tClosestApproach, dClosestApproach;
+                double tClosestApproach;
 
                 if (targetVessel != null && targetVessel.LandedOrSplashed)
                 {
-                    orbit = JUtil.ClosestApproachSrfOrbit(selectedPatch, targetVessel, out tClosestApproach, out dClosestApproach);
+                    Vector3d position = JUtil.ClosestApproachSrfOrbit(selectedPatch, targetVessel, out tClosestApproach, out double _);
+                    transformedPosition = screenTransform.MultiplyPoint3x4(position);
+                    DrawIcon(transformedPosition.x, transformedPosition.y, targetVessel.vesselType, iconColorTargetValue);
                 }
                 else
                 {
-                    dClosestApproach = JUtil.GetClosestApproach(selectedPatch, orbit, out tClosestApproach);
+                    JUtil.GetClosestApproach(selectedPatch, orbit, out tClosestApproach);
 
                     DrawNextPe(orbit, selectedPatch.referenceBody, now, iconColorTargetValue, screenTransform);
                     DrawNextAp(orbit, selectedPatch.referenceBody, now, iconColorTargetValue, screenTransform);
-                }
 
-                if (targetBody != null)
-                {
-                    transformedPosition = screenTransform.MultiplyPoint3x4(targetBody.getTruePositionAtUT(now) - selectedPatch.referenceBody.getTruePositionAtUT(now));
-                    DrawIcon(transformedPosition.x, transformedPosition.y, VesselType.Unknown, iconColorTargetValue, MapIcons.OtherIcon.PLANET);
-                }
-                else
-                {
-                    transformedPosition = screenTransform.MultiplyPoint3x4(orbit.SwappedRelativePositionAtUT(now));
-                    DrawIcon(transformedPosition.x, transformedPosition.y, targetVessel.vesselType, iconColorTargetValue);
+                    if (targetBody != null)
+                    {
+                        transformedPosition = screenTransform.MultiplyPoint3x4(targetBody.getTruePositionAtUT(now) - selectedPatch.referenceBody.getTruePositionAtUT(now));
+                        DrawIcon(transformedPosition.x, transformedPosition.y, VesselType.Unknown, iconColorTargetValue, MapIcons.OtherIcon.PLANET);
+                    }
+                    else
+                    {
+                        transformedPosition = screenTransform.MultiplyPoint3x4(orbit.SwappedRelativePositionAtUT(now));
+                        DrawIcon(transformedPosition.x, transformedPosition.y, targetVessel.vesselType, iconColorTargetValue);
+                    }
                 }
 
                 if (selectedPatch.AscendingNodeExists(orbit))
@@ -621,10 +623,13 @@ public bool RenderOrbit(RenderTexture screen, float cameraAspect)
                     DrawIcon(transformedPosition.x, transformedPosition.y, VesselType.Unknown, iconColorClosestApproachValue, MapIcons.OtherIcon.SHIPATINTERCEPT);
                 }
 
-                // Unconditionally try to draw the closest approach point on
-                // the target orbit.
-                transformedPosition = screenTransform.MultiplyPoint3x4(orbit.SwappedRelativePositionAtUT(tClosestApproach));
-                DrawIcon(transformedPosition.x, transformedPosition.y, VesselType.Unknown, iconColorClosestApproachValue, MapIcons.OtherIcon.TGTATINTERCEPT);
+                if (!targetVessel.LandedOrSplashed)
+                {
+                    // Unconditionally try to draw the closest approach point on
+                    // the target orbit.
+                    transformedPosition = screenTransform.MultiplyPoint3x4(orbit.SwappedRelativePositionAtUT(tClosestApproach));
+                    DrawIcon(transformedPosition.x, transformedPosition.y, VesselType.Unknown, iconColorClosestApproachValue, MapIcons.OtherIcon.TGTATINTERCEPT);
+                }
             }
             else
             {

Original file line number	Diff line number	Diff line change
`@@ -1714,21 +1714,21 @@ internal NumericVariableEvaluator GetNumericEvaluator(string input, out Variable`
`1714`	`1714`	`case "TIMETOANWITHTARGETSECS":`
`1715`	`1715`	`return (RPMVesselComputer comp) =>`
`1716`	`1716`	`{`
`1717`		`- if (comp.target == null \|\| comp.targetOrbit == null)`
	`1717`	`+ if (comp.target == null)`
`1718`	`1718`	`return double.NaN;`
`1719`		`- return vessel.GetOrbit().TimeOfAscendingNode(comp.targetOrbit, Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();`
	`1719`	`+ return vessel.GetOrbit().TimeOfAscendingNode(comp.target.GetOrbit(), Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();`
`1720`	`1720`	`};`
`1721`	`1721`	`case "TIMETODNWITHTARGETSECS":`
`1722`	`1722`	`return (RPMVesselComputer comp) =>`
`1723`	`1723`	`{`
`1724`		`- if (comp.target == null \|\| comp.targetOrbit == null)`
	`1724`	`+ if (comp.target == null)`
`1725`	`1725`	`return double.NaN;`
`1726`		`- return vessel.GetOrbit().TimeOfDescendingNode(comp.targetOrbit, Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();`
	`1726`	`+ return vessel.GetOrbit().TimeOfDescendingNode(comp.target.GetOrbit(), Planetarium.GetUniversalTime()) - Planetarium.GetUniversalTime();`
`1727`	`1727`	`};`
`1728`	`1728`	`case "TARGETCLOSESTAPPROACHTIME":`
`1729`	`1729`	`return (RPMVesselComputer comp) =>`
`1730`	`1730`	`{`
`1731`		`- if (comp.target == null \|\| comp.targetOrbit == null \|\| orbitSensibility == false)`
	`1731`	`+ if (comp.target == null \|\| orbitSensibility == false)`
`1732`	`1732`	`{`
`1733`	`1733`	`return double.NaN;`
`1734`	`1734`	`}`
`@@ -1742,7 +1742,7 @@ internal NumericVariableEvaluator GetNumericEvaluator(string input, out Variable`
`1742`	`1742`	`case "TARGETCLOSESTAPPROACHDISTANCE":`
`1743`	`1743`	`return (RPMVesselComputer comp) =>`
`1744`	`1744`	`{`
`1745`		`- if (comp.target == null \|\| comp.targetOrbit == null \|\| orbitSensibility == false)`
	`1745`	`+ if (comp.target == null \|\| orbitSensibility == false)`
`1746`	`1746`	`{`
`1747`	`1747`	`return double.NaN;`
`1748`	`1748`	`}`