import { WebSocketServer } from "ws"; import { MessageType, GAIT } from "../../../shared/protocol/constants.js"; import { chunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js"; import { VISIBLE_CHUNK_RADIUS } from "../../../shared/protocol/constants.js"; let nextSessionId = 1; export function attachGateway ({ httpServer, auth, stateDb, characters, 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, subscribed: 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) { switch (message.type) { case MessageType.createCharacter: characters.create(session.account, message.firstName, message.lastName, message.sex); send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) }); 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.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.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() }); 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); editor.applyPendingRevision(); simulation.reloadWorld(); for (const other of sessions.values()) { if (other.entityId) { syncSubscriptions(other, true); } } broadcastStatus(); 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 appearance = simulation.ecs.get(session.entityId, "appearance"); const position = simulation.ecs.get(session.entityId, "position"); const movement = simulation.ecs.get(session.entityId, "movement"); send(session, { type: MessageType.enterWorld, entityId: session.entityId, characterId: session.characterId, tileX: position.tileX, tileY: position.tileY, gait: movement.gait, sex: appearance.sex, firstName: appearance.firstName, lastName: appearance.lastName, settings: simulation.settings, worldTime: simulation.worldTime() }); syncSubscriptions(session, true); } function leaveWorld (session) { if (session.characterId) { simulation.despawnCharacter(session.characterId); } session.characterId = null; session.entityId = null; session.subscribed.clear(); } function syncSubscriptions (session, forceSnapshots) { if (!session.entityId) { return; } const position = simulation.ecs.get(session.entityId, "position"); if (!position) { return; } const next = new Set( visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS) .map((coord) => chunkKey(coord.chunkX, coord.chunkY)) ); for (const key of session.subscribed) { if (!next.has(key)) { const [chunkX, chunkY] = key.split(",").map(Number); send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY }); } } const snapshots = simulation.snapshotFor(session.entityId); for (const snapshot of snapshots) { const key = chunkKey(snapshot.chunkX, snapshot.chunkY); if (forceSnapshots || !session.subscribed.has(key)) { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); } } session.subscribed = next; } 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 broadcastSettings (payload) { for (const session of sessions.values()) { if (session.account.is_admin) { send(session, { type: MessageType.editorSettings, ...payload }); } } } function onTickResult (result) { 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 === "entity-move") { const fromKey = chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY)); const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY)); for (const session of sessions.values()) { if (!session.entityId) { continue; } const seesFrom = session.subscribed.has(fromKey); const seesTo = session.subscribed.has(toKey); if (seesTo) { send(session, { type: MessageType.entityMove, entityId: event.entityId, characterId: event.characterId, tileX: event.tileX, tileY: event.tileY, gait: event.gait }); } else if (seesFrom) { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); } if (session.entityId === event.entityId) { syncSubscriptions(session, false); } } } } if (simulation.tickIndex % simulation.settings.simulationTickHz === 0) { broadcastStatus(); } } return { sessions, onTickResult, wss }; } function send (session, payload) { if (session.socket.readyState === 1) { session.socket.send(JSON.stringify(payload)); } }