The outer seat feels the roll, and the envelope reaches the panel

OffsetProfile (GEnvelope.h) turns a heartline profile into the one a seat a
lateral distance y off it would have recorded: alpha * y of vertical snap
from the roll's angular acceleration, and -omega^2 * y of lateral pull back
toward the heartline. Both from RollRateDegPerSec, which every sample already
carried. At 1.2 m through a 180 deg/s roll that is +0.38 g of snap and 1.21 g
lateral that the centre seat reports as zero -- the wing-coaster difference
COASTER_TYPES.md describes, and the same term at a smaller y for the outer
seat of any wide train. Asserted: centre unchanged to the bit, left and right
mirror, magnitudes real.

JudgeRideProfile had only ever been called from its own suite. BuildDiagnostics
now runs it on a completed ride for the centre seat and the outer seat
(BodyWidth/4, the seat the camera already uses) and every finding is an
Envelope row with a metre to go and look at. -TUSmokeTest asserts the
showcase is judged and within envelope at both seats, so a layout that snapped
an outboard rider would fail the build rather than demonstrate it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: zebadrabbit

Prototypes/TrainPhysics/GEnvelope.h

@@ -549,3 +549,51 @@ inline FGVerdict JudgeRideProfile(const FRideProfile& P,
 // dropped, because the numbers are part of the table and losing them loses the
 // intent. Add it when a layout is found that trips it; nothing measured so far
 // reverses that fast.
+
+// ===================== A SEAT OFF THE HEARTLINE =====================
+//
+// Felt G is computed at the heartline, and a rider who is not on it feels
+// something else through every roll: the seat swings about the heartline at
+// the roll rate, so it carries the heartline's acceleration PLUS the
+// acceleration of that swing. For a seat a lateral distance y from the
+// heartline (+y is the rider's left, the frame's own sign):
+//
+//   vertical:  alpha * y      the angular ACCELERATION lifts or drops the seat --
+//                             the "snap" an outboard seat gets that the centre
+//                             never does, and why a wing coaster feels the way it does
+//   lateral:  -omega^2 * y    the centripetal pull back toward the heartline
+//
+// COASTER_TYPES.md argues this is worth building for every wide train rather
+// than for wing coasters alone; what a four-across train's outer seat feels is
+// the same term at a smaller y. Nothing in it is new data: RollRateDegPerSec
+// is already on every sample, so this is a transform of a profile into the
+// profile that seat would have recorded. Judge it with JudgeRideProfile like
+// any other, which is the "run it once per seat" rule the facing sign follows.
+//
+// Signs follow the frame: Tangent x Lateral = Up, so a positive roll rate
+// carries +Lateral toward +Up, and a seat at +y rises -- an upward seat
+// acceleration presses the rider into it, which is +Gz. The centripetal term
+// points at the heartline: for +y that is -Lateral, which the rider feels as a
+// push toward their RIGHT (LateralG's positive sense), hence the sign below.
+// The finite difference for alpha is per-sample and noisy; the 5 Hz filter
+// the judge already applies is what makes it a measurement.
+inline FRideProfile OffsetProfile(const FRideProfile& P, double LateralM)
+{
+    FRideProfile Out = P;
+    if (Out.Samples.size() < 2 || LateralM == 0.0) { return Out; }
+    const double G = 9.80665;
+    const double ToRad = 3.14159265358979323846 / 180.0;
+    for (std::size_t i = 0; i < Out.Samples.size(); ++i)
+    {
+        const std::size_t A = (i == 0) ? 0 : i - 1;
+        const std::size_t B = (i + 1 < Out.Samples.size()) ? i + 1 : i;
+        const double Dt = P.Samples[B].Time - P.Samples[A].Time;
+        const double Omega = P.Samples[i].RollRateDegPerSec * ToRad;
+        const double Alpha = (Dt > 1e-9)
+            ? (P.Samples[B].RollRateDegPerSec - P.Samples[A].RollRateDegPerSec) * ToRad / Dt
+            : 0.0;
+        Out.Samples[i].VerticalG += Alpha * LateralM / G;
+        Out.Samples[i].LateralG  += Omega * Omega * LateralM / G;
+    }
+    return Out;
+}

Prototypes/TrainPhysics/test_genvelope.cpp

@@ -580,6 +580,52 @@ void TestTheSAMEEventIsJudgedDifferentlyByFacing()
     // Recorded here so a verified table has something to answer.
 }
 
