Rennarten

Die Rennarten (in der App „Renntyp“) von OmegaSim legen fest, wie eine Sitzung abläuft, wann sie endet und wie gewertet wird. Es gibt sieben Renntypen: Training, Time Attack, Qualifying, Runden, Endurance, NPC Knockout und Demolition Derby. Alle benutzen dieselbe Rennmaschine in src/70-race.js: Startaufstellung, Startampel, Rundenzählung über das Start/Ziel-Muster der Strecke, Zielflagge und Ergebnis. Bis zu zehn Rennen lassen sich zu einer Meisterschaft mit Punktewertung verbinden. Welche Renntypen wählbar sind, hängt seit 1.2.4 davon ab, ob das Auto die Kunststoffschiene liest („Auf der Bahn“) oder gedruckte Muster („Ausdruck“).

Der Renntyp (raceMode) beschreibt die Regeln: wann ist Schluss, und wer gewinnt. Der Rennzustand (raceState) beschreibt, wo das Rennen gerade steht. Er ist eine Zustandsmaschine mit diesen Werten:

Bei fliegendem Start gibt es innerhalb von racing zusätzlich die Einführungsrunde (raceFormationLap), in der keine Runden zählen.

Eine Runde ist die Zeit zwischen zwei Überfahrten des Start/Ziel-Musters. Das Auto meldet in jedem Paket den Code des Teils unter sich (Byte 12) und einen Zähler (Byte 11); seit 0.9.39 setzt es beim Lesen des Startmusters außerdem rund eine Sekunde lang Bit 3 von Byte 15. Die steigende Flanke dieses Bits ist der Zielstrich. Eine Flanke ist der Moment, in dem ein Bit von 0 auf 1 wechselt. Doppelte Meldungen innerhalb von 1000 ms (TILE_REPEAT_BLOCK_MS) werden ignoriert. Einen eigenen Rundensensor gibt es nicht.

Die Pause zwischen der fünften roten Lampe und dem Start ist zufällig, damit niemand den Start vorhersehen kann: 1000 ms + Zufall · 2000 ms. Im Mehrspieler gibt das startende Telefon diesen Wert vor, damit alle gleichzeitig losfahren.

Ein Punkteschema ist eine Tabelle „Platz → Punkte“. Das bekannte F1-Schema vergibt 25 Punkte für den Sieg, 18 für Platz 2 und so weiter bis 1 Punkt für Platz 10.

1. In FAHREN die Kachel Renntyp wählen und die Grenze (Minuten, Runden oder Kills) eintragen.
2. Unter Optionen → Renneinstellungen bei Bedarf Wetter, Pflichtstopps, fliegenden Start, Sektoren, Frühstartstrafe und Tank beim Start einstellen.
3. Rennen starten (Kachel in FAHREN oder Knopf im Cockpit; am Controller ist ab Werk keine Taste belegt).
4. Außer im Training erscheint der Schirm Bringe die Autos in Position mit der Startaufstellung und den Knöpfen Abbrechen, Automatisch aufstellen (nur „Auf der Bahn“) und Start. Steuerkreuz wählt, X bestätigt, vorausgewählt ist Start.
5. Autos von Hand auf ihre Plätze stellen oder automatisch aufstellen lassen.
6. Ampel abwarten: fünf rote Lampen, dann gehen alle aus. Das ist der Start.
7. Zum Beenden das Rennen fahren, bis die Grenze erreicht ist, oder abbrechen. Ein Abbruch verwirft die laufende Runde.

1. Kachel Meisterschaft in FAHREN öffnen.
2. Je Zeile ein Event festlegen: Strecke, Format, Umfang, Wetter, Start, Aufstellung, Pflichtstopps.
3. Darunter Fahrgefühl, Aufstellung des ersten Events, Punkte, schnellste Runde und Teilnehmer wählen.
4. Meisterschaft starten; nach jedem Event erscheint der Zwischenstand mit der nächsten Startaufstellung. Die Meisterschaft kann pausiert und über die Kachel fortgesetzt werden.

