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 // Dead bodies may only respawn or leave the world — ignore all other intents.
140 return;
141 }
142 switch (message.type)
143 {
144 case MessageType.createCharacter:
145 {
146 const created = characters.create(
147 session.account,
148 message.firstName,
149 message.lastName,
150 message.sex,
151 message.hair ?? null,
152 simulation.settings,
153 message.clothing ?? null
154 );
155 enterWorld(session, created.characterId);
156 }
157 break;
158 case MessageType.selectCharacter:
159 enterWorld(session, message.characterId);
160 break;
161 case MessageType.scheduleDeleteCharacter:
162 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
163 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
164 break;
165 case MessageType.cancelDeleteCharacter:
166 characters.cancelDelete(session.account, message.characterId);
167 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
168 break;
169 case MessageType.leaveWorld:
170 leaveWorld(session);
171 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
172 break;
173 case MessageType.respawn:
174 requirePlaying(session);
175 simulation.enqueue(session.id, {
176 type: "respawn",
177 characterId: session.characterId
178 });
179 break;
180 case MessageType.moveTo:
181 requirePlaying(session);
182 simulation.enqueue(session.id, {
183 type: "move-to",
184 characterId: session.characterId,
185 tileX: message.tileX | 0,
186 tileY: message.tileY | 0
187 });
188 break;
189 case MessageType.setGait:
190 requirePlaying(session);
191 simulation.enqueue(session.id, {
192 type: "set-gait",
193 characterId: session.characterId,
194 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
195 });
196 break;
197 case MessageType.friendRequest:
198 requirePlaying(session);
199 friends.request(session.characterId, message.characterId);
200 pushFriends(session.characterId, message.characterId);
201 break;
202 case MessageType.friendAccept:
203 requirePlaying(session);
204 if (message.accountId)
205 { friends.acceptAccount(session.characterId, message.accountId); }
206 else
207 { friends.accept(session.characterId, message.characterId); }
208 pushFriends(session.characterId, message.characterId, message.accountId);
209 break;
210 case MessageType.friendDecline:
211 requirePlaying(session);
212 if (message.accountId)
213 { friends.declineAccount(session.characterId, message.accountId); }
214 else
215 { friends.decline(session.characterId, message.characterId); }
216 pushFriends(session.characterId, message.characterId, message.accountId);
217 break;
218 case MessageType.friendRemove:
219 requirePlaying(session);
220 if (message.accountId)
221 { friends.removeAccount(session.characterId, message.accountId); }
222 else
223 { friends.remove(session.characterId, message.characterId); }
224 pushFriends(session.characterId, message.characterId, message.accountId);
225 break;
226 case MessageType.chatSay:
227 requirePlaying(session);
228 broadcastSpeech(sessions, simulation, session, message.text);
229 break;
230 case MessageType.dropItem:
231 requirePlaying(session);
232 simulation.enqueue(session.id, {
233 type: "drop-item",
234 characterId: session.characterId,
235 slotIndex: message.slotIndex | 0,
236 quantity: message.quantity ?? null
237 });
238 break;
239 case MessageType.pickupItem:
240 requirePlaying(session);
241 simulation.enqueue(session.id, {
242 type: "pickup-item",
243 characterId: session.characterId,
244 groundItemId: message.groundItemId | 0
245 });
246 break;
247 case MessageType.equipItem:
248 requirePlaying(session);
249 simulation.enqueue(session.id, {
250 type: "equip-item",
251 characterId: session.characterId,
252 slotIndex: message.slotIndex | 0
253 });
254 break;
255 case MessageType.unequipItem:
256 requirePlaying(session);
257 simulation.enqueue(session.id, {
258 type: "unequip-item",
259 characterId: session.characterId,
260 equipSlot: message.equipSlot
261 });
262 break;
263 case MessageType.moveInventorySlot:
264 requirePlaying(session);
265 simulation.enqueue(session.id, {
266 type: "move-inventory-slot",
267 characterId: session.characterId,
268 fromSlotIndex: message.fromSlotIndex | 0,
269 toSlotIndex: message.toSlotIndex | 0
270 });
271 break;
272 case MessageType.eatItem:
273 requirePlaying(session);
274 simulation.enqueue(session.id, {
275 type: "eat-item",
276 characterId: session.characterId,
277 slotIndex: message.slotIndex | 0
278 });
279 break;
280 case MessageType.drinkItem:
281 requirePlaying(session);
282 simulation.enqueue(session.id, {
283 type: "drink-item",
284 characterId: session.characterId,
285 slotIndex: message.slotIndex | 0
286 });
287 break;
288 case MessageType.tipArrows:
289 requirePlaying(session);
290 simulation.enqueue(session.id, {
291 type: "tip-arrows",
292 characterId: session.characterId,
293 coatingSlotIndex: message.coatingSlotIndex | 0,
294 arrowSlotIndex: message.arrowSlotIndex | 0,
295 quantity: message.quantity | 0
296 });
297 break;
298 case MessageType.openBank:
299 requirePlaying(session);
300 simulation.enqueue(session.id, {
301 type: "open-bank",
302 characterId: session.characterId
303 });
304 break;
305 case MessageType.enterDoorway:
306 requirePlaying(session);
307 simulation.enqueue(session.id, {
308 type: "enter-doorway",
309 characterId: session.characterId,
310 tileX: message.tileX | 0,
311 tileY: message.tileY | 0
312 });
313 break;
314 case MessageType.openBounty:
315 requirePlaying(session);
316 simulation.enqueue(session.id, {
317 type: "open-bounty",
318 characterId: session.characterId
319 });
320 break;
321 case MessageType.raiseBounty:
322 requirePlaying(session);
323 simulation.enqueue(session.id, {
324 type: "raise-bounty",
325 characterId: session.characterId,
326 firstName: message.firstName,
327 lastName: message.lastName,
328 amountCopper: message.amountCopper
329 });
330 break;
331 case MessageType.getCharacterBounty:
332 requirePlaying(session);
333 simulation.enqueue(session.id, {
334 type: "get-character-bounty",
335 characterId: session.characterId,
336 targetCharacterId: message.characterId,
337 firstName: message.firstName,
338 lastName: message.lastName
339 });
340 break;
341 case MessageType.closeBounty:
342 requirePlaying(session);
343 simulation.enqueue(session.id, {
344 type: "close-bounty",
345 characterId: session.characterId
346 });
347 break;
348 case MessageType.openBarber:
349 requirePlaying(session);
350 simulation.enqueue(session.id, {
351 type: "open-barber",
352 characterId: session.characterId
353 });
354 break;
355 case MessageType.setHair:
356 requirePlaying(session);
357 simulation.enqueue(session.id, {
358 type: "set-hair",
359 characterId: session.characterId,
360 hair: message.hair ?? null
361 });
362 break;
363 case MessageType.closeBarber:
364 requirePlaying(session);
365 simulation.enqueue(session.id, {
366 type: "close-barber",
367 characterId: session.characterId
368 });
369 break;
370 case MessageType.openCauldron:
371 requirePlaying(session);
372 simulation.enqueue(session.id, {
373 type: "open-cauldron",
374 characterId: session.characterId
375 });
376 break;
377 case MessageType.openFurnace:
378 requirePlaying(session);
379 simulation.enqueue(session.id, {
380 type: "open-station",
381 characterId: session.characterId,
382 stationId: CraftingStationId.furnace
383 });
384 break;
385 case MessageType.openStation:
386 {
387 requirePlaying(session);
388 const stationId = typeof message.stationId === "string"
389 ? message.stationId
390 : null;
391 if (!stationId || !craftingStationDefinition(stationId))
392 { break; }
393 simulation.enqueue(session.id, {
394 type: "open-station",
395 characterId: session.characterId,
396 stationId
397 });
398 break;
399 }
400 case MessageType.mine:
401 requirePlaying(session);
402 simulation.enqueue(session.id, {
403 type: "mine",
404 characterId: session.characterId,
405 tileX: message.tileX | 0,
406 tileY: message.tileY | 0
407 });
408 break;
409 case MessageType.chop:
410 requirePlaying(session);
411 simulation.enqueue(session.id, {
412 type: "chop",
413 characterId: session.characterId,
414 tileX: message.tileX | 0,
415 tileY: message.tileY | 0
416 });
417 break;
418 case MessageType.pick:
419 requirePlaying(session);
420 simulation.enqueue(session.id, {
421 type: "pick",
422 characterId: session.characterId,
423 tileX: message.tileX | 0,
424 tileY: message.tileY | 0
425 });
426 break;
427 case MessageType.cancelGather:
428 requirePlaying(session);
429 simulation.enqueue(session.id, {
430 type: "cancel-gather",
431 characterId: session.characterId
432 });
433 break;
434 case MessageType.startCraft:
435 requirePlaying(session);
436 simulation.enqueue(session.id, {
437 type: "start-craft",
438 characterId: session.characterId,
439 stationId: message.stationId,
440 recipeId: message.recipeId,
441 clothTier: message.clothTier ?? null,
442 dyeSlotIndex: message.dyeSlotIndex ?? null,
443 batchCount: message.batchCount ?? null,
444 batchAll: !!message.batchAll
445 });
446 break;
447 case MessageType.startFire:
448 requirePlaying(session);
449 simulation.enqueue(session.id, {
450 type: "start-fire",
451 characterId: session.characterId,
452 groundItemId: message.groundItemId | 0
453 });
454 break;
455 case MessageType.startFish:
456 requirePlaying(session);
457 simulation.enqueue(session.id, {
458 type: "start-fish",
459 characterId: session.characterId,
460 tileX: message.tileX | 0,
461 tileY: message.tileY | 0
462 });
463 break;
464 case MessageType.cancelCraft:
465 requirePlaying(session);
466 simulation.enqueue(session.id, {
467 type: "cancel-craft",
468 characterId: session.characterId
469 });
470 break;
471 case MessageType.cauldronSetSlot:
472 requirePlaying(session);
473 simulation.enqueue(session.id, {
474 type: "cauldron-set-slot",
475 characterId: session.characterId,
476 slotIndex: message.slotIndex | 0,
477 itemId: message.itemId | 0,
478 quantity: message.quantity | 0,
479 instance: message.instance ?? null
480 });
481 break;
482 case MessageType.cauldronSetDyeSlot:
483 requirePlaying(session);
484 simulation.enqueue(session.id, {
485 type: "cauldron-set-dye-slot",
486 characterId: session.characterId,
487 slotIndex: message.slotIndex | 0,
488 itemId: message.itemId | 0,
489 quantity: message.quantity | 0,
490 instance: message.instance ?? null
491 });
492 break;
493 case MessageType.cauldronInsert:
494 requirePlaying(session);
495 simulation.enqueue(session.id, {
496 type: "cauldron-insert",
497 characterId: session.characterId,
498 itemId: message.itemId | 0,
499 quantity: message.quantity | 0,
500 instance: message.instance ?? null
501 });
502 break;
503 case MessageType.cauldronAction:
504 requirePlaying(session);
505 simulation.enqueue(session.id, {
506 type: "cauldron-action",
507 characterId: session.characterId,
508 action: message.action
509 });
510 break;
511 case MessageType.cauldronBottle:
512 requirePlaying(session);
513 simulation.enqueue(session.id, {
514 type: "cauldron-bottle",
515 characterId: session.characterId
516 });
517 break;
518 case MessageType.cauldronCreateDye:
519 requirePlaying(session);
520 simulation.enqueue(session.id, {
521 type: "cauldron-create-dye",
522 characterId: session.characterId,
523 confirmOverflow: !!message.confirmOverflow,
524 flowers: Array.isArray(message.flowers) ? message.flowers : []
525 });
526 break;
527 case MessageType.cauldronClear:
528 requirePlaying(session);
529 simulation.enqueue(session.id, {
530 type: "cauldron-clear",
531 characterId: session.characterId
532 });
533 break;
534 case MessageType.cauldronClearDye:
535 requirePlaying(session);
536 simulation.enqueue(session.id, {
537 type: "cauldron-clear-dye",
538 characterId: session.characterId
539 });
540 break;
541 case MessageType.cauldronSaveRecipe:
542 requirePlaying(session);
543 simulation.enqueue(session.id, {
544 type: "cauldron-save-recipe",
545 characterId: session.characterId
546 });
547 break;
548 case MessageType.cauldronClose:
549 requirePlaying(session);
550 simulation.enqueue(session.id, {
551 type: "cauldron-close",
552 characterId: session.characterId
553 });
554 break;
555 case MessageType.bankDeposit:
556 requirePlaying(session);
557 simulation.enqueue(session.id, {
558 type: "bank-deposit",
559 characterId: session.characterId,
560 slotIndex: message.slotIndex | 0,
561 quantity: message.quantity ?? null
562 });
563 break;
564 case MessageType.bankWithdraw:
565 requirePlaying(session);
566 simulation.enqueue(session.id, {
567 type: "bank-withdraw",
568 characterId: session.characterId,
569 slotIndex: message.slotIndex | 0,
570 quantity: message.quantity ?? null
571 });
572 break;
573 case MessageType.getBlankCheques:
574 requirePlaying(session);
575 simulation.enqueue(session.id, {
576 type: "get-blank-cheques",
577 characterId: session.characterId
578 });
579 break;
580 case MessageType.returnBlankCheques:
581 requirePlaying(session);
582 simulation.enqueue(session.id, {
583 type: "return-blank-cheques",
584 characterId: session.characterId,
585 slotIndex: message.slotIndex | 0,
586 quantity: message.quantity ?? null
587 });
588 break;
589 case MessageType.writeCheque:
590 requirePlaying(session);
591 simulation.enqueue(session.id, {
592 type: "write-cheque",
593 characterId: session.characterId,
594 slotIndex: message.slotIndex | 0,
595 vaultSlotIndex: message.vaultSlotIndex | 0,
596 quantity: message.quantity ?? 1
597 });
598 break;
599 case MessageType.redeemCheque:
600 requirePlaying(session);
601 simulation.enqueue(session.id, {
602 type: "redeem-cheque",
603 characterId: session.characterId,
604 slotIndex: message.slotIndex | 0
605 });
606 break;
607 case MessageType.claimInheritance:
608 requirePlaying(session);
609 {
610 const inheritance = stateDb.getInheritance(session.account.account_id);
611 simulation.enqueue(session.id, {
612 type: "claim-inheritance",
613 characterId: session.characterId,
614 stacks: (inheritance.slots ?? []).filter(Boolean)
615 });
616 }
617 break;
618 case MessageType.attack:
619 requirePlaying(session);
620 simulation.enqueue(session.id, {
621 type: "attack",
622 characterId: session.characterId,
623 targetEntityId: message.targetEntityId | 0
624 });
625 break;
626 case MessageType.cancelAttack:
627 requirePlaying(session);
628 simulation.enqueue(session.id, {
629 type: "cancel-attack",
630 characterId: session.characterId
631 });
632 break;
633 case MessageType.setSpellFavorite:
634 requirePlaying(session);
635 simulation.enqueue(session.id, {
636 type: "set-spell-favorite",
637 characterId: session.characterId,
638 spellId: message.spellId
639 });
640 break;
641 case MessageType.setSpellAutoCast:
642 requirePlaying(session);
643 simulation.enqueue(session.id, {
644 type: "set-spell-autocast",
645 characterId: session.characterId,
646 enabled: !!message.enabled
647 });
648 break;
649 case MessageType.armSpell:
650 requirePlaying(session);
651 simulation.enqueue(session.id, {
652 type: "arm-spell",
653 characterId: session.characterId,
654 spellId: message.spellId
655 });
656 break;
657 case MessageType.cancelArmSpell:
658 requirePlaying(session);
659 simulation.enqueue(session.id, {
660 type: "cancel-arm-spell",
661 characterId: session.characterId
662 });
663 break;
664 case MessageType.castSpellTile:
665 requirePlaying(session);
666 simulation.enqueue(session.id, {
667 type: "cast-spell-tile",
668 characterId: session.characterId,
669 spellId: message.spellId,
670 tileX: message.tileX | 0,
671 tileY: message.tileY | 0
672 });
673 break;
674 case MessageType.castSpellEntity:
675 requirePlaying(session);
676 simulation.enqueue(session.id, {
677 type: "cast-spell-entity",
678 characterId: session.characterId,
679 spellId: message.spellId,
680 targetEntityId: message.targetEntityId | 0
681 });
682 break;
683 case MessageType.readSpellbook:
684 requirePlaying(session);
685 simulation.enqueue(session.id, {
686 type: "read-spellbook",
687 characterId: session.characterId,
688 slotIndex: message.slotIndex | 0
689 });
690 break;
691 case MessageType.interact:
692 requirePlaying(session);
693 simulation.enqueue(session.id, {
694 type: "interact",
695 characterId: session.characterId,
696 targetEntityId: message.targetEntityId | 0,
697 purpose: message.purpose === "shop" || message.purpose === "talk"
698 ? message.purpose
699 : null
700 });
701 break;
702 case MessageType.buyFromShop:
703 requirePlaying(session);
704 simulation.enqueue(session.id, {
705 type: "buy-from-shop",
706 characterId: session.characterId,
707 npcEntityId: message.npcEntityId | 0,
708 itemId: message.itemId | 0,
709 quantity: message.quantity | 0 || 1,
710 listingId: typeof message.listingId === "string" ? message.listingId : null,
711 source: typeof message.source === "string" ? message.source : null
712 });
713 break;
714 case MessageType.sellToShop:
715 requirePlaying(session);
716 simulation.enqueue(session.id, {
717 type: "sell-to-shop",
718 characterId: session.characterId,
719 npcEntityId: message.npcEntityId | 0,
720 slotIndex: message.slotIndex | 0,
721 quantity: message.quantity | 0 || 1
722 });
723 break;
724 case MessageType.closeShop:
725 requirePlaying(session);
726 simulation.enqueue(session.id, {
727 type: "close-shop",
728 characterId: session.characterId,
729 npcEntityId: message.npcEntityId | 0
730 });
731 break;
732 case MessageType.openMarket:
733 requirePlaying(session);
734 simulation.enqueue(session.id, {
735 type: "open-market",
736 characterId: session.characterId
737 });
738 break;
739 case MessageType.closeMarket:
740 requirePlaying(session);
741 simulation.enqueue(session.id, {
742 type: "close-market",
743 characterId: session.characterId
744 });
745 break;
746 case MessageType.placeMarketSell:
747 requirePlaying(session);
748 simulation.enqueue(session.id, {
749 type: "place-market-sell",
750 characterId: session.characterId,
751 slotIndex: message.slotIndex | 0,
752 quantity: message.quantity | 0 || 1,
753 minUnitPrice: message.minUnitPrice | 0
754 });
755 break;
756 case MessageType.placeMarketBuy:
757 requirePlaying(session);
758 simulation.enqueue(session.id, {
759 type: "place-market-buy",
760 characterId: session.characterId,
761 itemId: message.itemId | 0,
762 quantity: message.quantity | 0 || 1,
763 maxUnitPrice: message.maxUnitPrice | 0
764 });
765 break;
766 case MessageType.cancelMarketOrder:
767 requirePlaying(session);
768 simulation.enqueue(session.id, {
769 type: "cancel-market-order",
770 characterId: session.characterId,
771 orderId: message.orderId | 0
772 });
773 break;
774 case MessageType.follow:
775 requirePlaying(session);
776 simulation.enqueue(session.id, {
777 type: "follow",
778 characterId: session.characterId,
779 targetEntityId: message.targetEntityId | 0
780 });
781 break;
782 case MessageType.cancelFollow:
783 requirePlaying(session);
784 simulation.enqueue(session.id, {
785 type: "cancel-follow",
786 characterId: session.characterId
787 });
788 break;
789 case MessageType.sendPigeon:
790 requirePlaying(session);
791 {
792 const result = simulation.dispatchPigeon({
793 characterId: session.characterId,
794 destination: message.destination,
795 cargo: message.cargo
796 });
797 send(session, {
798 type: MessageType.pigeonDispatched,
799 courierId: result.transit.courierId,
800 destinationKind: result.transit.destinationKind,
801 destinationCharacterId: result.transit.destinationCharacterId
802 });
803 send(session, { type: MessageType.inventory, ...result.bag });
804 }
805 break;
806 case MessageType.searchCharacter:
807 requirePlaying(session);
808 {
809 const character = friends.findByFullName(message.firstName, message.lastName);
810 send(session, {
811 type: MessageType.characterSearchResult,
812 character: character ?? null
813 });
814 }
815 break;
816 case MessageType.writeLetter:
817 requirePlaying(session);
818 simulation.enqueue(session.id, {
819 type: "write-letter",
820 characterId: session.characterId,
821 slotIndex: message.slotIndex,
822 body: message.body
823 });
824 break;
825 case MessageType.editLetter:
826 requirePlaying(session);
827 simulation.enqueue(session.id, {
828 type: "edit-letter",
829 characterId: session.characterId,
830 slotIndex: message.slotIndex,
831 body: message.body
832 });
833 break;
834 case MessageType.openLetter:
835 requirePlaying(session);
836 simulation.enqueue(session.id, {
837 type: "open-letter",
838 characterId: session.characterId,
839 slotIndex: message.slotIndex
840 });
841 break;
842 case MessageType.editorLoadChunk:
843 requireAdmin(session);
844 send(session, {
845 type: MessageType.editorChunk,
846 ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0, message.dimensionId)
847 });
848 break;
849 case MessageType.editorSaveChunk:
850 requireAdmin(session);
851 send(session, {
852 type: MessageType.editorChunk,
853 ...editor.saveChunk(
854 message.chunkX | 0,
855 message.chunkY | 0,
856 message.draft,
857 session.authSubject,
858 message.dimensionId
859 )
860 });
861 break;
862 case MessageType.editorListDimensions:
863 case "EDITOR_LIST_DIMENSIONS":
864 requireAdmin(session);
865 try
866 {
867 send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() });
868 }
869 catch (err)
870 {
871 send(session, { type: MessageType.error, message: err.userFacing ? err.message : "Failed to list dimensions." });
872 }
873 break;
874 case MessageType.editorCreateDimension:
875 case "EDITOR_CREATE_DIMENSION":
876 requireAdmin(session);
877 send(session, {
878 type: MessageType.editorDimensions,
879 ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject)
880 });
881 break;
882 case MessageType.editorSaveDimension:
883 case "EDITOR_SAVE_DIMENSION":
884 requireAdmin(session);
885 send(session, {
886 type: MessageType.editorDimensions,
887 ...editor.saveDimension(message.dimension ?? message, session.authSubject)
888 });
889 break;
890 case MessageType.editorSoftDeleteDimension:
891 case "EDITOR_SOFT_DELETE_DIMENSION":
892 requireAdmin(session);
893 send(session, {
894 type: MessageType.editorDimensions,
895 ...editor.softDeleteDimension(message.dimensionId, session.authSubject)
896 });
897 break;
898 case MessageType.editorCancelDimensionDeletion:
899 case "EDITOR_CANCEL_DIMENSION_DELETION":
900 requireAdmin(session);
901 send(session, {
902 type: MessageType.editorDimensions,
903 ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject)
904 });
905 break;
906 case MessageType.editorLoadSettings:
907 requireAdmin(session);
908 send(session, {
909 type: MessageType.editorSettings,
910 ...editor.loadSettings(),
911 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
912 });
913 break;
914 case MessageType.editorLoadGameAdmins:
915 requireAdmin(session);
916 send(session, {
917 type: MessageType.editorGameAdmins,
918 admins: listPublicGameAdmins()
919 });
920 break;
921 case MessageType.editorGrantGameAdmin:
922 requireAdmin(session);
923 {
924 const updated = stateDb.grantGameAdminByUsername(message.username);
925 refreshAccountAdminSessions(updated.auth_subject);
926 send(session, {
927 type: MessageType.editorGameAdmins,
928 admins: listPublicGameAdmins()
929 });
930 }
931 break;
932 case MessageType.editorRevokeGameAdmin:
933 requireAdmin(session);
934 {
935 const target = String(message.authSubject ?? "").trim();
936 if (!target)
937 { throw userError("Admin account is required."); }
938 if (target === session.authSubject && !message.confirmSelf)
939 { throw userError("Confirm removing your own admin access."); }
940 const updated = stateDb.setGameAdmin(target, false);
941 refreshAccountAdminSessions(updated.auth_subject);
942 send(session, {
943 type: MessageType.editorGameAdmins,
944 admins: listPublicGameAdmins()
945 });
946 }
947 break;
948 case MessageType.editorConsoleSubscribe:
949 requireAdmin(session);
950 session.consoleSubscribed = true;
951 send(session, {
952 type: MessageType.editorConsoleSnapshot,
953 lines: getConsoleSnapshot(800)
954 });
955 break;
956 case MessageType.editorSaveSettings:
957 requireAdmin(session);
958 {
959 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
960 simulation.applySettings(saved.settings);
961 broadcastStatus();
962 broadcastSettings(saved);
963 }
964 break;
965 case MessageType.editorApplyRevision:
966 requireAdmin(session);
967 if (!editor.revisionStatus().pendingRevisionId)
968 {
969 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
970 break;
971 }
972 {
973 const appliedRevisionId = editor.applyPendingRevision();
974 simulation.reloadWorld();
975 for (const other of sessions.values())
976 {
977 if (other.entityId)
978 { syncSubscriptions(other, true); }
979 }
980 broadcastStatus();
981 send(session, {
982 type: MessageType.editorRevisionApplied,
983 ...editor.revisionStatus(),
984 appliedRevisionId
985 });
986 }
987 break;
988 case MessageType.editorRestartNow:
989 requireAdmin(session);
990 deploy?.requestRestartNow?.("admin-editor");
991 break;
992 case MessageType.editorLoadQuests:
993 requireAdmin(session);
994 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
995 break;
996 case MessageType.editorSaveQuest:
997 requireAdmin(session);
998 send(session, {
999 type: MessageType.editorQuests,
1000 ...editor.saveQuest(message.quest ?? message, session.authSubject)
1001 });
1002 break;
1003 case MessageType.editorDeleteQuest:
1004 requireAdmin(session);
1005 send(session, {
1006 type: MessageType.editorQuests,
1007 ...editor.deleteQuest(message.questId, session.authSubject)
1008 });
1009 break;
1010 case MessageType.editorLoadDialogues:
1011 requireAdmin(session);
1012 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
1013 break;
1014 case MessageType.editorSaveDialogue:
1015 requireAdmin(session);
1016 send(session, {
1017 type: MessageType.editorDialogues,
1018 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
1019 });
1020 break;
1021 case MessageType.editorDeleteDialogue:
1022 requireAdmin(session);
1023 send(session, {
1024 type: MessageType.editorDialogues,
1025 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
1026 });
1027 break;
1028 case MessageType.dialogueChoose:
1029 requirePlaying(session);
1030 simulation.enqueue(session.id, {
1031 type: "dialogue-choose",
1032 characterId: session.characterId,
1033 trigger: String(message.trigger ?? "")
1034 });
1035 break;
1036 case MessageType.dialogueAdvance:
1037 requirePlaying(session);
1038 simulation.enqueue(session.id, {
1039 type: "dialogue-advance",
1040 characterId: session.characterId
1041 });
1042 break;
1043 case MessageType.closeDialogue:
1044 requirePlaying(session);
1045 simulation.enqueue(session.id, {
1046 type: "close-dialogue",
1047 characterId: session.characterId
1048 });
1049 break;
1050 case MessageType.requestQuests:
1051 requirePlaying(session);
1052 simulation.enqueue(session.id, {
1053 type: "request-quests",
1054 characterId: session.characterId
1055 });
1056 break;
1057 case MessageType.setGraphicsSettings:
1058 {
1059 const next = normalizeGraphicsSettings({
1060 viewDistance: message.viewDistance ?? session.viewDistance
1061 });
1062 const changed = next.viewDistance !== session.viewDistance;
1063 session.viewDistance = next.viewDistance;
1064 if (changed && session.entityId)
1065 { syncSubscriptions(session, true); }
1066 }
1067 break;
1068 default:
1069 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
1070 }
1071 }
1072
1073 function enterWorld (session, characterId)
1074 {
1075 if (draining || deploy?.isDraining?.())
1076 {
1077 const error = new Error("The server is restarting for an update. Please try again in a moment.");
1078 error.userFacing = true;
1079 throw error;
1080 }
1081 leaveWorld(session);
1082 const character = characters.getOwned(session.account.account_id, characterId);
1083 if (character.deletion_scheduled_at)
1084 {
1085 const error = new Error("That character is marked for deletion.");
1086 error.userFacing = true;
1087 throw error;
1088 }
1089 const targetCharacterId = character.character_id;
1090 let handoffEntityId = null;
1091 for (const other of [...sessions.values()])
1092 {
1093 if (other === session || other.account.account_id !== session.account.account_id || !other.characterId)
1094 { continue; }
1095 const sameCharacter = other.characterId === targetCharacterId;
1096 if (sameCharacter && simulation.isCharacterOnline(targetCharacterId))
1097 { handoffEntityId = simulation.entityForCharacter(targetCharacterId); }
1098 disconnectPlayingSession(other, {
1099 despawn: !sameCharacter,
1100 reason: sameCharacter
1101 ? "This character was opened in another window."
1102 : "Logged in from another window."
1103 });
1104 }
1105 session.characterId = targetCharacterId;
1106 if (handoffEntityId != null)
1107 {
1108 const entityId = simulation.reattachCharacterSession(targetCharacterId, session.id);
1109 if (!entityId)
1110 {
1111 const error = new Error("Could not resume that character. Please try again.");
1112 error.userFacing = true;
1113 throw error;
1114 }
1115 session.entityId = entityId;
1116 }
1117 else
1118 { session.entityId = simulation.spawnCharacter(session.id, character); }
1119 sendEnterWorld(session, character);
1120 }
1121
1122 function sendEnterWorld (session, character)
1123 {
1124 const spawned = simulation.entityRecord(session.entityId);
1125 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
1126 const dimRecord = simulation.getDimensionRecord?.(enterDim);
1127 send(session, {
1128 type: MessageType.enterWorld,
1129 entityId: session.entityId,
1130 characterId: session.characterId,
1131 accountId: session.account?.account_id ?? null,
1132 tileX: spawned.tileX,
1133 tileY: spawned.tileY,
1134 dimensionId: enterDim,
1135 lightingMode: dimRecord?.lightingMode ?? "dayNight",
1136 seasonMode: dimRecord?.seasonMode ?? "auto",
1137 gait: spawned.gait,
1138 sex: spawned.sex,
1139 firstName: spawned.firstName,
1140 lastName: spawned.lastName,
1141 layers: spawned.layers ?? [],
1142 health: spawned.health,
1143 maxHealth: spawned.maxHealth,
1144 skullValue: spawned.skullValue | 0,
1145 settings: simulation.settings,
1146 worldTime: simulation.worldTime(),
1147 restartStatus: deploy?.getStatus?.() ?? { scheduled: false }
1148 });
1149 syncSubscriptions(session, true);
1150 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
1151 const bag = simulation.bagOf(session.entityId);
1152 if (bag)
1153 { send(session, { type: MessageType.inventory, ...bag }); }
1154 const skills = simulation.skillsOf(session.entityId);
1155 if (skills)
1156 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
1157 const spellView = simulation.spellsOf(session.entityId);
1158 if (spellView)
1159 {
1160 send(session, {
1161 type: MessageType.spells,
1162 spells: spellView.spells,
1163 autoCast: spellView.autoCast,
1164 armedSpellId: spellView.armedSpellId ?? null
1165 });
1166 }
1167 const stamina = simulation.staminaOf(session.entityId);
1168 if (stamina)
1169 {
1170 send(session, {
1171 type: MessageType.stamina,
1172 current: stamina.current,
1173 max: stamina.max,
1174 gait: stamina.gait
1175 });
1176 }
1177 if (character.is_dead)
1178 {
1179 send(session, {
1180 type: MessageType.playerDied,
1181 entityId: session.entityId,
1182 characterId: session.characterId
1183 });
1184 }
1185 publishReplication(simulation.drainReplication());
1186 }
1187
1188 function disconnectPlayingSession (session, { despawn = true, reason = "Logged in from another window." } = {})
1189 {
1190 send(session, { type: MessageType.forceLogout, reason });
1191 const characterId = session.characterId;
1192 session.characterId = null;
1193 session.entityId = null;
1194 session.entitySubscribed.clear();
1195 session.staticSubscribed.clear();
1196 if (despawn && characterId)
1197 {
1198 simulation.despawnCharacter(characterId);
1199 publishReplication(simulation.drainReplication());
1200 }
1201 session.suppressLeaveWorldOnClose = true;
1202 if (session.socket.readyState === 1)
1203 { session.socket.close(4000, "Logged in elsewhere"); }
1204 }
1205
1206 function leaveWorld (session)
1207 {
1208 if (session.characterId)
1209 { simulation.despawnCharacter(session.characterId); }
1210 publishReplication(simulation.drainReplication());
1211 session.characterId = null;
1212 session.entityId = null;
1213 session.entitySubscribed.clear();
1214 session.staticSubscribed.clear();
1215 }
1216
1217 function syncSubscriptions (session, forceSnapshots)
1218 {
1219 if (!session.entityId)
1220 { return; }
1221 const position = simulation.positionOf(session.entityId);
1222 if (!position)
1223 { return; }
1224
1225 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1226 const centerChunkX = tileToChunk(position.tileX);
1227 const centerChunkY = tileToChunk(position.tileY);
1228 const mapRadius = staticChunkRadiusForViewDistance(
1229 session.viewDistance,
1230 STATIC_CHUNK_RADIUS,
1231 VISIBLE_CHUNK_RADIUS
1232 );
1233 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1234 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1235 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1236 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1237
1238 for (const key of session.staticSubscribed)
1239 {
1240 if (!staticNext.has(key))
1241 {
1242 const { chunkX, chunkY } = parseChunkKey(key);
1243 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1244 }
1245 }
1246
1247 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1248 for (const snapshot of snapshots)
1249 {
1250 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1251 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1252 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1253 {
1254 const groundItems = (snapshot.groundItems ?? []).filter((item) =>
1255 canCharacterSeeGroundItem(item, session.characterId)
1256 );
1257 send(session, { type: MessageType.chunkSnapshot, ...snapshot, groundItems });
1258 }
1259 }
1260 session.entitySubscribed = entityNext;
1261 session.staticSubscribed = staticNext;
1262 }
1263
1264 function requirePlaying (session)
1265 {
1266 if (!session.characterId)
1267 {
1268 const error = new Error("Select a character first.");
1269 error.userFacing = true;
1270 throw error;
1271 }
1272 }
1273
1274 function userError (message)
1275 {
1276 const error = new Error(message);
1277 error.userFacing = true;
1278 return error;
1279 }
1280
1281 function listPublicGameAdmins ()
1282 {
1283 return stateDb.listGameAdmins().map((row) => ({
1284 authSubject: row.auth_subject,
1285 username: row.username ?? null,
1286 email: row.email ?? null
1287 }));
1288 }
1289
1290 function refreshAccountAdminSessions (authSubject)
1291 {
1292 const account = stateDb.getAccountBySubject(authSubject);
1293 if (!account)
1294 { return; }
1295 for (const session of sessions.values())
1296 {
1297 if (session.authSubject !== authSubject)
1298 { continue; }
1299 session.account = account;
1300 send(session, {
1301 type: MessageType.session,
1302 accountId: account.account_id,
1303 authSubject: account.auth_subject,
1304 username: session.username ?? account.username ?? null,
1305 email: account.email ?? null,
1306 isAdmin: !!account.is_admin,
1307 characters: characters.list(account.account_id)
1308 });
1309 }
1310 }
1311
1312 function requireAdmin (session)
1313 {
1314 if (!session.account.is_admin)
1315 {
1316 const error = new Error("Admin only.");
1317 error.userFacing = true;
1318 throw error;
1319 }
1320 }
1321
1322 function broadcastStatus ()
1323 {
1324 const worldTime = simulation.worldTime();
1325 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1326 for (const session of sessions.values())
1327 {
1328 if (session.entityId)
1329 {
1330 send(session, {
1331 type: MessageType.worldStatus,
1332 worldTime,
1333 settings: simulation.settings,
1334 activeRevisionId: simulation.activeRevisionId,
1335 restartStatus
1336 });
1337 }
1338 }
1339 }
1340
1341 function broadcastRestartStatus ()
1342 {
1343 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1344 for (const session of sessions.values())
1345 {
1346 if (session.entityId)
1347 { send(session, { type: MessageType.restartStatus, restartStatus }); }
1348 }
1349 }
1350
1351 function pushFriends (...refs)
1352 {
1353 const accountIds = new Set();
1354 for (const ref of refs)
1355 {
1356 if (ref == null)
1357 { continue; }
1358 if (typeof ref === "object" && ref.accountId != null)
1359 {
1360 accountIds.add(ref.accountId | 0);
1361 continue;
1362 }
1363 const asNumber = Number(ref);
1364 if (!asNumber)
1365 { continue; }
1366 // Heuristic: character ids from messages; also accept bare account ids from panel.
1367 const character = stateDb.getCharacter(asNumber);
1368 if (character)
1369 { accountIds.add(character.account_id | 0); }
1370 else if (stateDb.getAccount(asNumber))
1371 { accountIds.add(asNumber); }
1372 }
1373 for (const session of sessions.values())
1374 {
1375 if (!session.characterId)
1376 { continue; }
1377 const accountId = session.account?.account_id | 0;
1378 if (!accountIds.has(accountId))
1379 { continue; }
1380 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
1381 }
1382 }
1383
1384 function broadcastSettings (payload)
1385 {
1386 for (const session of sessions.values())
1387 {
1388 if (session.account.is_admin)
1389 { send(session, { type: MessageType.editorSettings, ...payload }); }
1390 }
1391 }
1392
1393 function onTickResult (result)
1394 {
1395 publishReplication(result.replication ?? []);
1396 for (const event of result.events)
1397 {
1398 if (event.type === "command-error")
1399 {
1400 const session = sessions.get(event.sessionId);
1401 if (session)
1402 { send(session, { type: MessageType.error, message: event.message }); }
1403 continue;
1404 }
1405 if (event.type === "inventory")
1406 {
1407 const session = event.sessionId != null
1408 ? sessions.get(event.sessionId)
1409 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1410 if (!session)
1411 { continue; }
1412 send(session, {
1413 type: MessageType.inventory,
1414 inventory: event.inventory,
1415 equipment: event.equipment,
1416 vault: event.vault,
1417 vaultReserved: event.vaultReserved
1418 });
1419 if (event.bank)
1420 {
1421 send(session, {
1422 type: MessageType.bankSnapshot,
1423 vault: event.vault,
1424 vaultReserved: event.vaultReserved,
1425 inheritance: stateDb.getInheritance(session.account.account_id)
1426 });
1427 }
1428 if (event.cauldron != null)
1429 {
1430 send(session, {
1431 type: MessageType.cauldronSnapshot,
1432 open: !!event.cauldron,
1433 state: event.cauldronState ?? null,
1434 alchemyResult: event.alchemyResult ?? null,
1435 dyeConfirm: event.dyeConfirm ?? null
1436 });
1437 }
1438 continue;
1439 }
1440 if (event.type === "skills")
1441 {
1442 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1443 if (!session)
1444 { continue; }
1445 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
1446 continue;
1447 }
1448 if (event.type === "spells")
1449 {
1450 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1451 if (!session)
1452 { continue; }
1453 send(session, {
1454 type: MessageType.spellsUpdated,
1455 spells: event.spells ?? [],
1456 autoCast: !!event.autoCast,
1457 armedSpellId: event.armedSpellId ?? null
1458 });
1459 continue;
1460 }
1461 if (event.type === "spell-armed")
1462 {
1463 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1464 if (!session)
1465 { continue; }
1466 send(session, {
1467 type: MessageType.spellArmed,
1468 spellId: event.spellId
1469 });
1470 continue;
1471 }
1472 if (event.type === "spell-disarmed")
1473 {
1474 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1475 if (!session)
1476 { continue; }
1477 send(session, { type: MessageType.spellDisarmed });
1478 continue;
1479 }
1480 if (event.type === "stamina")
1481 {
1482 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1483 if (!session)
1484 { continue; }
1485 send(session, {
1486 type: MessageType.stamina,
1487 current: event.current,
1488 max: event.max,
1489 gait: event.gait
1490 });
1491 continue;
1492 }
1493 if (event.type === "status-effects")
1494 {
1495 const session = event.sessionId != null
1496 ? sessions.get(event.sessionId)
1497 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1498 if (!session)
1499 { continue; }
1500 send(session, {
1501 type: MessageType.statusEffects,
1502 effects: event.effects ?? [],
1503 blind: !!event.blind
1504 });
1505 continue;
1506 }
1507 if (event.type === "toast")
1508 {
1509 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1510 if (session)
1511 { send(session, { type: MessageType.toast, message: event.message }); }
1512 continue;
1513 }
1514 if (event.type === "quests-snapshot")
1515 {
1516 const session = event.sessionId != null
1517 ? sessions.get(event.sessionId)
1518 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1519 if (session)
1520 {
1521 send(session, {
1522 type: MessageType.questsSnapshot,
1523 quests: event.quests ?? []
1524 });
1525 }
1526 continue;
1527 }
1528 if (event.type === "quest-step-complete")
1529 {
1530 const session = event.sessionId != null
1531 ? sessions.get(event.sessionId)
1532 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1533 if (session)
1534 {
1535 send(session, {
1536 type: MessageType.questStepComplete,
1537 questId: event.questId,
1538 title: event.title
1539 });
1540 }
1541 continue;
1542 }
1543 if (event.type === "dialogue-step")
1544 {
1545 const session = event.sessionId != null
1546 ? sessions.get(event.sessionId)
1547 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1548 if (session)
1549 {
1550 send(session, {
1551 type: MessageType.dialogueStep,
1552 dialogueId: event.dialogueId,
1553 stepId: event.stepId,
1554 label: event.label,
1555 npcEntityId: event.npcEntityId ?? null,
1556 lines: event.lines ?? []
1557 });
1558 }
1559 continue;
1560 }
1561 if (event.type === "dialogue-choices")
1562 {
1563 const session = event.sessionId != null
1564 ? sessions.get(event.sessionId)
1565 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1566 if (session)
1567 {
1568 send(session, {
1569 type: MessageType.dialogueChoices,
1570 dialogueId: event.dialogueId,
1571 stepId: event.stepId,
1572 npcEntityId: event.npcEntityId ?? null,
1573 triggers: event.triggers ?? []
1574 });
1575 }
1576 continue;
1577 }
1578 if (event.type === "dialogue-close")
1579 {
1580 const session = event.sessionId != null
1581 ? sessions.get(event.sessionId)
1582 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1583 if (session)
1584 {
1585 send(session, {
1586 type: MessageType.dialogueClose,
1587 reason: event.reason ?? null
1588 });
1589 }
1590 continue;
1591 }
1592 if (event.type === "pigeon-delivered")
1593 {
1594 for (const session of sessions.values())
1595 {
1596 if (session.characterId === event.senderCharacterId
1597 || session.characterId === event.destinationCharacterId)
1598 {
1599 send(session, {
1600 type: MessageType.pigeonDelivered,
1601 courierId: event.courierId,
1602 destinationKind: event.destinationKind,
1603 cargo: event.cargo
1604 });
1605 }
1606 }
1607 continue;
1608 }
1609 if (event.type === "player-died")
1610 {
1611 const session = sessions.get(event.sessionId);
1612 if (session)
1613 {
1614 send(session, {
1615 type: MessageType.playerDied,
1616 entityId: event.entityId,
1617 characterId: event.characterId
1618 });
1619 }
1620 continue;
1621 }
1622 if (event.type === "player-respawned")
1623 {
1624 const session = sessions.get(event.sessionId);
1625 if (session)
1626 {
1627 send(session, {
1628 type: MessageType.playerRespawned,
1629 entityId: event.entityId,
1630 characterId: event.characterId,
1631 tileX: event.tileX,
1632 tileY: event.tileY,
1633 health: event.health,
1634 maxHealth: event.maxHealth,
1635 stamina: event.stamina,
1636 maxStamina: event.maxStamina,
1637 skullValue: event.skullValue | 0
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}