BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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