BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 9.1 KiB Download Raw
1import { WebSocketServer } from "ws";
2import { MessageType, GAIT } from "../../../shared/protocol/constants.js";
3import { chunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js";
4import { VISIBLE_CHUNK_RADIUS } from "../../../shared/protocol/constants.js";
5
6let nextSessionId = 1;
7
8export function attachGateway ({ httpServer, auth, stateDb, characters, editor, simulation })
9{
10 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
11 const sessions = new Map();
12
13 wss.on("connection", (socket) =>
14 {
15 const identity = auth.claimIdentity();
16 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
17 const session = {
18 id: nextSessionId++,
19 socket,
20 account,
21 authSubject: identity.authSubject,
22 characterId: null,
23 entityId: null,
24 subscribed: new Set()
25 };
26 auth.register(session);
27 sessions.set(session.id, session);
28 send(session, {
29 type: MessageType.session,
30 accountId: account.account_id,
31 authSubject: account.auth_subject,
32 isAdmin: !!account.is_admin,
33 characters: characters.list(account.account_id)
34 });
35
36 socket.on("message", (raw) =>
37 {
38 let message;
39 try
40 { message = JSON.parse(String(raw)); }
41 catch
42 {
43 send(session, { type: MessageType.error, message: "Invalid JSON." });
44 return;
45 }
46 try
47 { handleMessage(session, message); }
48 catch (error)
49 {
50 send(session, {
51 type: MessageType.error,
52 message: error.userFacing ? error.message : "Request failed."
53 });
54 }
55 });
56
57 socket.on("close", () =>
58 {
59 leaveWorld(session);
60 auth.release(session);
61 sessions.delete(session.id);
62 });
63 });
64
65 function handleMessage (session, message)
66 {
67 switch (message.type)
68 {
69 case MessageType.createCharacter:
70 characters.create(session.account, message.firstName, message.lastName, message.sex);
71 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
72 break;
73 case MessageType.selectCharacter:
74 enterWorld(session, message.characterId);
75 break;
76 case MessageType.scheduleDeleteCharacter:
77 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
78 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
79 break;
80 case MessageType.cancelDeleteCharacter:
81 characters.cancelDelete(session.account, message.characterId);
82 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
83 break;
84 case MessageType.leaveWorld:
85 leaveWorld(session);
86 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
87 break;
88 case MessageType.moveTo:
89 requirePlaying(session);
90 simulation.enqueue(session.id, {
91 type: "move-to",
92 characterId: session.characterId,
93 tileX: message.tileX | 0,
94 tileY: message.tileY | 0
95 });
96 break;
97 case MessageType.setGait:
98 requirePlaying(session);
99 simulation.enqueue(session.id, {
100 type: "set-gait",
101 characterId: session.characterId,
102 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
103 });
104 break;
105 case MessageType.editorLoadChunk:
106 requireAdmin(session);
107 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
108 break;
109 case MessageType.editorSaveChunk:
110 requireAdmin(session);
111 send(session, {
112 type: MessageType.editorChunk,
113 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
114 });
115 break;
116 case MessageType.editorLoadSettings:
117 requireAdmin(session);
118 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
119 break;
120 case MessageType.editorSaveSettings:
121 requireAdmin(session);
122 {
123 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
124 simulation.applySettings(saved.settings);
125 broadcastStatus();
126 broadcastSettings(saved);
127 }
128 break;
129 case MessageType.editorApplyRevision:
130 requireAdmin(session);
131 editor.applyPendingRevision();
132 simulation.reloadWorld();
133 for (const other of sessions.values())
134 {
135 if (other.entityId)
136 { syncSubscriptions(other, true); }
137 }
138 broadcastStatus();
139 break;
140 default:
141 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
142 }
143 }
144
145 function enterWorld (session, characterId)
146 {
147 leaveWorld(session);
148 const character = characters.getOwned(session.account.account_id, characterId);
149 if (character.deletion_scheduled_at)
150 {
151 const error = new Error("That character is marked for deletion.");
152 error.userFacing = true;
153 throw error;
154 }
155 for (const other of sessions.values())
156 {
157 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
158 {
159 const error = new Error("This account already has a character in the world.");
160 error.userFacing = true;
161 throw error;
162 }
163 }
164 session.characterId = character.character_id;
165 session.entityId = simulation.spawnCharacter(session.id, character);
166 const appearance = simulation.ecs.get(session.entityId, "appearance");
167 const position = simulation.ecs.get(session.entityId, "position");
168 const movement = simulation.ecs.get(session.entityId, "movement");
169 send(session, {
170 type: MessageType.enterWorld,
171 entityId: session.entityId,
172 characterId: session.characterId,
173 tileX: position.tileX,
174 tileY: position.tileY,
175 gait: movement.gait,
176 sex: appearance.sex,
177 firstName: appearance.firstName,
178 lastName: appearance.lastName,
179 settings: simulation.settings,
180 worldTime: simulation.worldTime()
181 });
182 syncSubscriptions(session, true);
183 }
184
185 function leaveWorld (session)
186 {
187 if (session.characterId)
188 { simulation.despawnCharacter(session.characterId); }
189 session.characterId = null;
190 session.entityId = null;
191 session.subscribed.clear();
192 }
193
194 function syncSubscriptions (session, forceSnapshots)
195 {
196 if (!session.entityId)
197 { return; }
198 const position = simulation.ecs.get(session.entityId, "position");
199 if (!position)
200 { return; }
201
202 const next = new Set(
203 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
204 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
205 );
206 for (const key of session.subscribed)
207 {
208 if (!next.has(key))
209 {
210 const [chunkX, chunkY] = key.split(",").map(Number);
211 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
212 }
213 }
214 const snapshots = simulation.snapshotFor(session.entityId);
215 for (const snapshot of snapshots)
216 {
217 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
218 if (forceSnapshots || !session.subscribed.has(key))
219 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
220 }
221 session.subscribed = next;
222 }
223
224 function requirePlaying (session)
225 {
226 if (!session.characterId)
227 {
228 const error = new Error("Select a character first.");
229 error.userFacing = true;
230 throw error;
231 }
232 }
233
234 function requireAdmin (session)
235 {
236 if (!session.account.is_admin)
237 {
238 const error = new Error("Admin only.");
239 error.userFacing = true;
240 throw error;
241 }
242 }
243
244 function broadcastStatus ()
245 {
246 const worldTime = simulation.worldTime();
247 for (const session of sessions.values())
248 {
249 if (session.entityId)
250 {
251 send(session, {
252 type: MessageType.worldStatus,
253 worldTime,
254 settings: simulation.settings,
255 activeRevisionId: simulation.activeRevisionId
256 });
257 }
258 }
259 }
260
261 function broadcastSettings (payload)
262 {
263 for (const session of sessions.values())
264 {
265 if (session.account.is_admin)
266 { send(session, { type: MessageType.editorSettings, ...payload }); }
267 }
268 }
269
270 function onTickResult (result)
271 {
272 for (const event of result.events)
273 {
274 if (event.type === "command-error")
275 {
276 const session = sessions.get(event.sessionId);
277 if (session)
278 { send(session, { type: MessageType.error, message: event.message }); }
279 continue;
280 }
281 if (event.type === "entity-move")
282 {
283 const fromKey = chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY));
284 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
285 for (const session of sessions.values())
286 {
287 if (!session.entityId)
288 { continue; }
289 const seesFrom = session.subscribed.has(fromKey);
290 const seesTo = session.subscribed.has(toKey);
291 if (seesTo)
292 {
293 send(session, {
294 type: MessageType.entityMove,
295 entityId: event.entityId,
296 characterId: event.characterId,
297 tileX: event.tileX,
298 tileY: event.tileY,
299 gait: event.gait
300 });
301 }
302 else if (seesFrom)
303 {
304 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
305 }
306 if (session.entityId === event.entityId)
307 { syncSubscriptions(session, false); }
308 }
309 }
310 }
311 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
312 { broadcastStatus(); }
313 }
314
315 return { sessions, onTickResult, wss };
316}
317
318function send (session, payload)
319{
320 if (session.socket.readyState === 1)
321 { session.socket.send(JSON.stringify(payload)); }
322}