BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 30.7 KiB Download Raw
1import { WebSocketServer } from "ws";
2import { MessageType, GAIT } from "../../../shared/protocol/constants.js";
3import { chunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js";
4import { VISIBLE_CHUNK_RADIUS } 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 });
407 break;
408 case MessageType.follow:
409 requirePlaying(session);
410 simulation.enqueue(session.id, {
411 type: "follow",
412 characterId: session.characterId,
413 targetEntityId: message.targetEntityId | 0
414 });
415 break;
416 case MessageType.cancelFollow:
417 requirePlaying(session);
418 simulation.enqueue(session.id, {
419 type: "cancel-follow",
420 characterId: session.characterId
421 });
422 break;
423 case MessageType.sendPigeon:
424 requirePlaying(session);
425 {
426 const result = simulation.dispatchPigeon({
427 characterId: session.characterId,
428 destination: message.destination,
429 cargo: message.cargo
430 });
431 send(session, {
432 type: MessageType.pigeonDispatched,
433 courierId: result.transit.courierId,
434 destinationKind: result.transit.destinationKind,
435 destinationCharacterId: result.transit.destinationCharacterId
436 });
437 send(session, { type: MessageType.inventory, ...result.bag });
438 }
439 break;
440 case MessageType.searchCharacter:
441 requirePlaying(session);
442 {
443 const character = friends.findByFullName(message.firstName, message.lastName);
444 send(session, {
445 type: MessageType.characterSearchResult,
446 character: character ?? null
447 });
448 }
449 break;
450 case MessageType.writeLetter:
451 requirePlaying(session);
452 simulation.enqueue(session.id, {
453 type: "write-letter",
454 characterId: session.characterId,
455 slotIndex: message.slotIndex,
456 body: message.body
457 });
458 break;
459 case MessageType.editLetter:
460 requirePlaying(session);
461 simulation.enqueue(session.id, {
462 type: "edit-letter",
463 characterId: session.characterId,
464 slotIndex: message.slotIndex,
465 body: message.body
466 });
467 break;
468 case MessageType.openLetter:
469 requirePlaying(session);
470 simulation.enqueue(session.id, {
471 type: "open-letter",
472 characterId: session.characterId,
473 slotIndex: message.slotIndex
474 });
475 break;
476 case MessageType.editorLoadChunk:
477 requireAdmin(session);
478 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
479 break;
480 case MessageType.editorSaveChunk:
481 requireAdmin(session);
482 send(session, {
483 type: MessageType.editorChunk,
484 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
485 });
486 break;
487 case MessageType.editorLoadSettings:
488 requireAdmin(session);
489 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
490 break;
491 case MessageType.editorSaveSettings:
492 requireAdmin(session);
493 {
494 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
495 simulation.applySettings(saved.settings);
496 broadcastStatus();
497 broadcastSettings(saved);
498 }
499 break;
500 case MessageType.editorApplyRevision:
501 requireAdmin(session);
502 if (!editor.revisionStatus().pendingRevisionId)
503 {
504 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
505 break;
506 }
507 {
508 const appliedRevisionId = editor.applyPendingRevision();
509 simulation.reloadWorld();
510 for (const other of sessions.values())
511 {
512 if (other.entityId)
513 { syncSubscriptions(other, true); }
514 }
515 broadcastStatus();
516 send(session, {
517 type: MessageType.editorRevisionApplied,
518 ...editor.revisionStatus(),
519 appliedRevisionId
520 });
521 }
522 break;
523 default:
524 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
525 }
526 }
527
528 function enterWorld (session, characterId)
529 {
530 leaveWorld(session);
531 const character = characters.getOwned(session.account.account_id, characterId);
532 if (character.deletion_scheduled_at)
533 {
534 const error = new Error("That character is marked for deletion.");
535 error.userFacing = true;
536 throw error;
537 }
538 for (const other of sessions.values())
539 {
540 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
541 {
542 const error = new Error("This account already has a character in the world.");
543 error.userFacing = true;
544 throw error;
545 }
546 }
547 session.characterId = character.character_id;
548 session.entityId = simulation.spawnCharacter(session.id, character);
549 const spawned = simulation.entityRecord(session.entityId);
550 send(session, {
551 type: MessageType.enterWorld,
552 entityId: session.entityId,
553 characterId: session.characterId,
554 tileX: spawned.tileX,
555 tileY: spawned.tileY,
556 gait: spawned.gait,
557 sex: spawned.sex,
558 firstName: spawned.firstName,
559 lastName: spawned.lastName,
560 layers: spawned.layers ?? [],
561 settings: simulation.settings,
562 worldTime: simulation.worldTime()
563 });
564 syncSubscriptions(session, true);
565 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
566 const bag = simulation.bagOf(session.entityId);
567 if (bag)
568 { send(session, { type: MessageType.inventory, ...bag }); }
569 const skills = simulation.skillsOf(session.entityId);
570 if (skills)
571 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
572 const stamina = simulation.staminaOf(session.entityId);
573 if (stamina)
574 {
575 send(session, {
576 type: MessageType.stamina,
577 current: stamina.current,
578 max: stamina.max,
579 gait: stamina.gait
580 });
581 }
582 if (character.is_dead)
583 {
584 send(session, {
585 type: MessageType.playerDied,
586 entityId: session.entityId,
587 characterId: session.characterId
588 });
589 }
590 publishReplication(simulation.drainReplication());
591 }
592
593 function leaveWorld (session)
594 {
595 if (session.characterId)
596 { simulation.despawnCharacter(session.characterId); }
597 publishReplication(simulation.drainReplication());
598 session.characterId = null;
599 session.entityId = null;
600 session.subscribed.clear();
601 }
602
603 function syncSubscriptions (session, forceSnapshots)
604 {
605 if (!session.entityId)
606 { return; }
607 const position = simulation.positionOf(session.entityId);
608 if (!position)
609 { return; }
610
611 const next = new Set(
612 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
613 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
614 );
615 for (const key of session.subscribed)
616 {
617 if (!next.has(key))
618 {
619 const [chunkX, chunkY] = key.split(",").map(Number);
620 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
621 }
622 }
623 const snapshots = simulation.snapshotFor(session.entityId);
624 for (const snapshot of snapshots)
625 {
626 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
627 if (forceSnapshots || !session.subscribed.has(key))
628 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
629 }
630 session.subscribed = next;
631 }
632
633 function requirePlaying (session)
634 {
635 if (!session.characterId)
636 {
637 const error = new Error("Select a character first.");
638 error.userFacing = true;
639 throw error;
640 }
641 }
642
643 function requireAdmin (session)
644 {
645 if (!session.account.is_admin)
646 {
647 const error = new Error("Admin only.");
648 error.userFacing = true;
649 throw error;
650 }
651 }
652
653 function broadcastStatus ()
654 {
655 const worldTime = simulation.worldTime();
656 for (const session of sessions.values())
657 {
658 if (session.entityId)
659 {
660 send(session, {
661 type: MessageType.worldStatus,
662 worldTime,
663 settings: simulation.settings,
664 activeRevisionId: simulation.activeRevisionId
665 });
666 }
667 }
668 }
669
670 function pushFriends (...characterIds)
671 {
672 const seen = new Set();
673 for (const characterId of characterIds)
674 {
675 const id = Number(characterId);
676 if (!id || seen.has(id))
677 { continue; }
678 seen.add(id);
679 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
680 for (const session of sessions.values())
681 {
682 if (session.characterId === id)
683 { send(session, payload); }
684 }
685 }
686 }
687
688 function broadcastSettings (payload)
689 {
690 for (const session of sessions.values())
691 {
692 if (session.account.is_admin)
693 { send(session, { type: MessageType.editorSettings, ...payload }); }
694 }
695 }
696
697 function onTickResult (result)
698 {
699 publishReplication(result.replication ?? []);
700 for (const event of result.events)
701 {
702 if (event.type === "command-error")
703 {
704 const session = sessions.get(event.sessionId);
705 if (session)
706 { send(session, { type: MessageType.error, message: event.message }); }
707 continue;
708 }
709 if (event.type === "inventory")
710 {
711 const session = event.sessionId != null
712 ? sessions.get(event.sessionId)
713 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
714 if (!session)
715 { continue; }
716 send(session, {
717 type: MessageType.inventory,
718 inventory: event.inventory,
719 equipment: event.equipment,
720 vault: event.vault,
721 vaultReserved: event.vaultReserved
722 });
723 if (event.bank)
724 {
725 send(session, {
726 type: MessageType.bankSnapshot,
727 vault: event.vault,
728 vaultReserved: event.vaultReserved,
729 inheritance: stateDb.getInheritance(session.account.account_id)
730 });
731 }
732 if (event.cauldron != null)
733 {
734 send(session, {
735 type: MessageType.cauldronSnapshot,
736 open: !!event.cauldron,
737 state: event.cauldronState ?? null,
738 alchemyResult: event.alchemyResult ?? null
739 });
740 }
741 continue;
742 }
743 if (event.type === "skills")
744 {
745 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
746 if (!session)
747 { continue; }
748 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
749 continue;
750 }
751 if (event.type === "stamina")
752 {
753 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
754 if (!session)
755 { continue; }
756 send(session, {
757 type: MessageType.stamina,
758 current: event.current,
759 max: event.max,
760 gait: event.gait
761 });
762 continue;
763 }
764 if (event.type === "pigeon-delivered")
765 {
766 for (const session of sessions.values())
767 {
768 if (session.characterId === event.senderCharacterId
769 || session.characterId === event.destinationCharacterId)
770 {
771 send(session, {
772 type: MessageType.pigeonDelivered,
773 courierId: event.courierId,
774 destinationKind: event.destinationKind,
775 cargo: event.cargo
776 });
777 }
778 }
779 continue;
780 }
781 if (event.type === "player-died")
782 {
783 const session = sessions.get(event.sessionId);
784 if (session)
785 {
786 send(session, {
787 type: MessageType.playerDied,
788 entityId: event.entityId,
789 characterId: event.characterId
790 });
791 }
792 continue;
793 }
794 if (event.type === "player-respawned")
795 {
796 const session = sessions.get(event.sessionId);
797 if (session)
798 {
799 send(session, {
800 type: MessageType.playerRespawned,
801 entityId: event.entityId,
802 characterId: event.characterId,
803 tileX: event.tileX,
804 tileY: event.tileY,
805 health: event.health,
806 maxHealth: event.maxHealth,
807 stamina: event.stamina,
808 maxStamina: event.maxStamina
809 });
810 }
811 continue;
812 }
813 if (event.type === "craft-result")
814 {
815 const session = sessions.get(event.sessionId);
816 if (session)
817 {
818 send(session, {
819 type: MessageType.craftResult,
820 recipeId: event.recipeId,
821 ok: !!event.ok,
822 error: event.error ?? null,
823 burned: !!event.burned
824 });
825 }
826 continue;
827 }
828 if (event.type === "station-open")
829 {
830 const session = sessions.get(event.sessionId);
831 if (session)
832 {
833 send(session, {
834 type: MessageType.stationOpen,
835 stationId: event.stationId
836 });
837 }
838 continue;
839 }
840 if (event.type === "shop-open")
841 {
842 const session = sessions.get(event.sessionId);
843 if (session)
844 {
845 send(session, {
846 type: MessageType.shopOpen,
847 npcEntityId: event.npcEntityId,
848 displayName: event.displayName,
849 stock: event.stock ?? []
850 });
851 }
852 continue;
853 }
854 if (event.type === "item-bubble")
855 {
856 broadcastItemBubble(
857 sessions,
858 simulation,
859 event.entityId,
860 event.itemId,
861 event.quantity
862 );
863 continue;
864 }
865 if (event.type === "gather-swing" || event.type === "tile-shove")
866 {
867 publishEntity({
868 ...event,
869 type: event.type
870 });
871 continue;
872 }
873 if (event.type === "chunk-delta")
874 {
875 publishEntity(event);
876 continue;
877 }
878 if (event.type === "gather-complete")
879 {
880 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
881 if (session)
882 {
883 send(session, {
884 type: MessageType.gatherComplete,
885 kind: event.kind,
886 materialId: event.materialId,
887 itemId: event.itemId
888 });
889 }
890 continue;
891 }
892 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")
893 { publishEntity(event); }
894 }
895 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
896 { broadcastStatus(); }
897 }
898
899 function publishReplication (events)
900 {
901 for (const event of events ?? [])
902 { publishEntity(event); }
903 }
904
905 function publishEntity (event)
906 {
907 const fromKey = event.fromTileX != null
908 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
909 : null;
910 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
911 for (const session of sessions.values())
912 {
913 if (!session.entityId)
914 { continue; }
915 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
916 const seesTo = session.subscribed.has(toKey);
917 if (event.type === "entity-spawn")
918 {
919 if (session.entityId === event.entityId || !seesTo)
920 { continue; }
921 send(session, spawnPayload(event));
922 continue;
923 }
924 if (event.type === "entity-despawn")
925 {
926 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
927 { continue; }
928 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
929 continue;
930 }
931 if (event.type === "entity-appearance")
932 {
933 if (!seesTo)
934 { continue; }
935 send(session, {
936 type: MessageType.entityAppearance,
937 entityId: event.entityId,
938 sprite: event.sprite,
939 layers: event.layers ?? [],
940 lightRadiusTiles: event.lightRadiusTiles ?? 0
941 });
942 continue;
943 }
944 if (event.type === "ground-item-appear")
945 {
946 if (!seesTo)
947 { continue; }
948 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
949 continue;
950 }
951 if (event.type === "ground-item-despawn")
952 {
953 if (!seesTo)
954 { continue; }
955 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
956 continue;
957 }
958 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
959 {
960 if (!seesTo && !seesFrom)
961 { continue; }
962 const type = event.type === "combat-swing"
963 ? MessageType.combatSwing
964 : event.type === "combat-hit"
965 ? MessageType.combatHit
966 : event.type === "combat-block"
967 ? MessageType.combatBlock
968 : MessageType.combatMiss;
969 send(session, {
970 type,
971 attackerId: event.attackerId,
972 targetId: event.targetId,
973 damage: event.damage,
974 health: event.health,
975 maxHealth: event.maxHealth,
976 tileX: event.tileX,
977 tileY: event.tileY,
978 fromTileX: event.fromTileX,
979 fromTileY: event.fromTileY
980 });
981 continue;
982 }
983 if (event.type === "gather-swing" || event.type === "tile-shove")
984 {
985 if (!seesTo && !seesFrom)
986 { continue; }
987 send(session, {
988 type: MessageType.tileShove,
989 attackerId: event.attackerId,
990 tileX: event.tileX,
991 tileY: event.tileY,
992 fromTileX: event.fromTileX,
993 fromTileY: event.fromTileY
994 });
995 continue;
996 }
997 if (event.type === "chunk-delta")
998 {
999 if (!seesTo)
1000 { continue; }
1001 send(session, {
1002 type: MessageType.chunkDelta,
1003 chunkX: event.chunkX,
1004 chunkY: event.chunkY,
1005 tiles: [{
1006 localX: event.localX,
1007 localY: event.localY,
1008 block: event.block
1009 }]
1010 });
1011 continue;
1012 }
1013 if (event.type !== "entity-move")
1014 { continue; }
1015 if (seesTo)
1016 {
1017 if (!seesFrom)
1018 { send(session, spawnPayload(event)); }
1019 else
1020 {
1021 send(session, {
1022 type: MessageType.entityMove,
1023 entityId: event.entityId,
1024 tileX: event.tileX,
1025 tileY: event.tileY,
1026 worldX: event.worldX,
1027 worldY: event.worldY,
1028 gait: event.gait,
1029 lerpMs: event.lerpMs,
1030 freeFlight: !!event.freeFlight
1031 });
1032 }
1033 }
1034 else if (seesFrom)
1035 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1036 if (session.entityId === event.entityId)
1037 { syncSubscriptions(session, false); }
1038 }
1039 }
1040
1041 function spawnPayload (event)
1042 {
1043 const record = simulation.entityRecord(event.entityId) ?? event;
1044 return {
1045 type: MessageType.entitySpawn,
1046 entityId: event.entityId,
1047 characterId: record.characterId ?? event.characterId ?? null,
1048 tileX: event.tileX ?? record.tileX,
1049 tileY: event.tileY ?? record.tileY,
1050 worldX: event.worldX ?? record.worldX,
1051 worldY: event.worldY ?? record.worldY,
1052 gait: event.gait ?? record.gait,
1053 sex: record.sex ?? event.sex ?? null,
1054 firstName: record.firstName ?? event.firstName ?? "",
1055 lastName: record.lastName ?? event.lastName ?? "",
1056 sprite: record.sprite ?? event.sprite ?? null,
1057 layers: record.layers ?? event.layers ?? [],
1058 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1059 canFight: !!(record.canFight ?? event.canFight),
1060 hostile: !!(record.hostile ?? event.hostile),
1061 talkable: !!(record.talkable ?? event.talkable),
1062 untargetable: !!(record.untargetable ?? event.untargetable),
1063 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1064 health: record.health ?? event.health,
1065 maxHealth: record.maxHealth ?? event.maxHealth,
1066 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1067 };
1068 }
1069
1070 return {
1071 sessions,
1072 onTickResult,
1073 wss,
1074 async shutdown ()
1075 {
1076 await Promise.all([...sessions.values()].map(async (session) =>
1077 {
1078 await sendAsync(session, {
1079 type: MessageType.forceLogout,
1080 reason: "Server shutting down."
1081 });
1082 leaveWorld(session);
1083 await closeAsync(session, 1001, "Server shutting down.");
1084 }));
1085 sessions.clear();
1086 await simulation.shutdown();
1087 }
1088 };
1089}
1090
1091function send (session, payload)
1092{
1093 if (session.socket.readyState === 1)
1094 { session.socket.send(JSON.stringify(payload)); }
1095}
1096
1097function sendAsync (session, payload)
1098{
1099 return new Promise((resolve) =>
1100 {
1101 if (session.socket.readyState !== 1)
1102 {
1103 resolve();
1104 return;
1105 }
1106 session.socket.send(JSON.stringify(payload), () => resolve());
1107 });
1108}
1109
1110function closeAsync (session, code, reason)
1111{
1112 return new Promise((resolve) =>
1113 {
1114 if (session.socket.readyState !== 1)
1115 {
1116 resolve();
1117 return;
1118 }
1119 session.socket.once("close", resolve);
1120 try
1121 { session.socket.close(code, reason); }
1122 catch
1123 { resolve(); }
1124 });
1125}