BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 26.0 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 } from "../chat/speech.js";
6import { publicSkillsView } from "../../../shared/skills/state.js";
7
8let nextSessionId = 1;
9
10export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation })
11{
12 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
13 const sessions = new Map();
14
15 wss.on("connection", (socket) =>
16 {
17 const identity = auth.claimIdentity();
18 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
19 const session = {
20 id: nextSessionId++,
21 socket,
22 account,
23 authSubject: identity.authSubject,
24 characterId: null,
25 entityId: null,
26 subscribed: new Set()
27 };
28 auth.register(session);
29 sessions.set(session.id, session);
30 send(session, {
31 type: MessageType.session,
32 accountId: account.account_id,
33 authSubject: account.auth_subject,
34 isAdmin: !!account.is_admin,
35 characters: characters.list(account.account_id)
36 });
37
38 socket.on("message", (raw) =>
39 {
40 let message;
41 try
42 { message = JSON.parse(String(raw)); }
43 catch
44 {
45 send(session, { type: MessageType.error, message: "Invalid JSON." });
46 return;
47 }
48 try
49 { handleMessage(session, message); }
50 catch (error)
51 {
52 send(session, {
53 type: MessageType.error,
54 message: error.userFacing ? error.message : "Request failed."
55 });
56 }
57 });
58
59 socket.on("close", () =>
60 {
61 leaveWorld(session);
62 auth.release(session);
63 sessions.delete(session.id);
64 });
65 });
66
67 function handleMessage (session, message)
68 {
69 if (session.characterId
70 && stateDb.getCharacter(session.characterId)?.is_dead
71 && message.type !== MessageType.respawn
72 && message.type !== MessageType.leaveWorld)
73 {
74 const error = new Error("You are dead.");
75 error.userFacing = true;
76 throw error;
77 }
78 switch (message.type)
79 {
80 case MessageType.createCharacter:
81 characters.create(session.account, message.firstName, message.lastName, message.sex);
82 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
83 break;
84 case MessageType.selectCharacter:
85 enterWorld(session, message.characterId);
86 break;
87 case MessageType.scheduleDeleteCharacter:
88 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
89 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
90 break;
91 case MessageType.cancelDeleteCharacter:
92 characters.cancelDelete(session.account, message.characterId);
93 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
94 break;
95 case MessageType.leaveWorld:
96 leaveWorld(session);
97 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
98 break;
99 case MessageType.respawn:
100 requirePlaying(session);
101 simulation.enqueue(session.id, {
102 type: "respawn",
103 characterId: session.characterId
104 });
105 break;
106 case MessageType.moveTo:
107 requirePlaying(session);
108 simulation.enqueue(session.id, {
109 type: "move-to",
110 characterId: session.characterId,
111 tileX: message.tileX | 0,
112 tileY: message.tileY | 0
113 });
114 break;
115 case MessageType.setGait:
116 requirePlaying(session);
117 simulation.enqueue(session.id, {
118 type: "set-gait",
119 characterId: session.characterId,
120 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
121 });
122 break;
123 case MessageType.friendRequest:
124 requirePlaying(session);
125 friends.request(session.characterId, message.characterId);
126 pushFriends(session.characterId, message.characterId);
127 break;
128 case MessageType.friendAccept:
129 requirePlaying(session);
130 friends.accept(session.characterId, message.characterId);
131 pushFriends(session.characterId, message.characterId);
132 break;
133 case MessageType.friendDecline:
134 requirePlaying(session);
135 friends.decline(session.characterId, message.characterId);
136 pushFriends(session.characterId, message.characterId);
137 break;
138 case MessageType.friendRemove:
139 requirePlaying(session);
140 friends.remove(session.characterId, message.characterId);
141 pushFriends(session.characterId, message.characterId);
142 break;
143 case MessageType.chatSay:
144 requirePlaying(session);
145 broadcastSpeech(sessions, simulation, session, message.text);
146 break;
147 case MessageType.dropItem:
148 requirePlaying(session);
149 simulation.enqueue(session.id, {
150 type: "drop-item",
151 characterId: session.characterId,
152 slotIndex: message.slotIndex | 0,
153 quantity: message.quantity ?? null
154 });
155 break;
156 case MessageType.pickupItem:
157 requirePlaying(session);
158 simulation.enqueue(session.id, {
159 type: "pickup-item",
160 characterId: session.characterId,
161 groundItemId: message.groundItemId | 0
162 });
163 break;
164 case MessageType.equipItem:
165 requirePlaying(session);
166 simulation.enqueue(session.id, {
167 type: "equip-item",
168 characterId: session.characterId,
169 slotIndex: message.slotIndex | 0
170 });
171 break;
172 case MessageType.unequipItem:
173 requirePlaying(session);
174 simulation.enqueue(session.id, {
175 type: "unequip-item",
176 characterId: session.characterId,
177 equipSlot: message.equipSlot
178 });
179 break;
180 case MessageType.eatItem:
181 requirePlaying(session);
182 simulation.enqueue(session.id, {
183 type: "eat-item",
184 characterId: session.characterId,
185 slotIndex: message.slotIndex | 0
186 });
187 break;
188 case MessageType.openBank:
189 requirePlaying(session);
190 simulation.enqueue(session.id, {
191 type: "open-bank",
192 characterId: session.characterId
193 });
194 break;
195 case MessageType.openCauldron:
196 requirePlaying(session);
197 simulation.enqueue(session.id, {
198 type: "open-cauldron",
199 characterId: session.characterId
200 });
201 break;
202 case MessageType.cauldronSetSlot:
203 requirePlaying(session);
204 simulation.enqueue(session.id, {
205 type: "cauldron-set-slot",
206 characterId: session.characterId,
207 slotIndex: message.slotIndex | 0,
208 itemId: message.itemId | 0,
209 quantity: message.quantity | 0
210 });
211 break;
212 case MessageType.cauldronInsert:
213 requirePlaying(session);
214 simulation.enqueue(session.id, {
215 type: "cauldron-insert",
216 characterId: session.characterId,
217 slotIndex: message.slotIndex | 0
218 });
219 break;
220 case MessageType.cauldronAction:
221 requirePlaying(session);
222 simulation.enqueue(session.id, {
223 type: "cauldron-action",
224 characterId: session.characterId,
225 action: message.action
226 });
227 break;
228 case MessageType.cauldronBottle:
229 requirePlaying(session);
230 simulation.enqueue(session.id, {
231 type: "cauldron-bottle",
232 characterId: session.characterId
233 });
234 break;
235 case MessageType.cauldronClear:
236 requirePlaying(session);
237 simulation.enqueue(session.id, {
238 type: "cauldron-clear",
239 characterId: session.characterId
240 });
241 break;
242 case MessageType.cauldronSaveRecipe:
243 requirePlaying(session);
244 simulation.enqueue(session.id, {
245 type: "cauldron-save-recipe",
246 characterId: session.characterId
247 });
248 break;
249 case MessageType.cauldronClose:
250 requirePlaying(session);
251 simulation.enqueue(session.id, {
252 type: "cauldron-close",
253 characterId: session.characterId
254 });
255 break;
256 case MessageType.bankDeposit:
257 requirePlaying(session);
258 simulation.enqueue(session.id, {
259 type: "bank-deposit",
260 characterId: session.characterId,
261 slotIndex: message.slotIndex | 0,
262 quantity: message.quantity ?? null
263 });
264 break;
265 case MessageType.bankWithdraw:
266 requirePlaying(session);
267 simulation.enqueue(session.id, {
268 type: "bank-withdraw",
269 characterId: session.characterId,
270 slotIndex: message.slotIndex | 0,
271 quantity: message.quantity ?? null
272 });
273 break;
274 case MessageType.getBlankCheques:
275 requirePlaying(session);
276 simulation.enqueue(session.id, {
277 type: "get-blank-cheques",
278 characterId: session.characterId
279 });
280 break;
281 case MessageType.returnBlankCheques:
282 requirePlaying(session);
283 simulation.enqueue(session.id, {
284 type: "return-blank-cheques",
285 characterId: session.characterId,
286 slotIndex: message.slotIndex | 0,
287 quantity: message.quantity ?? null
288 });
289 break;
290 case MessageType.writeCheque:
291 requirePlaying(session);
292 simulation.enqueue(session.id, {
293 type: "write-cheque",
294 characterId: session.characterId,
295 slotIndex: message.slotIndex | 0,
296 vaultSlotIndex: message.vaultSlotIndex | 0,
297 quantity: message.quantity ?? 1
298 });
299 break;
300 case MessageType.redeemCheque:
301 requirePlaying(session);
302 simulation.enqueue(session.id, {
303 type: "redeem-cheque",
304 characterId: session.characterId,
305 slotIndex: message.slotIndex | 0
306 });
307 break;
308 case MessageType.claimInheritance:
309 requirePlaying(session);
310 {
311 const inheritance = stateDb.getInheritance(session.account.account_id);
312 simulation.enqueue(session.id, {
313 type: "claim-inheritance",
314 characterId: session.characterId,
315 stacks: (inheritance.slots ?? []).filter(Boolean)
316 });
317 }
318 break;
319 case MessageType.attack:
320 requirePlaying(session);
321 simulation.enqueue(session.id, {
322 type: "attack",
323 characterId: session.characterId,
324 targetEntityId: message.targetEntityId | 0
325 });
326 break;
327 case MessageType.cancelAttack:
328 requirePlaying(session);
329 simulation.enqueue(session.id, {
330 type: "cancel-attack",
331 characterId: session.characterId
332 });
333 break;
334 case MessageType.interact:
335 requirePlaying(session);
336 simulation.enqueue(session.id, {
337 type: "interact",
338 characterId: session.characterId,
339 targetEntityId: message.targetEntityId | 0
340 });
341 break;
342 case MessageType.follow:
343 requirePlaying(session);
344 simulation.enqueue(session.id, {
345 type: "follow",
346 characterId: session.characterId,
347 targetEntityId: message.targetEntityId | 0
348 });
349 break;
350 case MessageType.cancelFollow:
351 requirePlaying(session);
352 simulation.enqueue(session.id, {
353 type: "cancel-follow",
354 characterId: session.characterId
355 });
356 break;
357 case MessageType.sendPigeon:
358 requirePlaying(session);
359 {
360 const result = simulation.dispatchPigeon({
361 characterId: session.characterId,
362 destination: message.destination,
363 cargo: message.cargo
364 });
365 send(session, {
366 type: MessageType.pigeonDispatched,
367 courierId: result.transit.courierId,
368 destinationKind: result.transit.destinationKind,
369 destinationCharacterId: result.transit.destinationCharacterId
370 });
371 send(session, { type: MessageType.inventory, ...result.bag });
372 }
373 break;
374 case MessageType.searchCharacter:
375 requirePlaying(session);
376 {
377 const character = friends.findByFullName(message.firstName, message.lastName);
378 send(session, {
379 type: MessageType.characterSearchResult,
380 character: character ?? null
381 });
382 }
383 break;
384 case MessageType.writeLetter:
385 requirePlaying(session);
386 simulation.enqueue(session.id, {
387 type: "write-letter",
388 characterId: session.characterId,
389 slotIndex: message.slotIndex,
390 body: message.body
391 });
392 break;
393 case MessageType.editLetter:
394 requirePlaying(session);
395 simulation.enqueue(session.id, {
396 type: "edit-letter",
397 characterId: session.characterId,
398 slotIndex: message.slotIndex,
399 body: message.body
400 });
401 break;
402 case MessageType.openLetter:
403 requirePlaying(session);
404 simulation.enqueue(session.id, {
405 type: "open-letter",
406 characterId: session.characterId,
407 slotIndex: message.slotIndex
408 });
409 break;
410 case MessageType.editorLoadChunk:
411 requireAdmin(session);
412 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
413 break;
414 case MessageType.editorSaveChunk:
415 requireAdmin(session);
416 send(session, {
417 type: MessageType.editorChunk,
418 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
419 });
420 break;
421 case MessageType.editorLoadSettings:
422 requireAdmin(session);
423 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
424 break;
425 case MessageType.editorSaveSettings:
426 requireAdmin(session);
427 {
428 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
429 simulation.applySettings(saved.settings);
430 broadcastStatus();
431 broadcastSettings(saved);
432 }
433 break;
434 case MessageType.editorApplyRevision:
435 requireAdmin(session);
436 if (!editor.revisionStatus().pendingRevisionId)
437 {
438 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
439 break;
440 }
441 {
442 const appliedRevisionId = editor.applyPendingRevision();
443 simulation.reloadWorld();
444 for (const other of sessions.values())
445 {
446 if (other.entityId)
447 { syncSubscriptions(other, true); }
448 }
449 broadcastStatus();
450 send(session, {
451 type: MessageType.editorRevisionApplied,
452 ...editor.revisionStatus(),
453 appliedRevisionId
454 });
455 }
456 break;
457 default:
458 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
459 }
460 }
461
462 function enterWorld (session, characterId)
463 {
464 leaveWorld(session);
465 const character = characters.getOwned(session.account.account_id, characterId);
466 if (character.deletion_scheduled_at)
467 {
468 const error = new Error("That character is marked for deletion.");
469 error.userFacing = true;
470 throw error;
471 }
472 for (const other of sessions.values())
473 {
474 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
475 {
476 const error = new Error("This account already has a character in the world.");
477 error.userFacing = true;
478 throw error;
479 }
480 }
481 session.characterId = character.character_id;
482 session.entityId = simulation.spawnCharacter(session.id, character);
483 const spawned = simulation.entityRecord(session.entityId);
484 send(session, {
485 type: MessageType.enterWorld,
486 entityId: session.entityId,
487 characterId: session.characterId,
488 tileX: spawned.tileX,
489 tileY: spawned.tileY,
490 gait: spawned.gait,
491 sex: spawned.sex,
492 firstName: spawned.firstName,
493 lastName: spawned.lastName,
494 layers: spawned.layers ?? [],
495 settings: simulation.settings,
496 worldTime: simulation.worldTime()
497 });
498 syncSubscriptions(session, true);
499 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
500 const bag = simulation.bagOf(session.entityId);
501 if (bag)
502 { send(session, { type: MessageType.inventory, ...bag }); }
503 const skills = simulation.skillsOf(session.entityId);
504 if (skills)
505 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
506 if (character.is_dead)
507 {
508 send(session, {
509 type: MessageType.playerDied,
510 entityId: session.entityId,
511 characterId: session.characterId
512 });
513 }
514 publishReplication(simulation.drainReplication());
515 }
516
517 function leaveWorld (session)
518 {
519 if (session.characterId)
520 { simulation.despawnCharacter(session.characterId); }
521 publishReplication(simulation.drainReplication());
522 session.characterId = null;
523 session.entityId = null;
524 session.subscribed.clear();
525 }
526
527 function syncSubscriptions (session, forceSnapshots)
528 {
529 if (!session.entityId)
530 { return; }
531 const position = simulation.positionOf(session.entityId);
532 if (!position)
533 { return; }
534
535 const next = new Set(
536 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
537 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
538 );
539 for (const key of session.subscribed)
540 {
541 if (!next.has(key))
542 {
543 const [chunkX, chunkY] = key.split(",").map(Number);
544 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
545 }
546 }
547 const snapshots = simulation.snapshotFor(session.entityId);
548 for (const snapshot of snapshots)
549 {
550 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
551 if (forceSnapshots || !session.subscribed.has(key))
552 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
553 }
554 session.subscribed = next;
555 }
556
557 function requirePlaying (session)
558 {
559 if (!session.characterId)
560 {
561 const error = new Error("Select a character first.");
562 error.userFacing = true;
563 throw error;
564 }
565 }
566
567 function requireAdmin (session)
568 {
569 if (!session.account.is_admin)
570 {
571 const error = new Error("Admin only.");
572 error.userFacing = true;
573 throw error;
574 }
575 }
576
577 function broadcastStatus ()
578 {
579 const worldTime = simulation.worldTime();
580 for (const session of sessions.values())
581 {
582 if (session.entityId)
583 {
584 send(session, {
585 type: MessageType.worldStatus,
586 worldTime,
587 settings: simulation.settings,
588 activeRevisionId: simulation.activeRevisionId
589 });
590 }
591 }
592 }
593
594 function pushFriends (...characterIds)
595 {
596 const seen = new Set();
597 for (const characterId of characterIds)
598 {
599 const id = Number(characterId);
600 if (!id || seen.has(id))
601 { continue; }
602 seen.add(id);
603 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
604 for (const session of sessions.values())
605 {
606 if (session.characterId === id)
607 { send(session, payload); }
608 }
609 }
610 }
611
612 function broadcastSettings (payload)
613 {
614 for (const session of sessions.values())
615 {
616 if (session.account.is_admin)
617 { send(session, { type: MessageType.editorSettings, ...payload }); }
618 }
619 }
620
621 function onTickResult (result)
622 {
623 publishReplication(result.replication ?? []);
624 for (const event of result.events)
625 {
626 if (event.type === "command-error")
627 {
628 const session = sessions.get(event.sessionId);
629 if (session)
630 { send(session, { type: MessageType.error, message: event.message }); }
631 continue;
632 }
633 if (event.type === "inventory")
634 {
635 const session = event.sessionId != null
636 ? sessions.get(event.sessionId)
637 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
638 if (!session)
639 { continue; }
640 send(session, {
641 type: MessageType.inventory,
642 inventory: event.inventory,
643 equipment: event.equipment,
644 vault: event.vault,
645 vaultReserved: event.vaultReserved
646 });
647 if (event.bank)
648 {
649 send(session, {
650 type: MessageType.bankSnapshot,
651 vault: event.vault,
652 vaultReserved: event.vaultReserved,
653 inheritance: stateDb.getInheritance(session.account.account_id)
654 });
655 }
656 if (event.cauldron != null)
657 {
658 send(session, {
659 type: MessageType.cauldronSnapshot,
660 open: !!event.cauldron,
661 state: event.cauldronState ?? null,
662 alchemyResult: event.alchemyResult ?? null
663 });
664 }
665 continue;
666 }
667 if (event.type === "skills")
668 {
669 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
670 if (!session)
671 { continue; }
672 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
673 continue;
674 }
675 if (event.type === "pigeon-delivered")
676 {
677 for (const session of sessions.values())
678 {
679 if (session.characterId === event.senderCharacterId
680 || session.characterId === event.destinationCharacterId)
681 {
682 send(session, {
683 type: MessageType.pigeonDelivered,
684 courierId: event.courierId,
685 destinationKind: event.destinationKind,
686 cargo: event.cargo
687 });
688 }
689 }
690 continue;
691 }
692 if (event.type === "player-died")
693 {
694 const session = sessions.get(event.sessionId);
695 if (session)
696 {
697 send(session, {
698 type: MessageType.playerDied,
699 entityId: event.entityId,
700 characterId: event.characterId
701 });
702 }
703 continue;
704 }
705 if (event.type === "player-respawned")
706 {
707 const session = sessions.get(event.sessionId);
708 if (session)
709 {
710 send(session, {
711 type: MessageType.playerRespawned,
712 entityId: event.entityId,
713 characterId: event.characterId,
714 tileX: event.tileX,
715 tileY: event.tileY,
716 health: event.health,
717 maxHealth: event.maxHealth,
718 stamina: event.stamina,
719 maxStamina: event.maxStamina
720 });
721 }
722 continue;
723 }
724 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")
725 { publishEntity(event); }
726 }
727 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
728 { broadcastStatus(); }
729 }
730
731 function publishReplication (events)
732 {
733 for (const event of events ?? [])
734 { publishEntity(event); }
735 }
736
737 function publishEntity (event)
738 {
739 const fromKey = event.fromTileX != null
740 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
741 : null;
742 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
743 for (const session of sessions.values())
744 {
745 if (!session.entityId)
746 { continue; }
747 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
748 const seesTo = session.subscribed.has(toKey);
749 if (event.type === "entity-spawn")
750 {
751 if (session.entityId === event.entityId || !seesTo)
752 { continue; }
753 send(session, spawnPayload(event));
754 continue;
755 }
756 if (event.type === "entity-despawn")
757 {
758 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
759 { continue; }
760 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
761 continue;
762 }
763 if (event.type === "entity-appearance")
764 {
765 if (!seesTo)
766 { continue; }
767 send(session, {
768 type: MessageType.entityAppearance,
769 entityId: event.entityId,
770 sprite: event.sprite,
771 layers: event.layers ?? [],
772 lightRadiusTiles: event.lightRadiusTiles ?? 0
773 });
774 continue;
775 }
776 if (event.type === "ground-item-appear")
777 {
778 if (!seesTo)
779 { continue; }
780 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
781 continue;
782 }
783 if (event.type === "ground-item-despawn")
784 {
785 if (!seesTo)
786 { continue; }
787 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
788 continue;
789 }
790 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
791 {
792 if (!seesTo && !seesFrom)
793 { continue; }
794 const type = event.type === "combat-swing"
795 ? MessageType.combatSwing
796 : event.type === "combat-hit"
797 ? MessageType.combatHit
798 : event.type === "combat-block"
799 ? MessageType.combatBlock
800 : MessageType.combatMiss;
801 send(session, {
802 type,
803 attackerId: event.attackerId,
804 targetId: event.targetId,
805 damage: event.damage,
806 health: event.health,
807 maxHealth: event.maxHealth,
808 tileX: event.tileX,
809 tileY: event.tileY,
810 fromTileX: event.fromTileX,
811 fromTileY: event.fromTileY
812 });
813 continue;
814 }
815 if (event.type !== "entity-move")
816 { continue; }
817 if (seesTo)
818 {
819 if (!seesFrom)
820 { send(session, spawnPayload(event)); }
821 else
822 {
823 send(session, {
824 type: MessageType.entityMove,
825 entityId: event.entityId,
826 tileX: event.tileX,
827 tileY: event.tileY,
828 worldX: event.worldX,
829 worldY: event.worldY,
830 gait: event.gait,
831 lerpMs: event.lerpMs,
832 freeFlight: !!event.freeFlight
833 });
834 }
835 }
836 else if (seesFrom)
837 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
838 if (session.entityId === event.entityId)
839 { syncSubscriptions(session, false); }
840 }
841 }
842
843 function spawnPayload (event)
844 {
845 const record = simulation.entityRecord(event.entityId) ?? event;
846 return {
847 type: MessageType.entitySpawn,
848 entityId: event.entityId,
849 characterId: record.characterId ?? event.characterId ?? null,
850 tileX: event.tileX ?? record.tileX,
851 tileY: event.tileY ?? record.tileY,
852 worldX: event.worldX ?? record.worldX,
853 worldY: event.worldY ?? record.worldY,
854 gait: event.gait ?? record.gait,
855 sex: record.sex ?? event.sex ?? null,
856 firstName: record.firstName ?? event.firstName ?? "",
857 lastName: record.lastName ?? event.lastName ?? "",
858 sprite: record.sprite ?? event.sprite ?? null,
859 layers: record.layers ?? event.layers ?? [],
860 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
861 canFight: !!(record.canFight ?? event.canFight),
862 hostile: !!(record.hostile ?? event.hostile),
863 talkable: !!(record.talkable ?? event.talkable),
864 untargetable: !!(record.untargetable ?? event.untargetable),
865 freeFlight: !!(record.freeFlight ?? event.freeFlight),
866 health: record.health ?? event.health,
867 maxHealth: record.maxHealth ?? event.maxHealth,
868 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
869 };
870 }
871
872 return {
873 sessions,
874 onTickResult,
875 wss,
876 async shutdown ()
877 {
878 await Promise.all([...sessions.values()].map(async (session) =>
879 {
880 await sendAsync(session, {
881 type: MessageType.forceLogout,
882 reason: "Server shutting down."
883 });
884 leaveWorld(session);
885 await closeAsync(session, 1001, "Server shutting down.");
886 }));
887 sessions.clear();
888 await simulation.shutdown();
889 }
890 };
891}
892
893function send (session, payload)
894{
895 if (session.socket.readyState === 1)
896 { session.socket.send(JSON.stringify(payload)); }
897}
898
899function sendAsync (session, payload)
900{
901 return new Promise((resolve) =>
902 {
903 if (session.socket.readyState !== 1)
904 {
905 resolve();
906 return;
907 }
908 session.socket.send(JSON.stringify(payload), () => resolve());
909 });
910}
911
912function closeAsync (session, code, reason)
913{
914 return new Promise((resolve) =>
915 {
916 if (session.socket.readyState !== 1)
917 {
918 resolve();
919 return;
920 }
921 session.socket.once("close", resolve);
922 try
923 { session.socket.close(code, reason); }
924 catch
925 { resolve(); }
926 });
927}