import { WebSocketServer } from "ws"; import { MessageType, GAIT } from "../../../shared/protocol/constants.js"; import { chunkKey, 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"; let nextSessionId = 1; export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation }) { const wss = new WebSocketServer({ server: httpServer, path: "/ws" }); const sessions = new Map(); 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, /** 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 ); 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.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 }); 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) }); break; case MessageType.editorSaveChunk: requireAdmin(session); send(session, { type: MessageType.editorChunk, ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject) }); break; case MessageType.editorLoadSettings: requireAdmin(session); send(session, { type: MessageType.editorSettings, ...editor.loadSettings(), itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {} }); 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.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) { 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); send(session, { type: MessageType.enterWorld, entityId: session.entityId, characterId: session.characterId, tileX: spawned.tileX, tileY: spawned.tileY, 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() }); 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 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))); const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY))); for (const key of session.staticSubscribed) { if (!staticNext.has(key)) { const [chunkX, chunkY] = key.split(",").map(Number); 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); const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key); if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged) { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); } } 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(); for (const session of sessions.values()) { if (session.entityId) { send(session, { type: MessageType.worldStatus, worldTime, settings: simulation.settings, activeRevisionId: simulation.activeRevisionId }); } } } 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 === "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 === "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 fromKey = event.fromTileX != null ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY)) : null; const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY)); 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; } send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear }); continue; } if (event.type === "ground-item-despawn") { if (!seesTo) { 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, 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, 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) { 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), 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, async shutdown () { 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(); } }); }