@bongos/core 1.17.0 → 1.17.2

package/tests/walkability.mjs

@@ -1,188 +0,0 @@
-// tests/walkability.mjs
-//
-// Verify the ground-object split's walkability semantics:
-//   - Ground SEA blocks (terrain-level).
-//   - Ground GRASS / SAND walkable on their own.
-//   - Object ROCK on grass blocks (object-level).
-//   - Object CONTAINER_PANEL_DOOR on sand blocks (object-level).
-//   - Both also blocks (object wins, same outcome).
-//   - Out-of-bounds blocks.
-//
-// Exercises the SERVER-side isBlocked() — that's the source of truth
-// for movement validation. Loads it via require() since the server
-// module is CJS.
-//
-// Run:  node tests/walkability.mjs
-
-import { strict as assert } from 'node:assert';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const serverMap = require('../modules/game/world/map.js');
-const serverTerrain = require('../modules/game/world/terrain.js');
-
-const { isBlocked, INITIAL_MAP, WORLD_COLS, WORLD_ROWS } = serverMap;
-const { TERRAIN, OBJECT, isBlockingTerrain, isBlockingObject } = serverTerrain;
-
-let passed = 0;
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  ok  ${name}`);
-    passed++;
-  } catch (e) {
-    console.error(`  FAIL ${name}: ${e.message}`);
-    process.exitCode = 1;
-  }
-}
-
-// ---------- helpers ------------------------------------------------------------
-
-// Find a sample cell of each kind in the actual INITIAL_MAP.
-function findCell(predicate) {
-  for (let y = 0; y < WORLD_ROWS; y++) {
-    for (let x = 0; x < WORLD_COLS; x++) {
-      if (predicate(INITIAL_MAP.ground[y][x], INITIAL_MAP.objects[y][x], x, y)) {
-        return { x, y };
-      }
-    }
-  }
-  return null;
-}
-
-const seaCell  = findCell((g, _o) => g === TERRAIN.SEA);
-const sandCell = findCell((g, o)  => g === TERRAIN.SAND && !o);
-const grassCell = findCell((g, o) => g === TERRAIN.GRASS && !o);
-const rockCell = findCell((_g, o) => o === OBJECT.ROCK);
-const doorCell = findCell((_g, o) => o === OBJECT.CONTAINER_PANEL_DOOR);
-const panelCell = findCell((_g, o) => o === OBJECT.CONTAINER_PANEL_TL);
-
-// ---------- registry shape ------------------------------------------------------
-
-test('TERRAIN + OBJECT enums export expected ids', () => {
-  assert.equal(TERRAIN.GRASS, 'grass');
-  assert.equal(TERRAIN.SAND,  'sand');
-  assert.equal(TERRAIN.SEA,   'sea');
-  assert.equal(OBJECT.ROCK,   'rock');
-  assert.equal(OBJECT.CONTAINER_PANEL_DOOR, 'container_panel_door');
-});
-
-test('isBlockingTerrain: SEA blocks; GRASS, SAND, MARBLE_PATH walkable', () => {
-  assert.equal(isBlockingTerrain(TERRAIN.SEA), true);
-  assert.equal(isBlockingTerrain(TERRAIN.GRASS), false);
-  assert.equal(isBlockingTerrain(TERRAIN.SAND), false);
-  assert.equal(isBlockingTerrain(TERRAIN.MARBLE_PATH), false);
-});
-
-test('isBlockingObject: ROCK + all 8 container panels block; null + PATH_MARBLE walkable', () => {
-  assert.equal(isBlockingObject(null), false);
-  assert.equal(isBlockingObject(undefined), false);
-  assert.equal(isBlockingObject(OBJECT.ROCK), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_TL), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_T1), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_T2), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_TR), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_DOOR), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_B1), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_B2), true);
-  assert.equal(isBlockingObject(OBJECT.CONTAINER_PANEL_BR), true);
-  // ADR 0013: paths are non-blocking objects (you walk on the path).
-  assert.equal(isBlockingObject(OBJECT.PATH_MARBLE), false);
-});
-
-// ---------- isBlocked over the actual INITIAL_MAP ------------------------------
-
-test('INITIAL_MAP contains the expected cell kinds', () => {
-  assert.ok(seaCell,   'no sea cell in INITIAL_MAP');
-  assert.ok(sandCell,  'no plain-sand cell in INITIAL_MAP');
-  assert.ok(grassCell, 'no plain-grass cell in INITIAL_MAP');
-  assert.ok(rockCell,  'no rock cell in INITIAL_MAP');
-  assert.ok(doorCell,  'no container-door cell in INITIAL_MAP');
-  assert.ok(panelCell, 'no container_panel_tl cell in INITIAL_MAP');
-});
-
-test('sea cells are blocked', () => {
-  assert.equal(isBlocked(seaCell.x, seaCell.y), true);
-});
-
-test('plain sand cells are walkable', () => {
-  assert.equal(isBlocked(sandCell.x, sandCell.y), false);
-});
-
-test('plain grass cells are walkable', () => {
-  assert.equal(isBlocked(grassCell.x, grassCell.y), false);
-});
-
-test('rock-on-grass cells are blocked (object wins)', () => {
-  // The ground at the rock cell is GRASS (walkable). The object is ROCK
-  // (blocking). isBlocked must return true.
-  assert.equal(INITIAL_MAP.ground[rockCell.y][rockCell.x], TERRAIN.GRASS);
-  assert.equal(INITIAL_MAP.objects[rockCell.y][rockCell.x], OBJECT.ROCK);
-  assert.equal(isBlocked(rockCell.x, rockCell.y), true);
-});
-
-test('container-door cells are blocked (object wins; ground is sand)', () => {
-  assert.equal(INITIAL_MAP.ground[doorCell.y][doorCell.x], TERRAIN.SAND);
-  assert.equal(INITIAL_MAP.objects[doorCell.y][doorCell.x], OBJECT.CONTAINER_PANEL_DOOR);
-  assert.equal(isBlocked(doorCell.x, doorCell.y), true);
-});
-
-test('all 8 container-panel cells share GROUND=sand and have an OBJECT', () => {
-  // Container is at anchor (13, 8), 2 rows x 4 cols.
-  for (let r = 0; r < 2; r++) {
-    for (let c = 0; c < 4; c++) {
-      const x = 13 + c, y = 8 + r;
-      assert.equal(INITIAL_MAP.ground[y][x], TERRAIN.SAND, `(${x},${y}) ground should be sand`);
-      assert.ok(INITIAL_MAP.objects[y][x], `(${x},${y}) object should not be null`);
-      assert.equal(isBlocked(x, y), true, `(${x},${y}) should be blocked`);
-    }
-  }
-});
-
-test('vendor cell (13, 9) ground=sand, object=container_panel_door, blocked', () => {
-  // Door MUST be at bottom-LEFT to preserve vendor placement.
-  assert.equal(INITIAL_MAP.ground[9][13], TERRAIN.SAND);
-  assert.equal(INITIAL_MAP.objects[9][13], OBJECT.CONTAINER_PANEL_DOOR);
-  assert.equal(isBlocked(13, 9), true);
-});
-
-test('cell south of vendor (13, 10) is walkable (path-as-object on sand)', () => {
-  // ADR 0013: marble path is now an OBJECT overlay over SAND ground.
-  // The player approaches the vendor from here (faces up + presses E),
-  // so the cell must remain walkable: sand is non-blocking ground +
-  // path_marble is a non-blocking object.
-  assert.equal(INITIAL_MAP.ground[10][13], TERRAIN.SAND);
-  assert.equal(INITIAL_MAP.objects[10][13], OBJECT.PATH_MARBLE);
-  assert.equal(isBlockingObject(OBJECT.PATH_MARBLE), false,
-               'PATH_MARBLE must be non-blocking (you walk on a path)');
-  assert.equal(isBlocked(13, 10), false);
-});
-
-test('marble path strip (rows 10-13, col 13) all walkable, all path-on-sand', () => {
-  // ADR 0013: the entire path strip is OBJECT.PATH_MARBLE over SAND.
-  // No cell should block; ground should be uniform sand.
-  for (let y = 10; y <= 13; y++) {
-    assert.equal(INITIAL_MAP.ground[y][13], TERRAIN.SAND,
-                 `(13,${y}) ground should be SAND under the path overlay`);
-    assert.equal(INITIAL_MAP.objects[y][13], OBJECT.PATH_MARBLE,
-                 `(13,${y}) object should be PATH_MARBLE`);
-    assert.equal(isBlocked(13, y), false,
-                 `(13,${y}) should be walkable (sand + non-blocking path)`);
-  }
-});
-
-test('out-of-bounds is blocked', () => {
-  assert.equal(isBlocked(-1, 0), true);
-  assert.equal(isBlocked(0, -1), true);
-  assert.equal(isBlocked(WORLD_COLS, 0), true);
-  assert.equal(isBlocked(0, WORLD_ROWS), true);
-});
-
-// ---------- summary -------------------------------------------------------------
-
-if (process.exitCode !== 1) {
-  console.log(`\n[walkability] OK — ${passed} tests passed`);
-} else {
-  console.error(`\n[walkability] FAIL — see output above`);
-  process.exit(1);
-}