BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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