BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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