raceLimitReached() wird viermal je Sekunde geprüft (raceClockTick(), 250 ms):

Training, Time Attack: Grenze > 0 und vergangene Zeit ≥ Grenze · 60 000 ms
Runden:                irgendein Auto hat ≥ Grenze Runden
Qualifying, Endurance: vergangene Zeit ≥ Grenze · 60 000 ms

Ist die Grenze erreicht, wird der Zustand finishing, das Cockpit zeigt „Letzte Runde“, und eine Glocke klingt. Die laufende Runde zählt noch; mit der nächsten Überfahrt des Fahrers fällt die Zielflagge. Im Renntyp Runden ist der Fahrer, der die Zielzahl selbst erreicht, sofort im Ziel. Fährt kein gesteuertes Auto, holt der erste NPC die Flagge. NPCs dürfen ihre angefangene Runde noch zu Ende fahren, höchstens 20 s nach dem Sieger (GHOST_AUSLAUF_MAX_MS).

Die Uhr startet nicht mit Grün, sondern mit der ersten Bewegung eines gesteuerten Autos (über 3 km/h, raceMoveErkannt()), damit die Reaktionszeit nicht in die erste Rundenzeit eingeht. In Challenges läuft die Uhr dagegen ab Grün.

renderRaceResults() sortiert:

Qualifying:       nach bester Runde (aufsteigend)
alle anderen:     nach Rundenzahl (absteigend), bei Gleichstand nach Gesamtzeit (aufsteigend)

Je Auto stehen Runden, beste, mittlere und schlechteste Runde sowie die Streuung in der Tabelle, darunter alle Einzelrunden. Eine Runde unter der kürzest möglichen Zeit zählt nicht als Bestzeit:

Mindestrunde = max(1500 ms ; Streckenlänge / 2,5 m/s)     (rundeMinMs)

Time Attack braucht „Auf der Bahn“ und eine eingescannte Strecke mit mindestens 3 Teilen (bestzeitBereit()). Jede gültige Runde eines gesteuerten Autos wird je Strecke gespeichert (omegasim-bestzeiten); eine gespiegelte Strecke gilt als dieselbe (Schlüssel ist der kleinere der beiden Streckencodes). Medaillen vergibt dieselbe Gold-Formel wie bei den Challenges (Beste Runde, eine Runde). Am Startschirm stehen die Medaillenzeiten, bisher gewonnene Medaillen und Bestzeiten; am Ende kommt eine Zusammenfassung mit Bestzeitvergleich, Schnitt, Streuung und dem Abstand zur nächsten Medaille. Die NPCs fahren als Challenger: gegen die eigene Bestzeit, gegen den Rekord der Online-Bestenliste oder mit Gummiband (Tempo 60 bis 140 % des Garagentempos, Schritt je Runde 4 %).

Menschliche Fahrer haben 3 Leben (KO_LEBEN); jedes Abkommen von der Bahn kostet eines (kurzer trauriger Ton, G4 nach Es4). Ein NPC ist raus, sobald er die Bahn verlässt; er bleibt dann stehen. Das Urteil (knockoutUrteil()):

keine NPCs mehr im Rennen                              → Menschen gewinnen (Fanfare)
Spieler 1 und alle Mitspieler ohne Leben               → NPCs gewinnen (Game-over-Ton)

Jedes Auto, auch jeder NPC, hat eine Health von 100 (DERBY_MAX). Ein Aufprall kostet frontal 10, seitlich oder von hinten getroffen 20 (derbyAufprall(), Richtung aus dem Bewegungssensor). Fährt das eigene Auto mit mehr als 30 km/h bis auf vier Teile an einen NPC heran, verliert der NPC 20 Health, höchstens einmal je Sekunde (DERBY_RAM_TILES, DERBY_RAM_KMH, DERBY_TREFFER_MS). Bei 0 bleibt das Auto stehen, nur die Lichter flackern; ein ausgeschalteter NPC zählt als Kill für den, der ihn getroffen hat. Das Urteil (derbyUrteil()):

