diff --git a/src/components/workers/hochhaus/RegieEbene.jsx b/src/components/workers/hochhaus/RegieEbene.jsx
new file mode 100644
index 0000000..7941f37
--- /dev/null
+++ b/src/components/workers/hochhaus/RegieEbene.jsx
@@ -0,0 +1,135 @@
+import { forwardRef, useEffect, useImperativeHandle, useRef, useState } from 'react'
+import { createRegie } from '../../../lib/hustlerRegie.js'
+
+// Regie-Ebene der Hochhaus-Welt (Spec E9): zeichnet die Effekte der Regie (src/lib/hustlerRegie.js) als absolut positionierte Elemente in
+// Weltkoordinaten über der Welt. Gehört als Kind in die skalierte Bühne (Wurzel mit position: absolute; inset: 0), nimmt keine Klicks an und
+// ist für Bildschirmleser versteckt (der Status steht schon an den Figuren). Keine Props: die Seite spielt über das Handle
+// { push(events), flush() } (regieRef) neue Ereignisse vor. Kein CSS-Import und keine Bilder: die Regeln stehen in styles/hustler/hustler-regie.css.
+// Ein Zeitgeber läuft nur, solange Effekte sichtbar sind oder gleich starten (setTimeout bis zur nächsten Änderung, kein Dauer-Intervall);
+// beim Abbau werden Zeitgeber und Beobachter aufgeräumt. „Weniger Bewegung“ (matchMedia, auch bei Änderung) zeigt nur Blasen,
+// ein verdeckter Tab leert die Ebene (visibilitychange) und nimmt keine neuen Ereignisse an.
+
+const WENIGER_BEWEGUNG = '(prefers-reduced-motion: reduce)'
+
+// Fenster und Dokument nur, wo es sie gibt (Tests unter Node, Vorschau ohne Browser)
+function bewegungMedium() {
+ try {
+ return typeof window !== 'undefined' && typeof window.matchMedia === 'function' ? window.matchMedia(WENIGER_BEWEGUNG) : null
+ } catch {
+ return null
+ }
+}
+const verdeckt = () => typeof document !== 'undefined' && document.hidden === true
+
+// Gleiche Effekte (nach Kennung und Reihenfolge)? Dann bleibt der Zustand unverändert und React zeichnet nicht neu.
+const gleich = (a, b) => a.length === b.length && a.every((e, i) => e.id === b[i].id)
+
+// Regie, Zeitgeber und Handle: einmal pro Ebene, gehalten in einem Ref (kein Zustand, damit Aufrufe von außen nie veraltete Werte sehen)
+function baueSteuerung(setEffekte) {
+ const s = { regie: createRegie(), timer: null, lebt: false }
+ const stoppen = () => {
+ if (s.timer !== null) {
+ clearTimeout(s.timer)
+ s.timer = null
+ }
+ }
+ // Liste neu holen, zeigen und den Zeitgeber auf die nächste Änderung stellen (nur wenn etwas läuft oder wartet)
+ const aktualisieren = () => {
+ stoppen()
+ if (!s.lebt) return
+ const liste = s.regie.tick()
+ setEffekte((alt) => (gleich(alt, liste) ? alt : liste))
+ const bis = s.regie.naechsteIn()
+ if (bis !== null) s.timer = setTimeout(aktualisieren, Math.max(1, bis))
+ }
+ s.aktualisieren = aktualisieren
+ s.stoppen = stoppen
+ s.push = (events) => {
+ if (!s.lebt || verdeckt()) return
+ s.regie.push(events)
+ aktualisieren()
+ }
+ s.flush = () => {
+ s.regie.flush()
+ aktualisieren()
+ }
+ s.setReduziert = (wert) => {
+ s.regie.setReduziert(wert)
+ aktualisieren()
+ }
+ return s
+}
+
+// Lage in Weltkoordinaten (Mittelpunkt bzw. Spitze der Blase) und Dauer für die CSS
+const stil = (e) => ({ left: `${e.x}px`, top: `${e.y}px`, '--dauer': `${e.dauer}ms` })
+
+function effektKnoten(e) {
+ switch (e.art) {
+ case 'blase':
+ return (
+
+ {e.text}
+
+ )
+ case 'icon':
+ return
+ case 'flug':
+ return (
+
+ )
+ case 'jubel':
+ return
+ default:
+ return null
+ }
+}
+
+const RegieEbene = forwardRef(function RegieEbene(_props, ref) {
+ const [effekte, setEffekte] = useState([])
+ const steuerung = useRef(null)
+ if (steuerung.current === null) steuerung.current = baueSteuerung(setEffekte)
+
+ useImperativeHandle(ref, () => ({
+ push: (events) => steuerung.current.push(events),
+ flush: () => steuerung.current.flush(),
+ }), [])
+
+ useEffect(() => {
+ const s = steuerung.current
+ s.lebt = true
+ const medium = bewegungMedium()
+ const beiBewegung = () => s.setReduziert(Boolean(medium && medium.matches))
+ if (medium) {
+ s.regie.setReduziert(medium.matches)
+ if (typeof medium.addEventListener === 'function') medium.addEventListener('change', beiBewegung)
+ else if (typeof medium.addListener === 'function') medium.addListener(beiBewegung)
+ }
+ const beiSicht = () => {
+ if (verdeckt()) s.flush()
+ }
+ if (typeof document !== 'undefined') document.addEventListener('visibilitychange', beiSicht)
+ s.aktualisieren() // nach einem erneuten Einhängen (StrictMode) steht keine alte Liste mehr da
+ return () => {
+ s.lebt = false
+ s.stoppen()
+ s.regie.flush()
+ if (medium) {
+ if (typeof medium.removeEventListener === 'function') medium.removeEventListener('change', beiBewegung)
+ else if (typeof medium.removeListener === 'function') medium.removeListener(beiBewegung)
+ }
+ if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', beiSicht)
+ }
+ }, [])
+
+ return (
+
+ {effekte.map(effektKnoten)}
+
+ )
+})
+
+export default RegieEbene
diff --git a/src/lib/hustlerRegie.js b/src/lib/hustlerRegie.js
new file mode 100644
index 0000000..1582423
--- /dev/null
+++ b/src/lib/hustlerRegie.js
@@ -0,0 +1,205 @@
+// Regie der Hustler-Pixelwelt (Spec E9): macht neue Ereignisse in der Hochhaus-Welt kurz sichtbar.
+// Rein: kein React, kein window/document, kein Zeitgeber. Grundlage sind die Schritte aus eventToSteps (workersEvents.js); die Regie
+// übersetzt sie in Effekte mit Ort (Weltkoordinaten aus hustlerWelt.js), Start und Dauer. Gezeichnet wird in RegieEbene.jsx.
+// blase Sprechblase über dem Kopf (say, 2,5 s) icon Symbol neben der Figur oder am Platz (fx, 1,2 s)
+// flug Umschlag oder Münze von A nach B (give, fx mit to, 0,9 s) jubel Stern-Pop neben der Figur (cheer, 1,2 s)
+// task und pose erzeugen nichts (Status und Text folgen schon über reduceEvents). Die Regie läuft nach einer Uhr, die der Aufrufer
+// liefert (jetzt), und hält selbst keinen Zeitgeber: tick() holt, was gerade zu sehen ist, naechsteIn() sagt, wann sich das ändert.
+import { eventToSteps, SPOTS } from './workersEvents.js'
+import { HUSTLER } from './hustlerWelt.js'
+
+// Dauer je Art in Millisekunden (die CSS in hustler-regie.css läuft mit derselben Dauer über --dauer)
+export const DAUER = Object.freeze({ blase: 2500, icon: 1200, flug: 900, jubel: 1200 })
+
+// Symbol je fx am Ort (fx mit Ziel, also envelope und coin, sind Flüge)
+export const ICON_NACH_FX = Object.freeze({ paper: 'akte', stampOk: 'haken', stampNo: 'stopp', drawer: 'akte', alert: 'alarm' })
+
+// Flugsymbol je fx
+const FLUG_NACH_FX = Object.freeze({ envelope: 'umschlag', coin: 'muenze' })
+
+// Plätze ohne Figur in Weltkoordinaten (Mittelpunkt): Briefkasten, Tresor-Tür, Keller, vor dem Eingang links am Haus
+export const PLAETZE = Object.freeze({
+ pult: Object.freeze({ x: 1240, y: 920 }),
+ tresor: Object.freeze({ x: 1375, y: 975 }),
+ archiv: Object.freeze({ x: 1250, y: 1040 }),
+ aussen: Object.freeze({ x: 900, y: 995 }),
+})
+
+const KOPF_ABSTAND = 36 // Spitze der Blase: so weit über dem Fußpunkt f (Kopf der Figur plus etwas Luft)
+const OTTO_ZUSATZ = 8 // der Overseer ist höher (Kristall)
+const KOERPER_ABSTAND = 16 // Mitte der Figur, Anfang und Ende der Flüge
+const SEITE_DX = 22 // Symbole stehen rechts neben der Figur, der Jubel links
+const SEITE_DY = 26 // Mittelpunkt der Symbole neben der Figur: so weit über f
+
+const MAX_STANDARD = 4
+const RUECKSTAU_STANDARD = 12
+
+const isRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
+const isNum = (n) => typeof n === 'number' && Number.isFinite(n)
+const hatFigur = (id) => typeof id === 'string' && Object.hasOwn(HUSTLER, id)
+const istPlatz = (id) => typeof id === 'string' && SPOTS.includes(id) && Object.hasOwn(PLAETZE, id)
+
+/** Punkt über dem Kopf der Figur (Spitze der Sprechblase); unbekannter Worker -> null. */
+export function kopfPunkt(id) {
+ if (!hatFigur(id)) return null
+ const h = HUSTLER[id]
+ return { x: h.a, y: h.f - KOPF_ABSTAND - (id === 'otto' ? OTTO_ZUSATZ : 0) }
+}
+
+/** Mitte der Figur (Anfang und Ende der Flüge); unbekannter Worker -> null. */
+export function koerperPunkt(id) {
+ if (!hatFigur(id)) return null
+ const h = HUSTLER[id]
+ return { x: h.a, y: h.f - KOERPER_ABSTAND }
+}
+
+// Mittelpunkt neben der Figur: richtung 1 rechts (Symbole), -1 links (Jubel)
+function seitePunkt(id, richtung) {
+ if (!hatFigur(id)) return null
+ const h = HUSTLER[id]
+ return { x: h.a + richtung * SEITE_DX, y: h.f - SEITE_DY }
+}
+
+// Ort eines Schritts: Worker oder Platz -> Punkt (Flüge), sonst null
+function endpunkt(id) {
+ if (hatFigur(id)) return koerperPunkt(id)
+ if (istPlatz(id)) return PLAETZE[id]
+ return null
+}
+
+function flugEntwurf(icon, von, nach, delay) {
+ const a = endpunkt(von)
+ const b = endpunkt(nach)
+ if (!a || !b) return null
+ // Start und Ziel am selben Ort: kein Flug
+ if (von === nach || (a.x === b.x && a.y === b.y)) return null
+ return { art: 'flug', icon, x: a.x, y: a.y, x2: b.x, y2: b.y, dauer: DAUER.flug, delay: isNum(delay) && delay > 0 ? delay * 1000 : 0 }
+}
+
+// Schritt (eventToSteps) -> Entwurf eines Effekts oder null (task, pose, Unbekanntes, Leeres)
+function entwurfVon(step) {
+ if (!isRecord(step)) return null
+ switch (step.op) {
+ case 'say': {
+ const p = kopfPunkt(step.who)
+ if (!p || typeof step.text !== 'string' || step.text === '') return null
+ return { art: 'blase', wer: step.who, text: step.text, x: p.x, y: p.y, dauer: DAUER.blase, delay: 0 }
+ }
+ case 'give':
+ return flugEntwurf('umschlag', step.from, step.to, 0)
+ case 'cheer': {
+ const p = seitePunkt(step.who, -1)
+ return p ? { art: 'jubel', icon: 'stern', wer: step.who, x: p.x, y: p.y, dauer: DAUER.jubel, delay: 0 } : null
+ }
+ case 'fx': {
+ if (Object.hasOwn(FLUG_NACH_FX, step.fx)) {
+ return Object.hasOwn(step, 'to') ? flugEntwurf(FLUG_NACH_FX[step.fx], step.at, step.to, step.delay) : null
+ }
+ if (!Object.hasOwn(ICON_NACH_FX, step.fx)) return null
+ const p = hatFigur(step.at) ? seitePunkt(step.at, 1) : istPlatz(step.at) ? PLAETZE[step.at] : null
+ return p ? { art: 'icon', icon: ICON_NACH_FX[step.fx], x: p.x, y: p.y, dauer: DAUER.icon, delay: 0 } : null
+ }
+ default:
+ return null
+ }
+}
+
+function ganzzahl(wert, standard, min) {
+ return isNum(wert) && Math.floor(wert) >= min ? Math.floor(wert) : standard
+}
+
+/**
+ * createRegie({ jetzt = () => Date.now(), max = 4, rueckstau = 12, reduziert = false })
+ * -> { push(events), tick(), flush(), setReduziert(bool), naechsteIn(), wartende() }
+ * push(events): Liste neuer Ereignisse (Reihenfolge = Alter); kaputte Eingaben, unbekannte Worker und Plätze erzeugen nichts.
+ * tick(): die jetzt sichtbaren Effekte { id, art, x, y, x2?, y2?, text?, icon?, wer?, start, dauer } (neues Feld je Aufruf, die Effekte
+ * selbst bleiben dieselben Objekte, solange sie laufen). Höchstens `max` zugleich; wartende rücken nach, sobald einer abläuft.
+ * Münzen mit delay werden erst zu ihrem Zeitpunkt sichtbar. Je Worker höchstens eine Blase: eine neue ersetzt die alte (auch die laufende,
+ * ohne einen weiteren Platz zu brauchen).
+ * Mehr als `rueckstau` Wartende: die ältesten fallen weg. reduziert: nur Blasen. flush(): leert Warteschlange und laufende Effekte
+ * (der Tab war verdeckt). naechsteIn(): Millisekunden bis sich die Liste ändert (Ablauf oder Start eines Verzögerten), null = nichts los.
+ * wartende(): Zahl der Wartenden (für Tests und Anzeigen).
+ */
+export function createRegie({ jetzt = () => Date.now(), max = MAX_STANDARD, rueckstau = RUECKSTAU_STANDARD, reduziert = false } = {}) {
+ const hoechstens = ganzzahl(max, MAX_STANDARD, 1)
+ const stau = ganzzahl(rueckstau, RUECKSTAU_STANDARD, 0)
+ let nurBlasen = Boolean(reduziert)
+ let zaehler = 0
+ let laufend = [] // sichtbare Effekte
+ let wartend = [] // Entwürfe mit bereit = frühester Start (Millisekunden der Uhr)
+
+ const uhr = () => {
+ const t = jetzt()
+ return isNum(t) ? t : 0
+ }
+
+ // Abgelaufene entfernen, bereite Wartende starten (in Reihenfolge); eine Blase ersetzt die laufende Blase desselben Workers
+ function fuellen(t) {
+ laufend = laufend.filter((e) => e.start + e.dauer > t)
+ let i = 0
+ while (i < wartend.length) {
+ const w = wartend[i]
+ if (w.bereit > t) { i += 1; continue }
+ const alt = w.art === 'blase' ? laufend.find((e) => e.art === 'blase' && e.wer === w.wer) : undefined
+ if (!alt && laufend.length >= hoechstens) { i += 1; continue }
+ if (alt) laufend = laufend.filter((e) => e !== alt)
+ wartend.splice(i, 1)
+ zaehler += 1
+ const { bereit, delay, ...rest } = w
+ laufend.push(Object.freeze({ id: `r${zaehler}`, ...rest, start: t }))
+ }
+ }
+
+ function einreihen(entwurf, t) {
+ // eine neue Blase macht eine noch wartende Blase desselben Workers überflüssig
+ if (entwurf.art === 'blase') wartend = wartend.filter((w) => !(w.art === 'blase' && w.wer === entwurf.wer))
+ wartend.push({ ...entwurf, bereit: t + entwurf.delay })
+ fuellen(t)
+ // Rückstau: die ältesten Wartenden fallen weg
+ if (wartend.length > stau) wartend = wartend.slice(wartend.length - stau)
+ }
+
+ return {
+ push(events) {
+ if (!Array.isArray(events)) return
+ const t = uhr()
+ for (const event of events) {
+ let steps
+ try {
+ steps = eventToSteps(event)
+ } catch {
+ continue // die Regie ist Zierde und darf den Ereignisstrom nie stören
+ }
+ for (const step of steps) {
+ const entwurf = entwurfVon(step)
+ if (!entwurf || (nurBlasen && entwurf.art !== 'blase')) continue
+ einreihen(entwurf, t)
+ }
+ }
+ },
+ tick() {
+ fuellen(uhr())
+ return laufend.slice()
+ },
+ flush() {
+ laufend = []
+ wartend = []
+ },
+ setReduziert(wert) {
+ nurBlasen = Boolean(wert)
+ if (!nurBlasen) return
+ laufend = laufend.filter((e) => e.art === 'blase')
+ wartend = wartend.filter((w) => w.art === 'blase')
+ },
+ naechsteIn() {
+ const t = uhr()
+ let naechste = Infinity
+ for (const e of laufend) naechste = Math.min(naechste, e.start + e.dauer)
+ for (const w of wartend) if (w.bereit > t) naechste = Math.min(naechste, w.bereit)
+ return naechste === Infinity ? null : Math.max(0, naechste - t)
+ },
+ wartende() {
+ return wartend.length
+ },
+ }
+}
diff --git a/src/styles/hustler/hustler-regie.css b/src/styles/hustler/hustler-regie.css
new file mode 100644
index 0000000..b317297
--- /dev/null
+++ b/src/styles/hustler/hustler-regie.css
@@ -0,0 +1,99 @@
+/* Regie der Hochhaus-Welt (T8, Spec E9): Sprechblase, Symbol-Pop, Flug (Umschlag, Münze) und Jubel-Stern, gezeichnet von RegieEbene.jsx.
+ Handgeschrieben, nicht erzeugt. Alle Klassen beginnen mit hk-regie- und stehen unter der Wurzel .hk-hochhaus; alle Keyframes heißen hk-regie-….
+ Die Ebene liegt in der skalierten Bühne (Weltkoordinaten, 1 Einheit = 1 Kunstpixel): left/top sind der Mittelpunkt (Blase: Spitze des Dreiecks),
+ --dauer (und beim Flug --dx/--dy, der Weg zum Ziel) kommen inline aus dem Effekt. Die Bilder sind die vorhandenen PNGs aus assets/hustler
+ (nichts Neues gezeichnet), 16 × 16 in der Welt; bei Sprite-Blättern (Münze, Stern) zeigt die Regel nur das erste Bild.
+ „Weniger Bewegung“: keine Animation (die Regie zeigt dann ohnehin nur Blasen). Wird in WorkersPage.jsx importiert (CSS-Importe nur dort). */
+
+.hk-hochhaus .hk-regie {
+ position: absolute; inset: 0; z-index: 50;
+ pointer-events: none; overflow: visible;
+ image-rendering: pixelated;
+}
+.hk-hochhaus .hk-regie * { pointer-events: none; }
+
+/* ---------- Sprechblase: dunkler Pixel-Rand ohne Ecken, kleines Dreieck nach unten; die Spitze sitzt auf left/top ---------- */
+.hk-hochhaus .hk-regie-blase {
+ position: absolute;
+ margin-top: -6px; /* Dreieck (2 px Rand + 4 px Spitze) hängt unter dem Kasten: die Spitze landet auf top */
+ transform: translate(-50%, -100%);
+}
+.hk-hochhaus .hk-regie-blase-text {
+ display: block; position: relative; box-sizing: border-box;
+ padding: 2px 4px; white-space: nowrap;
+ font-family: 'Pixelify Sans', ui-monospace, monospace; font-size: 8px; line-height: 10px; font-weight: 400; letter-spacing: normal;
+ color: #1a1630; background: #fffbe8;
+ box-shadow: 0 -2px 0 0 #1a1630, 0 2px 0 0 #1a1630, -2px 0 0 0 #1a1630, 2px 0 0 0 #1a1630;
+ transform-origin: 50% 100%;
+ animation: hk-regie-blase var(--dauer, 2500ms) steps(1, end) both;
+}
+.hk-hochhaus .hk-regie-blase-text::after {
+ content: ''; position: absolute; left: 50%; top: 100%; margin: 2px 0 0 -3px;
+ width: 0; height: 0;
+ border-left: 3px solid transparent; border-right: 3px solid transparent; border-top: 4px solid #1a1630;
+}
+
+/* ---------- Symbole: Haken, Stopp, Akte, Alarm, Umschlag, Münze, Stern (Mittelpunkt auf left/top) ---------- */
+.hk-hochhaus .hk-regie-icon,
+.hk-hochhaus .hk-regie-flug,
+.hk-hochhaus .hk-regie-jubel {
+ position: absolute; width: 16px; height: 16px; margin: -8px 0 0 -8px;
+ background-repeat: no-repeat; background-position: 0 0; background-size: auto 16px;
+ image-rendering: pixelated;
+}
+.hk-hochhaus .hk-regie-bild-umschlag { background-image: url(../../assets/hustler/pult/ui/art-mail.png); }
+.hk-hochhaus .hk-regie-bild-haken { background-image: url(../../assets/hustler/keller/ui/haken.png); }
+.hk-hochhaus .hk-regie-bild-stopp { background-image: url(../../assets/hustler/keller/ui/stopp.png); }
+.hk-hochhaus .hk-regie-bild-akte { background-image: url(../../assets/hustler/keller/ui/akte-icon.png); }
+.hk-hochhaus .hk-regie-bild-alarm { background-image: url(../../assets/hustler/pult/ui/art-beschwerde.png); }
+.hk-hochhaus .hk-regie-bild-muenze { background-image: url(../../assets/hustler/ui/muenze-gruen.png); }
+.hk-hochhaus .hk-regie-bild-stern { background-image: url(../../assets/hustler/ui/stern.png); }
+
+/* Icon-Pop: kurz aufploppen, stehen, am Ende ausblenden */
+.hk-hochhaus .hk-regie-icon { animation: hk-regie-pop var(--dauer, 1200ms) steps(1, end) both; }
+
+/* Flug: Bogen von der Mitte des Absenders zum Ziel (--dx/--dy), fünf Stützpunkte auf einer Parabel, 14 px Bogenhöhe */
+.hk-hochhaus .hk-regie-flug { animation: hk-regie-flug var(--dauer, 900ms) linear both; }
+
+/* Jubel: Stern ploppt auf und hüpft */
+.hk-hochhaus .hk-regie-jubel { animation: hk-regie-jubel var(--dauer, 1200ms) steps(1, end) both; }
+
+@keyframes hk-regie-blase {
+ 0% { transform: scale(0.5); opacity: 1; }
+ 4% { transform: scale(1.12); opacity: 1; }
+ 8% { transform: scale(1); opacity: 1; }
+ 90% { transform: scale(1); opacity: 0.6; }
+ 96% { transform: scale(1); opacity: 0.3; }
+ 100% { transform: scale(1); opacity: 0; }
+}
+@keyframes hk-regie-pop {
+ 0% { transform: scale(0.4); opacity: 1; }
+ 10% { transform: scale(1.35); opacity: 1; }
+ 22% { transform: scale(1); opacity: 1; }
+ 85% { transform: scale(1); opacity: 0.5; }
+ 100% { transform: scale(1); opacity: 0; }
+}
+@keyframes hk-regie-flug {
+ 0% { transform: translate(0, 0) scale(0.7); opacity: 1; }
+ 25% { transform: translate(calc(var(--dx, 0px) * 0.25), calc(var(--dy, 0px) * 0.25 - 10.5px)) scale(1); opacity: 1; }
+ 50% { transform: translate(calc(var(--dx, 0px) * 0.5), calc(var(--dy, 0px) * 0.5 - 14px)) scale(1); opacity: 1; }
+ 75% { transform: translate(calc(var(--dx, 0px) * 0.75), calc(var(--dy, 0px) * 0.75 - 10.5px)) scale(1); opacity: 1; }
+ 100% { transform: translate(var(--dx, 0px), var(--dy, 0px)) scale(0.8); opacity: 0; }
+}
+@keyframes hk-regie-jubel {
+ 0% { transform: translateY(0) scale(0.4); opacity: 1; }
+ 12% { transform: translateY(-4px) scale(1.4); opacity: 1; }
+ 24% { transform: translateY(-8px) scale(1); opacity: 1; }
+ 40% { transform: translateY(-3px) scale(1); opacity: 1; }
+ 56% { transform: translateY(-8px) scale(1); opacity: 1; }
+ 72% { transform: translateY(-3px) scale(1); opacity: 1; }
+ 88% { transform: translateY(-8px) scale(1); opacity: 0.6; }
+ 100% { transform: translateY(-8px) scale(1); opacity: 0; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+ .hk-hochhaus .hk-regie-blase-text,
+ .hk-hochhaus .hk-regie-icon,
+ .hk-hochhaus .hk-regie-flug,
+ .hk-hochhaus .hk-regie-jubel { animation: none; }
+}
diff --git a/tests/unit/hustlerRegie.test.mjs b/tests/unit/hustlerRegie.test.mjs
new file mode 100644
index 0000000..9bc1c66
--- /dev/null
+++ b/tests/unit/hustlerRegie.test.mjs
@@ -0,0 +1,990 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import esbuild from 'esbuild'
+import { loadModule } from './load.mjs'
+import { FAKE_REACT } from './helpers/fakeReact.mjs'
+import { ev, IDS } from './helpers/workersFixtures.mjs'
+
+// Regie der Hustler-Pixelwelt (T8, Spec E9):
+// 1. src/lib/hustlerRegie.js: Ereignisse -> Effekte (Blase, Symbol, Flug, Jubel), Höchstzahl, Rückstau, Zeitablauf mit eigener Uhr, reduziert, flush, kaputte Eingaben.
+// 2. RegieEbene.jsx im Mini-Läufer anstelle von React (helpers/fakeReact.mjs, um forwardRef und useImperativeHandle ergänzt), mit eigenem Zeitgeber,
+// eigener Uhr, matchMedia und document.
+// 3. hustler-regie.css: Bilder vorhanden, Klassen, Keyframes, „weniger Bewegung“.
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
+const R = await loadModule('src/lib/hustlerRegie.js')
+const E = await loadModule('src/lib/workersEvents.js')
+const W = await loadModule('src/lib/hustlerWelt.js')
+const { createRegie, PLAETZE, DAUER, ICON_NACH_FX, kopfPunkt, koerperPunkt } = R
+const { EVENT_KINDS } = E
+const { HUSTLER } = W
+
+// ---------- Hilfen ----------
+
+// Eigene Uhr: jetzt() liefert den Stand, vor(ms) stellt ihn weiter
+function uhrVon(start = 1_000_000) {
+ let t = start
+ return { jetzt: () => t, vor: (ms) => { t += ms }, stand: () => t }
+}
+
+// Alle Effekte, die im Lauf von `bis` Millisekunden einmal sichtbar waren (Schritt 100 ms), in der Reihenfolge ihres Erscheinens
+function sammeln(regie, uhr, bis = 8000, schritt = 100) {
+ const gesehen = new Map()
+ for (let ms = 0; ms <= bis; ms += schritt) {
+ for (const e of regie.tick()) if (!gesehen.has(e.id)) gesehen.set(e.id, e)
+ uhr.vor(schritt)
+ }
+ return [...gesehen.values()]
+}
+
+// Kurzform eines Effekts für Vergleiche: art[:icon][:wer:text]
+const kurz = (e) => (e.art === 'blase' ? `blase:${e.wer}:${e.text}` : e.icon ? `${e.art}:${e.icon}` : e.art)
+
+const ARTEN = new Set(['blase', 'icon', 'flug', 'jubel'])
+function pruefeForm(e) {
+ assert.ok(ARTEN.has(e.art), `art ${e.art}`)
+ assert.equal(typeof e.id, 'string')
+ assert.ok(Number.isFinite(e.x) && Number.isFinite(e.y), 'x/y')
+ assert.ok(Number.isFinite(e.start) && e.dauer > 0, 'start/dauer')
+ assert.equal(e.dauer, DAUER[e.art])
+ if (e.art === 'flug') assert.ok(Number.isFinite(e.x2) && Number.isFinite(e.y2), 'x2/y2')
+ else assert.ok(!('x2' in e) && !('y2' in e), 'x2/y2 nur beim Flug')
+ if (e.art === 'blase') assert.ok(typeof e.text === 'string' && e.text !== '')
+ assert.ok(Object.isFrozen(e))
+}
+
+// ---------- Plätze und Punkte ----------
+
+test('PLAETZE: vier Plätze in Weltkoordinaten (Briefkasten, Tresor-Tür, Keller, vor dem Eingang links), eingefroren', () => {
+ assert.deepEqual(Object.keys(PLAETZE).sort(), ['archiv', 'aussen', 'pult', 'tresor'])
+ assert.deepEqual({ ...PLAETZE.pult }, { x: 1240, y: 920 })
+ assert.deepEqual({ ...PLAETZE.tresor }, { x: 1375, y: 975 })
+ assert.deepEqual({ ...PLAETZE.archiv }, { x: 1250, y: 1040 })
+ assert.deepEqual({ ...PLAETZE.aussen }, { x: 900, y: 995 })
+ assert.ok(Object.isFrozen(PLAETZE))
+ for (const p of Object.values(PLAETZE)) assert.ok(Object.isFrozen(p))
+ assert.ok(PLAETZE.aussen.x < W.HAUS_BILD.x, 'aussen liegt links vom Haus')
+})
+
+test('Figurpunkte: Kopf = Anker a, f − 36 (Overseer höher), Körper = f − 16; unbekannte Kennungen -> null', () => {
+ assert.equal(IDS.length, 19)
+ for (const id of IDS) {
+ const h = HUSTLER[id]
+ assert.ok(h, `${id} fehlt in HUSTLER`)
+ assert.deepEqual(kopfPunkt(id), { x: h.a, y: id === 'otto' ? h.f - 44 : h.f - 36 }, id)
+ assert.deepEqual(koerperPunkt(id), { x: h.a, y: h.f - 16 }, id)
+ }
+ assert.ok(kopfPunkt('otto').y < HUSTLER.otto.f - 36, 'Overseer: Blase höher')
+ for (const id of ['niemand', '', 'constructor', '__proto__', 'toString', 'pult', 'system', null, undefined, 5, {}]) {
+ assert.equal(kopfPunkt(id), null, String(id))
+ assert.equal(koerperPunkt(id), null, String(id))
+ }
+})
+
+// ---------- Zuordnung je Ereignisart ----------
+
+// Ein Ereignis je Art (alle 26 aus EVENT_KINDS) mit den erwarteten Effekten, unabhängig vom Code unter Test aus Übersicht §7 abgeleitet
+const TABELLE = {
+ auftrag: { w: 'lea', extra: { to: 'max' }, soll: ['blase:lea:Max, los!', 'blase:max:Verstanden'] },
+ leerlauf: { w: 'lea', soll: [] },
+ gelesen: { w: 'lea', extra: { meta: { count: 3 } }, soll: ['blase:lea:3 gelesen'] },
+ fund: { w: 'lea', soll: ['blase:lea:Neuer Fund!', 'icon:akte'] },
+ doppelt: { w: 'lea', soll: ['blase:lea:Schon bekannt', 'icon:stopp'] },
+ uebergabe: { w: 'lea', extra: { to: 'bea' }, soll: ['flug:umschlag'] },
+ bewertet: { w: 'bea', extra: { meta: { score: 82 } }, soll: ['blase:bea:82 Punkte'] },
+ top3: { w: 'bea', soll: ['blase:bea:Top 3!', 'icon:haken'] },
+ botlead: { w: 'arne', soll: ['blase:arne:Abgelegt', 'icon:akte'] },
+ entwurf: { w: 'clara', soll: ['blase:clara:Entwurf fertig'] },
+ pult: { w: 'clara', soll: ['blase:clara:Zur Freigabe', 'flug:umschlag'] },
+ gesendet: { w: 'max', soll: ['blase:max:Raus damit!', 'flug:umschlag'] },
+ eingang: { w: 'nora', soll: ['blase:nora:Antwort!', 'flug:umschlag'] },
+ sortiert: { w: 'nora', extra: { meta: { classification: 'ja' } }, soll: ['blase:nora:Ja!', 'icon:haken'] },
+ bau_start: { w: 'bob', soll: ['blase:bob:Los geht’s'] },
+ bau_fertig: { w: 'bob', soll: ['blase:bob:Fertig!', 'flug:umschlag'] },
+ pruefung_zurueck: { w: 'paul', extra: { to: 'bob', meta: { round: 2 } }, soll: ['blase:paul:Runde 2 zurück', 'flug:umschlag', 'icon:stopp'] },
+ pruefung_ok: { w: 'paul', soll: ['blase:paul:Passt!', 'icon:haken'] },
+ vorschau_link: { w: 'bob', soll: ['blase:bob:Link raus', 'flug:umschlag'] },
+ angebot: { w: 'theo', soll: ['blase:theo:Kauf-Link!', 'icon:akte'] },
+ deal: { w: 'otto', soll: ['blase:otto:Deal! Super!', 'flug:muenze', 'flug:muenze', 'flug:muenze', 'jubel:stern'] },
+ gesperrt: { w: 'system', soll: ['blase:arne:Gesperrt', 'icon:stopp'] },
+ budget_warnung: { w: 'otto', soll: ['blase:otto:Budget 80 %', 'icon:alarm'] },
+ budget_stopp: { w: 'otto', soll: ['blase:otto:Budget leer', 'icon:alarm'] },
+ pause: { w: 'system', soll: [] },
+ fehler: { w: 'lea', soll: ['blase:lea:Fehler', 'icon:alarm'] },
+}
+
+test('Zuordnung: die Tabelle deckt genau die 26 Ereignisarten ab', () => {
+ assert.equal(EVENT_KINDS.length, 26)
+ assert.deepEqual(Object.keys(TABELLE).sort(), [...EVENT_KINDS].sort())
+})
+
+for (const kind of EVENT_KINDS) {
+ test(`Zuordnung: ${kind} läuft ohne Fehler und ergibt genau die erwarteten Effekte (wohlgeformt, Münzen mit Versatz)`, () => {
+ const { w, extra, soll } = TABELLE[kind]
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
+ r.push([ev(kind, w, extra)])
+ const effekte = sammeln(r, uhr)
+ effekte.forEach(pruefeForm)
+ assert.deepEqual(effekte.map(kurz).sort(), [...soll].sort())
+ assert.equal(r.wartende(), 0)
+ uhr.vor(10_000)
+ assert.deepEqual(r.tick(), [])
+ assert.equal(r.naechsteIn(), null)
+ })
+}
+
+test('task und pose erzeugen nichts: leerlauf und pause bleiben leer, auch direkt nach dem Push', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('leerlauf', 'lea'), ev('pause', 'system')])
+ assert.deepEqual(r.tick(), [])
+ assert.equal(r.naechsteIn(), null)
+})
+
+test('say: Sprechblase 2,5 s an der Spitze über dem Kopf des Workers, Text so lang wie im Schritt (höchstens 20 Zeichen)', () => {
+ const uhr = uhrVon(42_000)
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('gelesen', 'lea', { meta: { count: 3 } })])
+ const [b, ...rest] = r.tick()
+ assert.equal(rest.length, 0)
+ assert.equal(b.art, 'blase'); assert.equal(b.wer, 'lea'); assert.equal(b.text, '3 gelesen')
+ assert.deepEqual([b.x, b.y], [HUSTLER.lea.a, HUSTLER.lea.f - 36])
+ assert.equal(b.start, 42_000); assert.equal(b.dauer, 2500)
+ assert.ok(b.text.length <= 20)
+ // Overseer: Blase höher als bei den anderen
+ r.push([ev('budget_stopp', 'otto')])
+ const otto = r.tick().find((e) => e.art === 'blase' && e.wer === 'otto')
+ assert.deepEqual([otto.x, otto.y], [HUSTLER.otto.a, HUSTLER.otto.f - 44])
+})
+
+test('fund: Blase „Neuer Fund!“ am Kopf plus Symbol Akte neben der Figur (1,2 s)', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('fund', 'ali')])
+ const effekte = r.tick()
+ assert.equal(effekte.length, 2)
+ const blase = effekte.find((e) => e.art === 'blase')
+ const icon = effekte.find((e) => e.art === 'icon')
+ assert.equal(blase.text, 'Neuer Fund!'); assert.deepEqual([blase.x, blase.y], [HUSTLER.ali.a, HUSTLER.ali.f - 36])
+ assert.equal(icon.icon, 'akte'); assert.equal(icon.dauer, 1200)
+ // das Symbol sitzt neben der Figur (rechts), nicht auf der Blase
+ assert.ok(icon.x > HUSTLER.ali.a && icon.x < HUSTLER.ali.a + 40)
+ assert.ok(icon.y > blase.y && icon.y < HUSTLER.ali.f)
+})
+
+test('fx am Ort: Symbole paper/drawer -> akte, stampOk -> haken, stampNo -> stopp, alert -> alarm (ICON_NACH_FX)', () => {
+ assert.deepEqual({ ...ICON_NACH_FX }, { paper: 'akte', stampOk: 'haken', stampNo: 'stopp', drawer: 'akte', alert: 'alarm' })
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
+ r.push([ev('fund', 'lea'), ev('top3', 'bea'), ev('doppelt', 'sven'), ev('botlead', 'arne'), ev('fehler', 'kim')])
+ const icons = r.tick().filter((e) => e.art === 'icon')
+ assert.deepEqual(icons.map((e) => e.icon), ['akte', 'haken', 'stopp', 'akte', 'alarm'])
+})
+
+test('gesendet: Umschlag fliegt 900 ms von Max nach „aussen“; von system (Mensch am Pult) vom Briefkasten nach „aussen“', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('gesendet', 'max')])
+ const flug = r.tick().find((e) => e.art === 'flug')
+ assert.equal(flug.icon, 'umschlag'); assert.equal(flug.dauer, 900)
+ assert.deepEqual([flug.x, flug.y], [HUSTLER.max.a, HUSTLER.max.f - 16])
+ assert.deepEqual([flug.x2, flug.y2], [PLAETZE.aussen.x, PLAETZE.aussen.y])
+ r.flush()
+ r.push([ev('gesendet', 'system')])
+ const alle = r.tick()
+ assert.deepEqual(alle.map(kurz), ['flug:umschlag'])
+ assert.deepEqual([alle[0].x, alle[0].y, alle[0].x2, alle[0].y2], [PLAETZE.pult.x, PLAETZE.pult.y, PLAETZE.aussen.x, PLAETZE.aussen.y])
+})
+
+test('give und fx mit Ziel: Flüge zwischen Figuren, zum Briefkasten und von draußen zum Worker; gleicher Start und Ziel fliegt nicht', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
+ r.push([ev('uebergabe', 'lea', { to: 'bea' }), ev('pult', 'clara'), ev('eingang', 'nora'), ev('uebergabe', 'lea', { to: 'lea' })])
+ const fluege = r.tick().filter((e) => e.art === 'flug')
+ assert.equal(fluege.length, 3)
+ const koerper = (id) => [HUSTLER[id].a, HUSTLER[id].f - 16]
+ assert.deepEqual([fluege[0].x, fluege[0].y, fluege[0].x2, fluege[0].y2], [...koerper('lea'), ...koerper('bea')])
+ assert.deepEqual([fluege[1].x, fluege[1].y, fluege[1].x2, fluege[1].y2], [...koerper('clara'), PLAETZE.pult.x, PLAETZE.pult.y])
+ assert.deepEqual([fluege[2].x, fluege[2].y, fluege[2].x2, fluege[2].y2], [PLAETZE.aussen.x, PLAETZE.aussen.y, ...koerper('nora')])
+})
+
+test('deal: drei Münzflüge von „aussen“ zum Tresor mit 0,4 s Versatz, Jubel-Stern und Blase beim Overseer', () => {
+ const uhr = uhrVon(10_000)
+ const r = createRegie({ jetzt: uhr.jetzt, max: 8 })
+ r.push([ev('deal', 'otto')])
+ // sofort: erste Münze, Jubel, Blase; die anderen Münzen sind noch nicht dran
+ assert.deepEqual(r.tick().map(kurz).sort(), ['blase:otto:Deal! Super!', 'flug:muenze', 'jubel:stern'])
+ assert.equal(r.wartende(), 2)
+ assert.equal(r.naechsteIn(), 400)
+ uhr.vor(399)
+ assert.equal(r.tick().filter((e) => e.icon === 'muenze').length, 1)
+ uhr.vor(1)
+ assert.equal(r.tick().filter((e) => e.icon === 'muenze').length, 2)
+ uhr.vor(400)
+ const muenzen = r.tick().filter((e) => e.icon === 'muenze')
+ assert.equal(muenzen.length, 3)
+ assert.deepEqual(muenzen.map((m) => m.start), [10_000, 10_400, 10_800], 'Versatz 400 ms')
+ for (const m of muenzen) {
+ assert.deepEqual([m.x, m.y, m.x2, m.y2], [PLAETZE.aussen.x, PLAETZE.aussen.y, PLAETZE.tresor.x, PLAETZE.tresor.y])
+ assert.equal(m.dauer, 900)
+ }
+ const jubel = r.tick().find((e) => e.art === 'jubel')
+ assert.equal(jubel.wer, 'otto'); assert.equal(jubel.icon, 'stern'); assert.equal(jubel.dauer, 1200)
+ assert.ok(Math.abs(jubel.x - HUSTLER.otto.a) <= 40 && jubel.y < HUSTLER.otto.f && jubel.y > HUSTLER.otto.f - 40, 'Stern neben dem Overseer')
+})
+
+test('deal mit der Höchstzahl 4: die dritte Münze wartet, bis die erste (900 ms) im Ziel ist', () => {
+ const uhr = uhrVon(10_000)
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('deal', 'otto')])
+ r.tick()
+ uhr.vor(800)
+ assert.equal(r.tick().filter((e) => e.icon === 'muenze').length, 2)
+ assert.equal(r.tick().length, 4)
+ uhr.vor(100)
+ const muenzen = r.tick().filter((e) => e.icon === 'muenze')
+ assert.equal(muenzen.length, 2) // erste weg, dritte da
+ assert.equal(muenzen[1].start, 10_900)
+})
+
+// ---------- Höchstzahl, Rückstau, Zeitablauf ----------
+
+test('Höchstzahl: nie mehr als max zugleich sichtbar (Standard 4), wartende rücken nach, sobald einer abläuft', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push(IDS.slice(0, 6).map((id) => ev('fund', id))) // 12 Entwürfe
+ let gesehen = 0
+ for (let ms = 0; ms <= 20_000; ms += 50) {
+ const jetzt = r.tick()
+ assert.ok(jetzt.length <= 4, `${jetzt.length} bei ${ms} ms`)
+ gesehen = Math.max(gesehen, jetzt.length)
+ uhr.vor(50)
+ }
+ assert.equal(gesehen, 4)
+ assert.deepEqual(r.tick(), [])
+ assert.equal(r.wartende(), 0)
+
+ // eine andere Höchstzahl
+ const r2 = createRegie({ jetzt: uhr.jetzt, max: 2 })
+ r2.push(IDS.slice(0, 5).map((id) => ev('fund', id)))
+ assert.equal(r2.tick().length, 2)
+ // erster Ablauf: Symbole nach 1,2 s, dann rücken die nächsten nach (Start = Zeitpunkt des Ablaufs)
+ const anfang = uhr.stand()
+ uhr.vor(1200)
+ const danach = r2.tick()
+ assert.equal(danach.length, 2)
+ assert.ok(danach.some((e) => e.start === anfang + 1200))
+})
+
+test('Reihenfolge der Wartenden: wer zuerst kam, startet zuerst (max 1)', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 1 })
+ r.push(['kim', 'pia', 'finn'].map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
+ const texte = []
+ for (let i = 0; i < 3; i += 1) {
+ texte.push(...r.tick().map((e) => e.text))
+ uhr.vor(2500)
+ }
+ assert.deepEqual(texte, ['1 gelesen', '2 gelesen', '3 gelesen'])
+})
+
+test('Rückstau: mehr als 12 Wartende -> die ältesten fallen weg, die neuesten bleiben (19 Blasen: 1-4 laufen, 5-7 fallen weg, 8-19 warten)', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push(IDS.map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
+ assert.equal(r.tick().length, 4)
+ assert.equal(r.wartende(), 12)
+ const effekte = sammeln(r, uhr, 20_000, 50)
+ const zahlen = effekte.map((e) => Number.parseInt(e.text, 10))
+ assert.deepEqual(zahlen, [1, 2, 3, 4, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
+ assert.equal(r.wartende(), 0)
+})
+
+test('Rückstau einstellbar: max 1, rueckstau 3, acht Blasen -> 1 läuft, 2-5 fallen weg, danach 6, 7, 8', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 1, rueckstau: 3 })
+ r.push(IDS.slice(0, 8).map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
+ assert.equal(r.wartende(), 3)
+ const texte = []
+ for (let i = 0; i < 6; i += 1) {
+ texte.push(...r.tick().map((e) => e.text))
+ uhr.vor(2500)
+ }
+ assert.deepEqual(texte, ['1 gelesen', '6 gelesen', '7 gelesen', '8 gelesen'])
+})
+
+test('Rückstau 0: was nicht sofort starten kann, fällt weg', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 1, rueckstau: 0 })
+ r.push(IDS.slice(0, 3).map((id, i) => ev('gelesen', id, { meta: { count: i + 1 } })))
+ assert.equal(r.wartende(), 0)
+ assert.deepEqual(r.tick().map((e) => e.text), ['1 gelesen'])
+})
+
+test('Zeitablauf mit eigener Uhr: Blase 2500 ms, Symbol 1200 ms, Flug 900 ms; naechsteIn zählt bis zum nächsten Ablauf', () => {
+ const uhr = uhrVon(5000)
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('fund', 'lea'), ev('gesendet', 'max')])
+ assert.equal(r.tick().length, 4) // Blase + Akte (lea), Blase + Flug (max)
+ assert.equal(r.naechsteIn(), 900)
+ uhr.vor(899)
+ assert.equal(r.tick().length, 4)
+ assert.equal(r.naechsteIn(), 1)
+ uhr.vor(1)
+ assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:Neuer Fund!', 'blase:max:Raus damit!', 'icon:akte'])
+ assert.equal(r.naechsteIn(), 300)
+ uhr.vor(300)
+ assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:Neuer Fund!', 'blase:max:Raus damit!'])
+ uhr.vor(1299)
+ assert.equal(r.tick().length, 2)
+ uhr.vor(1)
+ assert.deepEqual(r.tick(), [])
+ assert.equal(r.naechsteIn(), null)
+})
+
+test('tick: neues Feld je Aufruf, dieselben (eingefrorenen) Effekte, solange sie laufen; start bleibt', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('fund', 'lea')])
+ const a = r.tick()
+ uhr.vor(500)
+ const b = r.tick()
+ assert.notEqual(a, b)
+ assert.equal(a[0], b[0])
+ assert.equal(b[0].start, 1_000_000)
+ a.pop()
+ assert.equal(r.tick().length, 2, 'das Feld gehört dem Aufrufer')
+ assert.equal(new Set(r.tick().map((e) => e.id)).size, 2)
+})
+
+test('Standarduhr: ohne jetzt wird Date.now benutzt', () => {
+ const r = createRegie()
+ const vorher = Date.now()
+ r.push([ev('fund', 'lea')])
+ const [e] = r.tick()
+ assert.ok(e.start >= vorher && e.start <= Date.now())
+})
+
+// ---------- Eine Blase je Worker ----------
+
+test('eine Blase je Worker: die neue ersetzt die laufende, auch wenn alle Plätze belegt sind', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 1 })
+ r.push([ev('gelesen', 'lea', { meta: { count: 1 } })])
+ assert.deepEqual(r.tick().map((e) => e.text), ['1 gelesen'])
+ uhr.vor(500)
+ r.push([ev('gelesen', 'lea', { meta: { count: 2 } })])
+ assert.deepEqual(r.tick().map((e) => e.text), ['2 gelesen'])
+ assert.equal(r.wartende(), 0)
+ assert.equal(r.tick()[0].start, uhr.stand())
+ // andere Worker haben eigene Blasen
+ const r2 = createRegie({ jetzt: uhr.jetzt })
+ r2.push([ev('gelesen', 'lea', { meta: { count: 1 } }), ev('gelesen', 'sven', { meta: { count: 2 } }), ev('gelesen', 'lea', { meta: { count: 3 } })])
+ assert.deepEqual(r2.tick().map((e) => `${e.wer}:${e.text}`).sort(), ['lea:3 gelesen', 'sven:2 gelesen'])
+})
+
+test('eine Blase je Worker: eine noch wartende Blase wird von der nächsten desselben Workers ersetzt', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 1 })
+ r.push([ev('gelesen', 'kim', { meta: { count: 1 } })]) // läuft
+ r.push([ev('gelesen', 'lea', { meta: { count: 2 } })]) // wartet
+ r.push([ev('gelesen', 'lea', { meta: { count: 3 } })]) // ersetzt die wartende
+ assert.equal(r.wartende(), 1)
+ const texte = []
+ for (let i = 0; i < 3; i += 1) {
+ texte.push(...r.tick().map((e) => e.text))
+ uhr.vor(2500)
+ }
+ assert.deepEqual(texte, ['1 gelesen', '3 gelesen'])
+})
+
+test('Blasen ersetzen nur Blasen: Symbole und Flüge desselben Workers laufen weiter', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('fund', 'lea')])
+ uhr.vor(300)
+ r.push([ev('gelesen', 'lea', { meta: { count: 9 } })])
+ assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:9 gelesen', 'icon:akte'])
+})
+
+// ---------- reduziert, flush ----------
+
+test('reduziert: nur Blasen, alles andere (Symbole, Flüge, Jubel) fällt weg', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, reduziert: true })
+ r.push([ev('fund', 'lea'), ev('gesendet', 'max'), ev('deal', 'otto'), ev('top3', 'bea')])
+ const effekte = sammeln(r, uhr)
+ assert.deepEqual(effekte.map(kurz).sort(), ['blase:bea:Top 3!', 'blase:lea:Neuer Fund!', 'blase:max:Raus damit!', 'blase:otto:Deal! Super!'])
+ assert.equal(r.wartende(), 0)
+})
+
+test('setReduziert: schaltet zur Laufzeit um, entfernt laufende und wartende Nicht-Blasen sofort; danach wieder alles', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([ev('deal', 'otto')])
+ assert.equal(r.tick().length, 3)
+ assert.equal(r.wartende(), 2)
+ r.setReduziert(true)
+ assert.deepEqual(r.tick().map(kurz), ['blase:otto:Deal! Super!'])
+ assert.equal(r.wartende(), 0)
+ assert.equal(r.naechsteIn(), 2500)
+ r.push([ev('fund', 'lea')])
+ assert.deepEqual(r.tick().map(kurz).sort(), ['blase:lea:Neuer Fund!', 'blase:otto:Deal! Super!'])
+ r.setReduziert(false)
+ r.push([ev('top3', 'bea')])
+ assert.ok(r.tick().some((e) => e.art === 'icon' && e.icon === 'haken'))
+})
+
+test('flush: leert Warteschlange und laufende Effekte; danach geht es normal weiter', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 2 })
+ r.push(IDS.slice(0, 6).map((id) => ev('fund', id)))
+ assert.equal(r.tick().length, 2)
+ assert.ok(r.wartende() > 0)
+ r.flush()
+ assert.deepEqual(r.tick(), [])
+ assert.equal(r.wartende(), 0)
+ assert.equal(r.naechsteIn(), null)
+ uhr.vor(60_000)
+ assert.deepEqual(r.tick(), [])
+ r.push([ev('top3', 'bea')])
+ assert.equal(r.tick().length, 2)
+ // Kennungen bleiben auch nach flush eindeutig
+ const ids = r.tick().map((e) => e.id)
+ r.flush()
+ r.push([ev('top3', 'bea')])
+ assert.ok(r.tick().every((e) => !ids.includes(e.id)))
+})
+
+test('naechsteIn: null im Leerlauf, Rest der Laufzeit, Beginn der nächsten verzögerten Münze', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ assert.equal(r.naechsteIn(), null)
+ r.push([ev('gelesen', 'lea')])
+ assert.equal(r.naechsteIn(), 2500)
+ uhr.vor(1000)
+ assert.equal(r.naechsteIn(), 1500)
+ uhr.vor(1500)
+ assert.equal(r.naechsteIn(), 0) // abgelaufen, aber noch nicht abgeholt
+ assert.deepEqual(r.tick(), [])
+ assert.equal(r.naechsteIn(), null)
+})
+
+// ---------- Unbekannte Worker, kaputte Eingaben ----------
+
+test('unbekannte Worker und Plätze erzeugen nichts', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt })
+ r.push([
+ ev('fund', 'niemand'), ev('gelesen', ''), ev('fund', '__proto__'), ev('fund', 'constructor'), ev('fund', 'toString'),
+ ev('uebergabe', 'lea', { to: 'niemand' }), ev('uebergabe', 'niemand', { to: 'lea' }), ev('pult', 'niemand'), ev('eingang', 'niemand'),
+ ev('auftrag', 'otto', { to: 'niemand' }),
+ ])
+ // auftrag an einen Unbekannten bleibt ein reiner task-Schritt: auch Ottos Blase „… los!“ entfällt
+ assert.deepEqual(r.tick().map(kurz), [])
+ assert.equal(r.wartende(), 0)
+})
+
+test('kaputte Eingaben: push mit Nicht-Listen, Nicht-Ereignissen, falschen Feldern und werfenden Getter wirft nie; gute Ereignisse laufen trotzdem', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 50, rueckstau: 50 })
+ for (const kaputt of [undefined, null, 5, 'text', {}, new Set([1]), () => {}]) assert.doesNotThrow(() => r.push(kaputt))
+ const werfend = { id: 'x', ts: '2026-10-17T20:00:00.000Z', workerId: 'lea', text: 'A', get kind() { throw new Error('kaputt') } }
+ assert.doesNotThrow(() => r.push([
+ null, undefined, 5, 'fund', [], {}, { kind: 'fund' }, { kind: 'fund', workerId: 5 }, { kind: 7, workerId: 'lea' },
+ { kind: 'unbekannt', workerId: 'lea', text: 'T' }, { kind: 'gelesen', workerId: 'lea', meta: '{kaputt' }, { kind: 'gelesen', workerId: 'lea', meta: [] },
+ { kind: 'deal', workerId: 'otto', meta: 5, text: {} }, werfend, ev('top3', 'bea'),
+ ]))
+ const effekte = r.tick()
+ effekte.forEach(pruefeForm)
+ assert.ok(effekte.some((e) => e.art === 'blase' && e.wer === 'bea' && e.text === 'Top 3!'))
+ assert.ok(effekte.some((e) => e.art === 'blase' && e.wer === 'lea' && e.text === 'Gelesen'), 'kaputtes meta zählt wie leer')
+ assert.equal(effekte.filter((e) => e.art === 'blase' && e.wer === 'lea').length, 1)
+})
+
+test('Blasen mit leerem oder fremdem Text entfallen; Text wird nur gekürzt, nie als HTML gedeutet', () => {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max: 50 })
+ // eventToSteps setzt feste Texte; Ereignis-Texte landen nur in task und erscheinen nie in einer Blase
+ r.push([ev('fund', 'lea', { text: '
' })])
+ const texte = r.tick().filter((e) => e.art === 'blase').map((e) => e.text)
+ assert.deepEqual(texte, ['Neuer Fund!'])
+})
+
+test('Optionen: ungültige max/rueckstau/jetzt fallen auf die Standardwerte zurück; kaputte Uhr stürzt nicht', () => {
+ for (const max of [NaN, 0, -3, 'a', null, Infinity]) {
+ const uhr = uhrVon()
+ const r = createRegie({ jetzt: uhr.jetzt, max, rueckstau: 'x' })
+ r.push(IDS.slice(0, 6).map((id) => ev('fund', id)))
+ assert.equal(r.tick().length, 4, `max ${String(max)}`)
+ assert.equal(r.wartende(), 8)
+ }
+ const r2 = createRegie({ jetzt: () => NaN })
+ assert.doesNotThrow(() => { r2.push([ev('fund', 'lea')]); r2.tick(); r2.naechsteIn() })
+ const r3 = createRegie({})
+ assert.doesNotThrow(() => r3.push([ev('fund', 'lea')]))
+})
+
+test('Quelltext: rein (kein React, window, document, Zeitgeber); Importe nur workersEvents, hustlerWelt, workersRoster', () => {
+ const src = readFileSync(path.join(ROOT, 'src/lib/hustlerRegie.js'), 'utf8')
+ const code = src.replace(/\/\/.*$/gm, '')
+ assert.doesNotMatch(code, /\b(window|document|setTimeout|setInterval|localStorage)\b/)
+ assert.doesNotMatch(code, /from 'react'|from "react"/)
+ const importe = [...src.matchAll(/^import .* from '([^']+)'/gm)].map((m) => m[1])
+ for (const i of importe) assert.ok(['./workersEvents.js', './hustlerWelt.js', './workersRoster.js'].includes(i), i)
+ assert.doesNotMatch(src, /engine\/director/)
+})
+
+// ---------- RegieEbene (Mini-Läufer) ----------
+
+// fakeReact kennt forwardRef und useImperativeHandle nicht: hier angehängt (ref kommt wie bei React 18 als zweites Argument)
+const FAKE_REACT_MIT_REF = `${FAKE_REACT}
+export function forwardRef(render) { return (props) => render(props, props.ref ?? null) }
+export function useImperativeHandle(ref, create, deps) {
+ useEffect(() => { if (ref) ref.current = create(); return () => { if (ref) ref.current = null } }, deps)
+}
+`
+const fakeReactMitRef = {
+ name: 'fake-react-mit-ref',
+ setup(build) {
+ build.onResolve({ filter: /^react(\/jsx-runtime)?$/ }, () => ({ path: 'react', namespace: 'fake-react' }))
+ build.onLoad({ filter: /.*/, namespace: 'fake-react' }, () => ({ contents: FAKE_REACT_MIT_REF, loader: 'js' }))
+ },
+}
+
+let ebeneBundle
+const ladeEbene = () => (ebeneBundle ??= esbuild.build({
+ stdin: { contents: "export { __mount, jsx } from 'react'\nexport { default as RegieEbene } from './src/components/workers/hochhaus/RegieEbene.jsx'", resolveDir: ROOT, loader: 'js' },
+ bundle: true, format: 'esm', platform: 'neutral', write: false, jsx: 'automatic', loader: { '.jsx': 'jsx' }, plugins: [fakeReactMitRef],
+}).then((out) => import(`data:text/javascript;base64,${Buffer.from(out.outputFiles[0].text).toString('base64')}`)))
+
+// Umgebung mit eigenem Zeitgeber, eigener Uhr (Date.now), matchMedia und document; ende() stellt alles zurück
+function umgebung({ bewegung = false, verdeckt = false, ohneFenster = false } = {}) {
+ const alt = { setTimeout: globalThis.setTimeout, clearTimeout: globalThis.clearTimeout, setInterval: globalThis.setInterval, now: Date.now, window: globalThis.window, document: globalThis.document }
+ let t = 1_000_000
+ let nr = 0
+ const zeitgeber = new Map()
+ const intervalle = []
+ globalThis.setTimeout = (fn, ms) => { nr += 1; zeitgeber.set(nr, { fn, bei: t + (ms ?? 0) }); return nr }
+ globalThis.clearTimeout = (id) => { zeitgeber.delete(id) }
+ globalThis.setInterval = (...args) => { intervalle.push(args); return 0 }
+ Date.now = () => t
+ const media = {
+ matches: bewegung,
+ zuhoerer: new Set(),
+ addEventListener(art, fn) { if (art === 'change') this.zuhoerer.add(fn) },
+ removeEventListener(art, fn) { if (art === 'change') this.zuhoerer.delete(fn) },
+ aendern(matches) { this.matches = matches; for (const fn of [...this.zuhoerer]) fn({ matches }) },
+ }
+ const doc = {
+ hidden: verdeckt,
+ zuhoerer: new Set(),
+ addEventListener(art, fn) { if (art === 'visibilitychange') this.zuhoerer.add(fn) },
+ removeEventListener(art, fn) { if (art === 'visibilitychange') this.zuhoerer.delete(fn) },
+ sichtwechsel(hidden) { this.hidden = hidden; for (const fn of [...this.zuhoerer]) fn({}) },
+ }
+ const anfragen = []
+ if (ohneFenster) { delete globalThis.window; delete globalThis.document } else {
+ globalThis.window = { matchMedia: (q) => { anfragen.push(q); return media } }
+ globalThis.document = doc
+ }
+ return {
+ media, doc, anfragen, intervalle,
+ jetzt: () => t,
+ offene: () => zeitgeber.size,
+ // Zeit vorstellen und dabei die fälligen Zeitgeber in ihrer Reihenfolge auslösen (t steht dann auf dem Zeitpunkt des Zeitgebers)
+ vor(ms) {
+ const ziel = t + ms
+ for (;;) {
+ const faellig = [...zeitgeber].filter(([, z]) => z.bei <= ziel).sort((a, b) => a[1].bei - b[1].bei)[0]
+ if (!faellig) break
+ zeitgeber.delete(faellig[0])
+ t = Math.max(t, faellig[1].bei)
+ faellig[1].fn()
+ }
+ t = ziel
+ },
+ ende() {
+ globalThis.setTimeout = alt.setTimeout; globalThis.clearTimeout = alt.clearTimeout; globalThis.setInterval = alt.setInterval; Date.now = alt.now
+ if (alt.window === undefined) delete globalThis.window; else globalThis.window = alt.window
+ if (alt.document === undefined) delete globalThis.document; else globalThis.document = alt.document
+ },
+ }
+}
+
+const nodes = (node, passt, out = []) => {
+ if (node === null || typeof node === 'string') return out
+ if (passt(node)) out.push(node)
+ for (const kind of node.children) nodes(kind, passt, out)
+ return out
+}
+const textVon = (node) => (typeof node === 'string' ? node : node === null ? '' : node.children.map(textVon).join(''))
+const hatKlasse = (n, name) => String(n.props.className ?? '').split(' ').includes(name)
+const nachKlasse = (baum, name) => nodes(baum, (n) => typeof n.tag === 'string' && hatKlasse(n, name))
+
+// Ebene einhängen; liefert Baum, Handle und Abbau
+async function ebene(umg) {
+ const { __mount, jsx, RegieEbene } = await ladeEbene()
+ const ref = { current: null }
+ const gemountet = __mount(jsx(RegieEbene, { ref }))
+ return { ref, tree: () => gemountet.tree(), abbau: () => gemountet.unmount(), spaet: () => gemountet.lateUpdates() }
+}
+
+test('RegieEbene: leere Ebene mit hk-regie, aria-hidden, Handle { push, flush }, kein Zeitgeber und kein Intervall im Ruhezustand', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ const wurzel = v.tree()
+ assert.equal(wurzel.tag, 'div'); assert.equal(wurzel.props.className, 'hk-regie'); assert.equal(wurzel.props['aria-hidden'], 'true')
+ assert.deepEqual(wurzel.children, [])
+ assert.deepEqual(Object.keys(v.ref.current).sort(), ['flush', 'push'])
+ assert.equal(umg.offene(), 0)
+ assert.equal(umg.intervalle.length, 0)
+ assert.deepEqual(umg.anfragen, ['(prefers-reduced-motion: reduce)'])
+ assert.equal(umg.media.zuhoerer.size, 1); assert.equal(umg.doc.zuhoerer.size, 1)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: Blase in Weltkoordinaten (left/top am Kopf, --dauer), Text als Textknoten; nach Ablauf weg und kein Zeitgeber mehr', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('gelesen', 'lea', { meta: { count: 3 } })])
+ const blasen = nachKlasse(v.tree(), 'hk-regie-blase')
+ assert.equal(blasen.length, 1)
+ assert.deepEqual({ ...blasen[0].props.style }, { left: `${HUSTLER.lea.a}px`, top: `${HUSTLER.lea.f - 36}px`, '--dauer': '2500ms' })
+ const text = nachKlasse(blasen[0], 'hk-regie-blase-text')
+ assert.equal(text.length, 1)
+ assert.deepEqual(text[0].children, ['3 gelesen'])
+ assert.equal(umg.offene(), 1, 'genau ein Zeitgeber bis zum Ablauf')
+ umg.vor(2499)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
+ umg.vor(1)
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ assert.equal(umg.intervalle.length, 0)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: Symbol (Klasse hk-regie-icon + hk-regie-bild-akte) neben der Figur, Blase bleibt länger als das Symbol', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('fund', 'lea')])
+ const icons = nachKlasse(v.tree(), 'hk-regie-icon')
+ assert.equal(icons.length, 1)
+ assert.ok(hatKlasse(icons[0], 'hk-regie-bild-akte'))
+ assert.equal(icons[0].props.style.left, `${HUSTLER.lea.a + 22}px`)
+ assert.equal(icons[0].props.style.top, `${HUSTLER.lea.f - 26}px`)
+ assert.equal(icons[0].props.style['--dauer'], '1200ms')
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
+ umg.vor(1200)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-icon').length, 0)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
+ umg.vor(1300)
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: Flug mit Start (left/top) und Weg zum Ziel (--dx/--dy); gesendet fliegt von Max nach „aussen“', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('gesendet', 'max')])
+ const fluege = nachKlasse(v.tree(), 'hk-regie-flug')
+ assert.equal(fluege.length, 1)
+ assert.ok(hatKlasse(fluege[0], 'hk-regie-bild-umschlag'))
+ const sx = HUSTLER.max.a
+ const sy = HUSTLER.max.f - 16
+ assert.deepEqual({ ...fluege[0].props.style }, { left: `${sx}px`, top: `${sy}px`, '--dauer': '900ms', '--dx': `${PLAETZE.aussen.x - sx}px`, '--dy': `${PLAETZE.aussen.y - sy}px` })
+ umg.vor(900)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-flug').length, 0)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: deal zeigt Münze 1, Jubel und Blase, 400 ms später Münze 2, und Münze 3 sobald ein Platz frei ist (Höchstzahl 4)', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('deal', 'otto')])
+ const muenzen = () => nachKlasse(v.tree(), 'hk-regie-bild-muenze')
+ assert.equal(muenzen().length, 1)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-jubel').length, 1)
+ assert.ok(hatKlasse(nachKlasse(v.tree(), 'hk-regie-jubel')[0], 'hk-regie-bild-stern'))
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
+ umg.vor(400)
+ assert.equal(muenzen().length, 2)
+ umg.vor(400)
+ assert.equal(muenzen().length, 2, 'bei 800 ms sind vier Plätze belegt')
+ umg.vor(100)
+ assert.equal(muenzen().length, 2, 'erste Münze weg, dritte da')
+ umg.vor(400)
+ assert.equal(muenzen().length, 1)
+ umg.vor(2500)
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: Elemente behalten ihre key-Kennung, solange sie laufen (kein Neustart der CSS-Animation durch andere Effekte)', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('gelesen', 'lea')])
+ const erste = nachKlasse(v.tree(), 'hk-regie-blase')[0]
+ umg.vor(300)
+ v.ref.current.push([ev('gelesen', 'sven')])
+ const blasen = nachKlasse(v.tree(), 'hk-regie-blase')
+ assert.equal(blasen.length, 2)
+ assert.equal(blasen[0].props.style.left, erste.props.style.left)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: „weniger Bewegung“ -> nur Blasen; Wechsel über den Änderungs-Listener wirkt sofort (laufende Flüge verschwinden)', async () => {
+ const umg = umgebung({ bewegung: true })
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('deal', 'otto'), ev('fund', 'lea')])
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 2)
+ for (const k of ['hk-regie-flug', 'hk-regie-icon', 'hk-regie-jubel']) assert.equal(nachKlasse(v.tree(), k).length, 0, k)
+ umg.media.aendern(false)
+ v.ref.current.push([ev('deal', 'otto')])
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-flug').length, 1)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-jubel').length, 1)
+ umg.media.aendern(true)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-flug').length, 0)
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-jubel').length, 0)
+ assert.ok(nachKlasse(v.tree(), 'hk-regie-blase').length >= 1)
+ umg.vor(5000)
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: verdeckter Tab leert die Ebene und stoppt den Zeitgeber; solange er verdeckt ist, kommt nichts an; danach geht es weiter', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('deal', 'otto'), ev('fund', 'lea')])
+ assert.ok(v.tree().children.length > 0)
+ assert.ok(umg.offene() > 0)
+ umg.doc.sichtwechsel(true)
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ v.ref.current.push([ev('fund', 'bea')])
+ assert.deepEqual(v.tree().children, [], 'verdeckt: nichts sammelt sich an')
+ assert.equal(umg.offene(), 0)
+ umg.doc.sichtwechsel(false)
+ assert.deepEqual(v.tree().children, [])
+ v.ref.current.push([ev('fund', 'bea')])
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: flush über das Handle leert alles und räumt den Zeitgeber auf', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('deal', 'otto'), ev('fund', 'lea')])
+ assert.ok(umg.offene() > 0)
+ v.ref.current.flush()
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ v.ref.current.push([ev('fund', 'lea')])
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-blase').length, 1)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: Abbau räumt Zeitgeber und Beobachter auf, nimmt das Handle zurück; späte Aufrufe und Zeitgeber ändern nichts', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ const handle = v.ref.current
+ handle.push([ev('deal', 'otto'), ev('fund', 'lea')])
+ assert.ok(umg.offene() > 0)
+ v.abbau()
+ assert.equal(umg.offene(), 0)
+ assert.equal(umg.media.zuhoerer.size, 0)
+ assert.equal(umg.doc.zuhoerer.size, 0)
+ assert.equal(v.ref.current, null)
+ handle.push([ev('fund', 'lea')])
+ handle.flush()
+ assert.equal(umg.offene(), 0, 'nach dem Abbau startet kein neuer Zeitgeber')
+ assert.equal(v.spaet(), 0, 'keine Zustandsänderung nach dem Abbau')
+ assert.equal(umg.intervalle.length, 0)
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: ohne window und document (z. B. Vorschau) läuft sie trotzdem', async () => {
+ const umg = umgebung({ ohneFenster: true })
+ try {
+ const v = await ebene(umg)
+ v.ref.current.push([ev('fund', 'lea')])
+ assert.equal(nachKlasse(v.tree(), 'hk-regie-icon').length, 1)
+ umg.vor(5000)
+ assert.deepEqual(v.tree().children, [])
+ v.abbau()
+ assert.equal(umg.offene(), 0)
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: kaputte Eingaben über das Handle werfen nicht', async () => {
+ const umg = umgebung()
+ try {
+ const v = await ebene(umg)
+ for (const kaputt of [undefined, null, 'x', {}, [null, 5, { kind: 'fund' }]]) assert.doesNotThrow(() => v.ref.current.push(kaputt))
+ assert.deepEqual(v.tree().children, [])
+ assert.equal(umg.offene(), 0)
+ v.abbau()
+ } finally { umg.ende() }
+})
+
+test('RegieEbene: Quelltext ohne dangerouslySetInnerHTML/innerHTML und ohne Dauer-Intervall, Klassen alle mit hk-regie', () => {
+ const src = readFileSync(path.join(ROOT, 'src/components/workers/hochhaus/RegieEbene.jsx'), 'utf8')
+ assert.doesNotMatch(src, /dangerouslySetInnerHTML|innerHTML|setInterval/)
+ assert.doesNotMatch(src, /^import .*\.(css|png)'/m)
+ for (const m of src.matchAll(/className=(?:"([^"]+)"|\{`([^`]+)`\})/g)) {
+ for (const klasse of (m[1] ?? m[2]).split(/\s+/)) assert.match(klasse, /^hk-regie/, klasse)
+ }
+ assert.doesNotMatch(src, /engine\/director/)
+})
+
+// ---------- hustler-regie.css ----------
+
+const cssText = readFileSync(path.join(ROOT, 'src/styles/hustler/hustler-regie.css'), 'utf8')
+const cssOhneKommentare = cssText.replace(/\/\*[\s\S]*?\*\//g, ' ')
+
+// -> { regeln: [{ selektor, koerper, kontext }], keyframes: [name] }
+function zerlege(text) {
+ const regeln = []
+ const keyframes = []
+ let i = 0
+ function liste(kontext) {
+ for (;;) {
+ while (i < text.length && /\s/.test(text[i])) i += 1
+ if (i >= text.length) return
+ if (text[i] === '}') { i += 1; return }
+ const start = i
+ while (i < text.length && text[i] !== '{' && text[i] !== '}') i += 1
+ const kopf = text.slice(start, i).trim()
+ assert.equal(text[i], '{', `Regel ohne Block: ${kopf.slice(0, 60)}`)
+ i += 1
+ if (kopf.startsWith('@keyframes')) {
+ keyframes.push(kopf.slice('@keyframes'.length).trim())
+ let tiefe = 1
+ while (i < text.length && tiefe > 0) { if (text[i] === '{') tiefe += 1; if (text[i] === '}') tiefe -= 1; i += 1 }
+ } else if (kopf.startsWith('@media')) {
+ liste(kopf)
+ } else {
+ const ks = i
+ while (i < text.length && text[i] !== '}') i += 1
+ regeln.push({ selektor: kopf, koerper: text.slice(ks, i), kontext })
+ i += 1
+ }
+ }
+ }
+ liste('')
+ return { regeln, keyframes }
+}
+const css = zerlege(cssOhneKommentare)
+
+test('CSS: Kopfkommentar nennt Aufgabe und Namensräume; mehr als zehn Regeln gelesen', () => {
+ assert.match(cssText.split('\n')[0], /^\/\* Regie der Hochhaus-Welt/)
+ assert.ok(css.regeln.length > 10, `nur ${css.regeln.length} Regeln`)
+})
+
+test('CSS: jede Bilddatei aus url(...) existiert unter src/assets/hustler (relativer Pfad, PNG), und die gewünschten Icons sind alle da', () => {
+ const urls = [...cssOhneKommentare.matchAll(/url\(\s*([^)]*?)\s*\)/g)].map((m) => m[1].replace(/^["']|["']$/g, ''))
+ assert.equal(urls.length, 7)
+ const assets = path.join(ROOT, 'src/assets/hustler')
+ for (const u of urls) {
+ assert.match(u, /^\.\.\/\.\.\/assets\/hustler\/[\w./-]+\.png$/, u)
+ const ziel = path.resolve(path.join(ROOT, 'src/styles/hustler'), u)
+ assert.ok(ziel.startsWith(assets + path.sep), `${u} liegt außerhalb`)
+ assert.ok(existsSync(ziel) && statSync(ziel).isFile(), `${u} fehlt`)
+ }
+ assert.deepEqual([...urls].map((u) => u.replace('../../assets/hustler/', '')).sort(), [
+ 'keller/ui/akte-icon.png', 'keller/ui/haken.png', 'keller/ui/stopp.png', 'pult/ui/art-beschwerde.png', 'pult/ui/art-mail.png', 'ui/muenze-gruen.png', 'ui/stern.png',
+ ])
+})
+
+test('CSS: jede Klasse in einem Selektor heißt hk-regie…, jede Regel steht unter .hk-hochhaus (auch im Media-Block)', () => {
+ for (const r of css.regeln) {
+ for (const teil of r.selektor.split(',').map((s) => s.trim())) {
+ assert.ok(teil.startsWith('.hk-hochhaus '), `nicht unter .hk-hochhaus: ${teil}`)
+ const klassen = [...teil.matchAll(/\.(-?[A-Za-z_][\w-]*)/g)].map((m) => m[1]).slice(1)
+ assert.ok(klassen.length >= 1, `keine Klasse: ${teil}`)
+ for (const k of klassen) assert.match(k, /^hk-regie(-|$)/, `${teil}: ${k}`)
+ }
+ }
+ for (const name of css.keyframes) assert.match(name, /^hk-regie-/, name)
+})
+
+test('CSS: alle von der Ebene gesetzten Klassen sind definiert, auch jedes Bild je Symbolname (Regie-Namen)', () => {
+ const definiert = new Set(css.regeln.flatMap((r) => [...r.selektor.matchAll(/\.(hk-regie[\w-]*)/g)].map((m) => m[1])))
+ const src = readFileSync(path.join(ROOT, 'src/components/workers/hochhaus/RegieEbene.jsx'), 'utf8')
+ for (const m of src.matchAll(/hk-regie[\w-]*/g)) {
+ if (m[0] === 'hk-regie-bild-') continue // dynamisch: je Symbolname
+ assert.ok(definiert.has(m[0]), `${m[0]} fehlt in hustler-regie.css`)
+ }
+ const symbole = new Set([...Object.values(ICON_NACH_FX), 'umschlag', 'muenze', 'stern'])
+ assert.deepEqual([...symbole].sort(), ['akte', 'alarm', 'haken', 'muenze', 'stern', 'stopp', 'umschlag'])
+ for (const s of symbole) assert.ok(definiert.has(`hk-regie-bild-${s}`), `hk-regie-bild-${s}`)
+})
+
+test('CSS: Keyframes sind definiert und werden benutzt; Dauer kommt aus --dauer', () => {
+ const benutzt = new Set([...cssOhneKommentare.matchAll(/animation:\s*(hk-regie-[\w-]+)/g)].map((m) => m[1]))
+ assert.deepEqual([...benutzt].sort(), [...css.keyframes].sort())
+ for (const name of benutzt) assert.ok(css.keyframes.includes(name), name)
+ for (const m of cssOhneKommentare.matchAll(/animation:\s*hk-regie-[\w-]+\s+var\(--dauer, (\d+)ms\)/g)) assert.ok(Number(m[1]) > 0)
+ // Standarddauer in der CSS = Dauer der Regie
+ assert.match(cssOhneKommentare, new RegExp(`hk-regie-blase var\\(--dauer, ${DAUER.blase}ms\\)`))
+ assert.match(cssOhneKommentare, new RegExp(`hk-regie-pop var\\(--dauer, ${DAUER.icon}ms\\)`))
+ assert.match(cssOhneKommentare, new RegExp(`hk-regie-flug var\\(--dauer, ${DAUER.flug}ms\\)`))
+ assert.match(cssOhneKommentare, new RegExp(`hk-regie-jubel var\\(--dauer, ${DAUER.jubel}ms\\)`))
+})
+
+test('CSS: Ebene nimmt keine Klicks an, Pixel-Darstellung, Symbole 16 px (Sprite-Blätter: nur das erste Bild), „weniger Bewegung“ ohne Animation', () => {
+ const regel = (teil) => css.regeln.filter((r) => r.selektor.split(',').map((s) => s.trim()).includes(teil))
+ const ebeneRegeln = regel('.hk-hochhaus .hk-regie')
+ assert.equal(ebeneRegeln.length, 1)
+ assert.match(ebeneRegeln[0].koerper, /pointer-events:\s*none/)
+ assert.match(ebeneRegeln[0].koerper, /image-rendering:\s*pixelated/)
+ assert.ok(regel('.hk-hochhaus .hk-regie *').some((r) => /pointer-events:\s*none/.test(r.koerper)))
+ const bild = regel('.hk-hochhaus .hk-regie-icon')[0]
+ assert.match(bild.koerper, /width:\s*16px/); assert.match(bild.koerper, /height:\s*16px/)
+ assert.match(bild.koerper, /image-rendering:\s*pixelated/)
+ assert.match(bild.koerper, /background-position:\s*0 0/) // erstes Bild
+ assert.match(bild.koerper, /background-size:\s*auto 16px/) // Sprite-Blatt in Originalgröße, nur Zelle 1 sichtbar
+ // Blase: Pixelify Sans, dunkler Rand, Dreieck
+ const text = regel('.hk-hochhaus .hk-regie-blase-text')[0].koerper
+ assert.match(text, /Pixelify Sans/); assert.match(text, /box-shadow/)
+ assert.ok(regel('.hk-hochhaus .hk-regie-blase-text::after').length === 1)
+ // weniger Bewegung
+ const media = css.regeln.filter((r) => r.kontext.includes('prefers-reduced-motion: reduce'))
+ assert.ok(media.length >= 1)
+ const ohne = media.flatMap((r) => r.selektor.split(',').map((s) => s.trim()))
+ for (const k of ['blase-text', 'icon', 'flug', 'jubel']) assert.ok(ohne.includes(`.hk-hochhaus .hk-regie-${k}`), k)
+ for (const r of media) assert.match(r.koerper, /animation:\s*none/)
+})
+
+test('CSS: Symbole auf die Größen der Welt begrenzt (12–16 px), keine @import/@font-face/googleapis', () => {
+ for (const r of css.regeln) {
+ for (const m of r.koerper.matchAll(/(?