BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 73.3 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 { publicSkillsPayload } 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, gifts, 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 // Dead bodies may only respawn or leave the world — ignore all other intents.
140 return;
141 }
142 switch (message.type)
143 {
144 case MessageType.createCharacter:
145 {
146 const created = characters.create(
147 session.account,
148 message.firstName,
149 message.lastName,
150 message.sex,
151 message.hair ?? null,
152 simulation.settings,
153 message.clothing ?? null
154 );
155 enterWorld(session, created.characterId);
156 }
157 break;
158 case MessageType.selectCharacter:
159 enterWorld(session, message.characterId);
160 break;
161 case MessageType.scheduleDeleteCharacter:
162 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
163 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
164 break;
165 case MessageType.cancelDeleteCharacter:
166 characters.cancelDelete(session.account, message.characterId);
167 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
168 break;
169 case MessageType.leaveWorld:
170 leaveWorld(session);
171 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
172 break;
173 case MessageType.respawn:
174 requirePlaying(session);
175 simulation.enqueue(session.id, {
176 type: "respawn",
177 characterId: session.characterId
178 });
179 break;
180 case MessageType.moveTo:
181 requirePlaying(session);
182 simulation.enqueue(session.id, {
183 type: "move-to",
184 characterId: session.characterId,
185 tileX: message.tileX | 0,
186 tileY: message.tileY | 0
187 });
188 break;
189 case MessageType.setGait:
190 requirePlaying(session);
191 simulation.enqueue(session.id, {
192 type: "set-gait",
193 characterId: session.characterId,
194 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
195 });
196 break;
197 case MessageType.friendRequest:
198 requirePlaying(session);
199 friends.request(session.characterId, message.characterId);
200 pushFriends(session.characterId, message.characterId);
201 break;
202 case MessageType.friendAccept:
203 requirePlaying(session);
204 if (message.accountId)
205 { friends.acceptAccount(session.characterId, message.accountId); }
206 else
207 { friends.accept(session.characterId, message.characterId); }
208 pushFriends(session.characterId, message.characterId, message.accountId);
209 break;
210 case MessageType.friendDecline:
211 requirePlaying(session);
212 if (message.accountId)
213 { friends.declineAccount(session.characterId, message.accountId); }
214 else
215 { friends.decline(session.characterId, message.characterId); }
216 pushFriends(session.characterId, message.characterId, message.accountId);
217 break;
218 case MessageType.friendRemove:
219 requirePlaying(session);
220 if (message.accountId)
221 { friends.removeAccount(session.characterId, message.accountId); }
222 else
223 { friends.remove(session.characterId, message.characterId); }
224 pushFriends(session.characterId, message.characterId, message.accountId);
225 break;
226 case MessageType.chatSay:
227 requirePlaying(session);
228 broadcastSpeech(sessions, simulation, session, message.text);
229 break;
230 case MessageType.dropItem:
231 requirePlaying(session);
232 simulation.enqueue(session.id, {
233 type: "drop-item",
234 characterId: session.characterId,
235 slotIndex: message.slotIndex | 0,
236 quantity: message.quantity ?? null
237 });
238 break;
239 case MessageType.pickupItem:
240 requirePlaying(session);
241 simulation.enqueue(session.id, {
242 type: "pickup-item",
243 characterId: session.characterId,
244 groundItemId: message.groundItemId | 0
245 });
246 break;
247 case MessageType.equipItem:
248 requirePlaying(session);
249 simulation.enqueue(session.id, {
250 type: "equip-item",
251 characterId: session.characterId,
252 slotIndex: message.slotIndex | 0
253 });
254 break;
255 case MessageType.unequipItem:
256 requirePlaying(session);
257 simulation.enqueue(session.id, {
258 type: "unequip-item",
259 characterId: session.characterId,
260 equipSlot: message.equipSlot
261 });
262 break;
263 case MessageType.moveInventorySlot:
264 requirePlaying(session);
265 simulation.enqueue(session.id, {
266 type: "move-inventory-slot",
267 characterId: session.characterId,
268 fromSlotIndex: message.fromSlotIndex | 0,
269 toSlotIndex: message.toSlotIndex | 0
270 });
271 break;
272 case MessageType.eatItem:
273 requirePlaying(session);
274 simulation.enqueue(session.id, {
275 type: "eat-item",
276 characterId: session.characterId,
277 slotIndex: message.slotIndex | 0
278 });
279 break;
280 case MessageType.drinkItem:
281 requirePlaying(session);
282 simulation.enqueue(session.id, {
283 type: "drink-item",
284 characterId: session.characterId,
285 slotIndex: message.slotIndex | 0
286 });
287 break;
288 case MessageType.tipArrows:
289 requirePlaying(session);
290 simulation.enqueue(session.id, {
291 type: "tip-arrows",
292 characterId: session.characterId,
293 coatingSlotIndex: message.coatingSlotIndex | 0,
294 arrowSlotIndex: message.arrowSlotIndex | 0,
295 quantity: message.quantity | 0
296 });
297 break;
298 case MessageType.openBank:
299 requirePlaying(session);
300 simulation.enqueue(session.id, {
301 type: "open-bank",
302 characterId: session.characterId
303 });
304 break;
305 case MessageType.prayAtAltar:
306 requirePlaying(session);
307 simulation.enqueue(session.id, {
308 type: "pray-at-altar",
309 characterId: session.characterId,
310 tileX: message.tileX | 0,
311 tileY: message.tileY | 0
312 });
313 break;
314 case MessageType.enterDoorway:
315 requirePlaying(session);
316 simulation.enqueue(session.id, {
317 type: "enter-doorway",
318 characterId: session.characterId,
319 tileX: message.tileX | 0,
320 tileY: message.tileY | 0
321 });
322 break;
323 case MessageType.openBounty:
324 requirePlaying(session);
325 simulation.enqueue(session.id, {
326 type: "open-bounty",
327 characterId: session.characterId
328 });
329 break;
330 case MessageType.raiseBounty:
331 requirePlaying(session);
332 simulation.enqueue(session.id, {
333 type: "raise-bounty",
334 characterId: session.characterId,
335 firstName: message.firstName,
336 lastName: message.lastName,
337 amountCopper: message.amountCopper
338 });
339 break;
340 case MessageType.payBounty:
341 requirePlaying(session);
342 simulation.enqueue(session.id, {
343 type: "pay-bounty",
344 characterId: session.characterId,
345 amountCopper: message.amountCopper
346 });
347 break;
348 case MessageType.getCharacterBounty:
349 requirePlaying(session);
350 simulation.enqueue(session.id, {
351 type: "get-character-bounty",
352 characterId: session.characterId,
353 targetCharacterId: message.characterId,
354 firstName: message.firstName,
355 lastName: message.lastName
356 });
357 break;
358 case MessageType.closeBounty:
359 requirePlaying(session);
360 simulation.enqueue(session.id, {
361 type: "close-bounty",
362 characterId: session.characterId
363 });
364 break;
365 case MessageType.openBarber:
366 requirePlaying(session);
367 simulation.enqueue(session.id, {
368 type: "open-barber",
369 characterId: session.characterId
370 });
371 break;
372 case MessageType.setHair:
373 requirePlaying(session);
374 simulation.enqueue(session.id, {
375 type: "set-hair",
376 characterId: session.characterId,
377 hair: message.hair ?? null
378 });
379 break;
380 case MessageType.closeBarber:
381 requirePlaying(session);
382 simulation.enqueue(session.id, {
383 type: "close-barber",
384 characterId: session.characterId
385 });
386 break;
387 case MessageType.openCauldron:
388 requirePlaying(session);
389 simulation.enqueue(session.id, {
390 type: "open-cauldron",
391 characterId: session.characterId
392 });
393 break;
394 case MessageType.openFurnace:
395 requirePlaying(session);
396 simulation.enqueue(session.id, {
397 type: "open-station",
398 characterId: session.characterId,
399 stationId: CraftingStationId.furnace
400 });
401 break;
402 case MessageType.openStation:
403 {
404 requirePlaying(session);
405 const stationId = typeof message.stationId === "string"
406 ? message.stationId
407 : null;
408 if (!stationId || !craftingStationDefinition(stationId))
409 { break; }
410 simulation.enqueue(session.id, {
411 type: "open-station",
412 characterId: session.characterId,
413 stationId
414 });
415 break;
416 }
417 case MessageType.mine:
418 requirePlaying(session);
419 simulation.enqueue(session.id, {
420 type: "mine",
421 characterId: session.characterId,
422 tileX: message.tileX | 0,
423 tileY: message.tileY | 0
424 });
425 break;
426 case MessageType.chop:
427 requirePlaying(session);
428 simulation.enqueue(session.id, {
429 type: "chop",
430 characterId: session.characterId,
431 tileX: message.tileX | 0,
432 tileY: message.tileY | 0
433 });
434 break;
435 case MessageType.pick:
436 requirePlaying(session);
437 simulation.enqueue(session.id, {
438 type: "pick",
439 characterId: session.characterId,
440 tileX: message.tileX | 0,
441 tileY: message.tileY | 0
442 });
443 break;
444 case MessageType.cancelGather:
445 requirePlaying(session);
446 simulation.enqueue(session.id, {
447 type: "cancel-gather",
448 characterId: session.characterId
449 });
450 break;
451 case MessageType.startCraft:
452 requirePlaying(session);
453 simulation.enqueue(session.id, {
454 type: "start-craft",
455 characterId: session.characterId,
456 stationId: message.stationId,
457 recipeId: message.recipeId,
458 clothTier: message.clothTier ?? null,
459 dyeSlotIndex: message.dyeSlotIndex ?? null,
460 batchCount: message.batchCount ?? null,
461 batchAll: !!message.batchAll
462 });
463 break;
464 case MessageType.startFire:
465 requirePlaying(session);
466 simulation.enqueue(session.id, {
467 type: "start-fire",
468 characterId: session.characterId,
469 groundItemId: message.groundItemId | 0
470 });
471 break;
472 case MessageType.debarkLog:
473 requirePlaying(session);
474 simulation.enqueue(session.id, {
475 type: "debark-log",
476 characterId: session.characterId,
477 groundItemId: message.groundItemId | 0
478 });
479 break;
480 case MessageType.shear:
481 requirePlaying(session);
482 simulation.enqueue(session.id, {
483 type: "shear",
484 characterId: session.characterId,
485 targetEntityId: message.targetEntityId | 0
486 });
487 break;
488 case MessageType.startFish:
489 requirePlaying(session);
490 simulation.enqueue(session.id, {
491 type: "start-fish",
492 characterId: session.characterId,
493 tileX: message.tileX | 0,
494 tileY: message.tileY | 0
495 });
496 break;
497 case MessageType.cancelCraft:
498 requirePlaying(session);
499 simulation.enqueue(session.id, {
500 type: "cancel-craft",
501 characterId: session.characterId
502 });
503 break;
504 case MessageType.cauldronSetSlot:
505 requirePlaying(session);
506 simulation.enqueue(session.id, {
507 type: "cauldron-set-slot",
508 characterId: session.characterId,
509 slotIndex: message.slotIndex | 0,
510 itemId: message.itemId | 0,
511 quantity: message.quantity | 0,
512 instance: message.instance ?? null
513 });
514 break;
515 case MessageType.cauldronSetDyeSlot:
516 requirePlaying(session);
517 simulation.enqueue(session.id, {
518 type: "cauldron-set-dye-slot",
519 characterId: session.characterId,
520 slotIndex: message.slotIndex | 0,
521 itemId: message.itemId | 0,
522 quantity: message.quantity | 0,
523 instance: message.instance ?? null
524 });
525 break;
526 case MessageType.cauldronInsert:
527 requirePlaying(session);
528 simulation.enqueue(session.id, {
529 type: "cauldron-insert",
530 characterId: session.characterId,
531 itemId: message.itemId | 0,
532 quantity: message.quantity | 0,
533 instance: message.instance ?? null
534 });
535 break;
536 case MessageType.cauldronAction:
537 requirePlaying(session);
538 simulation.enqueue(session.id, {
539 type: "cauldron-action",
540 characterId: session.characterId,
541 action: message.action
542 });
543 break;
544 case MessageType.cauldronBottle:
545 requirePlaying(session);
546 simulation.enqueue(session.id, {
547 type: "cauldron-bottle",
548 characterId: session.characterId
549 });
550 break;
551 case MessageType.cauldronCreateDye:
552 requirePlaying(session);
553 simulation.enqueue(session.id, {
554 type: "cauldron-create-dye",
555 characterId: session.characterId,
556 confirmOverflow: !!message.confirmOverflow,
557 flowers: Array.isArray(message.flowers) ? message.flowers : []
558 });
559 break;
560 case MessageType.cauldronClear:
561 requirePlaying(session);
562 simulation.enqueue(session.id, {
563 type: "cauldron-clear",
564 characterId: session.characterId
565 });
566 break;
567 case MessageType.cauldronClearDye:
568 requirePlaying(session);
569 simulation.enqueue(session.id, {
570 type: "cauldron-clear-dye",
571 characterId: session.characterId
572 });
573 break;
574 case MessageType.cauldronSaveRecipe:
575 requirePlaying(session);
576 simulation.enqueue(session.id, {
577 type: "cauldron-save-recipe",
578 characterId: session.characterId
579 });
580 break;
581 case MessageType.cauldronClose:
582 requirePlaying(session);
583 simulation.enqueue(session.id, {
584 type: "cauldron-close",
585 characterId: session.characterId
586 });
587 break;
588 case MessageType.bankDeposit:
589 requirePlaying(session);
590 simulation.enqueue(session.id, {
591 type: "bank-deposit",
592 characterId: session.characterId,
593 slotIndex: message.slotIndex | 0,
594 quantity: message.quantity ?? null
595 });
596 break;
597 case MessageType.bankWithdraw:
598 requirePlaying(session);
599 simulation.enqueue(session.id, {
600 type: "bank-withdraw",
601 characterId: session.characterId,
602 slotIndex: message.slotIndex | 0,
603 quantity: message.quantity ?? null
604 });
605 break;
606 case MessageType.getBlankCheques:
607 requirePlaying(session);
608 simulation.enqueue(session.id, {
609 type: "get-blank-cheques",
610 characterId: session.characterId
611 });
612 break;
613 case MessageType.returnBlankCheques:
614 requirePlaying(session);
615 simulation.enqueue(session.id, {
616 type: "return-blank-cheques",
617 characterId: session.characterId,
618 slotIndex: message.slotIndex | 0,
619 quantity: message.quantity ?? null
620 });
621 break;
622 case MessageType.writeCheque:
623 requirePlaying(session);
624 simulation.enqueue(session.id, {
625 type: "write-cheque",
626 characterId: session.characterId,
627 slotIndex: message.slotIndex | 0,
628 vaultSlotIndex: message.vaultSlotIndex | 0,
629 quantity: message.quantity ?? 1
630 });
631 break;
632 case MessageType.redeemCheque:
633 requirePlaying(session);
634 simulation.enqueue(session.id, {
635 type: "redeem-cheque",
636 characterId: session.characterId,
637 slotIndex: message.slotIndex | 0
638 });
639 break;
640 case MessageType.claimInheritance:
641 requirePlaying(session);
642 {
643 const inheritance = stateDb.getInheritance(session.account.account_id);
644 simulation.enqueue(session.id, {
645 type: "claim-inheritance",
646 characterId: session.characterId,
647 stacks: (inheritance.slots ?? []).filter(Boolean)
648 });
649 }
650 break;
651 case MessageType.attack:
652 requirePlaying(session);
653 simulation.enqueue(session.id, {
654 type: "attack",
655 characterId: session.characterId,
656 targetEntityId: message.targetEntityId | 0
657 });
658 break;
659 case MessageType.cancelAttack:
660 requirePlaying(session);
661 simulation.enqueue(session.id, {
662 type: "cancel-attack",
663 characterId: session.characterId
664 });
665 break;
666 case MessageType.setSpellFavorite:
667 requirePlaying(session);
668 simulation.enqueue(session.id, {
669 type: "set-spell-favorite",
670 characterId: session.characterId,
671 spellId: message.spellId
672 });
673 break;
674 case MessageType.reorderSpellFavorites:
675 requirePlaying(session);
676 simulation.enqueue(session.id, {
677 type: "reorder-spell-favorites",
678 characterId: session.characterId,
679 favoriteSpellIds: Array.isArray(message.favoriteSpellIds)
680 ? message.favoriteSpellIds
681 : (message.favorites ?? [])
682 });
683 break;
684 case MessageType.setSpellAutoCast:
685 requirePlaying(session);
686 simulation.enqueue(session.id, {
687 type: "set-spell-autocast",
688 characterId: session.characterId,
689 enabled: !!message.enabled
690 });
691 break;
692 case MessageType.armSpell:
693 requirePlaying(session);
694 simulation.enqueue(session.id, {
695 type: "arm-spell",
696 characterId: session.characterId,
697 spellId: message.spellId
698 });
699 break;
700 case MessageType.cancelArmSpell:
701 requirePlaying(session);
702 simulation.enqueue(session.id, {
703 type: "cancel-arm-spell",
704 characterId: session.characterId
705 });
706 break;
707 case MessageType.castSpellTile:
708 requirePlaying(session);
709 simulation.enqueue(session.id, {
710 type: "cast-spell-tile",
711 characterId: session.characterId,
712 spellId: message.spellId,
713 tileX: message.tileX | 0,
714 tileY: message.tileY | 0
715 });
716 break;
717 case MessageType.castSpellEntity:
718 requirePlaying(session);
719 simulation.enqueue(session.id, {
720 type: "cast-spell-entity",
721 characterId: session.characterId,
722 spellId: message.spellId,
723 targetEntityId: message.targetEntityId | 0
724 });
725 break;
726 case MessageType.readSpellbook:
727 requirePlaying(session);
728 simulation.enqueue(session.id, {
729 type: "read-spellbook",
730 characterId: session.characterId,
731 slotIndex: message.slotIndex | 0
732 });
733 break;
734 case MessageType.interact:
735 requirePlaying(session);
736 simulation.enqueue(session.id, {
737 type: "interact",
738 characterId: session.characterId,
739 targetEntityId: message.targetEntityId | 0,
740 purpose: message.purpose === "shop" || message.purpose === "talk"
741 ? message.purpose
742 : null
743 });
744 break;
745 case MessageType.buyFromShop:
746 requirePlaying(session);
747 simulation.enqueue(session.id, {
748 type: "buy-from-shop",
749 characterId: session.characterId,
750 npcEntityId: message.npcEntityId | 0,
751 itemId: message.itemId | 0,
752 quantity: message.quantity | 0 || 1,
753 listingId: typeof message.listingId === "string" ? message.listingId : null,
754 source: typeof message.source === "string" ? message.source : null
755 });
756 break;
757 case MessageType.sellToShop:
758 requirePlaying(session);
759 simulation.enqueue(session.id, {
760 type: "sell-to-shop",
761 characterId: session.characterId,
762 npcEntityId: message.npcEntityId | 0,
763 slotIndex: message.slotIndex | 0,
764 quantity: message.quantity | 0 || 1
765 });
766 break;
767 case MessageType.closeShop:
768 requirePlaying(session);
769 simulation.enqueue(session.id, {
770 type: "close-shop",
771 characterId: session.characterId,
772 npcEntityId: message.npcEntityId | 0
773 });
774 break;
775 case MessageType.openMarket:
776 requirePlaying(session);
777 simulation.enqueue(session.id, {
778 type: "open-market",
779 characterId: session.characterId
780 });
781 break;
782 case MessageType.closeMarket:
783 requirePlaying(session);
784 simulation.enqueue(session.id, {
785 type: "close-market",
786 characterId: session.characterId
787 });
788 break;
789 case MessageType.placeMarketSell:
790 requirePlaying(session);
791 simulation.enqueue(session.id, {
792 type: "place-market-sell",
793 characterId: session.characterId,
794 slotIndex: message.slotIndex | 0,
795 quantity: message.quantity | 0 || 1,
796 minUnitPrice: message.minUnitPrice | 0
797 });
798 break;
799 case MessageType.placeMarketBuy:
800 requirePlaying(session);
801 simulation.enqueue(session.id, {
802 type: "place-market-buy",
803 characterId: session.characterId,
804 itemId: message.itemId | 0,
805 listingKey: message.listingKey ?? null,
806 quantity: message.quantity | 0 || 1,
807 maxUnitPrice: message.maxUnitPrice | 0
808 });
809 break;
810 case MessageType.cancelMarketOrder:
811 requirePlaying(session);
812 simulation.enqueue(session.id, {
813 type: "cancel-market-order",
814 characterId: session.characterId,
815 orderId: message.orderId | 0
816 });
817 break;
818 case MessageType.follow:
819 requirePlaying(session);
820 simulation.enqueue(session.id, {
821 type: "follow",
822 characterId: session.characterId,
823 targetEntityId: message.targetEntityId | 0
824 });
825 break;
826 case MessageType.cancelFollow:
827 requirePlaying(session);
828 simulation.enqueue(session.id, {
829 type: "cancel-follow",
830 characterId: session.characterId
831 });
832 break;
833 case MessageType.jewelryTeleport:
834 requirePlaying(session);
835 simulation.enqueue(session.id, {
836 type: "jewelry-teleport",
837 characterId: session.characterId,
838 destination: message.destination === "bank" ? "bank" : "church"
839 });
840 break;
841 case MessageType.tradeRequest:
842 requirePlaying(session);
843 simulation.enqueue(session.id, {
844 type: "trade-request",
845 characterId: session.characterId,
846 targetEntityId: message.targetEntityId | 0
847 });
848 break;
849 case MessageType.tradeRespondInvite:
850 requirePlaying(session);
851 simulation.enqueue(session.id, {
852 type: "trade-respond-invite",
853 characterId: session.characterId,
854 inviteId: message.inviteId,
855 accept: !!message.accept
856 });
857 break;
858 case MessageType.tradeOfferSet:
859 requirePlaying(session);
860 simulation.enqueue(session.id, {
861 type: "trade-offer-set",
862 characterId: session.characterId,
863 bagSlotIndex: message.bagSlotIndex | 0,
864 quantity: message.quantity | 0 || 1
865 });
866 break;
867 case MessageType.tradeOfferRemove:
868 requirePlaying(session);
869 simulation.enqueue(session.id, {
870 type: "trade-offer-remove",
871 characterId: session.characterId,
872 bagSlotIndex: message.bagSlotIndex | 0
873 });
874 break;
875 case MessageType.tradeAccept:
876 requirePlaying(session);
877 simulation.enqueue(session.id, {
878 type: "trade-accept",
879 characterId: session.characterId
880 });
881 break;
882 case MessageType.tradeCancel:
883 requirePlaying(session);
884 simulation.enqueue(session.id, {
885 type: "trade-cancel",
886 characterId: session.characterId
887 });
888 break;
889 case MessageType.sendPigeon:
890 requirePlaying(session);
891 {
892 const result = simulation.dispatchPigeon({
893 characterId: session.characterId,
894 destination: message.destination,
895 cargo: message.cargo
896 });
897 send(session, {
898 type: MessageType.pigeonDispatched,
899 courierId: result.transit.courierId,
900 destinationKind: result.transit.destinationKind,
901 destinationCharacterId: result.transit.destinationCharacterId
902 });
903 send(session, { type: MessageType.inventory, ...result.bag });
904 }
905 break;
906 case MessageType.searchCharacter:
907 requirePlaying(session);
908 {
909 const character = friends.findByFullName(message.firstName, message.lastName);
910 send(session, {
911 type: MessageType.characterSearchResult,
912 character: character ?? null
913 });
914 }
915 break;
916 case MessageType.writeLetter:
917 requirePlaying(session);
918 simulation.enqueue(session.id, {
919 type: "write-letter",
920 characterId: session.characterId,
921 slotIndex: message.slotIndex,
922 body: message.body
923 });
924 break;
925 case MessageType.editLetter:
926 requirePlaying(session);
927 simulation.enqueue(session.id, {
928 type: "edit-letter",
929 characterId: session.characterId,
930 slotIndex: message.slotIndex,
931 body: message.body
932 });
933 break;
934 case MessageType.openLetter:
935 requirePlaying(session);
936 simulation.enqueue(session.id, {
937 type: "open-letter",
938 characterId: session.characterId,
939 slotIndex: message.slotIndex
940 });
941 break;
942 case MessageType.editorLoadChunk:
943 requireAdmin(session);
944 send(session, {
945 type: MessageType.editorChunk,
946 ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0, message.dimensionId)
947 });
948 break;
949 case MessageType.editorSaveChunk:
950 requireAdmin(session);
951 send(session, {
952 type: MessageType.editorChunk,
953 ...editor.saveChunk(
954 message.chunkX | 0,
955 message.chunkY | 0,
956 message.draft,
957 session.authSubject,
958 message.dimensionId
959 )
960 });
961 break;
962 case MessageType.editorListDimensions:
963 case "EDITOR_LIST_DIMENSIONS":
964 requireAdmin(session);
965 try
966 {
967 send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() });
968 }
969 catch (err)
970 {
971 send(session, { type: MessageType.error, message: err.userFacing ? err.message : "Failed to list dimensions." });
972 }
973 break;
974 case MessageType.editorCreateDimension:
975 case "EDITOR_CREATE_DIMENSION":
976 requireAdmin(session);
977 send(session, {
978 type: MessageType.editorDimensions,
979 ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject)
980 });
981 break;
982 case MessageType.editorSaveDimension:
983 case "EDITOR_SAVE_DIMENSION":
984 requireAdmin(session);
985 send(session, {
986 type: MessageType.editorDimensions,
987 ...editor.saveDimension(message.dimension ?? message, session.authSubject)
988 });
989 break;
990 case MessageType.editorSoftDeleteDimension:
991 case "EDITOR_SOFT_DELETE_DIMENSION":
992 requireAdmin(session);
993 send(session, {
994 type: MessageType.editorDimensions,
995 ...editor.softDeleteDimension(message.dimensionId, session.authSubject)
996 });
997 break;
998 case MessageType.editorCancelDimensionDeletion:
999 case "EDITOR_CANCEL_DIMENSION_DELETION":
1000 requireAdmin(session);
1001 send(session, {
1002 type: MessageType.editorDimensions,
1003 ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject)
1004 });
1005 break;
1006 case MessageType.editorLoadSettings:
1007 requireAdmin(session);
1008 send(session, {
1009 type: MessageType.editorSettings,
1010 ...editor.loadSettings(),
1011 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
1012 });
1013 break;
1014 case MessageType.editorLoadGlobalChangelog:
1015 requireAdmin(session);
1016 send(session, {
1017 type: MessageType.editorGlobalChangelog,
1018 ...editor.loadGlobalChangelog(message.limit)
1019 });
1020 break;
1021 case MessageType.editorLoadGameAdmins:
1022 requireAdmin(session);
1023 send(session, {
1024 type: MessageType.editorGameAdmins,
1025 admins: listPublicGameAdmins()
1026 });
1027 break;
1028 case MessageType.editorGrantGameAdmin:
1029 requireAdmin(session);
1030 {
1031 const updated = stateDb.grantGameAdminByUsername(message.username);
1032 refreshAccountAdminSessions(updated.auth_subject);
1033 send(session, {
1034 type: MessageType.editorGameAdmins,
1035 admins: listPublicGameAdmins()
1036 });
1037 }
1038 break;
1039 case MessageType.editorRevokeGameAdmin:
1040 requireAdmin(session);
1041 {
1042 const target = String(message.authSubject ?? "").trim();
1043 if (!target)
1044 { throw userError("Admin account is required."); }
1045 if (target === session.authSubject && !message.confirmSelf)
1046 { throw userError("Confirm removing your own admin access."); }
1047 const updated = stateDb.setGameAdmin(target, false);
1048 refreshAccountAdminSessions(updated.auth_subject);
1049 send(session, {
1050 type: MessageType.editorGameAdmins,
1051 admins: listPublicGameAdmins()
1052 });
1053 }
1054 break;
1055 case MessageType.editorConsoleSubscribe:
1056 requireAdmin(session);
1057 session.consoleSubscribed = true;
1058 send(session, {
1059 type: MessageType.editorConsoleSnapshot,
1060 lines: getConsoleSnapshot(800)
1061 });
1062 break;
1063 case MessageType.editorSaveSettings:
1064 requireAdmin(session);
1065 {
1066 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
1067 simulation.applySettings(saved.settings, {
1068 grantInitialQuests: Object.prototype.hasOwnProperty.call(saved.changed ?? {}, "initialQuests")
1069 });
1070 broadcastStatus();
1071 broadcastSettings(saved);
1072 }
1073 break;
1074 case MessageType.editorApplyRevision:
1075 requireAdmin(session);
1076 if (!editor.revisionStatus().pendingRevisionId)
1077 {
1078 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
1079 break;
1080 }
1081 {
1082 const appliedRevisionId = editor.applyPendingRevision();
1083 simulation.reloadWorld();
1084 for (const other of sessions.values())
1085 {
1086 if (other.entityId)
1087 { syncSubscriptions(other, true); }
1088 }
1089 broadcastStatus();
1090 send(session, {
1091 type: MessageType.editorRevisionApplied,
1092 ...editor.revisionStatus(),
1093 appliedRevisionId
1094 });
1095 }
1096 break;
1097 case MessageType.editorRestartNow:
1098 requireAdmin(session);
1099 deploy?.requestRestartNow?.("admin-editor");
1100 break;
1101 case MessageType.editorLoadQuests:
1102 requireAdmin(session);
1103 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
1104 break;
1105 case MessageType.editorSaveQuest:
1106 requireAdmin(session);
1107 send(session, {
1108 type: MessageType.editorQuests,
1109 ...editor.saveQuest(message.quest ?? message, session.authSubject)
1110 });
1111 break;
1112 case MessageType.editorDeleteQuest:
1113 requireAdmin(session);
1114 send(session, {
1115 type: MessageType.editorQuests,
1116 ...editor.deleteQuest(message.questId, session.authSubject)
1117 });
1118 break;
1119 case MessageType.editorLoadDialogues:
1120 requireAdmin(session);
1121 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
1122 break;
1123 case MessageType.editorSaveDialogue:
1124 requireAdmin(session);
1125 send(session, {
1126 type: MessageType.editorDialogues,
1127 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
1128 });
1129 break;
1130 case MessageType.editorDeleteDialogue:
1131 requireAdmin(session);
1132 send(session, {
1133 type: MessageType.editorDialogues,
1134 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
1135 });
1136 break;
1137 case MessageType.editorSearchGiftCharacters:
1138 requireAdmin(session);
1139 send(session, {
1140 type: MessageType.editorGiftCharacters,
1141 query: String(message.query ?? ""),
1142 ...gifts.search(message.query)
1143 });
1144 break;
1145 case MessageType.editorSendGift:
1146 requireAdmin(session);
1147 send(session, {
1148 type: MessageType.editorGiftSent,
1149 ...gifts.sendGift({
1150 characterId: message.characterId,
1151 message: message.message,
1152 items: message.items
1153 })
1154 });
1155 break;
1156 case MessageType.dialogueChoose:
1157 requirePlaying(session);
1158 simulation.enqueue(session.id, {
1159 type: "dialogue-choose",
1160 characterId: session.characterId,
1161 trigger: String(message.trigger ?? "")
1162 });
1163 break;
1164 case MessageType.dialogueAdvance:
1165 requirePlaying(session);
1166 simulation.enqueue(session.id, {
1167 type: "dialogue-advance",
1168 characterId: session.characterId
1169 });
1170 break;
1171 case MessageType.closeDialogue:
1172 requirePlaying(session);
1173 simulation.enqueue(session.id, {
1174 type: "close-dialogue",
1175 characterId: session.characterId
1176 });
1177 break;
1178 case MessageType.requestQuests:
1179 requirePlaying(session);
1180 simulation.enqueue(session.id, {
1181 type: "request-quests",
1182 characterId: session.characterId
1183 });
1184 break;
1185 case MessageType.setGraphicsSettings:
1186 {
1187 const next = normalizeGraphicsSettings({
1188 viewDistance: message.viewDistance ?? session.viewDistance
1189 });
1190 const changed = next.viewDistance !== session.viewDistance;
1191 session.viewDistance = next.viewDistance;
1192 if (changed && session.entityId)
1193 { syncSubscriptions(session, true); }
1194 }
1195 break;
1196 default:
1197 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
1198 }
1199 }
1200
1201 function enterWorld (session, characterId)
1202 {
1203 if (draining || deploy?.isDraining?.())
1204 {
1205 const error = new Error("The server is restarting for an update. Please try again in a moment.");
1206 error.userFacing = true;
1207 throw error;
1208 }
1209 leaveWorld(session);
1210 const character = characters.getOwned(session.account.account_id, characterId);
1211 if (character.deletion_scheduled_at)
1212 {
1213 const error = new Error("That character is marked for deletion.");
1214 error.userFacing = true;
1215 throw error;
1216 }
1217 const targetCharacterId = character.character_id;
1218 let handoffEntityId = null;
1219 for (const other of [...sessions.values()])
1220 {
1221 if (other === session || other.account.account_id !== session.account.account_id || !other.characterId)
1222 { continue; }
1223 const sameCharacter = other.characterId === targetCharacterId;
1224 if (sameCharacter && simulation.isCharacterInWorld(targetCharacterId))
1225 { handoffEntityId = simulation.entityForCharacter(targetCharacterId); }
1226 disconnectPlayingSession(other, {
1227 despawn: !sameCharacter,
1228 reason: sameCharacter
1229 ? "This character was opened in another window."
1230 : "Logged in from another window."
1231 });
1232 }
1233 session.characterId = targetCharacterId;
1234 if (handoffEntityId == null && simulation.isCharacterInWorld(targetCharacterId))
1235 { handoffEntityId = simulation.entityForCharacter(targetCharacterId); }
1236 if (handoffEntityId != null)
1237 {
1238 const entityId = simulation.reattachCharacterSession(targetCharacterId, session.id);
1239 if (!entityId)
1240 {
1241 const error = new Error("Could not resume that character. Please try again.");
1242 error.userFacing = true;
1243 throw error;
1244 }
1245 session.entityId = entityId;
1246 }
1247 else
1248 { session.entityId = simulation.spawnCharacter(session.id, character); }
1249 sendEnterWorld(session, character);
1250 notifyFriendPresence(session.account?.account_id);
1251 }
1252
1253 function sendEnterWorld (session, character)
1254 {
1255 const spawned = simulation.entityRecord(session.entityId);
1256 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
1257 const dimRecord = simulation.getDimensionRecord?.(enterDim);
1258 send(session, {
1259 type: MessageType.enterWorld,
1260 entityId: session.entityId,
1261 characterId: session.characterId,
1262 accountId: session.account?.account_id ?? null,
1263 tileX: spawned.tileX,
1264 tileY: spawned.tileY,
1265 dimensionId: enterDim,
1266 lightingMode: dimRecord?.lightingMode ?? "dayNight",
1267 seasonMode: dimRecord?.seasonMode ?? "auto",
1268 gait: spawned.gait,
1269 sex: spawned.sex,
1270 firstName: spawned.firstName,
1271 lastName: spawned.lastName,
1272 layers: spawned.layers ?? [],
1273 health: spawned.health,
1274 maxHealth: spawned.maxHealth,
1275 skullValue: spawned.skullValue | 0,
1276 settings: simulation.settings,
1277 worldTime: simulation.worldTime(),
1278 restartStatus: deploy?.getStatus?.() ?? { scheduled: false }
1279 });
1280 syncSubscriptions(session, true);
1281 send(session, { type: MessageType.friends, ...friendsPayload(session.characterId) });
1282 const bag = simulation.bagOf(session.entityId);
1283 if (bag)
1284 { send(session, { type: MessageType.inventory, ...bag }); }
1285 const skills = simulation.skillsOf(session.entityId);
1286 if (skills)
1287 { send(session, { type: MessageType.skills, ...publicSkillsPayload(skills) }); }
1288 const spellView = simulation.spellsOf(session.entityId);
1289 if (spellView)
1290 {
1291 send(session, {
1292 type: MessageType.spells,
1293 spells: spellView.spells,
1294 favorites: spellView.favorites ?? [],
1295 autoCast: spellView.autoCast,
1296 armedSpellId: spellView.armedSpellId ?? null
1297 });
1298 }
1299 const stamina = simulation.staminaOf(session.entityId);
1300 if (stamina)
1301 {
1302 send(session, {
1303 type: MessageType.stamina,
1304 current: stamina.current,
1305 max: stamina.max,
1306 gait: stamina.gait
1307 });
1308 }
1309 if (character.is_dead)
1310 {
1311 send(session, {
1312 type: MessageType.playerDied,
1313 entityId: session.entityId,
1314 characterId: session.characterId
1315 });
1316 }
1317 publishReplication(simulation.drainReplication());
1318 }
1319
1320 function disconnectPlayingSession (session, { despawn = true, reason = "Logged in from another window." } = {})
1321 {
1322 send(session, { type: MessageType.forceLogout, reason });
1323 const characterId = session.characterId;
1324 const accountId = session.account?.account_id | 0;
1325 session.characterId = null;
1326 session.entityId = null;
1327 session.entitySubscribed.clear();
1328 session.staticSubscribed.clear();
1329 if (despawn && characterId)
1330 {
1331 const stayed = simulation.beginCombatLogout(characterId);
1332 if (!stayed)
1333 { simulation.despawnCharacter(characterId); }
1334 publishReplication(simulation.drainReplication());
1335 }
1336 session.suppressLeaveWorldOnClose = true;
1337 if (session.socket.readyState === 1)
1338 { session.socket.close(4000, "Logged in elsewhere"); }
1339 if (accountId)
1340 { notifyFriendPresence(accountId); }
1341 }
1342
1343 function leaveWorld (session)
1344 {
1345 const accountId = session.account?.account_id | 0;
1346 if (session.characterId)
1347 {
1348 const stayed = simulation.beginCombatLogout(session.characterId);
1349 if (!stayed)
1350 { simulation.despawnCharacter(session.characterId); }
1351 }
1352 publishReplication(simulation.drainReplication());
1353 session.characterId = null;
1354 session.entityId = null;
1355 session.entitySubscribed.clear();
1356 session.staticSubscribed.clear();
1357 if (accountId)
1358 { notifyFriendPresence(accountId); }
1359 }
1360
1361 function syncSubscriptions (session, forceSnapshots)
1362 {
1363 if (!session.entityId)
1364 { return; }
1365 const position = simulation.positionOf(session.entityId);
1366 if (!position)
1367 { return; }
1368
1369 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1370 const centerChunkX = tileToChunk(position.tileX);
1371 const centerChunkY = tileToChunk(position.tileY);
1372 const mapRadius = staticChunkRadiusForViewDistance(
1373 session.viewDistance,
1374 STATIC_CHUNK_RADIUS,
1375 VISIBLE_CHUNK_RADIUS
1376 );
1377 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1378 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1379 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1380 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1381
1382 for (const key of session.staticSubscribed)
1383 {
1384 if (!staticNext.has(key))
1385 {
1386 const { chunkX, chunkY } = parseChunkKey(key);
1387 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1388 }
1389 }
1390
1391 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1392 for (const snapshot of snapshots)
1393 {
1394 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1395 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1396 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1397 {
1398 const groundItems = (snapshot.groundItems ?? []).filter((item) =>
1399 canCharacterSeeGroundItem(item, session.characterId)
1400 );
1401 send(session, { type: MessageType.chunkSnapshot, ...snapshot, groundItems });
1402 }
1403 }
1404 session.entitySubscribed = entityNext;
1405 session.staticSubscribed = staticNext;
1406 }
1407
1408 function requirePlaying (session)
1409 {
1410 if (!session.characterId)
1411 {
1412 const error = new Error("Select a character first.");
1413 error.userFacing = true;
1414 throw error;
1415 }
1416 }
1417
1418 function userError (message)
1419 {
1420 const error = new Error(message);
1421 error.userFacing = true;
1422 return error;
1423 }
1424
1425 function listPublicGameAdmins ()
1426 {
1427 return stateDb.listGameAdmins().map((row) => ({
1428 authSubject: row.auth_subject,
1429 username: row.username ?? null,
1430 email: row.email ?? null
1431 }));
1432 }
1433
1434 function refreshAccountAdminSessions (authSubject)
1435 {
1436 const account = stateDb.getAccountBySubject(authSubject);
1437 if (!account)
1438 { return; }
1439 for (const session of sessions.values())
1440 {
1441 if (session.authSubject !== authSubject)
1442 { continue; }
1443 session.account = account;
1444 send(session, {
1445 type: MessageType.session,
1446 accountId: account.account_id,
1447 authSubject: account.auth_subject,
1448 username: session.username ?? account.username ?? null,
1449 email: account.email ?? null,
1450 isAdmin: !!account.is_admin,
1451 characters: characters.list(account.account_id)
1452 });
1453 }
1454 }
1455
1456 function requireAdmin (session)
1457 {
1458 if (!session.account.is_admin)
1459 {
1460 const error = new Error("Admin only.");
1461 error.userFacing = true;
1462 throw error;
1463 }
1464 }
1465
1466 function broadcastStatus ()
1467 {
1468 const worldTime = simulation.worldTime();
1469 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1470 for (const session of sessions.values())
1471 {
1472 if (session.entityId)
1473 {
1474 send(session, {
1475 type: MessageType.worldStatus,
1476 worldTime,
1477 settings: simulation.settings,
1478 activeRevisionId: simulation.activeRevisionId,
1479 restartStatus
1480 });
1481 }
1482 }
1483 }
1484
1485 function broadcastRestartStatus ()
1486 {
1487 const restartStatus = deploy?.getStatus?.() ?? { scheduled: false };
1488 for (const session of sessions.values())
1489 {
1490 if (session.entityId)
1491 { send(session, { type: MessageType.restartStatus, restartStatus }); }
1492 }
1493 }
1494
1495 function onlinePresenceByAccount ()
1496 {
1497 const byAccount = new Map();
1498 for (const entry of sessions.values())
1499 {
1500 if (!entry.characterId || !entry.entityId)
1501 { continue; }
1502 const accountId = entry.account?.account_id | 0;
1503 if (!accountId)
1504 { continue; }
1505 const row = stateDb.getCharacter(entry.characterId);
1506 if (!row)
1507 { continue; }
1508 byAccount.set(accountId, {
1509 characterId: row.character_id,
1510 firstName: row.first_name,
1511 lastName: row.last_name
1512 });
1513 }
1514 return byAccount;
1515 }
1516
1517 function friendsPayload (characterId)
1518 {
1519 const snap = friends.snapshot(characterId);
1520 const presence = onlinePresenceByAccount();
1521 for (const account of snap.friends ?? [])
1522 {
1523 const playingAs = presence.get(account.accountId | 0) ?? null;
1524 account.online = !!playingAs;
1525 account.playingAs = playingAs;
1526 }
1527 return snap;
1528 }
1529
1530 /** Refresh friends panels for an account and everyone friended with them. */
1531 function notifyFriendPresence (accountId)
1532 {
1533 const id = accountId | 0;
1534 if (!id)
1535 { return; }
1536 const refs = [id];
1537 for (const row of stateDb.listAccountFriendRecords(id))
1538 { refs.push(row.account_id); }
1539 pushFriends(...refs);
1540 }
1541
1542 function pushFriends (...refs)
1543 {
1544 const accountIds = new Set();
1545 for (const ref of refs)
1546 {
1547 if (ref == null)
1548 { continue; }
1549 if (typeof ref === "object" && ref.accountId != null)
1550 {
1551 accountIds.add(ref.accountId | 0);
1552 continue;
1553 }
1554 const asNumber = Number(ref);
1555 if (!asNumber)
1556 { continue; }
1557 // Heuristic: character ids from messages; also accept bare account ids from panel.
1558 const character = stateDb.getCharacter(asNumber);
1559 if (character)
1560 { accountIds.add(character.account_id | 0); }
1561 else if (stateDb.getAccount(asNumber))
1562 { accountIds.add(asNumber); }
1563 }
1564 for (const session of sessions.values())
1565 {
1566 if (!session.characterId)
1567 { continue; }
1568 const accountId = session.account?.account_id | 0;
1569 if (!accountIds.has(accountId))
1570 { continue; }
1571 send(session, { type: MessageType.friends, ...friendsPayload(session.characterId) });
1572 }
1573 }
1574
1575 function broadcastSettings (payload)
1576 {
1577 for (const session of sessions.values())
1578 {
1579 if (session.account.is_admin)
1580 { send(session, { type: MessageType.editorSettings, ...payload }); }
1581 }
1582 }
1583
1584 function onTickResult (result)
1585 {
1586 publishReplication(result.replication ?? []);
1587 for (const event of result.events)
1588 {
1589 if (event.type === "command-error")
1590 {
1591 const session = sessions.get(event.sessionId);
1592 if (session)
1593 { send(session, { type: MessageType.error, message: event.message }); }
1594 continue;
1595 }
1596 if (event.type === "inventory")
1597 {
1598 const session = event.sessionId != null
1599 ? sessions.get(event.sessionId)
1600 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1601 if (!session)
1602 { continue; }
1603 send(session, {
1604 type: MessageType.inventory,
1605 inventory: event.inventory,
1606 equipment: event.equipment,
1607 vault: event.vault,
1608 vaultReserved: event.vaultReserved
1609 });
1610 if (event.bank)
1611 {
1612 send(session, {
1613 type: MessageType.bankSnapshot,
1614 vault: event.vault,
1615 vaultReserved: event.vaultReserved,
1616 inheritance: stateDb.getInheritance(session.account.account_id)
1617 });
1618 }
1619 if (event.cauldron != null)
1620 {
1621 send(session, {
1622 type: MessageType.cauldronSnapshot,
1623 open: !!event.cauldron,
1624 state: event.cauldronState ?? null,
1625 alchemyResult: event.alchemyResult ?? null,
1626 dyeConfirm: event.dyeConfirm ?? null
1627 });
1628 }
1629 continue;
1630 }
1631 if (event.type === "skills")
1632 {
1633 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1634 if (!session)
1635 { continue; }
1636 send(session, {
1637 type: MessageType.skills,
1638 skills: event.skills ?? [],
1639 combatLevel: event.combatLevel ?? 0
1640 });
1641 continue;
1642 }
1643 if (event.type === "spells")
1644 {
1645 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1646 if (!session)
1647 { continue; }
1648 send(session, {
1649 type: MessageType.spellsUpdated,
1650 spells: event.spells ?? [],
1651 favorites: event.favorites ?? [],
1652 autoCast: !!event.autoCast,
1653 armedSpellId: event.armedSpellId ?? null
1654 });
1655 continue;
1656 }
1657 if (event.type === "spell-armed")
1658 {
1659 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1660 if (!session)
1661 { continue; }
1662 send(session, {
1663 type: MessageType.spellArmed,
1664 spellId: event.spellId
1665 });
1666 continue;
1667 }
1668 if (event.type === "spell-disarmed")
1669 {
1670 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1671 if (!session)
1672 { continue; }
1673 send(session, { type: MessageType.spellDisarmed });
1674 continue;
1675 }
1676 if (event.type === "stamina")
1677 {
1678 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1679 if (!session)
1680 { continue; }
1681 send(session, {
1682 type: MessageType.stamina,
1683 current: event.current,
1684 max: event.max,
1685 gait: event.gait
1686 });
1687 continue;
1688 }
1689 if (event.type === "status-effects")
1690 {
1691 const session = event.sessionId != null
1692 ? sessions.get(event.sessionId)
1693 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1694 if (!session)
1695 { continue; }
1696 send(session, {
1697 type: MessageType.statusEffects,
1698 effects: event.effects ?? [],
1699 blind: !!event.blind
1700 });
1701 continue;
1702 }
1703 if (event.type === "toast")
1704 {
1705 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1706 if (session)
1707 { send(session, { type: MessageType.toast, message: event.message }); }
1708 continue;
1709 }
1710 if (event.type === "trade-invite")
1711 {
1712 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1713 if (session)
1714 {
1715 send(session, {
1716 type: MessageType.tradeInvite,
1717 inviteId: event.inviteId,
1718 fromCharacterId: event.fromCharacterId,
1719 fromEntityId: event.fromEntityId,
1720 fromName: event.fromName,
1721 expiresAt: event.expiresAt
1722 });
1723 }
1724 continue;
1725 }
1726 if (event.type === "trade-invite-expired")
1727 {
1728 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1729 if (session)
1730 { send(session, { type: MessageType.tradeInviteExpired, inviteId: event.inviteId }); }
1731 continue;
1732 }
1733 if (event.type === "trade-open")
1734 {
1735 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1736 if (session)
1737 {
1738 send(session, {
1739 type: MessageType.tradeOpen,
1740 partnerCharacterId: event.partnerCharacterId,
1741 partnerEntityId: event.partnerEntityId,
1742 partnerName: event.partnerName,
1743 youAccepted: event.youAccepted,
1744 theyAccepted: event.theyAccepted,
1745 yourOffer: event.yourOffer,
1746 theirOffer: event.theirOffer
1747 });
1748 }
1749 continue;
1750 }
1751 if (event.type === "trade-state")
1752 {
1753 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1754 if (session)
1755 {
1756 send(session, {
1757 type: MessageType.tradeState,
1758 youAccepted: event.youAccepted,
1759 theyAccepted: event.theyAccepted,
1760 yourOffer: event.yourOffer,
1761 theirOffer: event.theirOffer
1762 });
1763 }
1764 continue;
1765 }
1766 if (event.type === "trade-closed")
1767 {
1768 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1769 if (session)
1770 { send(session, { type: MessageType.tradeClosed }); }
1771 continue;
1772 }
1773 if (event.type === "quests-snapshot")
1774 {
1775 const session = event.sessionId != null
1776 ? sessions.get(event.sessionId)
1777 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1778 if (session)
1779 {
1780 send(session, {
1781 type: MessageType.questsSnapshot,
1782 quests: event.quests ?? []
1783 });
1784 }
1785 continue;
1786 }
1787 if (event.type === "quest-step-complete")
1788 {
1789 const session = event.sessionId != null
1790 ? sessions.get(event.sessionId)
1791 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1792 if (session)
1793 {
1794 send(session, {
1795 type: MessageType.questStepComplete,
1796 questId: event.questId,
1797 title: event.title
1798 });
1799 }
1800 continue;
1801 }
1802 if (event.type === "quest-objective-complete")
1803 {
1804 const session = event.sessionId != null
1805 ? sessions.get(event.sessionId)
1806 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1807 if (session)
1808 {
1809 send(session, {
1810 type: MessageType.questObjectiveComplete,
1811 questId: event.questId,
1812 objectiveId: event.objectiveId,
1813 text: event.text
1814 });
1815 }
1816 continue;
1817 }
1818 if (event.type === "quest-complete")
1819 {
1820 const session = event.sessionId != null
1821 ? sessions.get(event.sessionId)
1822 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1823 if (session)
1824 {
1825 send(session, {
1826 type: MessageType.questComplete,
1827 questId: event.questId,
1828 title: event.title,
1829 xp: event.xp ?? [],
1830 items: event.items ?? []
1831 });
1832 }
1833 continue;
1834 }
1835 if (event.type === "dialogue-step")
1836 {
1837 const session = event.sessionId != null
1838 ? sessions.get(event.sessionId)
1839 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1840 if (session)
1841 {
1842 send(session, {
1843 type: MessageType.dialogueStep,
1844 dialogueId: event.dialogueId,
1845 stepId: event.stepId,
1846 label: event.label,
1847 npcEntityId: event.npcEntityId ?? null,
1848 lines: event.lines ?? []
1849 });
1850 }
1851 continue;
1852 }
1853 if (event.type === "dialogue-choices")
1854 {
1855 const session = event.sessionId != null
1856 ? sessions.get(event.sessionId)
1857 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1858 if (session)
1859 {
1860 send(session, {
1861 type: MessageType.dialogueChoices,
1862 dialogueId: event.dialogueId,
1863 stepId: event.stepId,
1864 npcEntityId: event.npcEntityId ?? null,
1865 triggers: event.triggers ?? []
1866 });
1867 }
1868 continue;
1869 }
1870 if (event.type === "dialogue-item-rewards")
1871 {
1872 const session = event.sessionId != null
1873 ? sessions.get(event.sessionId)
1874 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1875 if (session)
1876 {
1877 send(session, {
1878 type: MessageType.dialogueItemRewards,
1879 dialogueId: event.dialogueId,
1880 stepId: event.stepId,
1881 npcEntityId: event.npcEntityId ?? null,
1882 messages: event.messages ?? []
1883 });
1884 }
1885 continue;
1886 }
1887 if (event.type === "dialogue-close")
1888 {
1889 const session = event.sessionId != null
1890 ? sessions.get(event.sessionId)
1891 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1892 if (session)
1893 {
1894 send(session, {
1895 type: MessageType.dialogueClose,
1896 reason: event.reason ?? null
1897 });
1898 }
1899 continue;
1900 }
1901 if (event.type === "pigeon-delivered")
1902 {
1903 for (const session of sessions.values())
1904 {
1905 if (session.characterId === event.senderCharacterId
1906 || session.characterId === event.destinationCharacterId)
1907 {
1908 send(session, {
1909 type: MessageType.pigeonDelivered,
1910 courierId: event.courierId,
1911 destinationKind: event.destinationKind,
1912 cargo: event.cargo
1913 });
1914 }
1915 }
1916 continue;
1917 }
1918 if (event.type === "player-died")
1919 {
1920 const session = sessions.get(event.sessionId);
1921 if (session)
1922 {
1923 send(session, {
1924 type: MessageType.playerDied,
1925 entityId: event.entityId,
1926 characterId: event.characterId
1927 });
1928 }
1929 continue;
1930 }
1931 if (event.type === "player-respawned")
1932 {
1933 const session = sessions.get(event.sessionId);
1934 if (session)
1935 {
1936 send(session, {
1937 type: MessageType.playerRespawned,
1938 entityId: event.entityId,
1939 characterId: event.characterId,
1940 tileX: event.tileX,
1941 tileY: event.tileY,
1942 health: event.health,
1943 maxHealth: event.maxHealth,
1944 stamina: event.stamina,
1945 maxStamina: event.maxStamina,
1946 skullValue: event.skullValue | 0
1947 });
1948 }
1949 continue;
1950 }
1951 if (event.type === "dimension-changed")
1952 {
1953 const session = sessions.get(event.sessionId);
1954 if (session)
1955 {
1956 session.entitySubscribed.clear();
1957 session.staticSubscribed.clear();
1958 send(session, {
1959 type: MessageType.dimensionChanged,
1960 dimensionId: event.dimensionId,
1961 tileX: event.tileX,
1962 tileY: event.tileY,
1963 lightingMode: event.lightingMode,
1964 seasonMode: event.seasonMode
1965 });
1966 syncSubscriptions(session, true);
1967 }
1968 continue;
1969 }
1970 if (event.type === "combat-no-arrows")
1971 {
1972 const session = sessions.get(event.sessionId);
1973 if (session)
1974 { send(session, { type: MessageType.combatNoArrows }); }
1975 continue;
1976 }
1977 if (event.type === "craft-result")
1978 {
1979 const session = sessions.get(event.sessionId);
1980 if (session)
1981 {
1982 send(session, {
1983 type: MessageType.craftResult,
1984 recipeId: event.recipeId,
1985 ok: !!event.ok,
1986 error: event.error ?? null,
1987 burned: !!event.burned,
1988 continuing: !!event.continuing
1989 });
1990 }
1991 continue;
1992 }
1993 if (event.type === "station-open")
1994 {
1995 const session = sessions.get(event.sessionId);
1996 if (session)
1997 {
1998 send(session, {
1999 type: MessageType.stationOpen,
2000 stationId: event.stationId
2001 });
2002 }
2003 continue;
2004 }
2005 if (event.type === "shop-open")
2006 {
2007 const session = sessions.get(event.sessionId);
2008 if (session)
2009 {
2010 send(session, {
2011 type: MessageType.shopOpen,
2012 npcEntityId: event.npcEntityId,
2013 displayName: event.displayName,
2014 sex: event.sex === "female" ? "female" : "male",
2015 buysItems: !!event.buysItems,
2016 stock: event.stock ?? []
2017 });
2018 }
2019 continue;
2020 }
2021 if (event.type === "shop-closed")
2022 {
2023 const session = sessions.get(event.sessionId);
2024 if (session)
2025 {
2026 send(session, {
2027 type: MessageType.shopClosed,
2028 npcEntityId: event.npcEntityId
2029 });
2030 }
2031 continue;
2032 }
2033 if (event.type === "market-open")
2034 {
2035 const session = sessions.get(event.sessionId);
2036 if (session)
2037 {
2038 send(session, {
2039 type: MessageType.marketOpen,
2040 displayName: event.displayName,
2041 orders: event.orders ?? [],
2042 catalog: event.catalog ?? []
2043 });
2044 }
2045 continue;
2046 }
2047 if (event.type === "market-closed")
2048 {
2049 const session = sessions.get(event.sessionId);
2050 if (session)
2051 { send(session, { type: MessageType.marketClosed }); }
2052 continue;
2053 }
2054 if (event.type === "bounty-snapshot")
2055 {
2056 const session = sessions.get(event.sessionId);
2057 if (session)
2058 {
2059 send(session, {
2060 type: MessageType.bountySnapshot,
2061 myAmountCopper: event.myAmountCopper | 0,
2062 myAmountLabel: event.myAmountLabel ?? "",
2063 nextDecayAt: event.nextDecayAt ?? null,
2064 payoffCoinsPerPoint: event.payoffCoinsPerPoint ?? 10,
2065 message: event.message ?? "",
2066 raised: event.raised ?? null,
2067 paidOff: event.paidOff ?? null
2068 });
2069 }
2070 continue;
2071 }
2072 if (event.type === "bounty-closed")
2073 {
2074 const session = sessions.get(event.sessionId);
2075 if (session)
2076 { send(session, { type: MessageType.closeBounty }); }
2077 continue;
2078 }
2079 if (event.type === "character-bounty")
2080 {
2081 const session = sessions.get(event.sessionId);
2082 if (session)
2083 {
2084 send(session, {
2085 type: MessageType.characterBounty,
2086 target: event.target ?? null
2087 });
2088 }
2089 continue;
2090 }
2091 if (event.type === "barber-snapshot")
2092 {
2093 const session = sessions.get(event.sessionId);
2094 if (session)
2095 {
2096 send(session, {
2097 type: MessageType.barberSnapshot,
2098 sex: event.sex,
2099 styles: event.styles ?? [],
2100 hair: event.hair ?? null,
2101 message: event.message ?? ""
2102 });
2103 }
2104 continue;
2105 }
2106 if (event.type === "barber-closed")
2107 {
2108 const session = sessions.get(event.sessionId);
2109 if (session)
2110 { send(session, { type: MessageType.closeBarber }); }
2111 continue;
2112 }
2113 if (event.type === "market-trade")
2114 {
2115 for (const session of sessions.values())
2116 {
2117 if (
2118 session.characterId === event.buyerCharacterId
2119 || session.characterId === event.sellerCharacterId
2120 )
2121 {
2122 send(session, {
2123 type: MessageType.marketTrade,
2124 itemId: event.itemId,
2125 quantity: event.quantity,
2126 unitPrice: event.unitPrice,
2127 triggeringSide: event.triggeringSide
2128 });
2129 }
2130 }
2131 continue;
2132 }
2133 if (event.type === "item-bubble")
2134 {
2135 broadcastItemBubble(
2136 sessions,
2137 simulation,
2138 event.entityId,
2139 event.itemId,
2140 event.quantity
2141 );
2142 continue;
2143 }
2144 if (event.type === "gather-swing" || event.type === "tile-shove")
2145 {
2146 publishEntity({
2147 ...event,
2148 type: event.type
2149 });
2150 continue;
2151 }
2152 if (event.type === "chunk-delta")
2153 {
2154 publishEntity(event);
2155 continue;
2156 }
2157 if (event.type === "gather-complete")
2158 {
2159 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
2160 if (session)
2161 {
2162 send(session, {
2163 type: MessageType.gatherComplete,
2164 kind: event.kind,
2165 materialId: event.materialId,
2166 itemId: event.itemId
2167 });
2168 }
2169 continue;
2170 }
2171 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")
2172 { publishEntity(event); }
2173 }
2174 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
2175 { broadcastStatus(); }
2176 }
2177
2178 function publishReplication (events)
2179 {
2180 for (const event of events ?? [])
2181 { publishEntity(event); }
2182 }
2183
2184 function publishEntity (event)
2185 {
2186 const toDim = normalizeDimensionId(event.dimensionId
2187 ?? simulation.entityRecord(event.entityId)?.dimensionId
2188 ?? OVERWORLD_ID);
2189 const fromDim = event.fromDimensionId != null
2190 ? normalizeDimensionId(event.fromDimensionId)
2191 : toDim;
2192 const fromKey = event.fromTileX != null
2193 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
2194 : null;
2195 const toKey = event.tileX != null
2196 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
2197 : null;
2198 for (const session of sessions.values())
2199 {
2200 if (!session.entityId)
2201 { continue; }
2202 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
2203 const seesTo = session.entitySubscribed.has(toKey);
2204 const seesStaticTo = session.staticSubscribed.has(toKey);
2205 if (event.type === "entity-spawn")
2206 {
2207 if (session.entityId === event.entityId || !seesTo)
2208 { continue; }
2209 send(session, spawnPayload(event));
2210 continue;
2211 }
2212 if (event.type === "entity-despawn")
2213 {
2214 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
2215 { continue; }
2216 const payload = { type: MessageType.entityDespawn, entityId: event.entityId };
2217 if (event.cause)
2218 { payload.cause = event.cause; }
2219 send(session, payload);
2220 continue;
2221 }
2222 if (event.type === "entity-appearance")
2223 {
2224 if (!seesTo)
2225 { continue; }
2226 send(session, {
2227 type: MessageType.entityAppearance,
2228 entityId: event.entityId,
2229 sprite: event.sprite,
2230 layers: event.layers ?? [],
2231 lightRadiusTiles: event.lightRadiusTiles ?? 0
2232 });
2233 continue;
2234 }
2235 if (event.type === "entity-skull")
2236 {
2237 if (!seesTo && session.entityId !== event.entityId)
2238 { continue; }
2239 send(session, {
2240 type: MessageType.entitySkull,
2241 entityId: event.entityId,
2242 skullValue: event.skullValue | 0
2243 });
2244 continue;
2245 }
2246 if (event.type === "ground-item-appear")
2247 {
2248 if (!seesTo)
2249 { continue; }
2250 if (!canCharacterSeeGroundItem(event, session.characterId))
2251 { continue; }
2252 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
2253 continue;
2254 }
2255 if (event.type === "ground-item-despawn")
2256 {
2257 if (!seesTo)
2258 { continue; }
2259 if (!canCharacterSeeGroundItem(event, session.characterId))
2260 { continue; }
2261 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
2262 continue;
2263 }
2264 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
2265 {
2266 if (!seesTo && !seesFrom)
2267 { continue; }
2268 const type = event.type === "combat-swing"
2269 ? MessageType.combatSwing
2270 : event.type === "combat-hit"
2271 ? MessageType.combatHit
2272 : event.type === "combat-block"
2273 ? MessageType.combatBlock
2274 : MessageType.combatMiss;
2275 send(session, {
2276 type,
2277 attackerId: event.attackerId,
2278 targetId: event.targetId,
2279 damage: event.damage,
2280 health: event.health,
2281 maxHealth: event.maxHealth,
2282 tileX: event.tileX,
2283 tileY: event.tileY,
2284 fromTileX: event.fromTileX,
2285 fromTileY: event.fromTileY
2286 });
2287 continue;
2288 }
2289 if (event.type === "combat-projectile")
2290 {
2291 if (!seesTo && !seesFrom)
2292 { continue; }
2293 send(session, {
2294 type: MessageType.combatProjectile,
2295 attackerId: event.attackerId,
2296 targetId: event.targetId,
2297 fromTileX: event.fromTileX,
2298 fromTileY: event.fromTileY,
2299 tileX: event.tileX,
2300 tileY: event.tileY,
2301 durationMs: event.durationMs ?? 400,
2302 trackTarget: event.trackTarget !== false,
2303 shaftTint: event.shaftTint ?? null,
2304 tipTint: event.tipTint ?? null
2305 });
2306 continue;
2307 }
2308 if (event.type === "spell-projectile")
2309 {
2310 if (!seesTo && !seesFrom)
2311 { continue; }
2312 send(session, {
2313 type: MessageType.spellProjectile,
2314 casterId: event.casterId,
2315 targetId: event.targetId ?? null,
2316 spellId: event.spellId,
2317 fromTileX: event.fromTileX,
2318 fromTileY: event.fromTileY,
2319 tileX: event.tileX,
2320 tileY: event.tileY,
2321 durationMs: event.durationMs ?? 2000,
2322 sprite: event.sprite ?? null
2323 });
2324 continue;
2325 }
2326 if (event.type === "spell-fizzle")
2327 {
2328 if (!seesTo && !seesFrom)
2329 { continue; }
2330 send(session, {
2331 type: MessageType.spellFizzle,
2332 casterId: event.casterId,
2333 spellId: event.spellId,
2334 fromTileX: event.fromTileX,
2335 fromTileY: event.fromTileY,
2336 tileX: event.tileX,
2337 tileY: event.tileY
2338 });
2339 continue;
2340 }
2341 if (event.type === "spell-cast-flash")
2342 {
2343 if (!seesTo)
2344 { continue; }
2345 send(session, {
2346 type: MessageType.spellCastFlash,
2347 casterId: event.casterId,
2348 tileX: event.tileX,
2349 tileY: event.tileY,
2350 radiusTiles: event.radiusTiles ?? 1,
2351 durationMs: event.durationMs ?? 500,
2352 tier: event.tier ?? 1
2353 });
2354 continue;
2355 }
2356 if (event.type === "spell-light-appear" || event.type === "spell-light-update"
2357 || event.type === "spell-dark-appear" || event.type === "spell-dark-update")
2358 {
2359 if (!seesTo)
2360 { continue; }
2361 const isDark = event.type.startsWith("spell-dark");
2362 const appear = event.type.endsWith("appear");
2363 send(session, {
2364 type: appear
2365 ? (isDark ? MessageType.spellDarkAppear : MessageType.spellLightAppear)
2366 : (isDark ? MessageType.spellDarkUpdate : MessageType.spellLightUpdate),
2367 tileX: event.tileX,
2368 tileY: event.tileY,
2369 ownerEntityId: event.ownerEntityId,
2370 remainingMs: event.remainingMs ?? 0,
2371 rangeTiles: event.rangeTiles ?? 0,
2372 intensity: event.intensity ?? 0,
2373 expiresAt: event.expiresAt ?? 0,
2374 kind: isDark ? "dark" : "light"
2375 });
2376 continue;
2377 }
2378 if (event.type === "spell-light-remove" || event.type === "spell-dark-remove")
2379 {
2380 if (!seesTo)
2381 { continue; }
2382 send(session, {
2383 type: event.type === "spell-dark-remove"
2384 ? MessageType.spellDarkRemove
2385 : MessageType.spellLightRemove,
2386 tileX: event.tileX,
2387 tileY: event.tileY
2388 });
2389 continue;
2390 }
2391 if (event.type === "entity-health")
2392 {
2393 if (!seesTo && !seesFrom)
2394 { continue; }
2395 send(session, {
2396 type: MessageType.entityHealth,
2397 entityId: event.entityId,
2398 health: event.health,
2399 maxHealth: event.maxHealth
2400 });
2401 continue;
2402 }
2403 if (event.type === "gather-swing" || event.type === "tile-shove")
2404 {
2405 if (!seesTo && !seesFrom)
2406 { continue; }
2407 if (event.type === "gather-swing")
2408 {
2409 send(session, {
2410 type: MessageType.gatherSwing,
2411 attackerId: event.attackerId,
2412 tileX: event.tileX,
2413 tileY: event.tileY,
2414 fromTileX: event.fromTileX,
2415 fromTileY: event.fromTileY,
2416 toolItemId: event.toolItemId ?? null
2417 });
2418 }
2419 else
2420 {
2421 send(session, {
2422 type: MessageType.tileShove,
2423 attackerId: event.attackerId,
2424 tileX: event.tileX,
2425 tileY: event.tileY,
2426 fromTileX: event.fromTileX,
2427 fromTileY: event.fromTileY
2428 });
2429 }
2430 continue;
2431 }
2432 if (event.type === "skill-level-up")
2433 {
2434 if (session.entityId !== event.entityId && !seesTo)
2435 { continue; }
2436 send(session, {
2437 type: MessageType.skillLevelUp,
2438 entityId: event.entityId,
2439 characterId: event.characterId,
2440 skillId: event.skillId,
2441 level: event.level,
2442 previousLevel: event.previousLevel,
2443 displayName: event.displayName,
2444 icon: event.icon
2445 });
2446 continue;
2447 }
2448 if (event.type === "chunk-delta")
2449 {
2450 if (!seesStaticTo)
2451 { continue; }
2452 send(session, {
2453 type: MessageType.chunkDelta,
2454 chunkX: event.chunkX,
2455 chunkY: event.chunkY,
2456 tiles: [{
2457 localX: event.localX,
2458 localY: event.localY,
2459 block: event.block
2460 }]
2461 });
2462 continue;
2463 }
2464 if (event.type !== "entity-move")
2465 { continue; }
2466 if (seesTo)
2467 {
2468 if (!seesFrom)
2469 { send(session, spawnPayload(event)); }
2470 else
2471 {
2472 send(session, {
2473 type: MessageType.entityMove,
2474 entityId: event.entityId,
2475 tileX: event.tileX,
2476 tileY: event.tileY,
2477 worldX: event.worldX,
2478 worldY: event.worldY,
2479 gait: event.gait,
2480 lerpMs: event.lerpMs,
2481 freeFlight: !!event.freeFlight
2482 });
2483 }
2484 }
2485 else if (seesFrom)
2486 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
2487 if (session.entityId === event.entityId)
2488 {
2489 const crossedDimension = event.fromDimensionId != null
2490 && event.dimensionId != null
2491 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
2492 if (!crossedDimension)
2493 { syncSubscriptions(session, false); }
2494 }
2495 }
2496 }
2497
2498 function spawnPayload (event)
2499 {
2500 const record = simulation.entityRecord(event.entityId) ?? event;
2501 return {
2502 type: MessageType.entitySpawn,
2503 entityId: event.entityId,
2504 characterId: record.characterId ?? event.characterId ?? null,
2505 accountId: record.accountId ?? event.accountId ?? null,
2506 tileX: event.tileX ?? record.tileX,
2507 tileY: event.tileY ?? record.tileY,
2508 worldX: event.worldX ?? record.worldX,
2509 worldY: event.worldY ?? record.worldY,
2510 gait: event.gait ?? record.gait,
2511 sex: record.sex ?? event.sex ?? null,
2512 firstName: record.firstName ?? event.firstName ?? "",
2513 lastName: record.lastName ?? event.lastName ?? "",
2514 sprite: record.sprite ?? event.sprite ?? null,
2515 layers: record.layers ?? event.layers ?? [],
2516 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
2517 canFight: !!(record.canFight ?? event.canFight),
2518 aggressive: !!(record.aggressive ?? event.aggressive ?? record.hostile ?? event.hostile),
2519 hostile: !!(record.hostile ?? event.hostile ?? record.aggressive ?? event.aggressive),
2520 talkable: !!(record.talkable ?? event.talkable),
2521 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
2522 hasShop: !!(record.hasShop ?? event.hasShop),
2523 untargetable: !!(record.untargetable ?? event.untargetable),
2524 freeFlight: !!(record.freeFlight ?? event.freeFlight),
2525 level: record.level ?? event.level ?? null,
2526 health: record.health ?? event.health,
2527 maxHealth: record.maxHealth ?? event.maxHealth,
2528 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0,
2529 skullValue: record.skullValue | 0
2530 };
2531 }
2532
2533 return {
2534 sessions,
2535 onTickResult,
2536 wss,
2537 broadcastRestartStatus,
2538 setDraining (value)
2539 {
2540 draining = !!value;
2541 },
2542 async shutdown ()
2543 {
2544 draining = true;
2545 await Promise.all([...sessions.values()].map(async (session) =>
2546 {
2547 await sendAsync(session, {
2548 type: MessageType.forceLogout,
2549 reason: "Server shutting down."
2550 });
2551 leaveWorld(session);
2552 await closeAsync(session, 1001, "Server shutting down.");
2553 }));
2554 sessions.clear();
2555 await simulation.shutdown();
2556 }
2557 };
2558}
2559
2560function send (session, payload)
2561{
2562 if (session.socket.readyState === 1)
2563 { session.socket.send(JSON.stringify(payload)); }
2564}
2565
2566function sendAsync (session, payload)
2567{
2568 return new Promise((resolve) =>
2569 {
2570 if (session.socket.readyState !== 1)
2571 {
2572 resolve();
2573 return;
2574 }
2575 session.socket.send(JSON.stringify(payload), () => resolve());
2576 });
2577}
2578
2579function closeAsync (session, code, reason)
2580{
2581 return new Promise((resolve) =>
2582 {
2583 if (session.socket.readyState !== 1)
2584 {
2585 resolve();
2586 return;
2587 }
2588 session.socket.once("close", resolve);
2589 try
2590 { session.socket.close(code, reason); }
2591 catch
2592 { resolve(); }
2593 });
2594}