BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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