ClaudeandClaude Sonnet 5.5
e69c4355bd
Dazu drawSideBubble in sprites.js: Ottos seitliche Blase braucht das Raster des Kontexts. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
234 lines
17 KiB
JavaScript
234 lines
17 KiB
JavaScript
import test from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { loadModule } from './load.mjs'
|
|
import { makeCtx } from './helpers/fakeCtx.mjs'
|
|
import { IDS, makeState } from './helpers/workersFixtures.mjs'
|
|
|
|
// Regie 1: Agenten, Snapshot ohne Animation, Posen, Leerlauf, Zeichnen (Quelle: entwuerfe/scene-turm.js)
|
|
const D = await loadModule('src/components/workers/engine/director.js')
|
|
const { buildLayout, homeOf } = await loadModule('src/components/workers/engine/layout.js')
|
|
const { createLift } = await loadModule('src/components/workers/engine/lift.js')
|
|
const { createFx } = await loadModule('src/components/workers/engine/fx.js')
|
|
const { createLook } = await loadModule('src/components/workers/engine/rooms.js')
|
|
const { pickAgent } = await loadModule('src/components/workers/engine/camera.js')
|
|
const { PAL } = await loadModule('src/components/workers/engine/sprites.js')
|
|
const { createDirector, drawAgents } = D
|
|
|
|
function setup() {
|
|
const layout = buildLayout(), lift = createLift(layout), fx = createFx(), look = createLook()
|
|
return { layout, lift, fx, look, d: createDirector({ layout, lift, fx, look, rnd: () => 0.5 }) }
|
|
}
|
|
const step = (d, n, dt = 0.1) => { for (let i = 0; i < n; i++) d.update(dt) }
|
|
const rectsOf = (ctx, fill) => ctx.rects.filter((r) => r.fill === fill)
|
|
const draw = (d, selectedId = null, t = 1) => { const m = makeCtx(); drawAgents(m.ctx, d, selectedId, t); return m }
|
|
const depth = (a) => a.y + a.lane + a.bob + 13 * a.scale
|
|
|
|
test('erster Snapshot: alle 19 an ihrem Platz, Pose nach Status, „!“ bei Fehler', () => {
|
|
const { d, layout } = setup(); d.applyState(makeState({ statuses: { kim: 'leerlauf', rita: 'wartet', bea: 'fehler' } }))
|
|
assert.equal(d.agents.length, 19)
|
|
for (const a of d.agents) { const h = homeOf(layout, a.id); assert.deepEqual([a.x, a.y], [h.x, h.y], a.id) }
|
|
assert.deepEqual([d.byId.kim.pose, d.byId.rita.pose, d.byId.otto.pose, d.byId.bea.alert], ['coffee', 'stand', 'type', true])
|
|
})
|
|
|
|
test('erster Snapshot stellt Agenten auf den Platz, auch wenn sie vorher woanders standen', () => {
|
|
const { d, layout } = setup(); for (const a of d.agents) { a.x = 5; a.y = 7; a.carrying = true; a.frame = 1 }
|
|
d.applyState(makeState())
|
|
for (const a of d.agents) { const h = homeOf(layout, a.id); assert.deepEqual([a.x, a.y, a.carrying, a.frame, a.floor], [h.x, h.y, false, 0, h.floor], a.id) }
|
|
assert.deepEqual([d.byId.otto.lane, d.byId.bob.lane], [0, -2])
|
|
})
|
|
|
|
test('nicht angeschlossen oder im Zustand fehlend ⇒ grau, schläft, Raum in look.greyRooms (Review Focus 4)', () => {
|
|
const { d, look } = setup(); const st = makeState({ connected: { kim: false } }); st.workers = st.workers.filter((w) => w.workerId !== 'pia')
|
|
d.applyState(st)
|
|
assert.deepEqual([d.byId.kim.grey, d.byId.kim.pose, d.byId.pia.grey, d.byId.pia.pose, d.byId.bob.grey], [true, 'sleep', true, 'sleep', false])
|
|
assert.deepEqual([...look.greyRooms].sort(), ['kleinanzeigen', 'portale'])
|
|
})
|
|
|
|
test('Kennzahlen landen in look; neuer Pokal blinkt nur bei steigender Zahl, nicht beim ersten Snapshot', () => {
|
|
const { d, look } = setup(); d.applyState(makeState({ kpis: { pultOpen: 4, dealsMonth: 9, botLeads: 112 } }))
|
|
assert.deepEqual([look.pultOpen, look.dealsMonth, look.botLeads, look.trophyPop], [4, 9, 112, 0])
|
|
d.applyState(makeState({ kpis: { pultOpen: 4, dealsMonth: 10, botLeads: 112 } })); assert.ok(look.trophyPop > 0)
|
|
d.applyState(makeState({ paused: true })); assert.equal(look.paused, true)
|
|
d.applyState(makeState({ sendingHalted: true, sendingHaltedReason: 'Zwei harte Bounces' })); assert.equal(look.paused, false) // Notbremse (H4) ist keine Pause: kein Schleier, die Meldung zeigt das Board
|
|
})
|
|
|
|
test('Leerlauf: erst Kaffee, nach 25 s Schlaf; Pokal-Seiten blättern alle 6 s', () => {
|
|
const { d, look } = setup(); d.applyState(makeState({ statuses: { kim: 'leerlauf' }, kpis: { dealsMonth: 9 } }))
|
|
const step = (n) => { for (let i = 0; i < n; i++) d.update(0.1) }
|
|
step(70); assert.equal(look.trophyPage, 1) // 7 s: erste Blätterung bei 6 s
|
|
step(60); assert.equal(look.trophyPage, 0); assert.equal(d.byId.kim.pose, 'coffee') // 13 s: zweite Blätterung bei 12 s
|
|
step(140); assert.equal(d.byId.kim.pose, 'sleep') // 27 s > 25 s
|
|
})
|
|
|
|
test('drawAgents: Trefferflächen für alle 19, jeder ist anklickbar', () => {
|
|
const { d } = setup(); d.applyState(makeState({ connected: { kim: false }, statuses: { rita: 'fehler' } })); const { ctx } = makeCtx(); drawAgents(ctx, d, 'bob', 1)
|
|
const boxes = d.boxes(); assert.equal(boxes.length, 19)
|
|
for (const { id, box } of boxes) assert.equal(pickAgent(boxes, box.x + box.w / 2, box.y + box.h / 2), id, id)
|
|
})
|
|
|
|
test('Konstanten der Regie', () => {
|
|
assert.deepEqual([D.BACKLOG_KEEP, D.GROUPS_PER_AGENT, D.IDLE_COFFEE_S, D.STEP_TIMEOUT_S, D.BUBBLE_MAX], [6, 4, 25, 45, 3])
|
|
})
|
|
|
|
test('Agent hat alle Felder der Schnittstelle; Hut, Größe, Blickrichtung und Platz stimmen', () => {
|
|
const { d, layout } = setup(); d.applyState(makeState())
|
|
const felder = ['id', 'name', 'hat', 'scale', 'x', 'y', 'floor', 'facing', 'frame', 'pose', 'carrying', 'stackN', 'say', 'bubT', 'grey', 'alert', 'status', 'task', 'counters', 'lane', 'bob', 'idleT', 'cheer', 'q', 'cur', 'stepT', 'groups', 'box', 'home']
|
|
for (const a of d.agents) for (const f of felder) assert.ok(Object.hasOwn(a, f), `${a.id}.${f}`)
|
|
assert.deepEqual(d.agents.map((a) => a.id), [...IDS])
|
|
assert.deepEqual([d.byId.otto.hat, d.byId.otto.scale, d.byId.bob.hat, d.byId.paul.hat, d.byId.kim.hat, d.byId.kim.scale], ['overseer', 2, 'opus', 'sonnet', 'haiku', 1])
|
|
assert.deepEqual([d.byId.otto.name, d.byId.clara.name], ['Otto', 'Clara'])
|
|
assert.deepEqual(['ali', 'hanna', 'sven', 'lea', 'paul', 'clara'].map((id) => d.byId[id].facing), [-1, -1, -1, -1, -1, -1])
|
|
assert.deepEqual(['otto', 'rita', 'bea', 'arne'].map((id) => d.byId[id].facing), [1, 1, 1, 1])
|
|
assert.deepEqual(d.agents.map((a) => [a.floor, a.home]), d.agents.map((a) => [homeOf(layout, a.id).floor, homeOf(layout, a.id)]))
|
|
assert.deepEqual([d.byId.otto.lane, d.byId.bob.lane], [0, -2])
|
|
assert.equal(d.byId.constructor, undefined)
|
|
assert.equal(d.pending(), 0)
|
|
})
|
|
|
|
test('spätere Snapshots bewegen nie; Status, Pose und Aufgabe nur bei Agenten ohne laufende Gruppe', () => {
|
|
const { d } = setup(); d.applyState(makeState()); const kim = d.byId.kim
|
|
kim.x = 77; kim.y = 66
|
|
const st1 = makeState({ statuses: { kim: 'leerlauf' } }); st1.workers.find((w) => w.workerId === 'kim').task = 'Pause'; st1.workers.find((w) => w.workerId === 'kim').counters = { gelesen: 4 }
|
|
d.applyState(st1)
|
|
assert.deepEqual([kim.x, kim.y, kim.status, kim.pose, kim.task, kim.counters], [77, 66, 'leerlauf', 'coffee', 'Pause', { gelesen: 4 }])
|
|
// laufende Gruppe: der Status gilt sofort, Pose und Aufgabe kommen erst nach dem Ende der Gruppe
|
|
kim.groups = 1; kim.pose = 'type'; kim.task = 'alt'
|
|
const st2 = makeState({ statuses: { kim: 'fehler' } }); st2.workers.find((w) => w.workerId === 'kim').task = 'neu'
|
|
d.applyState(st2)
|
|
assert.deepEqual([kim.status, kim.alert, kim.pose, kim.task], ['fehler', true, 'type', 'alt'])
|
|
d.update(0.05); assert.equal(kim.pose, 'type')
|
|
kim.groups = 0; d.update(0.05); assert.equal(kim.pose, 'stand')
|
|
d.applyState(st2); assert.equal(kim.task, 'neu')
|
|
})
|
|
|
|
test('unbrauchbarer Zustand wirft nicht: alle grau und schlafend, keine Pause', () => {
|
|
for (const bad of [null, undefined, {}, 'x', { workers: 'x' }, { workers: [null, 5, { workerId: 7 }] }]) {
|
|
const { d, look } = setup(); d.applyState(makeState({ paused: true })); d.applyState(bad)
|
|
assert.deepEqual([d.agents.every((a) => a.grey && a.pose === 'sleep' && a.status === 'grau'), look.paused, look.greyRooms.size], [true, false, 19], String(bad))
|
|
}
|
|
})
|
|
|
|
test('busyRooms: Räume der arbeitenden Worker; graue und ruhende gehören nicht dazu', () => {
|
|
const { d, look } = setup(); d.applyState(makeState({ statuses: { kim: 'leerlauf', bea: 'wartet', paul: 'fehler' }, connected: { pia: false } }))
|
|
assert.equal(look.busyRooms.has('bruecke'), true)
|
|
for (const room of ['kleinanzeigen', 'portale', 'waage', 'pruefung']) assert.equal(look.busyRooms.has(room), false, room)
|
|
assert.equal(look.busyRooms.size, 19 - 4)
|
|
})
|
|
|
|
test('Kennzahlen: fehlende Werte lassen look stehen und lösen kein Blinken aus; Rückgang blinkt nicht', () => {
|
|
const { d, look } = setup(); d.applyState(makeState({ kpis: { pultOpen: 4, dealsMonth: 9, botLeads: 112 } }))
|
|
const bare = makeState(); delete bare.kpis; d.applyState(bare)
|
|
assert.deepEqual([look.pultOpen, look.dealsMonth, look.botLeads, look.trophyPop], [4, 9, 112, 0])
|
|
d.applyState(makeState({ kpis: { dealsMonth: 'x', pultOpen: NaN, botLeads: null } })); assert.deepEqual([look.pultOpen, look.dealsMonth, look.botLeads, look.trophyPop], [4, 9, 112, 0])
|
|
d.applyState(makeState({ kpis: { dealsMonth: 9 } })); assert.equal(look.trophyPop, 0)
|
|
d.applyState(makeState({ kpis: { dealsMonth: 9.8, pultOpen: -3, botLeads: 112.9 } })); assert.deepEqual([look.dealsMonth, look.pultOpen, look.botLeads, look.trophyPop], [9, 0, 112, 0]) // ganze Zahlen, nie negativ
|
|
d.applyState(makeState({ kpis: { dealsMonth: 2 } })); assert.deepEqual([look.dealsMonth, look.trophyPop], [2, 0])
|
|
d.applyState(makeState({ kpis: { dealsMonth: 3 } })); assert.equal(look.trophyPop, 1.2)
|
|
// ein Zustand ohne Kennzahlen beim ersten Snapshot zählt nicht als erster Wert
|
|
const b = setup(); b.d.applyState(bare); b.d.applyState(makeState({ kpis: { dealsMonth: 9 } })); assert.equal(b.look.trophyPop, 0)
|
|
})
|
|
|
|
test('update: Pokal-Blinken und Tresor-Blitz zählen herunter; Pause friert alles ein', () => {
|
|
const { d, look, fx } = setup(); d.applyState(makeState({ kpis: { dealsMonth: 1 } })); d.applyState(makeState({ kpis: { dealsMonth: 2 } })); look.vaultFlash = 0.7
|
|
let ended = 0; fx.add(0.4, () => {}, () => { ended += 1 })
|
|
step(d, 5); assert.ok(look.trophyPop < 1.2 && look.trophyPop > 0.6); assert.ok(look.vaultFlash < 0.7 && look.vaultFlash > 0.1); assert.equal(ended, 1)
|
|
step(d, 20); assert.deepEqual([look.trophyPop, look.vaultFlash], [0, 0])
|
|
const kim = d.byId.kim; d.applyState(makeState({ statuses: { kim: 'leerlauf' }, paused: true })); look.pageT = 0
|
|
const before = [kim.idleT, look.pageT]; step(d, 100); assert.deepEqual([kim.idleT, look.pageT], before)
|
|
d.applyState(makeState({ statuses: { kim: 'leerlauf' }, paused: false })); step(d, 10); assert.ok(kim.idleT > 0.9)
|
|
})
|
|
|
|
test('update: ungültiges dt wird ignoriert; der Schlaf kehrt mit dem Status zurück', () => {
|
|
const { d } = setup(); d.applyState(makeState({ statuses: { kim: 'leerlauf' } }))
|
|
for (const dt of [NaN, undefined, 0, -1, Infinity]) d.update(dt)
|
|
assert.equal(d.byId.kim.idleT, 0)
|
|
step(d, 260); assert.equal(d.byId.kim.pose, 'sleep')
|
|
d.applyState(makeState({ statuses: { kim: 'arbeitet' } })); d.update(0.1); assert.deepEqual([d.byId.kim.idleT, d.byId.kim.pose], [0, 'type'])
|
|
d.applyState(makeState({ statuses: { kim: 'leerlauf' } })); step(d, 10); assert.equal(d.byId.kim.pose, 'coffee')
|
|
})
|
|
|
|
test('Wippen: nur wer am Platz tippt, wippt um einen Pixel; Jubel hüpft um zwei; unterwegs gilt die Spur 0', () => {
|
|
const { d } = setup(); d.applyState(makeState()); const seen = new Set()
|
|
for (let i = 0; i < 40; i++) { d.update(0.1); seen.add(d.byId.bob.bob) }
|
|
assert.deepEqual([...seen].sort(), [-1, 0])
|
|
assert.equal(d.byId.arne.pose, 'type')
|
|
d.applyState(makeState({ statuses: { bob: 'wartet' } })); d.update(0.1); assert.equal(d.byId.bob.bob, 0)
|
|
d.byId.otto.cheer = 0.5; const jubel = new Set(); for (let i = 0; i < 4; i++) { d.update(0.1); jubel.add(d.byId.otto.bob) }
|
|
assert.ok(jubel.has(-2) && jubel.has(0)); step(d, 3); assert.equal(d.byId.otto.cheer, 0)
|
|
// Spur: am Platz -2 (außer Otto), unterwegs gleitet sie auf 0
|
|
const kim = d.byId.kim; assert.equal(kim.lane, -2); kim.x += 30; kim.frame = 1; const unterwegs = new Set(); for (let i = 0; i < 20; i++) { d.update(0.1); unterwegs.add(kim.bob) }
|
|
assert.deepEqual([kim.lane, [...unterwegs]], [0, [0]]); kim.x -= 30; kim.frame = 0; d.update(0.05); assert.ok(kim.lane < 0 && kim.lane > -1)
|
|
step(d, 3); assert.equal(kim.lane, -2)
|
|
})
|
|
|
|
test('bubble: auf 20 Zeichen gekürzt, nach 2,2 s weg, höchstens drei fremde gleichzeitig, leer und unbekannt ignoriert', () => {
|
|
const { d } = setup(); d.applyState(makeState())
|
|
assert.equal(d.bubble(d.byId.kim, 'Dies ist ein sehr langer Satz'), true); assert.equal(d.byId.kim.say, 'Dies ist ein sehr la')
|
|
assert.equal(d.bubble(d.byId.rita, 'Eins'), true); assert.equal(d.bubble(d.byId.pia, 'Zwei'), true)
|
|
assert.equal(d.bubble(d.byId.finn, 'Drei'), false); assert.equal(d.byId.finn.say, null)
|
|
assert.equal(d.bubble(d.byId.kim, 'Neu'), true); assert.equal(d.byId.kim.say, 'Neu') // der Sprecher selbst zählt nicht mit
|
|
assert.deepEqual([d.bubble(d.byId.kim, ''), d.bubble(d.byId.kim, 42), d.bubble(null, 'x')], [false, false, false])
|
|
step(d, 20); assert.equal(d.byId.kim.say, 'Neu'); step(d, 5); assert.deepEqual(d.agents.filter((a) => a.say), [])
|
|
assert.equal(d.bubble(d.byId.finn, 'Jetzt'), true)
|
|
d.bubble(d.byId.ali, 'Lang', 5); step(d, 30); assert.equal(d.byId.ali.say, 'Lang'); step(d, 25); assert.equal(d.byId.ali.say, null)
|
|
})
|
|
|
|
test('drawAgents: y-sortiert, jede Figur genau einmal, Trefferfläche aus der Zeichnung', () => {
|
|
const { d } = setup(); d.applyState(makeState()); const m = draw(d)
|
|
const tiefen = d.boxes().map(({ id }) => depth(d.byId[id]))
|
|
assert.deepEqual(tiefen, [...tiefen].sort((a, b) => a - b))
|
|
assert.equal(new Set(d.boxes().map((b) => b.id)).size, 19)
|
|
assert.ok(m.rects.length > 19 * 40)
|
|
const otto = d.byId.otto; assert.deepEqual([otto.box.w, otto.box.h], [24, 32])
|
|
const e = setup(); assert.deepEqual(e.d.boxes(), []) // vor dem ersten Zeichnen gibt es keine Flächen
|
|
})
|
|
|
|
test('drawAgents: gezeichnet wird von hinten nach vorn, nicht in Listenreihenfolge', () => {
|
|
const kleine = (m) => m.rects.map((r, i) => (r.w === 3 && r.h === 3 ? i : -1)).filter((i) => i >= 0) // Zellen der normalen Figuren (Raster 3)
|
|
const grosse = (m) => m.rects.map((r, i) => (r.w === 6 && r.h === 6 ? i : -1)).filter((i) => i >= 0) // Zellen von Otto (Maßstab 2)
|
|
const { d } = setup(); d.applyState(makeState())
|
|
const oben = draw(d); assert.ok(Math.max(...grosse(oben)) < Math.max(...kleine(oben)), 'Otto steht oben und wird zuerst gezeichnet')
|
|
d.byId.otto.y = 300
|
|
const unten = draw(d); assert.ok(Math.min(...grosse(unten)) > Math.max(...kleine(unten)), 'Otto steht jetzt vor allen anderen')
|
|
assert.equal(d.boxes().at(-1).id, 'otto')
|
|
})
|
|
|
|
test('drawAgents: „!“ nur bei Fehler, Auswahlpfeil nur beim gewählten, Stapel nur bei mehreren Papieren', () => {
|
|
const { d } = setup(); d.applyState(makeState())
|
|
assert.equal(rectsOf(draw(d), PAL.red).length, 0)
|
|
assert.equal(rectsOf(draw(d), PAL.ink).length, 0)
|
|
d.applyState(makeState({ statuses: { bea: 'fehler' } })); assert.ok(rectsOf(draw(d), PAL.red).length > 0)
|
|
const rot = rectsOf(draw(d), PAL.red), bea = d.byId.bea
|
|
assert.equal(Math.max(...rot.map((r) => r.y + r.h)) + 3, (bea.y + bea.lane - 2) * 3, 'Unterkante des „!“ (mit Umriss) steht auf der Kopfoberkante')
|
|
assert.equal(rectsOf(draw(d, 'bob'), PAL.ink).length, 9)
|
|
const papier = (n, carrying = true) => { d.byId.kim.carrying = carrying; d.byId.kim.stackN = n; return draw(d).rects.filter((r) => r.fill === PAL.g).length }
|
|
const eins = papier(1); assert.ok(papier(2) > eins); assert.ok(papier(5) > papier(2)); assert.equal(papier(5, false), papier(1, false))
|
|
})
|
|
|
|
test('drawAgents: graue Figuren halbdurchsichtig, die Zeichnung lässt save/restore im Gleichgewicht', () => {
|
|
const { d } = setup(); d.applyState(makeState({ connected: { kim: false, pia: false } })); const m = draw(d)
|
|
assert.equal(m.alphas.filter((a) => a === 0.55).length, 2); assert.equal(m.counts.save, m.counts.restore)
|
|
})
|
|
|
|
test('drawAgents: Blasen zuletzt; Otto seitlich; außerhalb des Bildes keine Blase', () => {
|
|
const { d } = setup(); d.applyState(makeState()); d.bubble(d.byId.kim, 'Hallo'); d.bubble(d.byId.otto, 'Deal! Super!')
|
|
const m = draw(d); assert.deepEqual(m.texts.map((t) => t.text).sort(), ['Deal! Super!', 'Hallo'])
|
|
const weiss = m.rects.map((r, i) => [r, i]).filter(([r]) => r.fill === PAL.w && r.w > 20)
|
|
assert.equal(weiss.length, 2); for (const [, i] of weiss) assert.ok(m.rects.length - i <= 4 + 4, 'Blase liegt am Ende der Zeichnung')
|
|
// Otto: die Blase steht neben ihm, nicht über dem Kopf (Spitze liegt links von seiner linken Kante oder rechts von der rechten)
|
|
const otto = d.byId.otto, os = m.texts.find((t) => t.text === 'Deal! Super!'), kimText = m.texts.find((t) => t.text === 'Hallo')
|
|
assert.ok(os.x < otto.x * 3 - 20 || os.x > (otto.x + 24) * 3); assert.ok(os.y > otto.y * 3)
|
|
assert.ok(kimText.y < d.byId.kim.y * 3)
|
|
const kim = d.byId.kim, spitze = m.rects.at(-1); assert.equal(spitze.y + spitze.h, (kim.y + kim.lane - 2) * 3 + 1, 'Spitze steht auf der Kopfoberkante (Hut)')
|
|
d.byId.kim.x = -10; d.byId.rita.x = 330; d.bubble(d.byId.rita, 'Rechts'); const aus = draw(d); assert.deepEqual(aus.texts.map((t) => t.text).sort(), ['Deal! Super!'])
|
|
})
|
|
|
|
test('drawAgents: die Blase weicht dem „!“ und dem Auswahlpfeil aus', () => {
|
|
const { d } = setup(); d.applyState(makeState({ statuses: { kim: 'fehler' } })); d.bubble(d.byId.kim, 'Kim'); d.bubble(d.byId.rita, 'Rita')
|
|
const textY = (m, text) => m.texts.find((t) => t.text === text).y
|
|
const m = draw(d)
|
|
assert.equal(d.byId.kim.y, d.byId.rita.y)
|
|
assert.ok(textY(m, 'Rita') - textY(m, 'Kim') >= 27) // das „!“ ist 9 Einheiten hoch (Raster 3)
|
|
assert.equal(textY(m, 'Rita') - textY(draw(d, 'rita'), 'Rita'), 18) // der Pfeil nimmt 6 Einheiten
|
|
})
|