PR312 - Plane Movement Enhancements

.gitignore

@@ -23,3 +23,10 @@ xcuserdata/
 
 # MS Office Temporary Files
 ~$*
+
+# Local assistant artifacts — never commit
+CLAUDE.md
+.claude/
+*claude*
+*Claude*
+.aider*

CMakeLists.txt

@@ -23,7 +23,7 @@ endif()
 set(CACHE{CMAKE_BUILD_TYPE} TYPE STRING VALUE "RelWithDebInfo")
 
 project(LiveTraffic
-        VERSION 4.4.1
+        VERSION 4.5.0
         DESCRIPTION "LiveTraffic X-Plane plugin")
 set(VERSION_BETA 0)
 
@@ -57,25 +57,38 @@ endif()
 # For local builds, set environment variables before running cmake
 
 # Production environment
-if(DEFINED ENV{FSC_PROD_CLIENT_ID})
+#
+# The checks below reject an env var that is DEFINED but EMPTY (in
+# addition to the obvious not-defined case). GitHub Actions exposes
+# repository secrets as env-var assignments unconditionally — when a
+# fork PR doesn't have the secret configured, GA passes the env var
+# as the empty string, NOT as undefined. Without the `STREQUAL ""`
+# guard, the cmake fall-through to the default `"3"` / `"INOP"` stub
+# values never fires, the cmake substitution at line ~320 then emits
+# bare `-DFSC_PROD_CLIENT_ID=` (no value), the preprocessor expands
+# `FSC_PROD_CLIENT_ID` to nothing in `Src/LTFSCharter.cpp`, and the
+# Linux CI build fails with "expected primary-expression before ','".
+# This affects every fork PR; the empty-string guard makes the
+# default-fallback path correct in both unset and empty-string cases.
+if(DEFINED ENV{FSC_PROD_CLIENT_ID} AND NOT "$ENV{FSC_PROD_CLIENT_ID}" STREQUAL "")
     set(FSC_PROD_CLIENT_ID "$ENV{FSC_PROD_CLIENT_ID}" CACHE STRING "FSCharter production client ID")
 else()
     set(FSC_PROD_CLIENT_ID "3" CACHE STRING "FSCharter production client ID")
 endif()
-if(DEFINED ENV{FSC_PROD_CLIENT_SECRET})
+if(DEFINED ENV{FSC_PROD_CLIENT_SECRET} AND NOT "$ENV{FSC_PROD_CLIENT_SECRET}" STREQUAL "")
     set(FSC_PROD_CLIENT_SECRET "$ENV{FSC_PROD_CLIENT_SECRET}" CACHE STRING "FSCharter production client secret (base64)")
 else()
     # Default fallback value, is handled specifically by LiveTraffic code
     set(FSC_PROD_CLIENT_SECRET "INOP" CACHE STRING "FSCharter production client secret (base64)")
 endif()
 
-# Staging environment
-if(DEFINED ENV{FSC_STAGING_CLIENT_ID})
+# Staging environment — same empty-string-guard rationale as above.
+if(DEFINED ENV{FSC_STAGING_CLIENT_ID} AND NOT "$ENV{FSC_STAGING_CLIENT_ID}" STREQUAL "")
     set(FSC_STAGING_CLIENT_ID "$ENV{FSC_STAGING_CLIENT_ID}" CACHE STRING "FSCharter staging client ID")
 else()
     set(FSC_STAGING_CLIENT_ID "3" CACHE STRING "FSCharter staging client ID")
 endif()
-if(DEFINED ENV{FSC_STAGING_CLIENT_SECRET})
+if(DEFINED ENV{FSC_STAGING_CLIENT_SECRET} AND NOT "$ENV{FSC_STAGING_CLIENT_SECRET}" STREQUAL "")
     set(FSC_STAGING_CLIENT_SECRET "$ENV{FSC_STAGING_CLIENT_SECRET}" CACHE STRING "FSCharter staging client secret (base64)")
 else()
     # Default fallback value, is handled specifically by LiveTraffic code

Include/CoordCalc.h

@@ -24,6 +24,7 @@
 #define CoordCalc_h
 
 #include "XPLMScenery.h"
