BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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