BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 54.5 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 { publicSkillsView } from "../../../shared/skills/state.js";
9import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js";
10
11let nextSessionId = 1;
12
13export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation })
14{
15 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
16 const sessions = new Map();
17
18 wss.on("connection", (socket) =>
19 {
20 const identity = auth.claimIdentity();
21 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
22 const session = {
23 id: nextSessionId++,
24 socket,
25 account,
26 authSubject: identity.authSubject,
27 characterId: null,
28 entityId: null,
29 /** Client graphics: long = STATIC_CHUNK_RADIUS map ring; short = VISIBLE_CHUNK_RADIUS. */
30 viewDistance: ViewDistance.long,
31 /** Chunks where entity / ground-item replication is active (3×3). */
32 entitySubscribed: new Set(),
33 /** Chunks with map + baked lighting only (5×5 when long). */
34 staticSubscribed: new Set()
35 };
36 auth.register(session);
37 sessions.set(session.id, session);
38 send(session, {
39 type: MessageType.session,
40 accountId: account.account_id,
41 authSubject: account.auth_subject,
42 isAdmin: !!account.is_admin,
43 characters: characters.list(account.account_id)
44 });
45
46 socket.on("message", (raw) =>
47 {
48 let message;
49 try
50 { message = JSON.parse(String(raw)); }
51 catch
52 {
53 send(session, { type: MessageType.error, message: "Invalid JSON." });
54 return;
55 }
56 try
57 { handleMessage(session, message); }
58 catch (error)
59 {
60 send(session, {
61 type: MessageType.error,
62 message: error.userFacing ? error.message : "Request failed."
63 });
64 }
65 });
66
67 socket.on("close", () =>
68 {
69 leaveWorld(session);
70 auth.release(session);
71 sessions.delete(session.id);
72 });
73 });
74
75 function handleMessage (session, message)
76 {
77 if (session.characterId
78 && stateDb.getCharacter(session.characterId)?.is_dead
79 && message.type !== MessageType.respawn
80 && message.type !== MessageType.leaveWorld)
81 {
82 const error = new Error("You are dead.");
83 error.userFacing = true;
84 throw error;
85 }
86 switch (message.type)
87 {
88 case MessageType.createCharacter:
89 {
90 const created = characters.create(
91 session.account,
92 message.firstName,
93 message.lastName,
94 message.sex,
95 message.hair ?? null,
96 simulation.settings
97 );
98 enterWorld(session, created.characterId);
99 }
100 break;
101 case MessageType.selectCharacter:
102 enterWorld(session, message.characterId);
103 break;
104 case MessageType.scheduleDeleteCharacter:
105 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
106 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
107 break;
108 case MessageType.cancelDeleteCharacter:
109 characters.cancelDelete(session.account, message.characterId);
110 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
111 break;
112 case MessageType.leaveWorld:
113 leaveWorld(session);
114 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
115 break;
116 case MessageType.respawn:
117 requirePlaying(session);
118 simulation.enqueue(session.id, {
119 type: "respawn",
120 characterId: session.characterId
121 });
122 break;
123 case MessageType.moveTo:
124 requirePlaying(session);
125 simulation.enqueue(session.id, {
126 type: "move-to",
127 characterId: session.characterId,
128 tileX: message.tileX | 0,
129 tileY: message.tileY | 0
130 });
131 break;
132 case MessageType.setGait:
133 requirePlaying(session);
134 simulation.enqueue(session.id, {
135 type: "set-gait",
136 characterId: session.characterId,
137 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
138 });
139 break;
140 case MessageType.friendRequest:
141 requirePlaying(session);
142 friends.request(session.characterId, message.characterId);
143 pushFriends(session.characterId, message.characterId);
144 break;
145 case MessageType.friendAccept:
146 requirePlaying(session);
147 friends.accept(session.characterId, message.characterId);
148 pushFriends(session.characterId, message.characterId);
149 break;
150 case MessageType.friendDecline:
151 requirePlaying(session);
152 friends.decline(session.characterId, message.characterId);
153 pushFriends(session.characterId, message.characterId);
154 break;
155 case MessageType.friendRemove:
156 requirePlaying(session);
157 friends.remove(session.characterId, message.characterId);
158 pushFriends(session.characterId, message.characterId);
159 break;
160 case MessageType.chatSay:
161 requirePlaying(session);
162 broadcastSpeech(sessions, simulation, session, message.text);
163 break;
164 case MessageType.dropItem:
165 requirePlaying(session);
166 simulation.enqueue(session.id, {
167 type: "drop-item",
168 characterId: session.characterId,
169 slotIndex: message.slotIndex | 0,
170 quantity: message.quantity ?? null
171 });
172 break;
173 case MessageType.pickupItem:
174 requirePlaying(session);
175 simulation.enqueue(session.id, {
176 type: "pickup-item",
177 characterId: session.characterId,
178 groundItemId: message.groundItemId | 0
179 });
180 break;
181 case MessageType.equipItem:
182 requirePlaying(session);
183 simulation.enqueue(session.id, {
184 type: "equip-item",
185 characterId: session.characterId,
186 slotIndex: message.slotIndex | 0
187 });
188 break;
189 case MessageType.unequipItem:
190 requirePlaying(session);
191 simulation.enqueue(session.id, {
192 type: "unequip-item",
193 characterId: session.characterId,
194 equipSlot: message.equipSlot
195 });
196 break;
197 case MessageType.eatItem:
198 requirePlaying(session);
199 simulation.enqueue(session.id, {
200 type: "eat-item",
201 characterId: session.characterId,
202 slotIndex: message.slotIndex | 0
203 });
204 break;
205 case MessageType.drinkItem:
206 requirePlaying(session);
207 simulation.enqueue(session.id, {
208 type: "drink-item",
209 characterId: session.characterId,
210 slotIndex: message.slotIndex | 0
211 });
212 break;
213 case MessageType.openBank:
214 requirePlaying(session);
215 simulation.enqueue(session.id, {
216 type: "open-bank",
217 characterId: session.characterId
218 });
219 break;
220 case MessageType.enterDoorway:
221 requirePlaying(session);
222 simulation.enqueue(session.id, {
223 type: "enter-doorway",
224 characterId: session.characterId,
225 tileX: message.tileX | 0,
226 tileY: message.tileY | 0
227 });
228 break;
229 case MessageType.openBounty:
230 requirePlaying(session);
231 simulation.enqueue(session.id, {
232 type: "open-bounty",
233 characterId: session.characterId
234 });
235 break;
236 case MessageType.raiseBounty:
237 requirePlaying(session);
238 simulation.enqueue(session.id, {
239 type: "raise-bounty",
240 characterId: session.characterId,
241 firstName: message.firstName,
242 lastName: message.lastName,
243 amountCopper: message.amountCopper
244 });
245 break;
246 case MessageType.getCharacterBounty:
247 requirePlaying(session);
248 simulation.enqueue(session.id, {
249 type: "get-character-bounty",
250 characterId: session.characterId,
251 targetCharacterId: message.characterId,
252 firstName: message.firstName,
253 lastName: message.lastName
254 });
255 break;
256 case MessageType.closeBounty:
257 requirePlaying(session);
258 simulation.enqueue(session.id, {
259 type: "close-bounty",
260 characterId: session.characterId
261 });
262 break;
263 case MessageType.openBarber:
264 requirePlaying(session);
265 simulation.enqueue(session.id, {
266 type: "open-barber",
267 characterId: session.characterId
268 });
269 break;
270 case MessageType.setHair:
271 requirePlaying(session);
272 simulation.enqueue(session.id, {
273 type: "set-hair",
274 characterId: session.characterId,
275 hair: message.hair ?? null
276 });
277 break;
278 case MessageType.closeBarber:
279 requirePlaying(session);
280 simulation.enqueue(session.id, {
281 type: "close-barber",
282 characterId: session.characterId
283 });
284 break;
285 case MessageType.openCauldron:
286 requirePlaying(session);
287 simulation.enqueue(session.id, {
288 type: "open-cauldron",
289 characterId: session.characterId
290 });
291 break;
292 case MessageType.openFurnace:
293 requirePlaying(session);
294 simulation.enqueue(session.id, {
295 type: "open-station",
296 characterId: session.characterId,
297 stationId: CraftingStationId.furnace
298 });
299 break;
300 case MessageType.openStation:
301 {
302 requirePlaying(session);
303 const stationId = typeof message.stationId === "string"
304 ? message.stationId
305 : null;
306 if (!stationId || !craftingStationDefinition(stationId))
307 { break; }
308 simulation.enqueue(session.id, {
309 type: "open-station",
310 characterId: session.characterId,
311 stationId
312 });
313 break;
314 }
315 case MessageType.mine:
316 requirePlaying(session);
317 simulation.enqueue(session.id, {
318 type: "mine",
319 characterId: session.characterId,
320 tileX: message.tileX | 0,
321 tileY: message.tileY | 0
322 });
323 break;
324 case MessageType.chop:
325 requirePlaying(session);
326 simulation.enqueue(session.id, {
327 type: "chop",
328 characterId: session.characterId,
329 tileX: message.tileX | 0,
330 tileY: message.tileY | 0
331 });
332 break;
333 case MessageType.pick:
334 requirePlaying(session);
335 simulation.enqueue(session.id, {
336 type: "pick",
337 characterId: session.characterId,
338 tileX: message.tileX | 0,
339 tileY: message.tileY | 0
340 });
341 break;
342 case MessageType.cancelGather:
343 requirePlaying(session);
344 simulation.enqueue(session.id, {
345 type: "cancel-gather",
346 characterId: session.characterId
347 });
348 break;
349 case MessageType.startCraft:
350 requirePlaying(session);
351 simulation.enqueue(session.id, {
352 type: "start-craft",
353 characterId: session.characterId,
354 stationId: message.stationId,
355 recipeId: message.recipeId,
356 clothTier: message.clothTier ?? null,
357 dyeSlotIndex: message.dyeSlotIndex ?? null,
358 batchCount: message.batchCount ?? null,
359 batchAll: !!message.batchAll
360 });
361 break;
362 case MessageType.cancelCraft:
363 requirePlaying(session);
364 simulation.enqueue(session.id, {
365 type: "cancel-craft",
366 characterId: session.characterId
367 });
368 break;
369 case MessageType.cauldronSetSlot:
370 requirePlaying(session);
371 simulation.enqueue(session.id, {
372 type: "cauldron-set-slot",
373 characterId: session.characterId,
374 slotIndex: message.slotIndex | 0,
375 itemId: message.itemId | 0,
376 quantity: message.quantity | 0,
377 instance: message.instance ?? null
378 });
379 break;
380 case MessageType.cauldronSetDyeSlot:
381 requirePlaying(session);
382 simulation.enqueue(session.id, {
383 type: "cauldron-set-dye-slot",
384 characterId: session.characterId,
385 slotIndex: message.slotIndex | 0,
386 itemId: message.itemId | 0,
387 quantity: message.quantity | 0,
388 instance: message.instance ?? null
389 });
390 break;
391 case MessageType.cauldronInsert:
392 requirePlaying(session);
393 simulation.enqueue(session.id, {
394 type: "cauldron-insert",
395 characterId: session.characterId,
396 itemId: message.itemId | 0,
397 quantity: message.quantity | 0,
398 instance: message.instance ?? null
399 });
400 break;
401 case MessageType.cauldronAction:
402 requirePlaying(session);
403 simulation.enqueue(session.id, {
404 type: "cauldron-action",
405 characterId: session.characterId,
406 action: message.action
407 });
408 break;
409 case MessageType.cauldronBottle:
410 requirePlaying(session);
411 simulation.enqueue(session.id, {
412 type: "cauldron-bottle",
413 characterId: session.characterId
414 });
415 break;
416 case MessageType.cauldronCreateDye:
417 requirePlaying(session);
418 simulation.enqueue(session.id, {
419 type: "cauldron-create-dye",
420 characterId: session.characterId,
421 confirmOverflow: !!message.confirmOverflow,
422 flowers: Array.isArray(message.flowers) ? message.flowers : []
423 });
424 break;
425 case MessageType.cauldronClear:
426 requirePlaying(session);
427 simulation.enqueue(session.id, {
428 type: "cauldron-clear",
429 characterId: session.characterId
430 });
431 break;
432 case MessageType.cauldronClearDye:
433 requirePlaying(session);
434 simulation.enqueue(session.id, {
435 type: "cauldron-clear-dye",
436 characterId: session.characterId
437 });
438 break;
439 case MessageType.cauldronSaveRecipe:
440 requirePlaying(session);
441 simulation.enqueue(session.id, {
442 type: "cauldron-save-recipe",
443 characterId: session.characterId
444 });
445 break;
446 case MessageType.cauldronClose:
447 requirePlaying(session);
448 simulation.enqueue(session.id, {
449 type: "cauldron-close",
450 characterId: session.characterId
451 });
452 break;
453 case MessageType.bankDeposit:
454 requirePlaying(session);
455 simulation.enqueue(session.id, {
456 type: "bank-deposit",
457 characterId: session.characterId,
458 slotIndex: message.slotIndex | 0,
459 quantity: message.quantity ?? null
460 });
461 break;
462 case MessageType.bankWithdraw:
463 requirePlaying(session);
464 simulation.enqueue(session.id, {
465 type: "bank-withdraw",
466 characterId: session.characterId,
467 slotIndex: message.slotIndex | 0,
468 quantity: message.quantity ?? null
469 });
470 break;
471 case MessageType.getBlankCheques:
472 requirePlaying(session);
473 simulation.enqueue(session.id, {
474 type: "get-blank-cheques",
475 characterId: session.characterId
476 });
477 break;
478 case MessageType.returnBlankCheques:
479 requirePlaying(session);
480 simulation.enqueue(session.id, {
481 type: "return-blank-cheques",
482 characterId: session.characterId,
483 slotIndex: message.slotIndex | 0,
484 quantity: message.quantity ?? null
485 });
486 break;
487 case MessageType.writeCheque:
488 requirePlaying(session);
489 simulation.enqueue(session.id, {
490 type: "write-cheque",
491 characterId: session.characterId,
492 slotIndex: message.slotIndex | 0,
493 vaultSlotIndex: message.vaultSlotIndex | 0,
494 quantity: message.quantity ?? 1
495 });
496 break;
497 case MessageType.redeemCheque:
498 requirePlaying(session);
499 simulation.enqueue(session.id, {
500 type: "redeem-cheque",
501 characterId: session.characterId,
502 slotIndex: message.slotIndex | 0
503 });
504 break;
505 case MessageType.claimInheritance:
506 requirePlaying(session);
507 {
508 const inheritance = stateDb.getInheritance(session.account.account_id);
509 simulation.enqueue(session.id, {
510 type: "claim-inheritance",
511 characterId: session.characterId,
512 stacks: (inheritance.slots ?? []).filter(Boolean)
513 });
514 }
515 break;
516 case MessageType.attack:
517 requirePlaying(session);
518 simulation.enqueue(session.id, {
519 type: "attack",
520 characterId: session.characterId,
521 targetEntityId: message.targetEntityId | 0
522 });
523 break;
524 case MessageType.cancelAttack:
525 requirePlaying(session);
526 simulation.enqueue(session.id, {
527 type: "cancel-attack",
528 characterId: session.characterId
529 });
530 break;
531 case MessageType.setSpellFavorite:
532 requirePlaying(session);
533 simulation.enqueue(session.id, {
534 type: "set-spell-favorite",
535 characterId: session.characterId,
536 spellId: message.spellId
537 });
538 break;
539 case MessageType.setSpellAutoCast:
540 requirePlaying(session);
541 simulation.enqueue(session.id, {
542 type: "set-spell-autocast",
543 characterId: session.characterId,
544 enabled: !!message.enabled
545 });
546 break;
547 case MessageType.armSpell:
548 requirePlaying(session);
549 simulation.enqueue(session.id, {
550 type: "arm-spell",
551 characterId: session.characterId,
552 spellId: message.spellId
553 });
554 break;
555 case MessageType.cancelArmSpell:
556 requirePlaying(session);
557 simulation.enqueue(session.id, {
558 type: "cancel-arm-spell",
559 characterId: session.characterId
560 });
561 break;
562 case MessageType.castSpellTile:
563 requirePlaying(session);
564 simulation.enqueue(session.id, {
565 type: "cast-spell-tile",
566 characterId: session.characterId,
567 spellId: message.spellId,
568 tileX: message.tileX | 0,
569 tileY: message.tileY | 0
570 });
571 break;
572 case MessageType.castSpellEntity:
573 requirePlaying(session);
574 simulation.enqueue(session.id, {
575 type: "cast-spell-entity",
576 characterId: session.characterId,
577 spellId: message.spellId,
578 targetEntityId: message.targetEntityId | 0
579 });
580 break;
581 case MessageType.readSpellbook:
582 requirePlaying(session);
583 simulation.enqueue(session.id, {
584 type: "read-spellbook",
585 characterId: session.characterId,
586 slotIndex: message.slotIndex | 0
587 });
588 break;
589 case MessageType.interact:
590 requirePlaying(session);
591 simulation.enqueue(session.id, {
592 type: "interact",
593 characterId: session.characterId,
594 targetEntityId: message.targetEntityId | 0,
595 purpose: message.purpose === "shop" || message.purpose === "talk"
596 ? message.purpose
597 : null
598 });
599 break;
600 case MessageType.buyFromShop:
601 requirePlaying(session);
602 simulation.enqueue(session.id, {
603 type: "buy-from-shop",
604 characterId: session.characterId,
605 npcEntityId: message.npcEntityId | 0,
606 itemId: message.itemId | 0,
607 quantity: message.quantity | 0 || 1,
608 listingId: typeof message.listingId === "string" ? message.listingId : null,
609 source: typeof message.source === "string" ? message.source : null
610 });
611 break;
612 case MessageType.sellToShop:
613 requirePlaying(session);
614 simulation.enqueue(session.id, {
615 type: "sell-to-shop",
616 characterId: session.characterId,
617 npcEntityId: message.npcEntityId | 0,
618 slotIndex: message.slotIndex | 0,
619 quantity: message.quantity | 0 || 1
620 });
621 break;
622 case MessageType.closeShop:
623 requirePlaying(session);
624 simulation.enqueue(session.id, {
625 type: "close-shop",
626 characterId: session.characterId,
627 npcEntityId: message.npcEntityId | 0
628 });
629 break;
630 case MessageType.openMarket:
631 requirePlaying(session);
632 simulation.enqueue(session.id, {
633 type: "open-market",
634 characterId: session.characterId
635 });
636 break;
637 case MessageType.closeMarket:
638 requirePlaying(session);
639 simulation.enqueue(session.id, {
640 type: "close-market",
641 characterId: session.characterId
642 });
643 break;
644 case MessageType.placeMarketSell:
645 requirePlaying(session);
646 simulation.enqueue(session.id, {
647 type: "place-market-sell",
648 characterId: session.characterId,
649 slotIndex: message.slotIndex | 0,
650 quantity: message.quantity | 0 || 1,
651 minUnitPrice: message.minUnitPrice | 0
652 });
653 break;
654 case MessageType.placeMarketBuy:
655 requirePlaying(session);
656 simulation.enqueue(session.id, {
657 type: "place-market-buy",
658 characterId: session.characterId,
659 itemId: message.itemId | 0,
660 quantity: message.quantity | 0 || 1,
661 maxUnitPrice: message.maxUnitPrice | 0
662 });
663 break;
664 case MessageType.cancelMarketOrder:
665 requirePlaying(session);
666 simulation.enqueue(session.id, {
667 type: "cancel-market-order",
668 characterId: session.characterId,
669 orderId: message.orderId | 0
670 });
671 break;
672 case MessageType.follow:
673 requirePlaying(session);
674 simulation.enqueue(session.id, {
675 type: "follow",
676 characterId: session.characterId,
677 targetEntityId: message.targetEntityId | 0
678 });
679 break;
680 case MessageType.cancelFollow:
681 requirePlaying(session);
682 simulation.enqueue(session.id, {
683 type: "cancel-follow",
684 characterId: session.characterId
685 });
686 break;
687 case MessageType.sendPigeon:
688 requirePlaying(session);
689 {
690 const result = simulation.dispatchPigeon({
691 characterId: session.characterId,
692 destination: message.destination,
693 cargo: message.cargo
694 });
695 send(session, {
696 type: MessageType.pigeonDispatched,
697 courierId: result.transit.courierId,
698 destinationKind: result.transit.destinationKind,
699 destinationCharacterId: result.transit.destinationCharacterId
700 });
701 send(session, { type: MessageType.inventory, ...result.bag });
702 }
703 break;
704 case MessageType.searchCharacter:
705 requirePlaying(session);
706 {
707 const character = friends.findByFullName(message.firstName, message.lastName);
708 send(session, {
709 type: MessageType.characterSearchResult,
710 character: character ?? null
711 });
712 }
713 break;
714 case MessageType.writeLetter:
715 requirePlaying(session);
716 simulation.enqueue(session.id, {
717 type: "write-letter",
718 characterId: session.characterId,
719 slotIndex: message.slotIndex,
720 body: message.body
721 });
722 break;
723 case MessageType.editLetter:
724 requirePlaying(session);
725 simulation.enqueue(session.id, {
726 type: "edit-letter",
727 characterId: session.characterId,
728 slotIndex: message.slotIndex,
729 body: message.body
730 });
731 break;
732 case MessageType.openLetter:
733 requirePlaying(session);
734 simulation.enqueue(session.id, {
735 type: "open-letter",
736 characterId: session.characterId,
737 slotIndex: message.slotIndex
738 });
739 break;
740 case MessageType.editorLoadChunk:
741 requireAdmin(session);
742 send(session, {
743 type: MessageType.editorChunk,
744 ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0, message.dimensionId)
745 });
746 break;
747 case MessageType.editorSaveChunk:
748 requireAdmin(session);
749 send(session, {
750 type: MessageType.editorChunk,
751 ...editor.saveChunk(
752 message.chunkX | 0,
753 message.chunkY | 0,
754 message.draft,
755 session.authSubject,
756 message.dimensionId
757 )
758 });
759 break;
760 case MessageType.editorListDimensions:
761 requireAdmin(session);
762 send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() });
763 break;
764 case MessageType.editorCreateDimension:
765 requireAdmin(session);
766 send(session, {
767 type: MessageType.editorDimensions,
768 ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject)
769 });
770 break;
771 case MessageType.editorSaveDimension:
772 requireAdmin(session);
773 send(session, {
774 type: MessageType.editorDimensions,
775 ...editor.saveDimension(message.dimension ?? message, session.authSubject)
776 });
777 break;
778 case MessageType.editorSoftDeleteDimension:
779 requireAdmin(session);
780 send(session, {
781 type: MessageType.editorDimensions,
782 ...editor.softDeleteDimension(message.dimensionId, session.authSubject)
783 });
784 break;
785 case MessageType.editorCancelDimensionDeletion:
786 requireAdmin(session);
787 send(session, {
788 type: MessageType.editorDimensions,
789 ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject)
790 });
791 break;
792 case MessageType.editorLoadSettings:
793 requireAdmin(session);
794 send(session, {
795 type: MessageType.editorSettings,
796 ...editor.loadSettings(),
797 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
798 });
799 break;
800 case MessageType.editorSaveSettings:
801 requireAdmin(session);
802 {
803 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
804 simulation.applySettings(saved.settings);
805 broadcastStatus();
806 broadcastSettings(saved);
807 }
808 break;
809 case MessageType.editorApplyRevision:
810 requireAdmin(session);
811 if (!editor.revisionStatus().pendingRevisionId)
812 {
813 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
814 break;
815 }
816 {
817 const appliedRevisionId = editor.applyPendingRevision();
818 simulation.reloadWorld();
819 for (const other of sessions.values())
820 {
821 if (other.entityId)
822 { syncSubscriptions(other, true); }
823 }
824 broadcastStatus();
825 send(session, {
826 type: MessageType.editorRevisionApplied,
827 ...editor.revisionStatus(),
828 appliedRevisionId
829 });
830 }
831 break;
832 case MessageType.editorLoadQuests:
833 requireAdmin(session);
834 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
835 break;
836 case MessageType.editorSaveQuest:
837 requireAdmin(session);
838 send(session, {
839 type: MessageType.editorQuests,
840 ...editor.saveQuest(message.quest ?? message, session.authSubject)
841 });
842 break;
843 case MessageType.editorDeleteQuest:
844 requireAdmin(session);
845 send(session, {
846 type: MessageType.editorQuests,
847 ...editor.deleteQuest(message.questId, session.authSubject)
848 });
849 break;
850 case MessageType.editorLoadDialogues:
851 requireAdmin(session);
852 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
853 break;
854 case MessageType.editorSaveDialogue:
855 requireAdmin(session);
856 send(session, {
857 type: MessageType.editorDialogues,
858 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
859 });
860 break;
861 case MessageType.editorDeleteDialogue:
862 requireAdmin(session);
863 send(session, {
864 type: MessageType.editorDialogues,
865 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
866 });
867 break;
868 case MessageType.dialogueChoose:
869 requirePlaying(session);
870 simulation.enqueue(session.id, {
871 type: "dialogue-choose",
872 characterId: session.characterId,
873 trigger: String(message.trigger ?? "")
874 });
875 break;
876 case MessageType.dialogueAdvance:
877 requirePlaying(session);
878 simulation.enqueue(session.id, {
879 type: "dialogue-advance",
880 characterId: session.characterId
881 });
882 break;
883 case MessageType.closeDialogue:
884 requirePlaying(session);
885 simulation.enqueue(session.id, {
886 type: "close-dialogue",
887 characterId: session.characterId
888 });
889 break;
890 case MessageType.requestQuests:
891 requirePlaying(session);
892 simulation.enqueue(session.id, {
893 type: "request-quests",
894 characterId: session.characterId
895 });
896 break;
897 case MessageType.setGraphicsSettings:
898 {
899 const next = normalizeGraphicsSettings({
900 viewDistance: message.viewDistance ?? session.viewDistance
901 });
902 const changed = next.viewDistance !== session.viewDistance;
903 session.viewDistance = next.viewDistance;
904 if (changed && session.entityId)
905 { syncSubscriptions(session, true); }
906 }
907 break;
908 default:
909 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
910 }
911 }
912
913 function enterWorld (session, characterId)
914 {
915 leaveWorld(session);
916 const character = characters.getOwned(session.account.account_id, characterId);
917 if (character.deletion_scheduled_at)
918 {
919 const error = new Error("That character is marked for deletion.");
920 error.userFacing = true;
921 throw error;
922 }
923 for (const other of sessions.values())
924 {
925 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
926 {
927 const error = new Error("This account already has a character in the world.");
928 error.userFacing = true;
929 throw error;
930 }
931 }
932 session.characterId = character.character_id;
933 session.entityId = simulation.spawnCharacter(session.id, character);
934 const spawned = simulation.entityRecord(session.entityId);
935 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
936 const dimRecord = simulation.getDimensionRecord?.(enterDim);
937 send(session, {
938 type: MessageType.enterWorld,
939 entityId: session.entityId,
940 characterId: session.characterId,
941 tileX: spawned.tileX,
942 tileY: spawned.tileY,
943 dimensionId: enterDim,
944 lightingMode: dimRecord?.lightingMode ?? "dayNight",
945 seasonMode: dimRecord?.seasonMode ?? "auto",
946 gait: spawned.gait,
947 sex: spawned.sex,
948 firstName: spawned.firstName,
949 lastName: spawned.lastName,
950 layers: spawned.layers ?? [],
951 health: spawned.health,
952 maxHealth: spawned.maxHealth,
953 settings: simulation.settings,
954 worldTime: simulation.worldTime()
955 });
956 syncSubscriptions(session, true);
957 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
958 const bag = simulation.bagOf(session.entityId);
959 if (bag)
960 { send(session, { type: MessageType.inventory, ...bag }); }
961 const skills = simulation.skillsOf(session.entityId);
962 if (skills)
963 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
964 const spellView = simulation.spellsOf(session.entityId);
965 if (spellView)
966 {
967 send(session, {
968 type: MessageType.spells,
969 spells: spellView.spells,
970 autoCast: spellView.autoCast,
971 armedSpellId: spellView.armedSpellId ?? null
972 });
973 }
974 const stamina = simulation.staminaOf(session.entityId);
975 if (stamina)
976 {
977 send(session, {
978 type: MessageType.stamina,
979 current: stamina.current,
980 max: stamina.max,
981 gait: stamina.gait
982 });
983 }
984 if (character.is_dead)
985 {
986 send(session, {
987 type: MessageType.playerDied,
988 entityId: session.entityId,
989 characterId: session.characterId
990 });
991 }
992 publishReplication(simulation.drainReplication());
993 }
994
995 function leaveWorld (session)
996 {
997 if (session.characterId)
998 { simulation.despawnCharacter(session.characterId); }
999 publishReplication(simulation.drainReplication());
1000 session.characterId = null;
1001 session.entityId = null;
1002 session.entitySubscribed.clear();
1003 session.staticSubscribed.clear();
1004 }
1005
1006 function syncSubscriptions (session, forceSnapshots)
1007 {
1008 if (!session.entityId)
1009 { return; }
1010 const position = simulation.positionOf(session.entityId);
1011 if (!position)
1012 { return; }
1013
1014 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1015 const centerChunkX = tileToChunk(position.tileX);
1016 const centerChunkY = tileToChunk(position.tileY);
1017 const mapRadius = staticChunkRadiusForViewDistance(
1018 session.viewDistance,
1019 STATIC_CHUNK_RADIUS,
1020 VISIBLE_CHUNK_RADIUS
1021 );
1022 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1023 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1024 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1025 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1026
1027 for (const key of session.staticSubscribed)
1028 {
1029 if (!staticNext.has(key))
1030 {
1031 const { chunkX, chunkY } = parseChunkKey(key);
1032 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1033 }
1034 }
1035
1036 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1037 for (const snapshot of snapshots)
1038 {
1039 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1040 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1041 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1042 {
1043 send(session, { type: MessageType.chunkSnapshot, ...snapshot });
1044 }
1045 }
1046 session.entitySubscribed = entityNext;
1047 session.staticSubscribed = staticNext;
1048 }
1049
1050 function requirePlaying (session)
1051 {
1052 if (!session.characterId)
1053 {
1054 const error = new Error("Select a character first.");
1055 error.userFacing = true;
1056 throw error;
1057 }
1058 }
1059
1060 function requireAdmin (session)
1061 {
1062 if (!session.account.is_admin)
1063 {
1064 const error = new Error("Admin only.");
1065 error.userFacing = true;
1066 throw error;
1067 }
1068 }
1069
1070 function broadcastStatus ()
1071 {
1072 const worldTime = simulation.worldTime();
1073 for (const session of sessions.values())
1074 {
1075 if (session.entityId)
1076 {
1077 send(session, {
1078 type: MessageType.worldStatus,
1079 worldTime,
1080 settings: simulation.settings,
1081 activeRevisionId: simulation.activeRevisionId
1082 });
1083 }
1084 }
1085 }
1086
1087 function pushFriends (...characterIds)
1088 {
1089 const seen = new Set();
1090 for (const characterId of characterIds)
1091 {
1092 const id = Number(characterId);
1093 if (!id || seen.has(id))
1094 { continue; }
1095 seen.add(id);
1096 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
1097 for (const session of sessions.values())
1098 {
1099 if (session.characterId === id)
1100 { send(session, payload); }
1101 }
1102 }
1103 }
1104
1105 function broadcastSettings (payload)
1106 {
1107 for (const session of sessions.values())
1108 {
1109 if (session.account.is_admin)
1110 { send(session, { type: MessageType.editorSettings, ...payload }); }
1111 }
1112 }
1113
1114 function onTickResult (result)
1115 {
1116 publishReplication(result.replication ?? []);
1117 for (const event of result.events)
1118 {
1119 if (event.type === "command-error")
1120 {
1121 const session = sessions.get(event.sessionId);
1122 if (session)
1123 { send(session, { type: MessageType.error, message: event.message }); }
1124 continue;
1125 }
1126 if (event.type === "inventory")
1127 {
1128 const session = event.sessionId != null
1129 ? sessions.get(event.sessionId)
1130 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1131 if (!session)
1132 { continue; }
1133 send(session, {
1134 type: MessageType.inventory,
1135 inventory: event.inventory,
1136 equipment: event.equipment,
1137 vault: event.vault,
1138 vaultReserved: event.vaultReserved
1139 });
1140 if (event.bank)
1141 {
1142 send(session, {
1143 type: MessageType.bankSnapshot,
1144 vault: event.vault,
1145 vaultReserved: event.vaultReserved,
1146 inheritance: stateDb.getInheritance(session.account.account_id)
1147 });
1148 }
1149 if (event.cauldron != null)
1150 {
1151 send(session, {
1152 type: MessageType.cauldronSnapshot,
1153 open: !!event.cauldron,
1154 state: event.cauldronState ?? null,
1155 alchemyResult: event.alchemyResult ?? null,
1156 dyeConfirm: event.dyeConfirm ?? null
1157 });
1158 }
1159 continue;
1160 }
1161 if (event.type === "skills")
1162 {
1163 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1164 if (!session)
1165 { continue; }
1166 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
1167 continue;
1168 }
1169 if (event.type === "spells")
1170 {
1171 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1172 if (!session)
1173 { continue; }
1174 send(session, {
1175 type: MessageType.spellsUpdated,
1176 spells: event.spells ?? [],
1177 autoCast: !!event.autoCast,
1178 armedSpellId: event.armedSpellId ?? null
1179 });
1180 continue;
1181 }
1182 if (event.type === "spell-armed")
1183 {
1184 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1185 if (!session)
1186 { continue; }
1187 send(session, {
1188 type: MessageType.spellArmed,
1189 spellId: event.spellId
1190 });
1191 continue;
1192 }
1193 if (event.type === "spell-disarmed")
1194 {
1195 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1196 if (!session)
1197 { continue; }
1198 send(session, { type: MessageType.spellDisarmed });
1199 continue;
1200 }
1201 if (event.type === "stamina")
1202 {
1203 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1204 if (!session)
1205 { continue; }
1206 send(session, {
1207 type: MessageType.stamina,
1208 current: event.current,
1209 max: event.max,
1210 gait: event.gait
1211 });
1212 continue;
1213 }
1214 if (event.type === "status-effects")
1215 {
1216 const session = event.sessionId != null
1217 ? sessions.get(event.sessionId)
1218 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1219 if (!session)
1220 { continue; }
1221 send(session, {
1222 type: MessageType.statusEffects,
1223 effects: event.effects ?? [],
1224 blind: !!event.blind
1225 });
1226 continue;
1227 }
1228 if (event.type === "toast")
1229 {
1230 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1231 if (session)
1232 { send(session, { type: MessageType.toast, message: event.message }); }
1233 continue;
1234 }
1235 if (event.type === "quests-snapshot")
1236 {
1237 const session = event.sessionId != null
1238 ? sessions.get(event.sessionId)
1239 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1240 if (session)
1241 {
1242 send(session, {
1243 type: MessageType.questsSnapshot,
1244 quests: event.quests ?? []
1245 });
1246 }
1247 continue;
1248 }
1249 if (event.type === "quest-step-complete")
1250 {
1251 const session = event.sessionId != null
1252 ? sessions.get(event.sessionId)
1253 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1254 if (session)
1255 {
1256 send(session, {
1257 type: MessageType.questStepComplete,
1258 questId: event.questId,
1259 title: event.title
1260 });
1261 }
1262 continue;
1263 }
1264 if (event.type === "dialogue-step")
1265 {
1266 const session = event.sessionId != null
1267 ? sessions.get(event.sessionId)
1268 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1269 if (session)
1270 {
1271 send(session, {
1272 type: MessageType.dialogueStep,
1273 dialogueId: event.dialogueId,
1274 stepId: event.stepId,
1275 label: event.label,
1276 npcEntityId: event.npcEntityId ?? null,
1277 lines: event.lines ?? []
1278 });
1279 }
1280 continue;
1281 }
1282 if (event.type === "dialogue-choices")
1283 {
1284 const session = event.sessionId != null
1285 ? sessions.get(event.sessionId)
1286 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1287 if (session)
1288 {
1289 send(session, {
1290 type: MessageType.dialogueChoices,
1291 dialogueId: event.dialogueId,
1292 stepId: event.stepId,
1293 npcEntityId: event.npcEntityId ?? null,
1294 triggers: event.triggers ?? []
1295 });
1296 }
1297 continue;
1298 }
1299 if (event.type === "dialogue-close")
1300 {
1301 const session = event.sessionId != null
1302 ? sessions.get(event.sessionId)
1303 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1304 if (session)
1305 {
1306 send(session, {
1307 type: MessageType.dialogueClose,
1308 reason: event.reason ?? null
1309 });
1310 }
1311 continue;
1312 }
1313 if (event.type === "pigeon-delivered")
1314 {
1315 for (const session of sessions.values())
1316 {
1317 if (session.characterId === event.senderCharacterId
1318 || session.characterId === event.destinationCharacterId)
1319 {
1320 send(session, {
1321 type: MessageType.pigeonDelivered,
1322 courierId: event.courierId,
1323 destinationKind: event.destinationKind,
1324 cargo: event.cargo
1325 });
1326 }
1327 }
1328 continue;
1329 }
1330 if (event.type === "player-died")
1331 {
1332 const session = sessions.get(event.sessionId);
1333 if (session)
1334 {
1335 send(session, {
1336 type: MessageType.playerDied,
1337 entityId: event.entityId,
1338 characterId: event.characterId
1339 });
1340 }
1341 continue;
1342 }
1343 if (event.type === "player-respawned")
1344 {
1345 const session = sessions.get(event.sessionId);
1346 if (session)
1347 {
1348 send(session, {
1349 type: MessageType.playerRespawned,
1350 entityId: event.entityId,
1351 characterId: event.characterId,
1352 tileX: event.tileX,
1353 tileY: event.tileY,
1354 health: event.health,
1355 maxHealth: event.maxHealth,
1356 stamina: event.stamina,
1357 maxStamina: event.maxStamina
1358 });
1359 }
1360 continue;
1361 }
1362 if (event.type === "dimension-changed")
1363 {
1364 const session = sessions.get(event.sessionId);
1365 if (session)
1366 {
1367 session.entitySubscribed.clear();
1368 session.staticSubscribed.clear();
1369 send(session, {
1370 type: MessageType.dimensionChanged,
1371 dimensionId: event.dimensionId,
1372 tileX: event.tileX,
1373 tileY: event.tileY,
1374 lightingMode: event.lightingMode,
1375 seasonMode: event.seasonMode
1376 });
1377 syncSubscriptions(session, true);
1378 }
1379 continue;
1380 }
1381 if (event.type === "combat-no-arrows")
1382 {
1383 const session = sessions.get(event.sessionId);
1384 if (session)
1385 { send(session, { type: MessageType.combatNoArrows }); }
1386 continue;
1387 }
1388 if (event.type === "craft-result")
1389 {
1390 const session = sessions.get(event.sessionId);
1391 if (session)
1392 {
1393 send(session, {
1394 type: MessageType.craftResult,
1395 recipeId: event.recipeId,
1396 ok: !!event.ok,
1397 error: event.error ?? null,
1398 burned: !!event.burned,
1399 continuing: !!event.continuing
1400 });
1401 }
1402 continue;
1403 }
1404 if (event.type === "station-open")
1405 {
1406 const session = sessions.get(event.sessionId);
1407 if (session)
1408 {
1409 send(session, {
1410 type: MessageType.stationOpen,
1411 stationId: event.stationId
1412 });
1413 }
1414 continue;
1415 }
1416 if (event.type === "shop-open")
1417 {
1418 const session = sessions.get(event.sessionId);
1419 if (session)
1420 {
1421 send(session, {
1422 type: MessageType.shopOpen,
1423 npcEntityId: event.npcEntityId,
1424 displayName: event.displayName,
1425 sex: event.sex === "female" ? "female" : "male",
1426 buysItems: !!event.buysItems,
1427 stock: event.stock ?? []
1428 });
1429 }
1430 continue;
1431 }
1432 if (event.type === "shop-closed")
1433 {
1434 const session = sessions.get(event.sessionId);
1435 if (session)
1436 {
1437 send(session, {
1438 type: MessageType.shopClosed,
1439 npcEntityId: event.npcEntityId
1440 });
1441 }
1442 continue;
1443 }
1444 if (event.type === "market-open")
1445 {
1446 const session = sessions.get(event.sessionId);
1447 if (session)
1448 {
1449 send(session, {
1450 type: MessageType.marketOpen,
1451 displayName: event.displayName,
1452 orders: event.orders ?? [],
1453 catalog: event.catalog ?? []
1454 });
1455 }
1456 continue;
1457 }
1458 if (event.type === "market-closed")
1459 {
1460 const session = sessions.get(event.sessionId);
1461 if (session)
1462 { send(session, { type: MessageType.marketClosed }); }
1463 continue;
1464 }
1465 if (event.type === "bounty-snapshot")
1466 {
1467 const session = sessions.get(event.sessionId);
1468 if (session)
1469 {
1470 send(session, {
1471 type: MessageType.bountySnapshot,
1472 myAmountCopper: event.myAmountCopper | 0,
1473 myAmountLabel: event.myAmountLabel ?? "",
1474 message: event.message ?? "",
1475 raised: event.raised ?? null
1476 });
1477 }
1478 continue;
1479 }
1480 if (event.type === "bounty-closed")
1481 {
1482 const session = sessions.get(event.sessionId);
1483 if (session)
1484 { send(session, { type: MessageType.closeBounty }); }
1485 continue;
1486 }
1487 if (event.type === "character-bounty")
1488 {
1489 const session = sessions.get(event.sessionId);
1490 if (session)
1491 {
1492 send(session, {
1493 type: MessageType.characterBounty,
1494 target: event.target ?? null
1495 });
1496 }
1497 continue;
1498 }
1499 if (event.type === "barber-snapshot")
1500 {
1501 const session = sessions.get(event.sessionId);
1502 if (session)
1503 {
1504 send(session, {
1505 type: MessageType.barberSnapshot,
1506 sex: event.sex,
1507 styles: event.styles ?? [],
1508 hair: event.hair ?? null,
1509 message: event.message ?? ""
1510 });
1511 }
1512 continue;
1513 }
1514 if (event.type === "barber-closed")
1515 {
1516 const session = sessions.get(event.sessionId);
1517 if (session)
1518 { send(session, { type: MessageType.closeBarber }); }
1519 continue;
1520 }
1521 if (event.type === "market-trade")
1522 {
1523 for (const session of sessions.values())
1524 {
1525 if (
1526 session.characterId === event.buyerCharacterId
1527 || session.characterId === event.sellerCharacterId
1528 )
1529 {
1530 send(session, {
1531 type: MessageType.marketTrade,
1532 itemId: event.itemId,
1533 quantity: event.quantity,
1534 unitPrice: event.unitPrice,
1535 triggeringSide: event.triggeringSide
1536 });
1537 }
1538 }
1539 continue;
1540 }
1541 if (event.type === "item-bubble")
1542 {
1543 broadcastItemBubble(
1544 sessions,
1545 simulation,
1546 event.entityId,
1547 event.itemId,
1548 event.quantity
1549 );
1550 continue;
1551 }
1552 if (event.type === "gather-swing" || event.type === "tile-shove")
1553 {
1554 publishEntity({
1555 ...event,
1556 type: event.type
1557 });
1558 continue;
1559 }
1560 if (event.type === "chunk-delta")
1561 {
1562 publishEntity(event);
1563 continue;
1564 }
1565 if (event.type === "gather-complete")
1566 {
1567 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1568 if (session)
1569 {
1570 send(session, {
1571 type: MessageType.gatherComplete,
1572 kind: event.kind,
1573 materialId: event.materialId,
1574 itemId: event.itemId
1575 });
1576 }
1577 continue;
1578 }
1579 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 === "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 === "entity-health" || event.type === "gather-swing" || event.type === "tile-shove" || event.type === "chunk-delta" || event.type === "skill-level-up")
1580 { publishEntity(event); }
1581 }
1582 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1583 { broadcastStatus(); }
1584 }
1585
1586 function publishReplication (events)
1587 {
1588 for (const event of events ?? [])
1589 { publishEntity(event); }
1590 }
1591
1592 function publishEntity (event)
1593 {
1594 const toDim = normalizeDimensionId(event.dimensionId
1595 ?? simulation.entityRecord(event.entityId)?.dimensionId
1596 ?? OVERWORLD_ID);
1597 const fromDim = event.fromDimensionId != null
1598 ? normalizeDimensionId(event.fromDimensionId)
1599 : toDim;
1600 const fromKey = event.fromTileX != null
1601 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
1602 : null;
1603 const toKey = event.tileX != null
1604 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
1605 : null;
1606 for (const session of sessions.values())
1607 {
1608 if (!session.entityId)
1609 { continue; }
1610 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1611 const seesTo = session.entitySubscribed.has(toKey);
1612 const seesStaticTo = session.staticSubscribed.has(toKey);
1613 if (event.type === "entity-spawn")
1614 {
1615 if (session.entityId === event.entityId || !seesTo)
1616 { continue; }
1617 send(session, spawnPayload(event));
1618 continue;
1619 }
1620 if (event.type === "entity-despawn")
1621 {
1622 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1623 { continue; }
1624 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1625 continue;
1626 }
1627 if (event.type === "entity-appearance")
1628 {
1629 if (!seesTo)
1630 { continue; }
1631 send(session, {
1632 type: MessageType.entityAppearance,
1633 entityId: event.entityId,
1634 sprite: event.sprite,
1635 layers: event.layers ?? [],
1636 lightRadiusTiles: event.lightRadiusTiles ?? 0
1637 });
1638 continue;
1639 }
1640 if (event.type === "ground-item-appear")
1641 {
1642 if (!seesTo)
1643 { continue; }
1644 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1645 continue;
1646 }
1647 if (event.type === "ground-item-despawn")
1648 {
1649 if (!seesTo)
1650 { continue; }
1651 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1652 continue;
1653 }
1654 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1655 {
1656 if (!seesTo && !seesFrom)
1657 { continue; }
1658 const type = event.type === "combat-swing"
1659 ? MessageType.combatSwing
1660 : event.type === "combat-hit"
1661 ? MessageType.combatHit
1662 : event.type === "combat-block"
1663 ? MessageType.combatBlock
1664 : MessageType.combatMiss;
1665 send(session, {
1666 type,
1667 attackerId: event.attackerId,
1668 targetId: event.targetId,
1669 damage: event.damage,
1670 health: event.health,
1671 maxHealth: event.maxHealth,
1672 tileX: event.tileX,
1673 tileY: event.tileY,
1674 fromTileX: event.fromTileX,
1675 fromTileY: event.fromTileY
1676 });
1677 continue;
1678 }
1679 if (event.type === "combat-projectile")
1680 {
1681 if (!seesTo && !seesFrom)
1682 { continue; }
1683 send(session, {
1684 type: MessageType.combatProjectile,
1685 attackerId: event.attackerId,
1686 targetId: event.targetId,
1687 fromTileX: event.fromTileX,
1688 fromTileY: event.fromTileY,
1689 tileX: event.tileX,
1690 tileY: event.tileY,
1691 durationMs: event.durationMs ?? 400,
1692 shaftTint: event.shaftTint ?? null,
1693 tipTint: event.tipTint ?? null
1694 });
1695 continue;
1696 }
1697 if (event.type === "spell-projectile")
1698 {
1699 if (!seesTo && !seesFrom)
1700 { continue; }
1701 send(session, {
1702 type: MessageType.spellProjectile,
1703 casterId: event.casterId,
1704 spellId: event.spellId,
1705 fromTileX: event.fromTileX,
1706 fromTileY: event.fromTileY,
1707 tileX: event.tileX,
1708 tileY: event.tileY,
1709 durationMs: event.durationMs ?? 2000,
1710 sprite: event.sprite ?? null
1711 });
1712 continue;
1713 }
1714 if (event.type === "spell-fizzle")
1715 {
1716 if (!seesTo && !seesFrom)
1717 { continue; }
1718 send(session, {
1719 type: MessageType.spellFizzle,
1720 casterId: event.casterId,
1721 spellId: event.spellId,
1722 fromTileX: event.fromTileX,
1723 fromTileY: event.fromTileY,
1724 tileX: event.tileX,
1725 tileY: event.tileY
1726 });
1727 continue;
1728 }
1729 if (event.type === "spell-cast-flash")
1730 {
1731 if (!seesTo)
1732 { continue; }
1733 send(session, {
1734 type: MessageType.spellCastFlash,
1735 casterId: event.casterId,
1736 tileX: event.tileX,
1737 tileY: event.tileY,
1738 radiusTiles: event.radiusTiles ?? 1,
1739 durationMs: event.durationMs ?? 500,
1740 tier: event.tier ?? 1
1741 });
1742 continue;
1743 }
1744 if (event.type === "spell-light-appear" || event.type === "spell-light-update")
1745 {
1746 if (!seesTo)
1747 { continue; }
1748 send(session, {
1749 type: event.type === "spell-light-appear"
1750 ? MessageType.spellLightAppear
1751 : MessageType.spellLightUpdate,
1752 tileX: event.tileX,
1753 tileY: event.tileY,
1754 ownerEntityId: event.ownerEntityId,
1755 remainingMs: event.remainingMs ?? 0,
1756 rangeTiles: event.rangeTiles ?? 0,
1757 intensity: event.intensity ?? 0,
1758 expiresAt: event.expiresAt ?? 0
1759 });
1760 continue;
1761 }
1762 if (event.type === "spell-light-remove")
1763 {
1764 if (!seesTo)
1765 { continue; }
1766 send(session, {
1767 type: MessageType.spellLightRemove,
1768 tileX: event.tileX,
1769 tileY: event.tileY
1770 });
1771 continue;
1772 }
1773 if (event.type === "entity-health")
1774 {
1775 if (!seesTo && !seesFrom)
1776 { continue; }
1777 send(session, {
1778 type: MessageType.entityHealth,
1779 entityId: event.entityId,
1780 health: event.health,
1781 maxHealth: event.maxHealth
1782 });
1783 continue;
1784 }
1785 if (event.type === "gather-swing" || event.type === "tile-shove")
1786 {
1787 if (!seesTo && !seesFrom)
1788 { continue; }
1789 if (event.type === "gather-swing")
1790 {
1791 send(session, {
1792 type: MessageType.gatherSwing,
1793 attackerId: event.attackerId,
1794 tileX: event.tileX,
1795 tileY: event.tileY,
1796 fromTileX: event.fromTileX,
1797 fromTileY: event.fromTileY,
1798 toolItemId: event.toolItemId ?? null
1799 });
1800 }
1801 else
1802 {
1803 send(session, {
1804 type: MessageType.tileShove,
1805 attackerId: event.attackerId,
1806 tileX: event.tileX,
1807 tileY: event.tileY,
1808 fromTileX: event.fromTileX,
1809 fromTileY: event.fromTileY
1810 });
1811 }
1812 continue;
1813 }
1814 if (event.type === "skill-level-up")
1815 {
1816 if (session.entityId !== event.entityId && !seesTo)
1817 { continue; }
1818 send(session, {
1819 type: MessageType.skillLevelUp,
1820 entityId: event.entityId,
1821 characterId: event.characterId,
1822 skillId: event.skillId,
1823 level: event.level,
1824 displayName: event.displayName,
1825 icon: event.icon
1826 });
1827 continue;
1828 }
1829 if (event.type === "chunk-delta")
1830 {
1831 if (!seesStaticTo)
1832 { continue; }
1833 send(session, {
1834 type: MessageType.chunkDelta,
1835 chunkX: event.chunkX,
1836 chunkY: event.chunkY,
1837 tiles: [{
1838 localX: event.localX,
1839 localY: event.localY,
1840 block: event.block
1841 }]
1842 });
1843 continue;
1844 }
1845 if (event.type !== "entity-move")
1846 { continue; }
1847 if (seesTo)
1848 {
1849 if (!seesFrom)
1850 { send(session, spawnPayload(event)); }
1851 else
1852 {
1853 send(session, {
1854 type: MessageType.entityMove,
1855 entityId: event.entityId,
1856 tileX: event.tileX,
1857 tileY: event.tileY,
1858 worldX: event.worldX,
1859 worldY: event.worldY,
1860 gait: event.gait,
1861 lerpMs: event.lerpMs,
1862 freeFlight: !!event.freeFlight
1863 });
1864 }
1865 }
1866 else if (seesFrom)
1867 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1868 if (session.entityId === event.entityId)
1869 {
1870 const crossedDimension = event.fromDimensionId != null
1871 && event.dimensionId != null
1872 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
1873 if (!crossedDimension)
1874 { syncSubscriptions(session, false); }
1875 }
1876 }
1877 }
1878
1879 function spawnPayload (event)
1880 {
1881 const record = simulation.entityRecord(event.entityId) ?? event;
1882 return {
1883 type: MessageType.entitySpawn,
1884 entityId: event.entityId,
1885 characterId: record.characterId ?? event.characterId ?? null,
1886 tileX: event.tileX ?? record.tileX,
1887 tileY: event.tileY ?? record.tileY,
1888 worldX: event.worldX ?? record.worldX,
1889 worldY: event.worldY ?? record.worldY,
1890 gait: event.gait ?? record.gait,
1891 sex: record.sex ?? event.sex ?? null,
1892 firstName: record.firstName ?? event.firstName ?? "",
1893 lastName: record.lastName ?? event.lastName ?? "",
1894 sprite: record.sprite ?? event.sprite ?? null,
1895 layers: record.layers ?? event.layers ?? [],
1896 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1897 canFight: !!(record.canFight ?? event.canFight),
1898 hostile: !!(record.hostile ?? event.hostile),
1899 talkable: !!(record.talkable ?? event.talkable),
1900 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
1901 hasShop: !!(record.hasShop ?? event.hasShop),
1902 untargetable: !!(record.untargetable ?? event.untargetable),
1903 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1904 health: record.health ?? event.health,
1905 maxHealth: record.maxHealth ?? event.maxHealth,
1906 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1907 };
1908 }
1909
1910 return {
1911 sessions,
1912 onTickResult,
1913 wss,
1914 async shutdown ()
1915 {
1916 await Promise.all([...sessions.values()].map(async (session) =>
1917 {
1918 await sendAsync(session, {
1919 type: MessageType.forceLogout,
1920 reason: "Server shutting down."
1921 });
1922 leaveWorld(session);
1923 await closeAsync(session, 1001, "Server shutting down.");
1924 }));
1925 sessions.clear();
1926 await simulation.shutdown();
1927 }
1928 };
1929}
1930
1931function send (session, payload)
1932{
1933 if (session.socket.readyState === 1)
1934 { session.socket.send(JSON.stringify(payload)); }
1935}
1936
1937function sendAsync (session, payload)
1938{
1939 return new Promise((resolve) =>
1940 {
1941 if (session.socket.readyState !== 1)
1942 {
1943 resolve();
1944 return;
1945 }
1946 session.socket.send(JSON.stringify(payload), () => resolve());
1947 });
1948}
1949
1950function closeAsync (session, code, reason)
1951{
1952 return new Promise((resolve) =>
1953 {
1954 if (session.socket.readyState !== 1)
1955 {
1956 resolve();
1957 return;
1958 }
1959 session.socket.once("close", resolve);
1960 try
1961 { session.socket.close(code, reason); }
1962 catch
1963 { resolve(); }
1964 });
1965}