BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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