BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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