BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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