BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 64.2 KiB Download Raw
1import { WebSocketServer } from "ws";
2import { MessageType, GAIT } from "../../../shared/protocol/constants.js";
3import { chunkKey, parseChunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js";
4import { VISIBLE_CHUNK_RADIUS, STATIC_CHUNK_RADIUS } from "../../../shared/protocol/constants.js";
5import { staticChunkRadiusForViewDistance, ViewDistance, normalizeGraphicsSettings } from "../../../shared/graphics/settings.js";
6import { broadcastSpeech, broadcastItemBubble } from "../chat/speech.js";
7import { CraftingStationId, craftingStationDefinition } from "../../../shared/definitions/craftingStations.js";
8import { 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 skullValue: event.skullValue | 0
1639 });
1640 }
1641 continue;
1642 }
1643 if (event.type === "dimension-changed")
1644 {
1645 const session = sessions.get(event.sessionId);
1646 if (session)
1647 {
1648 session.entitySubscribed.clear();
1649 session.staticSubscribed.clear();
1650 send(session, {
1651 type: MessageType.dimensionChanged,
1652 dimensionId: event.dimensionId,
1653 tileX: event.tileX,
1654 tileY: event.tileY,
1655 lightingMode: event.lightingMode,
1656 seasonMode: event.seasonMode
1657 });
1658 syncSubscriptions(session, true);
1659 }
1660 continue;
1661 }
1662 if (event.type === "combat-no-arrows")
1663 {
1664 const session = sessions.get(event.sessionId);
1665 if (session)
1666 { send(session, { type: MessageType.combatNoArrows }); }
1667 continue;
1668 }
1669 if (event.type === "craft-result")
1670 {
1671 const session = sessions.get(event.sessionId);
1672 if (session)
1673 {
1674 send(session, {
1675 type: MessageType.craftResult,
1676 recipeId: event.recipeId,
1677 ok: !!event.ok,
1678 error: event.error ?? null,
1679 burned: !!event.burned,
1680 continuing: !!event.continuing
1681 });
1682 }
1683 continue;
1684 }
1685 if (event.type === "station-open")
1686 {
1687 const session = sessions.get(event.sessionId);
1688 if (session)
1689 {
1690 send(session, {
1691 type: MessageType.stationOpen,
1692 stationId: event.stationId
1693 });
1694 }
1695 continue;
1696 }
1697 if (event.type === "shop-open")
1698 {
1699 const session = sessions.get(event.sessionId);
1700 if (session)
1701 {
1702 send(session, {
1703 type: MessageType.shopOpen,
1704 npcEntityId: event.npcEntityId,
1705 displayName: event.displayName,
1706 sex: event.sex === "female" ? "female" : "male",
1707 buysItems: !!event.buysItems,
1708 stock: event.stock ?? []
1709 });
1710 }
1711 continue;
1712 }
1713 if (event.type === "shop-closed")
1714 {
1715 const session = sessions.get(event.sessionId);
1716 if (session)
1717 {
1718 send(session, {
1719 type: MessageType.shopClosed,
1720 npcEntityId: event.npcEntityId
1721 });
1722 }
1723 continue;
1724 }
1725 if (event.type === "market-open")
1726 {
1727 const session = sessions.get(event.sessionId);
1728 if (session)
1729 {
1730 send(session, {
1731 type: MessageType.marketOpen,
1732 displayName: event.displayName,
1733 orders: event.orders ?? [],
1734 catalog: event.catalog ?? []
1735 });
1736 }
1737 continue;
1738 }
1739 if (event.type === "market-closed")
1740 {
1741 const session = sessions.get(event.sessionId);
1742 if (session)
1743 { send(session, { type: MessageType.marketClosed }); }
1744 continue;
1745 }
1746 if (event.type === "bounty-snapshot")
1747 {
1748 const session = sessions.get(event.sessionId);
1749 if (session)
1750 {
1751 send(session, {
1752 type: MessageType.bountySnapshot,
1753 myAmountCopper: event.myAmountCopper | 0,
1754 myAmountLabel: event.myAmountLabel ?? "",
1755 message: event.message ?? "",
1756 raised: event.raised ?? null
1757 });
1758 }
1759 continue;
1760 }
1761 if (event.type === "bounty-closed")
1762 {
1763 const session = sessions.get(event.sessionId);
1764 if (session)
1765 { send(session, { type: MessageType.closeBounty }); }
1766 continue;
1767 }
1768 if (event.type === "character-bounty")
1769 {
1770 const session = sessions.get(event.sessionId);
1771 if (session)
1772 {
1773 send(session, {
1774 type: MessageType.characterBounty,
1775 target: event.target ?? null
1776 });
1777 }
1778 continue;
1779 }
1780 if (event.type === "barber-snapshot")
1781 {
1782 const session = sessions.get(event.sessionId);
1783 if (session)
1784 {
1785 send(session, {
1786 type: MessageType.barberSnapshot,
1787 sex: event.sex,
1788 styles: event.styles ?? [],
1789 hair: event.hair ?? null,
1790 message: event.message ?? ""
1791 });
1792 }
1793 continue;
1794 }
1795 if (event.type === "barber-closed")
1796 {
1797 const session = sessions.get(event.sessionId);
1798 if (session)
1799 { send(session, { type: MessageType.closeBarber }); }
1800 continue;
1801 }
1802 if (event.type === "market-trade")
1803 {
1804 for (const session of sessions.values())
1805 {
1806 if (
1807 session.characterId === event.buyerCharacterId
1808 || session.characterId === event.sellerCharacterId
1809 )
1810 {
1811 send(session, {
1812 type: MessageType.marketTrade,
1813 itemId: event.itemId,
1814 quantity: event.quantity,
1815 unitPrice: event.unitPrice,
1816 triggeringSide: event.triggeringSide
1817 });
1818 }
1819 }
1820 continue;
1821 }
1822 if (event.type === "item-bubble")
1823 {
1824 broadcastItemBubble(
1825 sessions,
1826 simulation,
1827 event.entityId,
1828 event.itemId,
1829 event.quantity
1830 );
1831 continue;
1832 }
1833 if (event.type === "gather-swing" || event.type === "tile-shove")
1834 {
1835 publishEntity({
1836 ...event,
1837 type: event.type
1838 });
1839 continue;
1840 }
1841 if (event.type === "chunk-delta")
1842 {
1843 publishEntity(event);
1844 continue;
1845 }
1846 if (event.type === "gather-complete")
1847 {
1848 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1849 if (session)
1850 {
1851 send(session, {
1852 type: MessageType.gatherComplete,
1853 kind: event.kind,
1854 materialId: event.materialId,
1855 itemId: event.itemId
1856 });
1857 }
1858 continue;
1859 }
1860 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")
1861 { publishEntity(event); }
1862 }
1863 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1864 { broadcastStatus(); }
1865 }
1866
1867 function publishReplication (events)
1868 {
1869 for (const event of events ?? [])
1870 { publishEntity(event); }
1871 }
1872
1873 function publishEntity (event)
1874 {
1875 const toDim = normalizeDimensionId(event.dimensionId
1876 ?? simulation.entityRecord(event.entityId)?.dimensionId
1877 ?? OVERWORLD_ID);
1878 const fromDim = event.fromDimensionId != null
1879 ? normalizeDimensionId(event.fromDimensionId)
1880 : toDim;
1881 const fromKey = event.fromTileX != null
1882 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
1883 : null;
1884 const toKey = event.tileX != null
1885 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
1886 : null;
1887 for (const session of sessions.values())
1888 {
1889 if (!session.entityId)
1890 { continue; }
1891 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1892 const seesTo = session.entitySubscribed.has(toKey);
1893 const seesStaticTo = session.staticSubscribed.has(toKey);
1894 if (event.type === "entity-spawn")
1895 {
1896 if (session.entityId === event.entityId || !seesTo)
1897 { continue; }
1898 send(session, spawnPayload(event));
1899 continue;
1900 }
1901 if (event.type === "entity-despawn")
1902 {
1903 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1904 { continue; }
1905 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1906 continue;
1907 }
1908 if (event.type === "entity-appearance")
1909 {
1910 if (!seesTo)
1911 { continue; }
1912 send(session, {
1913 type: MessageType.entityAppearance,
1914 entityId: event.entityId,
1915 sprite: event.sprite,
1916 layers: event.layers ?? [],
1917 lightRadiusTiles: event.lightRadiusTiles ?? 0
1918 });
1919 continue;
1920 }
1921 if (event.type === "entity-skull")
1922 {
1923 if (!seesTo && session.entityId !== event.entityId)
1924 { continue; }
1925 send(session, {
1926 type: MessageType.entitySkull,
1927 entityId: event.entityId,
1928 skullValue: event.skullValue | 0
1929 });
1930 continue;
1931 }
1932 if (event.type === "ground-item-appear")
1933 {
1934 if (!seesTo)
1935 { continue; }
1936 if (!canCharacterSeeGroundItem(event, session.characterId))
1937 { continue; }
1938 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1939 continue;
1940 }
1941 if (event.type === "ground-item-despawn")
1942 {
1943 if (!seesTo)
1944 { continue; }
1945 if (!canCharacterSeeGroundItem(event, session.characterId))
1946 { continue; }
1947 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1948 continue;
1949 }
1950 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1951 {
1952 if (!seesTo && !seesFrom)
1953 { continue; }
1954 const type = event.type === "combat-swing"
1955 ? MessageType.combatSwing
1956 : event.type === "combat-hit"
1957 ? MessageType.combatHit
1958 : event.type === "combat-block"
1959 ? MessageType.combatBlock
1960 : MessageType.combatMiss;
1961 send(session, {
1962 type,
1963 attackerId: event.attackerId,
1964 targetId: event.targetId,
1965 damage: event.damage,
1966 health: event.health,
1967 maxHealth: event.maxHealth,
1968 tileX: event.tileX,
1969 tileY: event.tileY,
1970 fromTileX: event.fromTileX,
1971 fromTileY: event.fromTileY
1972 });
1973 continue;
1974 }
1975 if (event.type === "combat-projectile")
1976 {
1977 if (!seesTo && !seesFrom)
1978 { continue; }
1979 send(session, {
1980 type: MessageType.combatProjectile,
1981 attackerId: event.attackerId,
1982 targetId: event.targetId,
1983 fromTileX: event.fromTileX,
1984 fromTileY: event.fromTileY,
1985 tileX: event.tileX,
1986 tileY: event.tileY,
1987 durationMs: event.durationMs ?? 400,
1988 trackTarget: event.trackTarget !== false,
1989 shaftTint: event.shaftTint ?? null,
1990 tipTint: event.tipTint ?? null
1991 });
1992 continue;
1993 }
1994 if (event.type === "spell-projectile")
1995 {
1996 if (!seesTo && !seesFrom)
1997 { continue; }
1998 send(session, {
1999 type: MessageType.spellProjectile,
2000 casterId: event.casterId,
2001 targetId: event.targetId ?? null,
2002 spellId: event.spellId,
2003 fromTileX: event.fromTileX,
2004 fromTileY: event.fromTileY,
2005 tileX: event.tileX,
2006 tileY: event.tileY,
2007 durationMs: event.durationMs ?? 2000,
2008 sprite: event.sprite ?? null
2009 });
2010 continue;
2011 }
2012 if (event.type === "spell-fizzle")
2013 {
2014 if (!seesTo && !seesFrom)
2015 { continue; }
2016 send(session, {
2017 type: MessageType.spellFizzle,
2018 casterId: event.casterId,
2019 spellId: event.spellId,
2020 fromTileX: event.fromTileX,
2021 fromTileY: event.fromTileY,
2022 tileX: event.tileX,
2023 tileY: event.tileY
2024 });
2025 continue;
2026 }
2027 if (event.type === "spell-cast-flash")
2028 {
2029 if (!seesTo)
2030 { continue; }
2031 send(session, {
2032 type: MessageType.spellCastFlash,
2033 casterId: event.casterId,
2034 tileX: event.tileX,
2035 tileY: event.tileY,
2036 radiusTiles: event.radiusTiles ?? 1,
2037 durationMs: event.durationMs ?? 500,
2038 tier: event.tier ?? 1
2039 });
2040 continue;
2041 }
2042 if (event.type === "spell-light-appear" || event.type === "spell-light-update"
2043 || event.type === "spell-dark-appear" || event.type === "spell-dark-update")
2044 {
2045 if (!seesTo)
2046 { continue; }
2047 const isDark = event.type.startsWith("spell-dark");
2048 const appear = event.type.endsWith("appear");
2049 send(session, {
2050 type: appear
2051 ? (isDark ? MessageType.spellDarkAppear : MessageType.spellLightAppear)
2052 : (isDark ? MessageType.spellDarkUpdate : MessageType.spellLightUpdate),
2053 tileX: event.tileX,
2054 tileY: event.tileY,
2055 ownerEntityId: event.ownerEntityId,
2056 remainingMs: event.remainingMs ?? 0,
2057 rangeTiles: event.rangeTiles ?? 0,
2058 intensity: event.intensity ?? 0,
2059 expiresAt: event.expiresAt ?? 0,
2060 kind: isDark ? "dark" : "light"
2061 });
2062 continue;
2063 }
2064 if (event.type === "spell-light-remove" || event.type === "spell-dark-remove")
2065 {
2066 if (!seesTo)
2067 { continue; }
2068 send(session, {
2069 type: event.type === "spell-dark-remove"
2070 ? MessageType.spellDarkRemove
2071 : MessageType.spellLightRemove,
2072 tileX: event.tileX,
2073 tileY: event.tileY
2074 });
2075 continue;
2076 }
2077 if (event.type === "entity-health")
2078 {
2079 if (!seesTo && !seesFrom)
2080 { continue; }
2081 send(session, {
2082 type: MessageType.entityHealth,
2083 entityId: event.entityId,
2084 health: event.health,
2085 maxHealth: event.maxHealth
2086 });
2087 continue;
2088 }
2089 if (event.type === "gather-swing" || event.type === "tile-shove")
2090 {
2091 if (!seesTo && !seesFrom)
2092 { continue; }
2093 if (event.type === "gather-swing")
2094 {
2095 send(session, {
2096 type: MessageType.gatherSwing,
2097 attackerId: event.attackerId,
2098 tileX: event.tileX,
2099 tileY: event.tileY,
2100 fromTileX: event.fromTileX,
2101 fromTileY: event.fromTileY,
2102 toolItemId: event.toolItemId ?? null
2103 });
2104 }
2105 else
2106 {
2107 send(session, {
2108 type: MessageType.tileShove,
2109 attackerId: event.attackerId,
2110 tileX: event.tileX,
2111 tileY: event.tileY,
2112 fromTileX: event.fromTileX,
2113 fromTileY: event.fromTileY
2114 });
2115 }
2116 continue;
2117 }
2118 if (event.type === "skill-level-up")
2119 {
2120 if (session.entityId !== event.entityId && !seesTo)
2121 { continue; }
2122 send(session, {
2123 type: MessageType.skillLevelUp,
2124 entityId: event.entityId,
2125 characterId: event.characterId,
2126 skillId: event.skillId,
2127 level: event.level,
2128 previousLevel: event.previousLevel,
2129 displayName: event.displayName,
2130 icon: event.icon
2131 });
2132 continue;
2133 }
2134 if (event.type === "chunk-delta")
2135 {
2136 if (!seesStaticTo)
2137 { continue; }
2138 send(session, {
2139 type: MessageType.chunkDelta,
2140 chunkX: event.chunkX,
2141 chunkY: event.chunkY,
2142 tiles: [{
2143 localX: event.localX,
2144 localY: event.localY,
2145 block: event.block
2146 }]
2147 });
2148 continue;
2149 }
2150 if (event.type !== "entity-move")
2151 { continue; }
2152 if (seesTo)
2153 {
2154 if (!seesFrom)
2155 { send(session, spawnPayload(event)); }
2156 else
2157 {
2158 send(session, {
2159 type: MessageType.entityMove,
2160 entityId: event.entityId,
2161 tileX: event.tileX,
2162 tileY: event.tileY,
2163 worldX: event.worldX,
2164 worldY: event.worldY,
2165 gait: event.gait,
2166 lerpMs: event.lerpMs,
2167 freeFlight: !!event.freeFlight
2168 });
2169 }
2170 }
2171 else if (seesFrom)
2172 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
2173 if (session.entityId === event.entityId)
2174 {
2175 const crossedDimension = event.fromDimensionId != null
2176 && event.dimensionId != null
2177 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
2178 if (!crossedDimension)
2179 { syncSubscriptions(session, false); }
2180 }
2181 }
2182 }
2183
2184 function spawnPayload (event)
2185 {
2186 const record = simulation.entityRecord(event.entityId) ?? event;
2187 return {
2188 type: MessageType.entitySpawn,
2189 entityId: event.entityId,
2190 characterId: record.characterId ?? event.characterId ?? null,
2191 accountId: record.accountId ?? event.accountId ?? null,
2192 tileX: event.tileX ?? record.tileX,
2193 tileY: event.tileY ?? record.tileY,
2194 worldX: event.worldX ?? record.worldX,
2195 worldY: event.worldY ?? record.worldY,
2196 gait: event.gait ?? record.gait,
2197 sex: record.sex ?? event.sex ?? null,
2198 firstName: record.firstName ?? event.firstName ?? "",
2199 lastName: record.lastName ?? event.lastName ?? "",
2200 sprite: record.sprite ?? event.sprite ?? null,
2201 layers: record.layers ?? event.layers ?? [],
2202 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
2203 canFight: !!(record.canFight ?? event.canFight),
2204 hostile: !!(record.hostile ?? event.hostile),
2205 talkable: !!(record.talkable ?? event.talkable),
2206 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
2207 hasShop: !!(record.hasShop ?? event.hasShop),
2208 untargetable: !!(record.untargetable ?? event.untargetable),
2209 freeFlight: !!(record.freeFlight ?? event.freeFlight),
2210 health: record.health ?? event.health,
2211 maxHealth: record.maxHealth ?? event.maxHealth,
2212 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0,
2213 skullValue: record.skullValue | 0
2214 };
2215 }
2216
2217 return {
2218 sessions,
2219 onTickResult,
2220 wss,
2221 broadcastRestartStatus,
2222 setDraining (value)
2223 {
2224 draining = !!value;
2225 },
2226 async shutdown ()
2227 {
2228 draining = true;
2229 await Promise.all([...sessions.values()].map(async (session) =>
2230 {
2231 await sendAsync(session, {
2232 type: MessageType.forceLogout,
2233 reason: "Server shutting down."
2234 });
2235 leaveWorld(session);
2236 await closeAsync(session, 1001, "Server shutting down.");
2237 }));
2238 sessions.clear();
2239 await simulation.shutdown();
2240 }
2241 };
2242}
2243
2244function send (session, payload)
2245{
2246 if (session.socket.readyState === 1)
2247 { session.socket.send(JSON.stringify(payload)); }
2248}
2249
2250function sendAsync (session, payload)
2251{
2252 return new Promise((resolve) =>
2253 {
2254 if (session.socket.readyState !== 1)
2255 {
2256 resolve();
2257 return;
2258 }
2259 session.socket.send(JSON.stringify(payload), () => resolve());
2260 });
2261}
2262
2263function closeAsync (session, code, reason)
2264{
2265 return new Promise((resolve) =>
2266 {
2267 if (session.socket.readyState !== 1)
2268 {
2269 resolve();
2270 return;
2271 }
2272 session.socket.once("close", resolve);
2273 try
2274 { session.socket.close(code, reason); }
2275 catch
2276 { resolve(); }
2277 });
2278}