BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 31.8 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.cancelGather:
236 requirePlaying(session);
237 simulation.enqueue(session.id, {
238 type: "cancel-gather",
239 characterId: session.characterId
240 });
241 break;
242 case MessageType.startCraft:
243 requirePlaying(session);
244 simulation.enqueue(session.id, {
245 type: "start-craft",
246 characterId: session.characterId,
247 stationId: message.stationId,
248 recipeId: message.recipeId
249 });
250 break;
251 case MessageType.cancelCraft:
252 requirePlaying(session);
253 simulation.enqueue(session.id, {
254 type: "cancel-craft",
255 characterId: session.characterId
256 });
257 break;
258 case MessageType.cauldronSetSlot:
259 requirePlaying(session);
260 simulation.enqueue(session.id, {
261 type: "cauldron-set-slot",
262 characterId: session.characterId,
263 slotIndex: message.slotIndex | 0,
264 itemId: message.itemId | 0,
265 quantity: message.quantity | 0
266 });
267 break;
268 case MessageType.cauldronInsert:
269 requirePlaying(session);
270 simulation.enqueue(session.id, {
271 type: "cauldron-insert",
272 characterId: session.characterId,
273 slotIndex: message.slotIndex | 0
274 });
275 break;
276 case MessageType.cauldronAction:
277 requirePlaying(session);
278 simulation.enqueue(session.id, {
279 type: "cauldron-action",
280 characterId: session.characterId,
281 action: message.action
282 });
283 break;
284 case MessageType.cauldronBottle:
285 requirePlaying(session);
286 simulation.enqueue(session.id, {
287 type: "cauldron-bottle",
288 characterId: session.characterId
289 });
290 break;
291 case MessageType.cauldronClear:
292 requirePlaying(session);
293 simulation.enqueue(session.id, {
294 type: "cauldron-clear",
295 characterId: session.characterId
296 });
297 break;
298 case MessageType.cauldronSaveRecipe:
299 requirePlaying(session);
300 simulation.enqueue(session.id, {
301 type: "cauldron-save-recipe",
302 characterId: session.characterId
303 });
304 break;
305 case MessageType.cauldronClose:
306 requirePlaying(session);
307 simulation.enqueue(session.id, {
308 type: "cauldron-close",
309 characterId: session.characterId
310 });
311 break;
312 case MessageType.bankDeposit:
313 requirePlaying(session);
314 simulation.enqueue(session.id, {
315 type: "bank-deposit",
316 characterId: session.characterId,
317 slotIndex: message.slotIndex | 0,
318 quantity: message.quantity ?? null
319 });
320 break;
321 case MessageType.bankWithdraw:
322 requirePlaying(session);
323 simulation.enqueue(session.id, {
324 type: "bank-withdraw",
325 characterId: session.characterId,
326 slotIndex: message.slotIndex | 0,
327 quantity: message.quantity ?? null
328 });
329 break;
330 case MessageType.getBlankCheques:
331 requirePlaying(session);
332 simulation.enqueue(session.id, {
333 type: "get-blank-cheques",
334 characterId: session.characterId
335 });
336 break;
337 case MessageType.returnBlankCheques:
338 requirePlaying(session);
339 simulation.enqueue(session.id, {
340 type: "return-blank-cheques",
341 characterId: session.characterId,
342 slotIndex: message.slotIndex | 0,
343 quantity: message.quantity ?? null
344 });
345 break;
346 case MessageType.writeCheque:
347 requirePlaying(session);
348 simulation.enqueue(session.id, {
349 type: "write-cheque",
350 characterId: session.characterId,
351 slotIndex: message.slotIndex | 0,
352 vaultSlotIndex: message.vaultSlotIndex | 0,
353 quantity: message.quantity ?? 1
354 });
355 break;
356 case MessageType.redeemCheque:
357 requirePlaying(session);
358 simulation.enqueue(session.id, {
359 type: "redeem-cheque",
360 characterId: session.characterId,
361 slotIndex: message.slotIndex | 0
362 });
363 break;
364 case MessageType.claimInheritance:
365 requirePlaying(session);
366 {
367 const inheritance = stateDb.getInheritance(session.account.account_id);
368 simulation.enqueue(session.id, {
369 type: "claim-inheritance",
370 characterId: session.characterId,
371 stacks: (inheritance.slots ?? []).filter(Boolean)
372 });
373 }
374 break;
375 case MessageType.attack:
376 requirePlaying(session);
377 simulation.enqueue(session.id, {
378 type: "attack",
379 characterId: session.characterId,
380 targetEntityId: message.targetEntityId | 0
381 });
382 break;
383 case MessageType.cancelAttack:
384 requirePlaying(session);
385 simulation.enqueue(session.id, {
386 type: "cancel-attack",
387 characterId: session.characterId
388 });
389 break;
390 case MessageType.interact:
391 requirePlaying(session);
392 simulation.enqueue(session.id, {
393 type: "interact",
394 characterId: session.characterId,
395 targetEntityId: message.targetEntityId | 0
396 });
397 break;
398 case MessageType.buyFromShop:
399 requirePlaying(session);
400 simulation.enqueue(session.id, {
401 type: "buy-from-shop",
402 characterId: session.characterId,
403 npcEntityId: message.npcEntityId | 0,
404 itemId: message.itemId | 0,
405 quantity: message.quantity | 0 || 1,
406 listingId: typeof message.listingId === "string" ? message.listingId : null,
407 source: typeof message.source === "string" ? message.source : null
408 });
409 break;
410 case MessageType.sellToShop:
411 requirePlaying(session);
412 simulation.enqueue(session.id, {
413 type: "sell-to-shop",
414 characterId: session.characterId,
415 npcEntityId: message.npcEntityId | 0,
416 slotIndex: message.slotIndex | 0,
417 quantity: message.quantity | 0 || 1
418 });
419 break;
420 case MessageType.closeShop:
421 requirePlaying(session);
422 simulation.enqueue(session.id, {
423 type: "close-shop",
424 characterId: session.characterId,
425 npcEntityId: message.npcEntityId | 0
426 });
427 break;
428 case MessageType.follow:
429 requirePlaying(session);
430 simulation.enqueue(session.id, {
431 type: "follow",
432 characterId: session.characterId,
433 targetEntityId: message.targetEntityId | 0
434 });
435 break;
436 case MessageType.cancelFollow:
437 requirePlaying(session);
438 simulation.enqueue(session.id, {
439 type: "cancel-follow",
440 characterId: session.characterId
441 });
442 break;
443 case MessageType.sendPigeon:
444 requirePlaying(session);
445 {
446 const result = simulation.dispatchPigeon({
447 characterId: session.characterId,
448 destination: message.destination,
449 cargo: message.cargo
450 });
451 send(session, {
452 type: MessageType.pigeonDispatched,
453 courierId: result.transit.courierId,
454 destinationKind: result.transit.destinationKind,
455 destinationCharacterId: result.transit.destinationCharacterId
456 });
457 send(session, { type: MessageType.inventory, ...result.bag });
458 }
459 break;
460 case MessageType.searchCharacter:
461 requirePlaying(session);
462 {
463 const character = friends.findByFullName(message.firstName, message.lastName);
464 send(session, {
465 type: MessageType.characterSearchResult,
466 character: character ?? null
467 });
468 }
469 break;
470 case MessageType.writeLetter:
471 requirePlaying(session);
472 simulation.enqueue(session.id, {
473 type: "write-letter",
474 characterId: session.characterId,
475 slotIndex: message.slotIndex,
476 body: message.body
477 });
478 break;
479 case MessageType.editLetter:
480 requirePlaying(session);
481 simulation.enqueue(session.id, {
482 type: "edit-letter",
483 characterId: session.characterId,
484 slotIndex: message.slotIndex,
485 body: message.body
486 });
487 break;
488 case MessageType.openLetter:
489 requirePlaying(session);
490 simulation.enqueue(session.id, {
491 type: "open-letter",
492 characterId: session.characterId,
493 slotIndex: message.slotIndex
494 });
495 break;
496 case MessageType.editorLoadChunk:
497 requireAdmin(session);
498 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
499 break;
500 case MessageType.editorSaveChunk:
501 requireAdmin(session);
502 send(session, {
503 type: MessageType.editorChunk,
504 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
505 });
506 break;
507 case MessageType.editorLoadSettings:
508 requireAdmin(session);
509 send(session, {
510 type: MessageType.editorSettings,
511 ...editor.loadSettings(),
512 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
513 });
514 break;
515 case MessageType.editorSaveSettings:
516 requireAdmin(session);
517 {
518 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
519 simulation.applySettings(saved.settings);
520 broadcastStatus();
521 broadcastSettings(saved);
522 }
523 break;
524 case MessageType.editorApplyRevision:
525 requireAdmin(session);
526 if (!editor.revisionStatus().pendingRevisionId)
527 {
528 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
529 break;
530 }
531 {
532 const appliedRevisionId = editor.applyPendingRevision();
533 simulation.reloadWorld();
534 for (const other of sessions.values())
535 {
536 if (other.entityId)
537 { syncSubscriptions(other, true); }
538 }
539 broadcastStatus();
540 send(session, {
541 type: MessageType.editorRevisionApplied,
542 ...editor.revisionStatus(),
543 appliedRevisionId
544 });
545 }
546 break;
547 default:
548 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
549 }
550 }
551
552 function enterWorld (session, characterId)
553 {
554 leaveWorld(session);
555 const character = characters.getOwned(session.account.account_id, characterId);
556 if (character.deletion_scheduled_at)
557 {
558 const error = new Error("That character is marked for deletion.");
559 error.userFacing = true;
560 throw error;
561 }
562 for (const other of sessions.values())
563 {
564 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
565 {
566 const error = new Error("This account already has a character in the world.");
567 error.userFacing = true;
568 throw error;
569 }
570 }
571 session.characterId = character.character_id;
572 session.entityId = simulation.spawnCharacter(session.id, character);
573 const spawned = simulation.entityRecord(session.entityId);
574 send(session, {
575 type: MessageType.enterWorld,
576 entityId: session.entityId,
577 characterId: session.characterId,
578 tileX: spawned.tileX,
579 tileY: spawned.tileY,
580 gait: spawned.gait,
581 sex: spawned.sex,
582 firstName: spawned.firstName,
583 lastName: spawned.lastName,
584 layers: spawned.layers ?? [],
585 settings: simulation.settings,
586 worldTime: simulation.worldTime()
587 });
588 syncSubscriptions(session, true);
589 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
590 const bag = simulation.bagOf(session.entityId);
591 if (bag)
592 { send(session, { type: MessageType.inventory, ...bag }); }
593 const skills = simulation.skillsOf(session.entityId);
594 if (skills)
595 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
596 const stamina = simulation.staminaOf(session.entityId);
597 if (stamina)
598 {
599 send(session, {
600 type: MessageType.stamina,
601 current: stamina.current,
602 max: stamina.max,
603 gait: stamina.gait
604 });
605 }
606 if (character.is_dead)
607 {
608 send(session, {
609 type: MessageType.playerDied,
610 entityId: session.entityId,
611 characterId: session.characterId
612 });
613 }
614 publishReplication(simulation.drainReplication());
615 }
616
617 function leaveWorld (session)
618 {
619 if (session.characterId)
620 { simulation.despawnCharacter(session.characterId); }
621 publishReplication(simulation.drainReplication());
622 session.characterId = null;
623 session.entityId = null;
624 session.subscribed.clear();
625 }
626
627 function syncSubscriptions (session, forceSnapshots)
628 {
629 if (!session.entityId)
630 { return; }
631 const position = simulation.positionOf(session.entityId);
632 if (!position)
633 { return; }
634
635 const next = new Set(
636 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
637 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
638 );
639 for (const key of session.subscribed)
640 {
641 if (!next.has(key))
642 {
643 const [chunkX, chunkY] = key.split(",").map(Number);
644 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
645 }
646 }
647 const snapshots = simulation.snapshotFor(session.entityId);
648 for (const snapshot of snapshots)
649 {
650 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
651 if (forceSnapshots || !session.subscribed.has(key))
652 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
653 }
654 session.subscribed = next;
655 }
656
657 function requirePlaying (session)
658 {
659 if (!session.characterId)
660 {
661 const error = new Error("Select a character first.");
662 error.userFacing = true;
663 throw error;
664 }
665 }
666
667 function requireAdmin (session)
668 {
669 if (!session.account.is_admin)
670 {
671 const error = new Error("Admin only.");
672 error.userFacing = true;
673 throw error;
674 }
675 }
676
677 function broadcastStatus ()
678 {
679 const worldTime = simulation.worldTime();
680 for (const session of sessions.values())
681 {
682 if (session.entityId)
683 {
684 send(session, {
685 type: MessageType.worldStatus,
686 worldTime,
687 settings: simulation.settings,
688 activeRevisionId: simulation.activeRevisionId
689 });
690 }
691 }
692 }
693
694 function pushFriends (...characterIds)
695 {
696 const seen = new Set();
697 for (const characterId of characterIds)
698 {
699 const id = Number(characterId);
700 if (!id || seen.has(id))
701 { continue; }
702 seen.add(id);
703 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
704 for (const session of sessions.values())
705 {
706 if (session.characterId === id)
707 { send(session, payload); }
708 }
709 }
710 }
711
712 function broadcastSettings (payload)
713 {
714 for (const session of sessions.values())
715 {
716 if (session.account.is_admin)
717 { send(session, { type: MessageType.editorSettings, ...payload }); }
718 }
719 }
720
721 function onTickResult (result)
722 {
723 publishReplication(result.replication ?? []);
724 for (const event of result.events)
725 {
726 if (event.type === "command-error")
727 {
728 const session = sessions.get(event.sessionId);
729 if (session)
730 { send(session, { type: MessageType.error, message: event.message }); }
731 continue;
732 }
733 if (event.type === "inventory")
734 {
735 const session = event.sessionId != null
736 ? sessions.get(event.sessionId)
737 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
738 if (!session)
739 { continue; }
740 send(session, {
741 type: MessageType.inventory,
742 inventory: event.inventory,
743 equipment: event.equipment,
744 vault: event.vault,
745 vaultReserved: event.vaultReserved
746 });
747 if (event.bank)
748 {
749 send(session, {
750 type: MessageType.bankSnapshot,
751 vault: event.vault,
752 vaultReserved: event.vaultReserved,
753 inheritance: stateDb.getInheritance(session.account.account_id)
754 });
755 }
756 if (event.cauldron != null)
757 {
758 send(session, {
759 type: MessageType.cauldronSnapshot,
760 open: !!event.cauldron,
761 state: event.cauldronState ?? null,
762 alchemyResult: event.alchemyResult ?? null
763 });
764 }
765 continue;
766 }
767 if (event.type === "skills")
768 {
769 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
770 if (!session)
771 { continue; }
772 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
773 continue;
774 }
775 if (event.type === "stamina")
776 {
777 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
778 if (!session)
779 { continue; }
780 send(session, {
781 type: MessageType.stamina,
782 current: event.current,
783 max: event.max,
784 gait: event.gait
785 });
786 continue;
787 }
788 if (event.type === "pigeon-delivered")
789 {
790 for (const session of sessions.values())
791 {
792 if (session.characterId === event.senderCharacterId
793 || session.characterId === event.destinationCharacterId)
794 {
795 send(session, {
796 type: MessageType.pigeonDelivered,
797 courierId: event.courierId,
798 destinationKind: event.destinationKind,
799 cargo: event.cargo
800 });
801 }
802 }
803 continue;
804 }
805 if (event.type === "player-died")
806 {
807 const session = sessions.get(event.sessionId);
808 if (session)
809 {
810 send(session, {
811 type: MessageType.playerDied,
812 entityId: event.entityId,
813 characterId: event.characterId
814 });
815 }
816 continue;
817 }
818 if (event.type === "player-respawned")
819 {
820 const session = sessions.get(event.sessionId);
821 if (session)
822 {
823 send(session, {
824 type: MessageType.playerRespawned,
825 entityId: event.entityId,
826 characterId: event.characterId,
827 tileX: event.tileX,
828 tileY: event.tileY,
829 health: event.health,
830 maxHealth: event.maxHealth,
831 stamina: event.stamina,
832 maxStamina: event.maxStamina
833 });
834 }
835 continue;
836 }
837 if (event.type === "craft-result")
838 {
839 const session = sessions.get(event.sessionId);
840 if (session)
841 {
842 send(session, {
843 type: MessageType.craftResult,
844 recipeId: event.recipeId,
845 ok: !!event.ok,
846 error: event.error ?? null,
847 burned: !!event.burned
848 });
849 }
850 continue;
851 }
852 if (event.type === "station-open")
853 {
854 const session = sessions.get(event.sessionId);
855 if (session)
856 {
857 send(session, {
858 type: MessageType.stationOpen,
859 stationId: event.stationId
860 });
861 }
862 continue;
863 }
864 if (event.type === "shop-open")
865 {
866 const session = sessions.get(event.sessionId);
867 if (session)
868 {
869 send(session, {
870 type: MessageType.shopOpen,
871 npcEntityId: event.npcEntityId,
872 displayName: event.displayName,
873 sex: event.sex === "female" ? "female" : "male",
874 buysItems: !!event.buysItems,
875 stock: event.stock ?? []
876 });
877 }
878 continue;
879 }
880 if (event.type === "shop-closed")
881 {
882 const session = sessions.get(event.sessionId);
883 if (session)
884 {
885 send(session, {
886 type: MessageType.shopClosed,
887 npcEntityId: event.npcEntityId
888 });
889 }
890 continue;
891 }
892 if (event.type === "item-bubble")
893 {
894 broadcastItemBubble(
895 sessions,
896 simulation,
897 event.entityId,
898 event.itemId,
899 event.quantity
900 );
901 continue;
902 }
903 if (event.type === "gather-swing" || event.type === "tile-shove")
904 {
905 publishEntity({
906 ...event,
907 type: event.type
908 });
909 continue;
910 }
911 if (event.type === "chunk-delta")
912 {
913 publishEntity(event);
914 continue;
915 }
916 if (event.type === "gather-complete")
917 {
918 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
919 if (session)
920 {
921 send(session, {
922 type: MessageType.gatherComplete,
923 kind: event.kind,
924 materialId: event.materialId,
925 itemId: event.itemId
926 });
927 }
928 continue;
929 }
930 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")
931 { publishEntity(event); }
932 }
933 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
934 { broadcastStatus(); }
935 }
936
937 function publishReplication (events)
938 {
939 for (const event of events ?? [])
940 { publishEntity(event); }
941 }
942
943 function publishEntity (event)
944 {
945 const fromKey = event.fromTileX != null
946 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
947 : null;
948 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
949 for (const session of sessions.values())
950 {
951 if (!session.entityId)
952 { continue; }
953 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
954 const seesTo = session.subscribed.has(toKey);
955 if (event.type === "entity-spawn")
956 {
957 if (session.entityId === event.entityId || !seesTo)
958 { continue; }
959 send(session, spawnPayload(event));
960 continue;
961 }
962 if (event.type === "entity-despawn")
963 {
964 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
965 { continue; }
966 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
967 continue;
968 }
969 if (event.type === "entity-appearance")
970 {
971 if (!seesTo)
972 { continue; }
973 send(session, {
974 type: MessageType.entityAppearance,
975 entityId: event.entityId,
976 sprite: event.sprite,
977 layers: event.layers ?? [],
978 lightRadiusTiles: event.lightRadiusTiles ?? 0
979 });
980 continue;
981 }
982 if (event.type === "ground-item-appear")
983 {
984 if (!seesTo)
985 { continue; }
986 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
987 continue;
988 }
989 if (event.type === "ground-item-despawn")
990 {
991 if (!seesTo)
992 { continue; }
993 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
994 continue;
995 }
996 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
997 {
998 if (!seesTo && !seesFrom)
999 { continue; }
1000 const type = event.type === "combat-swing"
1001 ? MessageType.combatSwing
1002 : event.type === "combat-hit"
1003 ? MessageType.combatHit
1004 : event.type === "combat-block"
1005 ? MessageType.combatBlock
1006 : MessageType.combatMiss;
1007 send(session, {
1008 type,
1009 attackerId: event.attackerId,
1010 targetId: event.targetId,
1011 damage: event.damage,
1012 health: event.health,
1013 maxHealth: event.maxHealth,
1014 tileX: event.tileX,
1015 tileY: event.tileY,
1016 fromTileX: event.fromTileX,
1017 fromTileY: event.fromTileY
1018 });
1019 continue;
1020 }
1021 if (event.type === "gather-swing" || event.type === "tile-shove")
1022 {
1023 if (!seesTo && !seesFrom)
1024 { continue; }
1025 send(session, {
1026 type: MessageType.tileShove,
1027 attackerId: event.attackerId,
1028 tileX: event.tileX,
1029 tileY: event.tileY,
1030 fromTileX: event.fromTileX,
1031 fromTileY: event.fromTileY
1032 });
1033 continue;
1034 }
1035 if (event.type === "chunk-delta")
1036 {
1037 if (!seesTo)
1038 { continue; }
1039 send(session, {
1040 type: MessageType.chunkDelta,
1041 chunkX: event.chunkX,
1042 chunkY: event.chunkY,
1043 tiles: [{
1044 localX: event.localX,
1045 localY: event.localY,
1046 block: event.block
1047 }]
1048 });
1049 continue;
1050 }
1051 if (event.type !== "entity-move")
1052 { continue; }
1053 if (seesTo)
1054 {
1055 if (!seesFrom)
1056 { send(session, spawnPayload(event)); }
1057 else
1058 {
1059 send(session, {
1060 type: MessageType.entityMove,
1061 entityId: event.entityId,
1062 tileX: event.tileX,
1063 tileY: event.tileY,
1064 worldX: event.worldX,
1065 worldY: event.worldY,
1066 gait: event.gait,
1067 lerpMs: event.lerpMs,
1068 freeFlight: !!event.freeFlight
1069 });
1070 }
1071 }
1072 else if (seesFrom)
1073 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1074 if (session.entityId === event.entityId)
1075 { syncSubscriptions(session, false); }
1076 }
1077 }
1078
1079 function spawnPayload (event)
1080 {
1081 const record = simulation.entityRecord(event.entityId) ?? event;
1082 return {
1083 type: MessageType.entitySpawn,
1084 entityId: event.entityId,
1085 characterId: record.characterId ?? event.characterId ?? null,
1086 tileX: event.tileX ?? record.tileX,
1087 tileY: event.tileY ?? record.tileY,
1088 worldX: event.worldX ?? record.worldX,
1089 worldY: event.worldY ?? record.worldY,
1090 gait: event.gait ?? record.gait,
1091 sex: record.sex ?? event.sex ?? null,
1092 firstName: record.firstName ?? event.firstName ?? "",
1093 lastName: record.lastName ?? event.lastName ?? "",
1094 sprite: record.sprite ?? event.sprite ?? null,
1095 layers: record.layers ?? event.layers ?? [],
1096 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1097 canFight: !!(record.canFight ?? event.canFight),
1098 hostile: !!(record.hostile ?? event.hostile),
1099 talkable: !!(record.talkable ?? event.talkable),
1100 untargetable: !!(record.untargetable ?? event.untargetable),
1101 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1102 health: record.health ?? event.health,
1103 maxHealth: record.maxHealth ?? event.maxHealth,
1104 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1105 };
1106 }
1107
1108 return {
1109 sessions,
1110 onTickResult,
1111 wss,
1112 async shutdown ()
1113 {
1114 await Promise.all([...sessions.values()].map(async (session) =>
1115 {
1116 await sendAsync(session, {
1117 type: MessageType.forceLogout,
1118 reason: "Server shutting down."
1119 });
1120 leaveWorld(session);
1121 await closeAsync(session, 1001, "Server shutting down.");
1122 }));
1123 sessions.clear();
1124 await simulation.shutdown();
1125 }
1126 };
1127}
1128
1129function send (session, payload)
1130{
1131 if (session.socket.readyState === 1)
1132 { session.socket.send(JSON.stringify(payload)); }
1133}
1134
1135function sendAsync (session, payload)
1136{
1137 return new Promise((resolve) =>
1138 {
1139 if (session.socket.readyState !== 1)
1140 {
1141 resolve();
1142 return;
1143 }
1144 session.socket.send(JSON.stringify(payload), () => resolve());
1145 });
1146}
1147
1148function closeAsync (session, code, reason)
1149{
1150 return new Promise((resolve) =>
1151 {
1152 if (session.socket.readyState !== 1)
1153 {
1154 resolve();
1155 return;
1156 }
1157 session.socket.once("close", resolve);
1158 try
1159 { session.socket.close(code, reason); }
1160 catch
1161 { resolve(); }
1162 });
1163}