BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 22.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";
6import { publicSkillsView } from "../../../shared/skills/state.js";
7
8let nextSessionId = 1;
9
10export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation })
11{
12 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
13 const sessions = new Map();
14
15 wss.on("connection", (socket) =>
16 {
17 const identity = auth.claimIdentity();
18 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
19 const session = {
20 id: nextSessionId++,
21 socket,
22 account,
23 authSubject: identity.authSubject,
24 characterId: null,
25 entityId: null,
26 subscribed: new Set()
27 };
28 auth.register(session);
29 sessions.set(session.id, session);
30 send(session, {
31 type: MessageType.session,
32 accountId: account.account_id,
33 authSubject: account.auth_subject,
34 isAdmin: !!account.is_admin,
35 characters: characters.list(account.account_id)
36 });
37
38 socket.on("message", (raw) =>
39 {
40 let message;
41 try
42 { message = JSON.parse(String(raw)); }
43 catch
44 {
45 send(session, { type: MessageType.error, message: "Invalid JSON." });
46 return;
47 }
48 try
49 { handleMessage(session, message); }
50 catch (error)
51 {
52 send(session, {
53 type: MessageType.error,
54 message: error.userFacing ? error.message : "Request failed."
55 });
56 }
57 });
58
59 socket.on("close", () =>
60 {
61 leaveWorld(session);
62 auth.release(session);
63 sessions.delete(session.id);
64 });
65 });
66
67 function handleMessage (session, message)
68 {
69 switch (message.type)
70 {
71 case MessageType.createCharacter:
72 characters.create(session.account, message.firstName, message.lastName, message.sex);
73 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
74 break;
75 case MessageType.selectCharacter:
76 enterWorld(session, message.characterId);
77 break;
78 case MessageType.scheduleDeleteCharacter:
79 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
80 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
81 break;
82 case MessageType.cancelDeleteCharacter:
83 characters.cancelDelete(session.account, message.characterId);
84 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
85 break;
86 case MessageType.leaveWorld:
87 leaveWorld(session);
88 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
89 break;
90 case MessageType.moveTo:
91 requirePlaying(session);
92 simulation.enqueue(session.id, {
93 type: "move-to",
94 characterId: session.characterId,
95 tileX: message.tileX | 0,
96 tileY: message.tileY | 0
97 });
98 break;
99 case MessageType.setGait:
100 requirePlaying(session);
101 simulation.enqueue(session.id, {
102 type: "set-gait",
103 characterId: session.characterId,
104 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
105 });
106 break;
107 case MessageType.friendRequest:
108 requirePlaying(session);
109 friends.request(session.characterId, message.characterId);
110 pushFriends(session.characterId, message.characterId);
111 break;
112 case MessageType.friendAccept:
113 requirePlaying(session);
114 friends.accept(session.characterId, message.characterId);
115 pushFriends(session.characterId, message.characterId);
116 break;
117 case MessageType.friendDecline:
118 requirePlaying(session);
119 friends.decline(session.characterId, message.characterId);
120 pushFriends(session.characterId, message.characterId);
121 break;
122 case MessageType.friendRemove:
123 requirePlaying(session);
124 friends.remove(session.characterId, message.characterId);
125 pushFriends(session.characterId, message.characterId);
126 break;
127 case MessageType.chatSay:
128 requirePlaying(session);
129 broadcastSpeech(sessions, simulation, session, message.text);
130 break;
131 case MessageType.dropItem:
132 requirePlaying(session);
133 simulation.enqueue(session.id, {
134 type: "drop-item",
135 characterId: session.characterId,
136 slotIndex: message.slotIndex | 0,
137 quantity: message.quantity ?? null
138 });
139 break;
140 case MessageType.pickupItem:
141 requirePlaying(session);
142 simulation.enqueue(session.id, {
143 type: "pickup-item",
144 characterId: session.characterId,
145 groundItemId: message.groundItemId | 0
146 });
147 break;
148 case MessageType.equipItem:
149 requirePlaying(session);
150 simulation.enqueue(session.id, {
151 type: "equip-item",
152 characterId: session.characterId,
153 slotIndex: message.slotIndex | 0
154 });
155 break;
156 case MessageType.unequipItem:
157 requirePlaying(session);
158 simulation.enqueue(session.id, {
159 type: "unequip-item",
160 characterId: session.characterId,
161 equipSlot: message.equipSlot
162 });
163 break;
164 case MessageType.eatItem:
165 requirePlaying(session);
166 simulation.enqueue(session.id, {
167 type: "eat-item",
168 characterId: session.characterId,
169 slotIndex: message.slotIndex | 0
170 });
171 break;
172 case MessageType.openBank:
173 requirePlaying(session);
174 simulation.enqueue(session.id, {
175 type: "open-bank",
176 characterId: session.characterId
177 });
178 break;
179 case MessageType.bankDeposit:
180 requirePlaying(session);
181 simulation.enqueue(session.id, {
182 type: "bank-deposit",
183 characterId: session.characterId,
184 slotIndex: message.slotIndex | 0,
185 quantity: message.quantity ?? null
186 });
187 break;
188 case MessageType.bankWithdraw:
189 requirePlaying(session);
190 simulation.enqueue(session.id, {
191 type: "bank-withdraw",
192 characterId: session.characterId,
193 slotIndex: message.slotIndex | 0,
194 quantity: message.quantity ?? null
195 });
196 break;
197 case MessageType.getBlankCheques:
198 requirePlaying(session);
199 simulation.enqueue(session.id, {
200 type: "get-blank-cheques",
201 characterId: session.characterId
202 });
203 break;
204 case MessageType.returnBlankCheques:
205 requirePlaying(session);
206 simulation.enqueue(session.id, {
207 type: "return-blank-cheques",
208 characterId: session.characterId,
209 slotIndex: message.slotIndex | 0,
210 quantity: message.quantity ?? null
211 });
212 break;
213 case MessageType.writeCheque:
214 requirePlaying(session);
215 simulation.enqueue(session.id, {
216 type: "write-cheque",
217 characterId: session.characterId,
218 slotIndex: message.slotIndex | 0,
219 vaultSlotIndex: message.vaultSlotIndex | 0,
220 quantity: message.quantity ?? 1
221 });
222 break;
223 case MessageType.redeemCheque:
224 requirePlaying(session);
225 simulation.enqueue(session.id, {
226 type: "redeem-cheque",
227 characterId: session.characterId,
228 slotIndex: message.slotIndex | 0
229 });
230 break;
231 case MessageType.claimInheritance:
232 requirePlaying(session);
233 {
234 const inheritance = stateDb.getInheritance(session.account.account_id);
235 simulation.enqueue(session.id, {
236 type: "claim-inheritance",
237 characterId: session.characterId,
238 stacks: (inheritance.slots ?? []).filter(Boolean)
239 });
240 }
241 break;
242 case MessageType.attack:
243 requirePlaying(session);
244 simulation.enqueue(session.id, {
245 type: "attack",
246 characterId: session.characterId,
247 targetEntityId: message.targetEntityId | 0
248 });
249 break;
250 case MessageType.cancelAttack:
251 requirePlaying(session);
252 simulation.enqueue(session.id, {
253 type: "cancel-attack",
254 characterId: session.characterId
255 });
256 break;
257 case MessageType.interact:
258 requirePlaying(session);
259 simulation.enqueue(session.id, {
260 type: "interact",
261 characterId: session.characterId,
262 targetEntityId: message.targetEntityId | 0
263 });
264 break;
265 case MessageType.follow:
266 requirePlaying(session);
267 simulation.enqueue(session.id, {
268 type: "follow",
269 characterId: session.characterId,
270 targetEntityId: message.targetEntityId | 0
271 });
272 break;
273 case MessageType.cancelFollow:
274 requirePlaying(session);
275 simulation.enqueue(session.id, {
276 type: "cancel-follow",
277 characterId: session.characterId
278 });
279 break;
280 case MessageType.sendPigeon:
281 requirePlaying(session);
282 {
283 const result = simulation.dispatchPigeon({
284 characterId: session.characterId,
285 destination: message.destination,
286 cargo: message.cargo
287 });
288 send(session, {
289 type: MessageType.pigeonDispatched,
290 courierId: result.transit.courierId,
291 destinationKind: result.transit.destinationKind,
292 destinationCharacterId: result.transit.destinationCharacterId
293 });
294 send(session, { type: MessageType.inventory, ...result.bag });
295 }
296 break;
297 case MessageType.searchCharacter:
298 requirePlaying(session);
299 {
300 const character = friends.findByFullName(message.firstName, message.lastName);
301 send(session, {
302 type: MessageType.characterSearchResult,
303 character: character ?? null
304 });
305 }
306 break;
307 case MessageType.writeLetter:
308 requirePlaying(session);
309 simulation.enqueue(session.id, {
310 type: "write-letter",
311 characterId: session.characterId,
312 slotIndex: message.slotIndex,
313 body: message.body
314 });
315 break;
316 case MessageType.editLetter:
317 requirePlaying(session);
318 simulation.enqueue(session.id, {
319 type: "edit-letter",
320 characterId: session.characterId,
321 slotIndex: message.slotIndex,
322 body: message.body
323 });
324 break;
325 case MessageType.openLetter:
326 requirePlaying(session);
327 simulation.enqueue(session.id, {
328 type: "open-letter",
329 characterId: session.characterId,
330 slotIndex: message.slotIndex
331 });
332 break;
333 case MessageType.editorLoadChunk:
334 requireAdmin(session);
335 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
336 break;
337 case MessageType.editorSaveChunk:
338 requireAdmin(session);
339 send(session, {
340 type: MessageType.editorChunk,
341 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
342 });
343 break;
344 case MessageType.editorLoadSettings:
345 requireAdmin(session);
346 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
347 break;
348 case MessageType.editorSaveSettings:
349 requireAdmin(session);
350 {
351 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
352 simulation.applySettings(saved.settings);
353 broadcastStatus();
354 broadcastSettings(saved);
355 }
356 break;
357 case MessageType.editorApplyRevision:
358 requireAdmin(session);
359 if (!editor.revisionStatus().pendingRevisionId)
360 {
361 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
362 break;
363 }
364 {
365 const appliedRevisionId = editor.applyPendingRevision();
366 simulation.reloadWorld();
367 for (const other of sessions.values())
368 {
369 if (other.entityId)
370 { syncSubscriptions(other, true); }
371 }
372 broadcastStatus();
373 send(session, {
374 type: MessageType.editorRevisionApplied,
375 ...editor.revisionStatus(),
376 appliedRevisionId
377 });
378 }
379 break;
380 default:
381 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
382 }
383 }
384
385 function enterWorld (session, characterId)
386 {
387 leaveWorld(session);
388 const character = characters.getOwned(session.account.account_id, characterId);
389 if (character.deletion_scheduled_at)
390 {
391 const error = new Error("That character is marked for deletion.");
392 error.userFacing = true;
393 throw error;
394 }
395 for (const other of sessions.values())
396 {
397 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
398 {
399 const error = new Error("This account already has a character in the world.");
400 error.userFacing = true;
401 throw error;
402 }
403 }
404 session.characterId = character.character_id;
405 session.entityId = simulation.spawnCharacter(session.id, character);
406 const spawned = simulation.entityRecord(session.entityId);
407 send(session, {
408 type: MessageType.enterWorld,
409 entityId: session.entityId,
410 characterId: session.characterId,
411 tileX: spawned.tileX,
412 tileY: spawned.tileY,
413 gait: spawned.gait,
414 sex: spawned.sex,
415 firstName: spawned.firstName,
416 lastName: spawned.lastName,
417 layers: spawned.layers ?? [],
418 settings: simulation.settings,
419 worldTime: simulation.worldTime()
420 });
421 syncSubscriptions(session, true);
422 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
423 const bag = simulation.bagOf(session.entityId);
424 if (bag)
425 { send(session, { type: MessageType.inventory, ...bag }); }
426 const skills = simulation.skillsOf(session.entityId);
427 if (skills)
428 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
429 publishReplication(simulation.drainReplication());
430 }
431
432 function leaveWorld (session)
433 {
434 if (session.characterId)
435 { simulation.despawnCharacter(session.characterId); }
436 publishReplication(simulation.drainReplication());
437 session.characterId = null;
438 session.entityId = null;
439 session.subscribed.clear();
440 }
441
442 function syncSubscriptions (session, forceSnapshots)
443 {
444 if (!session.entityId)
445 { return; }
446 const position = simulation.positionOf(session.entityId);
447 if (!position)
448 { return; }
449
450 const next = new Set(
451 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
452 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
453 );
454 for (const key of session.subscribed)
455 {
456 if (!next.has(key))
457 {
458 const [chunkX, chunkY] = key.split(",").map(Number);
459 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
460 }
461 }
462 const snapshots = simulation.snapshotFor(session.entityId);
463 for (const snapshot of snapshots)
464 {
465 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
466 if (forceSnapshots || !session.subscribed.has(key))
467 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
468 }
469 session.subscribed = next;
470 }
471
472 function requirePlaying (session)
473 {
474 if (!session.characterId)
475 {
476 const error = new Error("Select a character first.");
477 error.userFacing = true;
478 throw error;
479 }
480 }
481
482 function requireAdmin (session)
483 {
484 if (!session.account.is_admin)
485 {
486 const error = new Error("Admin only.");
487 error.userFacing = true;
488 throw error;
489 }
490 }
491
492 function broadcastStatus ()
493 {
494 const worldTime = simulation.worldTime();
495 for (const session of sessions.values())
496 {
497 if (session.entityId)
498 {
499 send(session, {
500 type: MessageType.worldStatus,
501 worldTime,
502 settings: simulation.settings,
503 activeRevisionId: simulation.activeRevisionId
504 });
505 }
506 }
507 }
508
509 function pushFriends (...characterIds)
510 {
511 const seen = new Set();
512 for (const characterId of characterIds)
513 {
514 const id = Number(characterId);
515 if (!id || seen.has(id))
516 { continue; }
517 seen.add(id);
518 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
519 for (const session of sessions.values())
520 {
521 if (session.characterId === id)
522 { send(session, payload); }
523 }
524 }
525 }
526
527 function broadcastSettings (payload)
528 {
529 for (const session of sessions.values())
530 {
531 if (session.account.is_admin)
532 { send(session, { type: MessageType.editorSettings, ...payload }); }
533 }
534 }
535
536 function onTickResult (result)
537 {
538 publishReplication(result.replication ?? []);
539 for (const event of result.events)
540 {
541 if (event.type === "command-error")
542 {
543 const session = sessions.get(event.sessionId);
544 if (session)
545 { send(session, { type: MessageType.error, message: event.message }); }
546 continue;
547 }
548 if (event.type === "inventory")
549 {
550 const session = event.sessionId != null
551 ? sessions.get(event.sessionId)
552 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
553 if (!session)
554 { continue; }
555 send(session, {
556 type: MessageType.inventory,
557 inventory: event.inventory,
558 equipment: event.equipment,
559 vault: event.vault,
560 vaultReserved: event.vaultReserved
561 });
562 if (event.bank)
563 {
564 send(session, {
565 type: MessageType.bankSnapshot,
566 vault: event.vault,
567 vaultReserved: event.vaultReserved,
568 inheritance: stateDb.getInheritance(session.account.account_id)
569 });
570 }
571 continue;
572 }
573 if (event.type === "skills")
574 {
575 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
576 if (!session)
577 { continue; }
578 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
579 continue;
580 }
581 if (event.type === "pigeon-delivered")
582 {
583 for (const session of sessions.values())
584 {
585 if (session.characterId === event.senderCharacterId
586 || session.characterId === event.destinationCharacterId)
587 {
588 send(session, {
589 type: MessageType.pigeonDelivered,
590 courierId: event.courierId,
591 destinationKind: event.destinationKind,
592 cargo: event.cargo
593 });
594 }
595 }
596 continue;
597 }
598 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")
599 { publishEntity(event); }
600 }
601 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
602 { broadcastStatus(); }
603 }
604
605 function publishReplication (events)
606 {
607 for (const event of events ?? [])
608 { publishEntity(event); }
609 }
610
611 function publishEntity (event)
612 {
613 const fromKey = event.fromTileX != null
614 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
615 : null;
616 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
617 for (const session of sessions.values())
618 {
619 if (!session.entityId)
620 { continue; }
621 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
622 const seesTo = session.subscribed.has(toKey);
623 if (event.type === "entity-spawn")
624 {
625 if (session.entityId === event.entityId || !seesTo)
626 { continue; }
627 send(session, spawnPayload(event));
628 continue;
629 }
630 if (event.type === "entity-despawn")
631 {
632 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
633 { continue; }
634 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
635 continue;
636 }
637 if (event.type === "entity-appearance")
638 {
639 if (!seesTo)
640 { continue; }
641 send(session, {
642 type: MessageType.entityAppearance,
643 entityId: event.entityId,
644 sprite: event.sprite,
645 layers: event.layers ?? []
646 });
647 continue;
648 }
649 if (event.type === "ground-item-appear")
650 {
651 if (!seesTo)
652 { continue; }
653 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
654 continue;
655 }
656 if (event.type === "ground-item-despawn")
657 {
658 if (!seesTo)
659 { continue; }
660 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
661 continue;
662 }
663 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
664 {
665 if (!seesTo && !seesFrom)
666 { continue; }
667 const type = event.type === "combat-swing"
668 ? MessageType.combatSwing
669 : event.type === "combat-hit"
670 ? MessageType.combatHit
671 : event.type === "combat-block"
672 ? MessageType.combatBlock
673 : MessageType.combatMiss;
674 send(session, {
675 type,
676 attackerId: event.attackerId,
677 targetId: event.targetId,
678 damage: event.damage,
679 health: event.health,
680 maxHealth: event.maxHealth,
681 tileX: event.tileX,
682 tileY: event.tileY,
683 fromTileX: event.fromTileX,
684 fromTileY: event.fromTileY
685 });
686 continue;
687 }
688 if (event.type !== "entity-move")
689 { continue; }
690 if (seesTo)
691 {
692 if (!seesFrom)
693 { send(session, spawnPayload(event)); }
694 else
695 {
696 send(session, {
697 type: MessageType.entityMove,
698 entityId: event.entityId,
699 tileX: event.tileX,
700 tileY: event.tileY,
701 worldX: event.worldX,
702 worldY: event.worldY,
703 gait: event.gait,
704 lerpMs: event.lerpMs,
705 freeFlight: !!event.freeFlight
706 });
707 }
708 }
709 else if (seesFrom)
710 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
711 if (session.entityId === event.entityId)
712 { syncSubscriptions(session, false); }
713 }
714 }
715
716 function spawnPayload (event)
717 {
718 const record = simulation.entityRecord(event.entityId) ?? event;
719 return {
720 type: MessageType.entitySpawn,
721 entityId: event.entityId,
722 characterId: record.characterId ?? event.characterId ?? null,
723 tileX: event.tileX ?? record.tileX,
724 tileY: event.tileY ?? record.tileY,
725 worldX: event.worldX ?? record.worldX,
726 worldY: event.worldY ?? record.worldY,
727 gait: event.gait ?? record.gait,
728 sex: record.sex ?? event.sex ?? null,
729 firstName: record.firstName ?? event.firstName ?? "",
730 lastName: record.lastName ?? event.lastName ?? "",
731 sprite: record.sprite ?? event.sprite ?? null,
732 layers: record.layers ?? event.layers ?? [],
733 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
734 canFight: !!(record.canFight ?? event.canFight),
735 hostile: !!(record.hostile ?? event.hostile),
736 talkable: !!(record.talkable ?? event.talkable),
737 untargetable: !!(record.untargetable ?? event.untargetable),
738 freeFlight: !!(record.freeFlight ?? event.freeFlight),
739 health: record.health ?? event.health,
740 maxHealth: record.maxHealth ?? event.maxHealth
741 };
742 }
743
744 return {
745 sessions,
746 onTickResult,
747 wss,
748 async shutdown ()
749 {
750 await Promise.all([...sessions.values()].map(async (session) =>
751 {
752 await sendAsync(session, {
753 type: MessageType.forceLogout,
754 reason: "Server shutting down."
755 });
756 leaveWorld(session);
757 await closeAsync(session, 1001, "Server shutting down.");
758 }));
759 sessions.clear();
760 await simulation.shutdown();
761 }
762 };
763}
764
765function send (session, payload)
766{
767 if (session.socket.readyState === 1)
768 { session.socket.send(JSON.stringify(payload)); }
769}
770
771function sendAsync (session, payload)
772{
773 return new Promise((resolve) =>
774 {
775 if (session.socket.readyState !== 1)
776 {
777 resolve();
778 return;
779 }
780 session.socket.send(JSON.stringify(payload), () => resolve());
781 });
782}
783
784function closeAsync (session, code, reason)
785{
786 return new Promise((resolve) =>
787 {
788 if (session.socket.readyState !== 1)
789 {
790 resolve();
791 return;
792 }
793 session.socket.once("close", resolve);
794 try
795 { session.socket.close(code, reason); }
796 catch
797 { resolve(); }
798 });
799}