From 45105e7b9c0d26e0d457b47966cbd548afd1e1b9 Mon Sep 17 00:00:00 2001 From: maj00r Date: Sat, 14 Nov 2026 00:50:02 +0100 Subject: [PATCH] fix(tapes): a command is not taken for the header, and a gap in a tape is neither driving nor distance - The header is the line that doesn't start with a figure. A line whose command, which is free text, says "Security" was taken for it, moving the alerter's column and dropping the line. - A tape the black box writes goes on after a gap when the player comes back to its vehicle. A step of more than twenty usual steps between two lines (a second at least) is time not recorded: no distance over it, and neither running nor standing time; the average with the stops leaves it out too. --- StarterNG.Tests/HaslerTapeTests.cs | 25 +++++++++ StarterNG/Domain/Tapes/HaslerTape.cs | 79 +++++++++++++++++++--------- 2 files changed, 80 insertions(+), 24 deletions(-) diff --git a/StarterNG.Tests/HaslerTapeTests.cs b/StarterNG.Tests/HaslerTapeTests.cs index 582fbaa..8858f7c 100644 --- a/StarterNG.Tests/HaslerTapeTests.cs +++ b/StarterNG.Tests/HaslerTapeTests.cs @@ -86,6 +86,31 @@ public class HaslerTapeTests Assert.True(tape.Samples[1].SecurityAlarm); } + [Fact] + public void A_command_named_like_a_heading_is_read_as_a_line_not_as_the_header() + { + var tape = HaslerTape.Parse(Header + Line(0, 36, 0, 0, command: "Security") + Line(1, 36, 0, 0, security: 1)); + + Assert.Equal(2, tape.Samples.Count); + Assert.False(tape.Samples[0].SecurityAlarm); + Assert.True(tape.Samples[1].SecurityAlarm); + } + + [Fact] + public void A_gap_in_the_time_is_neither_driving_nor_standing_and_covers_no_distance() + { + // the player in another vehicle for ten minutes, then back in this one + var tape = HaslerTape.Parse(Header + Line(0, 36, 0, 0) + Line(1, 36, 0, 0) + Line(601, 36, 0, 0) + + Line(602, 36, 0, 0) + Line(603, 0, 0, 0)); + + Assert.Equal(603, tape.Duration, 6); + Assert.Equal(600, tape.GapTime, 6); + Assert.Equal(2, tape.RunningTime, 6); + Assert.Equal(1, tape.StandingTime, 6); // the last second, stopping + Assert.Equal(10 + 10 + 5, tape.DistanceM, 6); + Assert.Equal(25 / 3.0 * 3.6, tape.AverageWithStopsKmh, 6); + } + [Fact] public void The_sample_under_a_point_of_the_tape_is_found_by_time_and_by_distance() { diff --git a/StarterNG/Domain/Tapes/HaslerTape.cs b/StarterNG/Domain/Tapes/HaslerTape.cs index ffaf607..35e16c7 100644 --- a/StarterNG/Domain/Tapes/HaslerTape.cs +++ b/StarterNG/Domain/Tapes/HaslerTape.cs @@ -41,14 +41,23 @@ public sealed class HaslerTape private const int SecurityFromEndOf25 = 6; // a log with no header to tell: the columns up to the water's temperature private const int MinimumColumns = 17; + private const double MinimumGapSeconds = 1.0; + private const int GapSteps = 20; + public HaslerTape(IReadOnlyList samples) { Samples = samples; foreach (var s in samples) MaxSpeedKmh = Math.Max(MaxSpeedKmh, s.SpeedKmh); + double gap = GapAbove(samples); for (int i = 1; i < samples.Count; i++) - if (samples[i].SpeedKmh > 0.5) - RunningTime += samples[i].Time - samples[i - 1].Time; + { + double step = samples[i].Time - samples[i - 1].Time; + if (step > gap) + GapTime += step; + else if (samples[i].SpeedKmh > 0.5) + RunningTime += step; + } } public IReadOnlyList Samples { get; } @@ -63,54 +72,76 @@ public sealed class HaslerTape public double MaxSpeedKmh { get; } - /// Seconds on the move; the rest of was spent standing. + /// Seconds on the move; the rest of was spent standing, or not recorded. public double RunningTime { get; } - public double StandingTime => Duration - RunningTime; + /// Seconds of not recorded: the gaps, see . + public double GapTime { get; } + + public double StandingTime => Duration - RunningTime - GapTime; /// Mean speed while moving. public double AverageSpeedKmh => RunningTime > 0 ? DistanceM / RunningTime * 3.6 : 0; /// Mean speed over the whole recording, stops included - the commercial speed. - public double AverageWithStopsKmh => Duration > 0 ? DistanceM / Duration * 3.6 : 0; + public double AverageWithStopsKmh => Duration - GapTime > 0 ? DistanceM / (Duration - GapTime) * 3.6 : 0; + + /// + /// A step between two lines longer than this is time not recorded, the player in another vehicle before + /// coming back to this one: neither driving nor standing, and no distance. The lines come every 0.05 s of + /// simulated time or so; it is twenty of their usual steps, a second at least. + /// + public static double GapAbove(IReadOnlyList samples) + { + if (samples.Count < 2) + return MinimumGapSeconds; + var steps = new double[samples.Count - 1]; + for (int i = 1; i < samples.Count; i++) + steps[i - 1] = samples[i].Time - samples[i - 1].Time; + Array.Sort(steps); + return Math.Max(MinimumGapSeconds, GapSteps * steps[steps.Length / 2]); + } public static HaslerTape Parse(string text) { var samples = new List(); - double distance = 0; - TapeSample? previous = null; int securityFromEnd = SecurityFromEndOf25; foreach (var raw in text.Split('\n')) { var columns = raw.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries); - int heading = Array.IndexOf(columns, SecurityHeading); - if (heading >= 0) + if (columns.Length == 0) + continue; + if (!Number(columns[TimeColumn], out double time)) { - securityFromEnd = columns.Length - heading; + // the header; a line of figures may have the word too, in the free text of its command + int heading = Array.IndexOf(columns, SecurityHeading); + if (heading >= 0) + securityFromEnd = columns.Length - heading; continue; } - if (columns.Length < MinimumColumns - || !Number(columns[TimeColumn], out double time) - || !Number(columns[VelocityColumn], out double velocity)) - continue; // the header, or a line cut short by a simulator still writing + if (columns.Length < MinimumColumns || !Number(columns[VelocityColumn], out double velocity)) + continue; // a line cut short by a simulator still writing Number(columns[BrakePressColumn], out double brake); Number(columns[PipePressColumn], out double pipe); Number(columns[MotorCurrentColumn], out double current); bool security = securityFromEnd <= columns.Length && columns[^securityFromEnd] == "1"; - double speed = Math.Abs(velocity); - if (previous is { } p) - { - if (time < p.Time) - continue; - distance += (p.SpeedKmh + speed) / 2 / 3.6 * (time - p.Time); - } + if (samples.Count > 0 && time < samples[^1].Time) + continue; + samples.Add(new TapeSample(time, Math.Abs(velocity), 0, brake, pipe, current, security)); + } - var sample = new TapeSample(time, speed, distance, brake, pipe, current, security); - samples.Add(sample); - previous = sample; + // the distance, trapezoid by trapezoid, none over the gaps + double gap = GapAbove(samples), distance = 0; + for (int i = 1; i < samples.Count; i++) + { + var (before, sample) = (samples[i - 1], samples[i]); + double step = sample.Time - before.Time; + if (step <= gap) + distance += (before.SpeedKmh + sample.SpeedKmh) / 2 / 3.6 * step; + samples[i] = sample with { DistanceM = distance }; } return new HaslerTape(samples);