337 lines
16 KiB
JavaScript
337 lines
16 KiB
JavaScript
import test from 'node:test'
|
||
import assert from 'node:assert/strict'
|
||
import { loadModule } from './load.mjs'
|
||
import { makeCtx } from './helpers/fakeCtx.mjs'
|
||
|
||
// Räume nach kind, Pokal-Seiten, graue Räume und Gebäudehülle (Quelle: entwuerfe/scene-turm.js Z. 99-314)
|
||
const R = await loadModule('src/components/workers/engine/rooms.js')
|
||
const B = await loadModule('src/components/workers/engine/building.js')
|
||
const { buildLayout, ROOM_META } = await loadModule('src/components/workers/engine/layout.js')
|
||
const { PAL, TEAM } = await loadModule('src/components/workers/engine/sprites.js')
|
||
const { FLOOR_TITLES, ROOM_TITLES } = await loadModule('src/lib/workersRoster.js')
|
||
|
||
const layout = buildLayout()
|
||
const draw = (look, t = 1) => {
|
||
const m = makeCtx()
|
||
R.drawRooms(m.ctx, layout, t, look)
|
||
return m
|
||
}
|
||
const SIGN = 'noch nicht angeschlossen'
|
||
const looks = (patch = {}) => Object.assign(R.createLook(), patch)
|
||
const count = (rects, fill) => rects.filter((r) => r.fill === fill).length
|
||
// Pokale sind die 7 × 3 großen Goldflächen (k = 3: 21 × 9 Geräte-Pixel)
|
||
const trophies = (look) => draw(look).rects.filter((r) => r.fill === PAL.gold && r.w === 21 && r.h === 9).length
|
||
|
||
test('trophyPaging: 8 je Seite, Seite wird geklemmt', () => {
|
||
assert.deepEqual(R.trophyPaging(0, 0), { shown: 0, page: 0, pages: 1, from: 0 })
|
||
assert.deepEqual(R.trophyPaging(8, 0), { shown: 8, page: 0, pages: 1, from: 0 })
|
||
assert.deepEqual(R.trophyPaging(9, 1), { shown: 1, page: 1, pages: 2, from: 8 })
|
||
assert.deepEqual(R.trophyPaging(9, 5), { shown: 1, page: 1, pages: 2, from: 8 })
|
||
assert.deepEqual(R.trophyPaging(25, -1), { shown: 8, page: 0, pages: 4, from: 0 })
|
||
})
|
||
|
||
test('alle 21 Räume zeichnen, jeder Titel erscheint', () => {
|
||
const { texts, rects } = draw(R.createLook())
|
||
assert.ok(rects.length > 300)
|
||
for (const title of Object.values(ROOM_TITLES)) assert.ok(texts.some((x) => x.text === title), title)
|
||
})
|
||
|
||
test('graue Räume tragen das Schild, sonst keins (Review Focus 4)', () => {
|
||
const look = R.createLook()
|
||
look.greyRooms = new Set(['kleinanzeigen', 'portale'])
|
||
assert.equal(draw(look).texts.filter((x) => x.text === SIGN).length, 2)
|
||
assert.equal(draw(R.createLook()).texts.filter((x) => x.text === SIGN).length, 0)
|
||
})
|
||
|
||
test('Pult-Zahl, Pokal- und Bot-Lead-Zähler', () => {
|
||
const look = R.createLook()
|
||
look.pultOpen = 7
|
||
look.dealsMonth = 9
|
||
look.botLeads = 112
|
||
const t = draw(look).texts.map((x) => x.text)
|
||
assert.ok(t.includes('7'))
|
||
assert.ok(t.includes('9 Deals'))
|
||
assert.ok(t.includes('112 Bot-Leads'))
|
||
assert.ok(!draw(R.createLook()).texts.some((x) => x.text === '7'))
|
||
})
|
||
|
||
test('Gebäude: Etagenschilder, Lampen, Pausenschleier', () => {
|
||
const m = makeCtx()
|
||
B.drawTower(m.ctx, layout, 1, { at: (i) => i === 3 })
|
||
for (const title of Object.values(FLOOR_TITLES)) assert.ok(m.texts.some((x) => x.text === title), title)
|
||
const on = makeCtx()
|
||
const look = R.createLook()
|
||
look.paused = true
|
||
B.drawPauseVeil(on.ctx, look)
|
||
assert.ok(on.texts.some((x) => x.text === 'Pausiert'))
|
||
const off = makeCtx()
|
||
B.drawPauseVeil(off.ctx, R.createLook())
|
||
assert.equal(off.texts.length, 0)
|
||
B.drawOutside(makeCtx().ctx)
|
||
})
|
||
|
||
// ---- Ergänzungen: Verhalten, das die fünf Tests oben nicht berühren ----
|
||
|
||
test('createLook: Ausgangszustand ohne gemeinsame Mengen zwischen zwei Aufrufen', () => {
|
||
const a = R.createLook()
|
||
const b = R.createLook()
|
||
assert.ok(a.greyRooms instanceof Set && a.busyRooms instanceof Set)
|
||
assert.equal(a.greyRooms.size + a.busyRooms.size, 0)
|
||
assert.deepEqual({ ...a, greyRooms: 0, busyRooms: 0 }, { greyRooms: 0, busyRooms: 0, pultOpen: 0, dealsMonth: 0, botLeads: 0, trophyPage: 0, pageT: 0, trophyPop: 0, vaultFlash: 0, paused: false })
|
||
a.busyRooms.add('netz')
|
||
assert.equal(b.busyRooms.size, 0)
|
||
})
|
||
|
||
test('ROOM_DRAWERS: eine Zeichnung für jede Raumart des Layouts, eingefroren', () => {
|
||
const kinds = new Set(Object.values(ROOM_META).map((m) => m.kind))
|
||
assert.equal(kinds.size, 16)
|
||
for (const kind of kinds) assert.equal(typeof R.ROOM_DRAWERS[kind], 'function', kind)
|
||
assert.ok(Object.isFrozen(R.ROOM_DRAWERS))
|
||
})
|
||
|
||
test('jeder Raum zeichnet sichtbaren Inhalt über Tint und Titel hinaus (kein leerer Raum)', () => {
|
||
// Rechtecke je Raum zählen: Raum für Raum in ein eigenes Layout mit nur dieser Etage
|
||
for (const floor of layout.floors) {
|
||
for (const room of floor.rooms) {
|
||
const single = { ...layout, floors: [{ ...floor, rooms: [room] }] }
|
||
const m = makeCtx()
|
||
R.drawRooms(m.ctx, single, 1, R.createLook())
|
||
assert.ok(m.rects.length >= 5, room.id)
|
||
}
|
||
}
|
||
})
|
||
|
||
test('trophyPaging: ungültige Werte fallen auf eine leere erste Seite zurück', () => {
|
||
const empty = { shown: 0, page: 0, pages: 1, from: 0 }
|
||
assert.deepEqual(R.trophyPaging(NaN, NaN), empty)
|
||
assert.deepEqual(R.trophyPaging(undefined, undefined), empty)
|
||
assert.deepEqual(R.trophyPaging(-4, 2), empty)
|
||
assert.deepEqual(R.trophyPaging(16, 1), { shown: 8, page: 1, pages: 2, from: 8 })
|
||
assert.deepEqual(R.trophyPaging(5, 0, 2), { shown: 2, page: 0, pages: 3, from: 0 })
|
||
})
|
||
|
||
test('Pokalbrett zeigt die gewählte Seite; der neueste Pokal blinkt bei trophyPop', () => {
|
||
assert.equal(trophies(looks()), 0)
|
||
assert.equal(trophies(looks({ dealsMonth: 3 })), 3)
|
||
assert.equal(trophies(looks({ dealsMonth: 20 })), 8)
|
||
assert.equal(trophies(looks({ dealsMonth: 9, trophyPage: 1 })), 1)
|
||
assert.equal(trophies(looks({ dealsMonth: 9, trophyPage: 7 })), 1)
|
||
// floor(0.25 * 10) = 2 -> gerade: sichtbar; floor(0.15 * 10) = 1 -> ungerade: der neueste Pokal fehlt
|
||
assert.equal(trophies(looks({ dealsMonth: 3, trophyPop: 0.25 })), 3)
|
||
assert.equal(trophies(looks({ dealsMonth: 3, trophyPop: 0.15 })), 2)
|
||
})
|
||
|
||
test('Tresor blitzt Gold bei vaultFlash, sonst nicht', () => {
|
||
const gold = (look) => draw(look).alphas.filter((a) => a > 0.1).length
|
||
assert.ok(gold(looks({ vaultFlash: 0.7 })) > gold(looks()))
|
||
})
|
||
|
||
test('Pult-Zahl: 0 zeigt keine Zahl, ab 100 steht 99+', () => {
|
||
const nums = (n) => draw(looks({ pultOpen: n })).texts.map((x) => x.text).filter((x) => /^\d+\+?$/.test(x))
|
||
assert.deepEqual(nums(0), [])
|
||
assert.deepEqual(nums(120), ['99+'])
|
||
assert.deepEqual(nums(99), ['99'])
|
||
})
|
||
|
||
test('Zähler zeigen immer ihre Zahl, auch 0', () => {
|
||
const t = draw(R.createLook()).texts.map((x) => x.text)
|
||
assert.ok(t.includes('0 Deals'))
|
||
assert.ok(t.includes('0 Bot-Leads'))
|
||
})
|
||
|
||
test('Monitore laufen nur in Räumen aus busyRooms', () => {
|
||
const lines = (look) => count(draw(look).rects, TEAM.aerzte)
|
||
const idle = lines(looks())
|
||
const busy = lines(looks({ busyRooms: new Set(['aerzte']) }))
|
||
assert.ok(busy > idle)
|
||
// ein anderer Raum arbeitet: Ärzte & Praxen bleibt dunkel
|
||
assert.equal(lines(looks({ busyRooms: new Set(['handwerk']) })), idle)
|
||
})
|
||
|
||
test('graue Räume: Monitor aus trotz busyRooms, pult und tresor werden nie grau', () => {
|
||
const lines = (look) => count(draw(look).rects, TEAM.aerzte)
|
||
const grey = looks({ greyRooms: new Set(['aerzte']), busyRooms: new Set(['aerzte']) })
|
||
const greyIdle = looks({ greyRooms: new Set(['aerzte']) })
|
||
assert.equal(lines(grey), lines(greyIdle))
|
||
const never = looks({ greyRooms: new Set(['pult', 'tresor', 'gibt-es-nicht']) })
|
||
assert.equal(draw(never).texts.filter((x) => x.text === SIGN).length, 0)
|
||
})
|
||
|
||
test('Schild steht innerhalb des grauen Raums und in der Etage seiner Figur', () => {
|
||
const look = looks({ greyRooms: new Set(['kleinanzeigen']) })
|
||
const m = draw(look)
|
||
const sign = m.texts.find((x) => x.text === SIGN)
|
||
const floor = layout.floors.find((f) => f.id === 'anfragen')
|
||
const room = floor.rooms.find((r) => r.id === 'kleinanzeigen')
|
||
// Mitte des Raums (k = 3, align center), Zeile innerhalb der Etage
|
||
assert.equal(sign.x, Math.round((room.x + room.w / 2) * 3))
|
||
assert.ok(sign.y >= floor.top * 3 && sign.y < floor.floorY * 3)
|
||
})
|
||
|
||
test('unbekannte Raumart zeichnet nur Titel und Tint, ohne Wurf', () => {
|
||
const odd = { ...layout, floors: layout.floors.map((f) => ({ ...f, rooms: f.rooms.map((r) => ({ ...r, kind: 'gibt-es-nicht' })) })) }
|
||
const m = makeCtx()
|
||
assert.doesNotThrow(() => R.drawRooms(m.ctx, odd, 1, R.createLook()))
|
||
assert.ok(m.texts.some((x) => x.text === ROOM_TITLES.netz))
|
||
})
|
||
|
||
test('drawRooms hält save/restore im Gleichgewicht', () => {
|
||
const m = draw(looks({ greyRooms: new Set(['netz']), pultOpen: 3, dealsMonth: 2 }))
|
||
assert.equal(m.counts.save, m.counts.restore)
|
||
})
|
||
|
||
test('Gebäude: Bodenlinie liegt auf dem Boden der Tresor-Etage (y 224)', () => {
|
||
const tresor = layout.floors.find((f) => f.id === 'tresor')
|
||
assert.equal(tresor.floorY, 224)
|
||
const m = makeCtx()
|
||
B.drawOutside(m.ctx)
|
||
// k = 3: volle Breite 960, eine logische Einheit hoch, auf y 672
|
||
assert.ok(m.rects.some((r) => r.x === 0 && r.y === 224 * 3 && r.w === 960 && r.h === 3))
|
||
// Erde unter der Bodenlinie, bis zum Weltrand
|
||
assert.ok(m.rects.some((r) => r.y === 225 * 3 && r.h === (256 - 225) * 3))
|
||
})
|
||
|
||
test('Gebäude: Lampe der Etage mit Kabine leuchtet grün, keine ohne Kabine', () => {
|
||
const green = (at) => {
|
||
const m = makeCtx()
|
||
B.drawTower(m.ctx, layout, 1, { at })
|
||
return count(m.rects, PAL.green)
|
||
}
|
||
const none = green(() => false)
|
||
assert.equal(green((i) => i === 3), none + 1)
|
||
assert.equal(green((i) => i === 0 || i === 9), none + 2)
|
||
})
|
||
|
||
test('Gebäude: Etagenschilder rechts außen bei x 234, in der Zeile ihrer Etage', () => {
|
||
const m = makeCtx()
|
||
B.drawTower(m.ctx, layout, 1, { at: () => false })
|
||
for (const floor of layout.floors) {
|
||
const sign = m.texts.find((x) => x.text === floor.title)
|
||
assert.equal(sign.x, 234 * 3, floor.id)
|
||
assert.ok(sign.y >= floor.top * 3 && sign.y < floor.floorY * 3, floor.id)
|
||
}
|
||
})
|
||
|
||
test('Gebäude: Hülle reicht bis zum Fundament der letzten Etage', () => {
|
||
const m = makeCtx()
|
||
B.drawTower(m.ctx, layout, 1, { at: () => false })
|
||
const last = layout.floors[layout.floors.length - 1]
|
||
const bottom = Math.max(...m.rects.map((r) => (r.y + r.h) / 3))
|
||
assert.equal(bottom, last.floorY + 2)
|
||
assert.ok(m.rects.every((r) => r.x >= 0 && (r.x + r.w) / 3 <= 320))
|
||
})
|
||
|
||
test('Pausenschleier: 45 % Weiß über der ganzen Welt, Aufrufe gleichen sich aus', () => {
|
||
const m = makeCtx()
|
||
B.drawPauseVeil(m.ctx, looks({ paused: true }))
|
||
assert.ok(m.alphas.includes(0.45))
|
||
const veil = m.rects.find((r) => r.fill === PAL.w)
|
||
assert.ok(veil.x <= 0 && veil.y <= 0 && veil.x + veil.w >= 960 && veil.y + veil.h >= 768)
|
||
assert.equal(m.counts.save, m.counts.restore)
|
||
const off = makeCtx()
|
||
B.drawPauseVeil(off.ctx, R.createLook())
|
||
assert.equal(off.rects.length, 0)
|
||
})
|
||
|
||
test('Gebäude: Layout ohne Etagen zeichnet nichts und wirft nicht', () => {
|
||
const m = makeCtx()
|
||
assert.doesNotThrow(() => B.drawTower(m.ctx, { floors: [], homes: {}, spots: {} }, 1, { at: () => false }))
|
||
assert.doesNotThrow(() => R.drawRooms(m.ctx, { floors: [], homes: {}, spots: {} }, 1, R.createLook()))
|
||
})
|
||
|
||
// ---- Fix-Runde 1: Zeichnung und Effektorte, graue Räume ----
|
||
|
||
// Rechtecke der Raumzeichnung, die den Mittelpunkt der Einheitszelle (x, y) überdecken; die Tönung, die den ganzen Raum füllt, zählt nicht
|
||
const hitsAt = (floorId, spot, look = R.createLook()) => {
|
||
const floor = layout.floors.find((f) => f.id === floorId)
|
||
const full = Math.max(...floor.rooms.map((r) => r.w)) * 3
|
||
const m = makeCtx()
|
||
R.drawRooms(m.ctx, { ...layout, floors: [floor] }, 1, look)
|
||
const cx = spot.x * 3 + 1
|
||
const cy = spot.y * 3 + 1
|
||
return m.rects.filter((r) => r.w < full && cx >= r.x && cx < r.x + r.w && cy >= r.y && cy < r.y + r.h)
|
||
}
|
||
|
||
test('Zeichnung trifft den Spot: Briefkasten am Pult, Spitze genau bei spots.pult', () => {
|
||
const spot = layout.spots.pult
|
||
assert.ok(hitsAt('freigabe', spot).some((r) => r.fill === TEAM.freigabe), 'Briefkasten unter dem Spot')
|
||
// Spitze: eine Zeile darüber ist kein Briefkasten mehr
|
||
assert.ok(!hitsAt('freigabe', { x: spot.x, y: spot.y - 1 }).some((r) => r.fill === TEAM.freigabe))
|
||
})
|
||
|
||
test('Zeichnung trifft den Spot: Tresortür in der Mitte von spots.tresor', () => {
|
||
const hit = hitsAt('tresor', layout.spots.tresor)
|
||
assert.ok(hit.some((r) => r.fill === PAL.metal2 && r.w === 22 * 3 && r.h === 20 * 3), 'Tresorkörper unter dem Spot')
|
||
// die 6 × 6 große Türplatte (x + 8 ... x + 14) umschließt den Spot
|
||
assert.ok(hit.some((r) => r.fill === PAL.metal && r.w === 6 * 3 && r.h === 6 * 3), 'Türplatte unter dem Spot')
|
||
})
|
||
|
||
test('Zeichnung trifft den Spot: Schublade eines Aktenschranks bei spots.archiv, nicht auf Arne', () => {
|
||
const spot = layout.spots.archiv
|
||
const hit = hitsAt('keller', spot)
|
||
// oberste Schubladenfront (10 × 5) des ersten Aktenschranks
|
||
assert.ok(hit.some((r) => r.fill === PAL.metal && r.w === 10 * 3 && r.h === 5 * 3), 'Schubladenfront unter dem Spot')
|
||
assert.ok(hit.some((r) => r.fill === PAL.metal2 && r.w === 12 * 3), 'Schrankkorpus unter dem Spot')
|
||
// Arnes Platz (Körper 12 breit, 14 hoch, Hut ab y - 2) liegt nicht auf dem Spot
|
||
const arne = layout.homes.arne
|
||
assert.ok(!(spot.x >= arne.x && spot.x < arne.x + 12 && spot.y >= arne.y - 2 && spot.y < arne.y + 14))
|
||
})
|
||
|
||
test('grauer Raum: Teamfarbton bleibt, das Schild ersetzt den Titel (kein Platz für beides)', () => {
|
||
const floor = layout.floors.find((f) => f.id === 'anfragen')
|
||
const room = floor.rooms.find((r) => r.id === 'kleinanzeigen')
|
||
assert.equal(room.w, 46)
|
||
const run = (look) => {
|
||
const m = makeCtx()
|
||
R.drawRooms(m.ctx, { ...layout, floors: [{ ...floor, rooms: [room] }] }, 1, look)
|
||
return m
|
||
}
|
||
const normal = run(looks())
|
||
const grey = run(looks({ greyRooms: new Set(['kleinanzeigen']) }))
|
||
const tintRects = (m) => m.rects.filter((r) => r.fill === TEAM[room.team] && r.w === room.w * 3 && r.h === floor.h * 3)
|
||
assert.equal(tintRects(normal).length, 1)
|
||
assert.equal(tintRects(grey).length, 1, 'Teamfarbton auch im grauen Raum')
|
||
assert.ok(grey.alphas.includes(0.1) && grey.alphas.includes(0.45), 'Teamfarbton 0,10, darüber die Grautönung 0,45')
|
||
assert.ok(normal.texts.some((x) => x.text === room.title))
|
||
assert.ok(!grey.texts.some((x) => x.text === room.title), 'im grauen Raum steht das Schild an der Stelle des Titels')
|
||
assert.equal(grey.texts.filter((x) => x.text === SIGN).length, 1)
|
||
assert.equal(normal.texts.filter((x) => x.text === SIGN).length, 0)
|
||
})
|
||
|
||
test('Schilder: drawRooms mit signs: false lässt sie aus (Grautönung bleibt), drawSigns zeichnet genau diese Schilder an dieselbe Stelle', () => {
|
||
const look = looks({ greyRooms: new Set(['kleinanzeigen', 'portale']) })
|
||
const withSigns = draw(look)
|
||
const m = makeCtx()
|
||
R.drawRooms(m.ctx, layout, 1, look, { signs: false })
|
||
assert.equal(m.texts.filter((x) => x.text === SIGN).length, 0)
|
||
assert.equal(m.rects.length < withSigns.rects.length, true)
|
||
assert.ok(m.alphas.includes(0.45), 'die Grautönung gehört weiter zum Raum')
|
||
assert.deepEqual(m.texts.filter((x) => x.text !== SIGN).map((x) => x.text), withSigns.texts.filter((x) => x.text !== SIGN).map((x) => x.text))
|
||
const s = makeCtx()
|
||
R.drawSigns(s.ctx, layout, look)
|
||
assert.deepEqual(s.texts.map((x) => x.text), [SIGN, SIGN])
|
||
assert.deepEqual(s.texts.map((x) => [x.x, x.y]), withSigns.texts.filter((x) => x.text === SIGN).map((x) => [x.x, x.y]))
|
||
const none = makeCtx()
|
||
R.drawSigns(none.ctx, layout, R.createLook())
|
||
assert.equal(none.rects.length + none.texts.length, 0)
|
||
const noWorker = makeCtx()
|
||
R.drawSigns(noWorker.ctx, layout, looks({ greyRooms: new Set(['pult', 'tresor']) })) // Räume ohne Worker werden nie grau
|
||
assert.equal(noWorker.texts.length, 0)
|
||
})
|
||
|
||
test('Raumtitel: über den Möbeln gezeichnet (ein Monitor deckt sie nicht zu) und mit hellem Rand', () => {
|
||
const floor = layout.floors.find((f) => f.id === 'gespraeche')
|
||
const room = floor.rooms.find((r) => r.id === 'mail')
|
||
const m = makeCtx()
|
||
R.drawRooms(m.ctx, { ...layout, floors: [{ ...floor, rooms: [room] }] }, 1, R.createLook())
|
||
assert.equal(m.strokes.length, 1)
|
||
assert.equal(m.strokes[0].text, room.title)
|
||
assert.ok(m.strokes[0].style.startsWith('rgba(255, 255, 255'))
|
||
assert.equal(m.strokes[0].rects, m.rects.length, 'nach dem Titel kommt keine Fläche mehr: Möbel, Tisch und Monitor liegen darunter')
|
||
assert.ok(m.rects.length > 20)
|
||
assert.equal(m.texts.filter((x) => x.text === room.title).length, 1)
|
||
const grey = makeCtx()
|
||
R.drawRooms(grey.ctx, { ...layout, floors: [{ ...floor, rooms: [{ ...room, id: 'kleinanzeigen' }] }] }, 1, looks({ greyRooms: new Set(['kleinanzeigen']) }))
|
||
assert.equal(grey.strokes.length, 0, 'im grauen Raum steht kein Titel')
|
||
})
|