BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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