BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 15.5 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";
5import { broadcastSpeech } from "../chat/speech.js";
6
7let nextSessionId = 1;
8
9export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation })
10{
11 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
12 const sessions = new Map();
13
14 wss.on("connection", (socket) =>
15 {
16 const identity = auth.claimIdentity();
17 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
18 const session = {
19 id: nextSessionId++,
20 socket,
21 account,
22 authSubject: identity.authSubject,
23 characterId: null,
24 entityId: null,
25 subscribed: new Set()
26 };
27 auth.register(session);
28 sessions.set(session.id, session);
29 send(session, {
30 type: MessageType.session,
31 accountId: account.account_id,
32 authSubject: account.auth_subject,
33 isAdmin: !!account.is_admin,
34 characters: characters.list(account.account_id)
35 });
36
37 socket.on("message", (raw) =>
38 {
39 let message;
40 try
41 { message = JSON.parse(String(raw)); }
42 catch
43 {
44 send(session, { type: MessageType.error, message: "Invalid JSON." });
45 return;
46 }
47 try
48 { handleMessage(session, message); }
49 catch (error)
50 {
51 send(session, {
52 type: MessageType.error,
53 message: error.userFacing ? error.message : "Request failed."
54 });
55 }
56 });
57
58 socket.on("close", () =>
59 {
60 leaveWorld(session);
61 auth.release(session);
62 sessions.delete(session.id);
63 });
64 });
65
66 function handleMessage (session, message)
67 {
68 switch (message.type)
69 {
70 case MessageType.createCharacter:
71 characters.create(session.account, message.firstName, message.lastName, message.sex);
72 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
73 break;
74 case MessageType.selectCharacter:
75 enterWorld(session, message.characterId);
76 break;
77 case MessageType.scheduleDeleteCharacter:
78 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
79 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
80 break;
81 case MessageType.cancelDeleteCharacter:
82 characters.cancelDelete(session.account, message.characterId);
83 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
84 break;
85 case MessageType.leaveWorld:
86 leaveWorld(session);
87 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
88 break;
89 case MessageType.moveTo:
90 requirePlaying(session);
91 simulation.enqueue(session.id, {
92 type: "move-to",
93 characterId: session.characterId,
94 tileX: message.tileX | 0,
95 tileY: message.tileY | 0
96 });
97 break;
98 case MessageType.setGait:
99 requirePlaying(session);
100 simulation.enqueue(session.id, {
101 type: "set-gait",
102 characterId: session.characterId,
103 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
104 });
105 break;
106 case MessageType.friendRequest:
107 requirePlaying(session);
108 friends.request(session.characterId, message.characterId);
109 pushFriends(session.characterId, message.characterId);
110 break;
111 case MessageType.friendAccept:
112 requirePlaying(session);
113 friends.accept(session.characterId, message.characterId);
114 pushFriends(session.characterId, message.characterId);
115 break;
116 case MessageType.friendDecline:
117 requirePlaying(session);
118 friends.decline(session.characterId, message.characterId);
119 pushFriends(session.characterId, message.characterId);
120 break;
121 case MessageType.friendRemove:
122 requirePlaying(session);
123 friends.remove(session.characterId, message.characterId);
124 pushFriends(session.characterId, message.characterId);
125 break;
126 case MessageType.chatSay:
127 requirePlaying(session);
128 broadcastSpeech(sessions, simulation, session, message.text);
129 break;
130 case MessageType.dropItem:
131 requirePlaying(session);
132 simulation.enqueue(session.id, {
133 type: "drop-item",
134 characterId: session.characterId,
135 slotIndex: message.slotIndex | 0,
136 quantity: message.quantity ?? null
137 });
138 break;
139 case MessageType.pickupItem:
140 requirePlaying(session);
141 simulation.enqueue(session.id, {
142 type: "pickup-item",
143 characterId: session.characterId,
144 groundItemId: message.groundItemId | 0
145 });
146 break;
147 case MessageType.equipItem:
148 requirePlaying(session);
149 simulation.enqueue(session.id, {
150 type: "equip-item",
151 characterId: session.characterId,
152 slotIndex: message.slotIndex | 0
153 });
154 break;
155 case MessageType.unequipItem:
156 requirePlaying(session);
157 simulation.enqueue(session.id, {
158 type: "unequip-item",
159 characterId: session.characterId,
160 equipSlot: message.equipSlot
161 });
162 break;
163 case MessageType.openBank:
164 requirePlaying(session);
165 simulation.enqueue(session.id, {
166 type: "open-bank",
167 characterId: session.characterId
168 });
169 break;
170 case MessageType.bankDeposit:
171 requirePlaying(session);
172 simulation.enqueue(session.id, {
173 type: message.money ? "bank-deposit-money" : "bank-deposit",
174 characterId: session.characterId,
175 slotIndex: message.slotIndex | 0,
176 quantity: message.quantity ?? null,
177 amount: message.amount | 0
178 });
179 break;
180 case MessageType.bankWithdraw:
181 requirePlaying(session);
182 simulation.enqueue(session.id, {
183 type: message.money ? "bank-withdraw-money" : "bank-withdraw",
184 characterId: session.characterId,
185 slotIndex: message.slotIndex | 0,
186 quantity: message.quantity ?? null,
187 amount: message.amount | 0
188 });
189 break;
190 case MessageType.claimInheritance:
191 requirePlaying(session);
192 {
193 const inheritance = stateDb.getInheritance(session.account.account_id);
194 simulation.enqueue(session.id, {
195 type: "claim-inheritance",
196 characterId: session.characterId,
197 stacks: (inheritance.slots ?? []).filter(Boolean),
198 currency: inheritance.currency | 0
199 });
200 }
201 break;
202 case MessageType.editorLoadChunk:
203 requireAdmin(session);
204 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
205 break;
206 case MessageType.editorSaveChunk:
207 requireAdmin(session);
208 send(session, {
209 type: MessageType.editorChunk,
210 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
211 });
212 break;
213 case MessageType.editorLoadSettings:
214 requireAdmin(session);
215 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
216 break;
217 case MessageType.editorSaveSettings:
218 requireAdmin(session);
219 {
220 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
221 simulation.applySettings(saved.settings);
222 broadcastStatus();
223 broadcastSettings(saved);
224 }
225 break;
226 case MessageType.editorApplyRevision:
227 requireAdmin(session);
228 editor.applyPendingRevision();
229 simulation.reloadWorld();
230 for (const other of sessions.values())
231 {
232 if (other.entityId)
233 { syncSubscriptions(other, true); }
234 }
235 broadcastStatus();
236 break;
237 default:
238 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
239 }
240 }
241
242 function enterWorld (session, characterId)
243 {
244 leaveWorld(session);
245 const character = characters.getOwned(session.account.account_id, characterId);
246 if (character.deletion_scheduled_at)
247 {
248 const error = new Error("That character is marked for deletion.");
249 error.userFacing = true;
250 throw error;
251 }
252 for (const other of sessions.values())
253 {
254 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
255 {
256 const error = new Error("This account already has a character in the world.");
257 error.userFacing = true;
258 throw error;
259 }
260 }
261 session.characterId = character.character_id;
262 session.entityId = simulation.spawnCharacter(session.id, character);
263 const spawned = simulation.entityRecord(session.entityId);
264 send(session, {
265 type: MessageType.enterWorld,
266 entityId: session.entityId,
267 characterId: session.characterId,
268 tileX: spawned.tileX,
269 tileY: spawned.tileY,
270 gait: spawned.gait,
271 sex: spawned.sex,
272 firstName: spawned.firstName,
273 lastName: spawned.lastName,
274 layers: spawned.layers ?? [],
275 settings: simulation.settings,
276 worldTime: simulation.worldTime()
277 });
278 syncSubscriptions(session, true);
279 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
280 const bag = simulation.bagOf(session.entityId);
281 if (bag)
282 { send(session, { type: MessageType.inventory, ...bag }); }
283 publishReplication(simulation.drainReplication());
284 }
285
286 function leaveWorld (session)
287 {
288 if (session.characterId)
289 { simulation.despawnCharacter(session.characterId); }
290 publishReplication(simulation.drainReplication());
291 session.characterId = null;
292 session.entityId = null;
293 session.subscribed.clear();
294 }
295
296 function syncSubscriptions (session, forceSnapshots)
297 {
298 if (!session.entityId)
299 { return; }
300 const position = simulation.positionOf(session.entityId);
301 if (!position)
302 { return; }
303
304 const next = new Set(
305 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
306 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
307 );
308 for (const key of session.subscribed)
309 {
310 if (!next.has(key))
311 {
312 const [chunkX, chunkY] = key.split(",").map(Number);
313 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
314 }
315 }
316 const snapshots = simulation.snapshotFor(session.entityId);
317 for (const snapshot of snapshots)
318 {
319 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
320 if (forceSnapshots || !session.subscribed.has(key))
321 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
322 }
323 session.subscribed = next;
324 }
325
326 function requirePlaying (session)
327 {
328 if (!session.characterId)
329 {
330 const error = new Error("Select a character first.");
331 error.userFacing = true;
332 throw error;
333 }
334 }
335
336 function requireAdmin (session)
337 {
338 if (!session.account.is_admin)
339 {
340 const error = new Error("Admin only.");
341 error.userFacing = true;
342 throw error;
343 }
344 }
345
346 function broadcastStatus ()
347 {
348 const worldTime = simulation.worldTime();
349 for (const session of sessions.values())
350 {
351 if (session.entityId)
352 {
353 send(session, {
354 type: MessageType.worldStatus,
355 worldTime,
356 settings: simulation.settings,
357 activeRevisionId: simulation.activeRevisionId
358 });
359 }
360 }
361 }
362
363 function pushFriends (...characterIds)
364 {
365 const seen = new Set();
366 for (const characterId of characterIds)
367 {
368 const id = Number(characterId);
369 if (!id || seen.has(id))
370 { continue; }
371 seen.add(id);
372 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
373 for (const session of sessions.values())
374 {
375 if (session.characterId === id)
376 { send(session, payload); }
377 }
378 }
379 }
380
381 function broadcastSettings (payload)
382 {
383 for (const session of sessions.values())
384 {
385 if (session.account.is_admin)
386 { send(session, { type: MessageType.editorSettings, ...payload }); }
387 }
388 }
389
390 function onTickResult (result)
391 {
392 publishReplication(result.replication ?? []);
393 for (const event of result.events)
394 {
395 if (event.type === "command-error")
396 {
397 const session = sessions.get(event.sessionId);
398 if (session)
399 { send(session, { type: MessageType.error, message: event.message }); }
400 continue;
401 }
402 if (event.type === "inventory")
403 {
404 const session = sessions.get(event.sessionId);
405 if (!session)
406 { continue; }
407 send(session, {
408 type: MessageType.inventory,
409 inventory: event.inventory,
410 equipment: event.equipment,
411 currency: event.currency,
412 vault: event.vault,
413 vaultCurrency: event.vaultCurrency
414 });
415 if (event.bank)
416 {
417 send(session, {
418 type: MessageType.bankSnapshot,
419 vault: event.vault,
420 vaultCurrency: event.vaultCurrency,
421 currency: event.currency,
422 inheritance: stateDb.getInheritance(session.account.account_id)
423 });
424 }
425 continue;
426 }
427 if (event.type === "entity-move" || event.type === "ground-item-appear" || event.type === "ground-item-despawn" || event.type === "entity-appearance")
428 { publishEntity(event); }
429 }
430 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
431 { broadcastStatus(); }
432 }
433
434 function publishReplication (events)
435 {
436 for (const event of events ?? [])
437 { publishEntity(event); }
438 }
439
440 function publishEntity (event)
441 {
442 const fromKey = event.fromTileX != null
443 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
444 : null;
445 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
446 for (const session of sessions.values())
447 {
448 if (!session.entityId)
449 { continue; }
450 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
451 const seesTo = session.subscribed.has(toKey);
452 if (event.type === "entity-spawn")
453 {
454 if (session.entityId === event.entityId || !seesTo)
455 { continue; }
456 send(session, spawnPayload(event));
457 continue;
458 }
459 if (event.type === "entity-despawn")
460 {
461 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
462 { continue; }
463 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
464 continue;
465 }
466 if (event.type === "entity-appearance")
467 {
468 if (!seesTo)
469 { continue; }
470 send(session, {
471 type: MessageType.entityAppearance,
472 entityId: event.entityId,
473 sprite: event.sprite,
474 layers: event.layers ?? []
475 });
476 continue;
477 }
478 if (event.type === "ground-item-appear")
479 {
480 if (!seesTo)
481 { continue; }
482 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
483 continue;
484 }
485 if (event.type === "ground-item-despawn")
486 {
487 if (!seesTo)
488 { continue; }
489 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
490 continue;
491 }
492 if (event.type !== "entity-move")
493 { continue; }
494 if (seesTo)
495 {
496 if (!seesFrom)
497 { send(session, spawnPayload(event)); }
498 else
499 {
500 send(session, {
501 type: MessageType.entityMove,
502 entityId: event.entityId,
503 tileX: event.tileX,
504 tileY: event.tileY,
505 gait: event.gait
506 });
507 }
508 }
509 else if (seesFrom)
510 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
511 if (session.entityId === event.entityId)
512 { syncSubscriptions(session, false); }
513 }
514 }
515
516 function spawnPayload (event)
517 {
518 const record = simulation.entityRecord(event.entityId) ?? event;
519 return {
520 type: MessageType.entitySpawn,
521 entityId: event.entityId,
522 characterId: record.characterId ?? event.characterId ?? null,
523 tileX: event.tileX ?? record.tileX,
524 tileY: event.tileY ?? record.tileY,
525 gait: event.gait ?? record.gait,
526 sex: record.sex ?? event.sex ?? null,
527 firstName: record.firstName ?? event.firstName ?? "",
528 lastName: record.lastName ?? event.lastName ?? "",
529 sprite: record.sprite ?? event.sprite ?? null,
530 layers: record.layers ?? event.layers ?? []
531 };
532 }
533
534 return { sessions, onTickResult, wss };
535}
536
537function send (session, payload)
538{
539 if (session.socket.readyState === 1)
540 { session.socket.send(JSON.stringify(payload)); }
541}