import { WebSocketServer } from "ws"; import { MessageType, GAIT } from "../../../shared/protocol/constants.js"; import { chunkKey, parseChunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js"; import { VISIBLE_CHUNK_RADIUS, STATIC_CHUNK_RADIUS } from "../../../shared/protocol/constants.js"; import { staticChunkRadiusForViewDistance, ViewDistance, normalizeGraphicsSettings } from "../../../shared/graphics/settings.js"; import { broadcastSpeech, broadcastItemBubble } from "../chat/speech.js"; import { CraftingStationId, craftingStationDefinition } from "../../../shared/definitions/craftingStations.js"; import { publicSkillsView } from "../../../shared/skills/state.js"; import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js"; import { canCharacterSeeGroundItem } from "../../../shared/items/letters.js"; import { getConsoleSnapshot, subscribeConsole } from "../logging/consoleCapture.js"; let nextSessionId = 1; export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation, deploy = null }) { const wss = new WebSocketServer({ server: httpServer, path: "/ws" }); const sessions = new Map(); let draining = false; subscribeConsole((entry) => { for (const session of sessions.values()) { if (session.consoleSubscribed && session.account?.is_admin) { send(session, { type: MessageType.editorConsoleLine, line: entry }); } } }); wss.on("connection", (socket) => { const identity = auth.claimIdentity(); const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email); const session = { id: nextSessionId++, socket, account, authSubject: identity.authSubject, characterId: null, entityId: null, /** Client graphics: long = STATIC_CHUNK_RADIUS map ring; short = VISIBLE_CHUNK_RADIUS. */ viewDistance: ViewDistance.long, consoleSubscribed: false, /** Chunks where entity / ground-item replication is active (3×3). */ entitySubscribed: new Set(), /** Chunks with map + baked lighting only (5×5 when long). */ staticSubscribed: new Set() }; auth.register(session); sessions.set(session.id, session); send(session, { type: MessageType.session, accountId: account.account_id, authSubject: account.auth_subject, isAdmin: !!account.is_admin, characters: characters.list(account.account_id) }); socket.on("message", (raw) => { let message; try { message = JSON.parse(String(raw)); } catch { send(session, { type: MessageType.error, message: "Invalid JSON." }); return; } try { handleMessage(session, message); } catch (error) { send(session, { type: MessageType.error, message: error.userFacing ? error.message : "Request failed." }); } }); socket.on("close", () => { leaveWorld(session); auth.release(session); sessions.delete(session.id); }); }); function handleMessage (session, message) { if (session.characterId && stateDb.getCharacter(session.characterId)?.is_dead && message.type !== MessageType.respawn && message.type !== MessageType.leaveWorld) { const error = new Error("You are dead."); error.userFacing = true; throw error; } switch (message.type) { case MessageType.createCharacter: { const created = characters.create( session.account, message.firstName, message.lastName, message.sex, message.hair ?? null, simulation.settings, message.clothing ?? null ); enterWorld(session, created.characterId); } break; case MessageType.selectCharacter: enterWorld(session, message.characterId); break; case MessageType.scheduleDeleteCharacter: characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs); send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) }); break; case MessageType.cancelDeleteCharacter: characters.cancelDelete(session.account, message.characterId); send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) }); break; case MessageType.leaveWorld: leaveWorld(session); send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) }); break; case MessageType.respawn: requirePlaying(session); simulation.enqueue(session.id, { type: "respawn", characterId: session.characterId }); break; case MessageType.moveTo: requirePlaying(session); simulation.enqueue(session.id, { type: "move-to", characterId: session.characterId, tileX: message.tileX | 0, tileY: message.tileY | 0 }); break; case MessageType.setGait: requirePlaying(session); simulation.enqueue(session.id, { type: "set-gait", characterId: session.characterId, gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk }); break; case MessageType.friendRequest: requirePlaying(session); friends.request(session.characterId, message.characterId); pushFriends(session.characterId, message.characterId); break; case MessageType.friendAccept: requirePlaying(session); friends.accept(session.characterId, message.characterId); pushFriends(session.characterId, message.characterId); break; case MessageType.friendDecline: requirePlaying(session); friends.decline(session.characterId, message.characterId); pushFriends(session.characterId, message.characterId); break; case MessageType.friendRemove: requirePlaying(session); friends.remove(session.characterId, message.characterId); pushFriends(session.characterId, message.characterId); break; case MessageType.chatSay: requirePlaying(session); broadcastSpeech(sessions, simulation, session, message.text); break; case MessageType.dropItem: requirePlaying(session); simulation.enqueue(session.id, { type: "drop-item", characterId: session.characterId, slotIndex: message.slotIndex | 0, quantity: message.quantity ?? null }); break; case MessageType.pickupItem: requirePlaying(session); simulation.enqueue(session.id, { type: "pickup-item", characterId: session.characterId, groundItemId: message.groundItemId | 0 }); break; case MessageType.equipItem: requirePlaying(session); simulation.enqueue(session.id, { type: "equip-item", characterId: session.characterId, slotIndex: message.slotIndex | 0 }); break; case MessageType.unequipItem: requirePlaying(session); simulation.enqueue(session.id, { type: "unequip-item", characterId: session.characterId, equipSlot: message.equipSlot }); break; case MessageType.eatItem: requirePlaying(session); simulation.enqueue(session.id, { type: "eat-item", characterId: session.characterId, slotIndex: message.slotIndex | 0 }); break; case MessageType.drinkItem: requirePlaying(session); simulation.enqueue(session.id, { type: "drink-item", characterId: session.characterId, slotIndex: message.slotIndex | 0 }); break; case MessageType.openBank: requirePlaying(session); simulation.enqueue(session.id, { type: "open-bank", characterId: session.characterId }); break; case MessageType.enterDoorway: requirePlaying(session); simulation.enqueue(session.id, { type: "enter-doorway", characterId: session.characterId, tileX: message.tileX | 0, tileY: message.tileY | 0 }); break; case MessageType.openBounty: requirePlaying(session); simulation.enqueue(session.id, { type: "open-bounty", characterId: session.characterId }); break; case MessageType.raiseBounty: requirePlaying(session); simulation.enqueue(session.id, { type: "raise-bounty", characterId: session.characterId, firstName: message.firstName, lastName: message.lastName, amountCopper: message.amountCopper }); break; case MessageType.getCharacterBounty: requirePlaying(session); simulation.enqueue(session.id, { type: "get-character-bounty", characterId: session.characterId, targetCharacterId: message.characterId, firstName: message.firstName, lastName: message.lastName }); break; case MessageType.closeBounty: requirePlaying(session); simulation.enqueue(session.id, { type: "close-bounty", characterId: session.characterId }); break; case MessageType.openBarber: requirePlaying(session); simulation.enqueue(session.id, { type: "open-barber", characterId: session.characterId }); break; case MessageType.setHair: requirePlaying(session); simulation.enqueue(session.id, { type: "set-hair", characterId: session.characterId, hair: message.hair ?? null }); break; case MessageType.closeBarber: requirePlaying(session); simulation.enqueue(session.id, { type: "close-barber", characterId: session.characterId }); break; case MessageType.openCauldron: requirePlaying(session); simulation.enqueue(session.id, { type: "open-cauldron", characterId: session.characterId }); break; case MessageType.openFurnace: requirePlaying(session); simulation.enqueue(session.id, { type: "open-station", characterId: session.characterId, stationId: CraftingStationId.furnace }); break; case MessageType.openStation: { requirePlaying(session); const stationId = typeof message.stationId === "string" ? message.stationId : null; if (!stationId || !craftingStationDefinition(stationId)) { break; } simulation.enqueue(session.id, { type: "open-station", characterId: session.characterId, stationId }); break; } case MessageType.mine: requirePlaying(session); simulation.enqueue(session.id, { type: "mine", characterId: session.characterId, tileX: message.tileX | 0, tileY: message.tileY | 0 }); break; case MessageType.chop: requirePlaying(session); simulation.enqueue(session.id, { type: "chop", characterId: session.characterId, tileX: message.tileX | 0, tileY: message.tileY | 0 }); break; case MessageType.pick: requirePlaying(session); simulation.enqueue(session.id, { type: "pick", characterId: session.characterId, tileX: message.tileX | 0, tileY: message.tileY | 0 }); break; case MessageType.cancelGather: requirePlaying(session); simulation.enqueue(session.id, { type: "cancel-gather", characterId: session.characterId }); break; case MessageType.startCraft: requirePlaying(session); simulation.enqueue(session.id, { type: "start-craft", characterId: session.characterId, stationId: message.stationId, recipeId: message.recipeId, clothTier: message.clothTier ?? null, dyeSlotIndex: message.dyeSlotIndex ?? null, batchCount: message.batchCount ?? null, batchAll: !!message.batchAll }); break; case MessageType.cancelCraft: requirePlaying(session); simulation.enqueue(session.id, { type: "cancel-craft", characterId: session.characterId }); break; case MessageType.cauldronSetSlot: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-set-slot", characterId: session.characterId, slotIndex: message.slotIndex | 0, itemId: message.itemId | 0, quantity: message.quantity | 0, instance: message.instance ?? null }); break; case MessageType.cauldronSetDyeSlot: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-set-dye-slot", characterId: session.characterId, slotIndex: message.slotIndex | 0, itemId: message.itemId | 0, quantity: message.quantity | 0, instance: message.instance ?? null }); break; case MessageType.cauldronInsert: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-insert", characterId: session.characterId, itemId: message.itemId | 0, quantity: message.quantity | 0, instance: message.instance ?? null }); break; case MessageType.cauldronAction: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-action", characterId: session.characterId, action: message.action }); break; case MessageType.cauldronBottle: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-bottle", characterId: session.characterId }); break; case MessageType.cauldronCreateDye: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-create-dye", characterId: session.characterId, confirmOverflow: !!message.confirmOverflow, flowers: Array.isArray(message.flowers) ? message.flowers : [] }); break; case MessageType.cauldronClear: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-clear", characterId: session.characterId }); break; case MessageType.cauldronClearDye: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-clear-dye", characterId: session.characterId }); break; case MessageType.cauldronSaveRecipe: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-save-recipe", characterId: session.characterId }); break; case MessageType.cauldronClose: requirePlaying(session); simulation.enqueue(session.id, { type: "cauldron-close", characterId: session.characterId }); break; case MessageType.bankDeposit: requirePlaying(session); simulation.enqueue(session.id, { type: "bank-deposit", characterId: session.characterId, slotIndex: message.slotIndex | 0, quantity: message.quantity ?? null }); break; case MessageType.bankWithdraw: requirePlaying(session); simulation.enqueue(session.id, { type: "bank-withdraw", characterId: session.characterId, slotIndex: message.slotIndex | 0, quantity: message.quantity ?? null }); break; case MessageType.getBlankCheques: requirePlaying(session); simulation.enqueue(session.id, { type: "get-blank-cheques", characterId: session.characterId }); break; case MessageType.returnBlankCheques: requirePlaying(session); simulation.enqueue(session.id, { type: "return-blank-cheques", characterId: session.characterId, slotIndex: message.slotIndex | 0, quantity: message.quantity ?? null }); break; case MessageType.writeCheque: requirePlaying(session); simulation.enqueue(session.id, { type: "write-cheque", characterId: session.characterId, slotIndex: message.slotIndex | 0, vaultSlotIndex: message.vaultSlotIndex | 0, quantity: message.quantity ?? 1 }); break; case MessageType.redeemCheque: requirePlaying(session); simulation.enqueue(session.id, { type: "redeem-cheque", characterId: session.characterId, slotIndex: message.slotIndex | 0 }); break; case MessageType.claimInheritance: requirePlaying(session); { const inheritance = stateDb.getInheritance(session.account.account_id); simulation.enqueue(session.id, { type: "claim-inheritance", characterId: session.characterId, stacks: (inheritance.slots ?? []).filter(Boolean) }); } break; case MessageType.attack: requirePlaying(session); simulation.enqueue(session.id, { type: "attack", characterId: session.characterId, targetEntityId: message.targetEntityId | 0 }); break; case MessageType.cancelAttack: requirePlaying(session); simulation.enqueue(session.id, { type: "cancel-attack", characterId: session.characterId }); break; case MessageType.setSpellFavorite: requirePlaying(session); simulation.enqueue(session.id, { type: "set-spell-favorite", characterId: session.characterId, spellId: message.spellId }); break; case MessageType.setSpellAutoCast: requirePlaying(session); simulation.enqueue(session.id, { type: "set-spell-autocast", characterId: session.characterId, enabled: !!message.enabled }); break; case MessageType.armSpell: requirePlaying(session); simulation.enqueue(session.id, { type: "arm-spell", characterId: session.characterId, spellId: message.spellId }); break; case MessageType.cancelArmSpell: requirePlaying(session); simulation.enqueue(session.id, { type: "cancel-arm-spell", characterId: session.characterId }); break; case MessageType.castSpellTile: requirePlaying(session); simulation.enqueue(session.id, { type: "cast-spell-tile", characterId: session.characterId, spellId: message.spellId, tileX: message.tileX | 0, tileY: message.tileY | 0 }); break; case MessageType.castSpellEntity: requirePlaying(session); simulation.enqueue(session.id, { type: "cast-spell-entity", characterId: session.characterId, spellId: message.spellId, targetEntityId: message.targetEntityId | 0 }); break; case MessageType.readSpellbook: requirePlaying(session); simulation.enqueue(session.id, { type: "read-spellbook", characterId: session.characterId, slotIndex: message.slotIndex | 0 }); break; case MessageType.interact: requirePlaying(session); simulation.enqueue(session.id, { type: "interact", characterId: session.characterId, targetEntityId: message.targetEntityId | 0, purpose: message.purpose === "shop" || message.purpose === "talk" ? message.purpose : null }); break; case MessageType.buyFromShop: requirePlaying(session); simulation.enqueue(session.id, { type: "buy-from-shop", characterId: session.characterId, npcEntityId: message.npcEntityId | 0, itemId: message.itemId | 0, quantity: message.quantity | 0 || 1, listingId: typeof message.listingId === "string" ? message.listingId : null, source: typeof message.source === "string" ? message.source : null }); break; case MessageType.sellToShop: requirePlaying(session); simulation.enqueue(session.id, { type: "sell-to-shop", characterId: session.characterId, npcEntityId: message.npcEntityId | 0, slotIndex: message.slotIndex | 0, quantity: message.quantity | 0 || 1 }); break; case MessageType.closeShop: requirePlaying(session); simulation.enqueue(session.id, { type: "close-shop", characterId: session.characterId, npcEntityId: message.npcEntityId | 0 }); break; case MessageType.openMarket: requirePlaying(session); simulation.enqueue(session.id, { type: "open-market", characterId: session.characterId }); break; case MessageType.closeMarket: requirePlaying(session); simulation.enqueue(session.id, { type: "close-market", characterId: session.characterId }); break; case MessageType.placeMarketSell: requirePlaying(session); simulation.enqueue(session.id, { type: "place-market-sell", characterId: session.characterId, slotIndex: message.slotIndex | 0, quantity: message.quantity | 0 || 1, minUnitPrice: message.minUnitPrice | 0 }); break; case MessageType.placeMarketBuy: requirePlaying(session); simulation.enqueue(session.id, { type: "place-market-buy", characterId: session.characterId, itemId: message.itemId | 0, quantity: message.quantity | 0 || 1, maxUnitPrice: message.maxUnitPrice | 0 }); break; case MessageType.cancelMarketOrder: requirePlaying(session); simulation.enqueue(session.id, { type: "cancel-market-order", characterId: session.characterId, orderId: message.orderId | 0 }); break; case MessageType.follow: requirePlaying(session); simulation.enqueue(session.id, { type: "follow", characterId: session.characterId, targetEntityId: message.targetEntityId | 0 }); break; case MessageType.cancelFollow: requirePlaying(session); simulation.enqueue(session.id, { type: "cancel-follow", characterId: session.characterId }); break; case MessageType.sendPigeon: requirePlaying(session); { const result = simulation.dispatchPigeon({ characterId: session.characterId, destination: message.destination, cargo: message.cargo }); send(session, { type: MessageType.pigeonDispatched, courierId: result.transit.courierId, destinationKind: result.transit.destinationKind, destinationCharacterId: result.transit.destinationCharacterId }); send(session, { type: MessageType.inventory, ...result.bag }); } break; case MessageType.searchCharacter: requirePlaying(session); { const character = friends.findByFullName(message.firstName, message.lastName); send(session, { type: MessageType.characterSearchResult, character: character ?? null }); } break; case MessageType.writeLetter: requirePlaying(session); simulation.enqueue(session.id, { type: "write-letter", characterId: session.characterId, slotIndex: message.slotIndex, body: message.body }); break; case MessageType.editLetter: requirePlaying(session); simulation.enqueue(session.id, { type: "edit-letter", characterId: session.characterId, slotIndex: message.slotIndex, body: message.body }); break; case MessageType.openLetter: requirePlaying(session); simulation.enqueue(session.id, { type: "open-letter", characterId: session.characterId, slotIndex: message.slotIndex }); break; case MessageType.editorLoadChunk: requireAdmin(session); send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0, message.dimensionId) }); break; case MessageType.editorSaveChunk: requireAdmin(session); send(session, { type: MessageType.editorChunk, ...editor.saveChunk( message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject, message.dimensionId ) }); break; case MessageType.editorListDimensions: case "EDITOR_LIST_DIMENSIONS": requireAdmin(session); try { send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() }); } catch (err) { send(session, { type: MessageType.error, message: err.userFacing ? err.message : "Failed to list dimensions." }); } break; case MessageType.editorCreateDimension: case "EDITOR_CREATE_DIMENSION": requireAdmin(session); send(session, { type: MessageType.editorDimensions, ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject) }); break; case MessageType.editorSaveDimension: case "EDITOR_SAVE_DIMENSION": requireAdmin(session); send(session, { type: MessageType.editorDimensions, ...editor.saveDimension(message.dimension ?? message, session.authSubject) }); break; case MessageType.editorSoftDeleteDimension: case "EDITOR_SOFT_DELETE_DIMENSION": requireAdmin(session); send(session, { type: MessageType.editorDimensions, ...editor.softDeleteDimension(message.dimensionId, session.authSubject) }); break; case MessageType.editorCancelDimensionDeletion: case "EDITOR_CANCEL_DIMENSION_DELETION": requireAdmin(session); send(session, { type: MessageType.editorDimensions, ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject) }); break; case MessageType.editorLoadSettings: requireAdmin(session); send(session, { type: MessageType.editorSettings, ...editor.loadSettings(), itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {} }); break; case MessageType.editorConsoleSubscribe: requireAdmin(session); session.consoleSubscribed = true; send(session, { type: MessageType.editorConsoleSnapshot, lines: getConsoleSnapshot(800) }); break; case MessageType.editorSaveSettings: requireAdmin(session); { const saved = editor.saveSettings(message.settings ?? {}, session.authSubject); simulation.applySettings(saved.settings); broadcastStatus(); broadcastSettings(saved); } break; case MessageType.editorApplyRevision: requireAdmin(session); if (!editor.revisionStatus().pendingRevisionId) { send(session, { type: MessageType.error, message: "Nothing pending to apply." }); break; } { const appliedRevisionId = editor.applyPendingRevision(); simulation.reloadWorld(); for (const other of sessions.values()) { if (other.entityId) { syncSubscriptions(other, true); } } broadcastStatus(); send(session, { type: MessageType.editorRevisionApplied, ...editor.revisionStatus(), appliedRevisionId }); } break; case MessageType.editorLoadQuests: requireAdmin(session); send(session, { type: MessageType.editorQuests, ...editor.loadQuests() }); break; case MessageType.editorSaveQuest: requireAdmin(session); send(session, { type: MessageType.editorQuests, ...editor.saveQuest(message.quest ?? message, session.authSubject) }); break; case MessageType.editorDeleteQuest: requireAdmin(session); send(session, { type: MessageType.editorQuests, ...editor.deleteQuest(message.questId, session.authSubject) }); break; case MessageType.editorLoadDialogues: requireAdmin(session); send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() }); break; case MessageType.editorSaveDialogue: requireAdmin(session); send(session, { type: MessageType.editorDialogues, ...editor.saveDialogue(message.dialogue ?? message, session.authSubject) }); break; case MessageType.editorDeleteDialogue: requireAdmin(session); send(session, { type: MessageType.editorDialogues, ...editor.deleteDialogue(message.dialogueId, session.authSubject) }); break; case MessageType.dialogueChoose: requirePlaying(session); simulation.enqueue(session.id, { type: "dialogue-choose", characterId: session.characterId, trigger: String(message.trigger ?? "") }); break; case MessageType.dialogueAdvance: requirePlaying(session); simulation.enqueue(session.id, { type: "dialogue-advance", characterId: session.characterId }); break; case MessageType.closeDialogue: requirePlaying(session); simulation.enqueue(session.id, { type: "close-dialogue", characterId: session.characterId }); break; case MessageType.requestQuests: requirePlaying(session); simulation.enqueue(session.id, { type: "request-quests", characterId: session.characterId }); break; case MessageType.setGraphicsSettings: { const next = normalizeGraphicsSettings({ viewDistance: message.viewDistance ?? session.viewDistance }); const changed = next.viewDistance !== session.viewDistance; session.viewDistance = next.viewDistance; if (changed && session.entityId) { syncSubscriptions(session, true); } } break; default: send(session, { type: MessageType.error, message: `Unknown message ${message.type}` }); } } function enterWorld (session, characterId) { if (draining || deploy?.isDraining?.()) { const error = new Error("The server is restarting for an update. Please try again in a moment."); error.userFacing = true; throw error; } leaveWorld(session); const character = characters.getOwned(session.account.account_id, characterId); if (character.deletion_scheduled_at) { const error = new Error("That character is marked for deletion."); error.userFacing = true; throw error; } for (const other of sessions.values()) { if (other !== session && other.account.account_id === session.account.account_id && other.characterId) { const error = new Error("This account already has a character in the world."); error.userFacing = true; throw error; } } session.characterId = character.character_id; session.entityId = simulation.spawnCharacter(session.id, character); const spawned = simulation.entityRecord(session.entityId); const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID); const dimRecord = simulation.getDimensionRecord?.(enterDim); send(session, { type: MessageType.enterWorld, entityId: session.entityId, characterId: session.characterId, tileX: spawned.tileX, tileY: spawned.tileY, dimensionId: enterDim, lightingMode: dimRecord?.lightingMode ?? "dayNight", seasonMode: dimRecord?.seasonMode ?? "auto", gait: spawned.gait, sex: spawned.sex, firstName: spawned.firstName, lastName: spawned.lastName, layers: spawned.layers ?? [], health: spawned.health, maxHealth: spawned.maxHealth, settings: simulation.settings, worldTime: simulation.worldTime(), restartStatus: deploy?.getStatus?.() ?? { scheduled: false } }); syncSubscriptions(session, true); send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) }); const bag = simulation.bagOf(session.entityId); if (bag) { send(session, { type: MessageType.inventory, ...bag }); } const skills = simulation.skillsOf(session.entityId); if (skills) { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); } const spellView = simulation.spellsOf(session.entityId); if (spellView) { send(session, { type: MessageType.spells, spells: spellView.spells, autoCast: spellView.autoCast, armedSpellId: spellView.armedSpellId ?? null }); } const stamina = simulation.staminaOf(session.entityId); if (stamina) { send(session, { type: MessageType.stamina, current: stamina.current, max: stamina.max, gait: stamina.gait }); } if (character.is_dead) { send(session, { type: MessageType.playerDied, entityId: session.entityId, characterId: session.characterId }); } publishReplication(simulation.drainReplication()); } function leaveWorld (session) { if (session.characterId) { simulation.despawnCharacter(session.characterId); } publishReplication(simulation.drainReplication()); session.characterId = null; session.entityId = null; session.entitySubscribed.clear(); session.staticSubscribed.clear(); } function syncSubscriptions (session, forceSnapshots) { if (!session.entityId) { return; } const position = simulation.positionOf(session.entityId); if (!position) { return; } const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID); const centerChunkX = tileToChunk(position.tileX); const centerChunkY = tileToChunk(position.tileY); const mapRadius = staticChunkRadiusForViewDistance( session.viewDistance, STATIC_CHUNK_RADIUS, VISIBLE_CHUNK_RADIUS ); const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS); const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius); const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId))); const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId))); for (const key of session.staticSubscribed) { if (!staticNext.has(key)) { const { chunkX, chunkY } = parseChunkKey(key); send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY }); } } const snapshots = simulation.snapshotsForView(session.entityId, mapRadius); for (const snapshot of snapshots) { const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId); const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key); if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged) { const groundItems = (snapshot.groundItems ?? []).filter((item) => canCharacterSeeGroundItem(item, session.characterId) ); send(session, { type: MessageType.chunkSnapshot, ...snapshot, groundItems }); } } session.entitySubscribed = entityNext; session.staticSubscribed = staticNext; } function requirePlaying (session) { if (!session.characterId) { const error = new Error("Select a character first."); error.userFacing = true; throw error; } } function requireAdmin (session) { if (!session.account.is_admin) { const error = new Error("Admin only."); error.userFacing = true; throw error; } } function broadcastStatus () { const worldTime = simulation.worldTime(); const restartStatus = deploy?.getStatus?.() ?? { scheduled: false }; for (const session of sessions.values()) { if (session.entityId) { send(session, { type: MessageType.worldStatus, worldTime, settings: simulation.settings, activeRevisionId: simulation.activeRevisionId, restartStatus }); } } } function broadcastRestartStatus () { const restartStatus = deploy?.getStatus?.() ?? { scheduled: false }; for (const session of sessions.values()) { if (session.entityId) { send(session, { type: MessageType.restartStatus, restartStatus }); } } } function pushFriends (...characterIds) { const seen = new Set(); for (const characterId of characterIds) { const id = Number(characterId); if (!id || seen.has(id)) { continue; } seen.add(id); const payload = { type: MessageType.friends, ...friends.snapshot(id) }; for (const session of sessions.values()) { if (session.characterId === id) { send(session, payload); } } } } function broadcastSettings (payload) { for (const session of sessions.values()) { if (session.account.is_admin) { send(session, { type: MessageType.editorSettings, ...payload }); } } } function onTickResult (result) { publishReplication(result.replication ?? []); for (const event of result.events) { if (event.type === "command-error") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.error, message: event.message }); } continue; } if (event.type === "inventory") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (!session) { continue; } send(session, { type: MessageType.inventory, inventory: event.inventory, equipment: event.equipment, vault: event.vault, vaultReserved: event.vaultReserved }); if (event.bank) { send(session, { type: MessageType.bankSnapshot, vault: event.vault, vaultReserved: event.vaultReserved, inheritance: stateDb.getInheritance(session.account.account_id) }); } if (event.cauldron != null) { send(session, { type: MessageType.cauldronSnapshot, open: !!event.cauldron, state: event.cauldronState ?? null, alchemyResult: event.alchemyResult ?? null, dyeConfirm: event.dyeConfirm ?? null }); } continue; } if (event.type === "skills") { const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (!session) { continue; } send(session, { type: MessageType.skills, skills: event.skills ?? [] }); continue; } if (event.type === "spells") { const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (!session) { continue; } send(session, { type: MessageType.spellsUpdated, spells: event.spells ?? [], autoCast: !!event.autoCast, armedSpellId: event.armedSpellId ?? null }); continue; } if (event.type === "spell-armed") { const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId); if (!session) { continue; } send(session, { type: MessageType.spellArmed, spellId: event.spellId }); continue; } if (event.type === "spell-disarmed") { const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId); if (!session) { continue; } send(session, { type: MessageType.spellDisarmed }); continue; } if (event.type === "stamina") { const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (!session) { continue; } send(session, { type: MessageType.stamina, current: event.current, max: event.max, gait: event.gait }); continue; } if (event.type === "status-effects") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (!session) { continue; } send(session, { type: MessageType.statusEffects, effects: event.effects ?? [], blind: !!event.blind }); continue; } if (event.type === "toast") { const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.toast, message: event.message }); } continue; } if (event.type === "quests-snapshot") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.questsSnapshot, quests: event.quests ?? [] }); } continue; } if (event.type === "quest-step-complete") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.questStepComplete, questId: event.questId, title: event.title }); } continue; } if (event.type === "dialogue-step") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.dialogueStep, dialogueId: event.dialogueId, stepId: event.stepId, label: event.label, npcEntityId: event.npcEntityId ?? null, lines: event.lines ?? [] }); } continue; } if (event.type === "dialogue-choices") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.dialogueChoices, dialogueId: event.dialogueId, stepId: event.stepId, npcEntityId: event.npcEntityId ?? null, triggers: event.triggers ?? [] }); } continue; } if (event.type === "dialogue-close") { const session = event.sessionId != null ? sessions.get(event.sessionId) : [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.dialogueClose, reason: event.reason ?? null }); } continue; } if (event.type === "pigeon-delivered") { for (const session of sessions.values()) { if (session.characterId === event.senderCharacterId || session.characterId === event.destinationCharacterId) { send(session, { type: MessageType.pigeonDelivered, courierId: event.courierId, destinationKind: event.destinationKind, cargo: event.cargo }); } } continue; } if (event.type === "player-died") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.playerDied, entityId: event.entityId, characterId: event.characterId }); } continue; } if (event.type === "player-respawned") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.playerRespawned, entityId: event.entityId, characterId: event.characterId, tileX: event.tileX, tileY: event.tileY, health: event.health, maxHealth: event.maxHealth, stamina: event.stamina, maxStamina: event.maxStamina }); } continue; } if (event.type === "dimension-changed") { const session = sessions.get(event.sessionId); if (session) { session.entitySubscribed.clear(); session.staticSubscribed.clear(); send(session, { type: MessageType.dimensionChanged, dimensionId: event.dimensionId, tileX: event.tileX, tileY: event.tileY, lightingMode: event.lightingMode, seasonMode: event.seasonMode }); syncSubscriptions(session, true); } continue; } if (event.type === "combat-no-arrows") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.combatNoArrows }); } continue; } if (event.type === "craft-result") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.craftResult, recipeId: event.recipeId, ok: !!event.ok, error: event.error ?? null, burned: !!event.burned, continuing: !!event.continuing }); } continue; } if (event.type === "station-open") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.stationOpen, stationId: event.stationId }); } continue; } if (event.type === "shop-open") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.shopOpen, npcEntityId: event.npcEntityId, displayName: event.displayName, sex: event.sex === "female" ? "female" : "male", buysItems: !!event.buysItems, stock: event.stock ?? [] }); } continue; } if (event.type === "shop-closed") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.shopClosed, npcEntityId: event.npcEntityId }); } continue; } if (event.type === "market-open") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.marketOpen, displayName: event.displayName, orders: event.orders ?? [], catalog: event.catalog ?? [] }); } continue; } if (event.type === "market-closed") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.marketClosed }); } continue; } if (event.type === "bounty-snapshot") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.bountySnapshot, myAmountCopper: event.myAmountCopper | 0, myAmountLabel: event.myAmountLabel ?? "", message: event.message ?? "", raised: event.raised ?? null }); } continue; } if (event.type === "bounty-closed") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.closeBounty }); } continue; } if (event.type === "character-bounty") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.characterBounty, target: event.target ?? null }); } continue; } if (event.type === "barber-snapshot") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.barberSnapshot, sex: event.sex, styles: event.styles ?? [], hair: event.hair ?? null, message: event.message ?? "" }); } continue; } if (event.type === "barber-closed") { const session = sessions.get(event.sessionId); if (session) { send(session, { type: MessageType.closeBarber }); } continue; } if (event.type === "market-trade") { for (const session of sessions.values()) { if ( session.characterId === event.buyerCharacterId || session.characterId === event.sellerCharacterId ) { send(session, { type: MessageType.marketTrade, itemId: event.itemId, quantity: event.quantity, unitPrice: event.unitPrice, triggeringSide: event.triggeringSide }); } } continue; } if (event.type === "item-bubble") { broadcastItemBubble( sessions, simulation, event.entityId, event.itemId, event.quantity ); continue; } if (event.type === "gather-swing" || event.type === "tile-shove") { publishEntity({ ...event, type: event.type }); continue; } if (event.type === "chunk-delta") { publishEntity(event); continue; } if (event.type === "gather-complete") { const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId); if (session) { send(session, { type: MessageType.gatherComplete, kind: event.kind, materialId: event.materialId, itemId: event.itemId }); } continue; } if (event.type === "entity-move" || event.type === "ground-item-appear" || event.type === "ground-item-despawn" || event.type === "entity-appearance" || event.type === "entity-despawn" || event.type === "entity-spawn" || event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block" || event.type === "combat-projectile" || event.type === "spell-projectile" || event.type === "spell-fizzle" || event.type === "spell-cast-flash" || event.type === "spell-light-appear" || event.type === "spell-light-update" || event.type === "spell-light-remove" || event.type === "entity-health" || event.type === "gather-swing" || event.type === "tile-shove" || event.type === "chunk-delta" || event.type === "skill-level-up") { publishEntity(event); } } if (simulation.tickIndex % simulation.settings.simulationTickHz === 0) { broadcastStatus(); } } function publishReplication (events) { for (const event of events ?? []) { publishEntity(event); } } function publishEntity (event) { const toDim = normalizeDimensionId(event.dimensionId ?? simulation.entityRecord(event.entityId)?.dimensionId ?? OVERWORLD_ID); const fromDim = event.fromDimensionId != null ? normalizeDimensionId(event.fromDimensionId) : toDim; const fromKey = event.fromTileX != null ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim) : null; const toKey = event.tileX != null ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim) : null; for (const session of sessions.values()) { if (!session.entityId) { continue; } const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false; const seesTo = session.entitySubscribed.has(toKey); const seesStaticTo = session.staticSubscribed.has(toKey); if (event.type === "entity-spawn") { if (session.entityId === event.entityId || !seesTo) { continue; } send(session, spawnPayload(event)); continue; } if (event.type === "entity-despawn") { if (session.entityId === event.entityId || (!seesTo && !seesFrom)) { continue; } send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); continue; } if (event.type === "entity-appearance") { if (!seesTo) { continue; } send(session, { type: MessageType.entityAppearance, entityId: event.entityId, sprite: event.sprite, layers: event.layers ?? [], lightRadiusTiles: event.lightRadiusTiles ?? 0 }); continue; } if (event.type === "ground-item-appear") { if (!seesTo) { continue; } if (!canCharacterSeeGroundItem(event, session.characterId)) { continue; } send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear }); continue; } if (event.type === "ground-item-despawn") { if (!seesTo) { continue; } if (!canCharacterSeeGroundItem(event, session.characterId)) { continue; } send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId }); continue; } if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block") { if (!seesTo && !seesFrom) { continue; } const type = event.type === "combat-swing" ? MessageType.combatSwing : event.type === "combat-hit" ? MessageType.combatHit : event.type === "combat-block" ? MessageType.combatBlock : MessageType.combatMiss; send(session, { type, attackerId: event.attackerId, targetId: event.targetId, damage: event.damage, health: event.health, maxHealth: event.maxHealth, tileX: event.tileX, tileY: event.tileY, fromTileX: event.fromTileX, fromTileY: event.fromTileY }); continue; } if (event.type === "combat-projectile") { if (!seesTo && !seesFrom) { continue; } send(session, { type: MessageType.combatProjectile, attackerId: event.attackerId, targetId: event.targetId, fromTileX: event.fromTileX, fromTileY: event.fromTileY, tileX: event.tileX, tileY: event.tileY, durationMs: event.durationMs ?? 400, trackTarget: event.trackTarget !== false, shaftTint: event.shaftTint ?? null, tipTint: event.tipTint ?? null }); continue; } if (event.type === "spell-projectile") { if (!seesTo && !seesFrom) { continue; } send(session, { type: MessageType.spellProjectile, casterId: event.casterId, targetId: event.targetId ?? null, spellId: event.spellId, fromTileX: event.fromTileX, fromTileY: event.fromTileY, tileX: event.tileX, tileY: event.tileY, durationMs: event.durationMs ?? 2000, sprite: event.sprite ?? null }); continue; } if (event.type === "spell-fizzle") { if (!seesTo && !seesFrom) { continue; } send(session, { type: MessageType.spellFizzle, casterId: event.casterId, spellId: event.spellId, fromTileX: event.fromTileX, fromTileY: event.fromTileY, tileX: event.tileX, tileY: event.tileY }); continue; } if (event.type === "spell-cast-flash") { if (!seesTo) { continue; } send(session, { type: MessageType.spellCastFlash, casterId: event.casterId, tileX: event.tileX, tileY: event.tileY, radiusTiles: event.radiusTiles ?? 1, durationMs: event.durationMs ?? 500, tier: event.tier ?? 1 }); continue; } if (event.type === "spell-light-appear" || event.type === "spell-light-update") { if (!seesTo) { continue; } send(session, { type: event.type === "spell-light-appear" ? MessageType.spellLightAppear : MessageType.spellLightUpdate, tileX: event.tileX, tileY: event.tileY, ownerEntityId: event.ownerEntityId, remainingMs: event.remainingMs ?? 0, rangeTiles: event.rangeTiles ?? 0, intensity: event.intensity ?? 0, expiresAt: event.expiresAt ?? 0 }); continue; } if (event.type === "spell-light-remove") { if (!seesTo) { continue; } send(session, { type: MessageType.spellLightRemove, tileX: event.tileX, tileY: event.tileY }); continue; } if (event.type === "entity-health") { if (!seesTo && !seesFrom) { continue; } send(session, { type: MessageType.entityHealth, entityId: event.entityId, health: event.health, maxHealth: event.maxHealth }); continue; } if (event.type === "gather-swing" || event.type === "tile-shove") { if (!seesTo && !seesFrom) { continue; } if (event.type === "gather-swing") { send(session, { type: MessageType.gatherSwing, attackerId: event.attackerId, tileX: event.tileX, tileY: event.tileY, fromTileX: event.fromTileX, fromTileY: event.fromTileY, toolItemId: event.toolItemId ?? null }); } else { send(session, { type: MessageType.tileShove, attackerId: event.attackerId, tileX: event.tileX, tileY: event.tileY, fromTileX: event.fromTileX, fromTileY: event.fromTileY }); } continue; } if (event.type === "skill-level-up") { if (session.entityId !== event.entityId && !seesTo) { continue; } send(session, { type: MessageType.skillLevelUp, entityId: event.entityId, characterId: event.characterId, skillId: event.skillId, level: event.level, displayName: event.displayName, icon: event.icon }); continue; } if (event.type === "chunk-delta") { if (!seesStaticTo) { continue; } send(session, { type: MessageType.chunkDelta, chunkX: event.chunkX, chunkY: event.chunkY, tiles: [{ localX: event.localX, localY: event.localY, block: event.block }] }); continue; } if (event.type !== "entity-move") { continue; } if (seesTo) { if (!seesFrom) { send(session, spawnPayload(event)); } else { send(session, { type: MessageType.entityMove, entityId: event.entityId, tileX: event.tileX, tileY: event.tileY, worldX: event.worldX, worldY: event.worldY, gait: event.gait, lerpMs: event.lerpMs, freeFlight: !!event.freeFlight }); } } else if (seesFrom) { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); } if (session.entityId === event.entityId) { const crossedDimension = event.fromDimensionId != null && event.dimensionId != null && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId); if (!crossedDimension) { syncSubscriptions(session, false); } } } } function spawnPayload (event) { const record = simulation.entityRecord(event.entityId) ?? event; return { type: MessageType.entitySpawn, entityId: event.entityId, characterId: record.characterId ?? event.characterId ?? null, tileX: event.tileX ?? record.tileX, tileY: event.tileY ?? record.tileY, worldX: event.worldX ?? record.worldX, worldY: event.worldY ?? record.worldY, gait: event.gait ?? record.gait, sex: record.sex ?? event.sex ?? null, firstName: record.firstName ?? event.firstName ?? "", lastName: record.lastName ?? event.lastName ?? "", sprite: record.sprite ?? event.sprite ?? null, layers: record.layers ?? event.layers ?? [], mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null, canFight: !!(record.canFight ?? event.canFight), hostile: !!(record.hostile ?? event.hostile), talkable: !!(record.talkable ?? event.talkable), hasDialogue: !!(record.hasDialogue ?? event.hasDialogue), hasShop: !!(record.hasShop ?? event.hasShop), untargetable: !!(record.untargetable ?? event.untargetable), freeFlight: !!(record.freeFlight ?? event.freeFlight), health: record.health ?? event.health, maxHealth: record.maxHealth ?? event.maxHealth, lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0 }; } return { sessions, onTickResult, wss, broadcastRestartStatus, setDraining (value) { draining = !!value; }, async shutdown () { draining = true; await Promise.all([...sessions.values()].map(async (session) => { await sendAsync(session, { type: MessageType.forceLogout, reason: "Server shutting down." }); leaveWorld(session); await closeAsync(session, 1001, "Server shutting down."); })); sessions.clear(); await simulation.shutdown(); } }; } function send (session, payload) { if (session.socket.readyState === 1) { session.socket.send(JSON.stringify(payload)); } } function sendAsync (session, payload) { return new Promise((resolve) => { if (session.socket.readyState !== 1) { resolve(); return; } session.socket.send(JSON.stringify(payload), () => resolve()); }); } function closeAsync (session, code, reason) { return new Promise((resolve) => { if (session.socket.readyState !== 1) { resolve(); return; } session.socket.once("close", resolve); try { session.socket.close(code, reason); } catch { resolve(); } }); }