BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 17.7 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.attack:
203 requirePlaying(session);
204 simulation.enqueue(session.id, {
205 type: "attack",
206 characterId: session.characterId,
207 targetEntityId: message.targetEntityId | 0
208 });
209 break;
210 case MessageType.cancelAttack:
211 requirePlaying(session);
212 simulation.enqueue(session.id, {
213 type: "cancel-attack",
214 characterId: session.characterId
215 });
216 break;
217 case MessageType.interact:
218 requirePlaying(session);
219 simulation.enqueue(session.id, {
220 type: "interact",
221 characterId: session.characterId,
222 targetEntityId: message.targetEntityId | 0
223 });
224 break;
225 case MessageType.follow:
226 requirePlaying(session);
227 simulation.enqueue(session.id, {
228 type: "follow",
229 characterId: session.characterId,
230 targetEntityId: message.targetEntityId | 0
231 });
232 break;
233 case MessageType.cancelFollow:
234 requirePlaying(session);
235 simulation.enqueue(session.id, {
236 type: "cancel-follow",
237 characterId: session.characterId
238 });
239 break;
240 case MessageType.editorLoadChunk:
241 requireAdmin(session);
242 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
243 break;
244 case MessageType.editorSaveChunk:
245 requireAdmin(session);
246 send(session, {
247 type: MessageType.editorChunk,
248 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
249 });
250 break;
251 case MessageType.editorLoadSettings:
252 requireAdmin(session);
253 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
254 break;
255 case MessageType.editorSaveSettings:
256 requireAdmin(session);
257 {
258 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
259 simulation.applySettings(saved.settings);
260 broadcastStatus();
261 broadcastSettings(saved);
262 }
263 break;
264 case MessageType.editorApplyRevision:
265 requireAdmin(session);
266 editor.applyPendingRevision();
267 simulation.reloadWorld();
268 for (const other of sessions.values())
269 {
270 if (other.entityId)
271 { syncSubscriptions(other, true); }
272 }
273 broadcastStatus();
274 break;
275 default:
276 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
277 }
278 }
279
280 function enterWorld (session, characterId)
281 {
282 leaveWorld(session);
283 const character = characters.getOwned(session.account.account_id, characterId);
284 if (character.deletion_scheduled_at)
285 {
286 const error = new Error("That character is marked for deletion.");
287 error.userFacing = true;
288 throw error;
289 }
290 for (const other of sessions.values())
291 {
292 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
293 {
294 const error = new Error("This account already has a character in the world.");
295 error.userFacing = true;
296 throw error;
297 }
298 }
299 session.characterId = character.character_id;
300 session.entityId = simulation.spawnCharacter(session.id, character);
301 const spawned = simulation.entityRecord(session.entityId);
302 send(session, {
303 type: MessageType.enterWorld,
304 entityId: session.entityId,
305 characterId: session.characterId,
306 tileX: spawned.tileX,
307 tileY: spawned.tileY,
308 gait: spawned.gait,
309 sex: spawned.sex,
310 firstName: spawned.firstName,
311 lastName: spawned.lastName,
312 layers: spawned.layers ?? [],
313 settings: simulation.settings,
314 worldTime: simulation.worldTime()
315 });
316 syncSubscriptions(session, true);
317 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
318 const bag = simulation.bagOf(session.entityId);
319 if (bag)
320 { send(session, { type: MessageType.inventory, ...bag }); }
321 publishReplication(simulation.drainReplication());
322 }
323
324 function leaveWorld (session)
325 {
326 if (session.characterId)
327 { simulation.despawnCharacter(session.characterId); }
328 publishReplication(simulation.drainReplication());
329 session.characterId = null;
330 session.entityId = null;
331 session.subscribed.clear();
332 }
333
334 function syncSubscriptions (session, forceSnapshots)
335 {
336 if (!session.entityId)
337 { return; }
338 const position = simulation.positionOf(session.entityId);
339 if (!position)
340 { return; }
341
342 const next = new Set(
343 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
344 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
345 );
346 for (const key of session.subscribed)
347 {
348 if (!next.has(key))
349 {
350 const [chunkX, chunkY] = key.split(",").map(Number);
351 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
352 }
353 }
354 const snapshots = simulation.snapshotFor(session.entityId);
355 for (const snapshot of snapshots)
356 {
357 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
358 if (forceSnapshots || !session.subscribed.has(key))
359 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
360 }
361 session.subscribed = next;
362 }
363
364 function requirePlaying (session)
365 {
366 if (!session.characterId)
367 {
368 const error = new Error("Select a character first.");
369 error.userFacing = true;
370 throw error;
371 }
372 }
373
374 function requireAdmin (session)
375 {
376 if (!session.account.is_admin)
377 {
378 const error = new Error("Admin only.");
379 error.userFacing = true;
380 throw error;
381 }
382 }
383
384 function broadcastStatus ()
385 {
386 const worldTime = simulation.worldTime();
387 for (const session of sessions.values())
388 {
389 if (session.entityId)
390 {
391 send(session, {
392 type: MessageType.worldStatus,
393 worldTime,
394 settings: simulation.settings,
395 activeRevisionId: simulation.activeRevisionId
396 });
397 }
398 }
399 }
400
401 function pushFriends (...characterIds)
402 {
403 const seen = new Set();
404 for (const characterId of characterIds)
405 {
406 const id = Number(characterId);
407 if (!id || seen.has(id))
408 { continue; }
409 seen.add(id);
410 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
411 for (const session of sessions.values())
412 {
413 if (session.characterId === id)
414 { send(session, payload); }
415 }
416 }
417 }
418
419 function broadcastSettings (payload)
420 {
421 for (const session of sessions.values())
422 {
423 if (session.account.is_admin)
424 { send(session, { type: MessageType.editorSettings, ...payload }); }
425 }
426 }
427
428 function onTickResult (result)
429 {
430 publishReplication(result.replication ?? []);
431 for (const event of result.events)
432 {
433 if (event.type === "command-error")
434 {
435 const session = sessions.get(event.sessionId);
436 if (session)
437 { send(session, { type: MessageType.error, message: event.message }); }
438 continue;
439 }
440 if (event.type === "inventory")
441 {
442 const session = sessions.get(event.sessionId);
443 if (!session)
444 { continue; }
445 send(session, {
446 type: MessageType.inventory,
447 inventory: event.inventory,
448 equipment: event.equipment,
449 currency: event.currency,
450 vault: event.vault,
451 vaultCurrency: event.vaultCurrency
452 });
453 if (event.bank)
454 {
455 send(session, {
456 type: MessageType.bankSnapshot,
457 vault: event.vault,
458 vaultCurrency: event.vaultCurrency,
459 currency: event.currency,
460 inheritance: stateDb.getInheritance(session.account.account_id)
461 });
462 }
463 continue;
464 }
465 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 === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss")
466 { publishEntity(event); }
467 }
468 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
469 { broadcastStatus(); }
470 }
471
472 function publishReplication (events)
473 {
474 for (const event of events ?? [])
475 { publishEntity(event); }
476 }
477
478 function publishEntity (event)
479 {
480 const fromKey = event.fromTileX != null
481 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
482 : null;
483 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
484 for (const session of sessions.values())
485 {
486 if (!session.entityId)
487 { continue; }
488 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
489 const seesTo = session.subscribed.has(toKey);
490 if (event.type === "entity-spawn")
491 {
492 if (session.entityId === event.entityId || !seesTo)
493 { continue; }
494 send(session, spawnPayload(event));
495 continue;
496 }
497 if (event.type === "entity-despawn")
498 {
499 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
500 { continue; }
501 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
502 continue;
503 }
504 if (event.type === "entity-appearance")
505 {
506 if (!seesTo)
507 { continue; }
508 send(session, {
509 type: MessageType.entityAppearance,
510 entityId: event.entityId,
511 sprite: event.sprite,
512 layers: event.layers ?? []
513 });
514 continue;
515 }
516 if (event.type === "ground-item-appear")
517 {
518 if (!seesTo)
519 { continue; }
520 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
521 continue;
522 }
523 if (event.type === "ground-item-despawn")
524 {
525 if (!seesTo)
526 { continue; }
527 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
528 continue;
529 }
530 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss")
531 {
532 if (!seesTo && !seesFrom)
533 { continue; }
534 const type = event.type === "combat-swing"
535 ? MessageType.combatSwing
536 : event.type === "combat-hit"
537 ? MessageType.combatHit
538 : MessageType.combatMiss;
539 send(session, {
540 type,
541 attackerId: event.attackerId,
542 targetId: event.targetId,
543 damage: event.damage,
544 health: event.health,
545 tileX: event.tileX,
546 tileY: event.tileY,
547 fromTileX: event.fromTileX,
548 fromTileY: event.fromTileY
549 });
550 continue;
551 }
552 if (event.type !== "entity-move")
553 { continue; }
554 if (seesTo)
555 {
556 if (!seesFrom)
557 { send(session, spawnPayload(event)); }
558 else
559 {
560 send(session, {
561 type: MessageType.entityMove,
562 entityId: event.entityId,
563 tileX: event.tileX,
564 tileY: event.tileY,
565 worldX: event.worldX,
566 worldY: event.worldY,
567 gait: event.gait,
568 lerpMs: event.lerpMs,
569 freeFlight: !!event.freeFlight
570 });
571 }
572 }
573 else if (seesFrom)
574 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
575 if (session.entityId === event.entityId)
576 { syncSubscriptions(session, false); }
577 }
578 }
579
580 function spawnPayload (event)
581 {
582 const record = simulation.entityRecord(event.entityId) ?? event;
583 return {
584 type: MessageType.entitySpawn,
585 entityId: event.entityId,
586 characterId: record.characterId ?? event.characterId ?? null,
587 tileX: event.tileX ?? record.tileX,
588 tileY: event.tileY ?? record.tileY,
589 worldX: event.worldX ?? record.worldX,
590 worldY: event.worldY ?? record.worldY,
591 gait: event.gait ?? record.gait,
592 sex: record.sex ?? event.sex ?? null,
593 firstName: record.firstName ?? event.firstName ?? "",
594 lastName: record.lastName ?? event.lastName ?? "",
595 sprite: record.sprite ?? event.sprite ?? null,
596 layers: record.layers ?? event.layers ?? [],
597 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
598 hostile: !!(record.hostile ?? event.hostile),
599 talkable: !!(record.talkable ?? event.talkable),
600 untargetable: !!(record.untargetable ?? event.untargetable),
601 freeFlight: !!(record.freeFlight ?? event.freeFlight)
602 };
603 }
604
605 return { sessions, onTickResult, wss };
606}
607
608function send (session, payload)
609{
610 if (session.socket.readyState === 1)
611 { session.socket.send(JSON.stringify(payload)); }
612}