BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 47.3 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 slotIndex: message.slotIndex | 0
387 });
388 break;
389 case MessageType.cauldronAction:
390 requirePlaying(session);
391 simulation.enqueue(session.id, {
392 type: "cauldron-action",
393 characterId: session.characterId,
394 action: message.action
395 });
396 break;
397 case MessageType.cauldronBottle:
398 requirePlaying(session);
399 simulation.enqueue(session.id, {
400 type: "cauldron-bottle",
401 characterId: session.characterId
402 });
403 break;
404 case MessageType.cauldronCreateDye:
405 requirePlaying(session);
406 simulation.enqueue(session.id, {
407 type: "cauldron-create-dye",
408 characterId: session.characterId,
409 confirmOverflow: !!message.confirmOverflow
410 });
411 break;
412 case MessageType.cauldronClear:
413 requirePlaying(session);
414 simulation.enqueue(session.id, {
415 type: "cauldron-clear",
416 characterId: session.characterId
417 });
418 break;
419 case MessageType.cauldronClearDye:
420 requirePlaying(session);
421 simulation.enqueue(session.id, {
422 type: "cauldron-clear-dye",
423 characterId: session.characterId
424 });
425 break;
426 case MessageType.cauldronSaveRecipe:
427 requirePlaying(session);
428 simulation.enqueue(session.id, {
429 type: "cauldron-save-recipe",
430 characterId: session.characterId
431 });
432 break;
433 case MessageType.cauldronClose:
434 requirePlaying(session);
435 simulation.enqueue(session.id, {
436 type: "cauldron-close",
437 characterId: session.characterId
438 });
439 break;
440 case MessageType.bankDeposit:
441 requirePlaying(session);
442 simulation.enqueue(session.id, {
443 type: "bank-deposit",
444 characterId: session.characterId,
445 slotIndex: message.slotIndex | 0,
446 quantity: message.quantity ?? null
447 });
448 break;
449 case MessageType.bankWithdraw:
450 requirePlaying(session);
451 simulation.enqueue(session.id, {
452 type: "bank-withdraw",
453 characterId: session.characterId,
454 slotIndex: message.slotIndex | 0,
455 quantity: message.quantity ?? null
456 });
457 break;
458 case MessageType.getBlankCheques:
459 requirePlaying(session);
460 simulation.enqueue(session.id, {
461 type: "get-blank-cheques",
462 characterId: session.characterId
463 });
464 break;
465 case MessageType.returnBlankCheques:
466 requirePlaying(session);
467 simulation.enqueue(session.id, {
468 type: "return-blank-cheques",
469 characterId: session.characterId,
470 slotIndex: message.slotIndex | 0,
471 quantity: message.quantity ?? null
472 });
473 break;
474 case MessageType.writeCheque:
475 requirePlaying(session);
476 simulation.enqueue(session.id, {
477 type: "write-cheque",
478 characterId: session.characterId,
479 slotIndex: message.slotIndex | 0,
480 vaultSlotIndex: message.vaultSlotIndex | 0,
481 quantity: message.quantity ?? 1
482 });
483 break;
484 case MessageType.redeemCheque:
485 requirePlaying(session);
486 simulation.enqueue(session.id, {
487 type: "redeem-cheque",
488 characterId: session.characterId,
489 slotIndex: message.slotIndex | 0
490 });
491 break;
492 case MessageType.claimInheritance:
493 requirePlaying(session);
494 {
495 const inheritance = stateDb.getInheritance(session.account.account_id);
496 simulation.enqueue(session.id, {
497 type: "claim-inheritance",
498 characterId: session.characterId,
499 stacks: (inheritance.slots ?? []).filter(Boolean)
500 });
501 }
502 break;
503 case MessageType.attack:
504 requirePlaying(session);
505 simulation.enqueue(session.id, {
506 type: "attack",
507 characterId: session.characterId,
508 targetEntityId: message.targetEntityId | 0
509 });
510 break;
511 case MessageType.cancelAttack:
512 requirePlaying(session);
513 simulation.enqueue(session.id, {
514 type: "cancel-attack",
515 characterId: session.characterId
516 });
517 break;
518 case MessageType.setSpellFavorite:
519 requirePlaying(session);
520 simulation.enqueue(session.id, {
521 type: "set-spell-favorite",
522 characterId: session.characterId,
523 spellId: message.spellId
524 });
525 break;
526 case MessageType.setSpellAutoCast:
527 requirePlaying(session);
528 simulation.enqueue(session.id, {
529 type: "set-spell-autocast",
530 characterId: session.characterId,
531 enabled: !!message.enabled
532 });
533 break;
534 case MessageType.armSpell:
535 requirePlaying(session);
536 simulation.enqueue(session.id, {
537 type: "arm-spell",
538 characterId: session.characterId,
539 spellId: message.spellId
540 });
541 break;
542 case MessageType.cancelArmSpell:
543 requirePlaying(session);
544 simulation.enqueue(session.id, {
545 type: "cancel-arm-spell",
546 characterId: session.characterId
547 });
548 break;
549 case MessageType.castSpellTile:
550 requirePlaying(session);
551 simulation.enqueue(session.id, {
552 type: "cast-spell-tile",
553 characterId: session.characterId,
554 spellId: message.spellId,
555 tileX: message.tileX | 0,
556 tileY: message.tileY | 0
557 });
558 break;
559 case MessageType.castSpellEntity:
560 requirePlaying(session);
561 simulation.enqueue(session.id, {
562 type: "cast-spell-entity",
563 characterId: session.characterId,
564 spellId: message.spellId,
565 targetEntityId: message.targetEntityId | 0
566 });
567 break;
568 case MessageType.readSpellbook:
569 requirePlaying(session);
570 simulation.enqueue(session.id, {
571 type: "read-spellbook",
572 characterId: session.characterId,
573 slotIndex: message.slotIndex | 0
574 });
575 break;
576 case MessageType.interact:
577 requirePlaying(session);
578 simulation.enqueue(session.id, {
579 type: "interact",
580 characterId: session.characterId,
581 targetEntityId: message.targetEntityId | 0
582 });
583 break;
584 case MessageType.buyFromShop:
585 requirePlaying(session);
586 simulation.enqueue(session.id, {
587 type: "buy-from-shop",
588 characterId: session.characterId,
589 npcEntityId: message.npcEntityId | 0,
590 itemId: message.itemId | 0,
591 quantity: message.quantity | 0 || 1,
592 listingId: typeof message.listingId === "string" ? message.listingId : null,
593 source: typeof message.source === "string" ? message.source : null
594 });
595 break;
596 case MessageType.sellToShop:
597 requirePlaying(session);
598 simulation.enqueue(session.id, {
599 type: "sell-to-shop",
600 characterId: session.characterId,
601 npcEntityId: message.npcEntityId | 0,
602 slotIndex: message.slotIndex | 0,
603 quantity: message.quantity | 0 || 1
604 });
605 break;
606 case MessageType.closeShop:
607 requirePlaying(session);
608 simulation.enqueue(session.id, {
609 type: "close-shop",
610 characterId: session.characterId,
611 npcEntityId: message.npcEntityId | 0
612 });
613 break;
614 case MessageType.openMarket:
615 requirePlaying(session);
616 simulation.enqueue(session.id, {
617 type: "open-market",
618 characterId: session.characterId
619 });
620 break;
621 case MessageType.closeMarket:
622 requirePlaying(session);
623 simulation.enqueue(session.id, {
624 type: "close-market",
625 characterId: session.characterId
626 });
627 break;
628 case MessageType.placeMarketSell:
629 requirePlaying(session);
630 simulation.enqueue(session.id, {
631 type: "place-market-sell",
632 characterId: session.characterId,
633 slotIndex: message.slotIndex | 0,
634 quantity: message.quantity | 0 || 1,
635 minUnitPrice: message.minUnitPrice | 0
636 });
637 break;
638 case MessageType.placeMarketBuy:
639 requirePlaying(session);
640 simulation.enqueue(session.id, {
641 type: "place-market-buy",
642 characterId: session.characterId,
643 itemId: message.itemId | 0,
644 quantity: message.quantity | 0 || 1,
645 maxUnitPrice: message.maxUnitPrice | 0
646 });
647 break;
648 case MessageType.cancelMarketOrder:
649 requirePlaying(session);
650 simulation.enqueue(session.id, {
651 type: "cancel-market-order",
652 characterId: session.characterId,
653 orderId: message.orderId | 0
654 });
655 break;
656 case MessageType.follow:
657 requirePlaying(session);
658 simulation.enqueue(session.id, {
659 type: "follow",
660 characterId: session.characterId,
661 targetEntityId: message.targetEntityId | 0
662 });
663 break;
664 case MessageType.cancelFollow:
665 requirePlaying(session);
666 simulation.enqueue(session.id, {
667 type: "cancel-follow",
668 characterId: session.characterId
669 });
670 break;
671 case MessageType.sendPigeon:
672 requirePlaying(session);
673 {
674 const result = simulation.dispatchPigeon({
675 characterId: session.characterId,
676 destination: message.destination,
677 cargo: message.cargo
678 });
679 send(session, {
680 type: MessageType.pigeonDispatched,
681 courierId: result.transit.courierId,
682 destinationKind: result.transit.destinationKind,
683 destinationCharacterId: result.transit.destinationCharacterId
684 });
685 send(session, { type: MessageType.inventory, ...result.bag });
686 }
687 break;
688 case MessageType.searchCharacter:
689 requirePlaying(session);
690 {
691 const character = friends.findByFullName(message.firstName, message.lastName);
692 send(session, {
693 type: MessageType.characterSearchResult,
694 character: character ?? null
695 });
696 }
697 break;
698 case MessageType.writeLetter:
699 requirePlaying(session);
700 simulation.enqueue(session.id, {
701 type: "write-letter",
702 characterId: session.characterId,
703 slotIndex: message.slotIndex,
704 body: message.body
705 });
706 break;
707 case MessageType.editLetter:
708 requirePlaying(session);
709 simulation.enqueue(session.id, {
710 type: "edit-letter",
711 characterId: session.characterId,
712 slotIndex: message.slotIndex,
713 body: message.body
714 });
715 break;
716 case MessageType.openLetter:
717 requirePlaying(session);
718 simulation.enqueue(session.id, {
719 type: "open-letter",
720 characterId: session.characterId,
721 slotIndex: message.slotIndex
722 });
723 break;
724 case MessageType.editorLoadChunk:
725 requireAdmin(session);
726 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
727 break;
728 case MessageType.editorSaveChunk:
729 requireAdmin(session);
730 send(session, {
731 type: MessageType.editorChunk,
732 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
733 });
734 break;
735 case MessageType.editorLoadSettings:
736 requireAdmin(session);
737 send(session, {
738 type: MessageType.editorSettings,
739 ...editor.loadSettings(),
740 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
741 });
742 break;
743 case MessageType.editorSaveSettings:
744 requireAdmin(session);
745 {
746 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
747 simulation.applySettings(saved.settings);
748 broadcastStatus();
749 broadcastSettings(saved);
750 }
751 break;
752 case MessageType.editorApplyRevision:
753 requireAdmin(session);
754 if (!editor.revisionStatus().pendingRevisionId)
755 {
756 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
757 break;
758 }
759 {
760 const appliedRevisionId = editor.applyPendingRevision();
761 simulation.reloadWorld();
762 for (const other of sessions.values())
763 {
764 if (other.entityId)
765 { syncSubscriptions(other, true); }
766 }
767 broadcastStatus();
768 send(session, {
769 type: MessageType.editorRevisionApplied,
770 ...editor.revisionStatus(),
771 appliedRevisionId
772 });
773 }
774 break;
775 case MessageType.setGraphicsSettings:
776 {
777 const next = normalizeGraphicsSettings({
778 viewDistance: message.viewDistance ?? session.viewDistance
779 });
780 const changed = next.viewDistance !== session.viewDistance;
781 session.viewDistance = next.viewDistance;
782 if (changed && session.entityId)
783 { syncSubscriptions(session, true); }
784 }
785 break;
786 default:
787 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
788 }
789 }
790
791 function enterWorld (session, characterId)
792 {
793 leaveWorld(session);
794 const character = characters.getOwned(session.account.account_id, characterId);
795 if (character.deletion_scheduled_at)
796 {
797 const error = new Error("That character is marked for deletion.");
798 error.userFacing = true;
799 throw error;
800 }
801 for (const other of sessions.values())
802 {
803 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
804 {
805 const error = new Error("This account already has a character in the world.");
806 error.userFacing = true;
807 throw error;
808 }
809 }
810 session.characterId = character.character_id;
811 session.entityId = simulation.spawnCharacter(session.id, character);
812 const spawned = simulation.entityRecord(session.entityId);
813 send(session, {
814 type: MessageType.enterWorld,
815 entityId: session.entityId,
816 characterId: session.characterId,
817 tileX: spawned.tileX,
818 tileY: spawned.tileY,
819 gait: spawned.gait,
820 sex: spawned.sex,
821 firstName: spawned.firstName,
822 lastName: spawned.lastName,
823 layers: spawned.layers ?? [],
824 health: spawned.health,
825 maxHealth: spawned.maxHealth,
826 settings: simulation.settings,
827 worldTime: simulation.worldTime()
828 });
829 syncSubscriptions(session, true);
830 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
831 const bag = simulation.bagOf(session.entityId);
832 if (bag)
833 { send(session, { type: MessageType.inventory, ...bag }); }
834 const skills = simulation.skillsOf(session.entityId);
835 if (skills)
836 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
837 const spellView = simulation.spellsOf(session.entityId);
838 if (spellView)
839 {
840 send(session, {
841 type: MessageType.spells,
842 spells: spellView.spells,
843 autoCast: spellView.autoCast,
844 armedSpellId: spellView.armedSpellId ?? null
845 });
846 }
847 const stamina = simulation.staminaOf(session.entityId);
848 if (stamina)
849 {
850 send(session, {
851 type: MessageType.stamina,
852 current: stamina.current,
853 max: stamina.max,
854 gait: stamina.gait
855 });
856 }
857 if (character.is_dead)
858 {
859 send(session, {
860 type: MessageType.playerDied,
861 entityId: session.entityId,
862 characterId: session.characterId
863 });
864 }
865 publishReplication(simulation.drainReplication());
866 }
867
868 function leaveWorld (session)
869 {
870 if (session.characterId)
871 { simulation.despawnCharacter(session.characterId); }
872 publishReplication(simulation.drainReplication());
873 session.characterId = null;
874 session.entityId = null;
875 session.entitySubscribed.clear();
876 session.staticSubscribed.clear();
877 }
878
879 function syncSubscriptions (session, forceSnapshots)
880 {
881 if (!session.entityId)
882 { return; }
883 const position = simulation.positionOf(session.entityId);
884 if (!position)
885 { return; }
886
887 const centerChunkX = tileToChunk(position.tileX);
888 const centerChunkY = tileToChunk(position.tileY);
889 const mapRadius = staticChunkRadiusForViewDistance(
890 session.viewDistance,
891 STATIC_CHUNK_RADIUS,
892 VISIBLE_CHUNK_RADIUS
893 );
894 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
895 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
896 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
897 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
898
899 for (const key of session.staticSubscribed)
900 {
901 if (!staticNext.has(key))
902 {
903 const [chunkX, chunkY] = key.split(",").map(Number);
904 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
905 }
906 }
907
908 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
909 for (const snapshot of snapshots)
910 {
911 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
912 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
913 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
914 {
915 send(session, { type: MessageType.chunkSnapshot, ...snapshot });
916 }
917 }
918 session.entitySubscribed = entityNext;
919 session.staticSubscribed = staticNext;
920 }
921
922 function requirePlaying (session)
923 {
924 if (!session.characterId)
925 {
926 const error = new Error("Select a character first.");
927 error.userFacing = true;
928 throw error;
929 }
930 }
931
932 function requireAdmin (session)
933 {
934 if (!session.account.is_admin)
935 {
936 const error = new Error("Admin only.");
937 error.userFacing = true;
938 throw error;
939 }
940 }
941
942 function broadcastStatus ()
943 {
944 const worldTime = simulation.worldTime();
945 for (const session of sessions.values())
946 {
947 if (session.entityId)
948 {
949 send(session, {
950 type: MessageType.worldStatus,
951 worldTime,
952 settings: simulation.settings,
953 activeRevisionId: simulation.activeRevisionId
954 });
955 }
956 }
957 }
958
959 function pushFriends (...characterIds)
960 {
961 const seen = new Set();
962 for (const characterId of characterIds)
963 {
964 const id = Number(characterId);
965 if (!id || seen.has(id))
966 { continue; }
967 seen.add(id);
968 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
969 for (const session of sessions.values())
970 {
971 if (session.characterId === id)
972 { send(session, payload); }
973 }
974 }
975 }
976
977 function broadcastSettings (payload)
978 {
979 for (const session of sessions.values())
980 {
981 if (session.account.is_admin)
982 { send(session, { type: MessageType.editorSettings, ...payload }); }
983 }
984 }
985
986 function onTickResult (result)
987 {
988 publishReplication(result.replication ?? []);
989 for (const event of result.events)
990 {
991 if (event.type === "command-error")
992 {
993 const session = sessions.get(event.sessionId);
994 if (session)
995 { send(session, { type: MessageType.error, message: event.message }); }
996 continue;
997 }
998 if (event.type === "inventory")
999 {
1000 const session = event.sessionId != null
1001 ? sessions.get(event.sessionId)
1002 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1003 if (!session)
1004 { continue; }
1005 send(session, {
1006 type: MessageType.inventory,
1007 inventory: event.inventory,
1008 equipment: event.equipment,
1009 vault: event.vault,
1010 vaultReserved: event.vaultReserved
1011 });
1012 if (event.bank)
1013 {
1014 send(session, {
1015 type: MessageType.bankSnapshot,
1016 vault: event.vault,
1017 vaultReserved: event.vaultReserved,
1018 inheritance: stateDb.getInheritance(session.account.account_id)
1019 });
1020 }
1021 if (event.cauldron != null)
1022 {
1023 send(session, {
1024 type: MessageType.cauldronSnapshot,
1025 open: !!event.cauldron,
1026 state: event.cauldronState ?? null,
1027 alchemyResult: event.alchemyResult ?? null,
1028 dyeConfirm: event.dyeConfirm ?? null
1029 });
1030 }
1031 continue;
1032 }
1033 if (event.type === "skills")
1034 {
1035 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1036 if (!session)
1037 { continue; }
1038 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
1039 continue;
1040 }
1041 if (event.type === "spells")
1042 {
1043 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1044 if (!session)
1045 { continue; }
1046 send(session, {
1047 type: MessageType.spellsUpdated,
1048 spells: event.spells ?? [],
1049 autoCast: !!event.autoCast,
1050 armedSpellId: event.armedSpellId ?? null
1051 });
1052 continue;
1053 }
1054 if (event.type === "spell-armed")
1055 {
1056 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1057 if (!session)
1058 { continue; }
1059 send(session, {
1060 type: MessageType.spellArmed,
1061 spellId: event.spellId
1062 });
1063 continue;
1064 }
1065 if (event.type === "spell-disarmed")
1066 {
1067 const session = [...sessions.values()].find((entry) => entry.entityId === event.entityId);
1068 if (!session)
1069 { continue; }
1070 send(session, { type: MessageType.spellDisarmed });
1071 continue;
1072 }
1073 if (event.type === "stamina")
1074 {
1075 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1076 if (!session)
1077 { continue; }
1078 send(session, {
1079 type: MessageType.stamina,
1080 current: event.current,
1081 max: event.max,
1082 gait: event.gait
1083 });
1084 continue;
1085 }
1086 if (event.type === "status-effects")
1087 {
1088 const session = event.sessionId != null
1089 ? sessions.get(event.sessionId)
1090 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1091 if (!session)
1092 { continue; }
1093 send(session, {
1094 type: MessageType.statusEffects,
1095 effects: event.effects ?? [],
1096 blind: !!event.blind
1097 });
1098 continue;
1099 }
1100 if (event.type === "toast")
1101 {
1102 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1103 if (session)
1104 { send(session, { type: MessageType.toast, message: event.message }); }
1105 continue;
1106 }
1107 if (event.type === "pigeon-delivered")
1108 {
1109 for (const session of sessions.values())
1110 {
1111 if (session.characterId === event.senderCharacterId
1112 || session.characterId === event.destinationCharacterId)
1113 {
1114 send(session, {
1115 type: MessageType.pigeonDelivered,
1116 courierId: event.courierId,
1117 destinationKind: event.destinationKind,
1118 cargo: event.cargo
1119 });
1120 }
1121 }
1122 continue;
1123 }
1124 if (event.type === "player-died")
1125 {
1126 const session = sessions.get(event.sessionId);
1127 if (session)
1128 {
1129 send(session, {
1130 type: MessageType.playerDied,
1131 entityId: event.entityId,
1132 characterId: event.characterId
1133 });
1134 }
1135 continue;
1136 }
1137 if (event.type === "player-respawned")
1138 {
1139 const session = sessions.get(event.sessionId);
1140 if (session)
1141 {
1142 send(session, {
1143 type: MessageType.playerRespawned,
1144 entityId: event.entityId,
1145 characterId: event.characterId,
1146 tileX: event.tileX,
1147 tileY: event.tileY,
1148 health: event.health,
1149 maxHealth: event.maxHealth,
1150 stamina: event.stamina,
1151 maxStamina: event.maxStamina
1152 });
1153 }
1154 continue;
1155 }
1156 if (event.type === "combat-no-arrows")
1157 {
1158 const session = sessions.get(event.sessionId);
1159 if (session)
1160 { send(session, { type: MessageType.combatNoArrows }); }
1161 continue;
1162 }
1163 if (event.type === "craft-result")
1164 {
1165 const session = sessions.get(event.sessionId);
1166 if (session)
1167 {
1168 send(session, {
1169 type: MessageType.craftResult,
1170 recipeId: event.recipeId,
1171 ok: !!event.ok,
1172 error: event.error ?? null,
1173 burned: !!event.burned,
1174 continuing: !!event.continuing
1175 });
1176 }
1177 continue;
1178 }
1179 if (event.type === "station-open")
1180 {
1181 const session = sessions.get(event.sessionId);
1182 if (session)
1183 {
1184 send(session, {
1185 type: MessageType.stationOpen,
1186 stationId: event.stationId
1187 });
1188 }
1189 continue;
1190 }
1191 if (event.type === "shop-open")
1192 {
1193 const session = sessions.get(event.sessionId);
1194 if (session)
1195 {
1196 send(session, {
1197 type: MessageType.shopOpen,
1198 npcEntityId: event.npcEntityId,
1199 displayName: event.displayName,
1200 sex: event.sex === "female" ? "female" : "male",
1201 buysItems: !!event.buysItems,
1202 stock: event.stock ?? []
1203 });
1204 }
1205 continue;
1206 }
1207 if (event.type === "shop-closed")
1208 {
1209 const session = sessions.get(event.sessionId);
1210 if (session)
1211 {
1212 send(session, {
1213 type: MessageType.shopClosed,
1214 npcEntityId: event.npcEntityId
1215 });
1216 }
1217 continue;
1218 }
1219 if (event.type === "market-open")
1220 {
1221 const session = sessions.get(event.sessionId);
1222 if (session)
1223 {
1224 send(session, {
1225 type: MessageType.marketOpen,
1226 displayName: event.displayName,
1227 orders: event.orders ?? [],
1228 catalog: event.catalog ?? []
1229 });
1230 }
1231 continue;
1232 }
1233 if (event.type === "market-closed")
1234 {
1235 const session = sessions.get(event.sessionId);
1236 if (session)
1237 { send(session, { type: MessageType.marketClosed }); }
1238 continue;
1239 }
1240 if (event.type === "bounty-snapshot")
1241 {
1242 const session = sessions.get(event.sessionId);
1243 if (session)
1244 {
1245 send(session, {
1246 type: MessageType.bountySnapshot,
1247 myAmountCopper: event.myAmountCopper | 0,
1248 myAmountLabel: event.myAmountLabel ?? "",
1249 message: event.message ?? "",
1250 raised: event.raised ?? null
1251 });
1252 }
1253 continue;
1254 }
1255 if (event.type === "bounty-closed")
1256 {
1257 const session = sessions.get(event.sessionId);
1258 if (session)
1259 { send(session, { type: MessageType.closeBounty }); }
1260 continue;
1261 }
1262 if (event.type === "character-bounty")
1263 {
1264 const session = sessions.get(event.sessionId);
1265 if (session)
1266 {
1267 send(session, {
1268 type: MessageType.characterBounty,
1269 target: event.target ?? null
1270 });
1271 }
1272 continue;
1273 }
1274 if (event.type === "barber-snapshot")
1275 {
1276 const session = sessions.get(event.sessionId);
1277 if (session)
1278 {
1279 send(session, {
1280 type: MessageType.barberSnapshot,
1281 sex: event.sex,
1282 styles: event.styles ?? [],
1283 hair: event.hair ?? null,
1284 message: event.message ?? ""
1285 });
1286 }
1287 continue;
1288 }
1289 if (event.type === "barber-closed")
1290 {
1291 const session = sessions.get(event.sessionId);
1292 if (session)
1293 { send(session, { type: MessageType.closeBarber }); }
1294 continue;
1295 }
1296 if (event.type === "market-trade")
1297 {
1298 for (const session of sessions.values())
1299 {
1300 if (
1301 session.characterId === event.buyerCharacterId
1302 || session.characterId === event.sellerCharacterId
1303 )
1304 {
1305 send(session, {
1306 type: MessageType.marketTrade,
1307 itemId: event.itemId,
1308 quantity: event.quantity,
1309 unitPrice: event.unitPrice,
1310 triggeringSide: event.triggeringSide
1311 });
1312 }
1313 }
1314 continue;
1315 }
1316 if (event.type === "item-bubble")
1317 {
1318 broadcastItemBubble(
1319 sessions,
1320 simulation,
1321 event.entityId,
1322 event.itemId,
1323 event.quantity
1324 );
1325 continue;
1326 }
1327 if (event.type === "gather-swing" || event.type === "tile-shove")
1328 {
1329 publishEntity({
1330 ...event,
1331 type: event.type
1332 });
1333 continue;
1334 }
1335 if (event.type === "chunk-delta")
1336 {
1337 publishEntity(event);
1338 continue;
1339 }
1340 if (event.type === "gather-complete")
1341 {
1342 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1343 if (session)
1344 {
1345 send(session, {
1346 type: MessageType.gatherComplete,
1347 kind: event.kind,
1348 materialId: event.materialId,
1349 itemId: event.itemId
1350 });
1351 }
1352 continue;
1353 }
1354 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")
1355 { publishEntity(event); }
1356 }
1357 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1358 { broadcastStatus(); }
1359 }
1360
1361 function publishReplication (events)
1362 {
1363 for (const event of events ?? [])
1364 { publishEntity(event); }
1365 }
1366
1367 function publishEntity (event)
1368 {
1369 const fromKey = event.fromTileX != null
1370 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
1371 : null;
1372 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
1373 for (const session of sessions.values())
1374 {
1375 if (!session.entityId)
1376 { continue; }
1377 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1378 const seesTo = session.entitySubscribed.has(toKey);
1379 const seesStaticTo = session.staticSubscribed.has(toKey);
1380 if (event.type === "entity-spawn")
1381 {
1382 if (session.entityId === event.entityId || !seesTo)
1383 { continue; }
1384 send(session, spawnPayload(event));
1385 continue;
1386 }
1387 if (event.type === "entity-despawn")
1388 {
1389 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1390 { continue; }
1391 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1392 continue;
1393 }
1394 if (event.type === "entity-appearance")
1395 {
1396 if (!seesTo)
1397 { continue; }
1398 send(session, {
1399 type: MessageType.entityAppearance,
1400 entityId: event.entityId,
1401 sprite: event.sprite,
1402 layers: event.layers ?? [],
1403 lightRadiusTiles: event.lightRadiusTiles ?? 0
1404 });
1405 continue;
1406 }
1407 if (event.type === "ground-item-appear")
1408 {
1409 if (!seesTo)
1410 { continue; }
1411 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1412 continue;
1413 }
1414 if (event.type === "ground-item-despawn")
1415 {
1416 if (!seesTo)
1417 { continue; }
1418 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1419 continue;
1420 }
1421 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1422 {
1423 if (!seesTo && !seesFrom)
1424 { continue; }
1425 const type = event.type === "combat-swing"
1426 ? MessageType.combatSwing
1427 : event.type === "combat-hit"
1428 ? MessageType.combatHit
1429 : event.type === "combat-block"
1430 ? MessageType.combatBlock
1431 : MessageType.combatMiss;
1432 send(session, {
1433 type,
1434 attackerId: event.attackerId,
1435 targetId: event.targetId,
1436 damage: event.damage,
1437 health: event.health,
1438 maxHealth: event.maxHealth,
1439 tileX: event.tileX,
1440 tileY: event.tileY,
1441 fromTileX: event.fromTileX,
1442 fromTileY: event.fromTileY
1443 });
1444 continue;
1445 }
1446 if (event.type === "combat-projectile")
1447 {
1448 if (!seesTo && !seesFrom)
1449 { continue; }
1450 send(session, {
1451 type: MessageType.combatProjectile,
1452 attackerId: event.attackerId,
1453 targetId: event.targetId,
1454 fromTileX: event.fromTileX,
1455 fromTileY: event.fromTileY,
1456 tileX: event.tileX,
1457 tileY: event.tileY,
1458 durationMs: event.durationMs ?? 400,
1459 shaftTint: event.shaftTint ?? null,
1460 tipTint: event.tipTint ?? null
1461 });
1462 continue;
1463 }
1464 if (event.type === "spell-projectile")
1465 {
1466 if (!seesTo && !seesFrom)
1467 { continue; }
1468 send(session, {
1469 type: MessageType.spellProjectile,
1470 casterId: event.casterId,
1471 spellId: event.spellId,
1472 fromTileX: event.fromTileX,
1473 fromTileY: event.fromTileY,
1474 tileX: event.tileX,
1475 tileY: event.tileY,
1476 durationMs: event.durationMs ?? 2000,
1477 sprite: event.sprite ?? null
1478 });
1479 continue;
1480 }
1481 if (event.type === "spell-fizzle")
1482 {
1483 if (!seesTo && !seesFrom)
1484 { continue; }
1485 send(session, {
1486 type: MessageType.spellFizzle,
1487 casterId: event.casterId,
1488 spellId: event.spellId,
1489 fromTileX: event.fromTileX,
1490 fromTileY: event.fromTileY,
1491 tileX: event.tileX,
1492 tileY: event.tileY
1493 });
1494 continue;
1495 }
1496 if (event.type === "spell-cast-flash")
1497 {
1498 if (!seesTo)
1499 { continue; }
1500 send(session, {
1501 type: MessageType.spellCastFlash,
1502 casterId: event.casterId,
1503 tileX: event.tileX,
1504 tileY: event.tileY,
1505 radiusTiles: event.radiusTiles ?? 1,
1506 durationMs: event.durationMs ?? 500,
1507 tier: event.tier ?? 1
1508 });
1509 continue;
1510 }
1511 if (event.type === "spell-light-appear" || event.type === "spell-light-update")
1512 {
1513 if (!seesTo)
1514 { continue; }
1515 send(session, {
1516 type: event.type === "spell-light-appear"
1517 ? MessageType.spellLightAppear
1518 : MessageType.spellLightUpdate,
1519 tileX: event.tileX,
1520 tileY: event.tileY,
1521 ownerEntityId: event.ownerEntityId,
1522 remainingMs: event.remainingMs ?? 0,
1523 rangeTiles: event.rangeTiles ?? 0,
1524 intensity: event.intensity ?? 0,
1525 expiresAt: event.expiresAt ?? 0
1526 });
1527 continue;
1528 }
1529 if (event.type === "spell-light-remove")
1530 {
1531 if (!seesTo)
1532 { continue; }
1533 send(session, {
1534 type: MessageType.spellLightRemove,
1535 tileX: event.tileX,
1536 tileY: event.tileY
1537 });
1538 continue;
1539 }
1540 if (event.type === "entity-health")
1541 {
1542 if (!seesTo && !seesFrom)
1543 { continue; }
1544 send(session, {
1545 type: MessageType.entityHealth,
1546 entityId: event.entityId,
1547 health: event.health,
1548 maxHealth: event.maxHealth
1549 });
1550 continue;
1551 }
1552 if (event.type === "gather-swing" || event.type === "tile-shove")
1553 {
1554 if (!seesTo && !seesFrom)
1555 { continue; }
1556 if (event.type === "gather-swing")
1557 {
1558 send(session, {
1559 type: MessageType.gatherSwing,
1560 attackerId: event.attackerId,
1561 tileX: event.tileX,
1562 tileY: event.tileY,
1563 fromTileX: event.fromTileX,
1564 fromTileY: event.fromTileY,
1565 toolItemId: event.toolItemId ?? null
1566 });
1567 }
1568 else
1569 {
1570 send(session, {
1571 type: MessageType.tileShove,
1572 attackerId: event.attackerId,
1573 tileX: event.tileX,
1574 tileY: event.tileY,
1575 fromTileX: event.fromTileX,
1576 fromTileY: event.fromTileY
1577 });
1578 }
1579 continue;
1580 }
1581 if (event.type === "skill-level-up")
1582 {
1583 if (session.entityId !== event.entityId && !seesTo)
1584 { continue; }
1585 send(session, {
1586 type: MessageType.skillLevelUp,
1587 entityId: event.entityId,
1588 characterId: event.characterId,
1589 skillId: event.skillId,
1590 level: event.level,
1591 displayName: event.displayName,
1592 icon: event.icon
1593 });
1594 continue;
1595 }
1596 if (event.type === "chunk-delta")
1597 {
1598 if (!seesStaticTo)
1599 { continue; }
1600 send(session, {
1601 type: MessageType.chunkDelta,
1602 chunkX: event.chunkX,
1603 chunkY: event.chunkY,
1604 tiles: [{
1605 localX: event.localX,
1606 localY: event.localY,
1607 block: event.block
1608 }]
1609 });
1610 continue;
1611 }
1612 if (event.type !== "entity-move")
1613 { continue; }
1614 if (seesTo)
1615 {
1616 if (!seesFrom)
1617 { send(session, spawnPayload(event)); }
1618 else
1619 {
1620 send(session, {
1621 type: MessageType.entityMove,
1622 entityId: event.entityId,
1623 tileX: event.tileX,
1624 tileY: event.tileY,
1625 worldX: event.worldX,
1626 worldY: event.worldY,
1627 gait: event.gait,
1628 lerpMs: event.lerpMs,
1629 freeFlight: !!event.freeFlight
1630 });
1631 }
1632 }
1633 else if (seesFrom)
1634 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1635 if (session.entityId === event.entityId)
1636 { syncSubscriptions(session, false); }
1637 }
1638 }
1639
1640 function spawnPayload (event)
1641 {
1642 const record = simulation.entityRecord(event.entityId) ?? event;
1643 return {
1644 type: MessageType.entitySpawn,
1645 entityId: event.entityId,
1646 characterId: record.characterId ?? event.characterId ?? null,
1647 tileX: event.tileX ?? record.tileX,
1648 tileY: event.tileY ?? record.tileY,
1649 worldX: event.worldX ?? record.worldX,
1650 worldY: event.worldY ?? record.worldY,
1651 gait: event.gait ?? record.gait,
1652 sex: record.sex ?? event.sex ?? null,
1653 firstName: record.firstName ?? event.firstName ?? "",
1654 lastName: record.lastName ?? event.lastName ?? "",
1655 sprite: record.sprite ?? event.sprite ?? null,
1656 layers: record.layers ?? event.layers ?? [],
1657 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1658 canFight: !!(record.canFight ?? event.canFight),
1659 hostile: !!(record.hostile ?? event.hostile),
1660 talkable: !!(record.talkable ?? event.talkable),
1661 untargetable: !!(record.untargetable ?? event.untargetable),
1662 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1663 health: record.health ?? event.health,
1664 maxHealth: record.maxHealth ?? event.maxHealth,
1665 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1666 };
1667 }
1668
1669 return {
1670 sessions,
1671 onTickResult,
1672 wss,
1673 async shutdown ()
1674 {
1675 await Promise.all([...sessions.values()].map(async (session) =>
1676 {
1677 await sendAsync(session, {
1678 type: MessageType.forceLogout,
1679 reason: "Server shutting down."
1680 });
1681 leaveWorld(session);
1682 await closeAsync(session, 1001, "Server shutting down.");
1683 }));
1684 sessions.clear();
1685 await simulation.shutdown();
1686 }
1687 };
1688}
1689
1690function send (session, payload)
1691{
1692 if (session.socket.readyState === 1)
1693 { session.socket.send(JSON.stringify(payload)); }
1694}
1695
1696function sendAsync (session, payload)
1697{
1698 return new Promise((resolve) =>
1699 {
1700 if (session.socket.readyState !== 1)
1701 {
1702 resolve();
1703 return;
1704 }
1705 session.socket.send(JSON.stringify(payload), () => resolve());
1706 });
1707}
1708
1709function closeAsync (session, code, reason)
1710{
1711 return new Promise((resolve) =>
1712 {
1713 if (session.socket.readyState !== 1)
1714 {
1715 resolve();
1716 return;
1717 }
1718 session.socket.once("close", resolve);
1719 try
1720 { session.socket.close(code, reason); }
1721 catch
1722 { resolve(); }
1723 });
1724}