kgames

fire-truck-decor.test.js (4394B)

---

 'use strict';
 
 const test = require('node:test');
 const assert = require('node:assert');
 const FT = require('../../games/fire-truck/lib.js');
 
 function makeIsland(seed) {
   return FT.buildIsland({ width: 50, height: 50, routeCount: 50, seed: seed ?? 1 });
 }
 
 test('hashCell is deterministic and in [0,1)', () => {
   for (let i = 0; i < 200; i++) {
     const x = (i * 7) % 50;
     const y = (i * 13) % 50;
     const a = FT.hashCell(x, y, 3);
     const b = FT.hashCell(x, y, 3);
     assert.strictEqual(a, b, 'same inputs → same output');
     assert.ok(a >= 0 && a < 1, `in range: ${a}`);
   }
   // Salt changes the value (very likely)
   assert.notStrictEqual(FT.hashCell(4, 9, 1), FT.hashCell(4, 9, 2));
 });
 
 test('findBuildingBlocks returns disjoint rectangles covering all building cells', () => {
   const island = makeIsland(2);
   const blocks = FT.findBuildingBlocks(island.grid);
   const covered = new Set();
   for (const b of blocks) {
     assert.ok(b.w >= 1 && b.h >= 1, 'positive size');
     for (let yy = b.y; yy < b.y + b.h; yy++) {
       for (let xx = b.x; xx < b.x + b.w; xx++) {
         const key = xx + ',' + yy;
         assert.ok(!covered.has(key), `no overlap at ${key}`);
         covered.add(key);
         assert.strictEqual(island.grid[yy][xx].type, FT.CELL_TYPES.BUILDING,
           `block cell ${key} is a building`);
       }
     }
   }
   // Every building cell is covered by exactly one block
   for (let y = 0; y < island.height; y++) {
     for (let x = 0; x < island.width; x++) {
       if (island.grid[y][x].type === FT.CELL_TYPES.BUILDING) {
         assert.ok(covered.has(x + ',' + y), `building ${x},${y} covered`);
       }
     }
   }
 });
 
 test('assignParks is deterministic and keeps type building', () => {
   const a = makeIsland(3);
   const b = makeIsland(3);
   FT.assignParks(a, { fraction: 0.15 });
   FT.assignParks(b, { fraction: 0.15 });
   let parkCount = 0;
   for (let y = 0; y < a.height; y++) {
     for (let x = 0; x < a.width; x++) {
       const ca = a.grid[y][x];
       const cb = b.grid[y][x];
       assert.strictEqual(!!ca.park, !!cb.park, `deterministic park tag at ${x},${y}`);
       if (ca.park) {
         parkCount++;
         assert.strictEqual(ca.type, FT.CELL_TYPES.BUILDING, 'park stays type building');
       }
     }
   }
   assert.ok(parkCount > 0, 'at least one park tagged');
 });
 
 test('advanceCarPlan stays on roads and avoids immediate reversal', () => {
   const island = makeIsland(4);
   const rand = FT.createSeededRng(99);
   let cell = island.roads[0];
   let heading = 'east';
   for (const card of ['N', 'E', 'S', 'W']) {
     if (cell.exits[card]) { heading = FT.CARD_TO_HEADING[card]; break; }
   }
   for (let i = 0; i < 500; i++) {
     const prev = cell;
     const next = FT.advanceCarPlan(island.grid, cell, heading, rand);
     assert.strictEqual(next.cell.type, FT.CELL_TYPES.ROAD, `step ${i} on road`);
     // No immediate reversal unless the current cell is a straight/dead corridor
     // where reversing is the only option (avoidable = >1 exit besides back).
     const exits = ['N', 'E', 'S', 'W'].filter(c => prev.exits[c]);
     const back = FT.OPPOSITE[heading];
     const forwardOptions = exits
       .map(c => FT.CARD_TO_HEADING[c])
       .filter(h => h !== back);
     if (forwardOptions.length > 0) {
       assert.notStrictEqual(next.heading, back, `step ${i} did not reverse when avoidable`);
     }
     cell = next.cell;
     heading = next.heading;
   }
 });
 
 test('sidewalkEdges flags building-adjacent edges of a road cell', () => {
   const island = makeIsland(5);
   // The ring road (index 2) has beach outside and buildings inside.
   // Find a straight vertical stretch of the left ring road.
   const cell = island.grid[25][2];
   assert.strictEqual(cell.type, FT.CELL_TYPES.ROAD, 'ring cell is road');
   const edges = FT.sidewalkEdges(island.grid, 2, 25);
   assert.strictEqual(edges.E, true, 'east edge abuts building interior');
   assert.strictEqual(edges.W, false, 'west edge abuts beach, not building');
 });
 
 test('pickFireDestination never targets a park building', () => {
   const island = makeIsland(6);
   FT.assignParks(island, { fraction: 0.3 });
   const rand = FT.createSeededRng(1234);
   for (let i = 0; i < 50; i++) {
     const dest = FT.pickFireDestination(island, rand, {});
     if (!dest) continue;
     assert.ok(!dest.buildingCell.park, `dest ${dest.buildingCell.x},${dest.buildingCell.y} is not a park`);
   }
 });