Two vehicles with automatic couplers coupled the moment they touched, in CouplerForce(), before
CollisionDetect() ran; its derail check only covers uncoupled vehicles, so they never collided nor
derailed, at any speed. With crash damage on, the coupling now waits for a closing speed of at most
15 km/h, the limit of the derail check. A faster hit locks the automatic coupling until the vehicles
part, so the collision runs its course instead of the couplers catching once it has slowed them down.
Two collision bugs on the way:
- CollisionVelocity() took the length of the difference of the heading quaternions times the speeds;
a quaternion turns by half its angle, so for vehicles facing each other the speeds came out at right
angles: a head-on hit at 10 + 10 km/h read as 14.1 km/h, under the limit. The closing speed is now
taken from the touching ends, as CouplerForce() relates the vehicles: the sum of the speeds head-on,
the difference rear-end, negative when the ends part,
- CollisionDetect() gave ComputeCollision() the other vehicle's speed along that vehicle's own axis,
which points the other way for vehicles facing each other: a wagon hit head-on counted as running
into the hitter, and the hitter bounced back as from a wall (20 km/h into a standing wagon: it ran
off at 6 km/h instead of 17). The speed is turned into this vehicle's frame and back.
Head-on hits now count with both speeds, so with crash damage on they derail sooner than before, at
the 15 km/h the check was meant for.
Tests: test::pair runs two test vehicles on one track the way vehicle_table::update() runs a scene
(neighbours, forces, movement), with coupling, buffing, collisions and derailing coming from the
physics. tests/unit/test_couplers.cpp: catching up to 15 km/h and not above; a slow hit couples, a fast
one doesn't, nor once slowed down, the lock resets once the vehicles part; a hit a little over 15 km/h
bounces apart on the rails, harder ones derail; head-on 7 + 7 couples, 8 + 8 bounces, 15 + 15 derails;
no catching a coupler of another type, couplers of different control systems couple without the
control connection.
The dumb3d->glm / utilities-simplification refactor replaced the old custom
clamp() (which tolerated Lo>Hi, returning the upper bound) with std::clamp,
where inverted bounds are undefined behaviour. Only a few sites were patched
afterwards, by hand, with std::minmax plumbing (incl. a stray `static` inside
a per-axle loop). Others silently produced wrong results in the AI braking /
acceleration path.
Add a safe_clamp() helper (normalizes inverted bounds) and use it ONLY where
Lo<=Hi cannot be proven at compile time (config min/max pairs, sign-dependent
expressions, container underflow). Sites with constant bounds or [0, x>=0]
keep std::clamp. Remove the manual std::minmax workarounds and rewrite the
damaged-track jolt code value-first.
- The `TMoverParameters::derail()` function has been renamed to `::Derail()`, with a capital D.
- All derail events now use that function.
- Simplified and unified the logic behind different derail types.
- The `dtrack_freerail` track type is now slightly increasing the chance of derailing on a tight curve, as it was the intention.
- A new `DerailReason` enum has been created which holds all derail types.
- The `DerailReason` field in the `TMoverParameters` class has been removed.
- This was a transient field which is not necessary anymore.
- The logging functionality as such has been moved from `DynObj.cpp` to `Mover.cpp`.
