We have released RumiCar Simulator v10.0.0. The release notes below are also available on GitHub.
v10.0.0
Cars running the wrong way in official races and live runs (auto-recover on) are now turned back on the spot, lap counting is fixed, and 🏅 ranking bugs are fixed (Stage BH; this is a change to the driving physics — runs in which a car ran the wrong way (where the turn-back applies), runs that cross the finish line backwards, and runs on small courses or Triangle whose laps were being missed no longer produce the same results as older versions. Runs with none of these — no wrong-way running, no backward crossing of the finish line, no missed lap — do not change. The official sample event’s verifyHash went from c731ecce to e9f1da0b, the frozen hash f2 was re-stamped, and f0, f1 and f3 are the same as before). (1) Laps are now counted with “owed crossings” — up to v9.0.0 a lap was counted when the car had once moved a little (up to 0.25 m) beyond the finish line and then crossed it from the negative to the positive side, so crossing the line backwards and then forwards again counted as a lap without going round (the winner of the shipped official sample event had not completed a lap: the distance driven was 19.8% of one lap, and a program that merely shuttles back and forth across the line “finished” 3 laps in 10.5 s). Conversely, on small courses (the 3 steering-limit bench courses 3.5 car widths wide) a car on the inside never reached 0.25 m beyond the line, so correct laps were missed, and on the shipped “Triangle” the finish segment was 60° off perpendicular to the start direction, so not a single lap was ever counted even when driven correctly. Now every backward crossing of the finish line adds one owed crossing; a forward crossing repays one if any is owed and is not counted; only a forward crossing through the segment with nothing owed counts as a lap (shuttling and wrong-way running never add laps). The “move beyond the line” condition is gone. A car that starts behind the line does not count its first forward crossing (once per car). A car that starts on or past the line counts its first crossing as lap 1 (the same convention as up to v9.0.0; hence on Triangle, whose start is 1.126 m past the line, lap 1 is 83% of the distance, and that short lap 1 time stays in best laps and practice bests). The moment of counting is unchanged, so runs that were already counted correctly do not change by a single bit in lap times or counting instants. Effect (official races, 66 shipped + 2 community courses × 1–6 cars, 3 laps): entries that counted a lap not actually driven 213 → 0 cars (148 → 0 among finishers), live 741 → 0; missed laps 22 → 0 cars in official races, 145 → 0 live. If you build your own course: draw the finish line so that it blocks the track from wall to wall (or divider) and crosses only one lane. On a custom course whose finish line spans both the outgoing and the returning lane with no wall between them, each lap crosses the line once forwards and once backwards, so no lap is counted at all (up to v9.0.0 it was — the line needs redrawing). On a course where the line does not block the track, a lap in which the car slips past the end of the line and then merely re-crosses the line during a back-and-turn is not counted either. Practice bests saved up to v9.0.0 by shuttling or wrong-way running (e.g. Speedway 3.20 s) are kept, labelled with their version such as “(was v9.0.0)”, but may be impossible to beat with real laps. (2) A car running the wrong way is turned back on the spot — running the wrong way is itself a consequence of the design (programs drive on three forward ToF sensors alone and cannot know the course direction; once a back-and-turn, a collision spin or the program’s own steering or reversing flips the car, it keeps driving the open corridor backwards — just as on the real car). In v9.0.0 official races (rejoin with a 3 s penalty, 1–6 cars) 6.3% of cars on the dynamic model, 4.6% on classic and 23.4% on precise v2 ran the wrong way for 5 car lengths or more, accounting for 28–70% of the cars that failed to finish (it happens with a single car, too). Now, in live runs with “Auto-recover on crash (back & turn)” on and in official races with the 3 s rejoin penalty, when a running car whose body faces against the local course direction (more than 90°) has made a net 5 car lengths against the course direction, it is turned to face the course direction where it is and its speed is set to 0 — like a marshal re-placing the car, not a physical motion (the car is rotated about its body centre or, failing that, about the rear-axle centre; a placement that would intersect a wall, increase its overlap with any other car, leave the car still not facing the local course direction, or carry the reference point forwards across the finish line is skipped and retried later; nothing is done outside the track). In official races it costs the same 3 s penalty per occurrence as a back-and-turn; the “Crashes” column of the race report is the sum of back-and-turns and turn-backs, with the turn-back count shown separately when non-zero. In live runs the car’s serial output logs one line. It works only on the 64 shipped courses whose course direction is known (36 lap courses and 24 touge courses with a centreline, plus the 4 whose walls are two rings — inner and outer — cut at equal angles from a common centre: Square in Circle, Circle in Square, Hexagon & Triangle, Wavy & Circle — and copies of exactly those walls) and not on custom or community courses, under the retire rule, or with auto-recover off (a shipped course with a centreline also loses it when opened and ✔applied in the course editor or embedded in an event definition, so it does not work there either, except for the 4 ring-shaped courses). Cars in the rear rows of the starting grid that already face against the course direction where they are placed (33 of 1,077 cars over the three engines): 19 of them are turned back within 20 s of the start (mostly 2–5 s after it), and in official races that one also counts 3 s (the grid placement itself is unchanged). A program that keeps U-turning or spinning by itself keeps getting turned back (up to 15 times for one car with the drift sample, 6 cars on Narrow Chicane). The turn-back is invisible to the program (the three forward sensor readings just change abruptly); a program that keeps odometry or a map may lose its position. Effect (official races, rejoin penalty, 1–6 cars; “before” is the version with (1) already fixed): correctly finished cars (finished without a lap not actually driven) dynamic 88.7 → 91.9%, classic 91.3 → 94.0%, precise v2 75.9 → 85.9% (with (1) and (2) together, up from 85.9, 89.3 and 72.3% in v9.0.0); total wrong-way distance down to 5.3%; cars still 3+ car lengths into a wrong-way run at the end 163 → 9; 332 cars turned back 485 times (at most 7 for one car). An independent measurement that does not use the course-direction field found 0 cases in 4,159 turn-backs of a correctly driving car being turned. It also works with a single car (of 396 single-car official races, 5 change their result under (2); under (1), separately, 8 of 408 single-car races change). Out-of-scope runs — 1,188 official races under the retire rule and 72 runs on community courses — match the version with (1) already fixed exactly in result and in every tick ((1) applies to out-of-scope courses and rules too). (3) 🏅 ranking / 🏆 official race / 👻 bugs fixed (no change to the driving physics): (a) opening 🏅 or 🏆 right after start-up (before the event list has arrived) left “No verified official records yet” on screen; it now shows “loading” until the list arrives and then fills in automatically (the start-up “records are missing” notice appears too). (b) When the list or an event’s records could not be fetched (GitHub rate limit, offline) it now says so instead of “none yet”, with the number of events that could not be fetched (a 404 for an event store that does not exist yet keeps the old wording). (c) 👻 You vs World Best could run on the course and entries of a different event that claimed the same eventId; fixed (it also runs for events without an eventId). “Entered” / “n races” are counted per event. (d) Selecting events in 🏆 one after another could let the previous event’s details overwrite the current ones; fixed. (e) One broken result file no longer hides the whole ranking. (4) Corrections to explanations: the back-and-turn steering goes straight back → left → right in that order, not “towards the open side seen by the front sensors” (the previous text was wrong); wrong-way running is not “made more frequent by the STUCK back-and-turn” (the v9.0.0 text was wrong — with the same predicate and population as v8.9.0 the total number of wrong-way cars did not increase; only the breakdown of how it starts changed); the three Python sample programs do not necessarily drive like the C versions (the Python Apex Hunter has no dead-end escape; the code is unchanged); the figures in the self-localisation sample’s description were updated to current measurements (forward detection 96% → 85%, among others); “Narrow Chicane’s effective capacity is 4 cars” was removed. The timeout read-out now shows the turn-back count for cars that were turned back and no longer asserts that “the setting is too high”. §14.1 (turn-backs) and §14.2 (lap counting) were added to the physics model notes (physics_model.md), and two Q&A entries to the in-app 🔬 Physics model text. [Important — what no longer reproduces] Runs in which a car ran the wrong way (where the turn-back applies), runs that cross the finish line backwards, and runs on small courses (the 3 steering-limit bench courses 3.5 car widths wide) or Triangle whose laps were being missed no longer produce the same results as older versions (versioned records keep the version label of their time). In the shipped official sample event the former winner, who had not completed a lap, timed out under (1) (finishers 3 → 2) and all three cars finish under (2) (the third went from timeout to finishing in 177.1 s with 57 s of penalties). The frozen hash f2 (Circuit, precise v2, 3 cars) was re-stamped (finishers 1 → 3); f0, f1 and f3 are unchanged. On one shipped course the number of cars that can actually get going on a live ▶ (driveable capacity) changed: steering-limit bench R_out/R_min=1.02 [3.5-car width] on precise v2, 5 → 6 (capacity is measured with rejoin-penalty races regardless of the auto-recover setting, so this course starts 6 cars even with auto-recover off). Triangle now counts laps, and small courses no longer miss them. A turn-back leaves one short line (at most 0.68 car lengths) in the trail. The verification setup was also extended (standing verification gates 74 → 77, real-browser checks 42 → 44; lap counting is checked by two independent measurements that look only at car positions, turn-backs by an independent measurement that does not use the course-direction field, and the figures in the explanations are checked against measurements made by running the product).
Verifying this release yourself
git clone https://github.com/RumiCar-group/RumiCar-Simulator.git
cd RumiCar-Simulator
node wf_run_all.mjs # the full assertion-gate suiteThe suite runs from a fresh clone with no dependencies beyond Node.js.
The real-browser checks under browser/ additionally need npm install and a display.