BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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