BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 22.3 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 editor.applyPendingRevision();
360 simulation.reloadWorld();
361 for (const other of sessions.values())
362 {
363 if (other.entityId)
364 { syncSubscriptions(other, true); }
365 }
366 broadcastStatus();
367 break;
368 default:
369 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
370 }
371 }
372
373 function enterWorld (session, characterId)
374 {
375 leaveWorld(session);
376 const character = characters.getOwned(session.account.account_id, characterId);
377 if (character.deletion_scheduled_at)
378 {
379 const error = new Error("That character is marked for deletion.");
380 error.userFacing = true;
381 throw error;
382 }
383 for (const other of sessions.values())
384 {
385 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
386 {
387 const error = new Error("This account already has a character in the world.");
388 error.userFacing = true;
389 throw error;
390 }
391 }
392 session.characterId = character.character_id;
393 session.entityId = simulation.spawnCharacter(session.id, character);
394 const spawned = simulation.entityRecord(session.entityId);
395 send(session, {
396 type: MessageType.enterWorld,
397 entityId: session.entityId,
398 characterId: session.characterId,
399 tileX: spawned.tileX,
400 tileY: spawned.tileY,
401 gait: spawned.gait,
402 sex: spawned.sex,
403 firstName: spawned.firstName,
404 lastName: spawned.lastName,
405 layers: spawned.layers ?? [],
406 settings: simulation.settings,
407 worldTime: simulation.worldTime()
408 });
409 syncSubscriptions(session, true);
410 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
411 const bag = simulation.bagOf(session.entityId);
412 if (bag)
413 { send(session, { type: MessageType.inventory, ...bag }); }
414 const skills = simulation.skillsOf(session.entityId);
415 if (skills)
416 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
417 publishReplication(simulation.drainReplication());
418 }
419
420 function leaveWorld (session)
421 {
422 if (session.characterId)
423 { simulation.despawnCharacter(session.characterId); }
424 publishReplication(simulation.drainReplication());
425 session.characterId = null;
426 session.entityId = null;
427 session.subscribed.clear();
428 }
429
430 function syncSubscriptions (session, forceSnapshots)
431 {
432 if (!session.entityId)
433 { return; }
434 const position = simulation.positionOf(session.entityId);
435 if (!position)
436 { return; }
437
438 const next = new Set(
439 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
440 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
441 );
442 for (const key of session.subscribed)
443 {
444 if (!next.has(key))
445 {
446 const [chunkX, chunkY] = key.split(",").map(Number);
447 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
448 }
449 }
450 const snapshots = simulation.snapshotFor(session.entityId);
451 for (const snapshot of snapshots)
452 {
453 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
454 if (forceSnapshots || !session.subscribed.has(key))
455 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
456 }
457 session.subscribed = next;
458 }
459
460 function requirePlaying (session)
461 {
462 if (!session.characterId)
463 {
464 const error = new Error("Select a character first.");
465 error.userFacing = true;
466 throw error;
467 }
468 }
469
470 function requireAdmin (session)
471 {
472 if (!session.account.is_admin)
473 {
474 const error = new Error("Admin only.");
475 error.userFacing = true;
476 throw error;
477 }
478 }
479
480 function broadcastStatus ()
481 {
482 const worldTime = simulation.worldTime();
483 for (const session of sessions.values())
484 {
485 if (session.entityId)
486 {
487 send(session, {
488 type: MessageType.worldStatus,
489 worldTime,
490 settings: simulation.settings,
491 activeRevisionId: simulation.activeRevisionId
492 });
493 }
494 }
495 }
496
497 function pushFriends (...characterIds)
498 {
499 const seen = new Set();
500 for (const characterId of characterIds)
501 {
502 const id = Number(characterId);
503 if (!id || seen.has(id))
504 { continue; }
505 seen.add(id);
506 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
507 for (const session of sessions.values())
508 {
509 if (session.characterId === id)
510 { send(session, payload); }
511 }
512 }
513 }
514
515 function broadcastSettings (payload)
516 {
517 for (const session of sessions.values())
518 {
519 if (session.account.is_admin)
520 { send(session, { type: MessageType.editorSettings, ...payload }); }
521 }
522 }
523
524 function onTickResult (result)
525 {
526 publishReplication(result.replication ?? []);
527 for (const event of result.events)
528 {
529 if (event.type === "command-error")
530 {
531 const session = sessions.get(event.sessionId);
532 if (session)
533 { send(session, { type: MessageType.error, message: event.message }); }
534 continue;
535 }
536 if (event.type === "inventory")
537 {
538 const session = event.sessionId != null
539 ? sessions.get(event.sessionId)
540 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
541 if (!session)
542 { continue; }
543 send(session, {
544 type: MessageType.inventory,
545 inventory: event.inventory,
546 equipment: event.equipment,
547 vault: event.vault,
548 vaultReserved: event.vaultReserved
549 });
550 if (event.bank)
551 {
552 send(session, {
553 type: MessageType.bankSnapshot,
554 vault: event.vault,
555 vaultReserved: event.vaultReserved,
556 inheritance: stateDb.getInheritance(session.account.account_id)
557 });
558 }
559 continue;
560 }
561 if (event.type === "skills")
562 {
563 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
564 if (!session)
565 { continue; }
566 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
567 continue;
568 }
569 if (event.type === "pigeon-delivered")
570 {
571 for (const session of sessions.values())
572 {
573 if (session.characterId === event.senderCharacterId
574 || session.characterId === event.destinationCharacterId)
575 {
576 send(session, {
577 type: MessageType.pigeonDelivered,
578 courierId: event.courierId,
579 destinationKind: event.destinationKind,
580 cargo: event.cargo
581 });
582 }
583 }
584 continue;
585 }
586 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")
587 { publishEntity(event); }
588 }
589 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
590 { broadcastStatus(); }
591 }
592
593 function publishReplication (events)
594 {
595 for (const event of events ?? [])
596 { publishEntity(event); }
597 }
598
599 function publishEntity (event)
600 {
601 const fromKey = event.fromTileX != null
602 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
603 : null;
604 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
605 for (const session of sessions.values())
606 {
607 if (!session.entityId)
608 { continue; }
609 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
610 const seesTo = session.subscribed.has(toKey);
611 if (event.type === "entity-spawn")
612 {
613 if (session.entityId === event.entityId || !seesTo)
614 { continue; }
615 send(session, spawnPayload(event));
616 continue;
617 }
618 if (event.type === "entity-despawn")
619 {
620 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
621 { continue; }
622 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
623 continue;
624 }
625 if (event.type === "entity-appearance")
626 {
627 if (!seesTo)
628 { continue; }
629 send(session, {
630 type: MessageType.entityAppearance,
631 entityId: event.entityId,
632 sprite: event.sprite,
633 layers: event.layers ?? []
634 });
635 continue;
636 }
637 if (event.type === "ground-item-appear")
638 {
639 if (!seesTo)
640 { continue; }
641 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
642 continue;
643 }
644 if (event.type === "ground-item-despawn")
645 {
646 if (!seesTo)
647 { continue; }
648 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
649 continue;
650 }
651 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
652 {
653 if (!seesTo && !seesFrom)
654 { continue; }
655 const type = event.type === "combat-swing"
656 ? MessageType.combatSwing
657 : event.type === "combat-hit"
658 ? MessageType.combatHit
659 : event.type === "combat-block"
660 ? MessageType.combatBlock
661 : MessageType.combatMiss;
662 send(session, {
663 type,
664 attackerId: event.attackerId,
665 targetId: event.targetId,
666 damage: event.damage,
667 health: event.health,
668 maxHealth: event.maxHealth,
669 tileX: event.tileX,
670 tileY: event.tileY,
671 fromTileX: event.fromTileX,
672 fromTileY: event.fromTileY
673 });
674 continue;
675 }
676 if (event.type !== "entity-move")
677 { continue; }
678 if (seesTo)
679 {
680 if (!seesFrom)
681 { send(session, spawnPayload(event)); }
682 else
683 {
684 send(session, {
685 type: MessageType.entityMove,
686 entityId: event.entityId,
687 tileX: event.tileX,
688 tileY: event.tileY,
689 worldX: event.worldX,
690 worldY: event.worldY,
691 gait: event.gait,
692 lerpMs: event.lerpMs,
693 freeFlight: !!event.freeFlight
694 });
695 }
696 }
697 else if (seesFrom)
698 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
699 if (session.entityId === event.entityId)
700 { syncSubscriptions(session, false); }
701 }
702 }
703
704 function spawnPayload (event)
705 {
706 const record = simulation.entityRecord(event.entityId) ?? event;
707 return {
708 type: MessageType.entitySpawn,
709 entityId: event.entityId,
710 characterId: record.characterId ?? event.characterId ?? null,
711 tileX: event.tileX ?? record.tileX,
712 tileY: event.tileY ?? record.tileY,
713 worldX: event.worldX ?? record.worldX,
714 worldY: event.worldY ?? record.worldY,
715 gait: event.gait ?? record.gait,
716 sex: record.sex ?? event.sex ?? null,
717 firstName: record.firstName ?? event.firstName ?? "",
718 lastName: record.lastName ?? event.lastName ?? "",
719 sprite: record.sprite ?? event.sprite ?? null,
720 layers: record.layers ?? event.layers ?? [],
721 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
722 canFight: !!(record.canFight ?? event.canFight),
723 hostile: !!(record.hostile ?? event.hostile),
724 talkable: !!(record.talkable ?? event.talkable),
725 untargetable: !!(record.untargetable ?? event.untargetable),
726 freeFlight: !!(record.freeFlight ?? event.freeFlight),
727 health: record.health ?? event.health,
728 maxHealth: record.maxHealth ?? event.maxHealth
729 };
730 }
731
732 return {
733 sessions,
734 onTickResult,
735 wss,
736 async shutdown ()
737 {
738 await Promise.all([...sessions.values()].map(async (session) =>
739 {
740 await sendAsync(session, {
741 type: MessageType.forceLogout,
742 reason: "Server shutting down."
743 });
744 leaveWorld(session);
745 await closeAsync(session, 1001, "Server shutting down.");
746 }));
747 sessions.clear();
748 await simulation.shutdown();
749 }
750 };
751}
752
753function send (session, payload)
754{
755 if (session.socket.readyState === 1)
756 { session.socket.send(JSON.stringify(payload)); }
757}
758
759function sendAsync (session, payload)
760{
761 return new Promise((resolve) =>
762 {
763 if (session.socket.readyState !== 1)
764 {
765 resolve();
766 return;
767 }
768 session.socket.send(JSON.stringify(payload), () => resolve());
769 });
770}
771
772function closeAsync (session, code, reason)
773{
774 return new Promise((resolve) =>
775 {
776 if (session.socket.readyState !== 1)
777 {
778 resolve();
779 return;
780 }
781 session.socket.once("close", resolve);
782 try
783 { session.socket.close(code, reason); }
784 catch
785 { resolve(); }
786 });
787}