import test from "node:test"; import assert from "node:assert/strict"; import fs from "node:fs/promises"; import * as THREE from "three"; import { DEFAULT_WORLD, resolveWorldId, fitWorldToRobot, arenaWalls, } from "../src/platform/worlds/arena.js"; import { validatePackage, validateWorld, } from "../src/platform/loader/SchemaValidator.js"; import { createArenaFloorPresentation } from "../src/game/worlds/arena/presentation.js"; const world = JSON.parse( await fs.readFile( new URL("../public/worlds/arena/world.json", import.meta.url), ), ); test("all bundled and future Packages share the arena template and declare nominal height; flat diagnostics stay explicit", async () => { assert.equal(DEFAULT_WORLD, "arena"); validateWorld(world); assert.equal(world.type, "flat"); assert.deepEqual(world.boundary, { half_extent: 2.25, wall_height: 0.25, wall_thickness: 0.05, }); assert.equal(world.boundary.half_extent / 1.5, 1.5); for (const id of ["microduck-legs", "microduck-rollers", "microban", "rp1"]) { const config = JSON.parse( await fs.readFile( new URL(`../public/robots/${id}/robot.json`, import.meta.url), ), ); validatePackage(config); assert.equal(resolveWorldId(config), "arena"); const fitted = fitWorldToRobot(world, config); assert.equal(fitted.scale, config.dimensions.height / 0.27); assert.equal(fitted.boundary.half_extent, 2.25 * fitted.scale); assert.equal(fitted.boundary.wall_height, 0.25 * fitted.scale); assert.equal(fitted.boundary.wall_thickness, 0.05 * fitted.scale); assert.equal(world.boundary.half_extent, 2.25); // Never mutate the template. if (id === "microban") { config.id = "future-bot"; config.family = "future-bot"; delete config.presentation.world; validatePackage(config); assert.equal(resolveWorldId(config), "arena"); config.presentation.world = "flat"; assert.equal(resolveWorldId(config), "flat"); } } }); test("fitting is idempotent, missing height stays at reference scale, and fixed diagnostic Worlds do not scale", () => { const config = { dimensions: { height: 1.32 } }; const fitted = fitWorldToRobot(world, config); assert.ok(Math.abs(fitted.boundary.half_extent * 2 - 22) < 1e-10); assert.deepEqual(fitWorldToRobot(fitted, config), fitted); assert.deepEqual(fitWorldToRobot(world, {}).boundary, world.boundary); const fixed = structuredClone(world); delete fixed.scale_to_robot; assert.equal(fitWorldToRobot(fixed, config), fixed); const gridded = structuredClone(world); gridded.floor.grid = { size: 3, divisions: 10, color: "#ffffff" }; assert.equal( fitWorldToRobot(gridded, config).floor.grid.size, 3 * fitted.scale, ); assert.equal(gridded.floor.grid.size, 3); for (const height of [0, -1, Infinity, NaN]) assert.throws( () => fitWorldToRobot(world, { dimensions: { height } }), /scale/, ); }); test("physical wall inner faces match 4.5m bounds and corners overlap", () => { const walls = arenaWalls(world.boundary); assert.equal(walls.length, 4); assert.deepEqual(walls[0], { name: "wall_px", pos: [2.275, 0, 0.125], size: [0.025, 2.3, 0.125], }); assert.deepEqual(walls[2], { name: "wall_py", pos: [0, 2.275, 0.125], size: [2.3, 0.025, 0.125], }); for (const w of walls) { assert.equal(w.size[2] * 2, 0.25); assert.ok(w.size[0] === 0.025 || w.size[1] === 0.025); } }); test("visual walls stay at physical inner faces while the floor focus follows; all resources release once", () => { const defs = [ "platform_floor", ...arenaWalls(world.boundary).map((w) => w.name), ], meshes = defs.map(() => new THREE.Mesh()); const sim = { model: { geom: (name) => ({ id: defs.indexOf(name) }) } }, rig = { items: meshes.map((mesh, id) => ({ mesh, id })) }; const view = createArenaFloorPresentation({ sim, rig, world }); assert.equal(view.walls.length, 4); assert.ok(meshes.every((m) => !m.visible)); const positions = view.walls.map((m) => m.position.toArray()); assert.deepEqual(positions[0], [2.25, 0.125, 0]); assert.deepEqual(positions[2], [0, 0.125, 2.25]); view.update(new THREE.Vector3(1, 0.2, -1)); assert.deepEqual( view.walls.map((m) => m.position.toArray()), positions, ); let releases = 0; for (const mesh of [view.grid, ...view.walls]) { mesh.geometry.addEventListener("dispose", () => releases++); mesh.material.addEventListener("dispose", () => releases++); } view.dispose(); view.dispose(); assert.equal(releases, 10); assert.ok(meshes.every((m) => m.visible)); }); test("RP1 visual walls, grid spacing and fade distances scale with the same collision dimensions", () => { const fitted = fitWorldToRobot(world, { dimensions: { height: 1.32 } }); const names = [ "platform_floor", ...arenaWalls(fitted.boundary).map((w) => w.name), ]; const sim = { model: { geom: (name) => ({ id: names.indexOf(name) }) } }; const rig = { items: names.map((_, id) => ({ id, mesh: new THREE.Mesh() })) }; const view = createArenaFloorPresentation({ sim, rig, world: fitted }); assert.equal(view.grid.material.uniforms.uCell.value, 0.1 * fitted.scale); assert.equal(view.grid.material.uniforms.uSection.value, 0.6 * fitted.scale); assert.equal(view.grid.material.uniforms.uFadeDist.value, 3 * fitted.scale); assert.equal(view.grid.geometry.parameters.width, 30 * fitted.scale); for (const mesh of view.walls) { assert.equal(mesh.geometry.parameters.height, fitted.boundary.wall_height); assert.equal( mesh.geometry.parameters.width, 2 * (fitted.boundary.half_extent + fitted.boundary.wall_thickness), ); assert.equal( mesh.material.uniforms.uWallH.value, fitted.boundary.wall_height, ); assert.equal(mesh.material.uniforms.uFadeDist.value, 5 * fitted.scale); assert.equal(mesh.material.uniforms.uCell.value, 0.1 * fitted.scale); } assert.deepEqual(view.walls[0].position.toArray(), [ fitted.boundary.half_extent, fitted.boundary.wall_height / 2, 0, ]); view.dispose(); }); test("invalid physical boundaries and scaling declarations are rejected", () => { for (const scale_to_robot of [ { reference_height: 0 }, { reference_height: -1 }, {}, ]) assert.throws( () => validateWorld({ ...world, scale_to_robot }), /scale_to_robot/, ); assert.throws( () => validateWorld({ ...world, boundary: undefined }), /boundary/, ); for (const bad of [ { half_extent: 0 }, { wall_height: -1 }, { wall_thickness: 0 }, ]) assert.throws( () => validateWorld({ ...world, boundary: { ...world.boundary, ...bad } }), /boundary/, ); });