BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 24.1 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.bankDeposit:
196 requirePlaying(session);
197 simulation.enqueue(session.id, {
198 type: "bank-deposit",
199 characterId: session.characterId,
200 slotIndex: message.slotIndex | 0,
201 quantity: message.quantity ?? null
202 });
203 break;
204 case MessageType.bankWithdraw:
205 requirePlaying(session);
206 simulation.enqueue(session.id, {
207 type: "bank-withdraw",
208 characterId: session.characterId,
209 slotIndex: message.slotIndex | 0,
210 quantity: message.quantity ?? null
211 });
212 break;
213 case MessageType.getBlankCheques:
214 requirePlaying(session);
215 simulation.enqueue(session.id, {
216 type: "get-blank-cheques",
217 characterId: session.characterId
218 });
219 break;
220 case MessageType.returnBlankCheques:
221 requirePlaying(session);
222 simulation.enqueue(session.id, {
223 type: "return-blank-cheques",
224 characterId: session.characterId,
225 slotIndex: message.slotIndex | 0,
226 quantity: message.quantity ?? null
227 });
228 break;
229 case MessageType.writeCheque:
230 requirePlaying(session);
231 simulation.enqueue(session.id, {
232 type: "write-cheque",
233 characterId: session.characterId,
234 slotIndex: message.slotIndex | 0,
235 vaultSlotIndex: message.vaultSlotIndex | 0,
236 quantity: message.quantity ?? 1
237 });
238 break;
239 case MessageType.redeemCheque:
240 requirePlaying(session);
241 simulation.enqueue(session.id, {
242 type: "redeem-cheque",
243 characterId: session.characterId,
244 slotIndex: message.slotIndex | 0
245 });
246 break;
247 case MessageType.claimInheritance:
248 requirePlaying(session);
249 {
250 const inheritance = stateDb.getInheritance(session.account.account_id);
251 simulation.enqueue(session.id, {
252 type: "claim-inheritance",
253 characterId: session.characterId,
254 stacks: (inheritance.slots ?? []).filter(Boolean)
255 });
256 }
257 break;
258 case MessageType.attack:
259 requirePlaying(session);
260 simulation.enqueue(session.id, {
261 type: "attack",
262 characterId: session.characterId,
263 targetEntityId: message.targetEntityId | 0
264 });
265 break;
266 case MessageType.cancelAttack:
267 requirePlaying(session);
268 simulation.enqueue(session.id, {
269 type: "cancel-attack",
270 characterId: session.characterId
271 });
272 break;
273 case MessageType.interact:
274 requirePlaying(session);
275 simulation.enqueue(session.id, {
276 type: "interact",
277 characterId: session.characterId,
278 targetEntityId: message.targetEntityId | 0
279 });
280 break;
281 case MessageType.follow:
282 requirePlaying(session);
283 simulation.enqueue(session.id, {
284 type: "follow",
285 characterId: session.characterId,
286 targetEntityId: message.targetEntityId | 0
287 });
288 break;
289 case MessageType.cancelFollow:
290 requirePlaying(session);
291 simulation.enqueue(session.id, {
292 type: "cancel-follow",
293 characterId: session.characterId
294 });
295 break;
296 case MessageType.sendPigeon:
297 requirePlaying(session);
298 {
299 const result = simulation.dispatchPigeon({
300 characterId: session.characterId,
301 destination: message.destination,
302 cargo: message.cargo
303 });
304 send(session, {
305 type: MessageType.pigeonDispatched,
306 courierId: result.transit.courierId,
307 destinationKind: result.transit.destinationKind,
308 destinationCharacterId: result.transit.destinationCharacterId
309 });
310 send(session, { type: MessageType.inventory, ...result.bag });
311 }
312 break;
313 case MessageType.searchCharacter:
314 requirePlaying(session);
315 {
316 const character = friends.findByFullName(message.firstName, message.lastName);
317 send(session, {
318 type: MessageType.characterSearchResult,
319 character: character ?? null
320 });
321 }
322 break;
323 case MessageType.writeLetter:
324 requirePlaying(session);
325 simulation.enqueue(session.id, {
326 type: "write-letter",
327 characterId: session.characterId,
328 slotIndex: message.slotIndex,
329 body: message.body
330 });
331 break;
332 case MessageType.editLetter:
333 requirePlaying(session);
334 simulation.enqueue(session.id, {
335 type: "edit-letter",
336 characterId: session.characterId,
337 slotIndex: message.slotIndex,
338 body: message.body
339 });
340 break;
341 case MessageType.openLetter:
342 requirePlaying(session);
343 simulation.enqueue(session.id, {
344 type: "open-letter",
345 characterId: session.characterId,
346 slotIndex: message.slotIndex
347 });
348 break;
349 case MessageType.editorLoadChunk:
350 requireAdmin(session);
351 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
352 break;
353 case MessageType.editorSaveChunk:
354 requireAdmin(session);
355 send(session, {
356 type: MessageType.editorChunk,
357 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
358 });
359 break;
360 case MessageType.editorLoadSettings:
361 requireAdmin(session);
362 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
363 break;
364 case MessageType.editorSaveSettings:
365 requireAdmin(session);
366 {
367 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
368 simulation.applySettings(saved.settings);
369 broadcastStatus();
370 broadcastSettings(saved);
371 }
372 break;
373 case MessageType.editorApplyRevision:
374 requireAdmin(session);
375 if (!editor.revisionStatus().pendingRevisionId)
376 {
377 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
378 break;
379 }
380 {
381 const appliedRevisionId = editor.applyPendingRevision();
382 simulation.reloadWorld();
383 for (const other of sessions.values())
384 {
385 if (other.entityId)
386 { syncSubscriptions(other, true); }
387 }
388 broadcastStatus();
389 send(session, {
390 type: MessageType.editorRevisionApplied,
391 ...editor.revisionStatus(),
392 appliedRevisionId
393 });
394 }
395 break;
396 default:
397 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
398 }
399 }
400
401 function enterWorld (session, characterId)
402 {
403 leaveWorld(session);
404 const character = characters.getOwned(session.account.account_id, characterId);
405 if (character.deletion_scheduled_at)
406 {
407 const error = new Error("That character is marked for deletion.");
408 error.userFacing = true;
409 throw error;
410 }
411 for (const other of sessions.values())
412 {
413 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
414 {
415 const error = new Error("This account already has a character in the world.");
416 error.userFacing = true;
417 throw error;
418 }
419 }
420 session.characterId = character.character_id;
421 session.entityId = simulation.spawnCharacter(session.id, character);
422 const spawned = simulation.entityRecord(session.entityId);
423 send(session, {
424 type: MessageType.enterWorld,
425 entityId: session.entityId,
426 characterId: session.characterId,
427 tileX: spawned.tileX,
428 tileY: spawned.tileY,
429 gait: spawned.gait,
430 sex: spawned.sex,
431 firstName: spawned.firstName,
432 lastName: spawned.lastName,
433 layers: spawned.layers ?? [],
434 settings: simulation.settings,
435 worldTime: simulation.worldTime()
436 });
437 syncSubscriptions(session, true);
438 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
439 const bag = simulation.bagOf(session.entityId);
440 if (bag)
441 { send(session, { type: MessageType.inventory, ...bag }); }
442 const skills = simulation.skillsOf(session.entityId);
443 if (skills)
444 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
445 if (character.is_dead)
446 {
447 send(session, {
448 type: MessageType.playerDied,
449 entityId: session.entityId,
450 characterId: session.characterId
451 });
452 }
453 publishReplication(simulation.drainReplication());
454 }
455
456 function leaveWorld (session)
457 {
458 if (session.characterId)
459 { simulation.despawnCharacter(session.characterId); }
460 publishReplication(simulation.drainReplication());
461 session.characterId = null;
462 session.entityId = null;
463 session.subscribed.clear();
464 }
465
466 function syncSubscriptions (session, forceSnapshots)
467 {
468 if (!session.entityId)
469 { return; }
470 const position = simulation.positionOf(session.entityId);
471 if (!position)
472 { return; }
473
474 const next = new Set(
475 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
476 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
477 );
478 for (const key of session.subscribed)
479 {
480 if (!next.has(key))
481 {
482 const [chunkX, chunkY] = key.split(",").map(Number);
483 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
484 }
485 }
486 const snapshots = simulation.snapshotFor(session.entityId);
487 for (const snapshot of snapshots)
488 {
489 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
490 if (forceSnapshots || !session.subscribed.has(key))
491 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
492 }
493 session.subscribed = next;
494 }
495
496 function requirePlaying (session)
497 {
498 if (!session.characterId)
499 {
500 const error = new Error("Select a character first.");
501 error.userFacing = true;
502 throw error;
503 }
504 }
505
506 function requireAdmin (session)
507 {
508 if (!session.account.is_admin)
509 {
510 const error = new Error("Admin only.");
511 error.userFacing = true;
512 throw error;
513 }
514 }
515
516 function broadcastStatus ()
517 {
518 const worldTime = simulation.worldTime();
519 for (const session of sessions.values())
520 {
521 if (session.entityId)
522 {
523 send(session, {
524 type: MessageType.worldStatus,
525 worldTime,
526 settings: simulation.settings,
527 activeRevisionId: simulation.activeRevisionId
528 });
529 }
530 }
531 }
532
533 function pushFriends (...characterIds)
534 {
535 const seen = new Set();
536 for (const characterId of characterIds)
537 {
538 const id = Number(characterId);
539 if (!id || seen.has(id))
540 { continue; }
541 seen.add(id);
542 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
543 for (const session of sessions.values())
544 {
545 if (session.characterId === id)
546 { send(session, payload); }
547 }
548 }
549 }
550
551 function broadcastSettings (payload)
552 {
553 for (const session of sessions.values())
554 {
555 if (session.account.is_admin)
556 { send(session, { type: MessageType.editorSettings, ...payload }); }
557 }
558 }
559
560 function onTickResult (result)
561 {
562 publishReplication(result.replication ?? []);
563 for (const event of result.events)
564 {
565 if (event.type === "command-error")
566 {
567 const session = sessions.get(event.sessionId);
568 if (session)
569 { send(session, { type: MessageType.error, message: event.message }); }
570 continue;
571 }
572 if (event.type === "inventory")
573 {
574 const session = event.sessionId != null
575 ? sessions.get(event.sessionId)
576 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
577 if (!session)
578 { continue; }
579 send(session, {
580 type: MessageType.inventory,
581 inventory: event.inventory,
582 equipment: event.equipment,
583 vault: event.vault,
584 vaultReserved: event.vaultReserved
585 });
586 if (event.bank)
587 {
588 send(session, {
589 type: MessageType.bankSnapshot,
590 vault: event.vault,
591 vaultReserved: event.vaultReserved,
592 inheritance: stateDb.getInheritance(session.account.account_id)
593 });
594 }
595 continue;
596 }
597 if (event.type === "skills")
598 {
599 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
600 if (!session)
601 { continue; }
602 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
603 continue;
604 }
605 if (event.type === "pigeon-delivered")
606 {
607 for (const session of sessions.values())
608 {
609 if (session.characterId === event.senderCharacterId
610 || session.characterId === event.destinationCharacterId)
611 {
612 send(session, {
613 type: MessageType.pigeonDelivered,
614 courierId: event.courierId,
615 destinationKind: event.destinationKind,
616 cargo: event.cargo
617 });
618 }
619 }
620 continue;
621 }
622 if (event.type === "player-died")
623 {
624 const session = sessions.get(event.sessionId);
625 if (session)
626 {
627 send(session, {
628 type: MessageType.playerDied,
629 entityId: event.entityId,
630 characterId: event.characterId
631 });
632 }
633 continue;
634 }
635 if (event.type === "player-respawned")
636 {
637 const session = sessions.get(event.sessionId);
638 if (session)
639 {
640 send(session, {
641 type: MessageType.playerRespawned,
642 entityId: event.entityId,
643 characterId: event.characterId,
644 tileX: event.tileX,
645 tileY: event.tileY,
646 health: event.health,
647 maxHealth: event.maxHealth,
648 stamina: event.stamina,
649 maxStamina: event.maxStamina
650 });
651 }
652 continue;
653 }
654 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")
655 { publishEntity(event); }
656 }
657 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
658 { broadcastStatus(); }
659 }
660
661 function publishReplication (events)
662 {
663 for (const event of events ?? [])
664 { publishEntity(event); }
665 }
666
667 function publishEntity (event)
668 {
669 const fromKey = event.fromTileX != null
670 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
671 : null;
672 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
673 for (const session of sessions.values())
674 {
675 if (!session.entityId)
676 { continue; }
677 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
678 const seesTo = session.subscribed.has(toKey);
679 if (event.type === "entity-spawn")
680 {
681 if (session.entityId === event.entityId || !seesTo)
682 { continue; }
683 send(session, spawnPayload(event));
684 continue;
685 }
686 if (event.type === "entity-despawn")
687 {
688 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
689 { continue; }
690 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
691 continue;
692 }
693 if (event.type === "entity-appearance")
694 {
695 if (!seesTo)
696 { continue; }
697 send(session, {
698 type: MessageType.entityAppearance,
699 entityId: event.entityId,
700 sprite: event.sprite,
701 layers: event.layers ?? [],
702 lightRadiusTiles: event.lightRadiusTiles ?? 0
703 });
704 continue;
705 }
706 if (event.type === "ground-item-appear")
707 {
708 if (!seesTo)
709 { continue; }
710 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
711 continue;
712 }
713 if (event.type === "ground-item-despawn")
714 {
715 if (!seesTo)
716 { continue; }
717 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
718 continue;
719 }
720 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
721 {
722 if (!seesTo && !seesFrom)
723 { continue; }
724 const type = event.type === "combat-swing"
725 ? MessageType.combatSwing
726 : event.type === "combat-hit"
727 ? MessageType.combatHit
728 : event.type === "combat-block"
729 ? MessageType.combatBlock
730 : MessageType.combatMiss;
731 send(session, {
732 type,
733 attackerId: event.attackerId,
734 targetId: event.targetId,
735 damage: event.damage,
736 health: event.health,
737 maxHealth: event.maxHealth,
738 tileX: event.tileX,
739 tileY: event.tileY,
740 fromTileX: event.fromTileX,
741 fromTileY: event.fromTileY
742 });
743 continue;
744 }
745 if (event.type !== "entity-move")
746 { continue; }
747 if (seesTo)
748 {
749 if (!seesFrom)
750 { send(session, spawnPayload(event)); }
751 else
752 {
753 send(session, {
754 type: MessageType.entityMove,
755 entityId: event.entityId,
756 tileX: event.tileX,
757 tileY: event.tileY,
758 worldX: event.worldX,
759 worldY: event.worldY,
760 gait: event.gait,
761 lerpMs: event.lerpMs,
762 freeFlight: !!event.freeFlight
763 });
764 }
765 }
766 else if (seesFrom)
767 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
768 if (session.entityId === event.entityId)
769 { syncSubscriptions(session, false); }
770 }
771 }
772
773 function spawnPayload (event)
774 {
775 const record = simulation.entityRecord(event.entityId) ?? event;
776 return {
777 type: MessageType.entitySpawn,
778 entityId: event.entityId,
779 characterId: record.characterId ?? event.characterId ?? null,
780 tileX: event.tileX ?? record.tileX,
781 tileY: event.tileY ?? record.tileY,
782 worldX: event.worldX ?? record.worldX,
783 worldY: event.worldY ?? record.worldY,
784 gait: event.gait ?? record.gait,
785 sex: record.sex ?? event.sex ?? null,
786 firstName: record.firstName ?? event.firstName ?? "",
787 lastName: record.lastName ?? event.lastName ?? "",
788 sprite: record.sprite ?? event.sprite ?? null,
789 layers: record.layers ?? event.layers ?? [],
790 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
791 canFight: !!(record.canFight ?? event.canFight),
792 hostile: !!(record.hostile ?? event.hostile),
793 talkable: !!(record.talkable ?? event.talkable),
794 untargetable: !!(record.untargetable ?? event.untargetable),
795 freeFlight: !!(record.freeFlight ?? event.freeFlight),
796 health: record.health ?? event.health,
797 maxHealth: record.maxHealth ?? event.maxHealth,
798 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
799 };
800 }
801
802 return {
803 sessions,
804 onTickResult,
805 wss,
806 async shutdown ()
807 {
808 await Promise.all([...sessions.values()].map(async (session) =>
809 {
810 await sendAsync(session, {
811 type: MessageType.forceLogout,
812 reason: "Server shutting down."
813 });
814 leaveWorld(session);
815 await closeAsync(session, 1001, "Server shutting down.");
816 }));
817 sessions.clear();
818 await simulation.shutdown();
819 }
820 };
821}
822
823function send (session, payload)
824{
825 if (session.socket.readyState === 1)
826 { session.socket.send(JSON.stringify(payload)); }
827}
828
829function sendAsync (session, payload)
830{
831 return new Promise((resolve) =>
832 {
833 if (session.socket.readyState !== 1)
834 {
835 resolve();
836 return;
837 }
838 session.socket.send(JSON.stringify(payload), () => resolve());
839 });
840}
841
842function closeAsync (session, code, reason)
843{
844 return new Promise((resolve) =>
845 {
846 if (session.socket.readyState !== 1)
847 {
848 resolve();
849 return;
850 }
851 session.socket.once("close", resolve);
852 try
853 { session.socket.close(code, reason); }
854 catch
855 { resolve(); }
856 });
857}