BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 66.4 KiB Download Raw
1import { WebSocketServer } from "ws";
2import { MessageType, GAIT } from "../../../shared/protocol/constants.js";
3import { chunkKey, parseChunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js";
4import { VISIBLE_CHUNK_RADIUS, STATIC_CHUNK_RADIUS } from "../../../shared/protocol/constants.js";
5import { staticChunkRadiusForViewDistance, ViewDistance, normalizeGraphicsSettings } from "../../../shared/graphics/settings.js";
6import { broadcastSpeech, broadcastItemBubble } from "../chat/speech.js";
7import { CraftingStationId, craftingStationDefinition } from "../../../shared/definitions/craftingStations.js";
8import { publicSkillsPayload } from "../../../shared/skills/state.js";
9import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js";
10import { canCharacterSeeGroundItem } from "../../../shared/items/letters.js";
11import { getConsoleSnapshot, subscribeConsole } from "../logging/consoleCapture.js";
12import { resolveAccount } from "../auth/routes.js";
13
14let nextSessionId = 1;
15
16export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation, deploy = null })
17{
18 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
19 const sessions = new Map();
20 let draining = false;
21
22 subscribeConsole((entry) =>
23 {
24 for (const session of sessions.values())
25 {
26 if (session.consoleSubscribed && session.account?.is_admin)
27 {
28 send(session, {
29 type: MessageType.editorConsoleLine,
30 line: entry
31 });
32 }
33 }
34 });
35
36 wss.on("connection", (socket, req) =>
37 {
38 void openSession(socket, req);
39 });
40
41 async function openSession (socket, req)
42 {
43 let identity;
44 try
45 {
46 identity = await auth.authenticateRequest(req);
47 }
48 catch (error)
49 {
50 console.error("[ws] Authentication error:", error?.message ?? error);
51 socket.close(1011, "Authentication failed.");
52 return;
53 }
54 if (!identity)
55 {
56 console.warn("[ws] Connection rejected: no valid session cookie.");
57 socket.close(4401, "Authentication required.");
58 return;
59 }
60
61 try
62 {
63 const account = identity.stub
64 ? stateDb.ensureAccount(identity.authSubject, true, identity.email, identity.username)
65 : await resolveAccount(stateDb, identity);
66 const session = {
67 id: nextSessionId++,
68 socket,
69 account,
70 authSubject: identity.authSubject,
71 username: identity.username ?? account.username ?? null,
72 accessToken: identity.accessToken ?? null,
73 characterId: null,
74 entityId: null,
75 /** Client graphics: long = STATIC_CHUNK_RADIUS map ring; short = VISIBLE_CHUNK_RADIUS. */
76 viewDistance: ViewDistance.long,
77 consoleSubscribed: false,
78 /** Chunks where entity / ground-item replication is active (3×3). */
79 entitySubscribed: new Set(),
80 /** Chunks with map + baked lighting only (5×5 when long). */
81 staticSubscribed: new Set()
82 };
83 auth.register(session);
84 auth.startSessionMaintenance?.(session);
85 sessions.set(session.id, session);
86 send(session, {
87 type: MessageType.session,
88 accountId: account.account_id,
89 authSubject: account.auth_subject,
90 username: session.username,
91 email: account.email ?? null,
92 isAdmin: !!account.is_admin,
93 characters: characters.list(account.account_id)
94 });
95
96 socket.on("message", (raw) =>
97 {
98 let message;
99 try
100 { message = JSON.parse(String(raw)); }
101 catch
102 {
103 send(session, { type: MessageType.error, message: "Invalid JSON." });
104 return;
105 }
106 try
107 { handleMessage(session, message); }
108 catch (error)
109 {
110 send(session, {
111 type: MessageType.error,
112 message: error.userFacing ? error.message : "Request failed."
113 });
114 }
115 });
116
117 socket.on("close", () =>
118 {
119 if (!session.suppressLeaveWorldOnClose)
120 { leaveWorld(session); }
121 auth.release(session);
122 sessions.delete(session.id);
123 });
124 }
125 catch (error)
126 {
127 console.error("[ws] Session setup failed:", error?.message ?? error);
128 socket.close(1011, "Session setup failed.");
129 }
130 }
131
132 function handleMessage (session, message)
133 {
134 if (session.characterId
135 && stateDb.getCharacter(session.characterId)?.is_dead
136 && message.type !== MessageType.respawn
137 && message.type !== MessageType.leaveWorld)
138 {
139 // Dead bodies may only respawn or leave the world — ignore all other intents.
140 return;
141 }
142 switch (message.type)
143 {
144 case MessageType.createCharacter:
145 {
146 const created = characters.create(
147 session.account,
148 message.firstName,
149 message.lastName,
150 message.sex,
151 message.hair ?? null,
152 simulation.settings,
153 message.clothing ?? null
154 );
155 enterWorld(session, created.characterId);
156 }
157 break;
158 case MessageType.selectCharacter:
159 enterWorld(session, message.characterId);
160 break;
161 case MessageType.scheduleDeleteCharacter:
162 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
163 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
164 break;
165 case MessageType.cancelDeleteCharacter:
166 characters.cancelDelete(session.account, message.characterId);
167 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
168 break;
169 case MessageType.leaveWorld:
170 leaveWorld(session);
171 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
172 break;
173 case MessageType.respawn:
174 requirePlaying(session);
175 simulation.enqueue(session.id, {
176 type: "respawn",
177 characterId: session.characterId
178 });
179 break;
180 case MessageType.moveTo:
181 requirePlaying(session);
182 simulation.enqueue(session.id, {
183 type: "move-to",
184 characterId: session.characterId,
185 tileX: message.tileX | 0,
186 tileY: message.tileY | 0
187 });
188 break;
189 case MessageType.setGait:
190 requirePlaying(session);
191 simulation.enqueue(session.id, {
192 type: "set-gait",
193 characterId: session.characterId,
194 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
195 });
196 break;
197 case MessageType.friendRequest:
198 requirePlaying(session);
199 friends.request(session.characterId, message.characterId);
200 pushFriends(session.characterId, message.characterId);
201 break;
202 case MessageType.friendAccept:
203 requirePlaying(session);
204 if (message.accountId)
205 { friends.acceptAccount(session.characterId, message.accountId); }
206 else
207 { friends.accept(session.characterId, message.characterId); }
208 pushFriends(session.characterId, message.characterId, message.accountId);
209 break;
210 case MessageType.friendDecline:
211 requirePlaying(session);
212 if (message.accountId)
213 { friends.declineAccount(session.characterId, message.accountId); }
214 else
215 { friends.decline(session.characterId, message.characterId); }
216 pushFriends(session.characterId, message.characterId, message.accountId);
217 break;
218 case MessageType.friendRemove:
219 requirePlaying(session);
220 if (message.accountId)
221 { friends.removeAccount(session.characterId, message.accountId); }
222 else
223 { friends.remove(session.characterId, message.characterId); }
224 pushFriends(session.characterId, message.characterId, message.accountId);
225 break;
226 case MessageType.chatSay:
227 requirePlaying(session);
228 broadcastSpeech(sessions, simulation, session, message.text);
229 break;
230 case MessageType.dropItem:
231 requirePlaying(session);
232 simulation.enqueue(session.id, {
233 type: "drop-item",
234 characterId: session.characterId,
235 slotIndex: message.slotIndex | 0,
236 quantity: message.quantity ?? null
237 });
238 break;
239 case MessageType.pickupItem:
240 requirePlaying(session);
241 simulation.enqueue(session.id, {
242 type: "pickup-item",
243 characterId: session.characterId,
244 groundItemId: message.groundItemId | 0
245 });
246 break;
247 case MessageType.equipItem:
248 requirePlaying(session);
249 simulation.enqueue(session.id, {
250 type: "equip-item",
251 characterId: session.characterId,
252 slotIndex: message.slotIndex | 0
253 });
254 break;
255 case MessageType.unequipItem:
256 requirePlaying(session);
257 simulation.enqueue(session.id, {
258 type: "unequip-item",
259 characterId: session.characterId,
260 equipSlot: message.equipSlot
261 });
262 break;
263 case MessageType.moveInventorySlot:
264 requirePlaying(session);
265 simulation.enqueue(session.id, {
266 type: "move-inventory-slot",
267 characterId: session.characterId,
268 fromSlotIndex: message.fromSlotIndex | 0,
269 toSlotIndex: message.toSlotIndex | 0
270 });
271 break;
272 case MessageType.eatItem:
273 requirePlaying(session);
274 simulation.enqueue(session.id, {
275 type: "eat-item",
276 characterId: session.characterId,
277 slotIndex: message.slotIndex | 0
278 });
279 break;
280 case MessageType.drinkItem:
281 requirePlaying(session);
282 simulation.enqueue(session.id, {
283 type: "drink-item",
284 characterId: session.characterId,
285 slotIndex: message.slotIndex | 0
286 });
287 break;
288 case MessageType.tipArrows:
289 requirePlaying(session);
290 simulation.enqueue(session.id, {
291 type: "tip-arrows",
292 characterId: session.characterId,
293 coatingSlotIndex: message.coatingSlotIndex | 0,
294 arrowSlotIndex: message.arrowSlotIndex | 0,
295 quantity: message.quantity | 0
296 });
297 break;
298 case MessageType.openBank:
299 requirePlaying(session);
300 simulation.enqueue(session.id, {
301 type: "open-bank",
302 characterId: session.characterId
303 });
304 break;
305 case MessageType.enterDoorway:
306 requirePlaying(session);
307 simulation.enqueue(session.id, {
308 type: "enter-doorway",
309 characterId: session.characterId,
310 tileX: message.tileX | 0,
311 tileY: message.tileY | 0
312 });
313 break;
314 case MessageType.openBounty:
315 requirePlaying(session);
316 simulation.enqueue(session.id, {
317 type: "open-bounty",
318 characterId: session.characterId
319 });
320 break;
321 case MessageType.raiseBounty:
322 requirePlaying(session);
323 simulation.enqueue(session.id, {
324 type: "raise-bounty",
325 characterId: session.characterId,
326 firstName: message.firstName,
327 lastName: message.lastName,
328 amountCopper: message.amountCopper
329 });
330 break;
331 case MessageType.getCharacterBounty:
332 requirePlaying(session);
333 simulation.enqueue(session.id, {
334 type: "get-character-bounty",
335 characterId: session.characterId,
336 targetCharacterId: message.characterId,
337 firstName: message.firstName,
338 lastName: message.lastName
339 });
340 break;
341 case MessageType.closeBounty:
342 requirePlaying(session);
343 simulation.enqueue(session.id, {
344 type: "close-bounty",
345 characterId: session.characterId
346 });
347 break;
348 case MessageType.openBarber:
349 requirePlaying(session);
350 simulation.enqueue(session.id, {
351 type: "open-barber",
352 characterId: session.characterId
353 });
354 break;
355 case MessageType.setHair:
356 requirePlaying(session);
357 simulation.enqueue(session.id, {
358 type: "set-hair",
359 characterId: session.characterId,
360 hair: message.hair ?? null
361 });
362 break;
363 case MessageType.closeBarber:
364 requirePlaying(session);
365 simulation.enqueue(session.id, {
366 type: "close-barber",
367 characterId: session.characterId
368 });
369 break;
370 case MessageType.openCauldron:
371 requirePlaying(session);
372 simulation.enqueue(session.id, {
373 type: "open-cauldron",
374 characterId: session.characterId
375 });
376 break;
377 case MessageType.openFurnace:
378 requirePlaying(session);
379 simulation.enqueue(session.id, {
380 type: "open-station",
381 characterId: session.characterId,
382 stationId: CraftingStationId.furnace
383 });
384 break;
385 case MessageType.openStation:
386 {
387 requirePlaying(session);
388 const stationId = typeof message.stationId === "string"
389 ? message.stationId
390 : null;
391 if (!stationId || !craftingStationDefinition(stationId))
392 { break; }
393 simulation.enqueue(session.id, {
394 type: "open-station",
395 characterId: session.characterId,
396 stationId
397 });
398 break;
399 }
400 case MessageType.mine:
401 requirePlaying(session);
402 simulation.enqueue(session.id, {
403 type: "mine",
404 characterId: session.characterId,
405 tileX: message.tileX | 0,
406 tileY: message.tileY | 0
407 });
408 break;
409 case MessageType.chop:
410 requirePlaying(session);
411 simulation.enqueue(session.id, {
412 type: "chop",
413 characterId: session.characterId,
414 tileX: message.tileX | 0,
415 tileY: message.tileY | 0
416 });
417 break;
418 case MessageType.pick:
419 requirePlaying(session);
420 simulation.enqueue(session.id, {
421 type: "pick",
422 characterId: session.characterId,
423 tileX: message.tileX | 0,
424 tileY: message.tileY | 0
425 });
426 break;
427 case MessageType.cancelGather:
428 requirePlaying(session);
429 simulation.enqueue(session.id, {
430 type: "cancel-gather",
431 characterId: session.characterId
432 });
433 break;
434 case MessageType.startCraft:
435 requirePlaying(session);
436 simulation.enqueue(session.id, {
437 type: "start-craft",
438 characterId: session.characterId,
439 stationId: message.stationId,
440 recipeId: message.recipeId,
441 clothTier: message.clothTier ?? null,
442 dyeSlotIndex: message.dyeSlotIndex ?? null,
443 batchCount: message.batchCount ?? null,
444 batchAll: !!message.batchAll
445 });
446 break;
447 case MessageType.startFire:
448 requirePlaying(session);
449 simulation.enqueue(session.id, {
450 type: "start-fire",
451 characterId: session.characterId,
452 groundItemId: message.groundItemId | 0
453 });
454 break;
455 case MessageType.shear:
456 requirePlaying(session);
457 simulation.enqueue(session.id, {
458 type: "shear",
459 characterId: session.characterId,
460 targetEntityId: message.targetEntityId | 0
461 });
462 break;
463 case MessageType.startFish:
464 requirePlaying(session);
465 simulation.enqueue(session.id, {
466 type: "start-fish",
467 characterId: session.characterId,
468 tileX: message.tileX | 0,
469 tileY: message.tileY | 0
470 });
471 break;
472 case MessageType.cancelCraft:
473 requirePlaying(session);
474 simulation.enqueue(session.id, {
475 type: "cancel-craft",
476 characterId: session.characterId
477 });
478 break;
479 case MessageType.cauldronSetSlot:
480 requirePlaying(session);
481 simulation.enqueue(session.id, {
482 type: "cauldron-set-slot",
483 characterId: session.characterId,
484 slotIndex: message.slotIndex | 0,
485 itemId: message.itemId | 0,
486 quantity: message.quantity | 0,
487 instance: message.instance ?? null
488 });
489 break;
490 case MessageType.cauldronSetDyeSlot:
491 requirePlaying(session);
492 simulation.enqueue(session.id, {
493 type: "cauldron-set-dye-slot",
494 characterId: session.characterId,
495 slotIndex: message.slotIndex | 0,
496 itemId: message.itemId | 0,
497 quantity: message.quantity | 0,
498 instance: message.instance ?? null
499 });
500 break;
501 case MessageType.cauldronInsert:
502 requirePlaying(session);
503 simulation.enqueue(session.id, {
504 type: "cauldron-insert",
505 characterId: session.characterId,
506 itemId: message.itemId | 0,
507 quantity: message.quantity | 0,
508 instance: message.instance ?? null
509 });
510 break;
511 case MessageType.cauldronAction:
512 requirePlaying(session);
513 simulation.enqueue(session.id, {
514 type: "cauldron-action",
515 characterId: session.characterId,
516 action: message.action
517 });
518 break;
519 case MessageType.cauldronBottle:
520 requirePlaying(session);
521 simulation.enqueue(session.id, {
522 type: "cauldron-bottle",
523 characterId: session.characterId
524 });
525 break;
526 case MessageType.cauldronCreateDye:
527 requirePlaying(session);
528 simulation.enqueue(session.id, {
529 type: "cauldron-create-dye",
530 characterId: session.characterId,
531 confirmOverflow: !!message.confirmOverflow,
532 flowers: Array.isArray(message.flowers) ? message.flowers : []
533 });
534 break;
535 case MessageType.cauldronClear:
536 requirePlaying(session);
537 simulation.enqueue(session.id, {
538 type: "cauldron-clear",
539 characterId: session.characterId
540 });
541 break;
542 case MessageType.cauldronClearDye:
543 requirePlaying(session);
544 simulation.enqueue(session.id, {
545 type: "cauldron-clear-dye",
546 characterId: session.characterId
547 });
548 break;
549 case MessageType.cauldronSaveRecipe:
550 requirePlaying(session);
551 simulation.enqueue(session.id, {
552 type: "cauldron-save-recipe",
553 characterId: session.characterId
554 });
555 break;
556 case MessageType.cauldronClose:
557 requirePlaying(session);
558 simulation.enqueue(session.id, {
559 type: "cauldron-close",
560 characterId: session.characterId
561 });
562 break;
563 case MessageType.bankDeposit:
564 requirePlaying(session);
565 simulation.enqueue(session.id, {
566 type: "bank-deposit",
567 characterId: session.characterId,
568 slotIndex: message.slotIndex | 0,
569 quantity: message.quantity ?? null
570 });
571 break;
572 case MessageType.bankWithdraw:
573 requirePlaying(session);
574 simulation.enqueue(session.id, {
575 type: "bank-withdraw",
576 characterId: session.characterId,
577 slotIndex: message.slotIndex | 0,
578 quantity: message.quantity ?? null
579 });
580 break;
581 case MessageType.getBlankCheques:
582 requirePlaying(session);
583 simulation.enqueue(session.id, {
584 type: "get-blank-cheques",
585 characterId: session.characterId
586 });
587 break;
588 case MessageType.returnBlankCheques:
589 requirePlaying(session);
590 simulation.enqueue(session.id, {
591 type: "return-blank-cheques",
592 characterId: session.characterId,
593 slotIndex: message.slotIndex | 0,
594 quantity: message.quantity ?? null
595 });
596 break;
597 case MessageType.writeCheque:
598 requirePlaying(session);
599 simulation.enqueue(session.id, {
600 type: "write-cheque",
601 characterId: session.characterId,
602 slotIndex: message.slotIndex | 0,
603 vaultSlotIndex: message.vaultSlotIndex | 0,
604 quantity: message.quantity ?? 1
605 });
606 break;
607 case MessageType.redeemCheque:
608 requirePlaying(session);
609 simulation.enqueue(session.id, {
610 type: "redeem-cheque",
611 characterId: session.characterId,
612 slotIndex: message.slotIndex | 0
613 });
614 break;
615 case MessageType.claimInheritance:
616 requirePlaying(session);
617 {
618 const inheritance = stateDb.getInheritance(session.account.account_id);
619 simulation.enqueue(session.id, {
620 type: "claim-inheritance",
621 characterId: session.characterId,
622 stacks: (inheritance.slots ?? []).filter(Boolean)
623 });
624 }
625 break;
626 case MessageType.attack:
627 requirePlaying(session);
628 simulation.enqueue(session.id, {
629 type: "attack",
630 characterId: session.characterId,
631 targetEntityId: message.targetEntityId | 0
632 });
633 break;
634 case MessageType.cancelAttack:
635 requirePlaying(session);
636 simulation.enqueue(session.id, {
637 type: "cancel-attack",
638 characterId: session.characterId
639 });
640 break;
641 case MessageType.setSpellFavorite:
642 requirePlaying(session);
643 simulation.enqueue(session.id, {
644 type: "set-spell-favorite",
645 characterId: session.characterId,
646 spellId: message.spellId
647 });
648 break;
649 case MessageType.setSpellAutoCast:
650 requirePlaying(session);
651 simulation.enqueue(session.id, {
652 type: "set-spell-autocast",
653 characterId: session.characterId,
654 enabled: !!message.enabled
655 });
656 break;
657 case MessageType.armSpell:
658 requirePlaying(session);
659 simulation.enqueue(session.id, {
660 type: "arm-spell",
661 characterId: session.characterId,
662 spellId: message.spellId
663 });
664 break;
665 case MessageType.cancelArmSpell:
666 requirePlaying(session);
667 simulation.enqueue(session.id, {
668 type: "cancel-arm-spell",
669 characterId: session.characterId
670 });
671 break;
672 case MessageType.castSpellTile:
673 requirePlaying(session);
674 simulation.enqueue(session.id, {
675 type: "cast-spell-tile",
676 characterId: session.characterId,
677 spellId: message.spellId,
678 tileX: message.tileX | 0,
679 tileY: message.tileY | 0
680 });
681 break;
682 case MessageType.castSpellEntity:
683 requirePlaying(session);
684 simulation.enqueue(session.id, {
685 type: "cast-spell-entity",
686 characterId: session.characterId,
687 spellId: message.spellId,
688 targetEntityId: message.targetEntityId | 0
689 });
690 break;
691 case MessageType.readSpellbook:
692 requirePlaying(session);
693 simulation.enqueue(session.id, {
694 type: "read-spellbook",
695 characterId: session.characterId,
696 slotIndex: message.slotIndex | 0
697 });
698 break;
699 case MessageType.interact:
700 requirePlaying(session);
701 simulation.enqueue(session.id, {
702 type: "interact",
703 characterId: session.characterId,
704 targetEntityId: message.targetEntityId | 0,
705 purpose: message.purpose === "shop" || message.purpose === "talk"
706 ? message.purpose
707 : null
708 });
709 break;
710 case MessageType.buyFromShop:
711 requirePlaying(session);
712 simulation.enqueue(session.id, {
713 type: "buy-from-shop",
714 characterId: session.characterId,
715 npcEntityId: message.npcEntityId | 0,
716 itemId: message.itemId | 0,
717 quantity: message.quantity | 0 || 1,
718 listingId: typeof message.listingId === "string" ? message.listingId : null,
719 source: typeof message.source === "string" ? message.source : null
720 });
721 break;
722 case MessageType.sellToShop:
723 requirePlaying(session);
724 simulation.enqueue(session.id, {
725 type: "sell-to-shop",
726 characterId: session.characterId,
727 npcEntityId: message.npcEntityId | 0,
728 slotIndex: message.slotIndex | 0,
729 quantity: message.quantity | 0 || 1
730 });
731 break;
732 case MessageType.closeShop:
733 requirePlaying(session);
734 simulation.enqueue(session.id, {
735 type: "close-shop",
736 characterId: session.characterId,
737 npcEntityId: message.npcEntityId | 0
738 });
739 break;
740 case MessageType.openMarket:
741 requirePlaying(session);
742 simulation.enqueue(session.id, {
743 type: "open-market",
744 characterId: session.characterId
745 });
746 break;
747 case MessageType.closeMarket:
748 requirePlaying(session);
749 simulation.enqueue(session.id, {
750 type: "close-market",
751 characterId: session.characterId
752 });
753 break;
754 case MessageType.placeMarketSell:
755 requirePlaying(session);
756 simulation.enqueue(session.id, {
757 type: "place-market-sell",
758 characterId: session.characterId,
759 slotIndex: message.slotIndex | 0,
760 quantity: message.quantity | 0 || 1,
761 minUnitPrice: message.minUnitPrice | 0
762 });
763 break;
764 case MessageType.placeMarketBuy:
765 requirePlaying(session);
766 simulation.enqueue(session.id, {
767 type: "place-market-buy",
768 characterId: session.characterId,
769 itemId: message.itemId | 0,
770 listingKey: message.listingKey ?? null,
771 quantity: message.quantity | 0 || 1,
772 maxUnitPrice: message.maxUnitPrice | 0
773 });
774 break;
775 case MessageType.cancelMarketOrder:
776 requirePlaying(session);
777 simulation.enqueue(session.id, {
778 type: "cancel-market-order",
779 characterId: session.characterId,
780 orderId: message.orderId | 0
781 });
782 break;
783 case MessageType.follow:
784 requirePlaying(session);
785 simulation.enqueue(session.id, {
786 type: "follow",
787 characterId: session.characterId,
788 targetEntityId: message.targetEntityId | 0
789 });
790 break;
791 case MessageType.cancelFollow:
792 requirePlaying(session);
793 simulation.enqueue(session.id, {
794 type: "cancel-follow",
795 characterId: session.characterId
796 });
797 break;
798 case MessageType.sendPigeon:
799 requirePlaying(session);
800 {
801 const result = simulation.dispatchPigeon({
802 characterId: session.characterId,
803 destination: message.destination,
804 cargo: message.cargo
805 });
806 send(session, {
807 type: MessageType.pigeonDispatched,
808 courierId: result.transit.courierId,
809 destinationKind: result.transit.destinationKind,
810 destinationCharacterId: result.transit.destinationCharacterId
811 });
812 send(session, { type: MessageType.inventory, ...result.bag });
813 }
814 break;
815 case MessageType.searchCharacter:
816 requirePlaying(session);
817 {
818 const character = friends.findByFullName(message.firstName, message.lastName);
819 send(session, {
820 type: MessageType.characterSearchResult,
821 character: character ?? null
822 });
823 }
824 break;
825 case MessageType.writeLetter:
826 requirePlaying(session);
827 simulation.enqueue(session.id, {
828 type: "write-letter",
829 characterId: session.characterId,
830 slotIndex: message.slotIndex,
831 body: message.body
832 });
833 break;
834 case MessageType.editLetter:
835 requirePlaying(session);
836 simulation.enqueue(session.id, {
837 type: "edit-letter",
838 characterId: session.characterId,
839 slotIndex: message.slotIndex,
840 body: message.body
841 });
842 break;
843 case MessageType.openLetter:
844 requirePlaying(session);
845 simulation.enqueue(session.id, {
846 type: "open-letter",
847 characterId: session.characterId,
848 slotIndex: message.slotIndex
849 });
850 break;
851 case MessageType.editorLoadChunk:
852 requireAdmin(session);
853 send(session, {
854 type: MessageType.editorChunk,
855 ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0, message.dimensionId)
856 });
857 break;
858 case MessageType.editorSaveChunk:
859 requireAdmin(session);
860 send(session, {
861 type: MessageType.editorChunk,
862 ...editor.saveChunk(
863 message.chunkX | 0,
864 message.chunkY | 0,
865 message.draft,
866 session.authSubject,
867 message.dimensionId
868 )
869 });
870 break;
871 case MessageType.editorListDimensions:
872 case "EDITOR_LIST_DIMENSIONS":
873 requireAdmin(session);
874 try
875 {
876 send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() });
877 }
878 catch (err)
879 {
880 send(session, { type: MessageType.error, message: err.userFacing ? err.message : "Failed to list dimensions." });
881 }
882 break;
883 case MessageType.editorCreateDimension:
884 case "EDITOR_CREATE_DIMENSION":
885 requireAdmin(session);
886 send(session, {
887 type: MessageType.editorDimensions,
888 ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject)
889 });
890 break;
891 case MessageType.editorSaveDimension:
892 case "EDITOR_SAVE_DIMENSION":
893 requireAdmin(session);
894 send(session, {
895 type: MessageType.editorDimensions,
896 ...editor.saveDimension(message.dimension ?? message, session.authSubject)
897 });
898 break;
899 case MessageType.editorSoftDeleteDimension:
900 case "EDITOR_SOFT_DELETE_DIMENSION":
901 requireAdmin(session);
902 send(session, {
903 type: MessageType.editorDimensions,
904 ...editor.softDeleteDimension(message.dimensionId, session.authSubject)
905 });
906 break;
907 case MessageType.editorCancelDimensionDeletion:
908 case "EDITOR_CANCEL_DIMENSION_DELETION":
909 requireAdmin(session);
910 send(session, {
911 type: MessageType.editorDimensions,
912 ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject)
913 });
914 break;
915 case MessageType.editorLoadSettings:
916 requireAdmin(session);
917 send(session, {
918 type: MessageType.editorSettings,
919 ...editor.loadSettings(),
920 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
921 });
922 break;
923 case MessageType.editorLoadGameAdmins:
924 requireAdmin(session);
925 send(session, {
926 type: MessageType.editorGameAdmins,
927 admins: listPublicGameAdmins()
928 });
929 break;
930 case MessageType.editorGrantGameAdmin:
931 requireAdmin(session);
932 {
933 const updated = stateDb.grantGameAdminByUsername(message.username);
934 refreshAccountAdminSessions(updated.auth_subject);
935 send(session, {
936 type: MessageType.editorGameAdmins,
937 admins: listPublicGameAdmins()
938 });
939 }
940 break;
941 case MessageType.editorRevokeGameAdmin:
942 requireAdmin(session);
943 {
944 const target = String(message.authSubject ?? "").trim();
945 if (!target)
946 { throw userError("Admin account is required."); }
947 if (target === session.authSubject && !message.confirmSelf)
948 { throw userError("Confirm removing your own admin access."); }
949 const updated = stateDb.setGameAdmin(target, false);
950 refreshAccountAdminSessions(updated.auth_subject);
951 send(session, {
952 type: MessageType.editorGameAdmins,
953 admins: listPublicGameAdmins()
954 });
955 }
956 break;
957 case MessageType.editorConsoleSubscribe:
958 requireAdmin(session);
959 session.consoleSubscribed = true;
960 send(session, {
961 type: MessageType.editorConsoleSnapshot,
962 lines: getConsoleSnapshot(800)
963 });
964 break;
965 case MessageType.editorSaveSettings:
966 requireAdmin(session);
967 {
968 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
969 simulation.applySettings(saved.settings);
970 broadcastStatus();
971 broadcastSettings(saved);
972 }
973 break;
974 case MessageType.editorApplyRevision:
975 requireAdmin(session);
976 if (!editor.revisionStatus().pendingRevisionId)
977 {
978 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
979 break;
980 }
981 {
982 const appliedRevisionId = editor.applyPendingRevision();
983 simulation.reloadWorld();
984 for (const other of sessions.values())
985 {
986 if (other.entityId)
987 { syncSubscriptions(other, true); }
988 }
989 broadcastStatus();
990 send(session, {
991 type: MessageType.editorRevisionApplied,
992 ...editor.revisionStatus(),
993 appliedRevisionId
994 });
995 }
996 break;
997 case MessageType.editorRestartNow:
998 requireAdmin(session);
999 deploy?.requestRestartNow?.("admin-editor");
1000 break;
1001 case MessageType.editorLoadQuests:
1002 requireAdmin(session);
1003 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
1004 break;
1005 case MessageType.editorSaveQuest:
1006 requireAdmin(session);
1007 send(session, {
1008 type: MessageType.editorQuests,
1009 ...editor.saveQuest(message.quest ?? message, session.authSubject)
1010 });
1011 break;
1012 case MessageType.editorDeleteQuest:
1013 requireAdmin(session);
1014 send(session, {
1015 type: MessageType.editorQuests,
1016 ...editor.deleteQuest(message.questId, session.authSubject)
1017 });
1018 break;
1019 case MessageType.editorLoadDialogues:
1020 requireAdmin(session);
1021 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
1022 break;
1023 case MessageType.editorSaveDialogue:
1024 requireAdmin(session);
1025 send(session, {
1026 type: MessageType.editorDialogues,
1027 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
1028 });
1029 break;
1030 case MessageType.editorDeleteDialogue:
1031 requireAdmin(session);
1032 send(session, {
1033 type: MessageType.editorDialogues,
1034 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
1035 });
1036 break;
1037 case MessageType.dialogueChoose:
1038 requirePlaying(session);
1039 simulation.enqueue(session.id, {
1040 type: "dialogue-choose",
1041 characterId: session.characterId,
1042 trigger: String(message.trigger ?? "")
1043 });
1044 break;
1045 case MessageType.dialogueAdvance:
1046 requirePlaying(session);
1047 simulation.enqueue(session.id, {
1048 type: "dialogue-advance",
1049 characterId: session.characterId
1050 });
1051 break;
1052 case MessageType.closeDialogue:
1053 requirePlaying(session);
1054 simulation.enqueue(session.id, {
1055 type: "close-dialogue",
1056 characterId: session.characterId
1057 });
1058 break;
1059 case MessageType.requestQuests:
1060 requirePlaying(session);
1061 simulation.enqueue(session.id, {
1062 type: "request-quests",
1063 characterId: session.characterId
1064 });
1065 break;
1066 case MessageType.setGraphicsSettings:
1067 {
1068 const next = normalizeGraphicsSettings({
1069 viewDistance: message.viewDistance ?? session.viewDistance
1070 });
1071 const changed = next.viewDistance !== session.viewDistance;
1072 session.viewDistance = next.viewDistance;
1073 if (changed && session.entityId)
1074 { syncSubscriptions(session, true); }
1075 }
1076 break;
1077 default:
1078 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
1079 }
1080 }
1081
1082 function enterWorld (session, characterId)
1083 {
1084 if (draining || deploy?.isDraining?.())
1085 {
1086 const error = new Error("The server is restarting for an update. Please try again in a moment.");
1087 error.userFacing = true;
1088 throw error;
1089 }
1090 leaveWorld(session);
1091 const character = characters.getOwned(session.account.account_id, characterId);
1092 if (character.deletion_scheduled_at)
1093 {
1094 const error = new Error("That character is marked for deletion.");
1095 error.userFacing = true;
1096 throw error;
1097 }
1098 const targetCharacterId = character.character_id;
1099 let handoffEntityId = null;
1100 for (const other of [...sessions.values()])
1101 {
1102 if (other === session || other.account.account_id !== session.account.account_id || !other.characterId)
1103 { continue; }
1104 const sameCharacter = other.characterId === targetCharacterId;
1105 if (sameCharacter && simulation.isCharacterOnline(targetCharacterId))
1106 { handoffEntityId = simulation.entityForCharacter(targetCharacterId); }
1107 disconnectPlayingSession(other, {
1108 despawn: !sameCharacter,
1109 reason: sameCharacter
1110 ? "This character was opened in another window."
1111 : "Logged in from another window."
1112 });
1113 }
1114 session.characterId = targetCharacterId;
1115 if (handoffEntityId != null)
1116 {
1117 const entityId = simulation.reattachCharacterSession(targetCharacterId, session.id);
1118 if (!entityId)
1119 {
1120 const error = new Error("Could not resume that character. Please try again.");
1121 error.userFacing = true;
1122 throw error;
1123 }
1124 session.entityId = entityId;
1125 }
1126 else
1127 { session.entityId = simulation.spawnCharacter(session.id, character); }
1128 sendEnterWorld(session, character);
1129 notifyFriendPresence(session.account?.account_id);
1130 }
1131
1132 function sendEnterWorld (session, character)
1133 {
1134 const spawned = simulation.entityRecord(session.entityId);
1135 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
1136 const dimRecord = simulation.getDimensionRecord?.(enterDim);
1137 send(session, {
1138 type: MessageType.enterWorld,
1139 entityId: session.entityId,
1140 characterId: session.characterId,
1141 accountId: session.account?.account_id ?? null,
1142 tileX: spawned.tileX,
1143 tileY: spawned.tileY,
1144 dimensionId: enterDim,
1145 lightingMode: dimRecord?.lightingMode ?? "dayNight",
1146 seasonMode: dimRecord?.seasonMode ?? "auto",
1147 gait: spawned.gait,
1148 sex: spawned.sex,
1149 firstName: spawned.firstName,
1150 lastName: spawned.lastName,
1151 layers: spawned.layers ?? [],
1152 health: spawned.health,
1153 maxHealth: spawned.maxHealth,
1154 skullValue: spawned.skullValue | 0,
1155 settings: simulation.settings,
1156 worldTime: simulation.worldTime(),
1157 restartStatus: deploy?.getStatus?.() ?? { scheduled: false }
1158 });
1159 syncSubscriptions(session, true);
1160 send(session, { type: MessageType.friends, ...friendsPayload(session.characterId) });
1161 const bag = simulation.bagOf(session.entityId);
1162 if (bag)
1163 { send(session, { type: MessageType.inventory, ...bag }); }
1164 const skills = simulation.skillsOf(session.entityId);
1165 if (skills)
1166 { send(session, { type: MessageType.skills, ...publicSkillsPayload(skills) }); }
1167 const spellView = simulation.spellsOf(session.entityId);
1168 if (spellView)
1169 {
1170 send(session, {
1171 type: MessageType.spells,
1172 spells: spellView.spells,
1173 autoCast: spellView.autoCast,
1174 armedSpellId: spellView.armedSpellId ?? null
1175 });
1176 }
1177 const stamina = simulation.staminaOf(session.entityId);
1178 if (stamina)
1179 {
1180 send(session, {
1181 type: MessageType.stamina,
1182 current: stamina.current,
1183 max: stamina.max,
1184 gait: stamina.gait
1185 });
1186 }
1187 if (character.is_dead)
1188 {
1189 send(session, {
1190 type: MessageType.playerDied,
1191 entityId: session.entityId,
1192 characterId: session.characterId
1193 });
1194 }
1195 publishReplication(simulation.drainReplication());
1196 }
1197
1198 function disconnectPlayingSession (session, { despawn = true, reason = "Logged in from another window." } = {})
1199 {
1200 send(session, { type: MessageType.forceLogout, reason });
1201 const characterId = session.characterId;
1202 const accountId = session.account?.account_id | 0;
1203 session.characterId = null;
1204 session.entityId = null;
1205 session.entitySubscribed.clear();
1206 session.staticSubscribed.clear();
1207 if (despawn && characterId)
1208 {
1209 simulation.despawnCharacter(characterId);
1210 publishReplication(simulation.drainReplication());
1211 }
1212 session.suppressLeaveWorldOnClose = true;
1213 if (session.socket.readyState === 1)
1214 { session.socket.close(4000, "Logged in elsewhere"); }
1215 if (accountId)
1216 { notifyFriendPresence(accountId); }
1217 }
1218
1219 function leaveWorld (session)
1220 {
1221 const accountId = session.account?.account_id | 0;
1222 if (session.characterId)
1223 { simulation.despawnCharacter(session.characterId); }
1224 publishReplication(simulation.drainReplication());
1225 session.characterId = null;
1226 session.entityId = null;
1227 session.entitySubscribed.clear();
1228 session.staticSubscribed.clear();
1229 if (accountId)
1230 { notifyFriendPresence(accountId); }
1231 }
1232
1233 function syncSubscriptions (session, forceSnapshots)
1234 {
1235 if (!session.entityId)
1236 { return; }
1237 const position = simulation.positionOf(session.entityId);
1238 if (!position)
1239 { return; }
1240
1241 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1242 const centerChunkX = tileToChunk(position.tileX);
1243 const centerChunkY = tileToChunk(position.tileY);
1244 const mapRadius = staticChunkRadiusForViewDistance(
1245 session.viewDistance,
1246 STATIC_CHUNK_RADIUS,
1247 VISIBLE_CHUNK_RADIUS
1248 );
1249 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1250 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1251 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1252 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1253
1254 for (const key of session.staticSubscribed)
1255 {
1256 if (!staticNext.has(key))
1257 {
1258 const { chunkX, chunkY } = parseChunkKey(key);
1259 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1260 }
1261 }
1262
1263 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1264 for (const snapshot of snapshots)
1265 {
1266 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1267 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1268 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1269 {
1270 const groundItems = (snapshot.groundItems ?? []).filter((item) =>
1271 canCharacterSeeGroundItem(item, session.characterId)
1272 );
1273 send(session, { type: MessageType.chunkSnapshot, ...snapshot, groundItems });
1274 }
1275 }
1276 session.entitySubscribed = entityNext;
1277 session.staticSubscribed = staticNext;
1278 }
1279
1280 function requirePlaying (session)
1281 {
1282 if (!session.characterId)
1283 {
1284 const error = new Error("Select a character first.");
1285 error.userFacing = true;
1286 throw error;
1287 }
1288 }
1289
1290 function userError (message)
1291 {
1292 const error = new Error(message);
1293 error.userFacing = true;
1294 return error;
1295 }
1296
1297 function listPublicGameAdmins ()
1298 {
1299 return stateDb.listGameAdmins().map((row) => ({
1300 authSubject: row.auth_subject,
1301 username: row.username ?? null,
1302 email: row.email ?? null
1303 }));
1304 }
1305
1306 function refreshAccountAdminSessions (authSubject)
1307 {
1308 const account = stateDb.getAccountBySubject(authSubject);
1309 if (!account)
1310 { return; }
1311 for (const session of sessions.values())
1312 {
1313 if (session.authSubject !== authSubject)
1314 { continue; }
1315 session.account = account;
1316 send(session, {
1317 type: MessageType.session,
1318 accountId: account.account_id,
1319 authSubject: account.auth_subject,
1320 username: session.username ?? account.username ?? null,
1321 email: account.email ?? null,
1322 isAdmin: !!account.is_admin,
1323 characters: characters.list(account.account_id)
1324 });
1325 }
1326 }
1327
1328 function requireAdmin (session)
1329 {
1330 if (!session.account.is_admin)
1331 {
1332 const error = new Error("Admin only.");
1333 error.userFacing = true;
1334 throw error;
1335 }
1336 }
1337
1338 function broadcastStatus ()
1339 {
1340 const worldTime = simulation.worldTime();
1341 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1342 for (const session of sessions.values())
1343 {
1344 if (session.entityId)
1345 {
1346 send(session, {
1347 type: MessageType.worldStatus,
1348 worldTime,
1349 settings: simulation.settings,
1350 activeRevisionId: simulation.activeRevisionId,
1351 restartStatus
1352 });
1353 }
1354 }
1355 }
1356
1357 function broadcastRestartStatus ()
1358 {
1359 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1360 for (const session of sessions.values())
1361 {
1362 if (session.entityId)
1363 { send(session, { type: MessageType.restartStatus, restartStatus }); }
1364 }
1365 }
1366
1367 function onlinePresenceByAccount ()
1368 {
1369 const byAccount = new Map();
1370 for (const entry of sessions.values())
1371 {
1372 if (!entry.characterId || !entry.entityId)
1373 { continue; }
1374 const accountId = entry.account?.account_id | 0;
1375 if (!accountId)
1376 { continue; }
1377 const row = stateDb.getCharacter(entry.characterId);
1378 if (!row)
1379 { continue; }
1380 byAccount.set(accountId, {
1381 characterId: row.character_id,
1382 firstName: row.first_name,
1383 lastName: row.last_name
1384 });
1385 }
1386 return byAccount;
1387 }
1388
1389 function friendsPayload (characterId)
1390 {
1391 const snap = friends.snapshot(characterId);
1392 const presence = onlinePresenceByAccount();
1393 for (const account of snap.friends ?? [])
1394 {
1395 const playingAs = presence.get(account.accountId | 0) ?? null;
1396 account.online = !!playingAs;
1397 account.playingAs = playingAs;
1398 }
1399 return snap;
1400 }
1401
1402 /** Refresh friends panels for an account and everyone friended with them. */
1403 function notifyFriendPresence (accountId)
1404 {
1405 const id = accountId | 0;
1406 if (!id)
1407 { return; }
1408 const refs = [id];
1409 for (const row of stateDb.listAccountFriendRecords(id))
1410 { refs.push(row.account_id); }
1411 pushFriends(...refs);
1412 }
1413
1414 function pushFriends (...refs)
1415 {
1416 const accountIds = new Set();
1417 for (const ref of refs)
1418 {
1419 if (ref == null)
1420 { continue; }
1421 if (typeof ref === "object" && ref.accountId != null)
1422 {
1423 accountIds.add(ref.accountId | 0);
1424 continue;
1425 }
1426 const asNumber = Number(ref);
1427 if (!asNumber)
1428 { continue; }
1429 // Heuristic: character ids from messages; also accept bare account ids from panel.
1430 const character = stateDb.getCharacter(asNumber);
1431 if (character)
1432 { accountIds.add(character.account_id | 0); }
1433 else if (stateDb.getAccount(asNumber))
1434 { accountIds.add(asNumber); }
1435 }
1436 for (const session of sessions.values())
1437 {
1438 if (!session.characterId)
1439 { continue; }
1440 const accountId = session.account?.account_id | 0;
1441 if (!accountIds.has(accountId))
1442 { continue; }
1443 send(session, { type: MessageType.friends, ...friendsPayload(session.characterId) });
1444 }
1445 }
1446
1447 function broadcastSettings (payload)
1448 {
1449 for (const session of sessions.values())
1450 {
1451 if (session.account.is_admin)
1452 { send(session, { type: MessageType.editorSettings, ...payload }); }
1453 }
1454 }
1455
1456 function onTickResult (result)
1457 {
1458 publishReplication(result.replication ?? []);
1459 for (const event of result.events)
1460 {
1461 if (event.type === "command-error")
1462 {
1463 const session = sessions.get(event.sessionId);
1464 if (session)
1465 { send(session, { type: MessageType.error, message: event.message }); }
1466 continue;
1467 }
1468 if (event.type === "inventory")
1469 {
1470 const session = event.sessionId != null
1471 ? sessions.get(event.sessionId)
1472 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1473 if (!session)
1474 { continue; }
1475 send(session, {
1476 type: MessageType.inventory,
1477 inventory: event.inventory,
1478 equipment: event.equipment,
1479 vault: event.vault,
1480 vaultReserved: event.vaultReserved
1481 });
1482 if (event.bank)
1483 {
1484 send(session, {
1485 type: MessageType.bankSnapshot,
1486 vault: event.vault,
1487 vaultReserved: event.vaultReserved,
1488 inheritance: stateDb.getInheritance(session.account.account_id)
1489 });
1490 }
1491 if (event.cauldron != null)
1492 {
1493 send(session, {
1494 type: MessageType.cauldronSnapshot,
1495 open: !!event.cauldron,
1496 state: event.cauldronState ?? null,
1497 alchemyResult: event.alchemyResult ?? null,
1498 dyeConfirm: event.dyeConfirm ?? null
1499 });
1500 }
1501 continue;
1502 }
1503 if (event.type === "skills")
1504 {
1505 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1506 if (!session)
1507 { continue; }
1508 send(session, {
1509 type: MessageType.skills,
1510 skills: event.skills ?? [],
1511 combatLevel: event.combatLevel ?? 0
1512 });
1513 continue;
1514 }
1515 if (event.type === "spells")
1516 {
1517 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1518 if (!session)
1519 { continue; }
1520 send(session, {
1521 type: MessageType.spellsUpdated,
1522 spells: event.spells ?? [],
1523 autoCast: !!event.autoCast,
1524 armedSpellId: event.armedSpellId ?? null
1525 });
1526 continue;
1527 }
1528 if (event.type === "spell-armed")
1529 {
1530 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1531 if (!session)
1532 { continue; }
1533 send(session, {
1534 type: MessageType.spellArmed,
1535 spellId: event.spellId
1536 });
1537 continue;
1538 }
1539 if (event.type === "spell-disarmed")
1540 {
1541 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1542 if (!session)
1543 { continue; }
1544 send(session, { type: MessageType.spellDisarmed });
1545 continue;
1546 }
1547 if (event.type === "stamina")
1548 {
1549 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1550 if (!session)
1551 { continue; }
1552 send(session, {
1553 type: MessageType.stamina,
1554 current: event.current,
1555 max: event.max,
1556 gait: event.gait
1557 });
1558 continue;
1559 }
1560 if (event.type === "status-effects")
1561 {
1562 const session = event.sessionId != null
1563 ? sessions.get(event.sessionId)
1564 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1565 if (!session)
1566 { continue; }
1567 send(session, {
1568 type: MessageType.statusEffects,
1569 effects: event.effects ?? [],
1570 blind: !!event.blind
1571 });
1572 continue;
1573 }
1574 if (event.type === "toast")
1575 {
1576 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1577 if (session)
1578 { send(session, { type: MessageType.toast, message: event.message }); }
1579 continue;
1580 }
1581 if (event.type === "quests-snapshot")
1582 {
1583 const session = event.sessionId != null
1584 ? sessions.get(event.sessionId)
1585 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1586 if (session)
1587 {
1588 send(session, {
1589 type: MessageType.questsSnapshot,
1590 quests: event.quests ?? []
1591 });
1592 }
1593 continue;
1594 }
1595 if (event.type === "quest-step-complete")
1596 {
1597 const session = event.sessionId != null
1598 ? sessions.get(event.sessionId)
1599 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1600 if (session)
1601 {
1602 send(session, {
1603 type: MessageType.questStepComplete,
1604 questId: event.questId,
1605 title: event.title
1606 });
1607 }
1608 continue;
1609 }
1610 if (event.type === "dialogue-step")
1611 {
1612 const session = event.sessionId != null
1613 ? sessions.get(event.sessionId)
1614 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1615 if (session)
1616 {
1617 send(session, {
1618 type: MessageType.dialogueStep,
1619 dialogueId: event.dialogueId,
1620 stepId: event.stepId,
1621 label: event.label,
1622 npcEntityId: event.npcEntityId ?? null,
1623 lines: event.lines ?? []
1624 });
1625 }
1626 continue;
1627 }
1628 if (event.type === "dialogue-choices")
1629 {
1630 const session = event.sessionId != null
1631 ? sessions.get(event.sessionId)
1632 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1633 if (session)
1634 {
1635 send(session, {
1636 type: MessageType.dialogueChoices,
1637 dialogueId: event.dialogueId,
1638 stepId: event.stepId,
1639 npcEntityId: event.npcEntityId ?? null,
1640 triggers: event.triggers ?? []
1641 });
1642 }
1643 continue;
1644 }
1645 if (event.type === "dialogue-item-rewards")
1646 {
1647 const session = event.sessionId != null
1648 ? sessions.get(event.sessionId)
1649 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1650 if (session)
1651 {
1652 send(session, {
1653 type: MessageType.dialogueItemRewards,
1654 dialogueId: event.dialogueId,
1655 stepId: event.stepId,
1656 npcEntityId: event.npcEntityId ?? null,
1657 messages: event.messages ?? []
1658 });
1659 }
1660 continue;
1661 }
1662 if (event.type === "dialogue-close")
1663 {
1664 const session = event.sessionId != null
1665 ? sessions.get(event.sessionId)
1666 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1667 if (session)
1668 {
1669 send(session, {
1670 type: MessageType.dialogueClose,
1671 reason: event.reason ?? null
1672 });
1673 }
1674 continue;
1675 }
1676 if (event.type === "pigeon-delivered")
1677 {
1678 for (const session of sessions.values())
1679 {
1680 if (session.characterId === event.senderCharacterId
1681 || session.characterId === event.destinationCharacterId)
1682 {
1683 send(session, {
1684 type: MessageType.pigeonDelivered,
1685 courierId: event.courierId,
1686 destinationKind: event.destinationKind,
1687 cargo: event.cargo
1688 });
1689 }
1690 }
1691 continue;
1692 }
1693 if (event.type === "player-died")
1694 {
1695 const session = sessions.get(event.sessionId);
1696 if (session)
1697 {
1698 send(session, {
1699 type: MessageType.playerDied,
1700 entityId: event.entityId,
1701 characterId: event.characterId
1702 });
1703 }
1704 continue;
1705 }
1706 if (event.type === "player-respawned")
1707 {
1708 const session = sessions.get(event.sessionId);
1709 if (session)
1710 {
1711 send(session, {
1712 type: MessageType.playerRespawned,
1713 entityId: event.entityId,
1714 characterId: event.characterId,
1715 tileX: event.tileX,
1716 tileY: event.tileY,
1717 health: event.health,
1718 maxHealth: event.maxHealth,
1719 stamina: event.stamina,
1720 maxStamina: event.maxStamina,
1721 skullValue: event.skullValue | 0
1722 });
1723 }
1724 continue;
1725 }
1726 if (event.type === "dimension-changed")
1727 {
1728 const session = sessions.get(event.sessionId);
1729 if (session)
1730 {
1731 session.entitySubscribed.clear();
1732 session.staticSubscribed.clear();
1733 send(session, {
1734 type: MessageType.dimensionChanged,
1735 dimensionId: event.dimensionId,
1736 tileX: event.tileX,
1737 tileY: event.tileY,
1738 lightingMode: event.lightingMode,
1739 seasonMode: event.seasonMode
1740 });
1741 syncSubscriptions(session, true);
1742 }
1743 continue;
1744 }
1745 if (event.type === "combat-no-arrows")
1746 {
1747 const session = sessions.get(event.sessionId);
1748 if (session)
1749 { send(session, { type: MessageType.combatNoArrows }); }
1750 continue;
1751 }
1752 if (event.type === "craft-result")
1753 {
1754 const session = sessions.get(event.sessionId);
1755 if (session)
1756 {
1757 send(session, {
1758 type: MessageType.craftResult,
1759 recipeId: event.recipeId,
1760 ok: !!event.ok,
1761 error: event.error ?? null,
1762 burned: !!event.burned,
1763 continuing: !!event.continuing
1764 });
1765 }
1766 continue;
1767 }
1768 if (event.type === "station-open")
1769 {
1770 const session = sessions.get(event.sessionId);
1771 if (session)
1772 {
1773 send(session, {
1774 type: MessageType.stationOpen,
1775 stationId: event.stationId
1776 });
1777 }
1778 continue;
1779 }
1780 if (event.type === "shop-open")
1781 {
1782 const session = sessions.get(event.sessionId);
1783 if (session)
1784 {
1785 send(session, {
1786 type: MessageType.shopOpen,
1787 npcEntityId: event.npcEntityId,
1788 displayName: event.displayName,
1789 sex: event.sex === "female" ? "female" : "male",
1790 buysItems: !!event.buysItems,
1791 stock: event.stock ?? []
1792 });
1793 }
1794 continue;
1795 }
1796 if (event.type === "shop-closed")
1797 {
1798 const session = sessions.get(event.sessionId);
1799 if (session)
1800 {
1801 send(session, {
1802 type: MessageType.shopClosed,
1803 npcEntityId: event.npcEntityId
1804 });
1805 }
1806 continue;
1807 }
1808 if (event.type === "market-open")
1809 {
1810 const session = sessions.get(event.sessionId);
1811 if (session)
1812 {
1813 send(session, {
1814 type: MessageType.marketOpen,
1815 displayName: event.displayName,
1816 orders: event.orders ?? [],
1817 catalog: event.catalog ?? []
1818 });
1819 }
1820 continue;
1821 }
1822 if (event.type === "market-closed")
1823 {
1824 const session = sessions.get(event.sessionId);
1825 if (session)
1826 { send(session, { type: MessageType.marketClosed }); }
1827 continue;
1828 }
1829 if (event.type === "bounty-snapshot")
1830 {
1831 const session = sessions.get(event.sessionId);
1832 if (session)
1833 {
1834 send(session, {
1835 type: MessageType.bountySnapshot,
1836 myAmountCopper: event.myAmountCopper | 0,
1837 myAmountLabel: event.myAmountLabel ?? "",
1838 message: event.message ?? "",
1839 raised: event.raised ?? null
1840 });
1841 }
1842 continue;
1843 }
1844 if (event.type === "bounty-closed")
1845 {
1846 const session = sessions.get(event.sessionId);
1847 if (session)
1848 { send(session, { type: MessageType.closeBounty }); }
1849 continue;
1850 }
1851 if (event.type === "character-bounty")
1852 {
1853 const session = sessions.get(event.sessionId);
1854 if (session)
1855 {
1856 send(session, {
1857 type: MessageType.characterBounty,
1858 target: event.target ?? null
1859 });
1860 }
1861 continue;
1862 }
1863 if (event.type === "barber-snapshot")
1864 {
1865 const session = sessions.get(event.sessionId);
1866 if (session)
1867 {
1868 send(session, {
1869 type: MessageType.barberSnapshot,
1870 sex: event.sex,
1871 styles: event.styles ?? [],
1872 hair: event.hair ?? null,
1873 message: event.message ?? ""
1874 });
1875 }
1876 continue;
1877 }
1878 if (event.type === "barber-closed")
1879 {
1880 const session = sessions.get(event.sessionId);
1881 if (session)
1882 { send(session, { type: MessageType.closeBarber }); }
1883 continue;
1884 }
1885 if (event.type === "market-trade")
1886 {
1887 for (const session of sessions.values())
1888 {
1889 if (
1890 session.characterId === event.buyerCharacterId
1891 || session.characterId === event.sellerCharacterId
1892 )
1893 {
1894 send(session, {
1895 type: MessageType.marketTrade,
1896 itemId: event.itemId,
1897 quantity: event.quantity,
1898 unitPrice: event.unitPrice,
1899 triggeringSide: event.triggeringSide
1900 });
1901 }
1902 }
1903 continue;
1904 }
1905 if (event.type === "item-bubble")
1906 {
1907 broadcastItemBubble(
1908 sessions,
1909 simulation,
1910 event.entityId,
1911 event.itemId,
1912 event.quantity
1913 );
1914 continue;
1915 }
1916 if (event.type === "gather-swing" || event.type === "tile-shove")
1917 {
1918 publishEntity({
1919 ...event,
1920 type: event.type
1921 });
1922 continue;
1923 }
1924 if (event.type === "chunk-delta")
1925 {
1926 publishEntity(event);
1927 continue;
1928 }
1929 if (event.type === "gather-complete")
1930 {
1931 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1932 if (session)
1933 {
1934 send(session, {
1935 type: MessageType.gatherComplete,
1936 kind: event.kind,
1937 materialId: event.materialId,
1938 itemId: event.itemId
1939 });
1940 }
1941 continue;
1942 }
1943 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 === "entity-skull" || event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block" || event.type === "combat-projectile" || event.type === "spell-projectile" || event.type === "spell-fizzle" || event.type === "spell-cast-flash" || event.type === "spell-light-appear" || event.type === "spell-light-update" || event.type === "spell-light-remove" || event.type === "spell-dark-appear" || event.type === "spell-dark-update" || event.type === "spell-dark-remove" || event.type === "entity-health" || event.type === "gather-swing" || event.type === "tile-shove" || event.type === "chunk-delta" || event.type === "skill-level-up")
1944 { publishEntity(event); }
1945 }
1946 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1947 { broadcastStatus(); }
1948 }
1949
1950 function publishReplication (events)
1951 {
1952 for (const event of events ?? [])
1953 { publishEntity(event); }
1954 }
1955
1956 function publishEntity (event)
1957 {
1958 const toDim = normalizeDimensionId(event.dimensionId
1959 ?? simulation.entityRecord(event.entityId)?.dimensionId
1960 ?? OVERWORLD_ID);
1961 const fromDim = event.fromDimensionId != null
1962 ? normalizeDimensionId(event.fromDimensionId)
1963 : toDim;
1964 const fromKey = event.fromTileX != null
1965 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
1966 : null;
1967 const toKey = event.tileX != null
1968 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
1969 : null;
1970 for (const session of sessions.values())
1971 {
1972 if (!session.entityId)
1973 { continue; }
1974 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1975 const seesTo = session.entitySubscribed.has(toKey);
1976 const seesStaticTo = session.staticSubscribed.has(toKey);
1977 if (event.type === "entity-spawn")
1978 {
1979 if (session.entityId === event.entityId || !seesTo)
1980 { continue; }
1981 send(session, spawnPayload(event));
1982 continue;
1983 }
1984 if (event.type === "entity-despawn")
1985 {
1986 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1987 { continue; }
1988 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1989 continue;
1990 }
1991 if (event.type === "entity-appearance")
1992 {
1993 if (!seesTo)
1994 { continue; }
1995 send(session, {
1996 type: MessageType.entityAppearance,
1997 entityId: event.entityId,
1998 sprite: event.sprite,
1999 layers: event.layers ?? [],
2000 lightRadiusTiles: event.lightRadiusTiles ?? 0
2001 });
2002 continue;
2003 }
2004 if (event.type === "entity-skull")
2005 {
2006 if (!seesTo && session.entityId !== event.entityId)
2007 { continue; }
2008 send(session, {
2009 type: MessageType.entitySkull,
2010 entityId: event.entityId,
2011 skullValue: event.skullValue | 0
2012 });
2013 continue;
2014 }
2015 if (event.type === "ground-item-appear")
2016 {
2017 if (!seesTo)
2018 { continue; }
2019 if (!canCharacterSeeGroundItem(event, session.characterId))
2020 { continue; }
2021 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
2022 continue;
2023 }
2024 if (event.type === "ground-item-despawn")
2025 {
2026 if (!seesTo)
2027 { continue; }
2028 if (!canCharacterSeeGroundItem(event, session.characterId))
2029 { continue; }
2030 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
2031 continue;
2032 }
2033 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
2034 {
2035 if (!seesTo && !seesFrom)
2036 { continue; }
2037 const type = event.type === "combat-swing"
2038 ? MessageType.combatSwing
2039 : event.type === "combat-hit"
2040 ? MessageType.combatHit
2041 : event.type === "combat-block"
2042 ? MessageType.combatBlock
2043 : MessageType.combatMiss;
2044 send(session, {
2045 type,
2046 attackerId: event.attackerId,
2047 targetId: event.targetId,
2048 damage: event.damage,
2049 health: event.health,
2050 maxHealth: event.maxHealth,
2051 tileX: event.tileX,
2052 tileY: event.tileY,
2053 fromTileX: event.fromTileX,
2054 fromTileY: event.fromTileY
2055 });
2056 continue;
2057 }
2058 if (event.type === "combat-projectile")
2059 {
2060 if (!seesTo && !seesFrom)
2061 { continue; }
2062 send(session, {
2063 type: MessageType.combatProjectile,
2064 attackerId: event.attackerId,
2065 targetId: event.targetId,
2066 fromTileX: event.fromTileX,
2067 fromTileY: event.fromTileY,
2068 tileX: event.tileX,
2069 tileY: event.tileY,
2070 durationMs: event.durationMs ?? 400,
2071 trackTarget: event.trackTarget !== false,
2072 shaftTint: event.shaftTint ?? null,
2073 tipTint: event.tipTint ?? null
2074 });
2075 continue;
2076 }
2077 if (event.type === "spell-projectile")
2078 {
2079 if (!seesTo && !seesFrom)
2080 { continue; }
2081 send(session, {
2082 type: MessageType.spellProjectile,
2083 casterId: event.casterId,
2084 targetId: event.targetId ?? null,
2085 spellId: event.spellId,
2086 fromTileX: event.fromTileX,
2087 fromTileY: event.fromTileY,
2088 tileX: event.tileX,
2089 tileY: event.tileY,
2090 durationMs: event.durationMs ?? 2000,
2091 sprite: event.sprite ?? null
2092 });
2093 continue;
2094 }
2095 if (event.type === "spell-fizzle")
2096 {
2097 if (!seesTo && !seesFrom)
2098 { continue; }
2099 send(session, {
2100 type: MessageType.spellFizzle,
2101 casterId: event.casterId,
2102 spellId: event.spellId,
2103 fromTileX: event.fromTileX,
2104 fromTileY: event.fromTileY,
2105 tileX: event.tileX,
2106 tileY: event.tileY
2107 });
2108 continue;
2109 }
2110 if (event.type === "spell-cast-flash")
2111 {
2112 if (!seesTo)
2113 { continue; }
2114 send(session, {
2115 type: MessageType.spellCastFlash,
2116 casterId: event.casterId,
2117 tileX: event.tileX,
2118 tileY: event.tileY,
2119 radiusTiles: event.radiusTiles ?? 1,
2120 durationMs: event.durationMs ?? 500,
2121 tier: event.tier ?? 1
2122 });
2123 continue;
2124 }
2125 if (event.type === "spell-light-appear" || event.type === "spell-light-update"
2126 || event.type === "spell-dark-appear" || event.type === "spell-dark-update")
2127 {
2128 if (!seesTo)
2129 { continue; }
2130 const isDark = event.type.startsWith("spell-dark");
2131 const appear = event.type.endsWith("appear");
2132 send(session, {
2133 type: appear
2134 ? (isDark ? MessageType.spellDarkAppear : MessageType.spellLightAppear)
2135 : (isDark ? MessageType.spellDarkUpdate : MessageType.spellLightUpdate),
2136 tileX: event.tileX,
2137 tileY: event.tileY,
2138 ownerEntityId: event.ownerEntityId,
2139 remainingMs: event.remainingMs ?? 0,
2140 rangeTiles: event.rangeTiles ?? 0,
2141 intensity: event.intensity ?? 0,
2142 expiresAt: event.expiresAt ?? 0,
2143 kind: isDark ? "dark" : "light"
2144 });
2145 continue;
2146 }
2147 if (event.type === "spell-light-remove" || event.type === "spell-dark-remove")
2148 {
2149 if (!seesTo)
2150 { continue; }
2151 send(session, {
2152 type: event.type === "spell-dark-remove"
2153 ? MessageType.spellDarkRemove
2154 : MessageType.spellLightRemove,
2155 tileX: event.tileX,
2156 tileY: event.tileY
2157 });
2158 continue;
2159 }
2160 if (event.type === "entity-health")
2161 {
2162 if (!seesTo && !seesFrom)
2163 { continue; }
2164 send(session, {
2165 type: MessageType.entityHealth,
2166 entityId: event.entityId,
2167 health: event.health,
2168 maxHealth: event.maxHealth
2169 });
2170 continue;
2171 }
2172 if (event.type === "gather-swing" || event.type === "tile-shove")
2173 {
2174 if (!seesTo && !seesFrom)
2175 { continue; }
2176 if (event.type === "gather-swing")
2177 {
2178 send(session, {
2179 type: MessageType.gatherSwing,
2180 attackerId: event.attackerId,
2181 tileX: event.tileX,
2182 tileY: event.tileY,
2183 fromTileX: event.fromTileX,
2184 fromTileY: event.fromTileY,
2185 toolItemId: event.toolItemId ?? null
2186 });
2187 }
2188 else
2189 {
2190 send(session, {
2191 type: MessageType.tileShove,
2192 attackerId: event.attackerId,
2193 tileX: event.tileX,
2194 tileY: event.tileY,
2195 fromTileX: event.fromTileX,
2196 fromTileY: event.fromTileY
2197 });
2198 }
2199 continue;
2200 }
2201 if (event.type === "skill-level-up")
2202 {
2203 if (session.entityId !== event.entityId && !seesTo)
2204 { continue; }
2205 send(session, {
2206 type: MessageType.skillLevelUp,
2207 entityId: event.entityId,
2208 characterId: event.characterId,
2209 skillId: event.skillId,
2210 level: event.level,
2211 previousLevel: event.previousLevel,
2212 displayName: event.displayName,
2213 icon: event.icon
2214 });
2215 continue;
2216 }
2217 if (event.type === "chunk-delta")
2218 {
2219 if (!seesStaticTo)
2220 { continue; }
2221 send(session, {
2222 type: MessageType.chunkDelta,
2223 chunkX: event.chunkX,
2224 chunkY: event.chunkY,
2225 tiles: [{
2226 localX: event.localX,
2227 localY: event.localY,
2228 block: event.block
2229 }]
2230 });
2231 continue;
2232 }
2233 if (event.type !== "entity-move")
2234 { continue; }
2235 if (seesTo)
2236 {
2237 if (!seesFrom)
2238 { send(session, spawnPayload(event)); }
2239 else
2240 {
2241 send(session, {
2242 type: MessageType.entityMove,
2243 entityId: event.entityId,
2244 tileX: event.tileX,
2245 tileY: event.tileY,
2246 worldX: event.worldX,
2247 worldY: event.worldY,
2248 gait: event.gait,
2249 lerpMs: event.lerpMs,
2250 freeFlight: !!event.freeFlight
2251 });
2252 }
2253 }
2254 else if (seesFrom)
2255 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
2256 if (session.entityId === event.entityId)
2257 {
2258 const crossedDimension = event.fromDimensionId != null
2259 && event.dimensionId != null
2260 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
2261 if (!crossedDimension)
2262 { syncSubscriptions(session, false); }
2263 }
2264 }
2265 }
2266
2267 function spawnPayload (event)
2268 {
2269 const record = simulation.entityRecord(event.entityId) ?? event;
2270 return {
2271 type: MessageType.entitySpawn,
2272 entityId: event.entityId,
2273 characterId: record.characterId ?? event.characterId ?? null,
2274 accountId: record.accountId ?? event.accountId ?? null,
2275 tileX: event.tileX ?? record.tileX,
2276 tileY: event.tileY ?? record.tileY,
2277 worldX: event.worldX ?? record.worldX,
2278 worldY: event.worldY ?? record.worldY,
2279 gait: event.gait ?? record.gait,
2280 sex: record.sex ?? event.sex ?? null,
2281 firstName: record.firstName ?? event.firstName ?? "",
2282 lastName: record.lastName ?? event.lastName ?? "",
2283 sprite: record.sprite ?? event.sprite ?? null,
2284 layers: record.layers ?? event.layers ?? [],
2285 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
2286 canFight: !!(record.canFight ?? event.canFight),
2287 hostile: !!(record.hostile ?? event.hostile),
2288 talkable: !!(record.talkable ?? event.talkable),
2289 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
2290 hasShop: !!(record.hasShop ?? event.hasShop),
2291 untargetable: !!(record.untargetable ?? event.untargetable),
2292 freeFlight: !!(record.freeFlight ?? event.freeFlight),
2293 health: record.health ?? event.health,
2294 maxHealth: record.maxHealth ?? event.maxHealth,
2295 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0,
2296 skullValue: record.skullValue | 0
2297 };
2298 }
2299
2300 return {
2301 sessions,
2302 onTickResult,
2303 wss,
2304 broadcastRestartStatus,
2305 setDraining (value)
2306 {
2307 draining = !!value;
2308 },
2309 async shutdown ()
2310 {
2311 draining = true;
2312 await Promise.all([...sessions.values()].map(async (session) =>
2313 {
2314 await sendAsync(session, {
2315 type: MessageType.forceLogout,
2316 reason: "Server shutting down."
2317 });
2318 leaveWorld(session);
2319 await closeAsync(session, 1001, "Server shutting down.");
2320 }));
2321 sessions.clear();
2322 await simulation.shutdown();
2323 }
2324 };
2325}
2326
2327function send (session, payload)
2328{
2329 if (session.socket.readyState === 1)
2330 { session.socket.send(JSON.stringify(payload)); }
2331}
2332
2333function sendAsync (session, payload)
2334{
2335 return new Promise((resolve) =>
2336 {
2337 if (session.socket.readyState !== 1)
2338 {
2339 resolve();
2340 return;
2341 }
2342 session.socket.send(JSON.stringify(payload), () => resolve());
2343 });
2344}
2345
2346function closeAsync (session, code, reason)
2347{
2348 return new Promise((resolve) =>
2349 {
2350 if (session.socket.readyState !== 1)
2351 {
2352 resolve();
2353 return;
2354 }
2355 session.socket.once("close", resolve);
2356 try
2357 { session.socket.close(code, reason); }
2358 catch
2359 { resolve(); }
2360 });
2361}