BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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