BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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