BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 59.8 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.editorRestartNow:
944 requireAdmin(session);
945 deploy?.requestRestartNow?.("admin-editor");
946 break;
947 case MessageType.editorLoadQuests:
948 requireAdmin(session);
949 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
950 break;
951 case MessageType.editorSaveQuest:
952 requireAdmin(session);
953 send(session, {
954 type: MessageType.editorQuests,
955 ...editor.saveQuest(message.quest ?? message, session.authSubject)
956 });
957 break;
958 case MessageType.editorDeleteQuest:
959 requireAdmin(session);
960 send(session, {
961 type: MessageType.editorQuests,
962 ...editor.deleteQuest(message.questId, session.authSubject)
963 });
964 break;
965 case MessageType.editorLoadDialogues:
966 requireAdmin(session);
967 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
968 break;
969 case MessageType.editorSaveDialogue:
970 requireAdmin(session);
971 send(session, {
972 type: MessageType.editorDialogues,
973 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
974 });
975 break;
976 case MessageType.editorDeleteDialogue:
977 requireAdmin(session);
978 send(session, {
979 type: MessageType.editorDialogues,
980 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
981 });
982 break;
983 case MessageType.dialogueChoose:
984 requirePlaying(session);
985 simulation.enqueue(session.id, {
986 type: "dialogue-choose",
987 characterId: session.characterId,
988 trigger: String(message.trigger ?? "")
989 });
990 break;
991 case MessageType.dialogueAdvance:
992 requirePlaying(session);
993 simulation.enqueue(session.id, {
994 type: "dialogue-advance",
995 characterId: session.characterId
996 });
997 break;
998 case MessageType.closeDialogue:
999 requirePlaying(session);
1000 simulation.enqueue(session.id, {
1001 type: "close-dialogue",
1002 characterId: session.characterId
1003 });
1004 break;
1005 case MessageType.requestQuests:
1006 requirePlaying(session);
1007 simulation.enqueue(session.id, {
1008 type: "request-quests",
1009 characterId: session.characterId
1010 });
1011 break;
1012 case MessageType.setGraphicsSettings:
1013 {
1014 const next = normalizeGraphicsSettings({
1015 viewDistance: message.viewDistance ?? session.viewDistance
1016 });
1017 const changed = next.viewDistance !== session.viewDistance;
1018 session.viewDistance = next.viewDistance;
1019 if (changed && session.entityId)
1020 { syncSubscriptions(session, true); }
1021 }
1022 break;
1023 default:
1024 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
1025 }
1026 }
1027
1028 function enterWorld (session, characterId)
1029 {
1030 if (draining || deploy?.isDraining?.())
1031 {
1032 const error = new Error("The server is restarting for an update. Please try again in a moment.");
1033 error.userFacing = true;
1034 throw error;
1035 }
1036 leaveWorld(session);
1037 const character = characters.getOwned(session.account.account_id, characterId);
1038 if (character.deletion_scheduled_at)
1039 {
1040 const error = new Error("That character is marked for deletion.");
1041 error.userFacing = true;
1042 throw error;
1043 }
1044 for (const other of sessions.values())
1045 {
1046 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
1047 {
1048 const error = new Error("This account already has a character in the world.");
1049 error.userFacing = true;
1050 throw error;
1051 }
1052 }
1053 session.characterId = character.character_id;
1054 session.entityId = simulation.spawnCharacter(session.id, character);
1055 const spawned = simulation.entityRecord(session.entityId);
1056 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
1057 const dimRecord = simulation.getDimensionRecord?.(enterDim);
1058 send(session, {
1059 type: MessageType.enterWorld,
1060 entityId: session.entityId,
1061 characterId: session.characterId,
1062 tileX: spawned.tileX,
1063 tileY: spawned.tileY,
1064 dimensionId: enterDim,
1065 lightingMode: dimRecord?.lightingMode ?? "dayNight",
1066 seasonMode: dimRecord?.seasonMode ?? "auto",
1067 gait: spawned.gait,
1068 sex: spawned.sex,
1069 firstName: spawned.firstName,
1070 lastName: spawned.lastName,
1071 layers: spawned.layers ?? [],
1072 health: spawned.health,
1073 maxHealth: spawned.maxHealth,
1074 settings: simulation.settings,
1075 worldTime: simulation.worldTime(),
1076 restartStatus: deploy?.getStatus?.() ?? { scheduled: false }
1077 });
1078 syncSubscriptions(session, true);
1079 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
1080 const bag = simulation.bagOf(session.entityId);
1081 if (bag)
1082 { send(session, { type: MessageType.inventory, ...bag }); }
1083 const skills = simulation.skillsOf(session.entityId);
1084 if (skills)
1085 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
1086 const spellView = simulation.spellsOf(session.entityId);
1087 if (spellView)
1088 {
1089 send(session, {
1090 type: MessageType.spells,
1091 spells: spellView.spells,
1092 autoCast: spellView.autoCast,
1093 armedSpellId: spellView.armedSpellId ?? null
1094 });
1095 }
1096 const stamina = simulation.staminaOf(session.entityId);
1097 if (stamina)
1098 {
1099 send(session, {
1100 type: MessageType.stamina,
1101 current: stamina.current,
1102 max: stamina.max,
1103 gait: stamina.gait
1104 });
1105 }
1106 if (character.is_dead)
1107 {
1108 send(session, {
1109 type: MessageType.playerDied,
1110 entityId: session.entityId,
1111 characterId: session.characterId
1112 });
1113 }
1114 publishReplication(simulation.drainReplication());
1115 }
1116
1117 function leaveWorld (session)
1118 {
1119 if (session.characterId)
1120 { simulation.despawnCharacter(session.characterId); }
1121 publishReplication(simulation.drainReplication());
1122 session.characterId = null;
1123 session.entityId = null;
1124 session.entitySubscribed.clear();
1125 session.staticSubscribed.clear();
1126 }
1127
1128 function syncSubscriptions (session, forceSnapshots)
1129 {
1130 if (!session.entityId)
1131 { return; }
1132 const position = simulation.positionOf(session.entityId);
1133 if (!position)
1134 { return; }
1135
1136 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1137 const centerChunkX = tileToChunk(position.tileX);
1138 const centerChunkY = tileToChunk(position.tileY);
1139 const mapRadius = staticChunkRadiusForViewDistance(
1140 session.viewDistance,
1141 STATIC_CHUNK_RADIUS,
1142 VISIBLE_CHUNK_RADIUS
1143 );
1144 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1145 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1146 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1147 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1148
1149 for (const key of session.staticSubscribed)
1150 {
1151 if (!staticNext.has(key))
1152 {
1153 const { chunkX, chunkY } = parseChunkKey(key);
1154 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1155 }
1156 }
1157
1158 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1159 for (const snapshot of snapshots)
1160 {
1161 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1162 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1163 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1164 {
1165 const groundItems = (snapshot.groundItems ?? []).filter((item) =>
1166 canCharacterSeeGroundItem(item, session.characterId)
1167 );
1168 send(session, { type: MessageType.chunkSnapshot, ...snapshot, groundItems });
1169 }
1170 }
1171 session.entitySubscribed = entityNext;
1172 session.staticSubscribed = staticNext;
1173 }
1174
1175 function requirePlaying (session)
1176 {
1177 if (!session.characterId)
1178 {
1179 const error = new Error("Select a character first.");
1180 error.userFacing = true;
1181 throw error;
1182 }
1183 }
1184
1185 function userError (message)
1186 {
1187 const error = new Error(message);
1188 error.userFacing = true;
1189 return error;
1190 }
1191
1192 function listPublicGameAdmins ()
1193 {
1194 return stateDb.listGameAdmins().map((row) => ({
1195 authSubject: row.auth_subject,
1196 username: row.username ?? null,
1197 email: row.email ?? null
1198 }));
1199 }
1200
1201 function refreshAccountAdminSessions (authSubject)
1202 {
1203 const account = stateDb.getAccountBySubject(authSubject);
1204 if (!account)
1205 { return; }
1206 for (const session of sessions.values())
1207 {
1208 if (session.authSubject !== authSubject)
1209 { continue; }
1210 session.account = account;
1211 send(session, {
1212 type: MessageType.session,
1213 accountId: account.account_id,
1214 authSubject: account.auth_subject,
1215 username: session.username ?? account.username ?? null,
1216 email: account.email ?? null,
1217 isAdmin: !!account.is_admin,
1218 characters: characters.list(account.account_id)
1219 });
1220 }
1221 }
1222
1223 function requireAdmin (session)
1224 {
1225 if (!session.account.is_admin)
1226 {
1227 const error = new Error("Admin only.");
1228 error.userFacing = true;
1229 throw error;
1230 }
1231 }
1232
1233 function broadcastStatus ()
1234 {
1235 const worldTime = simulation.worldTime();
1236 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1237 for (const session of sessions.values())
1238 {
1239 if (session.entityId)
1240 {
1241 send(session, {
1242 type: MessageType.worldStatus,
1243 worldTime,
1244 settings: simulation.settings,
1245 activeRevisionId: simulation.activeRevisionId,
1246 restartStatus
1247 });
1248 }
1249 }
1250 }
1251
1252 function broadcastRestartStatus ()
1253 {
1254 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1255 for (const session of sessions.values())
1256 {
1257 if (session.entityId)
1258 { send(session, { type: MessageType.restartStatus, restartStatus }); }
1259 }
1260 }
1261
1262 function pushFriends (...characterIds)
1263 {
1264 const seen = new Set();
1265 for (const characterId of characterIds)
1266 {
1267 const id = Number(characterId);
1268 if (!id || seen.has(id))
1269 { continue; }
1270 seen.add(id);
1271 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
1272 for (const session of sessions.values())
1273 {
1274 if (session.characterId === id)
1275 { send(session, payload); }
1276 }
1277 }
1278 }
1279
1280 function broadcastSettings (payload)
1281 {
1282 for (const session of sessions.values())
1283 {
1284 if (session.account.is_admin)
1285 { send(session, { type: MessageType.editorSettings, ...payload }); }
1286 }
1287 }
1288
1289 function onTickResult (result)
1290 {
1291 publishReplication(result.replication ?? []);
1292 for (const event of result.events)
1293 {
1294 if (event.type === "command-error")
1295 {
1296 const session = sessions.get(event.sessionId);
1297 if (session)
1298 { send(session, { type: MessageType.error, message: event.message }); }
1299 continue;
1300 }
1301 if (event.type === "inventory")
1302 {
1303 const session = event.sessionId != null
1304 ? sessions.get(event.sessionId)
1305 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1306 if (!session)
1307 { continue; }
1308 send(session, {
1309 type: MessageType.inventory,
1310 inventory: event.inventory,
1311 equipment: event.equipment,
1312 vault: event.vault,
1313 vaultReserved: event.vaultReserved
1314 });
1315 if (event.bank)
1316 {
1317 send(session, {
1318 type: MessageType.bankSnapshot,
1319 vault: event.vault,
1320 vaultReserved: event.vaultReserved,
1321 inheritance: stateDb.getInheritance(session.account.account_id)
1322 });
1323 }
1324 if (event.cauldron != null)
1325 {
1326 send(session, {
1327 type: MessageType.cauldronSnapshot,
1328 open: !!event.cauldron,
1329 state: event.cauldronState ?? null,
1330 alchemyResult: event.alchemyResult ?? null,
1331 dyeConfirm: event.dyeConfirm ?? null
1332 });
1333 }
1334 continue;
1335 }
1336 if (event.type === "skills")
1337 {
1338 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1339 if (!session)
1340 { continue; }
1341 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
1342 continue;
1343 }
1344 if (event.type === "spells")
1345 {
1346 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1347 if (!session)
1348 { continue; }
1349 send(session, {
1350 type: MessageType.spellsUpdated,
1351 spells: event.spells ?? [],
1352 autoCast: !!event.autoCast,
1353 armedSpellId: event.armedSpellId ?? null
1354 });
1355 continue;
1356 }
1357 if (event.type === "spell-armed")
1358 {
1359 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1360 if (!session)
1361 { continue; }
1362 send(session, {
1363 type: MessageType.spellArmed,
1364 spellId: event.spellId
1365 });
1366 continue;
1367 }
1368 if (event.type === "spell-disarmed")
1369 {
1370 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1371 if (!session)
1372 { continue; }
1373 send(session, { type: MessageType.spellDisarmed });
1374 continue;
1375 }
1376 if (event.type === "stamina")
1377 {
1378 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1379 if (!session)
1380 { continue; }
1381 send(session, {
1382 type: MessageType.stamina,
1383 current: event.current,
1384 max: event.max,
1385 gait: event.gait
1386 });
1387 continue;
1388 }
1389 if (event.type === "status-effects")
1390 {
1391 const session = event.sessionId != null
1392 ? sessions.get(event.sessionId)
1393 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1394 if (!session)
1395 { continue; }
1396 send(session, {
1397 type: MessageType.statusEffects,
1398 effects: event.effects ?? [],
1399 blind: !!event.blind
1400 });
1401 continue;
1402 }
1403 if (event.type === "toast")
1404 {
1405 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1406 if (session)
1407 { send(session, { type: MessageType.toast, message: event.message }); }
1408 continue;
1409 }
1410 if (event.type === "quests-snapshot")
1411 {
1412 const session = event.sessionId != null
1413 ? sessions.get(event.sessionId)
1414 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1415 if (session)
1416 {
1417 send(session, {
1418 type: MessageType.questsSnapshot,
1419 quests: event.quests ?? []
1420 });
1421 }
1422 continue;
1423 }
1424 if (event.type === "quest-step-complete")
1425 {
1426 const session = event.sessionId != null
1427 ? sessions.get(event.sessionId)
1428 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1429 if (session)
1430 {
1431 send(session, {
1432 type: MessageType.questStepComplete,
1433 questId: event.questId,
1434 title: event.title
1435 });
1436 }
1437 continue;
1438 }
1439 if (event.type === "dialogue-step")
1440 {
1441 const session = event.sessionId != null
1442 ? sessions.get(event.sessionId)
1443 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1444 if (session)
1445 {
1446 send(session, {
1447 type: MessageType.dialogueStep,
1448 dialogueId: event.dialogueId,
1449 stepId: event.stepId,
1450 label: event.label,
1451 npcEntityId: event.npcEntityId ?? null,
1452 lines: event.lines ?? []
1453 });
1454 }
1455 continue;
1456 }
1457 if (event.type === "dialogue-choices")
1458 {
1459 const session = event.sessionId != null
1460 ? sessions.get(event.sessionId)
1461 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1462 if (session)
1463 {
1464 send(session, {
1465 type: MessageType.dialogueChoices,
1466 dialogueId: event.dialogueId,
1467 stepId: event.stepId,
1468 npcEntityId: event.npcEntityId ?? null,
1469 triggers: event.triggers ?? []
1470 });
1471 }
1472 continue;
1473 }
1474 if (event.type === "dialogue-close")
1475 {
1476 const session = event.sessionId != null
1477 ? sessions.get(event.sessionId)
1478 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1479 if (session)
1480 {
1481 send(session, {
1482 type: MessageType.dialogueClose,
1483 reason: event.reason ?? null
1484 });
1485 }
1486 continue;
1487 }
1488 if (event.type === "pigeon-delivered")
1489 {
1490 for (const session of sessions.values())
1491 {
1492 if (session.characterId === event.senderCharacterId
1493 || session.characterId === event.destinationCharacterId)
1494 {
1495 send(session, {
1496 type: MessageType.pigeonDelivered,
1497 courierId: event.courierId,
1498 destinationKind: event.destinationKind,
1499 cargo: event.cargo
1500 });
1501 }
1502 }
1503 continue;
1504 }
1505 if (event.type === "player-died")
1506 {
1507 const session = sessions.get(event.sessionId);
1508 if (session)
1509 {
1510 send(session, {
1511 type: MessageType.playerDied,
1512 entityId: event.entityId,
1513 characterId: event.characterId
1514 });
1515 }
1516 continue;
1517 }
1518 if (event.type === "player-respawned")
1519 {
1520 const session = sessions.get(event.sessionId);
1521 if (session)
1522 {
1523 send(session, {
1524 type: MessageType.playerRespawned,
1525 entityId: event.entityId,
1526 characterId: event.characterId,
1527 tileX: event.tileX,
1528 tileY: event.tileY,
1529 health: event.health,
1530 maxHealth: event.maxHealth,
1531 stamina: event.stamina,
1532 maxStamina: event.maxStamina
1533 });
1534 }
1535 continue;
1536 }
1537 if (event.type === "dimension-changed")
1538 {
1539 const session = sessions.get(event.sessionId);
1540 if (session)
1541 {
1542 session.entitySubscribed.clear();
1543 session.staticSubscribed.clear();
1544 send(session, {
1545 type: MessageType.dimensionChanged,
1546 dimensionId: event.dimensionId,
1547 tileX: event.tileX,
1548 tileY: event.tileY,
1549 lightingMode: event.lightingMode,
1550 seasonMode: event.seasonMode
1551 });
1552 syncSubscriptions(session, true);
1553 }
1554 continue;
1555 }
1556 if (event.type === "combat-no-arrows")
1557 {
1558 const session = sessions.get(event.sessionId);
1559 if (session)
1560 { send(session, { type: MessageType.combatNoArrows }); }
1561 continue;
1562 }
1563 if (event.type === "craft-result")
1564 {
1565 const session = sessions.get(event.sessionId);
1566 if (session)
1567 {
1568 send(session, {
1569 type: MessageType.craftResult,
1570 recipeId: event.recipeId,
1571 ok: !!event.ok,
1572 error: event.error ?? null,
1573 burned: !!event.burned,
1574 continuing: !!event.continuing
1575 });
1576 }
1577 continue;
1578 }
1579 if (event.type === "station-open")
1580 {
1581 const session = sessions.get(event.sessionId);
1582 if (session)
1583 {
1584 send(session, {
1585 type: MessageType.stationOpen,
1586 stationId: event.stationId
1587 });
1588 }
1589 continue;
1590 }
1591 if (event.type === "shop-open")
1592 {
1593 const session = sessions.get(event.sessionId);
1594 if (session)
1595 {
1596 send(session, {
1597 type: MessageType.shopOpen,
1598 npcEntityId: event.npcEntityId,
1599 displayName: event.displayName,
1600 sex: event.sex === "female" ? "female" : "male",
1601 buysItems: !!event.buysItems,
1602 stock: event.stock ?? []
1603 });
1604 }
1605 continue;
1606 }
1607 if (event.type === "shop-closed")
1608 {
1609 const session = sessions.get(event.sessionId);
1610 if (session)
1611 {
1612 send(session, {
1613 type: MessageType.shopClosed,
1614 npcEntityId: event.npcEntityId
1615 });
1616 }
1617 continue;
1618 }
1619 if (event.type === "market-open")
1620 {
1621 const session = sessions.get(event.sessionId);
1622 if (session)
1623 {
1624 send(session, {
1625 type: MessageType.marketOpen,
1626 displayName: event.displayName,
1627 orders: event.orders ?? [],
1628 catalog: event.catalog ?? []
1629 });
1630 }
1631 continue;
1632 }
1633 if (event.type === "market-closed")
1634 {
1635 const session = sessions.get(event.sessionId);
1636 if (session)
1637 { send(session, { type: MessageType.marketClosed }); }
1638 continue;
1639 }
1640 if (event.type === "bounty-snapshot")
1641 {
1642 const session = sessions.get(event.sessionId);
1643 if (session)
1644 {
1645 send(session, {
1646 type: MessageType.bountySnapshot,
1647 myAmountCopper: event.myAmountCopper | 0,
1648 myAmountLabel: event.myAmountLabel ?? "",
1649 message: event.message ?? "",
1650 raised: event.raised ?? null
1651 });
1652 }
1653 continue;
1654 }
1655 if (event.type === "bounty-closed")
1656 {
1657 const session = sessions.get(event.sessionId);
1658 if (session)
1659 { send(session, { type: MessageType.closeBounty }); }
1660 continue;
1661 }
1662 if (event.type === "character-bounty")
1663 {
1664 const session = sessions.get(event.sessionId);
1665 if (session)
1666 {
1667 send(session, {
1668 type: MessageType.characterBounty,
1669 target: event.target ?? null
1670 });
1671 }
1672 continue;
1673 }
1674 if (event.type === "barber-snapshot")
1675 {
1676 const session = sessions.get(event.sessionId);
1677 if (session)
1678 {
1679 send(session, {
1680 type: MessageType.barberSnapshot,
1681 sex: event.sex,
1682 styles: event.styles ?? [],
1683 hair: event.hair ?? null,
1684 message: event.message ?? ""
1685 });
1686 }
1687 continue;
1688 }
1689 if (event.type === "barber-closed")
1690 {
1691 const session = sessions.get(event.sessionId);
1692 if (session)
1693 { send(session, { type: MessageType.closeBarber }); }
1694 continue;
1695 }
1696 if (event.type === "market-trade")
1697 {
1698 for (const session of sessions.values())
1699 {
1700 if (
1701 session.characterId === event.buyerCharacterId
1702 || session.characterId === event.sellerCharacterId
1703 )
1704 {
1705 send(session, {
1706 type: MessageType.marketTrade,
1707 itemId: event.itemId,
1708 quantity: event.quantity,
1709 unitPrice: event.unitPrice,
1710 triggeringSide: event.triggeringSide
1711 });
1712 }
1713 }
1714 continue;
1715 }
1716 if (event.type === "item-bubble")
1717 {
1718 broadcastItemBubble(
1719 sessions,
1720 simulation,
1721 event.entityId,
1722 event.itemId,
1723 event.quantity
1724 );
1725 continue;
1726 }
1727 if (event.type === "gather-swing" || event.type === "tile-shove")
1728 {
1729 publishEntity({
1730 ...event,
1731 type: event.type
1732 });
1733 continue;
1734 }
1735 if (event.type === "chunk-delta")
1736 {
1737 publishEntity(event);
1738 continue;
1739 }
1740 if (event.type === "gather-complete")
1741 {
1742 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1743 if (session)
1744 {
1745 send(session, {
1746 type: MessageType.gatherComplete,
1747 kind: event.kind,
1748 materialId: event.materialId,
1749 itemId: event.itemId
1750 });
1751 }
1752 continue;
1753 }
1754 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")
1755 { publishEntity(event); }
1756 }
1757 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1758 { broadcastStatus(); }
1759 }
1760
1761 function publishReplication (events)
1762 {
1763 for (const event of events ?? [])
1764 { publishEntity(event); }
1765 }
1766
1767 function publishEntity (event)
1768 {
1769 const toDim = normalizeDimensionId(event.dimensionId
1770 ?? simulation.entityRecord(event.entityId)?.dimensionId
1771 ?? OVERWORLD_ID);
1772 const fromDim = event.fromDimensionId != null
1773 ? normalizeDimensionId(event.fromDimensionId)
1774 : toDim;
1775 const fromKey = event.fromTileX != null
1776 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
1777 : null;
1778 const toKey = event.tileX != null
1779 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
1780 : null;
1781 for (const session of sessions.values())
1782 {
1783 if (!session.entityId)
1784 { continue; }
1785 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1786 const seesTo = session.entitySubscribed.has(toKey);
1787 const seesStaticTo = session.staticSubscribed.has(toKey);
1788 if (event.type === "entity-spawn")
1789 {
1790 if (session.entityId === event.entityId || !seesTo)
1791 { continue; }
1792 send(session, spawnPayload(event));
1793 continue;
1794 }
1795 if (event.type === "entity-despawn")
1796 {
1797 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1798 { continue; }
1799 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1800 continue;
1801 }
1802 if (event.type === "entity-appearance")
1803 {
1804 if (!seesTo)
1805 { continue; }
1806 send(session, {
1807 type: MessageType.entityAppearance,
1808 entityId: event.entityId,
1809 sprite: event.sprite,
1810 layers: event.layers ?? [],
1811 lightRadiusTiles: event.lightRadiusTiles ?? 0
1812 });
1813 continue;
1814 }
1815 if (event.type === "ground-item-appear")
1816 {
1817 if (!seesTo)
1818 { continue; }
1819 if (!canCharacterSeeGroundItem(event, session.characterId))
1820 { continue; }
1821 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1822 continue;
1823 }
1824 if (event.type === "ground-item-despawn")
1825 {
1826 if (!seesTo)
1827 { continue; }
1828 if (!canCharacterSeeGroundItem(event, session.characterId))
1829 { continue; }
1830 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1831 continue;
1832 }
1833 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1834 {
1835 if (!seesTo && !seesFrom)
1836 { continue; }
1837 const type = event.type === "combat-swing"
1838 ? MessageType.combatSwing
1839 : event.type === "combat-hit"
1840 ? MessageType.combatHit
1841 : event.type === "combat-block"
1842 ? MessageType.combatBlock
1843 : MessageType.combatMiss;
1844 send(session, {
1845 type,
1846 attackerId: event.attackerId,
1847 targetId: event.targetId,
1848 damage: event.damage,
1849 health: event.health,
1850 maxHealth: event.maxHealth,
1851 tileX: event.tileX,
1852 tileY: event.tileY,
1853 fromTileX: event.fromTileX,
1854 fromTileY: event.fromTileY
1855 });
1856 continue;
1857 }
1858 if (event.type === "combat-projectile")
1859 {
1860 if (!seesTo && !seesFrom)
1861 { continue; }
1862 send(session, {
1863 type: MessageType.combatProjectile,
1864 attackerId: event.attackerId,
1865 targetId: event.targetId,
1866 fromTileX: event.fromTileX,
1867 fromTileY: event.fromTileY,
1868 tileX: event.tileX,
1869 tileY: event.tileY,
1870 durationMs: event.durationMs ?? 400,
1871 trackTarget: event.trackTarget !== false,
1872 shaftTint: event.shaftTint ?? null,
1873 tipTint: event.tipTint ?? null
1874 });
1875 continue;
1876 }
1877 if (event.type === "spell-projectile")
1878 {
1879 if (!seesTo && !seesFrom)
1880 { continue; }
1881 send(session, {
1882 type: MessageType.spellProjectile,
1883 casterId: event.casterId,
1884 targetId: event.targetId ?? null,
1885 spellId: event.spellId,
1886 fromTileX: event.fromTileX,
1887 fromTileY: event.fromTileY,
1888 tileX: event.tileX,
1889 tileY: event.tileY,
1890 durationMs: event.durationMs ?? 2000,
1891 sprite: event.sprite ?? null
1892 });
1893 continue;
1894 }
1895 if (event.type === "spell-fizzle")
1896 {
1897 if (!seesTo && !seesFrom)
1898 { continue; }
1899 send(session, {
1900 type: MessageType.spellFizzle,
1901 casterId: event.casterId,
1902 spellId: event.spellId,
1903 fromTileX: event.fromTileX,
1904 fromTileY: event.fromTileY,
1905 tileX: event.tileX,
1906 tileY: event.tileY
1907 });
1908 continue;
1909 }
1910 if (event.type === "spell-cast-flash")
1911 {
1912 if (!seesTo)
1913 { continue; }
1914 send(session, {
1915 type: MessageType.spellCastFlash,
1916 casterId: event.casterId,
1917 tileX: event.tileX,
1918 tileY: event.tileY,
1919 radiusTiles: event.radiusTiles ?? 1,
1920 durationMs: event.durationMs ?? 500,
1921 tier: event.tier ?? 1
1922 });
1923 continue;
1924 }
1925 if (event.type === "spell-light-appear" || event.type === "spell-light-update")
1926 {
1927 if (!seesTo)
1928 { continue; }
1929 send(session, {
1930 type: event.type === "spell-light-appear"
1931 ? MessageType.spellLightAppear
1932 : MessageType.spellLightUpdate,
1933 tileX: event.tileX,
1934 tileY: event.tileY,
1935 ownerEntityId: event.ownerEntityId,
1936 remainingMs: event.remainingMs ?? 0,
1937 rangeTiles: event.rangeTiles ?? 0,
1938 intensity: event.intensity ?? 0,
1939 expiresAt: event.expiresAt ?? 0
1940 });
1941 continue;
1942 }
1943 if (event.type === "spell-light-remove")
1944 {
1945 if (!seesTo)
1946 { continue; }
1947 send(session, {
1948 type: MessageType.spellLightRemove,
1949 tileX: event.tileX,
1950 tileY: event.tileY
1951 });
1952 continue;
1953 }
1954 if (event.type === "entity-health")
1955 {
1956 if (!seesTo && !seesFrom)
1957 { continue; }
1958 send(session, {
1959 type: MessageType.entityHealth,
1960 entityId: event.entityId,
1961 health: event.health,
1962 maxHealth: event.maxHealth
1963 });
1964 continue;
1965 }
1966 if (event.type === "gather-swing" || event.type === "tile-shove")
1967 {
1968 if (!seesTo && !seesFrom)
1969 { continue; }
1970 if (event.type === "gather-swing")
1971 {
1972 send(session, {
1973 type: MessageType.gatherSwing,
1974 attackerId: event.attackerId,
1975 tileX: event.tileX,
1976 tileY: event.tileY,
1977 fromTileX: event.fromTileX,
1978 fromTileY: event.fromTileY,
1979 toolItemId: event.toolItemId ?? null
1980 });
1981 }
1982 else
1983 {
1984 send(session, {
1985 type: MessageType.tileShove,
1986 attackerId: event.attackerId,
1987 tileX: event.tileX,
1988 tileY: event.tileY,
1989 fromTileX: event.fromTileX,
1990 fromTileY: event.fromTileY
1991 });
1992 }
1993 continue;
1994 }
1995 if (event.type === "skill-level-up")
1996 {
1997 if (session.entityId !== event.entityId && !seesTo)
1998 { continue; }
1999 send(session, {
2000 type: MessageType.skillLevelUp,
2001 entityId: event.entityId,
2002 characterId: event.characterId,
2003 skillId: event.skillId,
2004 level: event.level,
2005 displayName: event.displayName,
2006 icon: event.icon
2007 });
2008 continue;
2009 }
2010 if (event.type === "chunk-delta")
2011 {
2012 if (!seesStaticTo)
2013 { continue; }
2014 send(session, {
2015 type: MessageType.chunkDelta,
2016 chunkX: event.chunkX,
2017 chunkY: event.chunkY,
2018 tiles: [{
2019 localX: event.localX,
2020 localY: event.localY,
2021 block: event.block
2022 }]
2023 });
2024 continue;
2025 }
2026 if (event.type !== "entity-move")
2027 { continue; }
2028 if (seesTo)
2029 {
2030 if (!seesFrom)
2031 { send(session, spawnPayload(event)); }
2032 else
2033 {
2034 send(session, {
2035 type: MessageType.entityMove,
2036 entityId: event.entityId,
2037 tileX: event.tileX,
2038 tileY: event.tileY,
2039 worldX: event.worldX,
2040 worldY: event.worldY,
2041 gait: event.gait,
2042 lerpMs: event.lerpMs,
2043 freeFlight: !!event.freeFlight
2044 });
2045 }
2046 }
2047 else if (seesFrom)
2048 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
2049 if (session.entityId === event.entityId)
2050 {
2051 const crossedDimension = event.fromDimensionId != null
2052 && event.dimensionId != null
2053 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
2054 if (!crossedDimension)
2055 { syncSubscriptions(session, false); }
2056 }
2057 }
2058 }
2059
2060 function spawnPayload (event)
2061 {
2062 const record = simulation.entityRecord(event.entityId) ?? event;
2063 return {
2064 type: MessageType.entitySpawn,
2065 entityId: event.entityId,
2066 characterId: record.characterId ?? event.characterId ?? null,
2067 tileX: event.tileX ?? record.tileX,
2068 tileY: event.tileY ?? record.tileY,
2069 worldX: event.worldX ?? record.worldX,
2070 worldY: event.worldY ?? record.worldY,
2071 gait: event.gait ?? record.gait,
2072 sex: record.sex ?? event.sex ?? null,
2073 firstName: record.firstName ?? event.firstName ?? "",
2074 lastName: record.lastName ?? event.lastName ?? "",
2075 sprite: record.sprite ?? event.sprite ?? null,
2076 layers: record.layers ?? event.layers ?? [],
2077 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
2078 canFight: !!(record.canFight ?? event.canFight),
2079 hostile: !!(record.hostile ?? event.hostile),
2080 talkable: !!(record.talkable ?? event.talkable),
2081 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
2082 hasShop: !!(record.hasShop ?? event.hasShop),
2083 untargetable: !!(record.untargetable ?? event.untargetable),
2084 freeFlight: !!(record.freeFlight ?? event.freeFlight),
2085 health: record.health ?? event.health,
2086 maxHealth: record.maxHealth ?? event.maxHealth,
2087 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
2088 };
2089 }
2090
2091 return {
2092 sessions,
2093 onTickResult,
2094 wss,
2095 broadcastRestartStatus,
2096 setDraining (value)
2097 {
2098 draining = !!value;
2099 },
2100 async shutdown ()
2101 {
2102 draining = true;
2103 await Promise.all([...sessions.values()].map(async (session) =>
2104 {
2105 await sendAsync(session, {
2106 type: MessageType.forceLogout,
2107 reason: "Server shutting down."
2108 });
2109 leaveWorld(session);
2110 await closeAsync(session, 1001, "Server shutting down.");
2111 }));
2112 sessions.clear();
2113 await simulation.shutdown();
2114 }
2115 };
2116}
2117
2118function send (session, payload)
2119{
2120 if (session.socket.readyState === 1)
2121 { session.socket.send(JSON.stringify(payload)); }
2122}
2123
2124function sendAsync (session, payload)
2125{
2126 return new Promise((resolve) =>
2127 {
2128 if (session.socket.readyState !== 1)
2129 {
2130 resolve();
2131 return;
2132 }
2133 session.socket.send(JSON.stringify(payload), () => resolve());
2134 });
2135}
2136
2137function closeAsync (session, code, reason)
2138{
2139 return new Promise((resolve) =>
2140 {
2141 if (session.socket.readyState !== 1)
2142 {
2143 resolve();
2144 return;
2145 }
2146 session.socket.once("close", resolve);
2147 try
2148 { session.socket.close(code, reason); }
2149 catch
2150 { resolve(); }
2151 });
2152}