Black box: the queries of the user's train worked out once a read, lights as the driver checks them

- The stations, the signals passed, the horn points, the couplings, the
  consists and the timetable progress of the user's train are kept until
  a read adds something; the views asked for them every frame, which on
  a long session with many trains took the window down. A read that adds
  nothing no longer counts as a change.
- The lights are checked against the lamps the vehicles at the ends have
  (written by the simulator from now on), as its driver checks them: Pc 1
  without the upper headlight, with the auxiliary lamps, Pc 5 with the
  rear-end signals. Only while the user drives: the autopilot's lights
  are its own.
- A train off the platform counts at both ends: its head past the stop
  point as well as its tail before the platform's end.
- A recording without the couplings keeps the timetable for any vehicle
  of the user.
- A signal passed at danger is ringed on the map only once it was.
- In the tapes window a black box opens on a click or Enter, not when
  the arrow keys go over it.
- The viewer's screenshot of a window not laid out saves nothing and
  still closes.

Eu07.BlackBox/HeadCodes.cs

@@ -70,12 +70,81 @@ public static class HeadCodes
         _ => null
     };
 
-    /// <summary>Whether both ends showed what they were to while the train moved; null when nothing tells it.</summary>
-    public static bool? Right(CabSample sample)
+    /// <summary>Whether the head of the train showed what it was to; null when nothing tells it.</summary>
+    public static bool? HeadRight(CabSample sample) => sample.Movement switch
     {
-        if (RequiredHead(sample) is not { } head || RequiredTail(sample) is not { } tail)
-            return null;
-        return Of(sample.LightsHead) == head && Of(sample.LightsTail) == tail;
+        Movement.Train => Meets(sample.LightsHead, sample.EquippedHead, sample.LightHintHead, HeadCode.Pc1),
+        Movement.Shunting => Shows(HeadCode.Tb1, sample.LightsHead, sample.EquippedHead),
+        _ => null
+    };
+
+    /// <summary>Whether the tail of the train showed what it was to; null when nothing tells it.</summary>
+    public static bool? TailRight(CabSample sample) => sample.Movement switch
+    {
+        Movement.Train => Meets(sample.LightsTail, sample.EquippedTail, sample.LightHintTail, HeadCode.Pc5),
+        Movement.Shunting => Shows(HeadCode.Tb1, sample.LightsTail, sample.EquippedTail),
+        _ => null
+    };
+
+    /// <summary>Whether both ends showed what they were to; null when nothing tells it.</summary>
+    public static bool? Right(CabSample sample) =>
+        HeadRight(sample) is { } head && TailRight(sample) is { } tail ? head && tail : null;
+
+    private const Lights HighBeams = Lights.HighBeamLeft | Lights.HighBeamRight;
+    private const Lights Auxiliary = Lights.AuxiliaryLeft | Lights.AuxiliaryRight;
+
+    // the pattern asked for at an end, the usual one when none is: the driver sets one asked for as it is
+    private static bool Meets(Lights lit, Lights? equipped, short hint, HeadCode usual)
+    {
+        if (hint < 0)
+            return Shows(usual, lit, equipped);
+        var pattern = (Lights)hint;
+        if (usual == HeadCode.Pc1 && pattern == (Lights.RedMarkerLeft | Lights.HeadlightRight | Lights.HeadlightUpper))
+            return Shows(HeadCode.Pc2, lit, equipped);
+        return (lit & ~HighBeams) == (equipped is { } lamps ? pattern & lamps : pattern);
+    }
+
+    /// <summary>
+    /// Whether the lamps lit at an end show the signal, as the simulator's driver checks it against the lamps
+    /// the vehicle has there: a vehicle without the upper headlight shows Pc 1 with the two others, one with
+    /// auxiliary lamps may show them instead, and one with no lamps for it the rear-end signals. A recording
+    /// made before the lamps were written has the pattern alone. The high beams tell nothing.
+    /// </summary>
+    public static bool Shows(HeadCode code, Lights lit, Lights? equipped)
+    {
+        if (equipped is not { } lamps)
+            return Of(lit) == code;
+        lit &= ~HighBeams;
+        bool auxiliary = (lamps & Auxiliary) != 0;
+        switch (code)
+        {
+            case HeadCode.Pc1:
+            {
+                var pattern = lamps & (Lights.HeadlightLeft | Lights.HeadlightRight | Lights.HeadlightUpper);
+                var fallback = lamps & (Auxiliary | Lights.HeadlightUpper);
+                return (pattern != 0 && lit == pattern) || (auxiliary && lit == fallback) ||
+                       (pattern == 0 && fallback == 0 && lit == Lights.RearEndSignals);
+            }
+            case HeadCode.Pc2:
+            {
+                var pattern = lamps & (Lights.RedMarkerLeft | Lights.HeadlightRight | Lights.HeadlightUpper);
+                var fallback = lamps & (Lights.RedMarkerLeft | Lights.AuxiliaryRight | Lights.HeadlightUpper);
+                return lit == pattern || (auxiliary && lit == fallback);
+            }
+            case HeadCode.Pc5:
+            {
+                var pattern = lamps & (Lights.RedMarkerLeft | Lights.RedMarkerRight);
+                var fallback = lamps & Lights.RearEndSignals;
+                return (pattern != 0 && lit == pattern) || (fallback != 0 && lit == fallback);
+            }
+            case HeadCode.Tb1:
+                // one headlight, of those there are
+                return lit == (lamps & Lights.HeadlightLeft) || lit == (lamps & Lights.HeadlightRight);
+            case HeadCode.Off:
+                return lit == Lights.None;
+            default:
+                return false;
+        }
     }
 
     /// <summary>The name of a signal as the rules give it.</summary>