BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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