BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 42.5 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.interact:
519 requirePlaying(session);
520 simulation.enqueue(session.id, {
521 type: "interact",
522 characterId: session.characterId,
523 targetEntityId: message.targetEntityId | 0
524 });
525 break;
526 case MessageType.buyFromShop:
527 requirePlaying(session);
528 simulation.enqueue(session.id, {
529 type: "buy-from-shop",
530 characterId: session.characterId,
531 npcEntityId: message.npcEntityId | 0,
532 itemId: message.itemId | 0,
533 quantity: message.quantity | 0 || 1,
534 listingId: typeof message.listingId === "string" ? message.listingId : null,
535 source: typeof message.source === "string" ? message.source : null
536 });
537 break;
538 case MessageType.sellToShop:
539 requirePlaying(session);
540 simulation.enqueue(session.id, {
541 type: "sell-to-shop",
542 characterId: session.characterId,
543 npcEntityId: message.npcEntityId | 0,
544 slotIndex: message.slotIndex | 0,
545 quantity: message.quantity | 0 || 1
546 });
547 break;
548 case MessageType.closeShop:
549 requirePlaying(session);
550 simulation.enqueue(session.id, {
551 type: "close-shop",
552 characterId: session.characterId,
553 npcEntityId: message.npcEntityId | 0
554 });
555 break;
556 case MessageType.openMarket:
557 requirePlaying(session);
558 simulation.enqueue(session.id, {
559 type: "open-market",
560 characterId: session.characterId
561 });
562 break;
563 case MessageType.closeMarket:
564 requirePlaying(session);
565 simulation.enqueue(session.id, {
566 type: "close-market",
567 characterId: session.characterId
568 });
569 break;
570 case MessageType.placeMarketSell:
571 requirePlaying(session);
572 simulation.enqueue(session.id, {
573 type: "place-market-sell",
574 characterId: session.characterId,
575 slotIndex: message.slotIndex | 0,
576 quantity: message.quantity | 0 || 1,
577 minUnitPrice: message.minUnitPrice | 0
578 });
579 break;
580 case MessageType.placeMarketBuy:
581 requirePlaying(session);
582 simulation.enqueue(session.id, {
583 type: "place-market-buy",
584 characterId: session.characterId,
585 itemId: message.itemId | 0,
586 quantity: message.quantity | 0 || 1,
587 maxUnitPrice: message.maxUnitPrice | 0
588 });
589 break;
590 case MessageType.cancelMarketOrder:
591 requirePlaying(session);
592 simulation.enqueue(session.id, {
593 type: "cancel-market-order",
594 characterId: session.characterId,
595 orderId: message.orderId | 0
596 });
597 break;
598 case MessageType.follow:
599 requirePlaying(session);
600 simulation.enqueue(session.id, {
601 type: "follow",
602 characterId: session.characterId,
603 targetEntityId: message.targetEntityId | 0
604 });
605 break;
606 case MessageType.cancelFollow:
607 requirePlaying(session);
608 simulation.enqueue(session.id, {
609 type: "cancel-follow",
610 characterId: session.characterId
611 });
612 break;
613 case MessageType.sendPigeon:
614 requirePlaying(session);
615 {
616 const result = simulation.dispatchPigeon({
617 characterId: session.characterId,
618 destination: message.destination,
619 cargo: message.cargo
620 });
621 send(session, {
622 type: MessageType.pigeonDispatched,
623 courierId: result.transit.courierId,
624 destinationKind: result.transit.destinationKind,
625 destinationCharacterId: result.transit.destinationCharacterId
626 });
627 send(session, { type: MessageType.inventory, ...result.bag });
628 }
629 break;
630 case MessageType.searchCharacter:
631 requirePlaying(session);
632 {
633 const character = friends.findByFullName(message.firstName, message.lastName);
634 send(session, {
635 type: MessageType.characterSearchResult,
636 character: character ?? null
637 });
638 }
639 break;
640 case MessageType.writeLetter:
641 requirePlaying(session);
642 simulation.enqueue(session.id, {
643 type: "write-letter",
644 characterId: session.characterId,
645 slotIndex: message.slotIndex,
646 body: message.body
647 });
648 break;
649 case MessageType.editLetter:
650 requirePlaying(session);
651 simulation.enqueue(session.id, {
652 type: "edit-letter",
653 characterId: session.characterId,
654 slotIndex: message.slotIndex,
655 body: message.body
656 });
657 break;
658 case MessageType.openLetter:
659 requirePlaying(session);
660 simulation.enqueue(session.id, {
661 type: "open-letter",
662 characterId: session.characterId,
663 slotIndex: message.slotIndex
664 });
665 break;
666 case MessageType.editorLoadChunk:
667 requireAdmin(session);
668 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
669 break;
670 case MessageType.editorSaveChunk:
671 requireAdmin(session);
672 send(session, {
673 type: MessageType.editorChunk,
674 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
675 });
676 break;
677 case MessageType.editorLoadSettings:
678 requireAdmin(session);
679 send(session, {
680 type: MessageType.editorSettings,
681 ...editor.loadSettings(),
682 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
683 });
684 break;
685 case MessageType.editorSaveSettings:
686 requireAdmin(session);
687 {
688 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
689 simulation.applySettings(saved.settings);
690 broadcastStatus();
691 broadcastSettings(saved);
692 }
693 break;
694 case MessageType.editorApplyRevision:
695 requireAdmin(session);
696 if (!editor.revisionStatus().pendingRevisionId)
697 {
698 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
699 break;
700 }
701 {
702 const appliedRevisionId = editor.applyPendingRevision();
703 simulation.reloadWorld();
704 for (const other of sessions.values())
705 {
706 if (other.entityId)
707 { syncSubscriptions(other, true); }
708 }
709 broadcastStatus();
710 send(session, {
711 type: MessageType.editorRevisionApplied,
712 ...editor.revisionStatus(),
713 appliedRevisionId
714 });
715 }
716 break;
717 case MessageType.setGraphicsSettings:
718 {
719 const next = normalizeGraphicsSettings({
720 viewDistance: message.viewDistance ?? session.viewDistance
721 });
722 const changed = next.viewDistance !== session.viewDistance;
723 session.viewDistance = next.viewDistance;
724 if (changed && session.entityId)
725 { syncSubscriptions(session, true); }
726 }
727 break;
728 default:
729 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
730 }
731 }
732
733 function enterWorld (session, characterId)
734 {
735 leaveWorld(session);
736 const character = characters.getOwned(session.account.account_id, characterId);
737 if (character.deletion_scheduled_at)
738 {
739 const error = new Error("That character is marked for deletion.");
740 error.userFacing = true;
741 throw error;
742 }
743 for (const other of sessions.values())
744 {
745 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
746 {
747 const error = new Error("This account already has a character in the world.");
748 error.userFacing = true;
749 throw error;
750 }
751 }
752 session.characterId = character.character_id;
753 session.entityId = simulation.spawnCharacter(session.id, character);
754 const spawned = simulation.entityRecord(session.entityId);
755 send(session, {
756 type: MessageType.enterWorld,
757 entityId: session.entityId,
758 characterId: session.characterId,
759 tileX: spawned.tileX,
760 tileY: spawned.tileY,
761 gait: spawned.gait,
762 sex: spawned.sex,
763 firstName: spawned.firstName,
764 lastName: spawned.lastName,
765 layers: spawned.layers ?? [],
766 health: spawned.health,
767 maxHealth: spawned.maxHealth,
768 settings: simulation.settings,
769 worldTime: simulation.worldTime()
770 });
771 syncSubscriptions(session, true);
772 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
773 const bag = simulation.bagOf(session.entityId);
774 if (bag)
775 { send(session, { type: MessageType.inventory, ...bag }); }
776 const skills = simulation.skillsOf(session.entityId);
777 if (skills)
778 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
779 const stamina = simulation.staminaOf(session.entityId);
780 if (stamina)
781 {
782 send(session, {
783 type: MessageType.stamina,
784 current: stamina.current,
785 max: stamina.max,
786 gait: stamina.gait
787 });
788 }
789 if (character.is_dead)
790 {
791 send(session, {
792 type: MessageType.playerDied,
793 entityId: session.entityId,
794 characterId: session.characterId
795 });
796 }
797 publishReplication(simulation.drainReplication());
798 }
799
800 function leaveWorld (session)
801 {
802 if (session.characterId)
803 { simulation.despawnCharacter(session.characterId); }
804 publishReplication(simulation.drainReplication());
805 session.characterId = null;
806 session.entityId = null;
807 session.entitySubscribed.clear();
808 session.staticSubscribed.clear();
809 }
810
811 function syncSubscriptions (session, forceSnapshots)
812 {
813 if (!session.entityId)
814 { return; }
815 const position = simulation.positionOf(session.entityId);
816 if (!position)
817 { return; }
818
819 const centerChunkX = tileToChunk(position.tileX);
820 const centerChunkY = tileToChunk(position.tileY);
821 const mapRadius = staticChunkRadiusForViewDistance(
822 session.viewDistance,
823 STATIC_CHUNK_RADIUS,
824 VISIBLE_CHUNK_RADIUS
825 );
826 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
827 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, mapRadius);
828 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
829 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
830
831 for (const key of session.staticSubscribed)
832 {
833 if (!staticNext.has(key))
834 {
835 const [chunkX, chunkY] = key.split(",").map(Number);
836 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
837 }
838 }
839
840 const snapshots = simulation.snapshotsForView(session.entityId, mapRadius);
841 for (const snapshot of snapshots)
842 {
843 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
844 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
845 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
846 {
847 send(session, { type: MessageType.chunkSnapshot, ...snapshot });
848 }
849 }
850 session.entitySubscribed = entityNext;
851 session.staticSubscribed = staticNext;
852 }
853
854 function requirePlaying (session)
855 {
856 if (!session.characterId)
857 {
858 const error = new Error("Select a character first.");
859 error.userFacing = true;
860 throw error;
861 }
862 }
863
864 function requireAdmin (session)
865 {
866 if (!session.account.is_admin)
867 {
868 const error = new Error("Admin only.");
869 error.userFacing = true;
870 throw error;
871 }
872 }
873
874 function broadcastStatus ()
875 {
876 const worldTime = simulation.worldTime();
877 for (const session of sessions.values())
878 {
879 if (session.entityId)
880 {
881 send(session, {
882 type: MessageType.worldStatus,
883 worldTime,
884 settings: simulation.settings,
885 activeRevisionId: simulation.activeRevisionId
886 });
887 }
888 }
889 }
890
891 function pushFriends (...characterIds)
892 {
893 const seen = new Set();
894 for (const characterId of characterIds)
895 {
896 const id = Number(characterId);
897 if (!id || seen.has(id))
898 { continue; }
899 seen.add(id);
900 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
901 for (const session of sessions.values())
902 {
903 if (session.characterId === id)
904 { send(session, payload); }
905 }
906 }
907 }
908
909 function broadcastSettings (payload)
910 {
911 for (const session of sessions.values())
912 {
913 if (session.account.is_admin)
914 { send(session, { type: MessageType.editorSettings, ...payload }); }
915 }
916 }
917
918 function onTickResult (result)
919 {
920 publishReplication(result.replication ?? []);
921 for (const event of result.events)
922 {
923 if (event.type === "command-error")
924 {
925 const session = sessions.get(event.sessionId);
926 if (session)
927 { send(session, { type: MessageType.error, message: event.message }); }
928 continue;
929 }
930 if (event.type === "inventory")
931 {
932 const session = event.sessionId != null
933 ? sessions.get(event.sessionId)
934 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
935 if (!session)
936 { continue; }
937 send(session, {
938 type: MessageType.inventory,
939 inventory: event.inventory,
940 equipment: event.equipment,
941 vault: event.vault,
942 vaultReserved: event.vaultReserved
943 });
944 if (event.bank)
945 {
946 send(session, {
947 type: MessageType.bankSnapshot,
948 vault: event.vault,
949 vaultReserved: event.vaultReserved,
950 inheritance: stateDb.getInheritance(session.account.account_id)
951 });
952 }
953 if (event.cauldron != null)
954 {
955 send(session, {
956 type: MessageType.cauldronSnapshot,
957 open: !!event.cauldron,
958 state: event.cauldronState ?? null,
959 alchemyResult: event.alchemyResult ?? null,
960 dyeConfirm: event.dyeConfirm ?? null
961 });
962 }
963 continue;
964 }
965 if (event.type === "skills")
966 {
967 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
968 if (!session)
969 { continue; }
970 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
971 continue;
972 }
973 if (event.type === "stamina")
974 {
975 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
976 if (!session)
977 { continue; }
978 send(session, {
979 type: MessageType.stamina,
980 current: event.current,
981 max: event.max,
982 gait: event.gait
983 });
984 continue;
985 }
986 if (event.type === "status-effects")
987 {
988 const session = event.sessionId != null
989 ? sessions.get(event.sessionId)
990 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
991 if (!session)
992 { continue; }
993 send(session, {
994 type: MessageType.statusEffects,
995 effects: event.effects ?? [],
996 blind: !!event.blind
997 });
998 continue;
999 }
1000 if (event.type === "toast")
1001 {
1002 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1003 if (session)
1004 { send(session, { type: MessageType.toast, message: event.message }); }
1005 continue;
1006 }
1007 if (event.type === "pigeon-delivered")
1008 {
1009 for (const session of sessions.values())
1010 {
1011 if (session.characterId === event.senderCharacterId
1012 || session.characterId === event.destinationCharacterId)
1013 {
1014 send(session, {
1015 type: MessageType.pigeonDelivered,
1016 courierId: event.courierId,
1017 destinationKind: event.destinationKind,
1018 cargo: event.cargo
1019 });
1020 }
1021 }
1022 continue;
1023 }
1024 if (event.type === "player-died")
1025 {
1026 const session = sessions.get(event.sessionId);
1027 if (session)
1028 {
1029 send(session, {
1030 type: MessageType.playerDied,
1031 entityId: event.entityId,
1032 characterId: event.characterId
1033 });
1034 }
1035 continue;
1036 }
1037 if (event.type === "player-respawned")
1038 {
1039 const session = sessions.get(event.sessionId);
1040 if (session)
1041 {
1042 send(session, {
1043 type: MessageType.playerRespawned,
1044 entityId: event.entityId,
1045 characterId: event.characterId,
1046 tileX: event.tileX,
1047 tileY: event.tileY,
1048 health: event.health,
1049 maxHealth: event.maxHealth,
1050 stamina: event.stamina,
1051 maxStamina: event.maxStamina
1052 });
1053 }
1054 continue;
1055 }
1056 if (event.type === "combat-no-arrows")
1057 {
1058 const session = sessions.get(event.sessionId);
1059 if (session)
1060 { send(session, { type: MessageType.combatNoArrows }); }
1061 continue;
1062 }
1063 if (event.type === "craft-result")
1064 {
1065 const session = sessions.get(event.sessionId);
1066 if (session)
1067 {
1068 send(session, {
1069 type: MessageType.craftResult,
1070 recipeId: event.recipeId,
1071 ok: !!event.ok,
1072 error: event.error ?? null,
1073 burned: !!event.burned,
1074 continuing: !!event.continuing
1075 });
1076 }
1077 continue;
1078 }
1079 if (event.type === "station-open")
1080 {
1081 const session = sessions.get(event.sessionId);
1082 if (session)
1083 {
1084 send(session, {
1085 type: MessageType.stationOpen,
1086 stationId: event.stationId
1087 });
1088 }
1089 continue;
1090 }
1091 if (event.type === "shop-open")
1092 {
1093 const session = sessions.get(event.sessionId);
1094 if (session)
1095 {
1096 send(session, {
1097 type: MessageType.shopOpen,
1098 npcEntityId: event.npcEntityId,
1099 displayName: event.displayName,
1100 sex: event.sex === "female" ? "female" : "male",
1101 buysItems: !!event.buysItems,
1102 stock: event.stock ?? []
1103 });
1104 }
1105 continue;
1106 }
1107 if (event.type === "shop-closed")
1108 {
1109 const session = sessions.get(event.sessionId);
1110 if (session)
1111 {
1112 send(session, {
1113 type: MessageType.shopClosed,
1114 npcEntityId: event.npcEntityId
1115 });
1116 }
1117 continue;
1118 }
1119 if (event.type === "market-open")
1120 {
1121 const session = sessions.get(event.sessionId);
1122 if (session)
1123 {
1124 send(session, {
1125 type: MessageType.marketOpen,
1126 displayName: event.displayName,
1127 orders: event.orders ?? [],
1128 catalog: event.catalog ?? []
1129 });
1130 }
1131 continue;
1132 }
1133 if (event.type === "market-closed")
1134 {
1135 const session = sessions.get(event.sessionId);
1136 if (session)
1137 { send(session, { type: MessageType.marketClosed }); }
1138 continue;
1139 }
1140 if (event.type === "bounty-snapshot")
1141 {
1142 const session = sessions.get(event.sessionId);
1143 if (session)
1144 {
1145 send(session, {
1146 type: MessageType.bountySnapshot,
1147 myAmountCopper: event.myAmountCopper | 0,
1148 myAmountLabel: event.myAmountLabel ?? "",
1149 message: event.message ?? "",
1150 raised: event.raised ?? null
1151 });
1152 }
1153 continue;
1154 }
1155 if (event.type === "bounty-closed")
1156 {
1157 const session = sessions.get(event.sessionId);
1158 if (session)
1159 { send(session, { type: MessageType.closeBounty }); }
1160 continue;
1161 }
1162 if (event.type === "character-bounty")
1163 {
1164 const session = sessions.get(event.sessionId);
1165 if (session)
1166 {
1167 send(session, {
1168 type: MessageType.characterBounty,
1169 target: event.target ?? null
1170 });
1171 }
1172 continue;
1173 }
1174 if (event.type === "barber-snapshot")
1175 {
1176 const session = sessions.get(event.sessionId);
1177 if (session)
1178 {
1179 send(session, {
1180 type: MessageType.barberSnapshot,
1181 sex: event.sex,
1182 styles: event.styles ?? [],
1183 hair: event.hair ?? null,
1184 message: event.message ?? ""
1185 });
1186 }
1187 continue;
1188 }
1189 if (event.type === "barber-closed")
1190 {
1191 const session = sessions.get(event.sessionId);
1192 if (session)
1193 { send(session, { type: MessageType.closeBarber }); }
1194 continue;
1195 }
1196 if (event.type === "market-trade")
1197 {
1198 for (const session of sessions.values())
1199 {
1200 if (
1201 session.characterId === event.buyerCharacterId
1202 || session.characterId === event.sellerCharacterId
1203 )
1204 {
1205 send(session, {
1206 type: MessageType.marketTrade,
1207 itemId: event.itemId,
1208 quantity: event.quantity,
1209 unitPrice: event.unitPrice,
1210 triggeringSide: event.triggeringSide
1211 });
1212 }
1213 }
1214 continue;
1215 }
1216 if (event.type === "item-bubble")
1217 {
1218 broadcastItemBubble(
1219 sessions,
1220 simulation,
1221 event.entityId,
1222 event.itemId,
1223 event.quantity
1224 );
1225 continue;
1226 }
1227 if (event.type === "gather-swing" || event.type === "tile-shove")
1228 {
1229 publishEntity({
1230 ...event,
1231 type: event.type
1232 });
1233 continue;
1234 }
1235 if (event.type === "chunk-delta")
1236 {
1237 publishEntity(event);
1238 continue;
1239 }
1240 if (event.type === "gather-complete")
1241 {
1242 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1243 if (session)
1244 {
1245 send(session, {
1246 type: MessageType.gatherComplete,
1247 kind: event.kind,
1248 materialId: event.materialId,
1249 itemId: event.itemId
1250 });
1251 }
1252 continue;
1253 }
1254 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 === "entity-health" || event.type === "gather-swing" || event.type === "tile-shove" || event.type === "chunk-delta" || event.type === "skill-level-up")
1255 { publishEntity(event); }
1256 }
1257 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1258 { broadcastStatus(); }
1259 }
1260
1261 function publishReplication (events)
1262 {
1263 for (const event of events ?? [])
1264 { publishEntity(event); }
1265 }
1266
1267 function publishEntity (event)
1268 {
1269 const fromKey = event.fromTileX != null
1270 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
1271 : null;
1272 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
1273 for (const session of sessions.values())
1274 {
1275 if (!session.entityId)
1276 { continue; }
1277 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1278 const seesTo = session.entitySubscribed.has(toKey);
1279 const seesStaticTo = session.staticSubscribed.has(toKey);
1280 if (event.type === "entity-spawn")
1281 {
1282 if (session.entityId === event.entityId || !seesTo)
1283 { continue; }
1284 send(session, spawnPayload(event));
1285 continue;
1286 }
1287 if (event.type === "entity-despawn")
1288 {
1289 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1290 { continue; }
1291 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1292 continue;
1293 }
1294 if (event.type === "entity-appearance")
1295 {
1296 if (!seesTo)
1297 { continue; }
1298 send(session, {
1299 type: MessageType.entityAppearance,
1300 entityId: event.entityId,
1301 sprite: event.sprite,
1302 layers: event.layers ?? [],
1303 lightRadiusTiles: event.lightRadiusTiles ?? 0
1304 });
1305 continue;
1306 }
1307 if (event.type === "ground-item-appear")
1308 {
1309 if (!seesTo)
1310 { continue; }
1311 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1312 continue;
1313 }
1314 if (event.type === "ground-item-despawn")
1315 {
1316 if (!seesTo)
1317 { continue; }
1318 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1319 continue;
1320 }
1321 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1322 {
1323 if (!seesTo && !seesFrom)
1324 { continue; }
1325 const type = event.type === "combat-swing"
1326 ? MessageType.combatSwing
1327 : event.type === "combat-hit"
1328 ? MessageType.combatHit
1329 : event.type === "combat-block"
1330 ? MessageType.combatBlock
1331 : MessageType.combatMiss;
1332 send(session, {
1333 type,
1334 attackerId: event.attackerId,
1335 targetId: event.targetId,
1336 damage: event.damage,
1337 health: event.health,
1338 maxHealth: event.maxHealth,
1339 tileX: event.tileX,
1340 tileY: event.tileY,
1341 fromTileX: event.fromTileX,
1342 fromTileY: event.fromTileY
1343 });
1344 continue;
1345 }
1346 if (event.type === "combat-projectile")
1347 {
1348 if (!seesTo && !seesFrom)
1349 { continue; }
1350 send(session, {
1351 type: MessageType.combatProjectile,
1352 attackerId: event.attackerId,
1353 targetId: event.targetId,
1354 fromTileX: event.fromTileX,
1355 fromTileY: event.fromTileY,
1356 tileX: event.tileX,
1357 tileY: event.tileY,
1358 durationMs: event.durationMs ?? 400,
1359 shaftTint: event.shaftTint ?? null,
1360 tipTint: event.tipTint ?? null
1361 });
1362 continue;
1363 }
1364 if (event.type === "entity-health")
1365 {
1366 if (!seesTo && !seesFrom)
1367 { continue; }
1368 send(session, {
1369 type: MessageType.entityHealth,
1370 entityId: event.entityId,
1371 health: event.health,
1372 maxHealth: event.maxHealth
1373 });
1374 continue;
1375 }
1376 if (event.type === "gather-swing" || event.type === "tile-shove")
1377 {
1378 if (!seesTo && !seesFrom)
1379 { continue; }
1380 if (event.type === "gather-swing")
1381 {
1382 send(session, {
1383 type: MessageType.gatherSwing,
1384 attackerId: event.attackerId,
1385 tileX: event.tileX,
1386 tileY: event.tileY,
1387 fromTileX: event.fromTileX,
1388 fromTileY: event.fromTileY,
1389 toolItemId: event.toolItemId ?? null
1390 });
1391 }
1392 else
1393 {
1394 send(session, {
1395 type: MessageType.tileShove,
1396 attackerId: event.attackerId,
1397 tileX: event.tileX,
1398 tileY: event.tileY,
1399 fromTileX: event.fromTileX,
1400 fromTileY: event.fromTileY
1401 });
1402 }
1403 continue;
1404 }
1405 if (event.type === "skill-level-up")
1406 {
1407 if (session.entityId !== event.entityId && !seesTo)
1408 { continue; }
1409 send(session, {
1410 type: MessageType.skillLevelUp,
1411 entityId: event.entityId,
1412 characterId: event.characterId,
1413 skillId: event.skillId,
1414 level: event.level,
1415 displayName: event.displayName,
1416 icon: event.icon
1417 });
1418 continue;
1419 }
1420 if (event.type === "chunk-delta")
1421 {
1422 if (!seesStaticTo)
1423 { continue; }
1424 send(session, {
1425 type: MessageType.chunkDelta,
1426 chunkX: event.chunkX,
1427 chunkY: event.chunkY,
1428 tiles: [{
1429 localX: event.localX,
1430 localY: event.localY,
1431 block: event.block
1432 }]
1433 });
1434 continue;
1435 }
1436 if (event.type !== "entity-move")
1437 { continue; }
1438 if (seesTo)
1439 {
1440 if (!seesFrom)
1441 { send(session, spawnPayload(event)); }
1442 else
1443 {
1444 send(session, {
1445 type: MessageType.entityMove,
1446 entityId: event.entityId,
1447 tileX: event.tileX,
1448 tileY: event.tileY,
1449 worldX: event.worldX,
1450 worldY: event.worldY,
1451 gait: event.gait,
1452 lerpMs: event.lerpMs,
1453 freeFlight: !!event.freeFlight
1454 });
1455 }
1456 }
1457 else if (seesFrom)
1458 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1459 if (session.entityId === event.entityId)
1460 { syncSubscriptions(session, false); }
1461 }
1462 }
1463
1464 function spawnPayload (event)
1465 {
1466 const record = simulation.entityRecord(event.entityId) ?? event;
1467 return {
1468 type: MessageType.entitySpawn,
1469 entityId: event.entityId,
1470 characterId: record.characterId ?? event.characterId ?? null,
1471 tileX: event.tileX ?? record.tileX,
1472 tileY: event.tileY ?? record.tileY,
1473 worldX: event.worldX ?? record.worldX,
1474 worldY: event.worldY ?? record.worldY,
1475 gait: event.gait ?? record.gait,
1476 sex: record.sex ?? event.sex ?? null,
1477 firstName: record.firstName ?? event.firstName ?? "",
1478 lastName: record.lastName ?? event.lastName ?? "",
1479 sprite: record.sprite ?? event.sprite ?? null,
1480 layers: record.layers ?? event.layers ?? [],
1481 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1482 canFight: !!(record.canFight ?? event.canFight),
1483 hostile: !!(record.hostile ?? event.hostile),
1484 talkable: !!(record.talkable ?? event.talkable),
1485 untargetable: !!(record.untargetable ?? event.untargetable),
1486 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1487 health: record.health ?? event.health,
1488 maxHealth: record.maxHealth ?? event.maxHealth,
1489 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1490 };
1491 }
1492
1493 return {
1494 sessions,
1495 onTickResult,
1496 wss,
1497 async shutdown ()
1498 {
1499 await Promise.all([...sessions.values()].map(async (session) =>
1500 {
1501 await sendAsync(session, {
1502 type: MessageType.forceLogout,
1503 reason: "Server shutting down."
1504 });
1505 leaveWorld(session);
1506 await closeAsync(session, 1001, "Server shutting down.");
1507 }));
1508 sessions.clear();
1509 await simulation.shutdown();
1510 }
1511 };
1512}
1513
1514function send (session, payload)
1515{
1516 if (session.socket.readyState === 1)
1517 { session.socket.send(JSON.stringify(payload)); }
1518}
1519
1520function sendAsync (session, payload)
1521{
1522 return new Promise((resolve) =>
1523 {
1524 if (session.socket.readyState !== 1)
1525 {
1526 resolve();
1527 return;
1528 }
1529 session.socket.send(JSON.stringify(payload), () => resolve());
1530 });
1531}
1532
1533function closeAsync (session, code, reason)
1534{
1535 return new Promise((resolve) =>
1536 {
1537 if (session.socket.readyState !== 1)
1538 {
1539 resolve();
1540 return;
1541 }
1542 session.socket.once("close", resolve);
1543 try
1544 { session.socket.close(code, reason); }
1545 catch
1546 { resolve(); }
1547 });
1548}