BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 20.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";
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.sendPigeon:
241 requirePlaying(session);
242 {
243 const result = simulation.dispatchPigeon({
244 characterId: session.characterId,
245 destination: message.destination,
246 cargo: message.cargo
247 });
248 send(session, {
249 type: MessageType.pigeonDispatched,
250 courierId: result.transit.courierId,
251 destinationKind: result.transit.destinationKind,
252 destinationCharacterId: result.transit.destinationCharacterId
253 });
254 send(session, { type: MessageType.inventory, ...result.bag });
255 }
256 break;
257 case MessageType.searchCharacter:
258 requirePlaying(session);
259 {
260 const character = friends.findByFullName(message.firstName, message.lastName);
261 send(session, {
262 type: MessageType.characterSearchResult,
263 character: character ?? null
264 });
265 }
266 break;
267 case MessageType.writeLetter:
268 requirePlaying(session);
269 simulation.enqueue(session.id, {
270 type: "write-letter",
271 characterId: session.characterId,
272 slotIndex: message.slotIndex,
273 body: message.body
274 });
275 break;
276 case MessageType.editLetter:
277 requirePlaying(session);
278 simulation.enqueue(session.id, {
279 type: "edit-letter",
280 characterId: session.characterId,
281 slotIndex: message.slotIndex,
282 body: message.body
283 });
284 break;
285 case MessageType.openLetter:
286 requirePlaying(session);
287 simulation.enqueue(session.id, {
288 type: "open-letter",
289 characterId: session.characterId,
290 slotIndex: message.slotIndex
291 });
292 break;
293 case MessageType.editorLoadChunk:
294 requireAdmin(session);
295 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
296 break;
297 case MessageType.editorSaveChunk:
298 requireAdmin(session);
299 send(session, {
300 type: MessageType.editorChunk,
301 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
302 });
303 break;
304 case MessageType.editorLoadSettings:
305 requireAdmin(session);
306 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
307 break;
308 case MessageType.editorSaveSettings:
309 requireAdmin(session);
310 {
311 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
312 simulation.applySettings(saved.settings);
313 broadcastStatus();
314 broadcastSettings(saved);
315 }
316 break;
317 case MessageType.editorApplyRevision:
318 requireAdmin(session);
319 editor.applyPendingRevision();
320 simulation.reloadWorld();
321 for (const other of sessions.values())
322 {
323 if (other.entityId)
324 { syncSubscriptions(other, true); }
325 }
326 broadcastStatus();
327 break;
328 default:
329 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
330 }
331 }
332
333 function enterWorld (session, characterId)
334 {
335 leaveWorld(session);
336 const character = characters.getOwned(session.account.account_id, characterId);
337 if (character.deletion_scheduled_at)
338 {
339 const error = new Error("That character is marked for deletion.");
340 error.userFacing = true;
341 throw error;
342 }
343 for (const other of sessions.values())
344 {
345 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
346 {
347 const error = new Error("This account already has a character in the world.");
348 error.userFacing = true;
349 throw error;
350 }
351 }
352 session.characterId = character.character_id;
353 session.entityId = simulation.spawnCharacter(session.id, character);
354 const spawned = simulation.entityRecord(session.entityId);
355 send(session, {
356 type: MessageType.enterWorld,
357 entityId: session.entityId,
358 characterId: session.characterId,
359 tileX: spawned.tileX,
360 tileY: spawned.tileY,
361 gait: spawned.gait,
362 sex: spawned.sex,
363 firstName: spawned.firstName,
364 lastName: spawned.lastName,
365 layers: spawned.layers ?? [],
366 settings: simulation.settings,
367 worldTime: simulation.worldTime()
368 });
369 syncSubscriptions(session, true);
370 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
371 const bag = simulation.bagOf(session.entityId);
372 if (bag)
373 { send(session, { type: MessageType.inventory, ...bag }); }
374 publishReplication(simulation.drainReplication());
375 }
376
377 function leaveWorld (session)
378 {
379 if (session.characterId)
380 { simulation.despawnCharacter(session.characterId); }
381 publishReplication(simulation.drainReplication());
382 session.characterId = null;
383 session.entityId = null;
384 session.subscribed.clear();
385 }
386
387 function syncSubscriptions (session, forceSnapshots)
388 {
389 if (!session.entityId)
390 { return; }
391 const position = simulation.positionOf(session.entityId);
392 if (!position)
393 { return; }
394
395 const next = new Set(
396 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
397 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
398 );
399 for (const key of session.subscribed)
400 {
401 if (!next.has(key))
402 {
403 const [chunkX, chunkY] = key.split(",").map(Number);
404 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
405 }
406 }
407 const snapshots = simulation.snapshotFor(session.entityId);
408 for (const snapshot of snapshots)
409 {
410 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
411 if (forceSnapshots || !session.subscribed.has(key))
412 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
413 }
414 session.subscribed = next;
415 }
416
417 function requirePlaying (session)
418 {
419 if (!session.characterId)
420 {
421 const error = new Error("Select a character first.");
422 error.userFacing = true;
423 throw error;
424 }
425 }
426
427 function requireAdmin (session)
428 {
429 if (!session.account.is_admin)
430 {
431 const error = new Error("Admin only.");
432 error.userFacing = true;
433 throw error;
434 }
435 }
436
437 function broadcastStatus ()
438 {
439 const worldTime = simulation.worldTime();
440 for (const session of sessions.values())
441 {
442 if (session.entityId)
443 {
444 send(session, {
445 type: MessageType.worldStatus,
446 worldTime,
447 settings: simulation.settings,
448 activeRevisionId: simulation.activeRevisionId
449 });
450 }
451 }
452 }
453
454 function pushFriends (...characterIds)
455 {
456 const seen = new Set();
457 for (const characterId of characterIds)
458 {
459 const id = Number(characterId);
460 if (!id || seen.has(id))
461 { continue; }
462 seen.add(id);
463 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
464 for (const session of sessions.values())
465 {
466 if (session.characterId === id)
467 { send(session, payload); }
468 }
469 }
470 }
471
472 function broadcastSettings (payload)
473 {
474 for (const session of sessions.values())
475 {
476 if (session.account.is_admin)
477 { send(session, { type: MessageType.editorSettings, ...payload }); }
478 }
479 }
480
481 function onTickResult (result)
482 {
483 publishReplication(result.replication ?? []);
484 for (const event of result.events)
485 {
486 if (event.type === "command-error")
487 {
488 const session = sessions.get(event.sessionId);
489 if (session)
490 { send(session, { type: MessageType.error, message: event.message }); }
491 continue;
492 }
493 if (event.type === "inventory")
494 {
495 const session = event.sessionId != null
496 ? sessions.get(event.sessionId)
497 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
498 if (!session)
499 { continue; }
500 send(session, {
501 type: MessageType.inventory,
502 inventory: event.inventory,
503 equipment: event.equipment,
504 currency: event.currency,
505 vault: event.vault,
506 vaultCurrency: event.vaultCurrency
507 });
508 if (event.bank)
509 {
510 send(session, {
511 type: MessageType.bankSnapshot,
512 vault: event.vault,
513 vaultCurrency: event.vaultCurrency,
514 currency: event.currency,
515 inheritance: stateDb.getInheritance(session.account.account_id)
516 });
517 }
518 continue;
519 }
520 if (event.type === "pigeon-delivered")
521 {
522 for (const session of sessions.values())
523 {
524 if (session.characterId === event.senderCharacterId
525 || session.characterId === event.destinationCharacterId)
526 {
527 send(session, {
528 type: MessageType.pigeonDelivered,
529 courierId: event.courierId,
530 destinationKind: event.destinationKind,
531 cargo: event.cargo
532 });
533 }
534 }
535 continue;
536 }
537 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")
538 { publishEntity(event); }
539 }
540 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
541 { broadcastStatus(); }
542 }
543
544 function publishReplication (events)
545 {
546 for (const event of events ?? [])
547 { publishEntity(event); }
548 }
549
550 function publishEntity (event)
551 {
552 const fromKey = event.fromTileX != null
553 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
554 : null;
555 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
556 for (const session of sessions.values())
557 {
558 if (!session.entityId)
559 { continue; }
560 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
561 const seesTo = session.subscribed.has(toKey);
562 if (event.type === "entity-spawn")
563 {
564 if (session.entityId === event.entityId || !seesTo)
565 { continue; }
566 send(session, spawnPayload(event));
567 continue;
568 }
569 if (event.type === "entity-despawn")
570 {
571 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
572 { continue; }
573 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
574 continue;
575 }
576 if (event.type === "entity-appearance")
577 {
578 if (!seesTo)
579 { continue; }
580 send(session, {
581 type: MessageType.entityAppearance,
582 entityId: event.entityId,
583 sprite: event.sprite,
584 layers: event.layers ?? []
585 });
586 continue;
587 }
588 if (event.type === "ground-item-appear")
589 {
590 if (!seesTo)
591 { continue; }
592 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
593 continue;
594 }
595 if (event.type === "ground-item-despawn")
596 {
597 if (!seesTo)
598 { continue; }
599 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
600 continue;
601 }
602 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss")
603 {
604 if (!seesTo && !seesFrom)
605 { continue; }
606 const type = event.type === "combat-swing"
607 ? MessageType.combatSwing
608 : event.type === "combat-hit"
609 ? MessageType.combatHit
610 : MessageType.combatMiss;
611 send(session, {
612 type,
613 attackerId: event.attackerId,
614 targetId: event.targetId,
615 damage: event.damage,
616 health: event.health,
617 tileX: event.tileX,
618 tileY: event.tileY,
619 fromTileX: event.fromTileX,
620 fromTileY: event.fromTileY
621 });
622 continue;
623 }
624 if (event.type !== "entity-move")
625 { continue; }
626 if (seesTo)
627 {
628 if (!seesFrom)
629 { send(session, spawnPayload(event)); }
630 else
631 {
632 send(session, {
633 type: MessageType.entityMove,
634 entityId: event.entityId,
635 tileX: event.tileX,
636 tileY: event.tileY,
637 worldX: event.worldX,
638 worldY: event.worldY,
639 gait: event.gait,
640 lerpMs: event.lerpMs,
641 freeFlight: !!event.freeFlight
642 });
643 }
644 }
645 else if (seesFrom)
646 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
647 if (session.entityId === event.entityId)
648 { syncSubscriptions(session, false); }
649 }
650 }
651
652 function spawnPayload (event)
653 {
654 const record = simulation.entityRecord(event.entityId) ?? event;
655 return {
656 type: MessageType.entitySpawn,
657 entityId: event.entityId,
658 characterId: record.characterId ?? event.characterId ?? null,
659 tileX: event.tileX ?? record.tileX,
660 tileY: event.tileY ?? record.tileY,
661 worldX: event.worldX ?? record.worldX,
662 worldY: event.worldY ?? record.worldY,
663 gait: event.gait ?? record.gait,
664 sex: record.sex ?? event.sex ?? null,
665 firstName: record.firstName ?? event.firstName ?? "",
666 lastName: record.lastName ?? event.lastName ?? "",
667 sprite: record.sprite ?? event.sprite ?? null,
668 layers: record.layers ?? event.layers ?? [],
669 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
670 hostile: !!(record.hostile ?? event.hostile),
671 talkable: !!(record.talkable ?? event.talkable),
672 untargetable: !!(record.untargetable ?? event.untargetable),
673 freeFlight: !!(record.freeFlight ?? event.freeFlight)
674 };
675 }
676
677 return {
678 sessions,
679 onTickResult,
680 wss,
681 async shutdown ()
682 {
683 for (const session of [...sessions.values()])
684 {
685 send(session, {
686 type: MessageType.forceLogout,
687 reason: "Server shutting down."
688 });
689 leaveWorld(session);
690 try
691 { session.socket.close(1001, "Server shutting down"); }
692 catch
693 { /* ignore */ }
694 }
695 sessions.clear();
696 await simulation.shutdown();
697 }
698 };
699}
700
701function send (session, payload)
702{
703 if (session.socket.readyState === 1)
704 { session.socket.send(JSON.stringify(payload)); }
705}