import test from "node:test"; import assert from "node:assert/strict"; import { mkdtempSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { BlockType } from "../../shared/definitions/tiles.js"; import { CraftingStationId } from "../../shared/definitions/craftingStations.js"; import { MobId } from "../../shared/definitions/mobs.js"; import { ItemId } from "../../shared/definitions/items.js"; import { OVERWORLD_ID, DimensionLightingMode, DimensionSeasonMode } from "../../shared/world/dimensions.js"; import { COMBAT_LOGOUT_MS } from "../../shared/combat/combatLogout.js"; import { emptyEquipment, emptySlots } from "../../shared/items/inventory.js"; import { WorldDatabase } from "../src/persistence/worldDb.js"; import { StateDatabase } from "../src/persistence/stateDb.js"; import { Simulation } from "../src/simulation/simulation.js"; import { createEmptyChunkData, encodeChunkBlob } from "../src/world/chunkData.js"; import { mobComponents } from "../src/simulation/spawners.js"; import { engageTarget, ensureMobCombat, stepCombat, stepAggression, applyDamageAndKill } from "../src/combat/service.js"; import { Component } from "../src/ecs/components.js"; import { WorkerMessage } from "../src/simulation/protocol.js"; import { eventInterestKeys } from "../src/gateway/eventInterest.js"; import { chunkKey, tileToChunk } from "../src/world/coordinates.js"; import { makeCharacter, openChunkStrip, writeOpenChunk, ensureDimension, makeDimensionSimulation, pinEastSplit } from "./helpers/simulationHarness.js"; import { normalizeQuestDef } from "../../shared/quests/normalize.js"; import { normalizeSpawnerConfig } from "../../shared/definitions/mobs.js"; import { regionKey } from "../src/world/coordinates.js"; import { CHURCH_LETTER_AUTHOR, formatChurchOfflineResurrectionBody } from "../../shared/courier/systemLetters.js"; const CAVE_ID = "test-cave"; function makeCaveHarness () { const dir = mkdtempSync(join(tmpdir(), "mmo-dim-interact-")); const worldDb = new WorldDatabase(join(dir, "world.sqlite")); const stateDb = new StateDatabase(join(dir, "state.sqlite")); openChunkStrip(worldDb, 2); const rev = worldDb.getActiveRevisionId(); worldDb.saveDimension(rev, { dimensionId: CAVE_ID, displayName: "Test Cave", lightingMode: DimensionLightingMode.alwaysLit, seasonMode: DimensionSeasonMode.summer, defaultGroundTypeId: 1 }); const cave = createEmptyChunkData(); cave.open = true; cave.blocks[8 * 16 + 9] = { typeId: BlockType.furnace, state: "furnace", config: null }; worldDb.saveChunkVersion(0, 0, rev, true, encodeChunkBlob(cave), CAVE_ID); writeOpenChunk(worldDb, 0, 0); let now = 1_000; const simulation = new Simulation(worldDb, stateDb, { workerCount: 1, workerMode: "inprocess", now: () => now }); return { simulation, worldDb, stateDb, now () { return now; }, advance (ms) { now += ms; }, close () { simulation.forceUnloadAll(); worldDb.close(); stateDb.close(); } }; } function workerOf (simulation, entityId) { const record = simulation.entityRecord(entityId); assert.ok(record, "entity record"); return simulation.workers[record.workerId]; } test("open furnace works in a non-overworld dimension", () => { const harness = makeCaveHarness(); try { const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); const playerId = harness.simulation.spawnCharacter(1, character); const position = harness.simulation.positionOf(playerId); assert.equal(position.dimensionId, CAVE_ID); harness.simulation.enqueue(1, { type: "open-station", characterId: character.character_id, stationId: CraftingStationId.furnace }); const result = harness.simulation.step(); assert.ok( result.events.some((event) => event.type === "station-open" && event.stationId === CraftingStationId.furnace), "expected station-open in cave" ); } finally { harness.close(); } }); test("melee combat ticks in a non-overworld dimension", () => { const harness = makeCaveHarness(); try { const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); const playerId = harness.simulation.spawnCharacter(1, character); assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID); const ratId = harness.simulation.spawnEntity(mobComponents({ tileX: 8, tileY: 9, mobTypeId: MobId.rat, spawnerId: null, dimensionId: CAVE_ID })); assert.equal(harness.simulation.positionOf(ratId).dimensionId, CAVE_ID); const worker = workerOf(harness.simulation, ratId); const world = worker.world; assert.ok(world.chunkIsSimulating(8, 9, CAVE_ID)); assert.equal(world.chunkIsSimulating(8, 9, OVERWORLD_ID), false); assert.ok(ensureMobCombat(world.ecs, ratId)); engageTarget(world.ecs, ratId, playerId, harness.now()); const combat = world.ecs.get(world.ecs.handleOf(ratId), Component.combat); combat.nextSwingAt = harness.now(); const events = stepCombat(world, harness.now()); const combatFx = events.find((event) => event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block" ); assert.ok( combatFx, `expected combat resolution in cave, got ${events.map((e) => e.type).join(",") || "none"}` ); assert.equal(combatFx.dimensionId, CAVE_ID); stepAggression(world, harness.now()); } finally { harness.close(); } }); test("mob kill entity-despawn carries cave dimensionId for interest", () => { const harness = makeCaveHarness(); try { const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); const playerId = harness.simulation.spawnCharacter(1, character); const ratId = harness.simulation.spawnEntity(mobComponents({ tileX: 8, tileY: 9, mobTypeId: MobId.rat, spawnerId: null, dimensionId: CAVE_ID })); const worker = workerOf(harness.simulation, ratId); const handle = worker.world.ecs.handleOf(ratId); worker.world.ecs.get(handle, Component.health).current = 1; const events = applyDamageAndKill(worker.world, playerId, ratId, 1, harness.now()); const despawn = events.find((event) => event.type === "entity-despawn" && event.entityId === ratId && event.cause === "death" ); assert.ok(despawn, "expected combat death despawn"); assert.equal(despawn.dimensionId, CAVE_ID); // Entity is already gone — interest must not fall back to overworld. const keys = eventInterestKeys(despawn, () => null); assert.equal(keys.dimensionId, CAVE_ID); assert.equal(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(9), CAVE_ID)); assert.notEqual(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(9), OVERWORLD_ID)); } finally { harness.close(); } }); test("cave rat kill advances killCount quest progress", () => { const harness = makeCaveHarness(); try { const quest = normalizeQuestDef({ questId: "kill-rats-cave", title: "Kill Rats", steps: [{ stepId: "step-1", title: "Hunt", objectives: [{ objectiveId: "obj-1", text: "Kill 5 rats", when: { all: [{ condition: { kind: "killCount", mobTypeId: "rat", count: 5 } }] } }], completionJournalText: "Done." }] }); const pending = harness.worldDb.ensurePendingRevision(1); harness.worldDb.saveQuestDef(pending, quest); harness.worldDb.promotePendingRevision(); harness.simulation.questContent.reload(); const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); const playerId = harness.simulation.spawnCharacter(1, character); harness.simulation.quests.startQuest(character.character_id, "kill-rats-cave", null, []); const ratId = harness.simulation.spawnEntity(mobComponents({ tileX: 8, tileY: 9, mobTypeId: MobId.rat, spawnerId: null, dimensionId: CAVE_ID })); const worker = workerOf(harness.simulation, ratId); worker.world.ecs.get(worker.world.ecs.handleOf(ratId), Component.health).current = 1; const killEvents = applyDamageAndKill(worker.world, playerId, ratId, 1, harness.now()); const mobKilled = killEvents.find((event) => event.type === "mob-killed"); assert.ok(mobKilled); const noteEvents = harness.simulation.quests.noteKill(character.character_id, { mobTypeId: mobKilled.mobTypeId, spawnerId: mobKilled.spawnerId }); assert.ok(noteEvents.some((event) => event.type === "questsDirty")); assert.equal( harness.stateDb.getQuestState(character.character_id, "kill-rats-cave").progress?.counters?.["mob:rat"], 1 ); const snap = harness.simulation.quests.questSnapshot(character.character_id); assert.equal(snap.quests[0].step.objectives[0].current, 1); assert.equal(snap.quests[0].step.objectives[0].required, 5); } finally { harness.close(); } }); test("character logout despawn carries dimensionId for cave interest", () => { const harness = makeCaveHarness(); try { const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); const entityId = harness.simulation.spawnCharacter(1, character); assert.equal(harness.simulation.positionOf(entityId).dimensionId, CAVE_ID); harness.simulation.drainReplication(); harness.simulation.despawnCharacter(character.character_id); const gone = harness.simulation.drainReplication(); const despawn = gone.find((event) => event.type === "entity-despawn" && event.entityId === entityId ); assert.ok(despawn, "expected entity-despawn replication"); assert.equal(despawn.dimensionId, CAVE_ID); const keys = eventInterestKeys(despawn, () => null); assert.equal(keys.dimensionId, CAVE_ID); assert.equal(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(8), CAVE_ID)); } finally { harness.close(); } }); test("mob death loot ground-item-appear stays in cave dimension", () => { const harness = makeCaveHarness(); try { const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); harness.stateDb.saveBag(character.character_id, { inventory: emptySlots(), equipment: emptyEquipment(), vault: [], vaultReserved: [] }); const playerId = harness.simulation.spawnCharacter(1, character); const ratId = harness.simulation.spawnEntity(mobComponents({ tileX: 8, tileY: 9, mobTypeId: MobId.rat, spawnerId: "cave-loot-rat", dimensionId: CAVE_ID, drops: [{ itemId: ItemId.stick, chance: 1, quantityMin: 1, quantityMax: 1 }] })); const worker = workerOf(harness.simulation, ratId); worker.world.ecs.get(worker.world.ecs.handleOf(ratId), Component.health).current = 1; const events = applyDamageAndKill(worker.world, playerId, ratId, 1, harness.now()); const appear = events.find((event) => event.type === "ground-item-appear" && event.stack?.itemId === ItemId.stick ); assert.ok(appear, JSON.stringify(events.filter((e) => e.type === "ground-item-appear" || e.type === "mob-killed"))); assert.equal(appear.dimensionId, CAVE_ID); assert.equal(appear.tileX, 8); assert.equal(appear.tileY, 9); const onGround = [...worker.world.groundItems.values()].filter( (item) => item.dimensionId === CAVE_ID && item.stack?.itemId === ItemId.stick ); assert.ok(onGround.length >= 1); assert.equal( [...worker.world.groundItems.values()].filter( (item) => item.dimensionId === OVERWORLD_ID && item.stack?.itemId === ItemId.stick ).length, 0 ); } finally { harness.close(); } }); test("combat logout quiet despawn carries cave dimensionId", () => { const harness = makeCaveHarness(); try { const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 }); harness.stateDb.saveCharacterPosition(character.character_id, 8, 8, "walk", CAVE_ID); const playerId = harness.simulation.spawnCharacter(1, character); assert.equal(harness.simulation.positionOf(playerId).dimensionId, CAVE_ID); const ratId = harness.simulation.spawnEntity(mobComponents({ tileX: 8, tileY: 9, mobTypeId: MobId.rat, spawnerId: null, dimensionId: CAVE_ID })); harness.simulation.enqueue(1, { type: "attack", characterId: character.character_id, targetEntityId: ratId }); harness.simulation.step(); assert.equal( harness.simulation.beginCombatLogout(character.character_id), true, "expected combat logout after engaging" ); harness.simulation.drainReplication(); const record = harness.simulation.entityRecord(playerId); harness.simulation.workers[record.workerId].call({ type: WorkerMessage.clearCombat, entityId: playerId, targetEntityId: playerId }); const track = harness.simulation.combatTracking.get(character.character_id); assert.ok(track); track.lastCombatActivityAt = harness.now() - COMBAT_LOGOUT_MS - 1; track.wasInCombat = false; const logout = harness.simulation.combatLogouts.get(character.character_id); assert.ok(logout); logout.startedAt = harness.now() - COMBAT_LOGOUT_MS - 1; const replication = []; for (let i = 0; i < 60; i++) { harness.advance(50); const stepped = harness.simulation.step(); replication.push(...(stepped.replication ?? [])); replication.push(...harness.simulation.drainReplication()); } assert.equal(harness.simulation.isCharacterInWorld(character.character_id), false); const despawn = replication.find((event) => event.type === "entity-despawn" && event.entityId === playerId ); assert.ok(despawn, JSON.stringify(replication.filter((e) => e.type === "entity-despawn"))); assert.equal(despawn.dimensionId, CAVE_ID); const keys = eventInterestKeys(despawn, () => null); assert.equal(keys.dimensionId, CAVE_ID); assert.notEqual(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(8), OVERWORLD_ID)); } finally { harness.close(); } }); const SHARED_MOB_SPAWNER_ID = "shared-mob-local"; function placeMobSpawner (worldDb, localX, localY, dimensionId, spawnerId, extras = {}) { ensureDimension(worldDb, dimensionId); const rev = worldDb.getActiveRevisionId(); const data = createEmptyChunkData(); data.open = true; data.spawners = [{ localX, localY, config: normalizeSpawnerConfig({ spawnerId, mobTypeId: MobId.rat, maxAlive: 1, spawnRangeTiles: 0, maxWanderRangeTiles: 0, respawnDelaySeconds: 60, ...extras }) }]; worldDb.saveChunkVersion(0, 0, rev, true, encodeChunkBlob(data), dimensionId); } test("authored overworld + cave mob spawners with same local spawnerId stay independent", () => { const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 1 }); try { placeMobSpawner(harness.worldDb, 9, 8, OVERWORLD_ID, SHARED_MOB_SPAWNER_ID, { drops: [{ itemId: ItemId.apple, chance: 1, quantityMin: 1, quantityMax: 1 }] }); placeMobSpawner(harness.worldDb, 9, 8, CAVE_ID, SHARED_MOB_SPAWNER_ID, { drops: [{ itemId: ItemId.stick, chance: 1, quantityMin: 1, quantityMax: 1 }] }); harness.simulation.reloadWorld(); const overChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "MobOver" }); const overId = harness.simulation.spawnCharacter(1, overChar); const caveChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "MobCave" }); harness.stateDb.saveCharacterPosition(caveChar.character_id, 8, 8, "walk", CAVE_ID); const caveId = harness.simulation.spawnCharacter(2, caveChar); assert.equal(harness.simulation.positionOf(overId).dimensionId, OVERWORLD_ID); assert.equal(harness.simulation.positionOf(caveId).dimensionId, CAVE_ID); for (let i = 0; i < 40; i++) { harness.advance(50); harness.simulation.step(); } const worker = workerOf(harness.simulation, caveId); const rats = []; for (const entity of worker.world.ecs.query(Component.creature, Component.position, Component.spawnOrigin)) { if (entity.creature.mobTypeId !== MobId.rat) { continue; } rats.push({ entityId: entity.entityId, dimensionId: entity.position.dimensionId, spawnerId: entity.spawnOrigin.spawnerId }); } const caveRats = rats.filter((r) => r.dimensionId === CAVE_ID); const overRats = rats.filter((r) => r.dimensionId === OVERWORLD_ID); assert.equal(caveRats.length, 1, JSON.stringify(rats)); assert.equal(overRats.length, 1, JSON.stringify(rats)); assert.equal(caveRats[0].spawnerId, `${CAVE_ID}:${SHARED_MOB_SPAWNER_ID}`); assert.equal(overRats[0].spawnerId, `${OVERWORLD_ID}:${SHARED_MOB_SPAWNER_ID}`); worker.world.ecs.get(worker.world.ecs.handleOf(caveRats[0].entityId), Component.health).current = 1; const killEvents = applyDamageAndKill( worker.world, caveId, caveRats[0].entityId, 1, harness.now() ); assert.ok(killEvents.some((e) => e.type === "entity-despawn" && e.entityId === caveRats[0].entityId)); const stillOver = []; for (const entity of worker.world.ecs.query(Component.creature, Component.position, Component.spawnOrigin)) { if (entity.creature.mobTypeId !== MobId.rat) { continue; } if (entity.position.dimensionId === OVERWORLD_ID) { stillOver.push(entity.spawnOrigin.spawnerId); } } assert.deepEqual(stillOver, [`${OVERWORLD_ID}:${SHARED_MOB_SPAWNER_ID}`]); } finally { harness.close(); } }); test("region ownership keys are independent per dimension", () => { assert.notEqual(regionKey(0, 0, OVERWORLD_ID), regionKey(0, 0, CAVE_ID)); const harness = makeDimensionSimulation(CAVE_ID, { workerCount: 2, pinRegion: pinEastSplit }); try { const overChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "OwnOver" }); const overId = harness.simulation.spawnCharacter(1, overChar); const caveChar = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, lastName: "OwnCave" }); harness.stateDb.saveCharacterPosition(caveChar.character_id, 8, 8, "walk", CAVE_ID); const caveId = harness.simulation.spawnCharacter(2, caveChar); harness.simulation.step(); assert.equal(harness.simulation.positionOf(overId).dimensionId, OVERWORLD_ID); assert.equal(harness.simulation.positionOf(caveId).dimensionId, CAVE_ID); assert.equal( harness.simulation.chunkIsSimulating(8, 8, OVERWORLD_ID), true ); assert.equal( harness.simulation.chunkIsSimulating(8, 8, CAVE_ID), true ); const owners = harness.simulation.regionOwner; assert.ok(owners.has(regionKey(0, 0, OVERWORLD_ID)), "overworld region owned"); assert.ok(owners.has(regionKey(0, 0, CAVE_ID)), "cave region owned"); } finally { harness.close(); } }); test("PvP combat-logout offline death in cave keeps loot and altar/letter dimension-aware", () => { const harness = makeCaveHarness(); try { // Overworld altar + bank; death happens in cave (no cave altar). const overChunk = createEmptyChunkData(); overChunk.open = true; overChunk.blocks[8 * 16 + 4] = { typeId: BlockType.bank, state: 0 }; harness.worldDb.saveChunkVersion( 0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(overChunk), OVERWORLD_ID ); const altarChunk = createEmptyChunkData(); altarChunk.open = true; altarChunk.blocks[8 * 16 + 4] = { typeId: BlockType.churchAltar, state: 0 }; // tile 20,8 in chunk 1,0 // chunk 1,0 local (4,8) => tileX=20, tileY=8 harness.worldDb.saveChunkVersion( 1, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(altarChunk), OVERWORLD_ID ); // Also place a closer cave altar so letter/respawn preference is tested against XY proximity. const caveAltar = createEmptyChunkData(); caveAltar.open = true; caveAltar.blocks[8 * 16 + 10] = { typeId: BlockType.churchAltar, state: 0 }; // tile 10,8 harness.worldDb.saveChunkVersion( 0, 0, harness.worldDb.getActiveRevisionId(), true, encodeChunkBlob(caveAltar), CAVE_ID ); harness.simulation.reloadWorld(); const victim = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, firstName: "Vic", lastName: "CaveVic" }); harness.stateDb.saveCharacterPosition(victim.character_id, 8, 8, "walk", CAVE_ID); harness.stateDb.saveBag(victim.character_id, { inventory: emptySlots(), equipment: emptyEquipment(), vault: [], vaultReserved: [] }); const attacker = makeCharacter(harness.stateDb, { tileX: 9, tileY: 8, firstName: "Atk", lastName: "CaveAtk" }); harness.stateDb.saveCharacterPosition(attacker.character_id, 9, 8, "walk", CAVE_ID); const victimId = harness.simulation.spawnCharacter(1, victim); const attackerId = harness.simulation.spawnCharacter(2, attacker); assert.equal(harness.simulation.positionOf(victimId).dimensionId, CAVE_ID); assert.equal(harness.simulation.positionOf(attackerId).dimensionId, CAVE_ID); harness.simulation.enqueue(1, { type: "attack", characterId: victim.character_id, targetEntityId: attackerId }); harness.simulation.step(); assert.equal(harness.simulation.beginCombatLogout(victim.character_id), true); assert.equal( harness.simulation.combatLogouts.get(victim.character_id).pendingCowardice, true ); const worker = workerOf(harness.simulation, victimId); worker.world.ecs.get(worker.world.ecs.handleOf(victimId), Component.health).current = 1; const deathEvents = applyDamageAndKill(worker.world, attackerId, victimId, 999, harness.now()); const died = deathEvents.find((event) => event.type === "player-died"); assert.ok(died, JSON.stringify(deathEvents.map((e) => e.type))); const applied = harness.simulation.applyPlayerDiedEvent(died); const loot = applied.filter((event) => event.type === "ground-item-appear" && (event.stack?.itemId === ItemId.bones || event.stack?.itemId === ItemId.skull) ); assert.ok(loot.length >= 2, JSON.stringify(applied.filter((e) => e.type === "ground-item-appear"))); for (const drop of loot) { assert.equal(drop.dimensionId, CAVE_ID); } const onGround = [...worker.world.groundItems.values()].filter( (item) => item.dimensionId === CAVE_ID && (item.stack?.itemId === ItemId.bones || item.stack?.itemId === ItemId.skull) ); assert.ok(onGround.length >= 2); assert.equal( [...worker.world.groundItems.values()].filter( (item) => item.dimensionId === OVERWORLD_ID && (item.stack?.itemId === ItemId.bones || item.stack?.itemId === ItemId.skull) ).length, 0 ); const despawn = applied.find((event) => event.type === "entity-despawn" && event.entityId === victimId && event.cause === "death" ); assert.ok(despawn); assert.equal(despawn.dimensionId, CAVE_ID); const letters = harness.stateDb.listHeldCourierDeliveries(victim.character_id) .map((hold) => hold.cargo?.stack) .filter((stack) => stack?.itemId === ItemId.letter); assert.ok(letters.some((stack) => stack.instance?.authorDisplayName === CHURCH_LETTER_AUTHOR && stack.instance?.body === formatChurchOfflineResurrectionBody() )); // Church letter should originate from the cave altar (same dim), not the farther overworld one. const churchHold = harness.stateDb.listHeldCourierDeliveries(victim.character_id) .find((hold) => hold.cargo?.stack?.instance?.authorDisplayName === CHURCH_LETTER_AUTHOR); assert.ok(churchHold); assert.equal(churchHold.originDimensionId, CAVE_ID); assert.equal(harness.simulation.isCharacterInWorld(victim.character_id), false); assert.equal(harness.stateDb.getCharacter(victim.character_id).is_dead, 0); const row = harness.stateDb.getCharacter(victim.character_id); // Respawn prefers death-dimension altar at (10,8). assert.equal(row.dimension_id, CAVE_ID); assert.equal( Math.max(Math.abs(row.tile_x - 10), Math.abs(row.tile_y - 8)), 1 ); } finally { harness.close(); } }); test("PvP combat-logout quiet despawn in cave still carries cave dimensionId", () => { const harness = makeCaveHarness(); try { const victim = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, firstName: "Quiet", lastName: "Vic" }); harness.stateDb.saveCharacterPosition(victim.character_id, 8, 8, "walk", CAVE_ID); const attacker = makeCharacter(harness.stateDb, { tileX: 9, tileY: 8, firstName: "Quiet", lastName: "Atk" }); harness.stateDb.saveCharacterPosition(attacker.character_id, 9, 8, "walk", CAVE_ID); const victimId = harness.simulation.spawnCharacter(1, victim); const attackerId = harness.simulation.spawnCharacter(2, attacker); harness.simulation.enqueue(1, { type: "attack", characterId: victim.character_id, targetEntityId: attackerId }); harness.simulation.step(); assert.equal(harness.simulation.beginCombatLogout(victim.character_id), true); harness.simulation.drainReplication(); const record = harness.simulation.entityRecord(victimId); harness.simulation.workers[record.workerId].call({ type: WorkerMessage.clearCombat, entityId: victimId, targetEntityId: victimId }); const track = harness.simulation.combatTracking.get(victim.character_id); track.lastCombatActivityAt = harness.now() - COMBAT_LOGOUT_MS - 1; track.wasInCombat = false; harness.simulation.combatLogouts.get(victim.character_id).startedAt = harness.now() - COMBAT_LOGOUT_MS - 1; const replication = []; for (let i = 0; i < 60; i++) { harness.advance(50); const stepped = harness.simulation.step(); replication.push(...(stepped.replication ?? [])); replication.push(...harness.simulation.drainReplication()); } assert.equal(harness.simulation.isCharacterInWorld(victim.character_id), false); const despawn = replication.find((event) => event.type === "entity-despawn" && event.entityId === victimId ); assert.ok(despawn); assert.equal(despawn.dimensionId, CAVE_ID); const keys = eventInterestKeys(despawn, () => null); assert.equal(keys.dimensionId, CAVE_ID); assert.equal(keys.toKey, chunkKey(tileToChunk(8), tileToChunk(8), CAVE_ID)); } finally { harness.close(); } });