BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 65.8 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 { publicSkillsView } 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 quantity: message.quantity | 0 || 1,
771 maxUnitPrice: message.maxUnitPrice | 0
772 });
773 break;
774 case MessageType.cancelMarketOrder:
775 requirePlaying(session);
776 simulation.enqueue(session.id, {
777 type: "cancel-market-order",
778 characterId: session.characterId,
779 orderId: message.orderId | 0
780 });
781 break;
782 case MessageType.follow:
783 requirePlaying(session);
784 simulation.enqueue(session.id, {
785 type: "follow",
786 characterId: session.characterId,
787 targetEntityId: message.targetEntityId | 0
788 });
789 break;
790 case MessageType.cancelFollow:
791 requirePlaying(session);
792 simulation.enqueue(session.id, {
793 type: "cancel-follow",
794 characterId: session.characterId
795 });
796 break;
797 case MessageType.sendPigeon:
798 requirePlaying(session);
799 {
800 const result = simulation.dispatchPigeon({
801 characterId: session.characterId,
802 destination: message.destination,
803 cargo: message.cargo
804 });
805 send(session, {
806 type: MessageType.pigeonDispatched,
807 courierId: result.transit.courierId,
808 destinationKind: result.transit.destinationKind,
809 destinationCharacterId: result.transit.destinationCharacterId
810 });
811 send(session, { type: MessageType.inventory, ...result.bag });
812 }
813 break;
814 case MessageType.searchCharacter:
815 requirePlaying(session);
816 {
817 const character = friends.findByFullName(message.firstName, message.lastName);
818 send(session, {
819 type: MessageType.characterSearchResult,
820 character: character ?? null
821 });
822 }
823 break;
824 case MessageType.writeLetter:
825 requirePlaying(session);
826 simulation.enqueue(session.id, {
827 type: "write-letter",
828 characterId: session.characterId,
829 slotIndex: message.slotIndex,
830 body: message.body
831 });
832 break;
833 case MessageType.editLetter:
834 requirePlaying(session);
835 simulation.enqueue(session.id, {
836 type: "edit-letter",
837 characterId: session.characterId,
838 slotIndex: message.slotIndex,
839 body: message.body
840 });
841 break;
842 case MessageType.openLetter:
843 requirePlaying(session);
844 simulation.enqueue(session.id, {
845 type: "open-letter",
846 characterId: session.characterId,
847 slotIndex: message.slotIndex
848 });
849 break;
850 case MessageType.editorLoadChunk:
851 requireAdmin(session);
852 send(session, {
853 type: MessageType.editorChunk,
854 ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0, message.dimensionId)
855 });
856 break;
857 case MessageType.editorSaveChunk:
858 requireAdmin(session);
859 send(session, {
860 type: MessageType.editorChunk,
861 ...editor.saveChunk(
862 message.chunkX | 0,
863 message.chunkY | 0,
864 message.draft,
865 session.authSubject,
866 message.dimensionId
867 )
868 });
869 break;
870 case MessageType.editorListDimensions:
871 case "EDITOR_LIST_DIMENSIONS":
872 requireAdmin(session);
873 try
874 {
875 send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() });
876 }
877 catch (err)
878 {
879 send(session, { type: MessageType.error, message: err.userFacing ? err.message : "Failed to list dimensions." });
880 }
881 break;
882 case MessageType.editorCreateDimension:
883 case "EDITOR_CREATE_DIMENSION":
884 requireAdmin(session);
885 send(session, {
886 type: MessageType.editorDimensions,
887 ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject)
888 });
889 break;
890 case MessageType.editorSaveDimension:
891 case "EDITOR_SAVE_DIMENSION":
892 requireAdmin(session);
893 send(session, {
894 type: MessageType.editorDimensions,
895 ...editor.saveDimension(message.dimension ?? message, session.authSubject)
896 });
897 break;
898 case MessageType.editorSoftDeleteDimension:
899 case "EDITOR_SOFT_DELETE_DIMENSION":
900 requireAdmin(session);
901 send(session, {
902 type: MessageType.editorDimensions,
903 ...editor.softDeleteDimension(message.dimensionId, session.authSubject)
904 });
905 break;
906 case MessageType.editorCancelDimensionDeletion:
907 case "EDITOR_CANCEL_DIMENSION_DELETION":
908 requireAdmin(session);
909 send(session, {
910 type: MessageType.editorDimensions,
911 ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject)
912 });
913 break;
914 case MessageType.editorLoadSettings:
915 requireAdmin(session);
916 send(session, {
917 type: MessageType.editorSettings,
918 ...editor.loadSettings(),
919 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
920 });
921 break;
922 case MessageType.editorLoadGameAdmins:
923 requireAdmin(session);
924 send(session, {
925 type: MessageType.editorGameAdmins,
926 admins: listPublicGameAdmins()
927 });
928 break;
929 case MessageType.editorGrantGameAdmin:
930 requireAdmin(session);
931 {
932 const updated = stateDb.grantGameAdminByUsername(message.username);
933 refreshAccountAdminSessions(updated.auth_subject);
934 send(session, {
935 type: MessageType.editorGameAdmins,
936 admins: listPublicGameAdmins()
937 });
938 }
939 break;
940 case MessageType.editorRevokeGameAdmin:
941 requireAdmin(session);
942 {
943 const target = String(message.authSubject ?? "").trim();
944 if (!target)
945 { throw userError("Admin account is required."); }
946 if (target === session.authSubject && !message.confirmSelf)
947 { throw userError("Confirm removing your own admin access."); }
948 const updated = stateDb.setGameAdmin(target, false);
949 refreshAccountAdminSessions(updated.auth_subject);
950 send(session, {
951 type: MessageType.editorGameAdmins,
952 admins: listPublicGameAdmins()
953 });
954 }
955 break;
956 case MessageType.editorConsoleSubscribe:
957 requireAdmin(session);
958 session.consoleSubscribed = true;
959 send(session, {
960 type: MessageType.editorConsoleSnapshot,
961 lines: getConsoleSnapshot(800)
962 });
963 break;
964 case MessageType.editorSaveSettings:
965 requireAdmin(session);
966 {
967 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
968 simulation.applySettings(saved.settings);
969 broadcastStatus();
970 broadcastSettings(saved);
971 }
972 break;
973 case MessageType.editorApplyRevision:
974 requireAdmin(session);
975 if (!editor.revisionStatus().pendingRevisionId)
976 {
977 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
978 break;
979 }
980 {
981 const appliedRevisionId = editor.applyPendingRevision();
982 simulation.reloadWorld();
983 for (const other of sessions.values())
984 {
985 if (other.entityId)
986 { syncSubscriptions(other, true); }
987 }
988 broadcastStatus();
989 send(session, {
990 type: MessageType.editorRevisionApplied,
991 ...editor.revisionStatus(),
992 appliedRevisionId
993 });
994 }
995 break;
996 case MessageType.editorRestartNow:
997 requireAdmin(session);
998 deploy?.requestRestartNow?.("admin-editor");
999 break;
1000 case MessageType.editorLoadQuests:
1001 requireAdmin(session);
1002 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
1003 break;
1004 case MessageType.editorSaveQuest:
1005 requireAdmin(session);
1006 send(session, {
1007 type: MessageType.editorQuests,
1008 ...editor.saveQuest(message.quest ?? message, session.authSubject)
1009 });
1010 break;
1011 case MessageType.editorDeleteQuest:
1012 requireAdmin(session);
1013 send(session, {
1014 type: MessageType.editorQuests,
1015 ...editor.deleteQuest(message.questId, session.authSubject)
1016 });
1017 break;
1018 case MessageType.editorLoadDialogues:
1019 requireAdmin(session);
1020 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
1021 break;
1022 case MessageType.editorSaveDialogue:
1023 requireAdmin(session);
1024 send(session, {
1025 type: MessageType.editorDialogues,
1026 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
1027 });
1028 break;
1029 case MessageType.editorDeleteDialogue:
1030 requireAdmin(session);
1031 send(session, {
1032 type: MessageType.editorDialogues,
1033 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
1034 });
1035 break;
1036 case MessageType.dialogueChoose:
1037 requirePlaying(session);
1038 simulation.enqueue(session.id, {
1039 type: "dialogue-choose",
1040 characterId: session.characterId,
1041 trigger: String(message.trigger ?? "")
1042 });
1043 break;
1044 case MessageType.dialogueAdvance:
1045 requirePlaying(session);
1046 simulation.enqueue(session.id, {
1047 type: "dialogue-advance",
1048 characterId: session.characterId
1049 });
1050 break;
1051 case MessageType.closeDialogue:
1052 requirePlaying(session);
1053 simulation.enqueue(session.id, {
1054 type: "close-dialogue",
1055 characterId: session.characterId
1056 });
1057 break;
1058 case MessageType.requestQuests:
1059 requirePlaying(session);
1060 simulation.enqueue(session.id, {
1061 type: "request-quests",
1062 characterId: session.characterId
1063 });
1064 break;
1065 case MessageType.setGraphicsSettings:
1066 {
1067 const next = normalizeGraphicsSettings({
1068 viewDistance: message.viewDistance ?? session.viewDistance
1069 });
1070 const changed = next.viewDistance !== session.viewDistance;
1071 session.viewDistance = next.viewDistance;
1072 if (changed && session.entityId)
1073 { syncSubscriptions(session, true); }
1074 }
1075 break;
1076 default:
1077 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
1078 }
1079 }
1080
1081 function enterWorld (session, characterId)
1082 {
1083 if (draining || deploy?.isDraining?.())
1084 {
1085 const error = new Error("The server is restarting for an update. Please try again in a moment.");
1086 error.userFacing = true;
1087 throw error;
1088 }
1089 leaveWorld(session);
1090 const character = characters.getOwned(session.account.account_id, characterId);
1091 if (character.deletion_scheduled_at)
1092 {
1093 const error = new Error("That character is marked for deletion.");
1094 error.userFacing = true;
1095 throw error;
1096 }
1097 const targetCharacterId = character.character_id;
1098 let handoffEntityId = null;
1099 for (const other of [...sessions.values()])
1100 {
1101 if (other === session || other.account.account_id !== session.account.account_id || !other.characterId)
1102 { continue; }
1103 const sameCharacter = other.characterId === targetCharacterId;
1104 if (sameCharacter && simulation.isCharacterOnline(targetCharacterId))
1105 { handoffEntityId = simulation.entityForCharacter(targetCharacterId); }
1106 disconnectPlayingSession(other, {
1107 despawn: !sameCharacter,
1108 reason: sameCharacter
1109 ? "This character was opened in another window."
1110 : "Logged in from another window."
1111 });
1112 }
1113 session.characterId = targetCharacterId;
1114 if (handoffEntityId != null)
1115 {
1116 const entityId = simulation.reattachCharacterSession(targetCharacterId, session.id);
1117 if (!entityId)
1118 {
1119 const error = new Error("Could not resume that character. Please try again.");
1120 error.userFacing = true;
1121 throw error;
1122 }
1123 session.entityId = entityId;
1124 }
1125 else
1126 { session.entityId = simulation.spawnCharacter(session.id, character); }
1127 sendEnterWorld(session, character);
1128 notifyFriendPresence(session.account?.account_id);
1129 }
1130
1131 function sendEnterWorld (session, character)
1132 {
1133 const spawned = simulation.entityRecord(session.entityId);
1134 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
1135 const dimRecord = simulation.getDimensionRecord?.(enterDim);
1136 send(session, {
1137 type: MessageType.enterWorld,
1138 entityId: session.entityId,
1139 characterId: session.characterId,
1140 accountId: session.account?.account_id ?? null,
1141 tileX: spawned.tileX,
1142 tileY: spawned.tileY,
1143 dimensionId: enterDim,
1144 lightingMode: dimRecord?.lightingMode ?? "dayNight",
1145 seasonMode: dimRecord?.seasonMode ?? "auto",
1146 gait: spawned.gait,
1147 sex: spawned.sex,
1148 firstName: spawned.firstName,
1149 lastName: spawned.lastName,
1150 layers: spawned.layers ?? [],
1151 health: spawned.health,
1152 maxHealth: spawned.maxHealth,
1153 skullValue: spawned.skullValue | 0,
1154 settings: simulation.settings,
1155 worldTime: simulation.worldTime(),
1156 restartStatus: deploy?.getStatus?.() ?? { scheduled: false }
1157 });
1158 syncSubscriptions(session, true);
1159 send(session, { type: MessageType.friends, ...friendsPayload(session.characterId) });
1160 const bag = simulation.bagOf(session.entityId);
1161 if (bag)
1162 { send(session, { type: MessageType.inventory, ...bag }); }
1163 const skills = simulation.skillsOf(session.entityId);
1164 if (skills)
1165 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
1166 const spellView = simulation.spellsOf(session.entityId);
1167 if (spellView)
1168 {
1169 send(session, {
1170 type: MessageType.spells,
1171 spells: spellView.spells,
1172 autoCast: spellView.autoCast,
1173 armedSpellId: spellView.armedSpellId ?? null
1174 });
1175 }
1176 const stamina = simulation.staminaOf(session.entityId);
1177 if (stamina)
1178 {
1179 send(session, {
1180 type: MessageType.stamina,
1181 current: stamina.current,
1182 max: stamina.max,
1183 gait: stamina.gait
1184 });
1185 }
1186 if (character.is_dead)
1187 {
1188 send(session, {
1189 type: MessageType.playerDied,
1190 entityId: session.entityId,
1191 characterId: session.characterId
1192 });
1193 }
1194 publishReplication(simulation.drainReplication());
1195 }
1196
1197 function disconnectPlayingSession (session, { despawn = true, reason = "Logged in from another window." } = {})
1198 {
1199 send(session, { type: MessageType.forceLogout, reason });
1200 const characterId = session.characterId;
1201 const accountId = session.account?.account_id | 0;
1202 session.characterId = null;
1203 session.entityId = null;
1204 session.entitySubscribed.clear();
1205 session.staticSubscribed.clear();
1206 if (despawn && characterId)
1207 {
1208 simulation.despawnCharacter(characterId);
1209 publishReplication(simulation.drainReplication());
1210 }
1211 session.suppressLeaveWorldOnClose = true;
1212 if (session.socket.readyState === 1)
1213 { session.socket.close(4000, "Logged in elsewhere"); }
1214 if (accountId)
1215 { notifyFriendPresence(accountId); }
1216 }
1217
1218 function leaveWorld (session)
1219 {
1220 const accountId = session.account?.account_id | 0;
1221 if (session.characterId)
1222 { simulation.despawnCharacter(session.characterId); }
1223 publishReplication(simulation.drainReplication());
1224 session.characterId = null;
1225 session.entityId = null;
1226 session.entitySubscribed.clear();
1227 session.staticSubscribed.clear();
1228 if (accountId)
1229 { notifyFriendPresence(accountId); }
1230 }
1231
1232 function syncSubscriptions (session, forceSnapshots)
1233 {
1234 if (!session.entityId)
1235 { return; }
1236 const position = simulation.positionOf(session.entityId);
1237 if (!position)
1238 { return; }
1239
1240 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1241 const centerChunkX = tileToChunk(position.tileX);
1242 const centerChunkY = tileToChunk(position.tileY);
1243 const mapRadius = staticChunkRadiusForViewDistance(
1244 session.viewDistance,
1245 STATIC_CHUNK_RADIUS,
1246 VISIBLE_CHUNK_RADIUS
1247 );
1248 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1249 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1250 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1251 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1252
1253 for (const key of session.staticSubscribed)
1254 {
1255 if (!staticNext.has(key))
1256 {
1257 const { chunkX, chunkY } = parseChunkKey(key);
1258 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1259 }
1260 }
1261
1262 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1263 for (const snapshot of snapshots)
1264 {
1265 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1266 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1267 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1268 {
1269 const groundItems = (snapshot.groundItems ?? []).filter((item) =>
1270 canCharacterSeeGroundItem(item, session.characterId)
1271 );
1272 send(session, { type: MessageType.chunkSnapshot, ...snapshot, groundItems });
1273 }
1274 }
1275 session.entitySubscribed = entityNext;
1276 session.staticSubscribed = staticNext;
1277 }
1278
1279 function requirePlaying (session)
1280 {
1281 if (!session.characterId)
1282 {
1283 const error = new Error("Select a character first.");
1284 error.userFacing = true;
1285 throw error;
1286 }
1287 }
1288
1289 function userError (message)
1290 {
1291 const error = new Error(message);
1292 error.userFacing = true;
1293 return error;
1294 }
1295
1296 function listPublicGameAdmins ()
1297 {
1298 return stateDb.listGameAdmins().map((row) => ({
1299 authSubject: row.auth_subject,
1300 username: row.username ?? null,
1301 email: row.email ?? null
1302 }));
1303 }
1304
1305 function refreshAccountAdminSessions (authSubject)
1306 {
1307 const account = stateDb.getAccountBySubject(authSubject);
1308 if (!account)
1309 { return; }
1310 for (const session of sessions.values())
1311 {
1312 if (session.authSubject !== authSubject)
1313 { continue; }
1314 session.account = account;
1315 send(session, {
1316 type: MessageType.session,
1317 accountId: account.account_id,
1318 authSubject: account.auth_subject,
1319 username: session.username ?? account.username ?? null,
1320 email: account.email ?? null,
1321 isAdmin: !!account.is_admin,
1322 characters: characters.list(account.account_id)
1323 });
1324 }
1325 }
1326
1327 function requireAdmin (session)
1328 {
1329 if (!session.account.is_admin)
1330 {
1331 const error = new Error("Admin only.");
1332 error.userFacing = true;
1333 throw error;
1334 }
1335 }
1336
1337 function broadcastStatus ()
1338 {
1339 const worldTime = simulation.worldTime();
1340 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1341 for (const session of sessions.values())
1342 {
1343 if (session.entityId)
1344 {
1345 send(session, {
1346 type: MessageType.worldStatus,
1347 worldTime,
1348 settings: simulation.settings,
1349 activeRevisionId: simulation.activeRevisionId,
1350 restartStatus
1351 });
1352 }
1353 }
1354 }
1355
1356 function broadcastRestartStatus ()
1357 {
1358 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1359 for (const session of sessions.values())
1360 {
1361 if (session.entityId)
1362 { send(session, { type: MessageType.restartStatus, restartStatus }); }
1363 }
1364 }
1365
1366 function onlinePresenceByAccount ()
1367 {
1368 const byAccount = new Map();
1369 for (const entry of sessions.values())
1370 {
1371 if (!entry.characterId || !entry.entityId)
1372 { continue; }
1373 const accountId = entry.account?.account_id | 0;
1374 if (!accountId)
1375 { continue; }
1376 const row = stateDb.getCharacter(entry.characterId);
1377 if (!row)
1378 { continue; }
1379 byAccount.set(accountId, {
1380 characterId: row.character_id,
1381 firstName: row.first_name,
1382 lastName: row.last_name
1383 });
1384 }
1385 return byAccount;
1386 }
1387
1388 function friendsPayload (characterId)
1389 {
1390 const snap = friends.snapshot(characterId);
1391 const presence = onlinePresenceByAccount();
1392 for (const account of snap.friends ?? [])
1393 {
1394 const playingAs = presence.get(account.accountId | 0) ?? null;
1395 account.online = !!playingAs;
1396 account.playingAs = playingAs;
1397 }
1398 return snap;
1399 }
1400
1401 /** Refresh friends panels for an account and everyone friended with them. */
1402 function notifyFriendPresence (accountId)
1403 {
1404 const id = accountId | 0;
1405 if (!id)
1406 { return; }
1407 const refs = [id];
1408 for (const row of stateDb.listAccountFriendRecords(id))
1409 { refs.push(row.account_id); }
1410 pushFriends(...refs);
1411 }
1412
1413 function pushFriends (...refs)
1414 {
1415 const accountIds = new Set();
1416 for (const ref of refs)
1417 {
1418 if (ref == null)
1419 { continue; }
1420 if (typeof ref === "object" && ref.accountId != null)
1421 {
1422 accountIds.add(ref.accountId | 0);
1423 continue;
1424 }
1425 const asNumber = Number(ref);
1426 if (!asNumber)
1427 { continue; }
1428 // Heuristic: character ids from messages; also accept bare account ids from panel.
1429 const character = stateDb.getCharacter(asNumber);
1430 if (character)
1431 { accountIds.add(character.account_id | 0); }
1432 else if (stateDb.getAccount(asNumber))
1433 { accountIds.add(asNumber); }
1434 }
1435 for (const session of sessions.values())
1436 {
1437 if (!session.characterId)
1438 { continue; }
1439 const accountId = session.account?.account_id | 0;
1440 if (!accountIds.has(accountId))
1441 { continue; }
1442 send(session, { type: MessageType.friends, ...friendsPayload(session.characterId) });
1443 }
1444 }
1445
1446 function broadcastSettings (payload)
1447 {
1448 for (const session of sessions.values())
1449 {
1450 if (session.account.is_admin)
1451 { send(session, { type: MessageType.editorSettings, ...payload }); }
1452 }
1453 }
1454
1455 function onTickResult (result)
1456 {
1457 publishReplication(result.replication ?? []);
1458 for (const event of result.events)
1459 {
1460 if (event.type === "command-error")
1461 {
1462 const session = sessions.get(event.sessionId);
1463 if (session)
1464 { send(session, { type: MessageType.error, message: event.message }); }
1465 continue;
1466 }
1467 if (event.type === "inventory")
1468 {
1469 const session = event.sessionId != null
1470 ? sessions.get(event.sessionId)
1471 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1472 if (!session)
1473 { continue; }
1474 send(session, {
1475 type: MessageType.inventory,
1476 inventory: event.inventory,
1477 equipment: event.equipment,
1478 vault: event.vault,
1479 vaultReserved: event.vaultReserved
1480 });
1481 if (event.bank)
1482 {
1483 send(session, {
1484 type: MessageType.bankSnapshot,
1485 vault: event.vault,
1486 vaultReserved: event.vaultReserved,
1487 inheritance: stateDb.getInheritance(session.account.account_id)
1488 });
1489 }
1490 if (event.cauldron != null)
1491 {
1492 send(session, {
1493 type: MessageType.cauldronSnapshot,
1494 open: !!event.cauldron,
1495 state: event.cauldronState ?? null,
1496 alchemyResult: event.alchemyResult ?? null,
1497 dyeConfirm: event.dyeConfirm ?? null
1498 });
1499 }
1500 continue;
1501 }
1502 if (event.type === "skills")
1503 {
1504 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1505 if (!session)
1506 { continue; }
1507 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
1508 continue;
1509 }
1510 if (event.type === "spells")
1511 {
1512 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1513 if (!session)
1514 { continue; }
1515 send(session, {
1516 type: MessageType.spellsUpdated,
1517 spells: event.spells ?? [],
1518 autoCast: !!event.autoCast,
1519 armedSpellId: event.armedSpellId ?? null
1520 });
1521 continue;
1522 }
1523 if (event.type === "spell-armed")
1524 {
1525 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1526 if (!session)
1527 { continue; }
1528 send(session, {
1529 type: MessageType.spellArmed,
1530 spellId: event.spellId
1531 });
1532 continue;
1533 }
1534 if (event.type === "spell-disarmed")
1535 {
1536 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1537 if (!session)
1538 { continue; }
1539 send(session, { type: MessageType.spellDisarmed });
1540 continue;
1541 }
1542 if (event.type === "stamina")
1543 {
1544 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1545 if (!session)
1546 { continue; }
1547 send(session, {
1548 type: MessageType.stamina,
1549 current: event.current,
1550 max: event.max,
1551 gait: event.gait
1552 });
1553 continue;
1554 }
1555 if (event.type === "status-effects")
1556 {
1557 const session = event.sessionId != null
1558 ? sessions.get(event.sessionId)
1559 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1560 if (!session)
1561 { continue; }
1562 send(session, {
1563 type: MessageType.statusEffects,
1564 effects: event.effects ?? [],
1565 blind: !!event.blind
1566 });
1567 continue;
1568 }
1569 if (event.type === "toast")
1570 {
1571 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1572 if (session)
1573 { send(session, { type: MessageType.toast, message: event.message }); }
1574 continue;
1575 }
1576 if (event.type === "quests-snapshot")
1577 {
1578 const session = event.sessionId != null
1579 ? sessions.get(event.sessionId)
1580 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1581 if (session)
1582 {
1583 send(session, {
1584 type: MessageType.questsSnapshot,
1585 quests: event.quests ?? []
1586 });
1587 }
1588 continue;
1589 }
1590 if (event.type === "quest-step-complete")
1591 {
1592 const session = event.sessionId != null
1593 ? sessions.get(event.sessionId)
1594 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1595 if (session)
1596 {
1597 send(session, {
1598 type: MessageType.questStepComplete,
1599 questId: event.questId,
1600 title: event.title
1601 });
1602 }
1603 continue;
1604 }
1605 if (event.type === "dialogue-step")
1606 {
1607 const session = event.sessionId != null
1608 ? sessions.get(event.sessionId)
1609 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1610 if (session)
1611 {
1612 send(session, {
1613 type: MessageType.dialogueStep,
1614 dialogueId: event.dialogueId,
1615 stepId: event.stepId,
1616 label: event.label,
1617 npcEntityId: event.npcEntityId ?? null,
1618 lines: event.lines ?? []
1619 });
1620 }
1621 continue;
1622 }
1623 if (event.type === "dialogue-choices")
1624 {
1625 const session = event.sessionId != null
1626 ? sessions.get(event.sessionId)
1627 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1628 if (session)
1629 {
1630 send(session, {
1631 type: MessageType.dialogueChoices,
1632 dialogueId: event.dialogueId,
1633 stepId: event.stepId,
1634 npcEntityId: event.npcEntityId ?? null,
1635 triggers: event.triggers ?? []
1636 });
1637 }
1638 continue;
1639 }
1640 if (event.type === "dialogue-close")
1641 {
1642 const session = event.sessionId != null
1643 ? sessions.get(event.sessionId)
1644 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1645 if (session)
1646 {
1647 send(session, {
1648 type: MessageType.dialogueClose,
1649 reason: event.reason ?? null
1650 });
1651 }
1652 continue;
1653 }
1654 if (event.type === "pigeon-delivered")
1655 {
1656 for (const session of sessions.values())
1657 {
1658 if (session.characterId === event.senderCharacterId
1659 || session.characterId === event.destinationCharacterId)
1660 {
1661 send(session, {
1662 type: MessageType.pigeonDelivered,
1663 courierId: event.courierId,
1664 destinationKind: event.destinationKind,
1665 cargo: event.cargo
1666 });
1667 }
1668 }
1669 continue;
1670 }
1671 if (event.type === "player-died")
1672 {
1673 const session = sessions.get(event.sessionId);
1674 if (session)
1675 {
1676 send(session, {
1677 type: MessageType.playerDied,
1678 entityId: event.entityId,
1679 characterId: event.characterId
1680 });
1681 }
1682 continue;
1683 }
1684 if (event.type === "player-respawned")
1685 {
1686 const session = sessions.get(event.sessionId);
1687 if (session)
1688 {
1689 send(session, {
1690 type: MessageType.playerRespawned,
1691 entityId: event.entityId,
1692 characterId: event.characterId,
1693 tileX: event.tileX,
1694 tileY: event.tileY,
1695 health: event.health,
1696 maxHealth: event.maxHealth,
1697 stamina: event.stamina,
1698 maxStamina: event.maxStamina,
1699 skullValue: event.skullValue | 0
1700 });
1701 }
1702 continue;
1703 }
1704 if (event.type === "dimension-changed")
1705 {
1706 const session = sessions.get(event.sessionId);
1707 if (session)
1708 {
1709 session.entitySubscribed.clear();
1710 session.staticSubscribed.clear();
1711 send(session, {
1712 type: MessageType.dimensionChanged,
1713 dimensionId: event.dimensionId,
1714 tileX: event.tileX,
1715 tileY: event.tileY,
1716 lightingMode: event.lightingMode,
1717 seasonMode: event.seasonMode
1718 });
1719 syncSubscriptions(session, true);
1720 }
1721 continue;
1722 }
1723 if (event.type === "combat-no-arrows")
1724 {
1725 const session = sessions.get(event.sessionId);
1726 if (session)
1727 { send(session, { type: MessageType.combatNoArrows }); }
1728 continue;
1729 }
1730 if (event.type === "craft-result")
1731 {
1732 const session = sessions.get(event.sessionId);
1733 if (session)
1734 {
1735 send(session, {
1736 type: MessageType.craftResult,
1737 recipeId: event.recipeId,
1738 ok: !!event.ok,
1739 error: event.error ?? null,
1740 burned: !!event.burned,
1741 continuing: !!event.continuing
1742 });
1743 }
1744 continue;
1745 }
1746 if (event.type === "station-open")
1747 {
1748 const session = sessions.get(event.sessionId);
1749 if (session)
1750 {
1751 send(session, {
1752 type: MessageType.stationOpen,
1753 stationId: event.stationId
1754 });
1755 }
1756 continue;
1757 }
1758 if (event.type === "shop-open")
1759 {
1760 const session = sessions.get(event.sessionId);
1761 if (session)
1762 {
1763 send(session, {
1764 type: MessageType.shopOpen,
1765 npcEntityId: event.npcEntityId,
1766 displayName: event.displayName,
1767 sex: event.sex === "female" ? "female" : "male",
1768 buysItems: !!event.buysItems,
1769 stock: event.stock ?? []
1770 });
1771 }
1772 continue;
1773 }
1774 if (event.type === "shop-closed")
1775 {
1776 const session = sessions.get(event.sessionId);
1777 if (session)
1778 {
1779 send(session, {
1780 type: MessageType.shopClosed,
1781 npcEntityId: event.npcEntityId
1782 });
1783 }
1784 continue;
1785 }
1786 if (event.type === "market-open")
1787 {
1788 const session = sessions.get(event.sessionId);
1789 if (session)
1790 {
1791 send(session, {
1792 type: MessageType.marketOpen,
1793 displayName: event.displayName,
1794 orders: event.orders ?? [],
1795 catalog: event.catalog ?? []
1796 });
1797 }
1798 continue;
1799 }
1800 if (event.type === "market-closed")
1801 {
1802 const session = sessions.get(event.sessionId);
1803 if (session)
1804 { send(session, { type: MessageType.marketClosed }); }
1805 continue;
1806 }
1807 if (event.type === "bounty-snapshot")
1808 {
1809 const session = sessions.get(event.sessionId);
1810 if (session)
1811 {
1812 send(session, {
1813 type: MessageType.bountySnapshot,
1814 myAmountCopper: event.myAmountCopper | 0,
1815 myAmountLabel: event.myAmountLabel ?? "",
1816 message: event.message ?? "",
1817 raised: event.raised ?? null
1818 });
1819 }
1820 continue;
1821 }
1822 if (event.type === "bounty-closed")
1823 {
1824 const session = sessions.get(event.sessionId);
1825 if (session)
1826 { send(session, { type: MessageType.closeBounty }); }
1827 continue;
1828 }
1829 if (event.type === "character-bounty")
1830 {
1831 const session = sessions.get(event.sessionId);
1832 if (session)
1833 {
1834 send(session, {
1835 type: MessageType.characterBounty,
1836 target: event.target ?? null
1837 });
1838 }
1839 continue;
1840 }
1841 if (event.type === "barber-snapshot")
1842 {
1843 const session = sessions.get(event.sessionId);
1844 if (session)
1845 {
1846 send(session, {
1847 type: MessageType.barberSnapshot,
1848 sex: event.sex,
1849 styles: event.styles ?? [],
1850 hair: event.hair ?? null,
1851 message: event.message ?? ""
1852 });
1853 }
1854 continue;
1855 }
1856 if (event.type === "barber-closed")
1857 {
1858 const session = sessions.get(event.sessionId);
1859 if (session)
1860 { send(session, { type: MessageType.closeBarber }); }
1861 continue;
1862 }
1863 if (event.type === "market-trade")
1864 {
1865 for (const session of sessions.values())
1866 {
1867 if (
1868 session.characterId === event.buyerCharacterId
1869 || session.characterId === event.sellerCharacterId
1870 )
1871 {
1872 send(session, {
1873 type: MessageType.marketTrade,
1874 itemId: event.itemId,
1875 quantity: event.quantity,
1876 unitPrice: event.unitPrice,
1877 triggeringSide: event.triggeringSide
1878 });
1879 }
1880 }
1881 continue;
1882 }
1883 if (event.type === "item-bubble")
1884 {
1885 broadcastItemBubble(
1886 sessions,
1887 simulation,
1888 event.entityId,
1889 event.itemId,
1890 event.quantity
1891 );
1892 continue;
1893 }
1894 if (event.type === "gather-swing" || event.type === "tile-shove")
1895 {
1896 publishEntity({
1897 ...event,
1898 type: event.type
1899 });
1900 continue;
1901 }
1902 if (event.type === "chunk-delta")
1903 {
1904 publishEntity(event);
1905 continue;
1906 }
1907 if (event.type === "gather-complete")
1908 {
1909 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1910 if (session)
1911 {
1912 send(session, {
1913 type: MessageType.gatherComplete,
1914 kind: event.kind,
1915 materialId: event.materialId,
1916 itemId: event.itemId
1917 });
1918 }
1919 continue;
1920 }
1921 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")
1922 { publishEntity(event); }
1923 }
1924 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1925 { broadcastStatus(); }
1926 }
1927
1928 function publishReplication (events)
1929 {
1930 for (const event of events ?? [])
1931 { publishEntity(event); }
1932 }
1933
1934 function publishEntity (event)
1935 {
1936 const toDim = normalizeDimensionId(event.dimensionId
1937 ?? simulation.entityRecord(event.entityId)?.dimensionId
1938 ?? OVERWORLD_ID);
1939 const fromDim = event.fromDimensionId != null
1940 ? normalizeDimensionId(event.fromDimensionId)
1941 : toDim;
1942 const fromKey = event.fromTileX != null
1943 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
1944 : null;
1945 const toKey = event.tileX != null
1946 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
1947 : null;
1948 for (const session of sessions.values())
1949 {
1950 if (!session.entityId)
1951 { continue; }
1952 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1953 const seesTo = session.entitySubscribed.has(toKey);
1954 const seesStaticTo = session.staticSubscribed.has(toKey);
1955 if (event.type === "entity-spawn")
1956 {
1957 if (session.entityId === event.entityId || !seesTo)
1958 { continue; }
1959 send(session, spawnPayload(event));
1960 continue;
1961 }
1962 if (event.type === "entity-despawn")
1963 {
1964 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1965 { continue; }
1966 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1967 continue;
1968 }
1969 if (event.type === "entity-appearance")
1970 {
1971 if (!seesTo)
1972 { continue; }
1973 send(session, {
1974 type: MessageType.entityAppearance,
1975 entityId: event.entityId,
1976 sprite: event.sprite,
1977 layers: event.layers ?? [],
1978 lightRadiusTiles: event.lightRadiusTiles ?? 0
1979 });
1980 continue;
1981 }
1982 if (event.type === "entity-skull")
1983 {
1984 if (!seesTo && session.entityId !== event.entityId)
1985 { continue; }
1986 send(session, {
1987 type: MessageType.entitySkull,
1988 entityId: event.entityId,
1989 skullValue: event.skullValue | 0
1990 });
1991 continue;
1992 }
1993 if (event.type === "ground-item-appear")
1994 {
1995 if (!seesTo)
1996 { continue; }
1997 if (!canCharacterSeeGroundItem(event, session.characterId))
1998 { continue; }
1999 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
2000 continue;
2001 }
2002 if (event.type === "ground-item-despawn")
2003 {
2004 if (!seesTo)
2005 { continue; }
2006 if (!canCharacterSeeGroundItem(event, session.characterId))
2007 { continue; }
2008 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
2009 continue;
2010 }
2011 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
2012 {
2013 if (!seesTo && !seesFrom)
2014 { continue; }
2015 const type = event.type === "combat-swing"
2016 ? MessageType.combatSwing
2017 : event.type === "combat-hit"
2018 ? MessageType.combatHit
2019 : event.type === "combat-block"
2020 ? MessageType.combatBlock
2021 : MessageType.combatMiss;
2022 send(session, {
2023 type,
2024 attackerId: event.attackerId,
2025 targetId: event.targetId,
2026 damage: event.damage,
2027 health: event.health,
2028 maxHealth: event.maxHealth,
2029 tileX: event.tileX,
2030 tileY: event.tileY,
2031 fromTileX: event.fromTileX,
2032 fromTileY: event.fromTileY
2033 });
2034 continue;
2035 }
2036 if (event.type === "combat-projectile")
2037 {
2038 if (!seesTo && !seesFrom)
2039 { continue; }
2040 send(session, {
2041 type: MessageType.combatProjectile,
2042 attackerId: event.attackerId,
2043 targetId: event.targetId,
2044 fromTileX: event.fromTileX,
2045 fromTileY: event.fromTileY,
2046 tileX: event.tileX,
2047 tileY: event.tileY,
2048 durationMs: event.durationMs ?? 400,
2049 trackTarget: event.trackTarget !== false,
2050 shaftTint: event.shaftTint ?? null,
2051 tipTint: event.tipTint ?? null
2052 });
2053 continue;
2054 }
2055 if (event.type === "spell-projectile")
2056 {
2057 if (!seesTo && !seesFrom)
2058 { continue; }
2059 send(session, {
2060 type: MessageType.spellProjectile,
2061 casterId: event.casterId,
2062 targetId: event.targetId ?? null,
2063 spellId: event.spellId,
2064 fromTileX: event.fromTileX,
2065 fromTileY: event.fromTileY,
2066 tileX: event.tileX,
2067 tileY: event.tileY,
2068 durationMs: event.durationMs ?? 2000,
2069 sprite: event.sprite ?? null
2070 });
2071 continue;
2072 }
2073 if (event.type === "spell-fizzle")
2074 {
2075 if (!seesTo && !seesFrom)
2076 { continue; }
2077 send(session, {
2078 type: MessageType.spellFizzle,
2079 casterId: event.casterId,
2080 spellId: event.spellId,
2081 fromTileX: event.fromTileX,
2082 fromTileY: event.fromTileY,
2083 tileX: event.tileX,
2084 tileY: event.tileY
2085 });
2086 continue;
2087 }
2088 if (event.type === "spell-cast-flash")
2089 {
2090 if (!seesTo)
2091 { continue; }
2092 send(session, {
2093 type: MessageType.spellCastFlash,
2094 casterId: event.casterId,
2095 tileX: event.tileX,
2096 tileY: event.tileY,
2097 radiusTiles: event.radiusTiles ?? 1,
2098 durationMs: event.durationMs ?? 500,
2099 tier: event.tier ?? 1
2100 });
2101 continue;
2102 }
2103 if (event.type === "spell-light-appear" || event.type === "spell-light-update"
2104 || event.type === "spell-dark-appear" || event.type === "spell-dark-update")
2105 {
2106 if (!seesTo)
2107 { continue; }
2108 const isDark = event.type.startsWith("spell-dark");
2109 const appear = event.type.endsWith("appear");
2110 send(session, {
2111 type: appear
2112 ? (isDark ? MessageType.spellDarkAppear : MessageType.spellLightAppear)
2113 : (isDark ? MessageType.spellDarkUpdate : MessageType.spellLightUpdate),
2114 tileX: event.tileX,
2115 tileY: event.tileY,
2116 ownerEntityId: event.ownerEntityId,
2117 remainingMs: event.remainingMs ?? 0,
2118 rangeTiles: event.rangeTiles ?? 0,
2119 intensity: event.intensity ?? 0,
2120 expiresAt: event.expiresAt ?? 0,
2121 kind: isDark ? "dark" : "light"
2122 });
2123 continue;
2124 }
2125 if (event.type === "spell-light-remove" || event.type === "spell-dark-remove")
2126 {
2127 if (!seesTo)
2128 { continue; }
2129 send(session, {
2130 type: event.type === "spell-dark-remove"
2131 ? MessageType.spellDarkRemove
2132 : MessageType.spellLightRemove,
2133 tileX: event.tileX,
2134 tileY: event.tileY
2135 });
2136 continue;
2137 }
2138 if (event.type === "entity-health")
2139 {
2140 if (!seesTo && !seesFrom)
2141 { continue; }
2142 send(session, {
2143 type: MessageType.entityHealth,
2144 entityId: event.entityId,
2145 health: event.health,
2146 maxHealth: event.maxHealth
2147 });
2148 continue;
2149 }
2150 if (event.type === "gather-swing" || event.type === "tile-shove")
2151 {
2152 if (!seesTo && !seesFrom)
2153 { continue; }
2154 if (event.type === "gather-swing")
2155 {
2156 send(session, {
2157 type: MessageType.gatherSwing,
2158 attackerId: event.attackerId,
2159 tileX: event.tileX,
2160 tileY: event.tileY,
2161 fromTileX: event.fromTileX,
2162 fromTileY: event.fromTileY,
2163 toolItemId: event.toolItemId ?? null
2164 });
2165 }
2166 else
2167 {
2168 send(session, {
2169 type: MessageType.tileShove,
2170 attackerId: event.attackerId,
2171 tileX: event.tileX,
2172 tileY: event.tileY,
2173 fromTileX: event.fromTileX,
2174 fromTileY: event.fromTileY
2175 });
2176 }
2177 continue;
2178 }
2179 if (event.type === "skill-level-up")
2180 {
2181 if (session.entityId !== event.entityId && !seesTo)
2182 { continue; }
2183 send(session, {
2184 type: MessageType.skillLevelUp,
2185 entityId: event.entityId,
2186 characterId: event.characterId,
2187 skillId: event.skillId,
2188 level: event.level,
2189 previousLevel: event.previousLevel,
2190 displayName: event.displayName,
2191 icon: event.icon
2192 });
2193 continue;
2194 }
2195 if (event.type === "chunk-delta")
2196 {
2197 if (!seesStaticTo)
2198 { continue; }
2199 send(session, {
2200 type: MessageType.chunkDelta,
2201 chunkX: event.chunkX,
2202 chunkY: event.chunkY,
2203 tiles: [{
2204 localX: event.localX,
2205 localY: event.localY,
2206 block: event.block
2207 }]
2208 });
2209 continue;
2210 }
2211 if (event.type !== "entity-move")
2212 { continue; }
2213 if (seesTo)
2214 {
2215 if (!seesFrom)
2216 { send(session, spawnPayload(event)); }
2217 else
2218 {
2219 send(session, {
2220 type: MessageType.entityMove,
2221 entityId: event.entityId,
2222 tileX: event.tileX,
2223 tileY: event.tileY,
2224 worldX: event.worldX,
2225 worldY: event.worldY,
2226 gait: event.gait,
2227 lerpMs: event.lerpMs,
2228 freeFlight: !!event.freeFlight
2229 });
2230 }
2231 }
2232 else if (seesFrom)
2233 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
2234 if (session.entityId === event.entityId)
2235 {
2236 const crossedDimension = event.fromDimensionId != null
2237 && event.dimensionId != null
2238 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
2239 if (!crossedDimension)
2240 { syncSubscriptions(session, false); }
2241 }
2242 }
2243 }
2244
2245 function spawnPayload (event)
2246 {
2247 const record = simulation.entityRecord(event.entityId) ?? event;
2248 return {
2249 type: MessageType.entitySpawn,
2250 entityId: event.entityId,
2251 characterId: record.characterId ?? event.characterId ?? null,
2252 accountId: record.accountId ?? event.accountId ?? null,
2253 tileX: event.tileX ?? record.tileX,
2254 tileY: event.tileY ?? record.tileY,
2255 worldX: event.worldX ?? record.worldX,
2256 worldY: event.worldY ?? record.worldY,
2257 gait: event.gait ?? record.gait,
2258 sex: record.sex ?? event.sex ?? null,
2259 firstName: record.firstName ?? event.firstName ?? "",
2260 lastName: record.lastName ?? event.lastName ?? "",
2261 sprite: record.sprite ?? event.sprite ?? null,
2262 layers: record.layers ?? event.layers ?? [],
2263 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
2264 canFight: !!(record.canFight ?? event.canFight),
2265 hostile: !!(record.hostile ?? event.hostile),
2266 talkable: !!(record.talkable ?? event.talkable),
2267 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
2268 hasShop: !!(record.hasShop ?? event.hasShop),
2269 untargetable: !!(record.untargetable ?? event.untargetable),
2270 freeFlight: !!(record.freeFlight ?? event.freeFlight),
2271 health: record.health ?? event.health,
2272 maxHealth: record.maxHealth ?? event.maxHealth,
2273 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0,
2274 skullValue: record.skullValue | 0
2275 };
2276 }
2277
2278 return {
2279 sessions,
2280 onTickResult,
2281 wss,
2282 broadcastRestartStatus,
2283 setDraining (value)
2284 {
2285 draining = !!value;
2286 },
2287 async shutdown ()
2288 {
2289 draining = true;
2290 await Promise.all([...sessions.values()].map(async (session) =>
2291 {
2292 await sendAsync(session, {
2293 type: MessageType.forceLogout,
2294 reason: "Server shutting down."
2295 });
2296 leaveWorld(session);
2297 await closeAsync(session, 1001, "Server shutting down.");
2298 }));
2299 sessions.clear();
2300 await simulation.shutdown();
2301 }
2302 };
2303}
2304
2305function send (session, payload)
2306{
2307 if (session.socket.readyState === 1)
2308 { session.socket.send(JSON.stringify(payload)); }
2309}
2310
2311function sendAsync (session, payload)
2312{
2313 return new Promise((resolve) =>
2314 {
2315 if (session.socket.readyState !== 1)
2316 {
2317 resolve();
2318 return;
2319 }
2320 session.socket.send(JSON.stringify(payload), () => resolve());
2321 });
2322}
2323
2324function closeAsync (session, code, reason)
2325{
2326 return new Promise((resolve) =>
2327 {
2328 if (session.socket.readyState !== 1)
2329 {
2330 resolve();
2331 return;
2332 }
2333 session.socket.once("close", resolve);
2334 try
2335 { session.socket.close(code, reason); }
2336 catch
2337 { resolve(); }
2338 });
2339}