Reaction: der Gleichlauf rechnet ohne Uhrenvergleich
Filipe: „die videos muessen perfekt laufen wenn ich die reaktions
mache."
GEMESSEN, NICHT VERMUTET. mess-reaktion hat einen neuen Abschnitt:
Er liest den Spielstand am ECHTEN <video>-Element in beiden Browsern,
rechnet beide auf denselben Augenblick um und sagt, wie weit Host und
Zuschauerin auseinanderliegen. Die vorhandene Pruefung fragte nur, ob
Start und Stopp ANKOMMEN -- zwei Videos koennen beide laufen und
trotzdem zwanzig Sekunden auseinander sein.
vorher nachher
Im Lauf 0,12 s -0,04 s
Wer dazukommt 6,91 s 0,26 s
Uhr des Geraets 30 s vor -29,97 s 0,26 s
DER SCHLIMMSTE FUND: DIE UHR DES TELEFONS
Der Zuschauer rechnete `Date.now() - stand.gesendet`. `gesendet` kam
vom SERVER, `Date.now()` vom Geraet -- zwei Uhren, die nie jemand
verglichen hat. Wessen Telefon dreissig Sekunden vorgeht, schaute
29,97 s weiter als alle anderen. Kein langsames Netz, kein schwaches
Handy. Oertlich faellt das nie auf: Auf einem Rechner sind beide
Uhren dieselbe.
Jetzt geht ein ALTER hinaus statt einer Uhrzeit -- die Differenz
zweier SERVERzeiten. Der Empfaenger braucht dafuer gar keine Uhr,
nur eine Stoppuhr (`performance.now()`), und die haelt Zeitumstellung
und Aufwachen aus dem Ruhezustand aus.
WEITER
* WER DAZUKOMMT, STEIGT RICHTIG EIN. Der gespeicherte Stand war so
alt wie der letzte Takt des Hosts; neue Spalte `sekunde_am` sagt,
wann er galt.
* DAS TEMPO GEHT IN DIE HOCHRECHNUNG EIN. Bei 2x laeuft die Videouhr
doppelt so schnell -- das fehlte ganz.
* JEDER RECHNET ALLE ZWEI SEKUNDEN SELBST NACH statt nur auf Zuruf.
Wer stockte, hing bis zu fuenf Sekunden hinterher.
* DER VORLAUF NACH EINEM SPRUNG WIRD GEREGELT, nicht geschaetzt --
gemessen wird der Rest, nicht die Ladezeit (siehe unten).
* PUFFERN IST AUCH IN DER TRANSPORTLEISTE KEINE PAUSE. Der
Start-Stopp-Knopf rief beim Puffern `playVideo()` -- wer Pause
drueckte, bekam „weiter". Lampe und Knopfbild flackerten bei jedem
Stocken. Die Lektion vom 29.09. war nur an einer Stelle eingeloest.
* DAS TEMPO MELDET UEBER `hostMelden()` statt ein zweites Mal von
Hand -- es hielt Puffern fuer Stillstand und hielt damit beim
Umschalten alle an.
* EIN VIDEO-RUNDRUF STATT DREI ABSCHRIFTEN. Beim Einbau hatte ich
zuerst nur eine nachgezogen; das Tauschen der beiden Videos haette
still die alte Rechnung weiterverschickt.
DREI EIGENE FEHLER UNTERWEGS, alle im Text festgehalten
1. ZWEI FUNKTIONEN HIESSEN `springen`. Meine „spring AUF die Stelle"
wurde von der vorhandenen „spring UM so viele Sekunden"
ueberschrieben -- lautlos, rueckwirkend fuer die ganze Datei. Ein
Zuschauer bei Sekunde 100, dem „geh auf 101" gesagt wird, waere
bei 201 gelandet. DREI BROWSERLAEUFE HABEN ES NICHT GEFUNDEN:
oertlich blieb der Abstand unter der Sprungschwelle, die Zeile
lief kein einziges Mal. Gefunden hat es erst eine Frage an die
ganze Datei -- die steht jetzt als Pruefung drin und wurde
nachgestellt (rot).
2. DER VORLAUF LERNTE NUR NACH OBEN. Gemessen wurde die Ladezeit
nach einem Sprung; ein Sprung in geladenes Material dauert aber
gar nicht, meldet nichts und lehrt nichts. Ergebnis: -0,95 s
stabil. Jetzt wird das ERGEBNIS geregelt statt der Ursache.
3. DER AUSREISSER VON 39,84 s WAR MEINE EIGENE MESSUNG -- der Block
davor schickt eine erfundene Position. Jetzt wird abgeklungen und
in Messreihenfolge ausgegeben.
GEPRUEFT
pruef-reaktion 421/0 (14 neue, darunter der Riegel gegen die
Rueckkehr der Uhrenrechnung und die Wache gegen doppelte
Funktionsnamen -- beide nachgestellt), mess-reaktion ohne ein
einziges ACHTUNG, pruef-buehne 38/0, pruef-struktur, pruef-
zwischenspeicher 34/0.
Schemaaenderung: ADD COLUMN sekunde_am. Datenbank vorher gesichert
und geprueft (integrity_check ok, 20 Personen).
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
@@ -117,7 +117,7 @@ const jetzt = () => new Date().toISOString();
|
||||
====================================================================== */
|
||||
const SENDUNGS_FELDER = {
|
||||
titel: "", video: "", video_titel: "", vorschau: "",
|
||||
beginnt_am: null, laeuft: 0, sekunde: 0, gestartet_am: null,
|
||||
beginnt_am: null, laeuft: 0, sekunde: 0, sekunde_am: 0, gestartet_am: null,
|
||||
zweit_video: "", zweit_titel: "", zweit_sekunde: 0,
|
||||
};
|
||||
|
||||
@@ -133,6 +133,63 @@ const PULT_EINSTELLUNGEN = {
|
||||
chat_modus: "offen",
|
||||
};
|
||||
|
||||
/** Wie alt ist dieser Spielstand -- in Millisekunden?
|
||||
*
|
||||
* DAS IST DIE EINE ZAHL, DIE HINAUSGEHT (30.09.2026), und
|
||||
* ausdruecklich keine Uhrzeit. Ein Alter ist die Differenz zweier
|
||||
* Serverzeiten; der Empfaenger braucht dafuer keine eigene Uhr.
|
||||
*
|
||||
* Vorher ging `gesendet: Date.now()` hinaus, und der Browser rechnete
|
||||
* `Date.now() - gesendet`. Das verglich die Serveruhr mit der Uhr des
|
||||
* Telefons. Gemessen am 30.09.2026: Ein Geraet, dessen Uhr 30 s
|
||||
* vorgeht, spielte das Video 29,97 s weiter als alle anderen. Kein
|
||||
* Fehler im Netz, kein langsames Handy -- nur zwei Uhren, die nie
|
||||
* jemand verglichen hat.
|
||||
*
|
||||
* GEDECKELT. Ein `sekunde_am` von 0 (alte Zeile, frisch angelegte
|
||||
* Sendung) hiesse sonst „dieser Stand ist 56 Jahre alt". Wer nichts
|
||||
* weiss, gibt `null` zurueck -- und `null` heisst beim Empfaenger
|
||||
* „nicht hochrechnen", nicht „null Millisekunden". */
|
||||
const MAX_ALTER_MS = 60_000;
|
||||
function standAlter(s) {
|
||||
const am = Number(s?.sekunde_am) || 0;
|
||||
if (!am) return null;
|
||||
const alt = Date.now() - am;
|
||||
if (alt < 0 || alt > MAX_ALTER_MS) return null;
|
||||
return Math.round(alt);
|
||||
}
|
||||
|
||||
/** Der Rundruf „so steht das Video jetzt" -- an EINER Stelle.
|
||||
*
|
||||
* ER WURDE AN DREI STELLEN VON HAND ZUSAMMENGESETZT: beim Starten
|
||||
* der Sendung, beim Takt des Hosts und beim Tauschen der beiden
|
||||
* Videos. Beim Einbau des Alters (30.09.2026) habe ich zuerst nur
|
||||
* eine davon nachgezogen -- das Tauschen haette danach weiter die
|
||||
* alte, kaputte Rechnung verschickt, und zwar still.
|
||||
*
|
||||
* Dieselbe Sorte Doppelung wie am 11.09.2026, als drei Spalten mit
|
||||
* Inhalt verlorengegangen sind. Eine Liste, die niemand pflegt, kann
|
||||
* nicht veralten.
|
||||
*
|
||||
* GELESEN WIRD AUS DER ZEILE, nicht aus dem, was der Aufrufer
|
||||
* gerade zu wissen glaubt. */
|
||||
function videoRundruf(s) {
|
||||
melden("reaktion", {
|
||||
was: "video",
|
||||
video: s.video,
|
||||
laeuft: !!s.laeuft,
|
||||
sekunde: s.sekunde,
|
||||
tempo: Number(s.tempo) || 1,
|
||||
/* DAS ALTER, NICHT DIE UHRZEIT. Warum: siehe standAlter(). */
|
||||
alter: standAlter(s),
|
||||
/* `gesendet` bleibt vorerst mit drin. Ein Browser, der die alte
|
||||
Fassung noch im Zwischenspeicher hat, wuerde sonst gar nicht
|
||||
mehr nachfuehren -- und „gar nicht" ist schlechter als „etwas
|
||||
ungenau". Darf weg, sobald der Stempel ueberall durch ist. */
|
||||
gesendet: Date.now(),
|
||||
});
|
||||
}
|
||||
|
||||
/* ---------- Schranken --------------------------------------------------- */
|
||||
|
||||
function angemeldet(req, res, next) {
|
||||
@@ -236,7 +293,7 @@ function listeHolen() {
|
||||
* Zuruecksetzen der Sekunde vergessen kann. */
|
||||
function weiterZu(zeile, personId) {
|
||||
db().prepare("UPDATE reaktion SET video = ?, video_titel = ?, laeuft = 1,"
|
||||
+ " sekunde = 0, geaendert = ? WHERE id = 1")
|
||||
+ " sekunde = 0, sekunde_am = unixepoch('subsec') * 1000, geaendert = ? WHERE id = 1")
|
||||
.run(zeile.video, zeile.titel, jetzt());
|
||||
db().prepare("DELETE FROM reaktion_liste WHERE id = ?").run(zeile.id);
|
||||
protokolliere("reaktion_weiter", { personId, detail: zeile.video });
|
||||
@@ -248,7 +305,11 @@ function weiterZu(zeile, personId) {
|
||||
betrifft nur die Anzeige und darf einen Wimpernschlag spaeter
|
||||
kommen. Nur die erste zu schicken hiesse: Das Video wechselt,
|
||||
und im Pult steht weiter der alte Name. */
|
||||
melden("reaktion", { was: "video", video: s.video, laeuft: true, sekunde: 0, gesendet: Date.now() });
|
||||
/* HIER GILT DIE SEKUNDE JETZT -- das Video faengt von vorn an.
|
||||
Ohne `sekunde_am` waere der Stand „unbekannt alt" und niemand
|
||||
duerfte hochrechnen; ausgerechnet beim Start, wo alle
|
||||
gleichzeitig einsteigen. */
|
||||
videoRundruf(s);
|
||||
return s;
|
||||
}
|
||||
|
||||
@@ -300,6 +361,12 @@ function lage(person) {
|
||||
layout: s.layout,
|
||||
laeuft: !!s.laeuft,
|
||||
sekunde: s.sekunde,
|
||||
/* WIE ALT DIESE SEKUNDE IST. Ohne sie setzte sich jeder, der
|
||||
mitten in der Sendung dazukam, auf den Stand des letzten
|
||||
Host-Taktes -- gemessen 6,91 s hinter allen anderen. Jetzt
|
||||
rechnet er die verstrichene Zeit dazu und steigt an der
|
||||
richtigen Stelle ein. */
|
||||
alter: standAlter(s),
|
||||
/* DIE GESCHWINDIGKEIT GEHT AN ALLE. Sie ist kein Regieknopf,
|
||||
sondern Teil dessen, was gerade laeuft -- wer sie nicht
|
||||
bekaeme, saehe dasselbe Video in einem anderen Tempo und waere
|
||||
@@ -943,6 +1010,14 @@ reaktionRouter.post("/workspace/api/reaktion/video", nurHost, express.json({ lim
|
||||
try {
|
||||
const laeuft = req.body?.laeuft ? 1 : 0;
|
||||
const sekunde = Math.max(0, Number(req.body?.sekunde) || 0);
|
||||
/* WIE ALT DIE ABLESUNG BEIM ABSENDEN WAR.
|
||||
Der Host misst das oertlich (Differenz zweier eigener
|
||||
Messpunkte) -- das stimmt auch auf einem Geraet mit falscher
|
||||
Uhr, waehrend eine mitgeschickte Uhrzeit dort falsch waere.
|
||||
Gedeckelt, weil es vom Browser kommt: Was hereinkommt, wird
|
||||
geprueft, nicht geglaubt. */
|
||||
const alter = Math.min(5000, Math.max(0, Number(req.body?.alter) || 0));
|
||||
const sekundeAm = Date.now() - alter;
|
||||
const video = req.body?.video === undefined ? null : videoKennung(String(req.body.video));
|
||||
if (req.body?.video !== undefined && !video) {
|
||||
return res.status(400).json({ fehler: "video_unklar" });
|
||||
@@ -963,8 +1038,9 @@ reaktionRouter.post("/workspace/api/reaktion/video", nurHost, express.json({ lim
|
||||
db().prepare("UPDATE reaktion SET tempo = ? WHERE id = 1").run(tempo);
|
||||
}
|
||||
if (video) {
|
||||
db().prepare("UPDATE reaktion SET video = ?, laeuft = ?, sekunde = ?, geaendert = ? WHERE id = 1")
|
||||
.run(video, laeuft, sekunde, jetzt());
|
||||
db().prepare(`UPDATE reaktion SET video = ?, laeuft = ?, sekunde = ?,
|
||||
sekunde_am = ?, geaendert = ? WHERE id = 1`)
|
||||
.run(video, laeuft, sekunde, sekundeAm, jetzt());
|
||||
/* Der Name wird NACHGEREICHT und nicht abgewartet: Diese
|
||||
Route laeuft waehrend der Sendung im Sekundentakt. Sie
|
||||
darf unter keinen Umstaenden auf YouTube warten. */
|
||||
@@ -977,19 +1053,11 @@ reaktionRouter.post("/workspace/api/reaktion/video", nurHost, express.json({ lim
|
||||
});
|
||||
}
|
||||
} else {
|
||||
db().prepare("UPDATE reaktion SET laeuft = ?, sekunde = ? WHERE id = 1")
|
||||
.run(laeuft, sekunde);
|
||||
db().prepare("UPDATE reaktion SET laeuft = ?, sekunde = ?, sekunde_am = ? WHERE id = 1")
|
||||
.run(laeuft, sekunde, sekundeAm);
|
||||
}
|
||||
const s = sendung();
|
||||
melden("reaktion", {
|
||||
was: "video",
|
||||
video: s.video, laeuft: !!s.laeuft, sekunde: s.sekunde,
|
||||
tempo: Number(s.tempo) || 1,
|
||||
/* Die Uhrzeit des Servers geht mit: Der Empfaenger rechnet
|
||||
die Laufzeit seit dem Absenden dazu. Ohne das waere jeder
|
||||
genau so weit hinten, wie sein Netz langsam ist. */
|
||||
gesendet: Date.now(),
|
||||
});
|
||||
videoRundruf(s);
|
||||
res.json({ ok: true, tempo: Number(s.tempo) || 1 });
|
||||
} catch (fehler) {
|
||||
console.error("[reaktion] Video:", fehler?.message);
|
||||
@@ -1073,6 +1141,7 @@ reaktionRouter.post("/workspace/api/reaktion/tauschen", nurHost,
|
||||
try {
|
||||
db().prepare(`UPDATE reaktion SET
|
||||
video = ?, video_titel = ?, sekunde = ?,
|
||||
sekunde_am = unixepoch('subsec') * 1000,
|
||||
zweit_video = ?, zweit_titel = ?, zweit_sekunde = ?,
|
||||
geaendert = ?
|
||||
WHERE id = 1`)
|
||||
@@ -1095,11 +1164,7 @@ reaktionRouter.post("/workspace/api/reaktion/tauschen", nurHost,
|
||||
}
|
||||
|
||||
const n = sendung();
|
||||
melden("reaktion", {
|
||||
was: "video",
|
||||
video: n.video, laeuft: !!n.laeuft, sekunde: n.sekunde,
|
||||
tempo: Number(n.tempo) || 1, gesendet: Date.now(),
|
||||
});
|
||||
videoRundruf(n);
|
||||
melden("reaktion", { was: "getauscht", lage: oeffentlich(lage(req.person)) });
|
||||
res.json(lage(req.person));
|
||||
} catch (fehler) {
|
||||
|
||||
Reference in New Issue
Block a user