BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 37.1 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 { broadcastSpeech, broadcastItemBubble } from "../chat/speech.js";
6import { CraftingStationId, craftingStationDefinition } from "../../../shared/definitions/craftingStations.js";
7import { publicSkillsView } from "../../../shared/skills/state.js";
8
9let nextSessionId = 1;
10
11export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation })
12{
13 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
14 const sessions = new Map();
15
16 wss.on("connection", (socket) =>
17 {
18 const identity = auth.claimIdentity();
19 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
20 const session = {
21 id: nextSessionId++,
22 socket,
23 account,
24 authSubject: identity.authSubject,
25 characterId: null,
26 entityId: null,
27 /** Chunks where entity / ground-item replication is active (3×3). */
28 entitySubscribed: new Set(),
29 /** Chunks with map + baked lighting only (5×5). */
30 staticSubscribed: new Set()
31 };
32 auth.register(session);
33 sessions.set(session.id, session);
34 send(session, {
35 type: MessageType.session,
36 accountId: account.account_id,
37 authSubject: account.auth_subject,
38 isAdmin: !!account.is_admin,
39 characters: characters.list(account.account_id)
40 });
41
42 socket.on("message", (raw) =>
43 {
44 let message;
45 try
46 { message = JSON.parse(String(raw)); }
47 catch
48 {
49 send(session, { type: MessageType.error, message: "Invalid JSON." });
50 return;
51 }
52 try
53 { handleMessage(session, message); }
54 catch (error)
55 {
56 send(session, {
57 type: MessageType.error,
58 message: error.userFacing ? error.message : "Request failed."
59 });
60 }
61 });
62
63 socket.on("close", () =>
64 {
65 leaveWorld(session);
66 auth.release(session);
67 sessions.delete(session.id);
68 });
69 });
70
71 function handleMessage (session, message)
72 {
73 if (session.characterId
74 && stateDb.getCharacter(session.characterId)?.is_dead
75 && message.type !== MessageType.respawn
76 && message.type !== MessageType.leaveWorld)
77 {
78 const error = new Error("You are dead.");
79 error.userFacing = true;
80 throw error;
81 }
82 switch (message.type)
83 {
84 case MessageType.createCharacter:
85 characters.create(session.account, message.firstName, message.lastName, message.sex);
86 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
87 break;
88 case MessageType.selectCharacter:
89 enterWorld(session, message.characterId);
90 break;
91 case MessageType.scheduleDeleteCharacter:
92 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
93 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
94 break;
95 case MessageType.cancelDeleteCharacter:
96 characters.cancelDelete(session.account, message.characterId);
97 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
98 break;
99 case MessageType.leaveWorld:
100 leaveWorld(session);
101 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
102 break;
103 case MessageType.respawn:
104 requirePlaying(session);
105 simulation.enqueue(session.id, {
106 type: "respawn",
107 characterId: session.characterId
108 });
109 break;
110 case MessageType.moveTo:
111 requirePlaying(session);
112 simulation.enqueue(session.id, {
113 type: "move-to",
114 characterId: session.characterId,
115 tileX: message.tileX | 0,
116 tileY: message.tileY | 0
117 });
118 break;
119 case MessageType.setGait:
120 requirePlaying(session);
121 simulation.enqueue(session.id, {
122 type: "set-gait",
123 characterId: session.characterId,
124 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
125 });
126 break;
127 case MessageType.friendRequest:
128 requirePlaying(session);
129 friends.request(session.characterId, message.characterId);
130 pushFriends(session.characterId, message.characterId);
131 break;
132 case MessageType.friendAccept:
133 requirePlaying(session);
134 friends.accept(session.characterId, message.characterId);
135 pushFriends(session.characterId, message.characterId);
136 break;
137 case MessageType.friendDecline:
138 requirePlaying(session);
139 friends.decline(session.characterId, message.characterId);
140 pushFriends(session.characterId, message.characterId);
141 break;
142 case MessageType.friendRemove:
143 requirePlaying(session);
144 friends.remove(session.characterId, message.characterId);
145 pushFriends(session.characterId, message.characterId);
146 break;
147 case MessageType.chatSay:
148 requirePlaying(session);
149 broadcastSpeech(sessions, simulation, session, message.text);
150 break;
151 case MessageType.dropItem:
152 requirePlaying(session);
153 simulation.enqueue(session.id, {
154 type: "drop-item",
155 characterId: session.characterId,
156 slotIndex: message.slotIndex | 0,
157 quantity: message.quantity ?? null
158 });
159 break;
160 case MessageType.pickupItem:
161 requirePlaying(session);
162 simulation.enqueue(session.id, {
163 type: "pickup-item",
164 characterId: session.characterId,
165 groundItemId: message.groundItemId | 0
166 });
167 break;
168 case MessageType.equipItem:
169 requirePlaying(session);
170 simulation.enqueue(session.id, {
171 type: "equip-item",
172 characterId: session.characterId,
173 slotIndex: message.slotIndex | 0
174 });
175 break;
176 case MessageType.unequipItem:
177 requirePlaying(session);
178 simulation.enqueue(session.id, {
179 type: "unequip-item",
180 characterId: session.characterId,
181 equipSlot: message.equipSlot
182 });
183 break;
184 case MessageType.eatItem:
185 requirePlaying(session);
186 simulation.enqueue(session.id, {
187 type: "eat-item",
188 characterId: session.characterId,
189 slotIndex: message.slotIndex | 0
190 });
191 break;
192 case MessageType.openBank:
193 requirePlaying(session);
194 simulation.enqueue(session.id, {
195 type: "open-bank",
196 characterId: session.characterId
197 });
198 break;
199 case MessageType.openCauldron:
200 requirePlaying(session);
201 simulation.enqueue(session.id, {
202 type: "open-cauldron",
203 characterId: session.characterId
204 });
205 break;
206 case MessageType.openFurnace:
207 requirePlaying(session);
208 simulation.enqueue(session.id, {
209 type: "open-station",
210 characterId: session.characterId,
211 stationId: CraftingStationId.furnace
212 });
213 break;
214 case MessageType.openStation:
215 {
216 requirePlaying(session);
217 const stationId = typeof message.stationId === "string"
218 ? message.stationId
219 : null;
220 if (!stationId || !craftingStationDefinition(stationId))
221 { break; }
222 simulation.enqueue(session.id, {
223 type: "open-station",
224 characterId: session.characterId,
225 stationId
226 });
227 break;
228 }
229 case MessageType.mine:
230 requirePlaying(session);
231 simulation.enqueue(session.id, {
232 type: "mine",
233 characterId: session.characterId,
234 tileX: message.tileX | 0,
235 tileY: message.tileY | 0
236 });
237 break;
238 case MessageType.chop:
239 requirePlaying(session);
240 simulation.enqueue(session.id, {
241 type: "chop",
242 characterId: session.characterId,
243 tileX: message.tileX | 0,
244 tileY: message.tileY | 0
245 });
246 break;
247 case MessageType.pick:
248 requirePlaying(session);
249 simulation.enqueue(session.id, {
250 type: "pick",
251 characterId: session.characterId,
252 tileX: message.tileX | 0,
253 tileY: message.tileY | 0
254 });
255 break;
256 case MessageType.cancelGather:
257 requirePlaying(session);
258 simulation.enqueue(session.id, {
259 type: "cancel-gather",
260 characterId: session.characterId
261 });
262 break;
263 case MessageType.startCraft:
264 requirePlaying(session);
265 simulation.enqueue(session.id, {
266 type: "start-craft",
267 characterId: session.characterId,
268 stationId: message.stationId,
269 recipeId: message.recipeId,
270 clothTier: message.clothTier ?? null,
271 dyeSlotIndex: message.dyeSlotIndex ?? null
272 });
273 break;
274 case MessageType.cancelCraft:
275 requirePlaying(session);
276 simulation.enqueue(session.id, {
277 type: "cancel-craft",
278 characterId: session.characterId
279 });
280 break;
281 case MessageType.cauldronSetSlot:
282 requirePlaying(session);
283 simulation.enqueue(session.id, {
284 type: "cauldron-set-slot",
285 characterId: session.characterId,
286 slotIndex: message.slotIndex | 0,
287 itemId: message.itemId | 0,
288 quantity: message.quantity | 0,
289 instance: message.instance ?? null
290 });
291 break;
292 case MessageType.cauldronSetDyeSlot:
293 requirePlaying(session);
294 simulation.enqueue(session.id, {
295 type: "cauldron-set-dye-slot",
296 characterId: session.characterId,
297 slotIndex: message.slotIndex | 0,
298 itemId: message.itemId | 0,
299 quantity: message.quantity | 0,
300 instance: message.instance ?? null
301 });
302 break;
303 case MessageType.cauldronInsert:
304 requirePlaying(session);
305 simulation.enqueue(session.id, {
306 type: "cauldron-insert",
307 characterId: session.characterId,
308 slotIndex: message.slotIndex | 0
309 });
310 break;
311 case MessageType.cauldronAction:
312 requirePlaying(session);
313 simulation.enqueue(session.id, {
314 type: "cauldron-action",
315 characterId: session.characterId,
316 action: message.action
317 });
318 break;
319 case MessageType.cauldronBottle:
320 requirePlaying(session);
321 simulation.enqueue(session.id, {
322 type: "cauldron-bottle",
323 characterId: session.characterId
324 });
325 break;
326 case MessageType.cauldronCreateDye:
327 requirePlaying(session);
328 simulation.enqueue(session.id, {
329 type: "cauldron-create-dye",
330 characterId: session.characterId,
331 confirmOverflow: !!message.confirmOverflow
332 });
333 break;
334 case MessageType.cauldronClear:
335 requirePlaying(session);
336 simulation.enqueue(session.id, {
337 type: "cauldron-clear",
338 characterId: session.characterId
339 });
340 break;
341 case MessageType.cauldronClearDye:
342 requirePlaying(session);
343 simulation.enqueue(session.id, {
344 type: "cauldron-clear-dye",
345 characterId: session.characterId
346 });
347 break;
348 case MessageType.cauldronSaveRecipe:
349 requirePlaying(session);
350 simulation.enqueue(session.id, {
351 type: "cauldron-save-recipe",
352 characterId: session.characterId
353 });
354 break;
355 case MessageType.cauldronClose:
356 requirePlaying(session);
357 simulation.enqueue(session.id, {
358 type: "cauldron-close",
359 characterId: session.characterId
360 });
361 break;
362 case MessageType.bankDeposit:
363 requirePlaying(session);
364 simulation.enqueue(session.id, {
365 type: "bank-deposit",
366 characterId: session.characterId,
367 slotIndex: message.slotIndex | 0,
368 quantity: message.quantity ?? null
369 });
370 break;
371 case MessageType.bankWithdraw:
372 requirePlaying(session);
373 simulation.enqueue(session.id, {
374 type: "bank-withdraw",
375 characterId: session.characterId,
376 slotIndex: message.slotIndex | 0,
377 quantity: message.quantity ?? null
378 });
379 break;
380 case MessageType.getBlankCheques:
381 requirePlaying(session);
382 simulation.enqueue(session.id, {
383 type: "get-blank-cheques",
384 characterId: session.characterId
385 });
386 break;
387 case MessageType.returnBlankCheques:
388 requirePlaying(session);
389 simulation.enqueue(session.id, {
390 type: "return-blank-cheques",
391 characterId: session.characterId,
392 slotIndex: message.slotIndex | 0,
393 quantity: message.quantity ?? null
394 });
395 break;
396 case MessageType.writeCheque:
397 requirePlaying(session);
398 simulation.enqueue(session.id, {
399 type: "write-cheque",
400 characterId: session.characterId,
401 slotIndex: message.slotIndex | 0,
402 vaultSlotIndex: message.vaultSlotIndex | 0,
403 quantity: message.quantity ?? 1
404 });
405 break;
406 case MessageType.redeemCheque:
407 requirePlaying(session);
408 simulation.enqueue(session.id, {
409 type: "redeem-cheque",
410 characterId: session.characterId,
411 slotIndex: message.slotIndex | 0
412 });
413 break;
414 case MessageType.claimInheritance:
415 requirePlaying(session);
416 {
417 const inheritance = stateDb.getInheritance(session.account.account_id);
418 simulation.enqueue(session.id, {
419 type: "claim-inheritance",
420 characterId: session.characterId,
421 stacks: (inheritance.slots ?? []).filter(Boolean)
422 });
423 }
424 break;
425 case MessageType.attack:
426 requirePlaying(session);
427 simulation.enqueue(session.id, {
428 type: "attack",
429 characterId: session.characterId,
430 targetEntityId: message.targetEntityId | 0
431 });
432 break;
433 case MessageType.cancelAttack:
434 requirePlaying(session);
435 simulation.enqueue(session.id, {
436 type: "cancel-attack",
437 characterId: session.characterId
438 });
439 break;
440 case MessageType.interact:
441 requirePlaying(session);
442 simulation.enqueue(session.id, {
443 type: "interact",
444 characterId: session.characterId,
445 targetEntityId: message.targetEntityId | 0
446 });
447 break;
448 case MessageType.buyFromShop:
449 requirePlaying(session);
450 simulation.enqueue(session.id, {
451 type: "buy-from-shop",
452 characterId: session.characterId,
453 npcEntityId: message.npcEntityId | 0,
454 itemId: message.itemId | 0,
455 quantity: message.quantity | 0 || 1,
456 listingId: typeof message.listingId === "string" ? message.listingId : null,
457 source: typeof message.source === "string" ? message.source : null
458 });
459 break;
460 case MessageType.sellToShop:
461 requirePlaying(session);
462 simulation.enqueue(session.id, {
463 type: "sell-to-shop",
464 characterId: session.characterId,
465 npcEntityId: message.npcEntityId | 0,
466 slotIndex: message.slotIndex | 0,
467 quantity: message.quantity | 0 || 1
468 });
469 break;
470 case MessageType.closeShop:
471 requirePlaying(session);
472 simulation.enqueue(session.id, {
473 type: "close-shop",
474 characterId: session.characterId,
475 npcEntityId: message.npcEntityId | 0
476 });
477 break;
478 case MessageType.openMarket:
479 requirePlaying(session);
480 simulation.enqueue(session.id, {
481 type: "open-market",
482 characterId: session.characterId
483 });
484 break;
485 case MessageType.closeMarket:
486 requirePlaying(session);
487 simulation.enqueue(session.id, {
488 type: "close-market",
489 characterId: session.characterId
490 });
491 break;
492 case MessageType.placeMarketSell:
493 requirePlaying(session);
494 simulation.enqueue(session.id, {
495 type: "place-market-sell",
496 characterId: session.characterId,
497 slotIndex: message.slotIndex | 0,
498 quantity: message.quantity | 0 || 1,
499 minUnitPrice: message.minUnitPrice | 0
500 });
501 break;
502 case MessageType.placeMarketBuy:
503 requirePlaying(session);
504 simulation.enqueue(session.id, {
505 type: "place-market-buy",
506 characterId: session.characterId,
507 itemId: message.itemId | 0,
508 quantity: message.quantity | 0 || 1,
509 maxUnitPrice: message.maxUnitPrice | 0
510 });
511 break;
512 case MessageType.cancelMarketOrder:
513 requirePlaying(session);
514 simulation.enqueue(session.id, {
515 type: "cancel-market-order",
516 characterId: session.characterId,
517 orderId: message.orderId | 0
518 });
519 break;
520 case MessageType.follow:
521 requirePlaying(session);
522 simulation.enqueue(session.id, {
523 type: "follow",
524 characterId: session.characterId,
525 targetEntityId: message.targetEntityId | 0
526 });
527 break;
528 case MessageType.cancelFollow:
529 requirePlaying(session);
530 simulation.enqueue(session.id, {
531 type: "cancel-follow",
532 characterId: session.characterId
533 });
534 break;
535 case MessageType.sendPigeon:
536 requirePlaying(session);
537 {
538 const result = simulation.dispatchPigeon({
539 characterId: session.characterId,
540 destination: message.destination,
541 cargo: message.cargo
542 });
543 send(session, {
544 type: MessageType.pigeonDispatched,
545 courierId: result.transit.courierId,
546 destinationKind: result.transit.destinationKind,
547 destinationCharacterId: result.transit.destinationCharacterId
548 });
549 send(session, { type: MessageType.inventory, ...result.bag });
550 }
551 break;
552 case MessageType.searchCharacter:
553 requirePlaying(session);
554 {
555 const character = friends.findByFullName(message.firstName, message.lastName);
556 send(session, {
557 type: MessageType.characterSearchResult,
558 character: character ?? null
559 });
560 }
561 break;
562 case MessageType.writeLetter:
563 requirePlaying(session);
564 simulation.enqueue(session.id, {
565 type: "write-letter",
566 characterId: session.characterId,
567 slotIndex: message.slotIndex,
568 body: message.body
569 });
570 break;
571 case MessageType.editLetter:
572 requirePlaying(session);
573 simulation.enqueue(session.id, {
574 type: "edit-letter",
575 characterId: session.characterId,
576 slotIndex: message.slotIndex,
577 body: message.body
578 });
579 break;
580 case MessageType.openLetter:
581 requirePlaying(session);
582 simulation.enqueue(session.id, {
583 type: "open-letter",
584 characterId: session.characterId,
585 slotIndex: message.slotIndex
586 });
587 break;
588 case MessageType.editorLoadChunk:
589 requireAdmin(session);
590 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
591 break;
592 case MessageType.editorSaveChunk:
593 requireAdmin(session);
594 send(session, {
595 type: MessageType.editorChunk,
596 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
597 });
598 break;
599 case MessageType.editorLoadSettings:
600 requireAdmin(session);
601 send(session, {
602 type: MessageType.editorSettings,
603 ...editor.loadSettings(),
604 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
605 });
606 break;
607 case MessageType.editorSaveSettings:
608 requireAdmin(session);
609 {
610 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
611 simulation.applySettings(saved.settings);
612 broadcastStatus();
613 broadcastSettings(saved);
614 }
615 break;
616 case MessageType.editorApplyRevision:
617 requireAdmin(session);
618 if (!editor.revisionStatus().pendingRevisionId)
619 {
620 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
621 break;
622 }
623 {
624 const appliedRevisionId = editor.applyPendingRevision();
625 simulation.reloadWorld();
626 for (const other of sessions.values())
627 {
628 if (other.entityId)
629 { syncSubscriptions(other, true); }
630 }
631 broadcastStatus();
632 send(session, {
633 type: MessageType.editorRevisionApplied,
634 ...editor.revisionStatus(),
635 appliedRevisionId
636 });
637 }
638 break;
639 default:
640 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
641 }
642 }
643
644 function enterWorld (session, characterId)
645 {
646 leaveWorld(session);
647 const character = characters.getOwned(session.account.account_id, characterId);
648 if (character.deletion_scheduled_at)
649 {
650 const error = new Error("That character is marked for deletion.");
651 error.userFacing = true;
652 throw error;
653 }
654 for (const other of sessions.values())
655 {
656 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
657 {
658 const error = new Error("This account already has a character in the world.");
659 error.userFacing = true;
660 throw error;
661 }
662 }
663 session.characterId = character.character_id;
664 session.entityId = simulation.spawnCharacter(session.id, character);
665 const spawned = simulation.entityRecord(session.entityId);
666 send(session, {
667 type: MessageType.enterWorld,
668 entityId: session.entityId,
669 characterId: session.characterId,
670 tileX: spawned.tileX,
671 tileY: spawned.tileY,
672 gait: spawned.gait,
673 sex: spawned.sex,
674 firstName: spawned.firstName,
675 lastName: spawned.lastName,
676 layers: spawned.layers ?? [],
677 settings: simulation.settings,
678 worldTime: simulation.worldTime()
679 });
680 syncSubscriptions(session, true);
681 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
682 const bag = simulation.bagOf(session.entityId);
683 if (bag)
684 { send(session, { type: MessageType.inventory, ...bag }); }
685 const skills = simulation.skillsOf(session.entityId);
686 if (skills)
687 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
688 const stamina = simulation.staminaOf(session.entityId);
689 if (stamina)
690 {
691 send(session, {
692 type: MessageType.stamina,
693 current: stamina.current,
694 max: stamina.max,
695 gait: stamina.gait
696 });
697 }
698 if (character.is_dead)
699 {
700 send(session, {
701 type: MessageType.playerDied,
702 entityId: session.entityId,
703 characterId: session.characterId
704 });
705 }
706 publishReplication(simulation.drainReplication());
707 }
708
709 function leaveWorld (session)
710 {
711 if (session.characterId)
712 { simulation.despawnCharacter(session.characterId); }
713 publishReplication(simulation.drainReplication());
714 session.characterId = null;
715 session.entityId = null;
716 session.entitySubscribed.clear();
717 session.staticSubscribed.clear();
718 }
719
720 function syncSubscriptions (session, forceSnapshots)
721 {
722 if (!session.entityId)
723 { return; }
724 const position = simulation.positionOf(session.entityId);
725 if (!position)
726 { return; }
727
728 const centerChunkX = tileToChunk(position.tileX);
729 const centerChunkY = tileToChunk(position.tileY);
730 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
731 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, STATIC_CHUNK_RADIUS);
732 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
733 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
734
735 for (const key of session.staticSubscribed)
736 {
737 if (!staticNext.has(key))
738 {
739 const [chunkX, chunkY] = key.split(",").map(Number);
740 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
741 }
742 }
743
744 const snapshots = simulation.snapshotsForView(session.entityId);
745 for (const snapshot of snapshots)
746 {
747 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
748 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
749 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
750 {
751 send(session, { type: MessageType.chunkSnapshot, ...snapshot });
752 }
753 }
754 session.entitySubscribed = entityNext;
755 session.staticSubscribed = staticNext;
756 }
757
758 function requirePlaying (session)
759 {
760 if (!session.characterId)
761 {
762 const error = new Error("Select a character first.");
763 error.userFacing = true;
764 throw error;
765 }
766 }
767
768 function requireAdmin (session)
769 {
770 if (!session.account.is_admin)
771 {
772 const error = new Error("Admin only.");
773 error.userFacing = true;
774 throw error;
775 }
776 }
777
778 function broadcastStatus ()
779 {
780 const worldTime = simulation.worldTime();
781 for (const session of sessions.values())
782 {
783 if (session.entityId)
784 {
785 send(session, {
786 type: MessageType.worldStatus,
787 worldTime,
788 settings: simulation.settings,
789 activeRevisionId: simulation.activeRevisionId
790 });
791 }
792 }
793 }
794
795 function pushFriends (...characterIds)
796 {
797 const seen = new Set();
798 for (const characterId of characterIds)
799 {
800 const id = Number(characterId);
801 if (!id || seen.has(id))
802 { continue; }
803 seen.add(id);
804 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
805 for (const session of sessions.values())
806 {
807 if (session.characterId === id)
808 { send(session, payload); }
809 }
810 }
811 }
812
813 function broadcastSettings (payload)
814 {
815 for (const session of sessions.values())
816 {
817 if (session.account.is_admin)
818 { send(session, { type: MessageType.editorSettings, ...payload }); }
819 }
820 }
821
822 function onTickResult (result)
823 {
824 publishReplication(result.replication ?? []);
825 for (const event of result.events)
826 {
827 if (event.type === "command-error")
828 {
829 const session = sessions.get(event.sessionId);
830 if (session)
831 { send(session, { type: MessageType.error, message: event.message }); }
832 continue;
833 }
834 if (event.type === "inventory")
835 {
836 const session = event.sessionId != null
837 ? sessions.get(event.sessionId)
838 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
839 if (!session)
840 { continue; }
841 send(session, {
842 type: MessageType.inventory,
843 inventory: event.inventory,
844 equipment: event.equipment,
845 vault: event.vault,
846 vaultReserved: event.vaultReserved
847 });
848 if (event.bank)
849 {
850 send(session, {
851 type: MessageType.bankSnapshot,
852 vault: event.vault,
853 vaultReserved: event.vaultReserved,
854 inheritance: stateDb.getInheritance(session.account.account_id)
855 });
856 }
857 if (event.cauldron != null)
858 {
859 send(session, {
860 type: MessageType.cauldronSnapshot,
861 open: !!event.cauldron,
862 state: event.cauldronState ?? null,
863 alchemyResult: event.alchemyResult ?? null,
864 dyeConfirm: event.dyeConfirm ?? null
865 });
866 }
867 continue;
868 }
869 if (event.type === "skills")
870 {
871 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
872 if (!session)
873 { continue; }
874 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
875 continue;
876 }
877 if (event.type === "stamina")
878 {
879 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
880 if (!session)
881 { continue; }
882 send(session, {
883 type: MessageType.stamina,
884 current: event.current,
885 max: event.max,
886 gait: event.gait
887 });
888 continue;
889 }
890 if (event.type === "toast")
891 {
892 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
893 if (session)
894 { send(session, { type: MessageType.toast, message: event.message }); }
895 continue;
896 }
897 if (event.type === "pigeon-delivered")
898 {
899 for (const session of sessions.values())
900 {
901 if (session.characterId === event.senderCharacterId
902 || session.characterId === event.destinationCharacterId)
903 {
904 send(session, {
905 type: MessageType.pigeonDelivered,
906 courierId: event.courierId,
907 destinationKind: event.destinationKind,
908 cargo: event.cargo
909 });
910 }
911 }
912 continue;
913 }
914 if (event.type === "player-died")
915 {
916 const session = sessions.get(event.sessionId);
917 if (session)
918 {
919 send(session, {
920 type: MessageType.playerDied,
921 entityId: event.entityId,
922 characterId: event.characterId
923 });
924 }
925 continue;
926 }
927 if (event.type === "player-respawned")
928 {
929 const session = sessions.get(event.sessionId);
930 if (session)
931 {
932 send(session, {
933 type: MessageType.playerRespawned,
934 entityId: event.entityId,
935 characterId: event.characterId,
936 tileX: event.tileX,
937 tileY: event.tileY,
938 health: event.health,
939 maxHealth: event.maxHealth,
940 stamina: event.stamina,
941 maxStamina: event.maxStamina
942 });
943 }
944 continue;
945 }
946 if (event.type === "craft-result")
947 {
948 const session = sessions.get(event.sessionId);
949 if (session)
950 {
951 send(session, {
952 type: MessageType.craftResult,
953 recipeId: event.recipeId,
954 ok: !!event.ok,
955 error: event.error ?? null,
956 burned: !!event.burned
957 });
958 }
959 continue;
960 }
961 if (event.type === "station-open")
962 {
963 const session = sessions.get(event.sessionId);
964 if (session)
965 {
966 send(session, {
967 type: MessageType.stationOpen,
968 stationId: event.stationId
969 });
970 }
971 continue;
972 }
973 if (event.type === "shop-open")
974 {
975 const session = sessions.get(event.sessionId);
976 if (session)
977 {
978 send(session, {
979 type: MessageType.shopOpen,
980 npcEntityId: event.npcEntityId,
981 displayName: event.displayName,
982 sex: event.sex === "female" ? "female" : "male",
983 buysItems: !!event.buysItems,
984 stock: event.stock ?? []
985 });
986 }
987 continue;
988 }
989 if (event.type === "shop-closed")
990 {
991 const session = sessions.get(event.sessionId);
992 if (session)
993 {
994 send(session, {
995 type: MessageType.shopClosed,
996 npcEntityId: event.npcEntityId
997 });
998 }
999 continue;
1000 }
1001 if (event.type === "market-open")
1002 {
1003 const session = sessions.get(event.sessionId);
1004 if (session)
1005 {
1006 send(session, {
1007 type: MessageType.marketOpen,
1008 displayName: event.displayName,
1009 orders: event.orders ?? [],
1010 catalog: event.catalog ?? []
1011 });
1012 }
1013 continue;
1014 }
1015 if (event.type === "market-closed")
1016 {
1017 const session = sessions.get(event.sessionId);
1018 if (session)
1019 { send(session, { type: MessageType.marketClosed }); }
1020 continue;
1021 }
1022 if (event.type === "market-trade")
1023 {
1024 for (const session of sessions.values())
1025 {
1026 if (
1027 session.characterId === event.buyerCharacterId
1028 || session.characterId === event.sellerCharacterId
1029 )
1030 {
1031 send(session, {
1032 type: MessageType.marketTrade,
1033 itemId: event.itemId,
1034 quantity: event.quantity,
1035 unitPrice: event.unitPrice,
1036 triggeringSide: event.triggeringSide
1037 });
1038 }
1039 }
1040 continue;
1041 }
1042 if (event.type === "item-bubble")
1043 {
1044 broadcastItemBubble(
1045 sessions,
1046 simulation,
1047 event.entityId,
1048 event.itemId,
1049 event.quantity
1050 );
1051 continue;
1052 }
1053 if (event.type === "gather-swing" || event.type === "tile-shove")
1054 {
1055 publishEntity({
1056 ...event,
1057 type: event.type
1058 });
1059 continue;
1060 }
1061 if (event.type === "chunk-delta")
1062 {
1063 publishEntity(event);
1064 continue;
1065 }
1066 if (event.type === "gather-complete")
1067 {
1068 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1069 if (session)
1070 {
1071 send(session, {
1072 type: MessageType.gatherComplete,
1073 kind: event.kind,
1074 materialId: event.materialId,
1075 itemId: event.itemId
1076 });
1077 }
1078 continue;
1079 }
1080 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 === "gather-swing" || event.type === "tile-shove" || event.type === "chunk-delta" || event.type === "skill-level-up")
1081 { publishEntity(event); }
1082 }
1083 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1084 { broadcastStatus(); }
1085 }
1086
1087 function publishReplication (events)
1088 {
1089 for (const event of events ?? [])
1090 { publishEntity(event); }
1091 }
1092
1093 function publishEntity (event)
1094 {
1095 const fromKey = event.fromTileX != null
1096 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
1097 : null;
1098 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
1099 for (const session of sessions.values())
1100 {
1101 if (!session.entityId)
1102 { continue; }
1103 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1104 const seesTo = session.entitySubscribed.has(toKey);
1105 const seesStaticTo = session.staticSubscribed.has(toKey);
1106 if (event.type === "entity-spawn")
1107 {
1108 if (session.entityId === event.entityId || !seesTo)
1109 { continue; }
1110 send(session, spawnPayload(event));
1111 continue;
1112 }
1113 if (event.type === "entity-despawn")
1114 {
1115 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1116 { continue; }
1117 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1118 continue;
1119 }
1120 if (event.type === "entity-appearance")
1121 {
1122 if (!seesTo)
1123 { continue; }
1124 send(session, {
1125 type: MessageType.entityAppearance,
1126 entityId: event.entityId,
1127 sprite: event.sprite,
1128 layers: event.layers ?? [],
1129 lightRadiusTiles: event.lightRadiusTiles ?? 0
1130 });
1131 continue;
1132 }
1133 if (event.type === "ground-item-appear")
1134 {
1135 if (!seesTo)
1136 { continue; }
1137 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1138 continue;
1139 }
1140 if (event.type === "ground-item-despawn")
1141 {
1142 if (!seesTo)
1143 { continue; }
1144 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1145 continue;
1146 }
1147 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1148 {
1149 if (!seesTo && !seesFrom)
1150 { continue; }
1151 const type = event.type === "combat-swing"
1152 ? MessageType.combatSwing
1153 : event.type === "combat-hit"
1154 ? MessageType.combatHit
1155 : event.type === "combat-block"
1156 ? MessageType.combatBlock
1157 : MessageType.combatMiss;
1158 send(session, {
1159 type,
1160 attackerId: event.attackerId,
1161 targetId: event.targetId,
1162 damage: event.damage,
1163 health: event.health,
1164 maxHealth: event.maxHealth,
1165 tileX: event.tileX,
1166 tileY: event.tileY,
1167 fromTileX: event.fromTileX,
1168 fromTileY: event.fromTileY
1169 });
1170 continue;
1171 }
1172 if (event.type === "gather-swing" || event.type === "tile-shove")
1173 {
1174 if (!seesTo && !seesFrom)
1175 { continue; }
1176 if (event.type === "gather-swing")
1177 {
1178 send(session, {
1179 type: MessageType.gatherSwing,
1180 attackerId: event.attackerId,
1181 tileX: event.tileX,
1182 tileY: event.tileY,
1183 fromTileX: event.fromTileX,
1184 fromTileY: event.fromTileY,
1185 toolItemId: event.toolItemId ?? null
1186 });
1187 }
1188 else
1189 {
1190 send(session, {
1191 type: MessageType.tileShove,
1192 attackerId: event.attackerId,
1193 tileX: event.tileX,
1194 tileY: event.tileY,
1195 fromTileX: event.fromTileX,
1196 fromTileY: event.fromTileY
1197 });
1198 }
1199 continue;
1200 }
1201 if (event.type === "skill-level-up")
1202 {
1203 if (session.entityId !== event.entityId && !seesTo)
1204 { continue; }
1205 send(session, {
1206 type: MessageType.skillLevelUp,
1207 entityId: event.entityId,
1208 characterId: event.characterId,
1209 skillId: event.skillId,
1210 level: event.level,
1211 displayName: event.displayName,
1212 icon: event.icon
1213 });
1214 continue;
1215 }
1216 if (event.type === "chunk-delta")
1217 {
1218 if (!seesStaticTo)
1219 { continue; }
1220 send(session, {
1221 type: MessageType.chunkDelta,
1222 chunkX: event.chunkX,
1223 chunkY: event.chunkY,
1224 tiles: [{
1225 localX: event.localX,
1226 localY: event.localY,
1227 block: event.block
1228 }]
1229 });
1230 continue;
1231 }
1232 if (event.type !== "entity-move")
1233 { continue; }
1234 if (seesTo)
1235 {
1236 if (!seesFrom)
1237 { send(session, spawnPayload(event)); }
1238 else
1239 {
1240 send(session, {
1241 type: MessageType.entityMove,
1242 entityId: event.entityId,
1243 tileX: event.tileX,
1244 tileY: event.tileY,
1245 worldX: event.worldX,
1246 worldY: event.worldY,
1247 gait: event.gait,
1248 lerpMs: event.lerpMs,
1249 freeFlight: !!event.freeFlight
1250 });
1251 }
1252 }
1253 else if (seesFrom)
1254 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1255 if (session.entityId === event.entityId)
1256 { syncSubscriptions(session, false); }
1257 }
1258 }
1259
1260 function spawnPayload (event)
1261 {
1262 const record = simulation.entityRecord(event.entityId) ?? event;
1263 return {
1264 type: MessageType.entitySpawn,
1265 entityId: event.entityId,
1266 characterId: record.characterId ?? event.characterId ?? null,
1267 tileX: event.tileX ?? record.tileX,
1268 tileY: event.tileY ?? record.tileY,
1269 worldX: event.worldX ?? record.worldX,
1270 worldY: event.worldY ?? record.worldY,
1271 gait: event.gait ?? record.gait,
1272 sex: record.sex ?? event.sex ?? null,
1273 firstName: record.firstName ?? event.firstName ?? "",
1274 lastName: record.lastName ?? event.lastName ?? "",
1275 sprite: record.sprite ?? event.sprite ?? null,
1276 layers: record.layers ?? event.layers ?? [],
1277 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1278 canFight: !!(record.canFight ?? event.canFight),
1279 hostile: !!(record.hostile ?? event.hostile),
1280 talkable: !!(record.talkable ?? event.talkable),
1281 untargetable: !!(record.untargetable ?? event.untargetable),
1282 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1283 health: record.health ?? event.health,
1284 maxHealth: record.maxHealth ?? event.maxHealth,
1285 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1286 };
1287 }
1288
1289 return {
1290 sessions,
1291 onTickResult,
1292 wss,
1293 async shutdown ()
1294 {
1295 await Promise.all([...sessions.values()].map(async (session) =>
1296 {
1297 await sendAsync(session, {
1298 type: MessageType.forceLogout,
1299 reason: "Server shutting down."
1300 });
1301 leaveWorld(session);
1302 await closeAsync(session, 1001, "Server shutting down.");
1303 }));
1304 sessions.clear();
1305 await simulation.shutdown();
1306 }
1307 };
1308}
1309
1310function send (session, payload)
1311{
1312 if (session.socket.readyState === 1)
1313 { session.socket.send(JSON.stringify(payload)); }
1314}
1315
1316function sendAsync (session, payload)
1317{
1318 return new Promise((resolve) =>
1319 {
1320 if (session.socket.readyState !== 1)
1321 {
1322 resolve();
1323 return;
1324 }
1325 session.socket.send(JSON.stringify(payload), () => resolve());
1326 });
1327}
1328
1329function closeAsync (session, code, reason)
1330{
1331 return new Promise((resolve) =>
1332 {
1333 if (session.socket.readyState !== 1)
1334 {
1335 resolve();
1336 return;
1337 }
1338 session.socket.once("close", resolve);
1339 try
1340 { session.socket.close(code, reason); }
1341 catch
1342 { resolve(); }
1343 });
1344}