BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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