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.
@@ -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
finally147
finally148
{ harness.close(); }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
try155
{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: 1172
});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
groundItemId193
});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
finally205
{ harness.close(); }206
});@@ -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";6
import { BlockType } from "../../shared/definitions/tiles.js";6
import { BlockType } from "../../shared/definitions/tiles.js";7
import { CraftingStationId } from "../../shared/definitions/craftingStations.js";7
import { CraftingStationId } from "../../shared/definitions/craftingStations.js";8
import { MobId } from "../../shared/definitions/mobs.js";8
import { MobId } from "../../shared/definitions/mobs.js";9
import { ItemId } from "../../shared/definitions/items.js";9
import { OVERWORLD_ID, DimensionLightingMode, DimensionSeasonMode } from "../../shared/world/dimensions.js";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
import { WorldDatabase } from "../src/persistence/worldDb.js";13
import { WorldDatabase } from "../src/persistence/worldDb.js";11
import { StateDatabase } from "../src/persistence/stateDb.js";14
import { StateDatabase } from "../src/persistence/stateDb.js";12
import { Simulation } from "../src/simulation/simulation.js";15
import { Simulation } from "../src/simulation/simulation.js";@@ -14,6 +17,7 @@ import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js14
import { mobComponents } from "../src/simulation/spawners.js";17
import { mobComponents } from "../src/simulation/spawners.js";15
import { engageTarget, ensureMobCombat, stepCombat, stepAggression, applyDamageAndKill } from "../src/combat/service.js";18
import { engageTarget, ensureMobCombat, stepCombat, stepAggression, applyDamageAndKill } from "../src/combat/service.js";16
import { Component } from "../src/ecs/components.js";19
import { Component } from "../src/ecs/components.js";20
import { WorkerMessage } from "../src/simulation/protocol.js";17
import { eventInterestKeys } from "../src/gateway/eventInterest.js";21
import { eventInterestKeys } from "../src/gateway/eventInterest.js";18
import { chunkKey, tileToChunk } from "../src/world/coordinates.js";22
import { chunkKey, tileToChunk } from "../src/world/coordinates.js";19
import { makeCharacter, openChunkStrip, writeOpenChunk } from "./helpers/simulationHarness.js";23
import { makeCharacter, openChunkStrip, writeOpenChunk } from "./helpers/simulationHarness.js";@@ -268,3 +272,116 @@ test("character logout despawn carries dimensionId for cave interest", () =>268
finally272
finally269
{ harness.close(); }273
{ harness.close(); }270
});274
});275
276
test("mob death loot ground-item-appear stays in cave dimension", () =>277
{278
const harness = makeCaveHarness();279
try280
{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.stick303
);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.stick310
);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.stick315
).length,316
0317
);318
}319
finally320
{ harness.close(); }321
});322
323
test("combat logout quiet despawn carries cave dimensionId", () =>324
{325
const harness = makeCaveHarness();326
try327
{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_ID339
}));340
harness.simulation.enqueue(1, {341
type: "attack",342
characterId: character.character_id,343
targetEntityId: ratId344
});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: playerId358
});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 === playerId378
);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
finally386
{ harness.close(); }387
});@@ -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";5
import { StateDatabase } from "../../src/persistence/stateDb.js";5
import { StateDatabase } from "../../src/persistence/stateDb.js";6
import { Simulation } from "../../src/simulation/simulation.js";6
import { Simulation } from "../../src/simulation/simulation.js";7
import { createEmptyChunkData, encodeChunkBlob } from "../../src/world/chunkData.js";7
import { createEmptyChunkData, encodeChunkBlob } from "../../src/world/chunkData.js";8
import9
{10
OVERWORLD_ID,11
DimensionLightingMode,12
DimensionSeasonMode13
} from "../../../shared/world/dimensions.js";8
14
9
let surname = 1;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
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
dimensionId21
);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 ?? 141
});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.pinRegion59
});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
dimensionId72
);73
harness.simulation.reloadWorld();74
return harness;75
}76
24
export function openChunkStrip (worldDb, maxChunkX = 5)77
export function openChunkStrip (worldDb, maxChunkX = 5)25
{78
{26
for (let chunkX = 0; chunkX <= maxChunkX; chunkX++)79
for (let chunkX = 0; chunkX <= maxChunkX; chunkX++)@@ -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 @@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
import8
{9
normalizeItemSpawnerConfig,10
ItemSpawnerAppearance,11
ITEM_SPAWNER_OPEN_DURATION_MS12
} from "../../shared/definitions/itemSpawners.js";13
import { emptySlots, emptyEquipment } from "../../shared/items/inventory.js";14
import { OVERWORLD_ID } from "../../shared/world/dimensions.js";15
import16
{17
itemContainerAtTile,18
itemContainersInChunk,19
ensureItemSpawnerState20
} 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
...config51
})52
}];53
harness.worldDb.saveChunkVersion(54
0,55
0,56
harness.worldDb.getActiveRevisionId(),57
true,58
encodeChunkBlob(data),59
dimensionId60
);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
try83
{84
placeItemSpawner(harness, 9, 8, {85
appearance: ItemSpawnerAppearance.chest,86
material: "oak",87
items: [{ itemId: ItemId.apple, quantity: 2 }],88
respawnDelaySeconds: 60,89
spawnRangeTiles: 090
}, 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
finally106
{ 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
try113
{114
placeItemSpawner(harness, 9, 8, {115
appearance: ItemSpawnerAppearance.barrel,116
items: [{ itemId: ItemId.apple, quantity: 2 }],117
respawnDelaySeconds: 60,118
spawnRangeTiles: 0119
}, 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.containerId131
});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.inventory139
);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
finally146
{ harness.close(); }147
});148
149
test("open container rejects player in wrong dimension", () =>150
{151
const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });152
try153
{154
placeItemSpawner(harness, 9, 8, {155
appearance: ItemSpawnerAppearance.crate,156
items: [{ itemId: ItemId.stick, quantity: 1 }],157
spawnRangeTiles: 0158
}, 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
containerId184
});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
finally195
{ harness.close(); }196
});197
198
test("chunk snapshot itemContainers are filtered by dimension", () =>199
{200
const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });201
try202
{203
placeItemSpawner(harness, 9, 8, {204
appearance: ItemSpawnerAppearance.chest,205
items: [{ itemId: ItemId.stick, quantity: 1 }],206
spawnRangeTiles: 0207
}, 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
finally227
{ 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
try234
{235
placeItemSpawner(harness, 9, 8, {236
appearance: ItemSpawnerAppearance.item,237
items: [{ itemId: ItemId.stick, quantity: 3 }],238
respawnDelaySeconds: 1,239
spawnRangeTiles: 0240
}, 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_ID248
);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_ID255
).length,256
0257
);258
259
const groundItemId = ground[0].groundItemId;260
harness.simulation.enqueue(1, {261
type: "pickup-item",262
characterId: character.character_id,263
groundItemId264
});265
harness.simulation.step();266
assert.equal(267
[...worker.world.groundItems.values()].filter((i) => i.itemSpawnerId).length,268
0269
);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_ID275
);276
assert.ok(again.length >= 1, "expected respawned ground item still in cave");277
assert.equal(again[0].dimensionId, CAVE_ID);278
}279
finally280
{ harness.close(); }281
});282
283
test("container respawn stays in custom dimension after open", () =>284
{285
const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 });286
try287
{288
placeItemSpawner(harness, 9, 8, {289
appearance: ItemSpawnerAppearance.chest,290
items: [{ itemId: ItemId.apple, quantity: 1 }],291
respawnDelaySeconds: 1,292
spawnRangeTiles: 0293
}, 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.containerId305
});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
finally317
{ harness.close(); }318
});