BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

lots of things
timfa Tim Falken · pushed by timfa · 2 months ago
07a95f71 History
websocket.js 54.9 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 case "EDITOR_LIST_DIMENSIONS":
762 requireAdmin(session);
763 try
764 {
765 send(session, { type: MessageType.editorDimensions, ...editor.listDimensions() });
766 }
767 catch (err)
768 {
769 send(session, { type: MessageType.error, message: err.userFacing ? err.message : "Failed to list dimensions." });
770 }
771 break;
772 case MessageType.editorCreateDimension:
773 case "EDITOR_CREATE_DIMENSION":
774 requireAdmin(session);
775 send(session, {
776 type: MessageType.editorDimensions,
777 ...editor.createDimension(message.dimensionId, message.displayName, session.authSubject)
778 });
779 break;
780 case MessageType.editorSaveDimension:
781 case "EDITOR_SAVE_DIMENSION":
782 requireAdmin(session);
783 send(session, {
784 type: MessageType.editorDimensions,
785 ...editor.saveDimension(message.dimension ?? message, session.authSubject)
786 });
787 break;
788 case MessageType.editorSoftDeleteDimension:
789 case "EDITOR_SOFT_DELETE_DIMENSION":
790 requireAdmin(session);
791 send(session, {
792 type: MessageType.editorDimensions,
793 ...editor.softDeleteDimension(message.dimensionId, session.authSubject)
794 });
795 break;
796 case MessageType.editorCancelDimensionDeletion:
797 case "EDITOR_CANCEL_DIMENSION_DELETION":
798 requireAdmin(session);
799 send(session, {
800 type: MessageType.editorDimensions,
801 ...editor.cancelDimensionDeletion(message.dimensionId, session.authSubject)
802 });
803 break;
804 case MessageType.editorLoadSettings:
805 requireAdmin(session);
806 send(session, {
807 type: MessageType.editorSettings,
808 ...editor.loadSettings(),
809 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
810 });
811 break;
812 case MessageType.editorSaveSettings:
813 requireAdmin(session);
814 {
815 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
816 simulation.applySettings(saved.settings);
817 broadcastStatus();
818 broadcastSettings(saved);
819 }
820 break;
821 case MessageType.editorApplyRevision:
822 requireAdmin(session);
823 if (!editor.revisionStatus().pendingRevisionId)
824 {
825 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
826 break;
827 }
828 {
829 const appliedRevisionId = editor.applyPendingRevision();
830 simulation.reloadWorld();
831 for (const other of sessions.values())
832 {
833 if (other.entityId)
834 { syncSubscriptions(other, true); }
835 }
836 broadcastStatus();
837 send(session, {
838 type: MessageType.editorRevisionApplied,
839 ...editor.revisionStatus(),
840 appliedRevisionId
841 });
842 }
843 break;
844 case MessageType.editorLoadQuests:
845 requireAdmin(session);
846 send(session, { type: MessageType.editorQuests, ...editor.loadQuests() });
847 break;
848 case MessageType.editorSaveQuest:
849 requireAdmin(session);
850 send(session, {
851 type: MessageType.editorQuests,
852 ...editor.saveQuest(message.quest ?? message, session.authSubject)
853 });
854 break;
855 case MessageType.editorDeleteQuest:
856 requireAdmin(session);
857 send(session, {
858 type: MessageType.editorQuests,
859 ...editor.deleteQuest(message.questId, session.authSubject)
860 });
861 break;
862 case MessageType.editorLoadDialogues:
863 requireAdmin(session);
864 send(session, { type: MessageType.editorDialogues, ...editor.loadDialogues() });
865 break;
866 case MessageType.editorSaveDialogue:
867 requireAdmin(session);
868 send(session, {
869 type: MessageType.editorDialogues,
870 ...editor.saveDialogue(message.dialogue ?? message, session.authSubject)
871 });
872 break;
873 case MessageType.editorDeleteDialogue:
874 requireAdmin(session);
875 send(session, {
876 type: MessageType.editorDialogues,
877 ...editor.deleteDialogue(message.dialogueId, session.authSubject)
878 });
879 break;
880 case MessageType.dialogueChoose:
881 requirePlaying(session);
882 simulation.enqueue(session.id, {
883 type: "dialogue-choose",
884 characterId: session.characterId,
885 trigger: String(message.trigger ?? "")
886 });
887 break;
888 case MessageType.dialogueAdvance:
889 requirePlaying(session);
890 simulation.enqueue(session.id, {
891 type: "dialogue-advance",
892 characterId: session.characterId
893 });
894 break;
895 case MessageType.closeDialogue:
896 requirePlaying(session);
897 simulation.enqueue(session.id, {
898 type: "close-dialogue",
899 characterId: session.characterId
900 });
901 break;
902 case MessageType.requestQuests:
903 requirePlaying(session);
904 simulation.enqueue(session.id, {
905 type: "request-quests",
906 characterId: session.characterId
907 });
908 break;
909 case MessageType.setGraphicsSettings:
910 {
911 const next = normalizeGraphicsSettings({
912 viewDistance: message.viewDistance ?? session.viewDistance
913 });
914 const changed = next.viewDistance !== session.viewDistance;
915 session.viewDistance = next.viewDistance;
916 if (changed && session.entityId)
917 { syncSubscriptions(session, true); }
918 }
919 break;
920 default:
921 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
922 }
923 }
924
925 function enterWorld (session, characterId)
926 {
927 leaveWorld(session);
928 const character = characters.getOwned(session.account.account_id, characterId);
929 if (character.deletion_scheduled_at)
930 {
931 const error = new Error("That character is marked for deletion.");
932 error.userFacing = true;
933 throw error;
934 }
935 for (const other of sessions.values())
936 {
937 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
938 {
939 const error = new Error("This account already has a character in the world.");
940 error.userFacing = true;
941 throw error;
942 }
943 }
944 session.characterId = character.character_id;
945 session.entityId = simulation.spawnCharacter(session.id, character);
946 const spawned = simulation.entityRecord(session.entityId);
947 const enterDim = normalizeDimensionId(spawned.dimensionId ?? OVERWORLD_ID);
948 const dimRecord = simulation.getDimensionRecord?.(enterDim);
949 send(session, {
950 type: MessageType.enterWorld,
951 entityId: session.entityId,
952 characterId: session.characterId,
953 tileX: spawned.tileX,
954 tileY: spawned.tileY,
955 dimensionId: enterDim,
956 lightingMode: dimRecord?.lightingMode ?? "dayNight",
957 seasonMode: dimRecord?.seasonMode ?? "auto",
958 gait: spawned.gait,
959 sex: spawned.sex,
960 firstName: spawned.firstName,
961 lastName: spawned.lastName,
962 layers: spawned.layers ?? [],
963 health: spawned.health,
964 maxHealth: spawned.maxHealth,
965 settings: simulation.settings,
966 worldTime: simulation.worldTime()
967 });
968 syncSubscriptions(session, true);
969 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
970 const bag = simulation.bagOf(session.entityId);
971 if (bag)
972 { send(session, { type: MessageType.inventory, ...bag }); }
973 const skills = simulation.skillsOf(session.entityId);
974 if (skills)
975 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
976 const spellView = simulation.spellsOf(session.entityId);
977 if (spellView)
978 {
979 send(session, {
980 type: MessageType.spells,
981 spells: spellView.spells,
982 autoCast: spellView.autoCast,
983 armedSpellId: spellView.armedSpellId ?? null
984 });
985 }
986 const stamina = simulation.staminaOf(session.entityId);
987 if (stamina)
988 {
989 send(session, {
990 type: MessageType.stamina,
991 current: stamina.current,
992 max: stamina.max,
993 gait: stamina.gait
994 });
995 }
996 if (character.is_dead)
997 {
998 send(session, {
999 type: MessageType.playerDied,
1000 entityId: session.entityId,
1001 characterId: session.characterId
1002 });
1003 }
1004 publishReplication(simulation.drainReplication());
1005 }
1006
1007 function leaveWorld (session)
1008 {
1009 if (session.characterId)
1010 { simulation.despawnCharacter(session.characterId); }
1011 publishReplication(simulation.drainReplication());
1012 session.characterId = null;
1013 session.entityId = null;
1014 session.entitySubscribed.clear();
1015 session.staticSubscribed.clear();
1016 }
1017
1018 function syncSubscriptions (session, forceSnapshots)
1019 {
1020 if (!session.entityId)
1021 { return; }
1022 const position = simulation.positionOf(session.entityId);
1023 if (!position)
1024 { return; }
1025
1026 const dimensionId = normalizeDimensionId(position.dimensionId ?? OVERWORLD_ID);
1027 const centerChunkX = tileToChunk(position.tileX);
1028 const centerChunkY = tileToChunk(position.tileY);
1029 const mapRadius = staticChunkRadiusForViewDistance(
1030 session.viewDistance,
1031 STATIC_CHUNK_RADIUS,
1032 VISIBLE_CHUNK_RADIUS
1033 );
1034 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
1035 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
1036 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1037 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY, dimensionId)));
1038
1039 for (const key of session.staticSubscribed)
1040 {
1041 if (!staticNext.has(key))
1042 {
1043 const { chunkX, chunkY } = parseChunkKey(key);
1044 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
1045 }
1046 }
1047
1048 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
1049 for (const snapshot of snapshots)
1050 {
1051 const key = chunkKey(snapshot.chunkX, snapshot.chunkY, dimensionId);
1052 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
1053 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
1054 {
1055 send(session, { type: MessageType.chunkSnapshot, ...snapshot });
1056 }
1057 }
1058 session.entitySubscribed = entityNext;
1059 session.staticSubscribed = staticNext;
1060 }
1061
1062 function requirePlaying (session)
1063 {
1064 if (!session.characterId)
1065 {
1066 const error = new Error("Select a character first.");
1067 error.userFacing = true;
1068 throw error;
1069 }
1070 }
1071
1072 function requireAdmin (session)
1073 {
1074 if (!session.account.is_admin)
1075 {
1076 const error = new Error("Admin only.");
1077 error.userFacing = true;
1078 throw error;
1079 }
1080 }
1081
1082 function broadcastStatus ()
1083 {
1084 const worldTime = simulation.worldTime();
1085 for (const session of sessions.values())
1086 {
1087 if (session.entityId)
1088 {
1089 send(session, {
1090 type: MessageType.worldStatus,
1091 worldTime,
1092 settings: simulation.settings,
1093 activeRevisionId: simulation.activeRevisionId
1094 });
1095 }
1096 }
1097 }
1098
1099 function pushFriends (...characterIds)
1100 {
1101 const seen = new Set();
1102 for (const characterId of characterIds)
1103 {
1104 const id = Number(characterId);
1105 if (!id || seen.has(id))
1106 { continue; }
1107 seen.add(id);
1108 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
1109 for (const session of sessions.values())
1110 {
1111 if (session.characterId === id)
1112 { send(session, payload); }
1113 }
1114 }
1115 }
1116
1117 function broadcastSettings (payload)
1118 {
1119 for (const session of sessions.values())
1120 {
1121 if (session.account.is_admin)
1122 { send(session, { type: MessageType.editorSettings, ...payload }); }
1123 }
1124 }
1125
1126 function onTickResult (result)
1127 {
1128 publishReplication(result.replication ?? []);
1129 for (const event of result.events)
1130 {
1131 if (event.type === "command-error")
1132 {
1133 const session = sessions.get(event.sessionId);
1134 if (session)
1135 { send(session, { type: MessageType.error, message: event.message }); }
1136 continue;
1137 }
1138 if (event.type === "inventory")
1139 {
1140 const session = event.sessionId != null
1141 ? sessions.get(event.sessionId)
1142 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1143 if (!session)
1144 { continue; }
1145 send(session, {
1146 type: MessageType.inventory,
1147 inventory: event.inventory,
1148 equipment: event.equipment,
1149 vault: event.vault,
1150 vaultReserved: event.vaultReserved
1151 });
1152 if (event.bank)
1153 {
1154 send(session, {
1155 type: MessageType.bankSnapshot,
1156 vault: event.vault,
1157 vaultReserved: event.vaultReserved,
1158 inheritance: stateDb.getInheritance(session.account.account_id)
1159 });
1160 }
1161 if (event.cauldron != null)
1162 {
1163 send(session, {
1164 type: MessageType.cauldronSnapshot,
1165 open: !!event.cauldron,
1166 state: event.cauldronState ?? null,
1167 alchemyResult: event.alchemyResult ?? null,
1168 dyeConfirm: event.dyeConfirm ?? null
1169 });
1170 }
1171 continue;
1172 }
1173 if (event.type === "skills")
1174 {
1175 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1176 if (!session)
1177 { continue; }
1178 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
1179 continue;
1180 }
1181 if (event.type === "spells")
1182 {
1183 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1184 if (!session)
1185 { continue; }
1186 send(session, {
1187 type: MessageType.spellsUpdated,
1188 spells: event.spells ?? [],
1189 autoCast: !!event.autoCast,
1190 armedSpellId: event.armedSpellId ?? null
1191 });
1192 continue;
1193 }
1194 if (event.type === "spell-armed")
1195 {
1196 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1197 if (!session)
1198 { continue; }
1199 send(session, {
1200 type: MessageType.spellArmed,
1201 spellId: event.spellId
1202 });
1203 continue;
1204 }
1205 if (event.type === "spell-disarmed")
1206 {
1207 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1208 if (!session)
1209 { continue; }
1210 send(session, { type: MessageType.spellDisarmed });
1211 continue;
1212 }
1213 if (event.type === "stamina")
1214 {
1215 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1216 if (!session)
1217 { continue; }
1218 send(session, {
1219 type: MessageType.stamina,
1220 current: event.current,
1221 max: event.max,
1222 gait: event.gait
1223 });
1224 continue;
1225 }
1226 if (event.type === "status-effects")
1227 {
1228 const session = event.sessionId != null
1229 ? sessions.get(event.sessionId)
1230 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1231 if (!session)
1232 { continue; }
1233 send(session, {
1234 type: MessageType.statusEffects,
1235 effects: event.effects ?? [],
1236 blind: !!event.blind
1237 });
1238 continue;
1239 }
1240 if (event.type === "toast")
1241 {
1242 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1243 if (session)
1244 { send(session, { type: MessageType.toast, message: event.message }); }
1245 continue;
1246 }
1247 if (event.type === "quests-snapshot")
1248 {
1249 const session = event.sessionId != null
1250 ? sessions.get(event.sessionId)
1251 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1252 if (session)
1253 {
1254 send(session, {
1255 type: MessageType.questsSnapshot,
1256 quests: event.quests ?? []
1257 });
1258 }
1259 continue;
1260 }
1261 if (event.type === "quest-step-complete")
1262 {
1263 const session = event.sessionId != null
1264 ? sessions.get(event.sessionId)
1265 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1266 if (session)
1267 {
1268 send(session, {
1269 type: MessageType.questStepComplete,
1270 questId: event.questId,
1271 title: event.title
1272 });
1273 }
1274 continue;
1275 }
1276 if (event.type === "dialogue-step")
1277 {
1278 const session = event.sessionId != null
1279 ? sessions.get(event.sessionId)
1280 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1281 if (session)
1282 {
1283 send(session, {
1284 type: MessageType.dialogueStep,
1285 dialogueId: event.dialogueId,
1286 stepId: event.stepId,
1287 label: event.label,
1288 npcEntityId: event.npcEntityId ?? null,
1289 lines: event.lines ?? []
1290 });
1291 }
1292 continue;
1293 }
1294 if (event.type === "dialogue-choices")
1295 {
1296 const session = event.sessionId != null
1297 ? sessions.get(event.sessionId)
1298 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1299 if (session)
1300 {
1301 send(session, {
1302 type: MessageType.dialogueChoices,
1303 dialogueId: event.dialogueId,
1304 stepId: event.stepId,
1305 npcEntityId: event.npcEntityId ?? null,
1306 triggers: event.triggers ?? []
1307 });
1308 }
1309 continue;
1310 }
1311 if (event.type === "dialogue-close")
1312 {
1313 const session = event.sessionId != null
1314 ? sessions.get(event.sessionId)
1315 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1316 if (session)
1317 {
1318 send(session, {
1319 type: MessageType.dialogueClose,
1320 reason: event.reason ?? null
1321 });
1322 }
1323 continue;
1324 }
1325 if (event.type === "pigeon-delivered")
1326 {
1327 for (const session of sessions.values())
1328 {
1329 if (session.characterId === event.senderCharacterId
1330 || session.characterId === event.destinationCharacterId)
1331 {
1332 send(session, {
1333 type: MessageType.pigeonDelivered,
1334 courierId: event.courierId,
1335 destinationKind: event.destinationKind,
1336 cargo: event.cargo
1337 });
1338 }
1339 }
1340 continue;
1341 }
1342 if (event.type === "player-died")
1343 {
1344 const session = sessions.get(event.sessionId);
1345 if (session)
1346 {
1347 send(session, {
1348 type: MessageType.playerDied,
1349 entityId: event.entityId,
1350 characterId: event.characterId
1351 });
1352 }
1353 continue;
1354 }
1355 if (event.type === "player-respawned")
1356 {
1357 const session = sessions.get(event.sessionId);
1358 if (session)
1359 {
1360 send(session, {
1361 type: MessageType.playerRespawned,
1362 entityId: event.entityId,
1363 characterId: event.characterId,
1364 tileX: event.tileX,
1365 tileY: event.tileY,
1366 health: event.health,
1367 maxHealth: event.maxHealth,
1368 stamina: event.stamina,
1369 maxStamina: event.maxStamina
1370 });
1371 }
1372 continue;
1373 }
1374 if (event.type === "dimension-changed")
1375 {
1376 const session = sessions.get(event.sessionId);
1377 if (session)
1378 {
1379 session.entitySubscribed.clear();
1380 session.staticSubscribed.clear();
1381 send(session, {
1382 type: MessageType.dimensionChanged,
1383 dimensionId: event.dimensionId,
1384 tileX: event.tileX,
1385 tileY: event.tileY,
1386 lightingMode: event.lightingMode,
1387 seasonMode: event.seasonMode
1388 });
1389 syncSubscriptions(session, true);
1390 }
1391 continue;
1392 }
1393 if (event.type === "combat-no-arrows")
1394 {
1395 const session = sessions.get(event.sessionId);
1396 if (session)
1397 { send(session, { type: MessageType.combatNoArrows }); }
1398 continue;
1399 }
1400 if (event.type === "craft-result")
1401 {
1402 const session = sessions.get(event.sessionId);
1403 if (session)
1404 {
1405 send(session, {
1406 type: MessageType.craftResult,
1407 recipeId: event.recipeId,
1408 ok: !!event.ok,
1409 error: event.error ?? null,
1410 burned: !!event.burned,
1411 continuing: !!event.continuing
1412 });
1413 }
1414 continue;
1415 }
1416 if (event.type === "station-open")
1417 {
1418 const session = sessions.get(event.sessionId);
1419 if (session)
1420 {
1421 send(session, {
1422 type: MessageType.stationOpen,
1423 stationId: event.stationId
1424 });
1425 }
1426 continue;
1427 }
1428 if (event.type === "shop-open")
1429 {
1430 const session = sessions.get(event.sessionId);
1431 if (session)
1432 {
1433 send(session, {
1434 type: MessageType.shopOpen,
1435 npcEntityId: event.npcEntityId,
1436 displayName: event.displayName,
1437 sex: event.sex === "female" ? "female" : "male",
1438 buysItems: !!event.buysItems,
1439 stock: event.stock ?? []
1440 });
1441 }
1442 continue;
1443 }
1444 if (event.type === "shop-closed")
1445 {
1446 const session = sessions.get(event.sessionId);
1447 if (session)
1448 {
1449 send(session, {
1450 type: MessageType.shopClosed,
1451 npcEntityId: event.npcEntityId
1452 });
1453 }
1454 continue;
1455 }
1456 if (event.type === "market-open")
1457 {
1458 const session = sessions.get(event.sessionId);
1459 if (session)
1460 {
1461 send(session, {
1462 type: MessageType.marketOpen,
1463 displayName: event.displayName,
1464 orders: event.orders ?? [],
1465 catalog: event.catalog ?? []
1466 });
1467 }
1468 continue;
1469 }
1470 if (event.type === "market-closed")
1471 {
1472 const session = sessions.get(event.sessionId);
1473 if (session)
1474 { send(session, { type: MessageType.marketClosed }); }
1475 continue;
1476 }
1477 if (event.type === "bounty-snapshot")
1478 {
1479 const session = sessions.get(event.sessionId);
1480 if (session)
1481 {
1482 send(session, {
1483 type: MessageType.bountySnapshot,
1484 myAmountCopper: event.myAmountCopper | 0,
1485 myAmountLabel: event.myAmountLabel ?? "",
1486 message: event.message ?? "",
1487 raised: event.raised ?? null
1488 });
1489 }
1490 continue;
1491 }
1492 if (event.type === "bounty-closed")
1493 {
1494 const session = sessions.get(event.sessionId);
1495 if (session)
1496 { send(session, { type: MessageType.closeBounty }); }
1497 continue;
1498 }
1499 if (event.type === "character-bounty")
1500 {
1501 const session = sessions.get(event.sessionId);
1502 if (session)
1503 {
1504 send(session, {
1505 type: MessageType.characterBounty,
1506 target: event.target ?? null
1507 });
1508 }
1509 continue;
1510 }
1511 if (event.type === "barber-snapshot")
1512 {
1513 const session = sessions.get(event.sessionId);
1514 if (session)
1515 {
1516 send(session, {
1517 type: MessageType.barberSnapshot,
1518 sex: event.sex,
1519 styles: event.styles ?? [],
1520 hair: event.hair ?? null,
1521 message: event.message ?? ""
1522 });
1523 }
1524 continue;
1525 }
1526 if (event.type === "barber-closed")
1527 {
1528 const session = sessions.get(event.sessionId);
1529 if (session)
1530 { send(session, { type: MessageType.closeBarber }); }
1531 continue;
1532 }
1533 if (event.type === "market-trade")
1534 {
1535 for (const session of sessions.values())
1536 {
1537 if (
1538 session.characterId === event.buyerCharacterId
1539 || session.characterId === event.sellerCharacterId
1540 )
1541 {
1542 send(session, {
1543 type: MessageType.marketTrade,
1544 itemId: event.itemId,
1545 quantity: event.quantity,
1546 unitPrice: event.unitPrice,
1547 triggeringSide: event.triggeringSide
1548 });
1549 }
1550 }
1551 continue;
1552 }
1553 if (event.type === "item-bubble")
1554 {
1555 broadcastItemBubble(
1556 sessions,
1557 simulation,
1558 event.entityId,
1559 event.itemId,
1560 event.quantity
1561 );
1562 continue;
1563 }
1564 if (event.type === "gather-swing" || event.type === "tile-shove")
1565 {
1566 publishEntity({
1567 ...event,
1568 type: event.type
1569 });
1570 continue;
1571 }
1572 if (event.type === "chunk-delta")
1573 {
1574 publishEntity(event);
1575 continue;
1576 }
1577 if (event.type === "gather-complete")
1578 {
1579 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1580 if (session)
1581 {
1582 send(session, {
1583 type: MessageType.gatherComplete,
1584 kind: event.kind,
1585 materialId: event.materialId,
1586 itemId: event.itemId
1587 });
1588 }
1589 continue;
1590 }
1591 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")
1592 { publishEntity(event); }
1593 }
1594 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1595 { broadcastStatus(); }
1596 }
1597
1598 function publishReplication (events)
1599 {
1600 for (const event of events ?? [])
1601 { publishEntity(event); }
1602 }
1603
1604 function publishEntity (event)
1605 {
1606 const toDim = normalizeDimensionId(event.dimensionId
1607 ?? simulation.entityRecord(event.entityId)?.dimensionId
1608 ?? OVERWORLD_ID);
1609 const fromDim = event.fromDimensionId != null
1610 ? normalizeDimensionId(event.fromDimensionId)
1611 : toDim;
1612 const fromKey = event.fromTileX != null
1613 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY), fromDim)
1614 : null;
1615 const toKey = event.tileX != null
1616 ? chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY), toDim)
1617 : null;
1618 for (const session of sessions.values())
1619 {
1620 if (!session.entityId)
1621 { continue; }
1622 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1623 const seesTo = session.entitySubscribed.has(toKey);
1624 const seesStaticTo = session.staticSubscribed.has(toKey);
1625 if (event.type === "entity-spawn")
1626 {
1627 if (session.entityId === event.entityId || !seesTo)
1628 { continue; }
1629 send(session, spawnPayload(event));
1630 continue;
1631 }
1632 if (event.type === "entity-despawn")
1633 {
1634 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1635 { continue; }
1636 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1637 continue;
1638 }
1639 if (event.type === "entity-appearance")
1640 {
1641 if (!seesTo)
1642 { continue; }
1643 send(session, {
1644 type: MessageType.entityAppearance,
1645 entityId: event.entityId,
1646 sprite: event.sprite,
1647 layers: event.layers ?? [],
1648 lightRadiusTiles: event.lightRadiusTiles ?? 0
1649 });
1650 continue;
1651 }
1652 if (event.type === "ground-item-appear")
1653 {
1654 if (!seesTo)
1655 { continue; }
1656 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1657 continue;
1658 }
1659 if (event.type === "ground-item-despawn")
1660 {
1661 if (!seesTo)
1662 { continue; }
1663 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1664 continue;
1665 }
1666 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1667 {
1668 if (!seesTo && !seesFrom)
1669 { continue; }
1670 const type = event.type === "combat-swing"
1671 ? MessageType.combatSwing
1672 : event.type === "combat-hit"
1673 ? MessageType.combatHit
1674 : event.type === "combat-block"
1675 ? MessageType.combatBlock
1676 : MessageType.combatMiss;
1677 send(session, {
1678 type,
1679 attackerId: event.attackerId,
1680 targetId: event.targetId,
1681 damage: event.damage,
1682 health: event.health,
1683 maxHealth: event.maxHealth,
1684 tileX: event.tileX,
1685 tileY: event.tileY,
1686 fromTileX: event.fromTileX,
1687 fromTileY: event.fromTileY
1688 });
1689 continue;
1690 }
1691 if (event.type === "combat-projectile")
1692 {
1693 if (!seesTo && !seesFrom)
1694 { continue; }
1695 send(session, {
1696 type: MessageType.combatProjectile,
1697 attackerId: event.attackerId,
1698 targetId: event.targetId,
1699 fromTileX: event.fromTileX,
1700 fromTileY: event.fromTileY,
1701 tileX: event.tileX,
1702 tileY: event.tileY,
1703 durationMs: event.durationMs ?? 400,
1704 shaftTint: event.shaftTint ?? null,
1705 tipTint: event.tipTint ?? null
1706 });
1707 continue;
1708 }
1709 if (event.type === "spell-projectile")
1710 {
1711 if (!seesTo && !seesFrom)
1712 { continue; }
1713 send(session, {
1714 type: MessageType.spellProjectile,
1715 casterId: event.casterId,
1716 spellId: event.spellId,
1717 fromTileX: event.fromTileX,
1718 fromTileY: event.fromTileY,
1719 tileX: event.tileX,
1720 tileY: event.tileY,
1721 durationMs: event.durationMs ?? 2000,
1722 sprite: event.sprite ?? null
1723 });
1724 continue;
1725 }
1726 if (event.type === "spell-fizzle")
1727 {
1728 if (!seesTo && !seesFrom)
1729 { continue; }
1730 send(session, {
1731 type: MessageType.spellFizzle,
1732 casterId: event.casterId,
1733 spellId: event.spellId,
1734 fromTileX: event.fromTileX,
1735 fromTileY: event.fromTileY,
1736 tileX: event.tileX,
1737 tileY: event.tileY
1738 });
1739 continue;
1740 }
1741 if (event.type === "spell-cast-flash")
1742 {
1743 if (!seesTo)
1744 { continue; }
1745 send(session, {
1746 type: MessageType.spellCastFlash,
1747 casterId: event.casterId,
1748 tileX: event.tileX,
1749 tileY: event.tileY,
1750 radiusTiles: event.radiusTiles ?? 1,
1751 durationMs: event.durationMs ?? 500,
1752 tier: event.tier ?? 1
1753 });
1754 continue;
1755 }
1756 if (event.type === "spell-light-appear" || event.type === "spell-light-update")
1757 {
1758 if (!seesTo)
1759 { continue; }
1760 send(session, {
1761 type: event.type === "spell-light-appear"
1762 ? MessageType.spellLightAppear
1763 : MessageType.spellLightUpdate,
1764 tileX: event.tileX,
1765 tileY: event.tileY,
1766 ownerEntityId: event.ownerEntityId,
1767 remainingMs: event.remainingMs ?? 0,
1768 rangeTiles: event.rangeTiles ?? 0,
1769 intensity: event.intensity ?? 0,
1770 expiresAt: event.expiresAt ?? 0
1771 });
1772 continue;
1773 }
1774 if (event.type === "spell-light-remove")
1775 {
1776 if (!seesTo)
1777 { continue; }
1778 send(session, {
1779 type: MessageType.spellLightRemove,
1780 tileX: event.tileX,
1781 tileY: event.tileY
1782 });
1783 continue;
1784 }
1785 if (event.type === "entity-health")
1786 {
1787 if (!seesTo && !seesFrom)
1788 { continue; }
1789 send(session, {
1790 type: MessageType.entityHealth,
1791 entityId: event.entityId,
1792 health: event.health,
1793 maxHealth: event.maxHealth
1794 });
1795 continue;
1796 }
1797 if (event.type === "gather-swing" || event.type === "tile-shove")
1798 {
1799 if (!seesTo && !seesFrom)
1800 { continue; }
1801 if (event.type === "gather-swing")
1802 {
1803 send(session, {
1804 type: MessageType.gatherSwing,
1805 attackerId: event.attackerId,
1806 tileX: event.tileX,
1807 tileY: event.tileY,
1808 fromTileX: event.fromTileX,
1809 fromTileY: event.fromTileY,
1810 toolItemId: event.toolItemId ?? null
1811 });
1812 }
1813 else
1814 {
1815 send(session, {
1816 type: MessageType.tileShove,
1817 attackerId: event.attackerId,
1818 tileX: event.tileX,
1819 tileY: event.tileY,
1820 fromTileX: event.fromTileX,
1821 fromTileY: event.fromTileY
1822 });
1823 }
1824 continue;
1825 }
1826 if (event.type === "skill-level-up")
1827 {
1828 if (session.entityId !== event.entityId && !seesTo)
1829 { continue; }
1830 send(session, {
1831 type: MessageType.skillLevelUp,
1832 entityId: event.entityId,
1833 characterId: event.characterId,
1834 skillId: event.skillId,
1835 level: event.level,
1836 displayName: event.displayName,
1837 icon: event.icon
1838 });
1839 continue;
1840 }
1841 if (event.type === "chunk-delta")
1842 {
1843 if (!seesStaticTo)
1844 { continue; }
1845 send(session, {
1846 type: MessageType.chunkDelta,
1847 chunkX: event.chunkX,
1848 chunkY: event.chunkY,
1849 tiles: [{
1850 localX: event.localX,
1851 localY: event.localY,
1852 block: event.block
1853 }]
1854 });
1855 continue;
1856 }
1857 if (event.type !== "entity-move")
1858 { continue; }
1859 if (seesTo)
1860 {
1861 if (!seesFrom)
1862 { send(session, spawnPayload(event)); }
1863 else
1864 {
1865 send(session, {
1866 type: MessageType.entityMove,
1867 entityId: event.entityId,
1868 tileX: event.tileX,
1869 tileY: event.tileY,
1870 worldX: event.worldX,
1871 worldY: event.worldY,
1872 gait: event.gait,
1873 lerpMs: event.lerpMs,
1874 freeFlight: !!event.freeFlight
1875 });
1876 }
1877 }
1878 else if (seesFrom)
1879 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1880 if (session.entityId === event.entityId)
1881 {
1882 const crossedDimension = event.fromDimensionId != null
1883 && event.dimensionId != null
1884 && normalizeDimensionId(event.fromDimensionId) !== normalizeDimensionId(event.dimensionId);
1885 if (!crossedDimension)
1886 { syncSubscriptions(session, false); }
1887 }
1888 }
1889 }
1890
1891 function spawnPayload (event)
1892 {
1893 const record = simulation.entityRecord(event.entityId) ?? event;
1894 return {
1895 type: MessageType.entitySpawn,
1896 entityId: event.entityId,
1897 characterId: record.characterId ?? event.characterId ?? null,
1898 tileX: event.tileX ?? record.tileX,
1899 tileY: event.tileY ?? record.tileY,
1900 worldX: event.worldX ?? record.worldX,
1901 worldY: event.worldY ?? record.worldY,
1902 gait: event.gait ?? record.gait,
1903 sex: record.sex ?? event.sex ?? null,
1904 firstName: record.firstName ?? event.firstName ?? "",
1905 lastName: record.lastName ?? event.lastName ?? "",
1906 sprite: record.sprite ?? event.sprite ?? null,
1907 layers: record.layers ?? event.layers ?? [],
1908 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1909 canFight: !!(record.canFight ?? event.canFight),
1910 hostile: !!(record.hostile ?? event.hostile),
1911 talkable: !!(record.talkable ?? event.talkable),
1912 hasDialogue: !!(record.hasDialogue ?? event.hasDialogue),
1913 hasShop: !!(record.hasShop ?? event.hasShop),
1914 untargetable: !!(record.untargetable ?? event.untargetable),
1915 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1916 health: record.health ?? event.health,
1917 maxHealth: record.maxHealth ?? event.maxHealth,
1918 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1919 };
1920 }
1921
1922 return {
1923 sessions,
1924 onTickResult,
1925 wss,
1926 async shutdown ()
1927 {
1928 await Promise.all([...sessions.values()].map(async (session) =>
1929 {
1930 await sendAsync(session, {
1931 type: MessageType.forceLogout,
1932 reason: "Server shutting down."
1933 });
1934 leaveWorld(session);
1935 await closeAsync(session, 1001, "Server shutting down.");
1936 }));
1937 sessions.clear();
1938 await simulation.shutdown();
1939 }
1940 };
1941}
1942
1943function send (session, payload)
1944{
1945 if (session.socket.readyState === 1)
1946 { session.socket.send(JSON.stringify(payload)); }
1947}
1948
1949function sendAsync (session, payload)
1950{
1951 return new Promise((resolve) =>
1952 {
1953 if (session.socket.readyState !== 1)
1954 {
1955 resolve();
1956 return;
1957 }
1958 session.socket.send(JSON.stringify(payload), () => resolve());
1959 });
1960}
1961
1962function closeAsync (session, code, reason)
1963{
1964 return new Promise((resolve) =>
1965 {
1966 if (session.socket.readyState !== 1)
1967 {
1968 resolve();
1969 return;
1970 }
1971 session.socket.once("close", resolve);
1972 try
1973 { session.socket.close(code, reason); }
1974 catch
1975 { resolve(); }
1976 });
1977}