BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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