BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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