BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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