395 lines
23 KiB
JavaScript
395 lines
23 KiB
JavaScript
// test/render/board3d.test.js — the official 3D board scene (DESIGN §15, public/js/render/board3d): the atlas surface
|
||
// table, the OBJ reader, the geometry builder (heights agree with the Pixi layers, areas per phase, gates, devices,
|
||
// fences, terrain, sane buffers), the board-space conversion of the official meshes, the asset pack loader (fake
|
||
// store), and the three.js scene graph built with the real three package and a stub renderer (no WebGL in Node).
|
||
|
||
import { test, describe } from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { readFileSync, existsSync } from 'node:fs';
|
||
import path from 'node:path';
|
||
import { fileURLToPath } from 'node:url';
|
||
import * as THREE from 'three';
|
||
import { SURFACES, SOURCES, surfaceUV, resolveUvTable, cleanSurface, sideRect, tintRgb } from '../../public/js/render/board3d/atlas.js';
|
||
import { parseObj, mapMesh } from '../../public/js/render/board3d/obj.js';
|
||
import {
|
||
buildBoard, classifyStage, heightOf, AREAS, areaFor, unionAreas, objToBoard, boxProjectUV, tube, Geom, uvAt, ROWS, COLS,
|
||
DEVICE_H, RAISED_FOOT,
|
||
} from '../../public/js/render/board3d/layout.js';
|
||
import { BoardScene, gatePulse, DIR_TURNS, boxData, LIGHTING } from '../../public/js/render/board3d/scene.js';
|
||
import { loadBoardPack, loadThree, resetBoardPack, PACK_IMAGES } from '../../public/js/render/board3d/load.js';
|
||
import { parseStage } from '../../public/js/render/tiles.js';
|
||
import { TILE_H } from '../../public/js/render/style.js';
|
||
import { presetCamera, syncThreeCamera } from '../../public/js/render/projection.js';
|
||
|
||
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
|
||
const stages = JSON.parse(readFileSync(path.join(ROOT, 'data/stages.json'), 'utf8'));
|
||
const ACTIVE = Object.values(stages).filter((s) => s.active).map((s) => s.id);
|
||
const LOCAL = path.join(ROOT, 'public/assets/local');
|
||
const near = (a, b, eps = 1e-6) => Math.abs(a - b) <= eps;
|
||
|
||
describe('atlas surfaces', () => {
|
||
test('every surface is valid and inside its source; tiles.json overrides merge, junk is ignored', () => {
|
||
for (const [k, v] of Object.entries(SURFACES)) {
|
||
const c = cleanSurface(v);
|
||
assert.ok(c, k);
|
||
const S = SOURCES[c.src];
|
||
assert.ok(c.rect[0] + c.rect[2] <= S.w && c.rect[1] + c.rect[3] <= S.h, k);
|
||
}
|
||
const t = resolveUvTable({ board3d: { concrete: { src: 'D', rect: [0, 0, 64, 64], rot: 90 }, bogus: { src: 'X', rect: [0, 0, 1, 1] }, hatch: { src: 'D', rect: [2040, 0, 64, 64] } } });
|
||
assert.deepEqual(t.concrete.rect, [0, 0, 64, 64]);
|
||
assert.equal(t.concrete.rot, 90);
|
||
assert.equal(t.bogus, undefined);
|
||
assert.deepEqual(t.hatch.rect, SURFACES.hatch.rect, 'out-of-bounds override rejected');
|
||
assert.deepEqual(Object.keys(resolveUvTable(null)).sort(), Object.keys(SURFACES).sort());
|
||
});
|
||
|
||
test('surfaceUV: corner order BL, BR, TR, TL with the texture top on the far edge; rotation and flip permute', () => {
|
||
const s = { src: 'D', rect: [256, 512, 256, 256] };
|
||
const uv = surfaceUV(s, null, 0);
|
||
// BL = (x0, bottom) → v = 1 − 768/2048; TL = (x0, top) → v = 1 − 512/2048
|
||
assert.deepEqual(uv.map((x) => +x.toFixed(6)), [0.125, 0.625, 0.25, 0.625, 0.25, 0.75, 0.125, 0.75]);
|
||
const r90 = surfaceUV({ ...s, rot: 90 }, null, 0);
|
||
assert.deepEqual(r90.slice(0, 2), uv.slice(2, 4), 'rot 90: BL samples the texture BR');
|
||
const f = surfaceUV({ ...s, flipX: true }, null, 0);
|
||
assert.deepEqual(f.slice(0, 2), uv.slice(2, 4));
|
||
const inset = surfaceUV(s, null, 2);
|
||
assert.ok(inset[0] > uv[0] && inset[2] < uv[2], 'mip inset');
|
||
// side panels keep their aspect: a 1 × 0.42 face uses the top 0.42·272/384 of the gold panel
|
||
const sr = sideRect(SURFACES.goldSide, 1, 0.42);
|
||
assert.ok(near(sr[3], 0.42 / (384 / 272), 1e-9));
|
||
assert.deepEqual(sideRect(SURFACES.goldSide, 1, 5), [0, 0, 1, 1]);
|
||
assert.deepEqual(tintRgb('#ff0000'), [1, 0, 0]);
|
||
assert.deepEqual(tintRgb('nope'), [1, 1, 1]);
|
||
assert.deepEqual(uvAt([0, 0, 1, 0, 1, 1, 0, 1], 0.25, 0.5), [0.25, 0.5]);
|
||
});
|
||
});
|
||
|
||
describe('OBJ reader', () => {
|
||
test('polygons fan into triangles; relative indices; groups; per-corner de-duplication', () => {
|
||
const m = parseObj(['# quad', 'v 0 0 0', 'v 1 0 0', 'v 1 1 0', 'v 0 1 0', 'vt 0 0', 'vt 1 0', 'vt 1 1', 'vt 0 1', 'vn 0 0 1',
|
||
'g a', 'f 1/1/1 2/2/1 3/3/1 4/4/1', 'g b', 'f -4/-4/-1 -2/-2/-1 -1/-1/-1'].join('\n'));
|
||
assert.equal(m.index.length, 9);
|
||
assert.equal(m.position.length / 3, 4, 'shared corners reused');
|
||
assert.deepEqual(m.groups.map((g) => [g.name, g.count]), [['a', 6], ['b', 3]]);
|
||
assert.deepEqual(m.bounds, { min: [0, 0, 0], max: [1, 1, 0] });
|
||
assert.ok(m.normal && m.uv);
|
||
assert.equal(parseObj(''), null);
|
||
assert.equal(parseObj('v 1 2 3\nf 1 2 9'), null, 'bad indices dropped');
|
||
const moved = mapMesh(m, (x, y, z) => [x + 1, y, z]);
|
||
assert.equal(moved.position[0], 1);
|
||
});
|
||
|
||
test('vertex colours (v x y z r g b) are read', () => {
|
||
const m = parseObj('v 0 0 0 1 0 0\nv 1 0 0 0 1 0\nv 0 1 0 0 0 1\nf 1 2 3');
|
||
assert.deepEqual([...m.color], [1, 0, 0, 0, 1, 0, 0, 0, 1]);
|
||
});
|
||
|
||
test('the extracted official meshes parse (when the local client was extracted)', { skip: !existsSync(path.join(LOCAL, 'mesh/s_common_box_01/pCube2.obj')) && 'not extracted' }, () => {
|
||
const crate = parseObj(readFileSync(path.join(LOCAL, 'mesh/s_common_box_01/pCube2.obj'), 'utf8'));
|
||
assert.deepEqual(crate.bounds.max.map(Math.round), [45, 68, 45]);
|
||
const b = objToBoard(crate, 0.01);
|
||
// Y-up Unity → board z-up: the crate stands 0.675 tall on the ground, 0.9 wide
|
||
let z1 = -Infinity, z0 = Infinity;
|
||
for (let i = 2; i < b.position.length; i += 3) { z1 = Math.max(z1, b.position[i]); z0 = Math.min(z0, b.position[i]); }
|
||
assert.ok(near(z0, 0, 1e-6) && near(z1, 0.675, 1e-4), `${z0}..${z1}`);
|
||
const blower = parseObj(readFileSync(path.join(LOCAL, 'mesh/s_wind_device/S_wild_wind_device.obj'), 'utf8'));
|
||
assert.ok(blower.index.length > 100 && blower.uv);
|
||
const gate = parseObj(readFileSync(path.join(LOCAL, 'map/fx/Start_up.obj'), 'utf8'));
|
||
assert.deepEqual(gate.bounds.min.map(Math.round), [-50, -50, -50], 'the gate box is a 1-tile cube at scale 0.01');
|
||
});
|
||
});
|
||
|
||
describe('board geometry (layout.js)', () => {
|
||
test('heights agree with the Pixi tile field (units stand on the same tops) on every stage', () => {
|
||
for (const st of Object.values(stages)) {
|
||
const G = classifyStage(st, AREAS.all);
|
||
const P = parseStage(st, [0, 18], [0, 18]);
|
||
for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
|
||
const a = G[r][c], b = P[r][c];
|
||
assert.equal(a.glyph, b.glyph, `${st.id} ${r},${c}`);
|
||
if (a.drawn) assert.ok(near(a.h, b.h), `${st.id} ${r},${c} h ${a.h} vs ${b.h}`);
|
||
}
|
||
assert.equal(heightOf(G, -1, 3), 0);
|
||
}
|
||
assert.equal(classifyStage(stages.act2autochess_m01)[10][4].h, TILE_H.wall, 'high ground');
|
||
});
|
||
|
||
test('areas: the normal phase builds the own field + pen, 联防 both halves, the Final Assault the boss field', () => {
|
||
const st = stages.act2autochess_m01;
|
||
const drawnRows = (area) => { const G = classifyStage(st, area); const rows = new Set(); for (const row of G) for (const t of row) if (t.drawn) rows.add(t.r); return [...rows].sort((a, b) => a - b); };
|
||
const n = drawnRows(AREAS.normal), b = drawnRows(AREAS.boss);
|
||
assert.ok(n.includes(7) && n.includes(12) && n.includes(16) && !n.includes(3), `normal rows ${n}`);
|
||
assert.ok(b.includes(0) && b.includes(5) && !b.includes(9), `boss rows ${b}`);
|
||
const G = classifyStage(st, AREAS.normal);
|
||
assert.ok(!G[9][14].drawn, 'the partner half is not built in the normal phase');
|
||
assert.ok(classifyStage(st, AREAS.unite)[9][14].drawn, '联防 builds the partner half');
|
||
assert.equal(areaFor('prep'), AREAS.normal);
|
||
assert.equal(areaFor('pen'), AREAS.normal);
|
||
assert.equal(areaFor('unite'), AREAS.unite);
|
||
assert.equal(areaFor('hidden'), AREAS.boss);
|
||
assert.equal(unionAreas(AREAS.normal, AREAS.normal, AREAS.boss).length, 3);
|
||
});
|
||
|
||
test('every active stage: finite buffers, unit normals, UVs inside the atlas, gates / fences / devices / terrain', () => {
|
||
for (const id of ACTIVE) {
|
||
const st = stages[id];
|
||
for (const area of [AREAS.normal, AREAS.unite, AREAS.boss]) {
|
||
const b = buildBoard(st, { area });
|
||
for (const [name, g] of Object.entries(b.buckets)) {
|
||
const n = g.position.length / 3;
|
||
assert.equal(g.normal.length, n * 3, `${id} ${name}`);
|
||
for (const v of g.position) assert.ok(Number.isFinite(v), `${id} ${name} position`);
|
||
for (let i = 0; i < g.normal.length; i += 3) assert.ok(near(Math.hypot(g.normal[i], g.normal[i + 1], g.normal[i + 2]), 1, 1e-4), `${id} ${name} normal`);
|
||
for (const u of g.uv) assert.ok(u >= 0 && u <= 1, `${id} ${name} uv ${u}`);
|
||
for (const i of g.index) assert.ok(i < n, `${id} ${name} index`);
|
||
}
|
||
// top faces wind counter-clockwise seen from above (front faces for three.js)
|
||
const g = b.buckets.board, P = g.position, I = g.index;
|
||
let tops = 0;
|
||
for (let t = 0; t < I.length; t += 3) {
|
||
const [a, bb, c] = [I[t], I[t + 1], I[t + 2]];
|
||
if (g.normal[a * 3 + 2] < 0.99) continue;
|
||
const ux = P[bb * 3] - P[a * 3], uy = P[bb * 3 + 1] - P[a * 3 + 1], vx = P[c * 3] - P[a * 3], vy = P[c * 3 + 1] - P[a * 3 + 1];
|
||
assert.ok(ux * vy - uy * vx > 0, `${id}: top triangle faces up`);
|
||
tops++;
|
||
}
|
||
assert.ok(tops > 100, `${id} tops`);
|
||
const G = b.grid;
|
||
const expected = [];
|
||
for (const row of G) for (const t of row) if (t.drawn && (t.glyph === 'S' || t.glyph === 'E')) expected.push(`${t.r},${t.c}`);
|
||
assert.deepEqual(b.gates.map((x) => `${x.r},${x.c}`).sort(), expected.sort(), `${id} gates`);
|
||
const fenced = G.flat().some((t) => t.drawn && t.glyph === 'b');
|
||
assert.equal(b.buckets.pipe.vertexCount > 0, fenced, `${id} railings iff fenced tiles`);
|
||
for (const d of b.devices) assert.ok(G[d.r][d.c].drawn, `${id} device on a built tile`);
|
||
assert.ok(b.edges.length > 0, `${id} field edge glow`);
|
||
}
|
||
}
|
||
// terrain lists
|
||
assert.ok(buildBoard(stages.act2autochess_m04).terrain.water.length > 0);
|
||
assert.ok(buildBoard(stages.act2autochess_m02).terrain.mire.length > 0);
|
||
assert.ok(buildBoard(stages.act2autochess_m03).terrain.smog.length > 0);
|
||
assert.ok(buildBoard(stages.act1autochess_m04).terrain.infection.length > 0);
|
||
// blowers are active devices of act2 m01; inactive crates of act1 m02 are not built
|
||
assert.ok(buildBoard(stages.act2autochess_m01).devices.some((d) => d.kind === 'blower' && d.dir === 'DOWN'));
|
||
assert.ok(!buildBoard(stages.act1autochess_m02).devices.some((d) => d.kind === 'crate'));
|
||
});
|
||
|
||
test('#569: the device slabs (射击台 / 特制水上平台 / 封印的地面) are repeated for an official scene, their sides reaching under its ground; nothing else is', () => {
|
||
const SLAB = new Set(['platform', 'waterPlatform', 'sealedFloor']);
|
||
for (const [id, st] of Object.entries(stages)) {
|
||
if (!Array.isArray(st?.rows)) continue;
|
||
for (const area of [AREAS.normal, AREAS.boss]) {
|
||
const b = buildBoard(st, { area });
|
||
const slabs = b.devices.filter((d) => SLAB.has(d.kind));
|
||
const decals = slabs.filter((d) => d.kind === 'sealedFloor').length;
|
||
// per slab four sides, plus its top: a plate (raised) or the hazard decal of a sealed floor (raisedDecal)
|
||
assert.equal(b.buckets.raised.vertexCount, (slabs.length * 5 - decals) * 4, `${id}: raised quads`);
|
||
assert.equal(b.buckets.raisedDecal.vertexCount, decals * 4, `${id}: raised decal quads`);
|
||
const P = b.buckets.raised.position;
|
||
for (let i = 0; i < P.length; i += 3) {
|
||
const d = slabs.find((x) => Math.abs(P[i] - x.c) <= 0.5 && Math.abs(P[i + 1] - x.r) <= 0.5);
|
||
assert.ok(d, `${id}: every raised vertex is on a slab tile`);
|
||
const h = b.grid[d.r][d.c].h;
|
||
assert.ok(near(P[i + 2], h + DEVICE_H[d.kind]) || near(P[i + 2], h - RAISED_FOOT), `${id}: a slab top or its foot, z ${P[i + 2]}`);
|
||
}
|
||
}
|
||
}
|
||
// the report's 射击台 beside the blue gate (战场#03) and the water platforms (战场#05 上半) are there; the 'h' high
|
||
// ground of act2 m01 / m02 is the scenes' own geometry and is not repeated
|
||
assert.ok(buildBoard(stages.act1autochess_m03, { area: AREAS.normal }).buckets.raised.vertexCount > 0);
|
||
assert.equal(buildBoard(stages.act1autochess_m05, { area: AREAS.normal }).devices.filter((d) => d.kind === 'waterPlatform').length, 16);
|
||
for (const id of ['act2autochess_m01', 'act2autochess_m02']) assert.equal(buildBoard(stages[id], { area: AREAS.normal }).buckets.raised.vertexCount, 0, id);
|
||
});
|
||
|
||
test('malformed stages never throw and still build an island', () => {
|
||
for (const st of [null, {}, { rows: ['xyz'] }, { rows: Array(19).fill('r'.repeat(21)), devices: [{ role: 'crate', pos: [3, 3] }, { role: 'crate', pos: 'x' }] }]) {
|
||
const b = buildBoard(st, { area: AREAS.all });
|
||
assert.ok(b.buckets.board.index.length >= 0);
|
||
}
|
||
});
|
||
|
||
test('objToBoard is a proper rotation (normals stay unit, outward); boxProjectUV maps tops and sides', () => {
|
||
const box = { position: new Float32Array([0, 1, 0, 1, 1, 0, 1, 1, 1]), normal: new Float32Array([0, 1, 0, 0, 1, 0, 0, 1, 0]), index: new Uint16Array([0, 1, 2]) };
|
||
const b = objToBoard(box, 1);
|
||
assert.deepEqual([...b.normal.slice(0, 3)], [-0, 0, 1], 'Unity +Y is board +z');
|
||
assert.deepEqual([...b.position.slice(3, 6)], [-1, 0, 1]);
|
||
const crate = boxProjectUV({ ...boxData(0.9, 0.675), color: null }, SURFACES.crateTop, SURFACES.crateSide);
|
||
const top = surfaceUV(SURFACES.crateTop), side = surfaceUV(SURFACES.crateSide);
|
||
const inRange = (u, v, uv) => u >= Math.min(uv[0], uv[2], uv[4]) - 1e-6 && u <= Math.max(uv[0], uv[2], uv[4]) + 1e-6 && v >= Math.min(uv[1], uv[5]) - 1e-6 && v <= Math.max(uv[1], uv[5]) + 1e-6;
|
||
for (let i = 0; i < crate.uv.length / 2; i++) {
|
||
const up = crate.normal[i * 3 + 2] > 0.6;
|
||
assert.ok(inRange(crate.uv[i * 2], crate.uv[i * 2 + 1], up ? top : side), `vertex ${i}`);
|
||
}
|
||
const g = tube(new Geom(), [0, 0, 0], [1, 0, 0], 0.05);
|
||
assert.ok(g.vertexCount > 0 && g.triangleCount > 0);
|
||
});
|
||
});
|
||
|
||
// ---- the three.js scene with a stub renderer ---------------------------------------------------------------------
|
||
|
||
function stubRenderer() {
|
||
const calls = [];
|
||
return {
|
||
calls,
|
||
domElement: { addEventListener() {}, removeEventListener() {} },
|
||
shadowMap: { enabled: true, needsUpdate: false },
|
||
capabilities: { getMaxAnisotropy: () => 8 },
|
||
info: { render: { calls: 7, triangles: 1234 }, memory: { textures: 3, geometries: 5 } },
|
||
setClearColor() {}, setPixelRatio(d) { calls.push(['dpr', d]); }, setSize(w, h) { calls.push(['size', w, h]); },
|
||
render(scene, camera) { calls.push(['render', scene, camera]); },
|
||
dispose() { calls.push(['dispose']); },
|
||
};
|
||
}
|
||
|
||
function fakePack() {
|
||
const img = { width: 4, height: 4 };
|
||
const crate = existsSync(path.join(LOCAL, 'mesh/s_common_box_01/pCube2.obj')) ? parseObj(readFileSync(path.join(LOCAL, 'mesh/s_common_box_01/pCube2.obj'), 'utf8')) : null;
|
||
const cube = parseObj(['v -50 -50 -50', 'v 50 -50 -50', 'v 50 50 -50', 'v -50 50 -50', 'vt 0 0', 'vt 1 0', 'vt 1 1', 'vt 0 1', 'vn 0 0 -1', 'f 1/1/1 2/2/1 3/3/1 4/4/1'].join('\n'));
|
||
return {
|
||
key: 'test', images: { D: img, N: img, R: img, E: img, common: img, gate: img, BG: img, wind: img },
|
||
meshes: { crate, blower: cube, bgPlane: null, gate: { startDown: { mesh: cube }, startUp: { mesh: cube }, startBack: { mesh: cube }, endDown: { mesh: cube }, endUp: { mesh: cube } } },
|
||
tiles: null, uv: resolveUvTable(null), materials: {},
|
||
};
|
||
}
|
||
|
||
describe('BoardScene (three.js scene graph, stub renderer)', () => {
|
||
test('builds merged meshes per material, few draw objects, shadows once; areas rebuild', () => {
|
||
const R = stubRenderer();
|
||
const board = new BoardScene(THREE, fakePack(), { renderer: R });
|
||
board.setStage(stages.act2autochess_m01);
|
||
const meshes = board.root.children;
|
||
assert.ok(meshes.length >= 5 && meshes.length <= 16, `draw objects ${meshes.length}`);
|
||
for (const m of meshes) assert.ok(m.geometry.getAttribute('position').count > 0);
|
||
assert.ok(board.meshes.board && board.meshes.gateStart && board.meshes.gateEndAb && board.meshes.blowers && board.meshes.bg, Object.keys(board.meshes).join());
|
||
assert.equal(R.shadowMap.needsUpdate, true);
|
||
const before = board.meshes.board.geometry.getAttribute('position').count;
|
||
assert.equal(board.setArea(AREAS.boss), true);
|
||
assert.notEqual(board.meshes.board.geometry.getAttribute('position').count, before);
|
||
assert.equal(board.setArea(AREAS.boss), false, 'same area: no rebuild');
|
||
board.destroy();
|
||
assert.ok(R.calls.some((c) => c[0] === 'dispose'));
|
||
});
|
||
|
||
test('battle rect hides the static crates inside it (the sim spawns them); device handles follow DeviceView', () => {
|
||
const board = new BoardScene(THREE, fakePack(), { renderer: stubRenderer() });
|
||
board.setStage(stages.act1autochess_m01);
|
||
const crates = () => board.meshes.crates ? board.meshes.crates.geometry.getAttribute('position').count : 0;
|
||
const all = crates();
|
||
assert.ok(all > 0);
|
||
board.setBattleRect({ r0: 9, r1: 12, c0: 0, c1: 10 });
|
||
assert.ok(crates() < all, 'field crates hidden in battle');
|
||
board.setBattleRect(null);
|
||
assert.equal(crates(), all);
|
||
const h = board.createDevice();
|
||
assert.equal(h.mesh, null, 'DeviceView adds nothing to Pixi');
|
||
h.update(null, { x: 5, y: 10, z: 0, size: 0.45, height: 0.3, alpha: 0.5 });
|
||
const m = [...board.dynamic.children].at(-1);
|
||
assert.ok(near(m.position.x, 5) && near(m.scale.x, 0.5, 0.02) && m.material.opacity === 0.5);
|
||
h.destroy();
|
||
assert.equal(board.devices.size, 0);
|
||
board.destroy();
|
||
});
|
||
|
||
test('render syncs the three camera from the projection camera (identical pixels) and animates the gates', () => {
|
||
const R = stubRenderer();
|
||
const board = new BoardScene(THREE, fakePack(), { renderer: R });
|
||
board.setStage(stages.act2autochess_m03);
|
||
board.resize(1280, 720, 2);
|
||
const cam = presetCamera('normal', { width: 1280, height: 720 });
|
||
assert.equal(board.render(cam, 1.25), true);
|
||
const ref = syncThreeCamera(cam, new THREE.PerspectiveCamera(), 1280, 720);
|
||
board.camera.updateMatrixWorld(true);
|
||
for (const [x, y, z] of [[2, 9, 0], [10, 12, 0.42], [6, 10.5, 0]]) {
|
||
const a = new THREE.Vector3(x, y, z).project(board.camera), b = new THREE.Vector3(x, y, z).project(ref);
|
||
assert.ok(near(a.x, b.x, 1e-9) && near(a.y, b.y, 1e-9));
|
||
}
|
||
const p0 = board.mat.gateStartAdd.uniforms.uPulse.value;
|
||
board.render(cam, 2.25);
|
||
assert.notEqual(board.mat.gateStartAdd.uniforms.uPulse.value, p0, 'gate pulse animates');
|
||
board.flashObjective(9, 2);
|
||
board.render(cam, 2.4);
|
||
assert.ok(board.mat.gateEndAb.uniforms.uFlash.value.r > 0.5, 'leak flash');
|
||
board.setFocus({ r0: 9, r1: 12, c0: 0, c1: 10 });
|
||
for (let i = 0; i < 60; i++) board.render(cam, 2.4 + i / 30);
|
||
const F = board.focus.uFocus.value;
|
||
assert.ok(near(F.x, -0.5, 0.05) && near(F.w, 12.5, 0.05), 'focus eases to the field rect');
|
||
assert.equal(R.calls.filter((c) => c[0] === 'render').length, 63);
|
||
assert.deepEqual(board.stats().calls, 7);
|
||
board.lost = true;
|
||
assert.equal(board.render(cam, 5), false, 'lost context: no draw');
|
||
board.destroy();
|
||
});
|
||
|
||
test('gate pulse follows the official 2 s curve; device outlets turn with their dir', () => {
|
||
let lo = Infinity, hi = -Infinity;
|
||
for (let t = 0; t < 2; t += 0.01) { const v = gatePulse(t); lo = Math.min(lo, v); hi = Math.max(hi, v); }
|
||
assert.ok(near(lo, 0.134, 1e-3) && near(hi, 0.229, 1e-3));
|
||
assert.ok(near(gatePulse(0.3), gatePulse(2.3), 1e-9), 'periodic');
|
||
assert.deepEqual(new Set(Object.values(DIR_TURNS)), new Set([0, 1, 2, 3]));
|
||
assert.ok(LIGHTING.key.intensity > 0 && LIGHTING.bg.z < 0);
|
||
});
|
||
});
|
||
|
||
describe('asset pack loader (fake store)', () => {
|
||
test('resetBoardPack lets a later three.js import try again after three failures', async () => {
|
||
resetBoardPack();
|
||
const missing = new URL('./no-such-three.mjs', import.meta.url).href;
|
||
for (let i = 0; i < 3; i++) assert.equal(await loadThree(missing), null);
|
||
assert.equal(await loadThree(missing), null, 'three failures stop further imports');
|
||
resetBoardPack();
|
||
const mod = await loadThree(new URL('./fake-three.mjs', import.meta.url).href);
|
||
assert.equal(typeof mod?.WebGLRenderer, 'function');
|
||
resetBoardPack();
|
||
});
|
||
test('a transient diffuse-image failure is retried by the next mount instead of cached as permanent 2D', async () => {
|
||
resetBoardPack();
|
||
let calls = 0;
|
||
const store = { local: async () => ({ groups: {} }), localUrl: (g, n) => n === 'TX_autochessi_D' ? '/test/atlas.png' : null,
|
||
image: async () => ++calls === 1 ? null : { width: 8, height: 8 } };
|
||
const original = globalThis.fetch;
|
||
globalThis.fetch = async () => ({ ok: false });
|
||
try {
|
||
assert.equal(await loadBoardPack(store), null);
|
||
const pack = await loadBoardPack(store);
|
||
assert.ok(pack?.images.D); assert.equal(calls, 2);
|
||
assert.equal(await loadBoardPack(store), pack, 'successful pack remains shared');
|
||
} finally { globalThis.fetch = original; resetBoardPack(); }
|
||
});
|
||
test('loads images through the store and meshes through fetch; null without the diffuse atlas', async () => {
|
||
resetBoardPack();
|
||
const manifest = { groups: {} };
|
||
for (const [slot, [g, n]] of Object.entries(PACK_IMAGES)) (manifest.groups[g] ||= {})[n] = { path: `/assets/local/${g}/${n}.png` };
|
||
manifest.groups['mesh/s_common_box_01'] = { pCube2: { path: '/assets/local/mesh/s_common_box_01/pCube2.obj' } };
|
||
manifest.groups['map/fx'] = { ...manifest.groups['map/fx'], Start_up: { path: '/assets/local/map/fx/Start_up.obj' }, prefab: { path: '/assets/local/map/fx/prefab.json' } };
|
||
const requested = [];
|
||
const store = {
|
||
local: async () => manifest,
|
||
localUrl: (g, n) => manifest.groups[g]?.[n]?.path || null,
|
||
image: async (u) => { requested.push(u); return { width: 8, height: 8 }; },
|
||
};
|
||
const realFetch = globalThis.fetch;
|
||
globalThis.fetch = async (u) => {
|
||
const s = String(u);
|
||
if (s.endsWith('.obj')) return { ok: true, text: async () => 'v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3' };
|
||
if (s.endsWith('prefab.json')) return { ok: true, json: async () => [{ name: 'Start_up', parent: 'Start', mesh: 'Start_up', materials: ['[opt]start_end_add'] }] };
|
||
return { ok: false, json: async () => null, text: async () => '' };
|
||
};
|
||
try {
|
||
const pack = await loadBoardPack(store);
|
||
assert.ok(pack && pack.images.D && pack.images.gate, 'images');
|
||
assert.ok(requested.some((u) => u.includes('%5Bopt%5Dmerged_textures')), 'bracketed names are URL-encoded');
|
||
assert.ok(pack.meshes.crate && pack.meshes.gate.startUp, 'meshes');
|
||
assert.equal(pack.meshes.gate.startUp.material, '[opt]start_end_add');
|
||
assert.ok(pack.uv.concrete);
|
||
resetBoardPack();
|
||
delete manifest.groups['map/autochess'].TX_autochessi_D;
|
||
assert.equal(await loadBoardPack(store), null, 'no diffuse atlas → no 3D board');
|
||
resetBoardPack();
|
||
assert.equal(await loadBoardPack(null), null);
|
||
} finally {
|
||
globalThis.fetch = realFetch;
|
||
resetBoardPack();
|
||
}
|
||
});
|
||
});
|