import test from "node:test"; import assert from "node:assert/strict"; import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js"; import { makeCharacter, ensureDimension, makeDimensionSimulation } from "./helpers/simulationHarness.js"; import { ItemId } from "../../shared/definitions/items.js"; import { Component } from "../src/ecs/components.js"; import { normalizeItemSpawnerConfig, ItemSpawnerAppearance, ITEM_SPAWNER_OPEN_DURATION_MS } from "../../shared/definitions/itemSpawners.js"; import { emptySlots, emptyEquipment } from "../../shared/items/inventory.js"; import { OVERWORLD_ID } from "../../shared/world/dimensions.js"; import { itemContainerAtTile, itemContainersInChunk, ensureItemSpawnerState } from "../src/itemSpawners/service.js"; const CAVE_ID = "item-spawner-cave"; function workerOf (simulation, playerId) { const record = simulation.entityRecord(playerId); return simulation.workers[record.workerId]; } function advanceMs (harness, ms) { const ticks = Math.ceil(ms / 50) + 3; for (let i = 0; i < ticks; i++) { harness.advance(50); harness.simulation.step(); } } function placeItemSpawner (harness, localX, localY, config, dimensionId) { ensureDimension(harness.worldDb, dimensionId); const data = createEmptyChunkData(); data.open = true; data.spawners = [{ localX, localY, config: normalizeItemSpawnerConfig({ spawnerId: `item-${localX}-${localY}`, ...config }) }]; harness.worldDb.saveChunkVersion( 0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data), dimensionId ); harness.simulation.reloadWorld(); } function spawnInCave (harness, tileX, tileY) { const character = makeCharacter(harness.stateDb, { tileX, tileY }); harness.stateDb.saveCharacterPosition(character.character_id, tileX, tileY, "walk", CAVE_ID); harness.stateDb.saveBag(character.character_id, { inventory: emptySlots(), equipment: emptyEquipment(), vault: [], vaultReserved: [] }); const playerId = harness.simulation.spawnCharacter(1, character); assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID); return { character, playerId }; } test("chest container spawns in custom dimension (not overworld)", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawner(harness, 9, 8, { appearance: ItemSpawnerAppearance.chest, material: "oak", items: [{ itemId: ItemId.apple, quantity: 2 }], respawnDelaySeconds: 60, spawnRangeTiles: 0 }, CAVE_ID); const { playerId } = spawnInCave(harness, 8, 8); advanceMs(harness, 200); const worker = workerOf(harness.simulation, playerId); const caveContainer = itemContainerAtTile(worker.world, 9, 8, CAVE_ID); assert.ok(caveContainer, "expected chest in cave"); assert.equal(caveContainer.dimensionId, CAVE_ID); assert.equal(itemContainerAtTile(worker.world, 9, 8, OVERWORLD_ID), null); const appear = [...ensureItemSpawnerState(worker.world).active.values()] .find((e) => e.mode === "container" && e.dimensionId === CAVE_ID); assert.ok(appear); assert.match(appear.spawnerId, new RegExp(`^${CAVE_ID}:`)); } finally { harness.close(); } }); test("open container from adjacent tile in same dimension grants loot", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawner(harness, 9, 8, { appearance: ItemSpawnerAppearance.barrel, items: [{ itemId: ItemId.apple, quantity: 2 }], respawnDelaySeconds: 60, spawnRangeTiles: 0 }, CAVE_ID); const { character, playerId } = spawnInCave(harness, 8, 8); advanceMs(harness, 200); const worker = workerOf(harness.simulation, playerId); const container = itemContainerAtTile(worker.world, 9, 8, CAVE_ID); assert.ok(container); harness.simulation.enqueue(1, { type: "open-item-container", characterId: character.character_id, containerId: container.containerId }); harness.simulation.step(); advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200); assert.equal(itemContainerAtTile(worker.world, 9, 8, CAVE_ID), null); const inventory = worker.world.ecs.get( worker.world.ecs.handleOf(playerId), Component.inventory ); const qty = (inventory?.slots ?? []) .filter((s) => s?.itemId === ItemId.apple) .reduce((n, s) => n + (s.quantity | 0), 0); assert.equal(qty, 2); } finally { harness.close(); } }); test("open container rejects player in wrong dimension", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawner(harness, 9, 8, { appearance: ItemSpawnerAppearance.crate, items: [{ itemId: ItemId.stick, quantity: 1 }], spawnRangeTiles: 0 }, CAVE_ID); // Seed cave sim so the container actually spawns, then leave a player in overworld. const seeder = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Seeder" }); harness.stateDb.saveCharacterPosition(seeder.character_id, 8, 8, "walk", CAVE_ID); const seederId = harness.simulation.spawnCharacter(2, seeder); advanceMs(harness, 200); const caveWorker = workerOf(harness.simulation, seederId); const container = itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID); assert.ok(container, "cave container must exist"); const containerId = container.containerId; const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Overworld" }); harness.stateDb.saveBag(overworld.character_id, { inventory: emptySlots(), equipment: emptyEquipment(), vault: [], vaultReserved: [] }); const overworldId = harness.simulation.spawnCharacter(1, overworld); assert.equal(harness.simulation.positionOf(overworldId).dimensionId, OVERWORLD_ID); harness.simulation.enqueue(1, { type: "open-item-container", characterId: overworld.character_id, containerId }); const step = harness.simulation.step(); const err = step.events.find((e) => e.type === "command-error"); assert.ok(err, JSON.stringify(step.events)); assert.match(err.message, /gone|container/i); assert.ok( itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID), "wrong-dim open must not consume cave container" ); } finally { harness.close(); } }); test("chunk snapshot itemContainers are filtered by dimension", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawner(harness, 9, 8, { appearance: ItemSpawnerAppearance.chest, items: [{ itemId: ItemId.stick, quantity: 1 }], spawnRangeTiles: 0 }, CAVE_ID); const { playerId } = spawnInCave(harness, 8, 8); advanceMs(harness, 200); const worker = workerOf(harness.simulation, playerId); const caveOnly = itemContainersInChunk(worker.world, 0, 0, CAVE_ID); const overworldOnly = itemContainersInChunk(worker.world, 0, 0, OVERWORLD_ID); assert.equal(caveOnly.length, 1); assert.equal(caveOnly[0].dimensionId, CAVE_ID); assert.equal(overworldOnly.length, 0); const caveSnap = harness.simulation.snapshotChunk(0, 0, false, CAVE_ID); const overSnap = harness.simulation.snapshotChunk(0, 0, false, OVERWORLD_ID); assert.equal(caveSnap.dimensionId, CAVE_ID); assert.equal(caveSnap.itemContainers?.length, 1); assert.equal(caveSnap.itemContainers[0].dimensionId, CAVE_ID); assert.equal(overSnap.dimensionId, OVERWORLD_ID); assert.equal(overSnap.itemContainers?.length ?? 0, 0); } finally { harness.close(); } }); test("item appearance ground pile spawns and respawns in custom dimension", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawner(harness, 9, 8, { appearance: ItemSpawnerAppearance.item, items: [{ itemId: ItemId.stick, quantity: 3 }], respawnDelaySeconds: 1, spawnRangeTiles: 0 }, CAVE_ID); const { character, playerId } = spawnInCave(harness, 9, 8); advanceMs(harness, 200); const worker = workerOf(harness.simulation, playerId); const ground = [...worker.world.groundItems.values()].filter( (item) => (item.source === "item-spawner" || item.itemSpawnerId) && item.dimensionId === CAVE_ID ); assert.ok(ground.length >= 1, "expected cave spawner ground item"); assert.equal(ground[0].stack.itemId, ItemId.stick); assert.equal( [...worker.world.groundItems.values()].filter( (item) => (item.source === "item-spawner" || item.itemSpawnerId) && item.dimensionId === OVERWORLD_ID ).length, 0 ); const groundItemId = ground[0].groundItemId; harness.simulation.enqueue(1, { type: "pickup-item", characterId: character.character_id, groundItemId }); harness.simulation.step(); assert.equal( [...worker.world.groundItems.values()].filter((i) => i.itemSpawnerId).length, 0 ); advanceMs(harness, 1500); const again = [...worker.world.groundItems.values()].filter( (item) => (item.source === "item-spawner" || item.itemSpawnerId) && item.dimensionId === CAVE_ID ); assert.ok(again.length >= 1, "expected respawned ground item still in cave"); assert.equal(again[0].dimensionId, CAVE_ID); } finally { harness.close(); } }); test("container respawn stays in custom dimension after open", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawner(harness, 9, 8, { appearance: ItemSpawnerAppearance.chest, items: [{ itemId: ItemId.apple, quantity: 1 }], respawnDelaySeconds: 1, spawnRangeTiles: 0 }, CAVE_ID); const { character, playerId } = spawnInCave(harness, 8, 8); advanceMs(harness, 200); const worker = workerOf(harness.simulation, playerId); const container = itemContainerAtTile(worker.world, 9, 8, CAVE_ID); assert.ok(container); harness.simulation.enqueue(1, { type: "open-item-container", characterId: character.character_id, containerId: container.containerId }); harness.simulation.step(); advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200); assert.equal(itemContainerAtTile(worker.world, 9, 8, CAVE_ID), null); advanceMs(harness, 1500); const again = itemContainerAtTile(worker.world, 9, 8, CAVE_ID); assert.ok(again, "expected chest respawn in cave"); assert.equal(again.dimensionId, CAVE_ID); assert.equal(itemContainerAtTile(worker.world, 9, 8, OVERWORLD_ID), null); } finally { harness.close(); } }); const SHARED_LOCAL_ID = "shared-local-spawner"; function placeItemSpawnerWithId (harness, localX, localY, config, dimensionId, spawnerId) { ensureDimension(harness.worldDb, dimensionId); const data = createEmptyChunkData(); data.open = true; data.spawners = [{ localX, localY, config: normalizeItemSpawnerConfig({ spawnerId, ...config }) }]; harness.worldDb.saveChunkVersion( 0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(data), dimensionId ); harness.simulation.reloadWorld(); } test("authored overworld + cave item spawners with same local spawnerId stay independent", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawnerWithId(harness, 9, 8, { appearance: ItemSpawnerAppearance.chest, material: "oak", items: [{ itemId: ItemId.apple, quantity: 1 }], respawnDelaySeconds: 60, spawnRangeTiles: 0 }, OVERWORLD_ID, SHARED_LOCAL_ID); placeItemSpawnerWithId(harness, 9, 8, { appearance: ItemSpawnerAppearance.chest, material: "oak", items: [{ itemId: ItemId.stick, quantity: 1 }], respawnDelaySeconds: 60, spawnRangeTiles: 0 }, CAVE_ID, SHARED_LOCAL_ID); const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "Over" }); harness.stateDb.saveBag(overworld.character_id, { inventory: emptySlots(), equipment: emptyEquipment(), vault: [], vaultReserved: [] }); const overworldId = harness.simulation.spawnCharacter(1, overworld); assert.equal(harness.simulation.positionOf(overworldId).dimensionId, OVERWORLD_ID); const caveChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "CaveLoot" }); harness.stateDb.saveCharacterPosition(caveChar.character_id, 8, 8, "walk", CAVE_ID); harness.stateDb.saveBag(caveChar.character_id, { inventory: emptySlots(), equipment: emptyEquipment(), vault: [], vaultReserved: [] }); const playerId = harness.simulation.spawnCharacter(2, caveChar); assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID); advanceMs(harness, 200); const caveWorker = workerOf(harness.simulation, playerId); const overWorker = workerOf(harness.simulation, overworldId); const caveContainer = itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID); const overContainer = itemContainerAtTile(overWorker.world, 9, 8, OVERWORLD_ID); assert.ok(caveContainer, "expected cave chest"); assert.ok(overContainer, "expected overworld chest"); assert.equal(caveContainer.dimensionId, CAVE_ID); assert.equal(overContainer.dimensionId, OVERWORLD_ID); assert.notEqual(caveContainer.containerId, overContainer.containerId); assert.equal(caveContainer.spawnerId, `${CAVE_ID}:${SHARED_LOCAL_ID}`); assert.equal(overContainer.spawnerId, `${OVERWORLD_ID}:${SHARED_LOCAL_ID}`); const active = [...ensureItemSpawnerState(caveWorker.world).active.values()]; const caveActive = active.filter((e) => e.dimensionId === CAVE_ID && e.spawnerId.endsWith(`:${SHARED_LOCAL_ID}`)); const overActive = active.filter((e) => e.dimensionId === OVERWORLD_ID && e.spawnerId.endsWith(`:${SHARED_LOCAL_ID}`)); assert.equal(caveActive.length, 1); assert.equal(overActive.length, 1); harness.simulation.enqueue(2, { type: "open-item-container", characterId: caveChar.character_id, containerId: caveContainer.containerId }); harness.simulation.step(); advanceMs(harness, ITEM_SPAWNER_OPEN_DURATION_MS + 200); assert.equal(itemContainerAtTile(caveWorker.world, 9, 8, CAVE_ID), null, "cave chest consumed"); assert.ok( itemContainerAtTile(overWorker.world, 9, 8, OVERWORLD_ID), "overworld chest must remain after cave open" ); const inventory = caveWorker.world.ecs.get( caveWorker.world.ecs.handleOf(playerId), Component.inventory ); const sticks = (inventory?.slots ?? []) .filter((s) => s?.itemId === ItemId.stick) .reduce((n, s) => n + (s.quantity | 0), 0); assert.equal(sticks, 1, "cave chest grants cave loot only"); } finally { harness.close(); } }); test("authored overworld + cave ground item spawners with same local spawnerId stay independent", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeItemSpawnerWithId(harness, 9, 8, { appearance: ItemSpawnerAppearance.item, items: [{ itemId: ItemId.apple, quantity: 1 }], respawnDelaySeconds: 60, spawnRangeTiles: 0 }, OVERWORLD_ID, SHARED_LOCAL_ID); placeItemSpawnerWithId(harness, 9, 8, { appearance: ItemSpawnerAppearance.item, items: [{ itemId: ItemId.stick, quantity: 1 }], respawnDelaySeconds: 60, spawnRangeTiles: 0 }, CAVE_ID, SHARED_LOCAL_ID); const overworld = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "PileOver" }); const overworldId = harness.simulation.spawnCharacter(1, overworld); const caveChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "PileCave" }); harness.stateDb.saveCharacterPosition(caveChar.character_id, 8, 8, "walk", CAVE_ID); const playerId = harness.simulation.spawnCharacter(2, caveChar); assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID); advanceMs(harness, 200); const worker = workerOf(harness.simulation, playerId); const caveGround = [...worker.world.groundItems.values()].filter( (item) => item.itemSpawnerId === `${CAVE_ID}:${SHARED_LOCAL_ID}` ); const overGround = [...worker.world.groundItems.values()].filter( (item) => item.itemSpawnerId === `${OVERWORLD_ID}:${SHARED_LOCAL_ID}` ); assert.equal(caveGround.length, 1); assert.equal(overGround.length, 1); assert.equal(caveGround[0].dimensionId, CAVE_ID); assert.equal(overGround[0].dimensionId, OVERWORLD_ID); assert.equal(caveGround[0].stack.itemId, ItemId.stick); assert.equal(overGround[0].stack.itemId, ItemId.apple); void overworldId; } finally { harness.close(); } });