+// ===================== THE OUTER SEAT =====================
+void TestAnOffsetSeatFeelsTheRollAndTheCentreDoesNot()
+{
+    // Level track, 1 g, with the roll rate ramping 0 -> 180 deg/s over one
+    // second then holding: alpha = pi rad/s^2 during the ramp, omega = pi after.
+    FRideProfile P = Hold(1.0, 0.0, 0.0, 4.0);
+    for (FRideSample& S : P.Samples)
+    {
+        S.RollRateDegPerSec = S.Time < 1.0 ? 180.0 * S.Time : 180.0;
+    }
+    const double G = 9.80665, Pi = 3.14159265358979323846;
+
+    // The centre seat is unchanged, to the bit.
+    const FRideProfile C = OffsetProfile(P, 0.0);
+    for (std::size_t i = 0; i < P.Samples.size(); ++i)
+    {
+        assert(C.Samples[i].VerticalG == P.Samples[i].VerticalG);
+        assert(C.Samples[i].LateralG == P.Samples[i].LateralG);
+    }
+
+    // 1.2 m out on the rider's left (a wing seat), mid-ramp at t = 0.5 s:
+    // vertical snap alpha * y / g, no steady centripetal yet to speak of.
+    const FRideProfile L = OffsetProfile(P, 1.2);
+    const std::size_t Mid = 100;   // 0.5 s at 200 Hz
+    const double ExpectSnap = Pi * 1.2 / G;
+    assert(std::fabs(L.Samples[Mid].VerticalG - (1.0 + ExpectSnap)) < 1e-3);
+    // On the plateau at t = 3 s: no snap, centripetal omega^2 y / g toward the
+    // heartline, felt as a push to the rider's right (positive LateralG).
+    const std::size_t Late = 600;
+    const double ExpectCent = Pi * Pi * 1.2 / G;
+    assert(std::fabs(L.Samples[Late].VerticalG - 1.0) < 1e-3);
+    assert(std::fabs(L.Samples[Late].LateralG - ExpectCent) < 1e-3);
+
+    // The right-hand seat mirrors BOTH: the snap drops it, and the pull is
+    // toward the heartline from the other side.
+    const FRideProfile R = OffsetProfile(P, -1.2);
+    assert(std::fabs(R.Samples[Mid].VerticalG - (1.0 - ExpectSnap)) < 1e-3);
+    assert(std::fabs(R.Samples[Late].LateralG + ExpectCent) < 1e-3);
+
+    // And the magnitudes are real: 180 deg/s at 1.2 m is about 0.38 g of snap
+    // and 1.2 g of lateral that the heartline reports as zero.
+    assert(ExpectSnap > 0.35 && ExpectCent > 1.1);
+    std::printf("  outer seat at 1.2 m through a 180 deg/s roll: +%.2f g snap, %.2f g lateral; centre 0\n",
+        ExpectSnap, ExpectCent);
+}
+
 int main()
 {
     std::printf("GEnvelope: judging a ride against acceleration envelopes\n");
@@ -602,6 +648,7 @@ int main()
     TestRealRideIsJudgedAndLocatable();
     TestABackwardFacingSeatFlipsFOREAFTAndLATERALButNotVERTICAL();
     TestTheSAMEEventIsJudgedDifferentlyByFacing();
+    TestAnOffsetSeatFeelsTheRollAndTheCentreDoesNot();
 
     std::printf("\nAll GEnvelope assertions passed.\n");
     return 0;

Source/TrackUnlimited/TUCoasterRide.cpp

@@ -5935,13 +5935,27 @@ bool ATUCoasterRide::RunDocumentSmokeTest()
 			if (S.Zone == ETUSegmentZone::Brake) { ++Trims; }
 		}
 