ein Teilnehmer hat ≥ Kill-Ziel Kills                     → er gewinnt (Menschen vor NPCs geprüft)
weniger als 2 Teilnehmer                                  → läuft weiter (nur von Hand beendbar)
genau 1 Teilnehmer fährt noch                             → er gewinnt
sonst                                                     → läuft weiter

Im Derby nimmt auch ein stehendes Auto Schaden, und es gibt keinen Boxenstopp.

startRaceCountdown() setzt vor der Ampel: eine gelbe Flagge und eine liegengebliebene Aufstellung werden beendet, das Weich-Verbot angewandt, das Startwetter gesetzt (wechselhaft beginnt trocken), die Windrichtung neu gewürfelt, der Tank aller Spielerautos auf die Startmenge, kein Schaden, kalte Reifen (mit Reifenwärmer 85 °C), Pflichtstopp-Zähler auf 0, alle Rundenlisten leer. Im Ausdruck-Modus mit NPCs oder Safety Car in der Garage erscheint die Warnung „Ausdruck-Modus: NPCs und Safety Car fahren hier nicht“ mit der Zahl der Autos.

ampelZeitplan(grün, Pause) legt feste Zeitpunkte vor Grün fest:

Lampe i (i = 1 … 5) leuchtet bei   grün − Pause − (5 − i) · 1000 ms
alle aus (Start)                    grün
Pause = 1000 + Zufall · 2000 ms
lokal: grün = jetzt + 4600 ms + Pause   (erste Lampe nach 600 ms)

Jede Lampe klingt mit einem Rechteckton von 440 + (i − 1) · 60 Hz, der Start mit 880 Hz. Kommt der Plan verspätet an (Mehrspieler), werden verpasste Lampen übersprungen; nur der Start zählt. Im Mehrspieler kann die Ampel vor der ersten Lampe noch um den Uhrabgleich verschoben werden (ampelVerschieben()). Näheres auf der Seite Startampel.

Während des Countdowns prüft ein Takt alle 100 ms, ob ein gesteuertes Auto (Spieler 1 bis 3) schneller als 3 km/h ist (FRUEHSTART_KMH = 3 / REAL_SCALE). Dann gilt es als Frühstarter; die Ampel läuft weiter.

Bei fliegendem Start beginnt nach Grün eine Einführungsrunde: Das Tempo ist auf das Formationstempo begrenzt, formationPace() = max(Boxentempo 0,294 ; Leseschwelle 0,35) des Höchsttempos, und das eigene Auto fährt im Autopiloten; die Bremse bleibt verfügbar. Runden zählen nicht. Frei ist das Rennen, wenn ein Auto Start/Ziel zum 1 + Sektorzahl-ten Mal überfährt, ohne Sektoren also zum zweiten Mal (formationNoetig()): zwischen zwei Überfahrten desselben Autos liegt immer eine volle Runde, egal wo es stand. Nur in der Stellung „Auf der Bahn“, weil der Autopilot die Querregelung der Schiene braucht.

Die Reihenfolge der Startplätze wird im Startschirm durch Ziehen oder mit den Pfeilen sortiert; das eigene Auto steht mit in der Liste. Platz 0 ist rechts, Platz 1 links, je zwei bilden eine Reihe.

Automatisch aufstellen (experimentell, nur „Auf der Bahn“, nicht im Training) lässt NPCs, Safety Car und Fahrerautos selbst zu ihren Plätzen fahren (src/90-ghosts.js):

Zielort(Platz) = Startkachel − 1 + Seitenbruch(Platz) − floor(Platz/2) · 0,5
Seitenbruch    = 0,15 rechts (gerade Plätze), 0,0 links (ungerade Plätze)

Reihe 1 steht also auf der Kachel vor Start/Ziel, jede weitere Reihe eine halbe Kachel dahinter (AUFSTELL_REIHE_KACHEL), vier Autos je Teil. Fällt ein Platz auf eine Haarnadel oder Engstelle, rücken er und alle dahinter um ganze Teile zurück. Ob ein Auto seinen Platz erreicht hat, prüft aufstellAmPunkt(o, ziel, platz):

