BlueGit

timfa questward

Files

questward / server / tests / doors.test.js

doors.test.js

doors.test.js 8.0 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { fileURLToPath } from "node:url";
4import { join } from "node:path";
5import { BlockType, isBlockPassable, isChunkAtlasBakedBlock, blockLightOcclusionForBlock, blockBlocksRangedAttacks, LightOcclusion } from "../../shared/definitions/tiles.js";
6import { WOOD_TIER_ORDER } from "../../shared/definitions/materialTiers.js";
7import { MobId } from "../../shared/definitions/mobs.js";
8import {
9 composeDoorState,
10 doorSortSubOrder,
11 flipDoorState,
12 isDoorTraversable,
13 listAllDoorStates,
14 parseDoorState
15} from "../../shared/world/doors.js";
16import { buildSpriteCatalog } from "../src/assets/spriteCatalog.js";
17import { Component } from "../src/ecs/components.js";
18import { mobComponents } from "../src/simulation/spawners.js";
19import {
20 entityCanOpenDoors,
21 holdDoorForPassage,
22 maybeOpenDoorOnApproach,
23 stepDoors
24} from "../src/doors/service.js";
25import { makeCharacter, makeSimulation, walkTicks } from "./helpers/simulationHarness.js";
26
27const ASSET_ROOT = join(fileURLToPath(new URL("../../client/assets", import.meta.url)));
28
29function workerOf (simulation, entityId)
30{
31 const record = simulation.entityRecord(entityId);
32 assert.ok(record);
33 return simulation.workers[record.workerId];
34}
35
36function placeDoor (worker, tileX, tileY, state)
37{
38 const data = worker.world.chunkData(Math.floor(tileX / 16), Math.floor(tileY / 16));
39 const localX = ((tileX % 16) + 16) % 16;
40 const localY = ((tileY % 16) + 16) % 16;
41 data.blocks[localY * 16 + localX] = {
42 typeId: BlockType.door,
43 state,
44 config: null
45 };
46}
47
48function doorAt (worker, tileX, tileY)
49{
50 const data = worker.world.chunkData(Math.floor(tileX / 16), Math.floor(tileY / 16));
51 const localX = ((tileX % 16) + 16) % 16;
52 const localY = ((tileY % 16) + 16) % 16;
53 return data.blocks[localY * 16 + localX];
54}
55
56test("door states cover every wood facing and openness", () =>
57{
58 const states = listAllDoorStates();
59 assert.equal(states.length, WOOD_TIER_ORDER.length * 4);
60 assert.deepEqual(parseDoorState("oak-n-open"), { wood: "oak", facing: "n", open: true });
61 assert.equal(flipDoorState("pine-s-closed"), "pine-s-open");
62 assert.equal(flipDoorState("birch-n-open"), "birch-n-closed");
63 assert.equal(composeDoorState("elder", "n", false), "elder-n-closed");
64});
65
66test("closed doors block passability unless opener; open doors do not", () =>
67{
68 assert.equal(isBlockPassable(BlockType.door, "pine-s-closed"), false);
69 assert.equal(isBlockPassable(BlockType.door, "pine-s-open"), true);
70 assert.equal(isDoorTraversable({ state: "pine-s-closed" }, { canOpenDoors: false }), false);
71 assert.equal(isDoorTraversable({ state: "pine-s-closed" }, { canOpenDoors: true }), true);
72 assert.equal(isDoorTraversable({ state: "pine-s-open" }, { canOpenDoors: false }), true);
73});
74
75test("closed doors block light and ranged LoS; open doors do not", () =>
76{
77 assert.equal(blockLightOcclusionForBlock({ typeId: BlockType.door, state: "pine-s-closed" }), LightOcclusion.solid);
78 assert.equal(blockLightOcclusionForBlock({ typeId: BlockType.door, state: "pine-s-open" }), LightOcclusion.clear);
79 assert.equal(blockBlocksRangedAttacks(BlockType.door, "pine-s-closed"), true);
80 assert.equal(blockBlocksRangedAttacks(BlockType.door, "pine-s-open"), false);
81});
82
83test("door sort sub-order puts N-closed behind and S-closed in front", () =>
84{
85 assert.equal(doorSortSubOrder("pine-n-closed", 3), 1);
86 assert.equal(doorSortSubOrder("pine-s-closed", 3), 4);
87 assert.equal(doorSortSubOrder("pine-n-open", 3), 3);
88 assert.equal(doorSortSubOrder("pine-s-open", 3), 3);
89});
90
91test("doors are per-tile sprites with tinted catalog states", () =>
92{
93 assert.equal(isChunkAtlasBakedBlock({ typeId: BlockType.door, state: "pine-s-closed" }), false);
94 const catalog = buildSpriteCatalog(ASSET_ROOT);
95 assert.equal(catalog.blocks.door.defaultState, "pine-s-closed");
96 assert.equal(catalog.blocks.door.states.length, WOOD_TIER_ORDER.length * 4);
97 assert.ok(catalog.images.some((image) => image.name === "block:door:oak-n-open"));
98 const tinted = catalog.images.find((image) => image.name === "block:door:pine-s-closed");
99 assert.ok(tinted?.tint);
100});
101
102test("players and humanoids can open doors; rats cannot unless already open", () =>
103{
104 const harness = makeSimulation({ workerCount: 1 });
105 try
106 {
107 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
108 harness.simulation.spawnCharacter(1, character);
109 const humanoidId = harness.simulation.spawnEntity(mobComponents({
110 tileX: 10,
111 tileY: 8,
112 mobTypeId: MobId.humanoid
113 }));
114 const ratId = harness.simulation.spawnEntity(mobComponents({
115 tileX: 11,
116 tileY: 8,
117 mobTypeId: MobId.rat
118 }));
119 harness.simulation.step();
120
121 const worker = workerOf(harness.simulation, character.character_id);
122 assert.equal(entityCanOpenDoors(worker.world.ecs, character.character_id), true);
123 assert.equal(entityCanOpenDoors(worker.world.ecs, humanoidId), true);
124 assert.equal(entityCanOpenDoors(worker.world.ecs, ratId), false);
125
126 placeDoor(worker, 9, 8, "pine-s-closed");
127 assert.equal(worker.world.walkableFor(character.character_id, 9, 8), true);
128 assert.equal(worker.world.walkableFor(ratId, 9, 8), false);
129
130 placeDoor(worker, 9, 8, "pine-s-open");
131 assert.equal(worker.world.walkableFor(ratId, 9, 8), true);
132 }
133 finally
134 { harness.close(); }
135});
136
137test("approaching a closed door opens it and restores when vicinity clears", () =>
138{
139 const harness = makeSimulation({ workerCount: 1 });
140 try
141 {
142 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
143 harness.simulation.spawnCharacter(1, character);
144 harness.simulation.step();
145 const worker = workerOf(harness.simulation, character.character_id);
146 placeDoor(worker, 9, 8, "oak-n-closed");
147
148 const opened = maybeOpenDoorOnApproach(worker.world, character.character_id, 9, 8);
149 assert.ok(opened);
150 assert.equal(opened.block.state, "oak-n-open");
151 assert.equal(doorAt(worker, 9, 8).state, "oak-n-open");
152 assert.equal(doorAt(worker, 9, 8).config?.restingState, "oak-n-closed");
153
154 const stillHeld = stepDoors(worker.world);
155 assert.equal(stillHeld.length, 0);
156 assert.equal(doorAt(worker, 9, 8).state, "oak-n-open");
157
158 const handle = worker.world.ecs.handleOf(character.character_id);
159 const position = worker.world.ecs.get(handle, Component.position);
160 position.tileX = 12;
161 position.tileY = 8;
162
163 const restored = stepDoors(worker.world);
164 assert.equal(restored.length, 1);
165 assert.equal(restored[0].block.state, "oak-n-closed");
166 assert.equal(doorAt(worker, 9, 8).state, "oak-n-closed");
167 }
168 finally
169 { harness.close(); }
170});
171
172test("player walking through a door flips it open via movement", () =>
173{
174 const harness = makeSimulation({ workerCount: 1 });
175 try
176 {
177 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
178 harness.simulation.spawnCharacter(1, character);
179 harness.simulation.step();
180 const worker = workerOf(harness.simulation, character.character_id);
181 placeDoor(worker, 9, 8, "pine-s-closed");
182
183 const handle = worker.world.ecs.handleOf(character.character_id);
184 const path = worker.world.ecs.get(handle, Component.path)
185 ?? worker.world.ecs.add(handle, Component.path, { tiles: [] });
186 path.tiles = [{ x: 9, y: 8 }, { x: 10, y: 8 }];
187
188 for (let i = 0; i < walkTicks(2); i++)
189 {
190 harness.advance(50);
191 harness.simulation.step();
192 }
193
194 assert.equal(doorAt(worker, 9, 8).state, "pine-s-open");
195 const position = worker.world.ecs.get(handle, Component.position);
196 assert.ok(position.tileX >= 9);
197 }
198 finally
199 { harness.close(); }
200});
201
202test("holdDoorForPassage remembers resting open without flipping again", () =>
203{
204 const harness = makeSimulation({ workerCount: 1 });
205 try
206 {
207 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
208 harness.simulation.spawnCharacter(1, character);
209 harness.simulation.step();
210 const worker = workerOf(harness.simulation, character.character_id);
211 placeDoor(worker, 9, 8, "pine-s-open");
212
213 assert.equal(holdDoorForPassage(worker.world, 9, 8), null);
214 assert.ok(worker.world.heldDoors?.size > 0);
215 assert.equal(doorAt(worker, 9, 8).state, "pine-s-open");
216 }
217 finally
218 { harness.close(); }
219});