+#include <array>
 #include <deque>
 
 // positions and angles are in degrees
@@ -107,6 +108,124 @@ positionTy CoordPlusVector (const positionTy& pos, const vectorTy& vec);
 // returns NaN in case of failure
 double YProbe_at_m (const positionTy& posAt, XPLMProbeRef& probeRef);
 
+/// @brief Result of evaluating a Catmull-Rom spline at one parameter
+/// @details All values are expressed in the local meters frame centred at
+///          the spline's `P1` control point (see `CatmullRomEvalCentripetal`):
+///          `x` increases eastward, `y` increases northward. `headingDeg` is
+///          the curve's tangent direction at this parameter, converted to
+///          the same compass convention LiveTraffic uses elsewhere
+///          (0° = north, 90° = east, range [0, 360)).
+struct CatmullRomResult {
+    double xMtr;            ///< east offset from P1 in metres
+    double yMtr;            ///< north offset from P1 in metres
+    double headingDeg;      ///< curve tangent direction [0, 360)
+};
+
+/// @brief Evaluate a centripetal Catmull-Rom spline through four ground
+///        positions at one parameter, returning both the curve point and
+///        the tangent direction at that point.
+///
+/// @details The spline interpolates **exactly through** `P1` and `P2` and
+///          uses `P0` and `P3` as context to determine the tangent at the
+///          endpoints. The centripetal parameterisation (α = 0.5 in
+///          Lee 2009) makes the curve well-behaved at sharp corners — it
+///          never produces the cusps or self-intersecting loops that
+///          uniform Catmull-Rom can generate at a 90° taxi turn.
+///
+///          The curve is fit in a local meters frame centred at `P1`,
+///          using `Lat2Dist` / `Lon2Dist` for the conversion. This keeps
+///          the math Euclidean (avoids cos(lat) accumulating across
+///          control points) and the result is returned in the same local
+///          frame; callers convert back to lat/lon via `Dist2Lat` /
+///          `Dist2Lon` if a geographic position is needed.
+///
+///          The heading is derived from the curve's tangent
+///          (`atan2(dx, dy)`) so the returned heading is by construction
+///          aligned with the rendered direction of motion at this point —
+///          this is the property that eliminates the "sideways during
+///          turn" symptom that linear-chord interpolation produces.
+///
+/// @param P0 Control point before `P1`. May be a degenerate copy of `P1`
+///           (same lat/lon) when no real predecessor is available — the
+///           curve degenerates to a quadratic segment with zero tangent
+///           at `P1`. Caller is responsible for choosing whether to do
+///           this duplication; the function does NOT check for NaN.
+/// @param P1 First interpolated control point — the curve passes through
+///           this exactly at `u = 0`. Origin of the returned local frame.
+/// @param P2 Second interpolated control point — the curve passes through
+///           this exactly at `u = 1`.
+/// @param P3 Control point after `P2`. May be a degenerate copy of `P2`.
+/// @param u  Curve parameter in `[0, 1]`; `u=0` returns `P1` (with the
+///           local frame's origin), `u=1` returns `P2`.
+/// @return   Curve point in local meters frame relative to `P1`, and
+///           tangent-derived heading at that point in degrees.
+///
+/// @note Only the lat/lon of the control points are used. Altitude,
+///       heading, and timestamps are ignored — the spline is purely a
+///       horizontal-plane construction.
+CatmullRomResult CatmullRomEvalCentripetal(const positionTy& P0,
+                                           const positionTy& P1,
+                                           const positionTy& P2,
+                                           const positionTy& P3,
+                                           double u);
+
+/// @brief Cached arc-length lookup table for a Catmull-Rom spline segment,
+///        used to make the rendered animation advance at constant arc-length
+///        speed (rather than constant knot-parameter speed).
+///
+/// @details The native parameter `u ∈ [0, 1]` of `CatmullRomEvalCentripetal`
+///          is NOT proportional to arc length on the curve — the spline's
+///          arc length per unit `u` varies with local curvature. If the
+///          caller advances `u` linearly with time, the rendered position
+///          accelerates and decelerates within the segment (visible as a
+///          "speed up / slow down" pulsation), and the velocity at the start
+///          of leg N+1 does not match the velocity at the end of leg N
+///          (visible as a small velocity pop at every segment boundary).
+///
+///          This LUT subdivides the segment at `N` uniformly-spaced values
+///          of `u`, evaluates the curve at each, and accumulates chord-based
+///          arc length. The mapping s→u is then queried per frame to turn
+///          a time-linear progression (0..1 across the leg duration) into a
+///          curve parameter that advances at constant arc-length-per-time.
+///          Visually the rendered aircraft now moves at the segment's mean
+///          speed (`total_arc / duration`) throughout the segment.
+///
+///          `N = 16` is a deliberate trade-off: the chord error against the
+///          true integral is below 0.1 % on the curvatures we see at airport
+///          ground speeds, the build cost is 16 spline evaluations per
+///          segment switch (~once per 1-5 s of feed), and the per-frame
+///          lookup is a 4-step binary search plus one lerp.
+struct CatmullRomArcLut {
+    static constexpr int N = 16;            ///< number of sample sub-intervals; N+1 entries
+
+    /// Cumulative arc length at each sample. `sAtU[i]` is the arc length
+    /// from `u=0` to `u = i / N`. Always `sAtU[0] == 0`.
+    std::array<double, N + 1> sAtU{};
+    /// Total arc length of the segment (i.e., `sAtU[N]`). Cached for
+    /// quick access in the per-frame lookup.
+    double totalArc = 0.0;
+    /// True once `Build()` has populated the table for the current segment.
+    /// Reset to false when the parent segment switches so the next render
+    /// frame rebuilds with the new control points.
+    bool   valid    = false;
+
+    /// Sample the spline at `N+1` uniformly-spaced `u` values, accumulate
+    /// chord lengths between successive samples, and store the running
+    /// totals in `sAtU`. Must be called whenever the control-point set
+    /// changes (i.e., at every segment switch in `LTAircraft::CalcPPos`).
+    void Build(const positionTy& P0, const positionTy& P1,
+               const positionTy& P2, const positionTy& P3);
+
+    /// Given a time-linear progression `f ∈ [0, 1]` across the segment,
+    /// return the curve parameter `u ∈ [0, 1]` at which the spline has
+    /// covered `f * totalArc` of arc length. The mapping is inverted by
+    /// a short binary search across the LUT plus one linear interpolation.
+    /// If the LUT has zero total arc (e.g., all control points coincided)
+    /// the function returns `f` unchanged — the spline will collapse to
+    /// a point anyway, so the choice of parameter is irrelevant.
+    double UFromArcFraction(double f) const;
+};
+
 //
 // MARK: Estimated Functions on coordinates
 //

