BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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