BlueGit

timfa questward

Add non-overworld regression coverage for spawners and combat paths.

Item spawners, ground pickup, mob loot, and combat-logout despawn now assert custom dimensionId instead of silently falling back to overworld.

timfa Tim Falken · pushed by timfa

Authored 2026-09-15 · 2 months ago

Hash
64b985b7ba36060ee55154a164355e047e7594b3
Parent
d5d45a60
4 files changed +547 −2
server/tests/dimension-ground-items.test.js +57 −0
@@ -147,3 +147,60 @@ test("spawner collect requests scope legacy spawner ids by dimension", () =>
147 147 finally
148 148 { harness.close(); }
149 149 });
150
151 test("pickup rejects when player is in a different dimension than the item", () =>
152 {
153 const harness = makeDimHarness();
154 try
155 {
156 const caveChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "CaveDrop" });
157 harness.stateDb.saveCharacterPosition(caveChar.character_id, 8, 8, "walk", CAVE_ID);
158 harness.stateDb.saveBag(caveChar.character_id, {
159 inventory: [{ itemId: ItemId.paper, quantity: 1 }, ...emptySlots().slice(1)],
160 equipment: emptyEquipment(),
161 vault: [],
162 vaultReserved: []
163 });
164 const caveId = harness.simulation.spawnCharacter(2, caveChar);
165 assert.equal(harness.simulation.positionOf(caveId).dimensionId, CAVE_ID);
166
167 harness.simulation.enqueue(2, {
168 type: "drop-item",
169 characterId: caveChar.character_id,
170 slotIndex: 0,
171 quantity: 1
172 });
173 const dropped = harness.simulation.step();
174 const appear = dropped.events.find((event) => event.type === "ground-item-appear");
175 assert.ok(appear);
176 assert.equal(appear.dimensionId, CAVE_ID);
177 const groundItemId = appear.groundItemId;
178
179 const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "OwPickup" });
180 harness.stateDb.saveBag(overworld.character_id, {
181 inventory: emptySlots(),
182 equipment: emptyEquipment(),
183 vault: [],
184 vaultReserved: []
185 });
186 const overId = harness.simulation.spawnCharacter(1, overworld);
187 assert.equal(harness.simulation.positionOf(overId).dimensionId, OVERWORLD_ID);
188
189 harness.simulation.enqueue(1, {
190 type: "pickup-item",
191 characterId: overworld.character_id,
192 groundItemId
193 });
194 const result = harness.simulation.step();
195 const err = result.events.find((event) => event.type === "command-error");
196 assert.ok(err, JSON.stringify(result.events));
197 assert.match(err.message, /stand on the item/i);
198 assert.equal(
199 harness.stateDb.listGroundItemsInRegion(0, 0, 63, 63, CAVE_ID).length,
200 1,
201 "cave ground item must remain"
202 );
203 }
204 finally
205 { harness.close(); }
206 });
@@ -147,3 +147,60 @@ test("spawner collect requests scope legacy spawner ids by dimension", () =>
147 finally
147 finally
148 { harness.close(); }
148 { harness.close(); }
149});
149});
150
151test("pickup rejects when player is in a different dimension than the item", () =>
152{
153 const harness = makeDimHarness();
154 try
155 {
156 const caveChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "CaveDrop" });
157 harness.stateDb.saveCharacterPosition(caveChar.character_id, 8, 8, "walk", CAVE_ID);
158 harness.stateDb.saveBag(caveChar.character_id, {
159 inventory: [{ itemId: ItemId.paper, quantity: 1 }, ...emptySlots().slice(1)],
160 equipment: emptyEquipment(),
161 vault: [],
162 vaultReserved: []
163 });
164 const caveId = harness.simulation.spawnCharacter(2, caveChar);
165 assert.equal(harness.simulation.positionOf(caveId).dimensionId, CAVE_ID);
166
167 harness.simulation.enqueue(2, {
168 type: "drop-item",
169 characterId: caveChar.character_id,
170 slotIndex: 0,
171 quantity: 1
172 });
173 const dropped = harness.simulation.step();
174 const appear = dropped.events.find((event) => event.type === "ground-item-appear");
175 assert.ok(appear);
176 assert.equal(appear.dimensionId, CAVE_ID);
177 const groundItemId = appear.groundItemId;
178
179 const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "OwPickup" });
180 harness.stateDb.saveBag(overworld.character_id, {
181 inventory: emptySlots(),
182 equipment: emptyEquipment(),
183 vault: [],
184 vaultReserved: []
185 });
186 const overId = harness.simulation.spawnCharacter(1, overworld);
187 assert.equal(harness.simulation.positionOf(overId).dimensionId, OVERWORLD_ID);
188
189 harness.simulation.enqueue(1, {
190 type: "pickup-item",
191 characterId: overworld.character_id,
192 groundItemId
193 });
194 const result = harness.simulation.step();
195 const err = result.events.find((event) => event.type === "command-error");
196 assert.ok(err, JSON.stringify(result.events));
197 assert.match(err.message, /stand on the item/i);
198 assert.equal(
199 harness.stateDb.listGroundItemsInRegion(0, 0, 63, 63, CAVE_ID).length,
200 1,
201 "cave ground item must remain"
202 );
203 }
204 finally
205 { harness.close(); }
206});
server/tests/dimension-interactions.test.js +117 −0
@@ -6,7 +6,10 @@ import { join } from "node:path";
6 6 import { BlockType } from "../../shared/definitions/tiles.js";
7 7 import { CraftingStationId } from "../../shared/definitions/craftingStations.js";
8 8 import { MobId } from "../../shared/definitions/mobs.js";
9 import { ItemId } from "../../shared/definitions/items.js";
9 10 import { OVERWORLD_ID, DimensionLightingMode, DimensionSeasonMode } from "../../shared/world/dimensions.js";
11 import { COMBAT_LOGOUT_MS } from "../../shared/combat/combatLogout.js";
12 import { emptyEquipment, emptySlots } from "../../shared/items/inventory.js";
10 13 import { WorldDatabase } from "../src/persistence/worldDb.js";
11 14 import { StateDatabase } from "../src/persistence/stateDb.js";
12 15 import { Simulation } from "../src/simulation/simulation.js";
@@ -14,6 +17,7 @@ import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js
14 17 import { mobComponents } from "../src/simulation/spawners.js";
15 18 import { engageTarget, ensureMobCombat, stepCombat, stepAggression, applyDamageAndKill } from "../src/combat/service.js";
16 19 import { Component } from "../src/ecs/components.js";
20 import { WorkerMessage } from "../src/simulation/protocol.js";
17 21 import { eventInterestKeys } from "../src/gateway/eventInterest.js";
18 22 import { chunkKey, tileToChunk } from "../src/world/coordinates.js";
19 23 import { makeCharacter, openChunkStrip, writeOpenChunk } from "./helpers/simulationHarness.js";
@@ -268,3 +272,116 @@ test("character logout despawn carries dimensionId for cave interest", () =>
268 272 finally
269 273 { harness.close(); }
270 274 });
275
276 test("mob death loot ground-item-appear stays in cave dimension", () =>
277 {
278 const harness = makeCaveHarness();
279 try
280 {
281 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
282 harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID);
283 harness.stateDb.saveBag(character.character_id, {
284 inventory: emptySlots(),
285 equipment: emptyEquipment(),
286 vault: [],
287 vaultReserved: []
288 });
289 const playerId = harness.simulation.spawnCharacter(1, character);
290 const ratId = harness.simulation.spawnEntity(mobComponents({
291 tileX: 8,
292 tileY: 9,
293 mobTypeId: MobId.rat,
294 spawnerId: "cave-loot-rat",
295 dimensionId: CAVE_ID,
296 drops: [{ itemId: ItemId.stick, chance: 1, quantityMin: 1, quantityMax: 1 }]
297 }));
298 const worker = workerOf(harness.simulation, ratId);
299 worker.world.ecs.get(worker.world.ecs.handleOf(ratId), Component.health).current = 1;
300 const events = applyDamageAndKill(worker.world, playerId, ratId, 1, harness.now());
301 const appear = events.find((event) =>
302 event.type === "ground-item-appear" && event.stack?.itemId === ItemId.stick
303 );
304 assert.ok(appear, JSON.stringify(events.filter((e) => e.type === "ground-item-appear" || e.type === "mob-killed")));
305 assert.equal(appear.dimensionId, CAVE_ID);
306 assert.equal(appear.tileX, 8);
307 assert.equal(appear.tileY, 9);
308 const onGround = [...worker.world.groundItems.values()].filter(
309 (item) => item.dimensionId === CAVE_ID && item.stack?.itemId === ItemId.stick
310 );
311 assert.ok(onGround.length >= 1);
312 assert.equal(
313 [...worker.world.groundItems.values()].filter(
314 (item) => item.dimensionId === OVERWORLD_ID && item.stack?.itemId === ItemId.stick
315 ).length,
316 0
317 );
318 }
319 finally
320 { harness.close(); }
321 });
322
323 test("combat logout quiet despawn carries cave dimensionId", () =>
324 {
325 const harness = makeCaveHarness();
326 try
327 {
328 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
329 harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID);
330 const playerId = harness.simulation.spawnCharacter(1, character);
331 assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID);
332
333 const ratId = harness.simulation.spawnEntity(mobComponents({
334 tileX: 8,
335 tileY: 9,
336 mobTypeId: MobId.rat,
337 spawnerId: null,
338 dimensionId: CAVE_ID
339 }));
340 harness.simulation.enqueue(1, {
341 type: "attack",
342 characterId: character.character_id,
343 targetEntityId: ratId
344 });
345 harness.simulation.step();
346 assert.equal(
347 harness.simulation.beginCombatLogout(character.character_id),
348 true,
349 "expected combat logout after engaging"
350 );
351 harness.simulation.drainReplication();
352
353 const record = harness.simulation.entityRecord(playerId);
354 harness.simulation.workers[record.workerId].call({
355 type: WorkerMessage.clearCombat,
356 entityId: playerId,
357 targetEntityId: playerId
358 });
359 const track = harness.simulation.combatTracking.get(character.character_id);
360 assert.ok(track);
361 track.lastCombatActivityAt = harness.now() - COMBAT_LOGOUT_MS - 1;
362 track.wasInCombat = false;
363 const logout = harness.simulation.combatLogouts.get(character.character_id);
364 assert.ok(logout);
365 logout.startedAt = harness.now() - COMBAT_LOGOUT_MS - 1;
366
367 const replication = [];
368 for (let i = 0; i < 60; i++)
369 {
370 harness.advance(50);
371 const stepped = harness.simulation.step();
372 replication.push(...(stepped.replication ?? []));
373 replication.push(...harness.simulation.drainReplication());
374 }
375 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), false);
376 const despawn = replication.find((event) =>
377 event.type === "entity-despawn" && event.entityId === playerId
378 );
379 assert.ok(despawn, JSON.stringify(replication.filter((e) => e.type === "entity-despawn")));
380 assert.equal(despawn.dimensionId, CAVE_ID);
381 const keys = eventInterestKeys(despawn, () => null);
382 assert.equal(keys.dimensionId, CAVE_ID);
383 assert.notEqual(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(8), OVERWORLD_ID));
384 }
385 finally
386 { harness.close(); }
387 });
@@ -6,7 +6,10 @@ import { join } from "node:path";
6import { BlockType } from "../../shared/definitions/tiles.js";
6import { BlockType } from "../../shared/definitions/tiles.js";
7import { CraftingStationId } from "../../shared/definitions/craftingStations.js";
7import { CraftingStationId } from "../../shared/definitions/craftingStations.js";
8import { MobId } from "../../shared/definitions/mobs.js";
8import { MobId } from "../../shared/definitions/mobs.js";
9import { ItemId } from "../../shared/definitions/items.js";
9import { OVERWORLD_ID, DimensionLightingMode, DimensionSeasonMode } from "../../shared/world/dimensions.js";
10import { OVERWORLD_ID, DimensionLightingMode, DimensionSeasonMode } from "../../shared/world/dimensions.js";
11import { COMBAT_LOGOUT_MS } from "../../shared/combat/combatLogout.js";
12import { emptyEquipment, emptySlots } from "../../shared/items/inventory.js";
10import { WorldDatabase } from "../src/persistence/worldDb.js";
13import { WorldDatabase } from "../src/persistence/worldDb.js";
11import { StateDatabase } from "../src/persistence/stateDb.js";
14import { StateDatabase } from "../src/persistence/stateDb.js";
12import { Simulation } from "../src/simulation/simulation.js";
15import { Simulation } from "../src/simulation/simulation.js";
@@ -14,6 +17,7 @@ import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js
14import { mobComponents } from "../src/simulation/spawners.js";
17import { mobComponents } from "../src/simulation/spawners.js";
15import { engageTarget, ensureMobCombat, stepCombat, stepAggression, applyDamageAndKill } from "../src/combat/service.js";
18import { engageTarget, ensureMobCombat, stepCombat, stepAggression, applyDamageAndKill } from "../src/combat/service.js";
16import { Component } from "../src/ecs/components.js";
19import { Component } from "../src/ecs/components.js";
20import { WorkerMessage } from "../src/simulation/protocol.js";
17import { eventInterestKeys } from "../src/gateway/eventInterest.js";
21import { eventInterestKeys } from "../src/gateway/eventInterest.js";
18import { chunkKey, tileToChunk } from "../src/world/coordinates.js";
22import { chunkKey, tileToChunk } from "../src/world/coordinates.js";
19import { makeCharacter, openChunkStrip, writeOpenChunk } from "./helpers/simulationHarness.js";
23import { makeCharacter, openChunkStrip, writeOpenChunk } from "./helpers/simulationHarness.js";
@@ -268,3 +272,116 @@ test("character logout despawn carries dimensionId for cave interest", () =>
268 finally
272 finally
269 { harness.close(); }
273 { harness.close(); }
270});
274});
275
276test("mob death loot ground-item-appear stays in cave dimension", () =>
277{
278 const harness = makeCaveHarness();
279 try
280 {
281 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
282 harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID);
283 harness.stateDb.saveBag(character.character_id, {
284 inventory: emptySlots(),
285 equipment: emptyEquipment(),
286 vault: [],
287 vaultReserved: []
288 });
289 const playerId = harness.simulation.spawnCharacter(1, character);
290 const ratId = harness.simulation.spawnEntity(mobComponents({
291 tileX: 8,
292 tileY: 9,
293 mobTypeId: MobId.rat,
294 spawnerId: "cave-loot-rat",
295 dimensionId: CAVE_ID,
296 drops: [{ itemId: ItemId.stick, chance: 1, quantityMin: 1, quantityMax: 1 }]
297 }));
298 const worker = workerOf(harness.simulation, ratId);
299 worker.world.ecs.get(worker.world.ecs.handleOf(ratId), Component.health).current = 1;
300 const events = applyDamageAndKill(worker.world, playerId, ratId, 1, harness.now());
301 const appear = events.find((event) =>
302 event.type === "ground-item-appear" && event.stack?.itemId === ItemId.stick
303 );
304 assert.ok(appear, JSON.stringify(events.filter((e) => e.type === "ground-item-appear" || e.type === "mob-killed")));
305 assert.equal(appear.dimensionId, CAVE_ID);
306 assert.equal(appear.tileX, 8);
307 assert.equal(appear.tileY, 9);
308 const onGround = [...worker.world.groundItems.values()].filter(
309 (item) => item.dimensionId === CAVE_ID && item.stack?.itemId === ItemId.stick
310 );
311 assert.ok(onGround.length >= 1);
312 assert.equal(
313 [...worker.world.groundItems.values()].filter(
314 (item) => item.dimensionId === OVERWORLD_ID && item.stack?.itemId === ItemId.stick
315 ).length,
316 0
317 );
318 }
319 finally
320 { harness.close(); }
321});
322
323test("combat logout quiet despawn carries cave dimensionId", () =>
324{
325 const harness = makeCaveHarness();
326 try
327 {
328 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
329 harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID);
330 const playerId = harness.simulation.spawnCharacter(1, character);
331 assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID);
332
333 const ratId = harness.simulation.spawnEntity(mobComponents({
334 tileX: 8,
335 tileY: 9,
336 mobTypeId: MobId.rat,
337 spawnerId: null,
338 dimensionId: CAVE_ID
339 }));
340 harness.simulation.enqueue(1, {
341 type: "attack",
342 characterId: character.character_id,
343 targetEntityId: ratId
344 });
345 harness.simulation.step();
346 assert.equal(
347 harness.simulation.beginCombatLogout(character.character_id),
348 true,
349 "expected combat logout after engaging"
350 );
351 harness.simulation.drainReplication();
352
353 const record = harness.simulation.entityRecord(playerId);
354 harness.simulation.workers[record.workerId].call({
355 type: WorkerMessage.clearCombat,
356 entityId: playerId,
357 targetEntityId: playerId
358 });
359 const track = harness.simulation.combatTracking.get(character.character_id);
360 assert.ok(track);
361 track.lastCombatActivityAt = harness.now() - COMBAT_LOGOUT_MS - 1;
362 track.wasInCombat = false;
363 const logout = harness.simulation.combatLogouts.get(character.character_id);
364 assert.ok(logout);
365 logout.startedAt = harness.now() - COMBAT_LOGOUT_MS - 1;
366
367 const replication = [];
368 for (let i = 0; i < 60; i++)
369 {
370 harness.advance(50);
371 const stepped = harness.simulation.step();
372 replication.push(...(stepped.replication ?? []));
373 replication.push(...harness.simulation.drainReplication());
374 }
375 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), false);
376 const despawn = replication.find((event) =>
377 event.type === "entity-despawn" && event.entityId === playerId
378 );
379 assert.ok(despawn, JSON.stringify(replication.filter((e) => e.type === "entity-despawn")));
380 assert.equal(despawn.dimensionId, CAVE_ID);
381 const keys = eventInterestKeys(despawn, () => null);
382 assert.equal(keys.dimensionId, CAVE_ID);
383 assert.notEqual(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(8), OVERWORLD_ID));
384 }
385 finally
386 { harness.close(); }
387});
server/tests/helpers/simulationHarness.js +55 −2
@@ -5,10 +5,16 @@ import { WorldDatabase } from "../../src/persistence/worldDb.js";
5 5 import { StateDatabase } from "../../src/persistence/stateDb.js";
6 6 import { Simulation } from "../../src/simulation/simulation.js";
7 7 import { createEmptyChunkData, encodeChunkBlob } from "../../src/world/chunkData.js";
8 import
9 {
10 OVERWORLD_ID,
11 DimensionLightingMode,
12 DimensionSeasonMode
13 } from "../../../shared/world/dimensions.js";
8 14
9 15 let surname = 1;
10 16
11 export function writeOpenChunk (worldDb, chunkX, chunkY)
17 export function writeOpenChunk (worldDb, chunkX, chunkY, dimensionId = OVERWORLD_ID)
12 18 {
13 19 const data = createEmptyChunkData();
14 20 data.open = true;
@@ -17,10 +23,57 @@ export function writeOpenChunk (worldDb, chunkX, chunkY)
17 23 chunkY,
18 24 worldDb.getActiveRevisionId(),
19 25 true,
20 encodeChunkBlob(data)
26 encodeChunkBlob(data),
27 dimensionId
21 28 );
22 29 }
23 30
31 /** Register a custom dimension on the active revision (idempotent enough for tests). */
32 export function ensureDimension (worldDb, dimensionId, options = {})
33 {
34 const rev = worldDb.getActiveRevisionId();
35 worldDb.saveDimension(rev, {
36 dimensionId,
37 displayName: options.displayName ?? String(dimensionId),
38 lightingMode: options.lightingMode ?? DimensionLightingMode.alwaysLit,
39 seasonMode: options.seasonMode ?? DimensionSeasonMode.summer,
40 defaultGroundTypeId: options.defaultGroundTypeId ?? 1
41 });
42 return rev;
43 }
44
45 /**
46 * Overworld strip + one open chunk (and dimension row) for a custom dimensionId.
47 * Optional mutateCave(data) can seed blocks/spawners before save.
48 */
49 export function makeDimensionSimulation (dimensionId, options = {})
50 {
51 const harness = makeSimulation({
52 workerCount: options.workerCount ?? 1,
53 workerMode: options.workerMode,
54 maxChunkX: options.maxChunkX ?? 2,
55 extraChunks: options.extraChunks,
56 now: options.now,
57 graceMs: options.graceMs,
58 pinRegion: options.pinRegion
59 });
60 ensureDimension(harness.worldDb, dimensionId, options.dimension);
61 const data = createEmptyChunkData();
62 data.open = true;
63 if (typeof options.mutateChunk === "function")
64 { options.mutateChunk(data); }
65 harness.worldDb.saveChunkVersion(
66 options.chunkX ?? 0,
67 options.chunkY ?? 0,
68 harness.worldDb.getActiveRevisionId(),
69 true,
70 encodeChunkBlob(data),
71 dimensionId
72 );
73 harness.simulation.reloadWorld();
74 return harness;
75 }
76
24 77 export function openChunkStrip (worldDb, maxChunkX = 5)
25 78 {
26 79 for (let chunkX = 0; chunkX <= maxChunkX; chunkX++)
@@ -5,10 +5,16 @@ import { WorldDatabase } from "../../src/persistence/worldDb.js";
5import { StateDatabase } from "../../src/persistence/stateDb.js";
5import { StateDatabase } from "../../src/persistence/stateDb.js";
6import { Simulation } from "../../src/simulation/simulation.js";
6import { Simulation } from "../../src/simulation/simulation.js";
7import { createEmptyChunkData, encodeChunkBlob } from "../../src/world/chunkData.js";
7import { createEmptyChunkData, encodeChunkBlob } from "../../src/world/chunkData.js";
8import
9 {
10 OVERWORLD_ID,
11 DimensionLightingMode,
12 DimensionSeasonMode
13 } from "../../../shared/world/dimensions.js";
8
14
9let surname = 1;
15let surname = 1;
10
16
11export function writeOpenChunk (worldDb, chunkX, chunkY)
17export function writeOpenChunk (worldDb, chunkX, chunkY, dimensionId = OVERWORLD_ID)
12{
18{
13 const data = createEmptyChunkData();
19 const data = createEmptyChunkData();
14 data.open = true;
20 data.open = true;
@@ -17,10 +23,57 @@ export function writeOpenChunk (worldDb, chunkX, chunkY)
17 chunkY,
23 chunkY,
18 worldDb.getActiveRevisionId(),
24 worldDb.getActiveRevisionId(),
19 true,
25 true,
20 encodeChunkBlob(data)
26 encodeChunkBlob(data),
27 dimensionId
21 );
28 );
22}
29}
23
30
31/** Register a custom dimension on the active revision (idempotent enough for tests). */
32export function ensureDimension (worldDb, dimensionId, options = {})
33{
34 const rev = worldDb.getActiveRevisionId();
35 worldDb.saveDimension(rev, {
36 dimensionId,
37 displayName: options.displayName ?? String(dimensionId),
38 lightingMode: options.lightingMode ?? DimensionLightingMode.alwaysLit,
39 seasonMode: options.seasonMode ?? DimensionSeasonMode.summer,
40 defaultGroundTypeId: options.defaultGroundTypeId ?? 1
41 });
42 return rev;
43}
44
45/**
46 * Overworld strip + one open chunk (and dimension row) for a custom dimensionId.
47 * Optional mutateCave(data) can seed blocks/spawners before save.
48 */
49export function makeDimensionSimulation (dimensionId, options = {})
50{
51 const harness = makeSimulation({
52 workerCount: options.workerCount ?? 1,
53 workerMode: options.workerMode,
54 maxChunkX: options.maxChunkX ?? 2,
55 extraChunks: options.extraChunks,
56 now: options.now,
57 graceMs: options.graceMs,
58 pinRegion: options.pinRegion
59 });
60 ensureDimension(harness.worldDb, dimensionId, options.dimension);
61 const data = createEmptyChunkData();
62 data.open = true;
63 if (typeof options.mutateChunk === "function")
64 { options.mutateChunk(data); }
65 harness.worldDb.saveChunkVersion(
66 options.chunkX ?? 0,
67 options.chunkY ?? 0,
68 harness.worldDb.getActiveRevisionId(),
69 true,
70 encodeChunkBlob(data),
71 dimensionId
72 );
73 harness.simulation.reloadWorld();
74 return harness;
75}
76
24export function openChunkStrip (worldDb, maxChunkX = 5)
77export function openChunkStrip (worldDb, maxChunkX = 5)
25{
78{
26 for (let chunkX = 0; chunkX <= maxChunkX; chunkX++)
79 for (let chunkX = 0; chunkX <= maxChunkX; chunkX++)
server/tests/item-spawners-dimension.test.js added +318 −0
@@ -0,0 +1,318 @@
1 import test from "node:test";
2 import assert from "node:assert/strict";
3 import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js";
4 import { makeCharacter, ensureDimension, makeDimensionSimulation } from "./helpers/simulationHarness.js";
5 import { ItemId } from "../../shared/definitions/items.js";
6 import { Component } from "../src/ecs/components.js";
7 import
8 {
9 normalizeItemSpawnerConfig,
10 ItemSpawnerAppearance,
11 ITEM_SPAWNER_OPEN_DURATION_MS
12 } from "../../shared/definitions/itemSpawners.js";
13 import { emptySlots, emptyEquipment } from "../../shared/items/inventory.js";
14 import { OVERWORLD_ID } from "../../shared/world/dimensions.js";
15 import
16 {
17 itemContainerAtTile,
18 itemContainersInChunk,
19 ensureItemSpawnerState
20 } from "../src/itemSpawners/service.js";
21
22 const CAVE_ID = "item-spawner-cave";
23
24 function workerOf (simulation, playerId)
25 {
26 const record = simulation.entityRecord(playerId);
27 return simulation.workers[record.workerId];
28 }
29
30 function advanceMs (harness, ms)
31 {
32 const ticks = Math.ceil(ms / 50) + 3;
33 for (let i = 0; i < ticks; i++)
34 {
35 harness.advance(50);
36 harness.simulation.step();
37 }
38 }
39
40 function placeItemSpawner (harness, localX, localY, config, dimensionId)
41 {
42 ensureDimension(harness.worldDb, dimensionId);
43 const data = createEmptyChunkData();
44 data.open = true;
45 data.spawners = [{
46 localX,
47 localY,
48 config: normalizeItemSpawnerConfig({
49 spawnerId: `item-${localX}-${localY}`,
50 ...config
51 })
52 }];
53 harness.worldDb.saveChunkVersion(
54 0,
55 0,
56 harness.worldDb.getActiveRevisionId(),
57 true,
58 encodeChunkBlob(data),
59 dimensionId
60 );
61 harness.simulation.reloadWorld();
62 }
63
64 function spawnInCave (harness, tileX, tileY)
65 {
66 const character = makeCharacter(harness.stateDb, { tileX, tileY });
67 harness.stateDb.saveCharacterPosition(character.character_id, tileX, tileY, "walk", CAVE_ID);
68 harness.stateDb.saveBag(character.character_id, {
69 inventory: emptySlots(),
70 equipment: emptyEquipment(),
71 vault: [],
72 vaultReserved: []
73 });
74 const playerId = harness.simulation.spawnCharacter(1, character);
75 assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID);
76 return { character, playerId };
77 }
78
79 test("chest container spawns in custom dimension (not overworld)", () =>
80 {
81 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
82 try
83 {
84 placeItemSpawner(harness, 9, 8, {
85 appearance: ItemSpawnerAppearance.chest,
86 material: "oak",
87 items: [{ itemId: ItemId.apple, quantity: 2 }],
88 respawnDelaySeconds: 60,
89 spawnRangeTiles: 0
90 }, CAVE_ID);
91 const { playerId } = spawnInCave(harness, 8, 8);
92 advanceMs(harness, 200);
93
94 const worker = workerOf(harness.simulation, playerId);
95 const caveContainer = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
96 assert.ok(caveContainer, "expected chest in cave");
97 assert.equal(caveContainer.dimensionId, CAVE_ID);
98 assert.equal(itemContainerAtTile(worker.world, 9, 8, OVERWORLD_ID), null);
99
100 const appear = [...ensureItemSpawnerState(worker.world).active.values()]
101 .find((e) => e.mode === "container" && e.dimensionId === CAVE_ID);
102 assert.ok(appear);
103 assert.match(appear.spawnerId, new RegExp(`^${CAVE_ID}:`));
104 }
105 finally
106 { harness.close(); }
107 });
108
109 test("open container from adjacent tile in same dimension grants loot", () =>
110 {
111 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
112 try
113 {
114 placeItemSpawner(harness, 9, 8, {
115 appearance: ItemSpawnerAppearance.barrel,
116 items: [{ itemId: ItemId.apple, quantity: 2 }],
117 respawnDelaySeconds: 60,
118 spawnRangeTiles: 0
119 }, CAVE_ID);
120 const { character, playerId } = spawnInCave(harness, 8, 8);
121 advanceMs(harness, 200);
122
123 const worker = workerOf(harness.simulation, playerId);
124 const container = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
125 assert.ok(container);
126
127 harness.simulation.enqueue(1, {
128 type: "open-item-container",
129 characterId: character.character_id,
130 containerId: container.containerId
131 });
132 harness.simulation.step();
133 advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200);
134
135 assert.equal(itemContainerAtTile(worker.world, 9, 8, CAVE_ID), null);
136 const inventory = worker.world.ecs.get(
137 worker.world.ecs.handleOf(playerId),
138 Component.inventory
139 );
140 const qty = (inventory?.slots ?? [])
141 .filter((s) => s?.itemId === ItemId.apple)
142 .reduce((n, s) => n + (s.quantity | 0), 0);
143 assert.equal(qty, 2);
144 }
145 finally
146 { harness.close(); }
147 });
148
149 test("open container rejects player in wrong dimension", () =>
150 {
151 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
152 try
153 {
154 placeItemSpawner(harness, 9, 8, {
155 appearance: ItemSpawnerAppearance.crate,
156 items: [{ itemId: ItemId.stick, quantity: 1 }],
157 spawnRangeTiles: 0
158 }, CAVE_ID);
159
160 // Seed cave sim so the container actually spawns, then leave a player in overworld.
161 const seeder = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Seeder" });
162 harness.stateDb.saveCharacterPosition(seeder.character_id, 8, 8, "walk", CAVE_ID);
163 const seederId = harness.simulation.spawnCharacter(2, seeder);
164 advanceMs(harness, 200);
165 const caveWorker = workerOf(harness.simulation, seederId);
166 const container = itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID);
167 assert.ok(container, "cave container must exist");
168 const containerId = container.containerId;
169
170 const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Overworld" });
171 harness.stateDb.saveBag(overworld.character_id, {
172 inventory: emptySlots(),
173 equipment: emptyEquipment(),
174 vault: [],
175 vaultReserved: []
176 });
177 const overworldId = harness.simulation.spawnCharacter(1, overworld);
178 assert.equal(harness.simulation.positionOf(overworldId).dimensionId, OVERWORLD_ID);
179
180 harness.simulation.enqueue(1, {
181 type: "open-item-container",
182 characterId: overworld.character_id,
183 containerId
184 });
185 const step = harness.simulation.step();
186 const err = step.events.find((e) => e.type === "command-error");
187 assert.ok(err, JSON.stringify(step.events));
188 assert.match(err.message, /gone|container/i);
189 assert.ok(
190 itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID),
191 "wrong-dim open must not consume cave container"
192 );
193 }
194 finally
195 { harness.close(); }
196 });
197
198 test("chunk snapshot itemContainers are filtered by dimension", () =>
199 {
200 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
201 try
202 {
203 placeItemSpawner(harness, 9, 8, {
204 appearance: ItemSpawnerAppearance.chest,
205 items: [{ itemId: ItemId.stick, quantity: 1 }],
206 spawnRangeTiles: 0
207 }, CAVE_ID);
208 const { playerId } = spawnInCave(harness, 8, 8);
209 advanceMs(harness, 200);
210
211 const worker = workerOf(harness.simulation, playerId);
212 const caveOnly = itemContainersInChunk(worker.world, 0, 0, CAVE_ID);
213 const overworldOnly = itemContainersInChunk(worker.world, 0, 0, OVERWORLD_ID);
214 assert.equal(caveOnly.length, 1);
215 assert.equal(caveOnly[0].dimensionId, CAVE_ID);
216 assert.equal(overworldOnly.length, 0);
217
218 const caveSnap = harness.simulation.snapshotChunk(0, 0, false, CAVE_ID);
219 const overSnap = harness.simulation.snapshotChunk(0, 0, false, OVERWORLD_ID);
220 assert.equal(caveSnap.dimensionId, CAVE_ID);
221 assert.equal(caveSnap.itemContainers?.length, 1);
222 assert.equal(caveSnap.itemContainers[0].dimensionId, CAVE_ID);
223 assert.equal(overSnap.dimensionId, OVERWORLD_ID);
224 assert.equal(overSnap.itemContainers?.length ?? 0, 0);
225 }
226 finally
227 { harness.close(); }
228 });
229
230 test("item appearance ground pile spawns and respawns in custom dimension", () =>
231 {
232 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
233 try
234 {
235 placeItemSpawner(harness, 9, 8, {
236 appearance: ItemSpawnerAppearance.item,
237 items: [{ itemId: ItemId.stick, quantity: 3 }],
238 respawnDelaySeconds: 1,
239 spawnRangeTiles: 0
240 }, CAVE_ID);
241 const { character, playerId } = spawnInCave(harness, 9, 8);
242 advanceMs(harness, 200);
243
244 const worker = workerOf(harness.simulation, playerId);
245 const ground = [...worker.world.groundItems.values()].filter(
246 (item) => (item.source === "item-spawner" || item.itemSpawnerId)
247 && item.dimensionId === CAVE_ID
248 );
249 assert.ok(ground.length >= 1, "expected cave spawner ground item");
250 assert.equal(ground[0].stack.itemId, ItemId.stick);
251 assert.equal(
252 [...worker.world.groundItems.values()].filter(
253 (item) => (item.source === "item-spawner" || item.itemSpawnerId)
254 && item.dimensionId === OVERWORLD_ID
255 ).length,
256 0
257 );
258
259 const groundItemId = ground[0].groundItemId;
260 harness.simulation.enqueue(1, {
261 type: "pickup-item",
262 characterId: character.character_id,
263 groundItemId
264 });
265 harness.simulation.step();
266 assert.equal(
267 [...worker.world.groundItems.values()].filter((i) => i.itemSpawnerId).length,
268 0
269 );
270
271 advanceMs(harness, 1500);
272 const again = [...worker.world.groundItems.values()].filter(
273 (item) => (item.source === "item-spawner" || item.itemSpawnerId)
274 && item.dimensionId === CAVE_ID
275 );
276 assert.ok(again.length >= 1, "expected respawned ground item still in cave");
277 assert.equal(again[0].dimensionId, CAVE_ID);
278 }
279 finally
280 { harness.close(); }
281 });
282
283 test("container respawn stays in custom dimension after open", () =>
284 {
285 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
286 try
287 {
288 placeItemSpawner(harness, 9, 8, {
289 appearance: ItemSpawnerAppearance.chest,
290 items: [{ itemId: ItemId.apple, quantity: 1 }],
291 respawnDelaySeconds: 1,
292 spawnRangeTiles: 0
293 }, CAVE_ID);
294 const { character, playerId } = spawnInCave(harness, 8, 8);
295 advanceMs(harness, 200);
296
297 const worker = workerOf(harness.simulation, playerId);
298 const container = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
299 assert.ok(container);
300
301 harness.simulation.enqueue(1, {
302 type: "open-item-container",
303 characterId: character.character_id,
304 containerId: container.containerId
305 });
306 harness.simulation.step();
307 advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200);
308 assert.equal(itemContainerAtTile(worker.world, 9, 8, CAVE_ID), null);
309
310 advanceMs(harness, 1500);
311 const again = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
312 assert.ok(again, "expected chest respawn in cave");
313 assert.equal(again.dimensionId, CAVE_ID);
314 assert.equal(itemContainerAtTile(worker.world, 9, 8, OVERWORLD_ID), null);
315 }
316 finally
317 { harness.close(); }
318 });
@@ -0,0 +1,318 @@
1import test from "node:test";
2import assert from "node:assert/strict";
3import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js";
4import { makeCharacter, ensureDimension, makeDimensionSimulation } from "./helpers/simulationHarness.js";
5import { ItemId } from "../../shared/definitions/items.js";
6import { Component } from "../src/ecs/components.js";
7import
8 {
9 normalizeItemSpawnerConfig,
10 ItemSpawnerAppearance,
11 ITEM_SPAWNER_OPEN_DURATION_MS
12 } from "../../shared/definitions/itemSpawners.js";
13import { emptySlots, emptyEquipment } from "../../shared/items/inventory.js";
14import { OVERWORLD_ID } from "../../shared/world/dimensions.js";
15import
16 {
17 itemContainerAtTile,
18 itemContainersInChunk,
19 ensureItemSpawnerState
20 } from "../src/itemSpawners/service.js";
21
22const CAVE_ID = "item-spawner-cave";
23
24function workerOf (simulation, playerId)
25{
26 const record = simulation.entityRecord(playerId);
27 return simulation.workers[record.workerId];
28}
29
30function advanceMs (harness, ms)
31{
32 const ticks = Math.ceil(ms / 50) + 3;
33 for (let i = 0; i < ticks; i++)
34 {
35 harness.advance(50);
36 harness.simulation.step();
37 }
38}
39
40function placeItemSpawner (harness, localX, localY, config, dimensionId)
41{
42 ensureDimension(harness.worldDb, dimensionId);
43 const data = createEmptyChunkData();
44 data.open = true;
45 data.spawners = [{
46 localX,
47 localY,
48 config: normalizeItemSpawnerConfig({
49 spawnerId: `item-${localX}-${localY}`,
50 ...config
51 })
52 }];
53 harness.worldDb.saveChunkVersion(
54 0,
55 0,
56 harness.worldDb.getActiveRevisionId(),
57 true,
58 encodeChunkBlob(data),
59 dimensionId
60 );
61 harness.simulation.reloadWorld();
62}
63
64function spawnInCave (harness, tileX, tileY)
65{
66 const character = makeCharacter(harness.stateDb, { tileX, tileY });
67 harness.stateDb.saveCharacterPosition(character.character_id, tileX, tileY, "walk", CAVE_ID);
68 harness.stateDb.saveBag(character.character_id, {
69 inventory: emptySlots(),
70 equipment: emptyEquipment(),
71 vault: [],
72 vaultReserved: []
73 });
74 const playerId = harness.simulation.spawnCharacter(1, character);
75 assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID);
76 return { character, playerId };
77}
78
79test("chest container spawns in custom dimension (not overworld)", () =>
80{
81 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
82 try
83 {
84 placeItemSpawner(harness, 9, 8, {
85 appearance: ItemSpawnerAppearance.chest,
86 material: "oak",
87 items: [{ itemId: ItemId.apple, quantity: 2 }],
88 respawnDelaySeconds: 60,
89 spawnRangeTiles: 0
90 }, CAVE_ID);
91 const { playerId } = spawnInCave(harness, 8, 8);
92 advanceMs(harness, 200);
93
94 const worker = workerOf(harness.simulation, playerId);
95 const caveContainer = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
96 assert.ok(caveContainer, "expected chest in cave");
97 assert.equal(caveContainer.dimensionId, CAVE_ID);
98 assert.equal(itemContainerAtTile(worker.world, 9, 8, OVERWORLD_ID), null);
99
100 const appear = [...ensureItemSpawnerState(worker.world).active.values()]
101 .find((e) => e.mode === "container" && e.dimensionId === CAVE_ID);
102 assert.ok(appear);
103 assert.match(appear.spawnerId, new RegExp(`^${CAVE_ID}:`));
104 }
105 finally
106 { harness.close(); }
107});
108
109test("open container from adjacent tile in same dimension grants loot", () =>
110{
111 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
112 try
113 {
114 placeItemSpawner(harness, 9, 8, {
115 appearance: ItemSpawnerAppearance.barrel,
116 items: [{ itemId: ItemId.apple, quantity: 2 }],
117 respawnDelaySeconds: 60,
118 spawnRangeTiles: 0
119 }, CAVE_ID);
120 const { character, playerId } = spawnInCave(harness, 8, 8);
121 advanceMs(harness, 200);
122
123 const worker = workerOf(harness.simulation, playerId);
124 const container = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
125 assert.ok(container);
126
127 harness.simulation.enqueue(1, {
128 type: "open-item-container",
129 characterId: character.character_id,
130 containerId: container.containerId
131 });
132 harness.simulation.step();
133 advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200);
134
135 assert.equal(itemContainerAtTile(worker.world, 9, 8, CAVE_ID), null);
136 const inventory = worker.world.ecs.get(
137 worker.world.ecs.handleOf(playerId),
138 Component.inventory
139 );
140 const qty = (inventory?.slots ?? [])
141 .filter((s) => s?.itemId === ItemId.apple)
142 .reduce((n, s) => n + (s.quantity | 0), 0);
143 assert.equal(qty, 2);
144 }
145 finally
146 { harness.close(); }
147});
148
149test("open container rejects player in wrong dimension", () =>
150{
151 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
152 try
153 {
154 placeItemSpawner(harness, 9, 8, {
155 appearance: ItemSpawnerAppearance.crate,
156 items: [{ itemId: ItemId.stick, quantity: 1 }],
157 spawnRangeTiles: 0
158 }, CAVE_ID);
159
160 // Seed cave sim so the container actually spawns, then leave a player in overworld.
161 const seeder = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Seeder" });
162 harness.stateDb.saveCharacterPosition(seeder.character_id, 8, 8, "walk", CAVE_ID);
163 const seederId = harness.simulation.spawnCharacter(2, seeder);
164 advanceMs(harness, 200);
165 const caveWorker = workerOf(harness.simulation, seederId);
166 const container = itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID);
167 assert.ok(container, "cave container must exist");
168 const containerId = container.containerId;
169
170 const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Overworld" });
171 harness.stateDb.saveBag(overworld.character_id, {
172 inventory: emptySlots(),
173 equipment: emptyEquipment(),
174 vault: [],
175 vaultReserved: []
176 });
177 const overworldId = harness.simulation.spawnCharacter(1, overworld);
178 assert.equal(harness.simulation.positionOf(overworldId).dimensionId, OVERWORLD_ID);
179
180 harness.simulation.enqueue(1, {
181 type: "open-item-container",
182 characterId: overworld.character_id,
183 containerId
184 });
185 const step = harness.simulation.step();
186 const err = step.events.find((e) => e.type === "command-error");
187 assert.ok(err, JSON.stringify(step.events));
188 assert.match(err.message, /gone|container/i);
189 assert.ok(
190 itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID),
191 "wrong-dim open must not consume cave container"
192 );
193 }
194 finally
195 { harness.close(); }
196});
197
198test("chunk snapshot itemContainers are filtered by dimension", () =>
199{
200 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
201 try
202 {
203 placeItemSpawner(harness, 9, 8, {
204 appearance: ItemSpawnerAppearance.chest,
205 items: [{ itemId: ItemId.stick, quantity: 1 }],
206 spawnRangeTiles: 0
207 }, CAVE_ID);
208 const { playerId } = spawnInCave(harness, 8, 8);
209 advanceMs(harness, 200);
210
211 const worker = workerOf(harness.simulation, playerId);
212 const caveOnly = itemContainersInChunk(worker.world, 0, 0, CAVE_ID);
213 const overworldOnly = itemContainersInChunk(worker.world, 0, 0, OVERWORLD_ID);
214 assert.equal(caveOnly.length, 1);
215 assert.equal(caveOnly[0].dimensionId, CAVE_ID);
216 assert.equal(overworldOnly.length, 0);
217
218 const caveSnap = harness.simulation.snapshotChunk(0, 0, false, CAVE_ID);
219 const overSnap = harness.simulation.snapshotChunk(0, 0, false, OVERWORLD_ID);
220 assert.equal(caveSnap.dimensionId, CAVE_ID);
221 assert.equal(caveSnap.itemContainers?.length, 1);
222 assert.equal(caveSnap.itemContainers[0].dimensionId, CAVE_ID);
223 assert.equal(overSnap.dimensionId, OVERWORLD_ID);
224 assert.equal(overSnap.itemContainers?.length ?? 0, 0);
225 }
226 finally
227 { harness.close(); }
228});
229
230test("item appearance ground pile spawns and respawns in custom dimension", () =>
231{
232 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
233 try
234 {
235 placeItemSpawner(harness, 9, 8, {
236 appearance: ItemSpawnerAppearance.item,
237 items: [{ itemId: ItemId.stick, quantity: 3 }],
238 respawnDelaySeconds: 1,
239 spawnRangeTiles: 0
240 }, CAVE_ID);
241 const { character, playerId } = spawnInCave(harness, 9, 8);
242 advanceMs(harness, 200);
243
244 const worker = workerOf(harness.simulation, playerId);
245 const ground = [...worker.world.groundItems.values()].filter(
246 (item) => (item.source === "item-spawner" || item.itemSpawnerId)
247 && item.dimensionId === CAVE_ID
248 );
249 assert.ok(ground.length >= 1, "expected cave spawner ground item");
250 assert.equal(ground[0].stack.itemId, ItemId.stick);
251 assert.equal(
252 [...worker.world.groundItems.values()].filter(
253 (item) => (item.source === "item-spawner" || item.itemSpawnerId)
254 && item.dimensionId === OVERWORLD_ID
255 ).length,
256 0
257 );
258
259 const groundItemId = ground[0].groundItemId;
260 harness.simulation.enqueue(1, {
261 type: "pickup-item",
262 characterId: character.character_id,
263 groundItemId
264 });
265 harness.simulation.step();
266 assert.equal(
267 [...worker.world.groundItems.values()].filter((i) => i.itemSpawnerId).length,
268 0
269 );
270
271 advanceMs(harness, 1500);
272 const again = [...worker.world.groundItems.values()].filter(
273 (item) => (item.source === "item-spawner" || item.itemSpawnerId)
274 && item.dimensionId === CAVE_ID
275 );
276 assert.ok(again.length >= 1, "expected respawned ground item still in cave");
277 assert.equal(again[0].dimensionId, CAVE_ID);
278 }
279 finally
280 { harness.close(); }
281});
282
283test("container respawn stays in custom dimension after open", () =>
284{
285 const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });
286 try
287 {
288 placeItemSpawner(harness, 9, 8, {
289 appearance: ItemSpawnerAppearance.chest,
290 items: [{ itemId: ItemId.apple, quantity: 1 }],
291 respawnDelaySeconds: 1,
292 spawnRangeTiles: 0
293 }, CAVE_ID);
294 const { character, playerId } = spawnInCave(harness, 8, 8);
295 advanceMs(harness, 200);
296
297 const worker = workerOf(harness.simulation, playerId);
298 const container = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
299 assert.ok(container);
300
301 harness.simulation.enqueue(1, {
302 type: "open-item-container",
303 characterId: character.character_id,
304 containerId: container.containerId
305 });
306 harness.simulation.step();
307 advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200);
308 assert.equal(itemContainerAtTile(worker.world, 9, 8, CAVE_ID), null);
309
310 advanceMs(harness, 1500);
311 const again = itemContainerAtTile(worker.world, 9, 8, CAVE_ID);
312 assert.ok(again, "expected chest respawn in cave");
313 assert.equal(again.dimensionId, CAVE_ID);
314 assert.equal(itemContainerAtTile(worker.world, 9, 8, OVERWORLD_ID), null);
315 }
316 finally
317 { harness.close(); }
318});