BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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