+		// AND IT IS WITHIN THE ENVELOPE, at the centre and at the outer seat.
+		// Judged for real (both verdicts run on a completed ride and their
+		// findings land in the panel), so a showcase that snapped an outboard
+		// rider through its helix would fail here rather than demonstrate it.
+		int32 EnvelopeRows = 0;
+		for (std::size_t i = 0; i < Diagnostics.Num(); ++i)
+		{
+			if (Diagnostics.At(i).Group == "Envelope") { ++EnvelopeRows; }
+		}
+		const FGVerdict Outer = JudgeRideProfile(OffsetProfile(Profile_,
+			TrainMeshSettings().BodyWidthM * 0.25));
+		const bool bJudged = Outer.SamplesJudged > 0;
+
 		if (!bTrackIsCircuit || !Profile_.bCompleted || Pads < 2 || Trims != 1
-			|| !bEmptied || !bReturned || !bTrainExact)
+			|| !bEmptied || !bReturned || !bTrainExact || EnvelopeRows != 0 || !bJudged)
 		{
 			UE_LOG(LogTUEvents, Error,
 				TEXT("smoke: the showcase is wrong (circuit %d, completed %d, pads %d, ")
-				TEXT("trims %d, shed to zero %d, returned %d, train exact %d)"),
-				bTrackIsCircuit, Profile_.bCompleted, Pads, Trims, bEmptied, bReturned, bTrainExact);
+				TEXT("trims %d, shed to zero %d, returned %d, train exact %d, envelope rows %d, judged %d)"),
+				bTrackIsCircuit, Profile_.bCompleted, Pads, Trims, bEmptied, bReturned, bTrainExact,
+				EnvelopeRows, bJudged);
 			Failures.Add(TEXT("showcase"));
 		}
 		else
@@ -6521,6 +6535,37 @@ void ATUCoasterRide::BuildDiagnostics()
 	Diagnostics.AddRideProfile(Profile_.bCompleted, Profile_.StalledAtS,
 		Top, PeakG, PeakAt, Lap);
 
+	// ===================== THE ENVELOPE, AT LAST IN THE PANEL =====================
+	//
+	// JudgeRideProfile had only ever been called from its own suite. It runs
+	// here on a COMPLETED ride only (the suite's own old failure: a verdict on a
+	// ride that did not happen), for the centre seat and for the outer seat --
+	// OffsetProfile adds what a rider BodyWidth/4 off the heartline feels
+	// through every roll, which the heartline reports as nothing. Two runs,
+	// one per seat, which is the rule the facing sign already follows.
+	// Limits are unverified research (the header says so); a finding is a row
+	// to go and look at, never a repair.
+	if (Profile_.bCompleted)
+	{
+		const double OuterM = TrainMeshSettings().BodyWidthM * 0.25;
+		struct { const char* Seat; double LateralM; } Seats[] = {{"centre", 0.0}, {"outer seat", OuterM}};
+		for (const auto& Seat : Seats)
+		{
+			const FGVerdict V = JudgeRideProfile(OffsetProfile(Profile_, Seat.LateralM));
+			for (const FGFinding& F : V.Findings)
+			{
+				static const char* KindName[] = {"sustained", "impact", "jerk", "combined", "reversal"};
+				FDiagTarget T;
+				T.S = F.AtS;
+				Diagnostics.Add(EDiagSeverity::Warning, "Envelope",
+					TCHAR_TO_UTF8(*FString::Printf(TEXT("%s %s %.2f g for %.2f s, limit %.2f (%s, %s)"),
+						UTF8_TO_TCHAR(F.Axis), UTF8_TO_TCHAR(KindName[static_cast<int32>(F.Kind)]),
+						F.Value, F.Duration, F.Limit, UTF8_TO_TCHAR(Seat.Seat),
+						V.Standard == EGStandard::ASTM_F2291 ? TEXT("ASTM") : TEXT("EN"))), T);
+			}
+		}
+	}
+
 	// Support placement, which refuses more than it places on a layout with a
 	// helix — and the hole its refusals leave is the number an engineer asks for.
 	if (bShowSupportFindings)

Source/TrackUnlimited/TUCoasterRide.h

@@ -14,6 +14,7 @@
 
 #include "TrainPhysics/TrainPhysics.h"
 #include "TrainPhysics/Seat.h"
+#include "TrainPhysics/GEnvelope.h"
 #include "TrainPhysics/RideProfile.h"
 #include "TrackSpline/TrackProfile.h"
 // FTrackDiagnostic is a MEMBER type below, not just something the .cpp uses.