BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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