BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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