BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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