@bongos/core 1.17.1 → 1.17.3

package/tests/turn_in_place.mjs

@@ -1,280 +0,0 @@
-// tests/turn_in_place.mjs
-//
-// Turn-in-place (#1057): quick-tap a direction to face it without stepping;
-// hold past the threshold to walk as before. Exercises the pure movement
-// helpers (Phaser-free, DB-free) that drive Player.update:
-//   - decideMove(dir, facing, heldMs, threshold) — the tap-vs-hold rule.
-//   - readDirectionFromInput(moveKeys) — WASD + arrow key resolution.
-// Plus a frame-by-frame simulation proving a real tap never steps and a
-// real hold does.
-//
-// Run:  node tests/turn_in_place.mjs
-
-import { strict as assert } from 'node:assert';
-import {
-  decideMove,
-  readDirectionFromInput,
-  TURN_TAP_MS,
-  DIRS,
-} from '../modules/game/public/game/player/movement.js';
-
-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;
-  }
-}
-
-// A Phaser Key stand-in — readDirectionFromInput only reads these two props.
-const key = (isDown, timeDown = 0) => ({ isDown, timeDown });
-const NONE = key(false);
-
-// ---------- decideMove: the tap-vs-hold rule -----------------------------
-
-test('quick tap of a NEW direction turns, never steps (even if heldMs is large)', () => {
-  // A fresh press in a new direction always pivots first and never steps the
-  // same frame — so a quick tap of a new direction can only ever face it.
-  assert.deepEqual(decideMove('left', 'down', 5, TURN_TAP_MS), { turn: true, step: false });
-  assert.deepEqual(decideMove('up', 'down', 9999, TURN_TAP_MS), { turn: true, step: false });
-});
-
-test('already facing + held below threshold = no-op (a quick tap is just a look)', () => {
-  assert.deepEqual(decideMove('down', 'down', 0, TURN_TAP_MS), { turn: false, step: false });
-  assert.deepEqual(decideMove('down', 'down', TURN_TAP_MS - 1, TURN_TAP_MS), { turn: false, step: false });
-});
-
-test('already facing + held at/over threshold = step (walk)', () => {
-  assert.deepEqual(decideMove('down', 'down', TURN_TAP_MS, TURN_TAP_MS), { turn: false, step: true });
-  assert.deepEqual(decideMove('right', 'right', TURN_TAP_MS + 500, TURN_TAP_MS), { turn: false, step: true });
-});
-
-test('no direction held = nothing', () => {
-  assert.deepEqual(decideMove(null, 'down', 9999, TURN_TAP_MS), { turn: false, step: false });
-});
-
-test('threshold sits in the task-specified 120-150ms band', () => {
-  assert.ok(TURN_TAP_MS >= 120 && TURN_TAP_MS <= 150, `TURN_TAP_MS=${TURN_TAP_MS}`);
-});
-
-// ---------- readDirectionFromInput: WASD + arrow bindings ----------------
-
-const dirKeys = (over) => ({
-  up: [NONE, NONE], down: [NONE, NONE], left: [NONE, NONE], right: [NONE, NONE], ...over,
-});
-
-test('nothing held resolves to null', () => {
-  assert.equal(readDirectionFromInput(dirKeys({})), null);
-});
-
-test('WASD drives direction (W = up)', () => {
-  const sel = readDirectionFromInput(dirKeys({ up: [key(true, 100), NONE] }));
-  assert.equal(sel.dir, 'up');
-  assert.equal(sel.t, 100);
-});
-
-test('arrow keys drive the same direction (#1057 added arrow bindings)', () => {
-  // second slot in each direction array is the cursor (arrow) key
-  const sel = readDirectionFromInput(dirKeys({ right: [NONE, key(true, 250)] }));
-  assert.equal(sel.dir, 'right');
-  assert.equal(sel.t, 250);
-});
-
-test('WASD + arrow for one direction use the most-recent press time', () => {
-  const sel = readDirectionFromInput(dirKeys({ down: [key(true, 100), key(true, 400)] }));
-  assert.equal(sel.dir, 'down');
-  assert.equal(sel.t, 400);
-});
-
-test('most-recently-pressed direction wins', () => {
-  const sel = readDirectionFromInput(dirKeys({
-    up:   [key(true, 100), NONE],
-    left: [key(true, 200), NONE],
-  }));
-  assert.equal(sel.dir, 'left');
-});
-
-test('opposing keys cancel (W+S held = no direction)', () => {
-  assert.equal(readDirectionFromInput(dirKeys({
-    up:   [key(true, 100), NONE],
-    down: [key(true, 110), NONE],
-  })), null);
-});
-
-test('opposing pair cancels but a third direction still resolves', () => {
-  const sel = readDirectionFromInput(dirKeys({
-    left:  [key(true, 100), NONE],
-    right: [key(true, 110), NONE],
-    up:    [key(true, 90), NONE],
-  }));
-  assert.equal(sel.dir, 'up');
-});
-
-test('equal timeDown breaks ties deterministically (up before left)', () => {
-  const sel = readDirectionFromInput(dirKeys({
-    up:   [key(true, 100), NONE],
-    left: [key(true, 100), NONE],
-  }));
-  assert.equal(sel.dir, 'up');
-});
-
-// ---------- frame-by-frame: a real tap vs a real hold --------------------
-
-// Drive the same decision loop Player.update runs, over a sequence of
-// frames. Each frame: resolve the held direction, compute heldMs = now - t,
-// decide, and apply (turn updates facing; step counts a tile move).
-function simulate(frames, startFacing = 'down') {
-  let facing = startFacing;
-  let steps = 0;
-  let turns = 0;
-  for (const f of frames) {
-    const sel = readDirectionFromInput(f.keys);
-    if (!sel) continue;
-    const { turn, step } = decideMove(sel.dir, facing, f.now - sel.t, TURN_TAP_MS);
-    if (turn) { facing = sel.dir; turns++; continue; }
-    if (step) { steps++; }
-  }
-  return { facing, steps, turns };
-}
-
-test('a quick tap of a new direction turns once and never steps', () => {
-  const pressedAt = 1000;
-  const held = (now) => dirKeys({ left: [key(true, pressedAt), NONE] });
-  // Press at 1000, sampled at 1000 and 1050, then released before 130ms.
-  const r = simulate([
-    { now: 1000, keys: held(1000) },
-    { now: 1050, keys: held(1050) },
-    { now: 1100, keys: dirKeys({}) }, // released (~100ms tap)
-  ]);
-  assert.equal(r.facing, 'left');
-  assert.equal(r.turns, 1);
-  assert.equal(r.steps, 0); // pure turn-in-place — no tile change
-});
-
-test('a quick tap while already facing that way is a no-op (no step)', () => {
-  const r = simulate([
-    { now: 1000, keys: dirKeys({ down: [key(true, 1000), NONE] }) },
-    { now: 1060, keys: dirKeys({ down: [key(true, 1060), NONE] }) },
-    { now: 1090, keys: dirKeys({}) }, // released (~90ms tap)
-  ], 'down');
-  assert.equal(r.facing, 'down');
-  assert.equal(r.turns, 0);
-  assert.equal(r.steps, 0);
-});
-
-test('holding a direction walks (turn then step past the threshold)', () => {
-  const pressedAt = 1000;
-  const r = simulate([
-    { now: 1000, keys: dirKeys({ left: [key(true, pressedAt), NONE] }) }, // turn
-    { now: 1050, keys: dirKeys({ left: [key(true, pressedAt), NONE] }) }, // still in tap window
-    { now: 1000 + TURN_TAP_MS + 10, keys: dirKeys({ left: [key(true, pressedAt), NONE] }) }, // step
-  ]);
-  assert.equal(r.facing, 'left');
-  assert.equal(r.turns, 1);
-  assert.equal(r.steps, 1);
-});
-
-test('holding the direction you already face walks after the threshold (no extra turn)', () => {
-  const pressedAt = 2000;
-  const r = simulate([
-    { now: 2000, keys: dirKeys({ up: [key(true, pressedAt), NONE] }) }, // within tap window: nothing
-    { now: 2000 + TURN_TAP_MS + 5, keys: dirKeys({ up: [key(true, pressedAt), NONE] }) }, // step
-  ], 'up');
-  assert.equal(r.turns, 0);
-  assert.equal(r.steps, 1);
-});
-
-// DIRS sanity — Player.update derives the target tile from these.
-test('DIRS deltas are the four cardinal unit steps', () => {
-  assert.deepEqual(DIRS.up, { dx: 0, dy: -1 });
-  assert.deepEqual(DIRS.down, { dx: 0, dy: 1 });
-  assert.deepEqual(DIRS.left, { dx: -1, dy: 0 });
-  assert.deepEqual(DIRS.right, { dx: 1, dy: 0 });
-});
-
-// ---------- integration: the real Player class with Phaser/DB mocks ------
-//
-// Player.js is Phaser-free at module load (it only touches the API at
-// runtime), so we can drive the real update() loop with light mocks and
-// assert the wiring: a pure turn sends 'turn' and changes NO position; a
-// held press sends 'move' and steps exactly one tile.
-
-const { Player } = await import('../modules/game/public/game/player/Player.js');
-
-function makePlayer() {
-  const sprite = {
-    x: 0, y: 0,
-    setOrigin() { return this; },
-    setDepth() { return this; },
-    setTexture() { return this; },
-    setFlipX() { return this; },
-    setPosition(x, y) { this.x = x; this.y = y; return this; },
-  };
-  const sent = [];
-  const scene = {
-    add: { image: () => sprite },
-    textures: { exists: () => false }, // canvas-fallback path in spriteTextureFor
-    isBlocked: () => false,
-    // Synchronous tween: fire onComplete immediately so the step settles
-    // within the same call (real Phaser tweens take STEP_MS).
-    tweens: { add: (cfg) => { if (cfg.onComplete) cfg.onComplete(); } },
-  };
-  const player = new Player(scene, 10, 10);
-  player.attachRoom({ send: (type, msg) => sent.push({ type, msg }) });
-  return { player, sent };
-}
-
-const keysFor = (dir, t) => dirKeys({ [dir]: [key(true, t), NONE] });
-
-test('integration: quick tap of a new direction → faces it, sends turn, NO position change', () => {
-  const { player, sent } = makePlayer();
-  assert.equal(player.facing, 'down');
-  player.update(keysFor('left', 1000), 1000); // press; dir != facing → turn
-  assert.equal(player.facing, 'left');
-  assert.equal(player.gridX, 10);
-  assert.equal(player.gridY, 10); // zero position change — the headline acceptance
-  assert.deepEqual(sent, [{ type: 'turn', msg: { dir: 'left' } }]);
-});
-
-test('integration: tap while already facing that way → no message, no move', () => {
-  const { player, sent } = makePlayer(); // starts facing down
-  player.update(keysFor('down', 2000), 2000 + 50); // held 50ms < threshold
-  assert.equal(player.gridX, 10);
-  assert.equal(player.gridY, 10);
-  assert.deepEqual(sent, []);
-});
-
-test('integration: holding past the threshold → sends move and steps one tile', () => {
-  const { player, sent } = makePlayer(); // facing down
-  // Already facing 'down'; hold past threshold → one step down (+1 y).
-  player.update(keysFor('down', 3000), 3000 + TURN_TAP_MS + 10);
-  assert.equal(player.gridY, 11);
-  assert.equal(player.gridX, 10);
-  assert.deepEqual(sent, [{ type: 'move', msg: { dir: 'down' } }]);
-});
-
-test('integration: turn frame never steps even when the key is already held long', () => {
-  const { player, sent } = makePlayer(); // facing down
-  // First time we see 'left' it differs from facing → must turn only, never
-  // step, regardless of how long the (newly-resolved) key reads as held.
-  player.update(keysFor('left', 100), 100 + 5000);
-  assert.equal(player.facing, 'left');
-  assert.equal(player.gridX, 10);
-  assert.equal(player.gridY, 10);
-  assert.deepEqual(sent, [{ type: 'turn', msg: { dir: 'left' } }]);
-});
-
-test('integration: blocked tile → faces direction but does not step', () => {
-  const { player, sent } = makePlayer();
-  player.scene.isBlocked = () => true;
-  player.facing = 'up'; // pretend already facing up
-  player.update(keysFor('up', 4000), 4000 + TURN_TAP_MS + 10); // would step, but blocked
-  assert.equal(player.gridY, 10); // unchanged
-  assert.deepEqual(sent, []); // beginWalk (which sends 'move') never reached
-});
-
-console.log(`\nturn_in_place: ${passed} passed`);

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);
-}