BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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