auf der Zielkachel und Anteil in der Kachel ≥ Haltebruch(Platz)
oder schon auf der nächsten Kachel, aber höchstens eine halbe Kachel weiter

Die zweite Bedingung (seit 1.2) verhindert, dass ein knapp vorbeigerollter Wagen eine weitere Runde dreht. Am Platz fährt das Auto die aufgenommene Einparkfolge des Safety Cars (MANOEVER.scEin), für die linke Spalte mit gespiegelter Lenkung, mit 300 ms Angleichen ans Aufnahmetempo und mit dem Gas der Folge mal 0,70 (AUFSTELL_SC_GAS; bis 1.2 0,75, Reihe 1 stand etwas zu weit außen). In der Schlange fällt das Tempo nie unter 0,28 des Höchsttempos (AUFSTELL_BODEN), sonst meldete das Auto die Bahn nicht mehr und würde als abgeflogen abgestellt. Zeitgrenze für die ganze Aufstellung: 60 s (AUFSTELLEN_MAX_MS). Mit „Lenkimpuls“ fährt das Auto stattdessen kurz voll zu seiner Seite und genauso lang zurück.

Die Rennpause (seit 1.2.25, übernommen aus PR #9 von Playdater1974; als WIP gekennzeichnet) hält ein laufendes Rennen an, ohne es zu beenden: Die Autos bleiben stehen, die Rennuhr steht still, der Rennzustand bleibt erhalten. Weiter geht es mit einer kurzen Wiederanlauf-Ampel. Der Ablauf ist im Code src/15-pause.js und src/98h-pause.js umgesetzt.

Details aus dem Code:

• Die Pause verwendet eine eigene Uhr (rennPause.uhrStop); Date.now() und performance.now() bleiben für Funk-Wachhund und Netzwerk echt.
• verzug (die Summe aller Pausen) wird beim Rennstart auf 0 gesetzt (rennUhrNullen()); damit gilt im Rennen rennZeitJetzt() === Date.now(), solange niemand pausiert, und die Wanduhr-Startzeit des WLAN-Mehrspielers liegt wieder exakt.
• Nach einem Neuladen der App bleibt kein Auto mehr in der Pause hängen: Beim Laden ruft die Seite OMEGA_BRUECKE.rennPause(false), und das Plugin setzt sich selbst in load() und bei jedem Seitenstart der WebView zurück.
• Ein Druck im Countdown bricht ein laufendes Rennintro ab; Grün kommt über die Wiederanlauf-Ampel.
• Pausierbare Renn-Timeouts laufen über rennZeitTimerStart(), Browser-Timeouts bleiben unverändert.
• Selbsttest: „Rennpause v1.2.25“ in src/95-selftest.js.

Das Rennintro (Optionen → Ansagen → „Rennintro vor der Ampel“, setting-announce-intro; Standard aus, WIP) sagt vor der Startampel den Start an. Es verwendet vorproduzierte Piper-Aufnahmen und die Sprache, Sprechgeschwindigkeit, Lautstärke und den Hall der Rennstand-Ansagen.

• Gesagt werden: Willkommen, Modus, Rundendistanz bzw. Minutenlimit, Pflichtboxenstopps, Teilnehmerzahl, vollständige Startaufstellung (Position, Farbe, Modell), Startwetter und Bereitschaft.
• Teilnehmer und Reihenfolge entsprechen dem Startschirm (inklusive NPCs/Spielerautos, ohne Safety Car/Reinigungsauto); die Identitäten werden beim Introstart eingefroren.
• Ohne Farbzuordnung nur der Artikel, ohne Modellzuordnung „Wagen“. Ein Teilnehmer wird mit „einen Teilnehmer“ angekündigt, bei leerem Feld null Teilnehmer und keine Positionen.
• Die Ampel beginnt erst nach dem letzten Clip; die Frühstartüberwachung läuft schon ab Intro-Beginn (der Rennzustand ist dann bereits countdown).
• Nicht in Challenges (eigener Ablauf mit Ampel) und nicht im WLAN-Mehrspieler; dort gibt es kein Intro.
• Training mit aktivem Intro bekommt die Ampel, ohne Intro weiter den unmittelbaren Start.
• Einzelne fehlende Clips werden ausgelassen (einmal im Protokoll); nur wenn keiner ladbar ist oder der Audiokontext fehlt, Start ohne Ansage.
• Lade-Timeout 20 s (maximal sechs parallele Downloads, geladene Clips bleiben im Speicher), maximale Ansagedauer 180 s mit Wiedergabe-Watchdog.
• Abbrechen stoppt die Audios und verhindert nachträgliche Ampeln; Ausschalten während des Intros beendet die Ansage und geht zur Ampel weiter.
• Sprachaufnahmen: 94 Ogg-Clips unter audio/rennintro_*.ogg (Deutsch/Englisch; Spanisch nutzt Englisch). Erzeugt mit tools/voice_rennintro.py.
• Code: src/80d-rennintro.js; Selbsttest in src/95-selftest.js.

Die Rennstand-Ansage (Optionen → Ansagen; als WIP gekennzeichnet) sagt während eines Rennens den Zwischenstand des lokalen Rennfelds an, und nach der Zielflagge das Ergebnis. Sie verwendet vorproduzierte Sprachclips aus src/80c-rennstand.js.

Messung (Beispiel Intervall 5): Sobald das erste Auto Runde 5 beendet (Runde 6 beginnt), wird der Messstand vorgemerkt. Nach drei Durchfahrten derselben Runde erfolgt die Ansage; bei weniger als drei Autos werden alle abgewartet. Die ersten drei Durchfahrtszeitpunkte bestimmen die Reihenfolge und die Sekundenrückstände; spätere Runden ändern den eingefrorenen Messstand nicht. Nach Ablauf der Wartezeit werden nur die vorhandenen Messwerte gesprochen; fehlende Durchfahrten werden nicht als Überrundung ausgegeben.

• Der Einstieg lautet „Nach Runde drei“. Farbe, Modell und gegebenenfalls die lokale Spielerkennung identifizieren die Fahrzeuge; ohne Zuordnung „Wagen“.
• Die Ergebnisansage beginnt mit „Gewonnen hat …“ und verwendet die finale Rennwertung; sie ist von der Zwischenstands-Messung getrennt.
• Nur lokale Teilnehmer in Rundenrennen und Endurance, keine entfernten Clients. Warnungen und Rennende haben Vorrang; am Rennende keine zusätzliche Zwischenstandsansage.
• Deutsch/Englisch; Spanisch verwendet Englisch. Zahlenclips werden wiederverwendet; keine Online-TTS und keine native Android-Erweiterung erforderlich.
• Die separate Rennstand-Lautstärke beeinflusst Zwischenstand und Ergebnis, nicht Motoren, Regen oder Warnungen (0 % stumm, bis 200 % mit Boost); optionaler Stadionhall liegt nur auf dem Rennstand-Bus.
• Code: src/80c-rennstand.js; automatische Rennstand-Tests im bestehenden Selbsttest.

Seit 1.2.4 gilt (renntypErlaubt()):

// src/70-race.js
function renntypErlaubt(modus) {
  return trackMode === 'on' ? modus !== 'derby' : modus !== 'bestzeit';
}

Ein nicht erlaubter Typ verschwindet aus Kacheln, Liste und dem Durchschalten in FAHREN; war er gewählt, fällt die Wahl auf Training zurück, mit einer Meldung.

Eine gelbe Flagge begrenzt das Tempo auf 80 km/h (YELLOW_KMH, Faktor 80 / (4,0 · 73,75) ≈ 0,27). Das eigene Auto fährt dabei im Autopiloten, auch beim Neustart-Countdown; der Gasfaktor des Fahrgefühls gilt dann nicht, sodass es genauso schnell fährt wie die NPCs. Ausgerufen wird Gelb über den Knopf oder durch Halten der Boxentaste, außer „Gelbe Flagge deaktivieren“ ist an. Ein neues Rennen beginnt nie unter Gelb, und das Rennende beendet eine gelbe Phase. Safety Car und Reinigungswagen beschreibt die Seite Safety Car und Reinigungswagen.

Die Meisterschaft (src/73-meisterschaft.js, Speicher omegasim-meisterschaft) ist kein eigenes Rennen: ein Event setzt nur die vorhandenen Renneinstellungen (Modus, Länge, Wetter, fliegender Start, Pflichtstopps, Strecke, Aufstellung, ggf. Fahrgefühl) und startet den normalen Ablauf. „Wetter ändert sich“ wird für jedes Event ausgeschaltet.

Je Event:

Ab Werk besteht der Plan aus zwei Events: Qualifying über 5 Minuten und Runden über 15 Runden.

Global:

„Automatisch“ bei der Aufstellung löst sich so auf (meisterAufstAufgeloest()): direkt nach einem Qualifying nach dessen Ergebnis; sonst, wenn schon ein Rennen gewertet ist, nach Punkten mit dem Führenden hinten; beim ersten Rennen nach der Einstellung „Startaufstellung 1. Event“. Die Reihe wird je Event einmal festgelegt und bis zum Start behalten, auch bei Zufall.

Wertung eines Events (meisterKlassieren(), meisterPunkteVergeben()):

gewertet:     wer mindestens eine Runde hat
Qualifying:   nach bester Runde
sonst:        nach Runden, dann Gesamtzeit + Strafe für verpasste Pflichtstopps
Punkte F1:    Platz 1 bis 10: 25, 18, 15, 12, 10, 8, 6, 4, 2, 1; danach 0
Klassisch:    10, 6, 4, 3, 2, 1; danach 0
Linear:       Anzahl Gewertete − Platzindex   (Sieger N, Letzter 1)
Schnellste Runde: +1 für den Gewerteten mit der besten Runde (nur Rennen)

Ein von Hand abgebrochenes Rennen zählt für alle mit 0 Punkten, und es geht beim nächsten Event weiter; ein von Hand beendetes Training gilt als regulär. Gewertet wird erst, wenn alle NPCs ihre Auslaufrunde beendet haben (höchstens 95 s). Gesamtwertung (meisterTabelle()): Punkte, dann mehr Siege, mehr zweite Plätze und so weiter bis Platz 10, dann das bessere Ergebnis im letzten Event.

Im Mehrspieler ist das planende Telefon der Leiter: es startet jedes Event für alle, wertet und verschickt den Zwischenstand. Die Menschen werden in der Reihenfolge des Hosts eingeordnet; die eigenen NPCs und Spieler 2/3 werden nach Runden dazwischen sortiert, bei gleicher Rundenzahl anhand des eigenen Autos als Anker.

Rennen gestartet um t = 0, gezogene Pause 1800 ms. Grün liegt bei 4600 + 1800 = 6400 ms.

1. Lampe 1: 6400 − 1800 − 4000 = 600 ms
2. Lampe 2: 1600 ms, Lampe 3: 2600 ms, Lampe 4: 3600 ms, Lampe 5: 4600 ms
3. alle aus: 6400 ms, also 1,8 s nach der fünften Lampe.

Fährt ein Auto bei 5000 ms los, ist es Frühstarter; seine erste Runde von 6,20 s wird mit 11,20 s gewertet.

10 Minuten. Auto A fährt 52 Runden in 9:58,3, Auto B 52 Runden in 10:01,0 (die letzte Runde nach Ablauf zählt), Auto C 51 Runden. Reihenfolge: A, B, C. Hat A einen Pflichtstopp verpasst (Strafe 10 s), wird seine Zeit in der Meisterschaft 10:08,3, und B liegt vorn.

Vorgabe-Plan, F1-Schema mit schnellster Runde, drei Teilnehmer. Qualifying: B, A, C (keine Punkte, Aufstellung des Rennens danach: B, A, C). Rennen: A gewinnt, B Zweiter mit schnellster Runde, C Dritter.

• A: 25, B: 18 + 1 = 19, C: 15.
• Mit linearem Schema: A 3, B 2 + 1 = 3, C 1. Gleichstand A und B: A hat mehr Siege und liegt vorn.

Startkachel 0, Strecke mit 12 Teilen. Zielorte: Platz 0 bei −1 + 0,15 = Kachel 11, Anteil 0,15 (rechts); Platz 1 bei Kachel 11, Anteil 0,0 (links); Platz 2 bei 10,65 (Kachel 10, Anteil 0,65, rechts); Platz 3 bei 10,5 (links); Platz 4 bei 10,15; Platz 5 bei 10,0. Ist Kachel 10 eine Haarnadel, rücken die Plätze 2 bis 5 um ein Teil auf Kachel 9 zurück.

• Die Rennfunktion als Ganzes ist als WIP gekennzeichnet; Time Attack, Knockout, Derby, Sektoren, fliegender Start und automatisches Aufstellen sind experimentell.
• Autos muss man grundsätzlich selbst auf die Bahn setzen; die automatische Aufstellung fährt nur Autos, die schon auf der Bahn stehen.
• Die Einparkfolge ist eine Aufnahme von einem Boden; auf anderen Böden können die Autos weiter innen oder außen stehen (Regler Gas der Safety-Car-Folge).
• Im Derby wird die Richtung eines Stoßes für Spieler 2 und 3 nicht gemessen; ein Treffer zählt für sie immer als seitlich, wenn keine Richtung vorliegt.
• Die Mindestrunde nimmt 2,5 m/s an; auf sehr kurzen Strecken greift der Boden von 1,5 s.
• In der Meisterschaft fehlen GT3, F1 und Realismus GT3 in der Fahrgefühl-Auswahl.

• Startampel
• Boxenstopp
• Verschleiß
• Safety Car und Reinigungswagen
• NPC-Fahrverhalten
• Challenges
• Mehrspieler
• Strecke
• Glossar

• src/70-race.js: RACE_MODES, raceLimitReached(), raceClockTick(), startRaceCountdown(), ampelZeitplan(), ampelVerschieben(), raceGreen(), finishRace(), requestRaceStop(), raceMoveErkannt(), fruehstartBeginnen(), fruehstartZuschlag(), fruehstartStrafeAktiv(), formationNoetig(), endFormationLap(), carRaceNotify(), carLapCrossed(), playerLapCrossed(), rundeMinMs(), renderRaceResults(), renntypErlaubt(), renntypenFiltern(), ausdruckNpcWarnung(), knockoutUrteil(), derbyUrteil(), derbyAufprall(), derbyTick(), bestzeitRunde(), applySpeedLimit(), yellowFactor()
• src/73-meisterschaft.js: MEISTER_FORMATE, MEISTER_GLOBAL, MEISTER_PUNKTE, meisterKlassieren(), meisterPunkteFuer(), meisterPunkteVergeben(), meisterTabelle(), meisterMischen(), meisterAufstAufgeloest(), meisterStartReihe(), meisterEventStarten(), meisterRennenEnde(), meisterWerten()
• src/90-ghosts.js: formationPace(), aufstellZielOrt(), aufstellHaltBruch(), aufstellAmPunkt(), aufstellSkript(), AUFSTELL_SC_GAS, AUFSTELL_BODEN, AUFSTELL_REIHE_KACHEL
• src/71-rammen.js: crashRichtung(), Rammstrafe
• src/15-pause.js, src/98h-pause.js: rennPauseAktiv(), rennZeitJetzt(), rennUhrNullen(), rennZeitTimerStart(), rennPauseErlaubt(), rennPauseWache(), rennPauseMalen()
• src/80d-rennintro.js: Rennintro; src/80c-rennstand.js: rennstandAnwenden(), rennstandMessen(), rennstandSagen(), Ergebnisansage

• Browserfassung, Android-App und Quellcode: Links auf der Hauptseite