BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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