Include/DataRefs.h

@@ -415,6 +415,7 @@ enum dataRefsLT {
     // debug options
     DR_DBG_AC_FILTER,
     DR_DBG_AC_POS,
+    DR_DBG_DIAGNOSTIC,                      ///< Detailed diagnostic log output
     DR_DBG_LOG_RAW_FD,
     DR_DBG_LOG_WEATHER,
     DR_DBG_MODEL_MATCHING,
@@ -688,6 +689,7 @@ class DataRefs
     int bShowingAircraft        = false;
     unsigned uDebugAcFilter     = 0;    // icao24 for a/c filter
     int bDebugAcPos             = false;// output debug info on position calc into log file?
+    int bDebugDiagnostic        = false;///< output detailed diagnostic debug messages that really fill up your Log very fast
     int bDebugLogRawFd          = false;// log raw flight data to LTRawFD.log
     int bDebugWeather           = false;///< log weather data for debugging
     exportFDFormat eDebugExportFdFormat = EXP_FD_AITFC; ///< Which format to use when exporting flight data?
@@ -1087,6 +1089,7 @@ class DataRefs
     // livetraffic/dbg/ac_pos: Debug Positions for given a/c?
     inline bool GetDebugAcPos(const std::string& key) const
         { return bDebugAcPos && key == GetSelectedAcKey(); }
+    bool ShallLogDiagnostics() const { return bDebugDiagnostic; }
 
     inline bool GetDebugLogRawFD() const        { return bDebugLogRawFd; }
     void SetDebugLogRawFD (bool bLog)           { bDebugLogRawFd = bLog; }