BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

tweaks to sprites, shading
timfa Tim Falken · pushed by timfa · 2 months ago
48b50124 History
websocket.js 35.9 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, STATIC_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 /** Chunks where entity / ground-item replication is active (3×3). */
28 entitySubscribed: new Set(),
29 /** Chunks with map + baked lighting only (5×5). */
30 staticSubscribed: new Set()
31 };
32 auth.register(session);
33 sessions.set(session.id, session);
34 send(session, {
35 type: MessageType.session,
36 accountId: account.account_id,
37 authSubject: account.auth_subject,
38 isAdmin: !!account.is_admin,
39 characters: characters.list(account.account_id)
40 });
41
42 socket.on("message", (raw) =>
43 {
44 let message;
45 try
46 { message = JSON.parse(String(raw)); }
47 catch
48 {
49 send(session, { type: MessageType.error, message: "Invalid JSON." });
50 return;
51 }
52 try
53 { handleMessage(session, message); }
54 catch (error)
55 {
56 send(session, {
57 type: MessageType.error,
58 message: error.userFacing ? error.message : "Request failed."
59 });
60 }
61 });
62
63 socket.on("close", () =>
64 {
65 leaveWorld(session);
66 auth.release(session);
67 sessions.delete(session.id);
68 });
69 });
70
71 function handleMessage (session, message)
72 {
73 if (session.characterId
74 && stateDb.getCharacter(session.characterId)?.is_dead
75 && message.type !== MessageType.respawn
76 && message.type !== MessageType.leaveWorld)
77 {
78 const error = new Error("You are dead.");
79 error.userFacing = true;
80 throw error;
81 }
82 switch (message.type)
83 {
84 case MessageType.createCharacter:
85 characters.create(session.account, message.firstName, message.lastName, message.sex);
86 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
87 break;
88 case MessageType.selectCharacter:
89 enterWorld(session, message.characterId);
90 break;
91 case MessageType.scheduleDeleteCharacter:
92 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
93 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
94 break;
95 case MessageType.cancelDeleteCharacter:
96 characters.cancelDelete(session.account, message.characterId);
97 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
98 break;
99 case MessageType.leaveWorld:
100 leaveWorld(session);
101 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
102 break;
103 case MessageType.respawn:
104 requirePlaying(session);
105 simulation.enqueue(session.id, {
106 type: "respawn",
107 characterId: session.characterId
108 });
109 break;
110 case MessageType.moveTo:
111 requirePlaying(session);
112 simulation.enqueue(session.id, {
113 type: "move-to",
114 characterId: session.characterId,
115 tileX: message.tileX | 0,
116 tileY: message.tileY | 0
117 });
118 break;
119 case MessageType.setGait:
120 requirePlaying(session);
121 simulation.enqueue(session.id, {
122 type: "set-gait",
123 characterId: session.characterId,
124 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
125 });
126 break;
127 case MessageType.friendRequest:
128 requirePlaying(session);
129 friends.request(session.characterId, message.characterId);
130 pushFriends(session.characterId, message.characterId);
131 break;
132 case MessageType.friendAccept:
133 requirePlaying(session);
134 friends.accept(session.characterId, message.characterId);
135 pushFriends(session.characterId, message.characterId);
136 break;
137 case MessageType.friendDecline:
138 requirePlaying(session);
139 friends.decline(session.characterId, message.characterId);
140 pushFriends(session.characterId, message.characterId);
141 break;
142 case MessageType.friendRemove:
143 requirePlaying(session);
144 friends.remove(session.characterId, message.characterId);
145 pushFriends(session.characterId, message.characterId);
146 break;
147 case MessageType.chatSay:
148 requirePlaying(session);
149 broadcastSpeech(sessions, simulation, session, message.text);
150 break;
151 case MessageType.dropItem:
152 requirePlaying(session);
153 simulation.enqueue(session.id, {
154 type: "drop-item",
155 characterId: session.characterId,
156 slotIndex: message.slotIndex | 0,
157 quantity: message.quantity ?? null
158 });
159 break;
160 case MessageType.pickupItem:
161 requirePlaying(session);
162 simulation.enqueue(session.id, {
163 type: "pickup-item",
164 characterId: session.characterId,
165 groundItemId: message.groundItemId | 0
166 });
167 break;
168 case MessageType.equipItem:
169 requirePlaying(session);
170 simulation.enqueue(session.id, {
171 type: "equip-item",
172 characterId: session.characterId,
173 slotIndex: message.slotIndex | 0
174 });
175 break;
176 case MessageType.unequipItem:
177 requirePlaying(session);
178 simulation.enqueue(session.id, {
179 type: "unequip-item",
180 characterId: session.characterId,
181 equipSlot: message.equipSlot
182 });
183 break;
184 case MessageType.eatItem:
185 requirePlaying(session);
186 simulation.enqueue(session.id, {
187 type: "eat-item",
188 characterId: session.characterId,
189 slotIndex: message.slotIndex | 0
190 });
191 break;
192 case MessageType.openBank:
193 requirePlaying(session);
194 simulation.enqueue(session.id, {
195 type: "open-bank",
196 characterId: session.characterId
197 });
198 break;
199 case MessageType.openCauldron:
200 requirePlaying(session);
201 simulation.enqueue(session.id, {
202 type: "open-cauldron",
203 characterId: session.characterId
204 });
205 break;
206 case MessageType.openFurnace:
207 requirePlaying(session);
208 simulation.enqueue(session.id, {
209 type: "open-station",
210 characterId: session.characterId,
211 stationId: CraftingStationId.furnace
212 });
213 break;
214 case MessageType.openStation:
215 {
216 requirePlaying(session);
217 const stationId = typeof message.stationId === "string"
218 ? message.stationId
219 : null;
220 if (!stationId || !craftingStationDefinition(stationId))
221 { break; }
222 simulation.enqueue(session.id, {
223 type: "open-station",
224 characterId: session.characterId,
225 stationId
226 });
227 break;
228 }
229 case MessageType.mine:
230 requirePlaying(session);
231 simulation.enqueue(session.id, {
232 type: "mine",
233 characterId: session.characterId,
234 tileX: message.tileX | 0,
235 tileY: message.tileY | 0
236 });
237 break;
238 case MessageType.chop:
239 requirePlaying(session);
240 simulation.enqueue(session.id, {
241 type: "chop",
242 characterId: session.characterId,
243 tileX: message.tileX | 0,
244 tileY: message.tileY | 0
245 });
246 break;
247 case MessageType.cancelGather:
248 requirePlaying(session);
249 simulation.enqueue(session.id, {
250 type: "cancel-gather",
251 characterId: session.characterId
252 });
253 break;
254 case MessageType.startCraft:
255 requirePlaying(session);
256 simulation.enqueue(session.id, {
257 type: "start-craft",
258 characterId: session.characterId,
259 stationId: message.stationId,
260 recipeId: message.recipeId
261 });
262 break;
263 case MessageType.cancelCraft:
264 requirePlaying(session);
265 simulation.enqueue(session.id, {
266 type: "cancel-craft",
267 characterId: session.characterId
268 });
269 break;
270 case MessageType.cauldronSetSlot:
271 requirePlaying(session);
272 simulation.enqueue(session.id, {
273 type: "cauldron-set-slot",
274 characterId: session.characterId,
275 slotIndex: message.slotIndex | 0,
276 itemId: message.itemId | 0,
277 quantity: message.quantity | 0
278 });
279 break;
280 case MessageType.cauldronInsert:
281 requirePlaying(session);
282 simulation.enqueue(session.id, {
283 type: "cauldron-insert",
284 characterId: session.characterId,
285 slotIndex: message.slotIndex | 0
286 });
287 break;
288 case MessageType.cauldronAction:
289 requirePlaying(session);
290 simulation.enqueue(session.id, {
291 type: "cauldron-action",
292 characterId: session.characterId,
293 action: message.action
294 });
295 break;
296 case MessageType.cauldronBottle:
297 requirePlaying(session);
298 simulation.enqueue(session.id, {
299 type: "cauldron-bottle",
300 characterId: session.characterId
301 });
302 break;
303 case MessageType.cauldronClear:
304 requirePlaying(session);
305 simulation.enqueue(session.id, {
306 type: "cauldron-clear",
307 characterId: session.characterId
308 });
309 break;
310 case MessageType.cauldronSaveRecipe:
311 requirePlaying(session);
312 simulation.enqueue(session.id, {
313 type: "cauldron-save-recipe",
314 characterId: session.characterId
315 });
316 break;
317 case MessageType.cauldronClose:
318 requirePlaying(session);
319 simulation.enqueue(session.id, {
320 type: "cauldron-close",
321 characterId: session.characterId
322 });
323 break;
324 case MessageType.bankDeposit:
325 requirePlaying(session);
326 simulation.enqueue(session.id, {
327 type: "bank-deposit",
328 characterId: session.characterId,
329 slotIndex: message.slotIndex | 0,
330 quantity: message.quantity ?? null
331 });
332 break;
333 case MessageType.bankWithdraw:
334 requirePlaying(session);
335 simulation.enqueue(session.id, {
336 type: "bank-withdraw",
337 characterId: session.characterId,
338 slotIndex: message.slotIndex | 0,
339 quantity: message.quantity ?? null
340 });
341 break;
342 case MessageType.getBlankCheques:
343 requirePlaying(session);
344 simulation.enqueue(session.id, {
345 type: "get-blank-cheques",
346 characterId: session.characterId
347 });
348 break;
349 case MessageType.returnBlankCheques:
350 requirePlaying(session);
351 simulation.enqueue(session.id, {
352 type: "return-blank-cheques",
353 characterId: session.characterId,
354 slotIndex: message.slotIndex | 0,
355 quantity: message.quantity ?? null
356 });
357 break;
358 case MessageType.writeCheque:
359 requirePlaying(session);
360 simulation.enqueue(session.id, {
361 type: "write-cheque",
362 characterId: session.characterId,
363 slotIndex: message.slotIndex | 0,
364 vaultSlotIndex: message.vaultSlotIndex | 0,
365 quantity: message.quantity ?? 1
366 });
367 break;
368 case MessageType.redeemCheque:
369 requirePlaying(session);
370 simulation.enqueue(session.id, {
371 type: "redeem-cheque",
372 characterId: session.characterId,
373 slotIndex: message.slotIndex | 0
374 });
375 break;
376 case MessageType.claimInheritance:
377 requirePlaying(session);
378 {
379 const inheritance = stateDb.getInheritance(session.account.account_id);
380 simulation.enqueue(session.id, {
381 type: "claim-inheritance",
382 characterId: session.characterId,
383 stacks: (inheritance.slots ?? []).filter(Boolean)
384 });
385 }
386 break;
387 case MessageType.attack:
388 requirePlaying(session);
389 simulation.enqueue(session.id, {
390 type: "attack",
391 characterId: session.characterId,
392 targetEntityId: message.targetEntityId | 0
393 });
394 break;
395 case MessageType.cancelAttack:
396 requirePlaying(session);
397 simulation.enqueue(session.id, {
398 type: "cancel-attack",
399 characterId: session.characterId
400 });
401 break;
402 case MessageType.interact:
403 requirePlaying(session);
404 simulation.enqueue(session.id, {
405 type: "interact",
406 characterId: session.characterId,
407 targetEntityId: message.targetEntityId | 0
408 });
409 break;
410 case MessageType.buyFromShop:
411 requirePlaying(session);
412 simulation.enqueue(session.id, {
413 type: "buy-from-shop",
414 characterId: session.characterId,
415 npcEntityId: message.npcEntityId | 0,
416 itemId: message.itemId | 0,
417 quantity: message.quantity | 0 || 1,
418 listingId: typeof message.listingId === "string" ? message.listingId : null,
419 source: typeof message.source === "string" ? message.source : null
420 });
421 break;
422 case MessageType.sellToShop:
423 requirePlaying(session);
424 simulation.enqueue(session.id, {
425 type: "sell-to-shop",
426 characterId: session.characterId,
427 npcEntityId: message.npcEntityId | 0,
428 slotIndex: message.slotIndex | 0,
429 quantity: message.quantity | 0 || 1
430 });
431 break;
432 case MessageType.closeShop:
433 requirePlaying(session);
434 simulation.enqueue(session.id, {
435 type: "close-shop",
436 characterId: session.characterId,
437 npcEntityId: message.npcEntityId | 0
438 });
439 break;
440 case MessageType.openMarket:
441 requirePlaying(session);
442 simulation.enqueue(session.id, {
443 type: "open-market",
444 characterId: session.characterId
445 });
446 break;
447 case MessageType.closeMarket:
448 requirePlaying(session);
449 simulation.enqueue(session.id, {
450 type: "close-market",
451 characterId: session.characterId
452 });
453 break;
454 case MessageType.placeMarketSell:
455 requirePlaying(session);
456 simulation.enqueue(session.id, {
457 type: "place-market-sell",
458 characterId: session.characterId,
459 slotIndex: message.slotIndex | 0,
460 quantity: message.quantity | 0 || 1,
461 minUnitPrice: message.minUnitPrice | 0
462 });
463 break;
464 case MessageType.placeMarketBuy:
465 requirePlaying(session);
466 simulation.enqueue(session.id, {
467 type: "place-market-buy",
468 characterId: session.characterId,
469 itemId: message.itemId | 0,
470 quantity: message.quantity | 0 || 1,
471 maxUnitPrice: message.maxUnitPrice | 0
472 });
473 break;
474 case MessageType.cancelMarketOrder:
475 requirePlaying(session);
476 simulation.enqueue(session.id, {
477 type: "cancel-market-order",
478 characterId: session.characterId,
479 orderId: message.orderId | 0
480 });
481 break;
482 case MessageType.follow:
483 requirePlaying(session);
484 simulation.enqueue(session.id, {
485 type: "follow",
486 characterId: session.characterId,
487 targetEntityId: message.targetEntityId | 0
488 });
489 break;
490 case MessageType.cancelFollow:
491 requirePlaying(session);
492 simulation.enqueue(session.id, {
493 type: "cancel-follow",
494 characterId: session.characterId
495 });
496 break;
497 case MessageType.sendPigeon:
498 requirePlaying(session);
499 {
500 const result = simulation.dispatchPigeon({
501 characterId: session.characterId,
502 destination: message.destination,
503 cargo: message.cargo
504 });
505 send(session, {
506 type: MessageType.pigeonDispatched,
507 courierId: result.transit.courierId,
508 destinationKind: result.transit.destinationKind,
509 destinationCharacterId: result.transit.destinationCharacterId
510 });
511 send(session, { type: MessageType.inventory, ...result.bag });
512 }
513 break;
514 case MessageType.searchCharacter:
515 requirePlaying(session);
516 {
517 const character = friends.findByFullName(message.firstName, message.lastName);
518 send(session, {
519 type: MessageType.characterSearchResult,
520 character: character ?? null
521 });
522 }
523 break;
524 case MessageType.writeLetter:
525 requirePlaying(session);
526 simulation.enqueue(session.id, {
527 type: "write-letter",
528 characterId: session.characterId,
529 slotIndex: message.slotIndex,
530 body: message.body
531 });
532 break;
533 case MessageType.editLetter:
534 requirePlaying(session);
535 simulation.enqueue(session.id, {
536 type: "edit-letter",
537 characterId: session.characterId,
538 slotIndex: message.slotIndex,
539 body: message.body
540 });
541 break;
542 case MessageType.openLetter:
543 requirePlaying(session);
544 simulation.enqueue(session.id, {
545 type: "open-letter",
546 characterId: session.characterId,
547 slotIndex: message.slotIndex
548 });
549 break;
550 case MessageType.editorLoadChunk:
551 requireAdmin(session);
552 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
553 break;
554 case MessageType.editorSaveChunk:
555 requireAdmin(session);
556 send(session, {
557 type: MessageType.editorChunk,
558 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
559 });
560 break;
561 case MessageType.editorLoadSettings:
562 requireAdmin(session);
563 send(session, {
564 type: MessageType.editorSettings,
565 ...editor.loadSettings(),
566 itemLastSales: simulation.itemLastSalesSnapshot?.() ?? {}
567 });
568 break;
569 case MessageType.editorSaveSettings:
570 requireAdmin(session);
571 {
572 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
573 simulation.applySettings(saved.settings);
574 broadcastStatus();
575 broadcastSettings(saved);
576 }
577 break;
578 case MessageType.editorApplyRevision:
579 requireAdmin(session);
580 if (!editor.revisionStatus().pendingRevisionId)
581 {
582 send(session, { type: MessageType.error, message: "Nothing pending to apply." });
583 break;
584 }
585 {
586 const appliedRevisionId = editor.applyPendingRevision();
587 simulation.reloadWorld();
588 for (const other of sessions.values())
589 {
590 if (other.entityId)
591 { syncSubscriptions(other, true); }
592 }
593 broadcastStatus();
594 send(session, {
595 type: MessageType.editorRevisionApplied,
596 ...editor.revisionStatus(),
597 appliedRevisionId
598 });
599 }
600 break;
601 default:
602 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
603 }
604 }
605
606 function enterWorld (session, characterId)
607 {
608 leaveWorld(session);
609 const character = characters.getOwned(session.account.account_id, characterId);
610 if (character.deletion_scheduled_at)
611 {
612 const error = new Error("That character is marked for deletion.");
613 error.userFacing = true;
614 throw error;
615 }
616 for (const other of sessions.values())
617 {
618 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
619 {
620 const error = new Error("This account already has a character in the world.");
621 error.userFacing = true;
622 throw error;
623 }
624 }
625 session.characterId = character.character_id;
626 session.entityId = simulation.spawnCharacter(session.id, character);
627 const spawned = simulation.entityRecord(session.entityId);
628 send(session, {
629 type: MessageType.enterWorld,
630 entityId: session.entityId,
631 characterId: session.characterId,
632 tileX: spawned.tileX,
633 tileY: spawned.tileY,
634 gait: spawned.gait,
635 sex: spawned.sex,
636 firstName: spawned.firstName,
637 lastName: spawned.lastName,
638 layers: spawned.layers ?? [],
639 settings: simulation.settings,
640 worldTime: simulation.worldTime()
641 });
642 syncSubscriptions(session, true);
643 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
644 const bag = simulation.bagOf(session.entityId);
645 if (bag)
646 { send(session, { type: MessageType.inventory, ...bag }); }
647 const skills = simulation.skillsOf(session.entityId);
648 if (skills)
649 { send(session, { type: MessageType.skills, skills: publicSkillsView(skills) }); }
650 const stamina = simulation.staminaOf(session.entityId);
651 if (stamina)
652 {
653 send(session, {
654 type: MessageType.stamina,
655 current: stamina.current,
656 max: stamina.max,
657 gait: stamina.gait
658 });
659 }
660 if (character.is_dead)
661 {
662 send(session, {
663 type: MessageType.playerDied,
664 entityId: session.entityId,
665 characterId: session.characterId
666 });
667 }
668 publishReplication(simulation.drainReplication());
669 }
670
671 function leaveWorld (session)
672 {
673 if (session.characterId)
674 { simulation.despawnCharacter(session.characterId); }
675 publishReplication(simulation.drainReplication());
676 session.characterId = null;
677 session.entityId = null;
678 session.entitySubscribed.clear();
679 session.staticSubscribed.clear();
680 }
681
682 function syncSubscriptions (session, forceSnapshots)
683 {
684 if (!session.entityId)
685 { return; }
686 const position = simulation.positionOf(session.entityId);
687 if (!position)
688 { return; }
689
690 const centerChunkX = tileToChunk(position.tileX);
691 const centerChunkY = tileToChunk(position.tileY);
692 const entityCoords = visibleChunkCoords(centerChunkX, centerChunkY, VISIBLE_CHUNK_RADIUS);
693 const staticCoords = visibleChunkCoords(centerChunkX, centerChunkY, STATIC_CHUNK_RADIUS);
694 const entityNext = new Set(entityCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
695 const staticNext = new Set(staticCoords.map((coord) => chunkKey(coord.chunkX, coord.chunkY)));
696
697 for (const key of session.staticSubscribed)
698 {
699 if (!staticNext.has(key))
700 {
701 const [chunkX, chunkY] = key.split(",").map(Number);
702 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
703 }
704 }
705
706 const snapshots = simulation.snapshotsForView(session.entityId);
707 for (const snapshot of snapshots)
708 {
709 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
710 const entityChanged = entityNext.has(key) !== session.entitySubscribed.has(key);
711 if (forceSnapshots || !session.staticSubscribed.has(key) || entityChanged)
712 {
713 send(session, { type: MessageType.chunkSnapshot, ...snapshot });
714 }
715 }
716 session.entitySubscribed = entityNext;
717 session.staticSubscribed = staticNext;
718 }
719
720 function requirePlaying (session)
721 {
722 if (!session.characterId)
723 {
724 const error = new Error("Select a character first.");
725 error.userFacing = true;
726 throw error;
727 }
728 }
729
730 function requireAdmin (session)
731 {
732 if (!session.account.is_admin)
733 {
734 const error = new Error("Admin only.");
735 error.userFacing = true;
736 throw error;
737 }
738 }
739
740 function broadcastStatus ()
741 {
742 const worldTime = simulation.worldTime();
743 for (const session of sessions.values())
744 {
745 if (session.entityId)
746 {
747 send(session, {
748 type: MessageType.worldStatus,
749 worldTime,
750 settings: simulation.settings,
751 activeRevisionId: simulation.activeRevisionId
752 });
753 }
754 }
755 }
756
757 function pushFriends (...characterIds)
758 {
759 const seen = new Set();
760 for (const characterId of characterIds)
761 {
762 const id = Number(characterId);
763 if (!id || seen.has(id))
764 { continue; }
765 seen.add(id);
766 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
767 for (const session of sessions.values())
768 {
769 if (session.characterId === id)
770 { send(session, payload); }
771 }
772 }
773 }
774
775 function broadcastSettings (payload)
776 {
777 for (const session of sessions.values())
778 {
779 if (session.account.is_admin)
780 { send(session, { type: MessageType.editorSettings, ...payload }); }
781 }
782 }
783
784 function onTickResult (result)
785 {
786 publishReplication(result.replication ?? []);
787 for (const event of result.events)
788 {
789 if (event.type === "command-error")
790 {
791 const session = sessions.get(event.sessionId);
792 if (session)
793 { send(session, { type: MessageType.error, message: event.message }); }
794 continue;
795 }
796 if (event.type === "inventory")
797 {
798 const session = event.sessionId != null
799 ? sessions.get(event.sessionId)
800 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
801 if (!session)
802 { continue; }
803 send(session, {
804 type: MessageType.inventory,
805 inventory: event.inventory,
806 equipment: event.equipment,
807 vault: event.vault,
808 vaultReserved: event.vaultReserved
809 });
810 if (event.bank)
811 {
812 send(session, {
813 type: MessageType.bankSnapshot,
814 vault: event.vault,
815 vaultReserved: event.vaultReserved,
816 inheritance: stateDb.getInheritance(session.account.account_id)
817 });
818 }
819 if (event.cauldron != null)
820 {
821 send(session, {
822 type: MessageType.cauldronSnapshot,
823 open: !!event.cauldron,
824 state: event.cauldronState ?? null,
825 alchemyResult: event.alchemyResult ?? null
826 });
827 }
828 continue;
829 }
830 if (event.type === "skills")
831 {
832 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
833 if (!session)
834 { continue; }
835 send(session, { type: MessageType.skills, skills: event.skills ?? [] });
836 continue;
837 }
838 if (event.type === "stamina")
839 {
840 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
841 if (!session)
842 { continue; }
843 send(session, {
844 type: MessageType.stamina,
845 current: event.current,
846 max: event.max,
847 gait: event.gait
848 });
849 continue;
850 }
851 if (event.type === "toast")
852 {
853 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
854 if (session)
855 { send(session, { type: MessageType.toast, message: event.message }); }
856 continue;
857 }
858 if (event.type === "pigeon-delivered")
859 {
860 for (const session of sessions.values())
861 {
862 if (session.characterId === event.senderCharacterId
863 || session.characterId === event.destinationCharacterId)
864 {
865 send(session, {
866 type: MessageType.pigeonDelivered,
867 courierId: event.courierId,
868 destinationKind: event.destinationKind,
869 cargo: event.cargo
870 });
871 }
872 }
873 continue;
874 }
875 if (event.type === "player-died")
876 {
877 const session = sessions.get(event.sessionId);
878 if (session)
879 {
880 send(session, {
881 type: MessageType.playerDied,
882 entityId: event.entityId,
883 characterId: event.characterId
884 });
885 }
886 continue;
887 }
888 if (event.type === "player-respawned")
889 {
890 const session = sessions.get(event.sessionId);
891 if (session)
892 {
893 send(session, {
894 type: MessageType.playerRespawned,
895 entityId: event.entityId,
896 characterId: event.characterId,
897 tileX: event.tileX,
898 tileY: event.tileY,
899 health: event.health,
900 maxHealth: event.maxHealth,
901 stamina: event.stamina,
902 maxStamina: event.maxStamina
903 });
904 }
905 continue;
906 }
907 if (event.type === "craft-result")
908 {
909 const session = sessions.get(event.sessionId);
910 if (session)
911 {
912 send(session, {
913 type: MessageType.craftResult,
914 recipeId: event.recipeId,
915 ok: !!event.ok,
916 error: event.error ?? null,
917 burned: !!event.burned
918 });
919 }
920 continue;
921 }
922 if (event.type === "station-open")
923 {
924 const session = sessions.get(event.sessionId);
925 if (session)
926 {
927 send(session, {
928 type: MessageType.stationOpen,
929 stationId: event.stationId
930 });
931 }
932 continue;
933 }
934 if (event.type === "shop-open")
935 {
936 const session = sessions.get(event.sessionId);
937 if (session)
938 {
939 send(session, {
940 type: MessageType.shopOpen,
941 npcEntityId: event.npcEntityId,
942 displayName: event.displayName,
943 sex: event.sex === "female" ? "female" : "male",
944 buysItems: !!event.buysItems,
945 stock: event.stock ?? []
946 });
947 }
948 continue;
949 }
950 if (event.type === "shop-closed")
951 {
952 const session = sessions.get(event.sessionId);
953 if (session)
954 {
955 send(session, {
956 type: MessageType.shopClosed,
957 npcEntityId: event.npcEntityId
958 });
959 }
960 continue;
961 }
962 if (event.type === "market-open")
963 {
964 const session = sessions.get(event.sessionId);
965 if (session)
966 {
967 send(session, {
968 type: MessageType.marketOpen,
969 displayName: event.displayName,
970 orders: event.orders ?? [],
971 catalog: event.catalog ?? []
972 });
973 }
974 continue;
975 }
976 if (event.type === "market-closed")
977 {
978 const session = sessions.get(event.sessionId);
979 if (session)
980 { send(session, { type: MessageType.marketClosed }); }
981 continue;
982 }
983 if (event.type === "market-trade")
984 {
985 for (const session of sessions.values())
986 {
987 if (
988 session.characterId === event.buyerCharacterId
989 || session.characterId === event.sellerCharacterId
990 )
991 {
992 send(session, {
993 type: MessageType.marketTrade,
994 itemId: event.itemId,
995 quantity: event.quantity,
996 unitPrice: event.unitPrice,
997 triggeringSide: event.triggeringSide
998 });
999 }
1000 }
1001 continue;
1002 }
1003 if (event.type === "item-bubble")
1004 {
1005 broadcastItemBubble(
1006 sessions,
1007 simulation,
1008 event.entityId,
1009 event.itemId,
1010 event.quantity
1011 );
1012 continue;
1013 }
1014 if (event.type === "gather-swing" || event.type === "tile-shove")
1015 {
1016 publishEntity({
1017 ...event,
1018 type: event.type
1019 });
1020 continue;
1021 }
1022 if (event.type === "chunk-delta")
1023 {
1024 publishEntity(event);
1025 continue;
1026 }
1027 if (event.type === "gather-complete")
1028 {
1029 const session = [...sessions.values()].find((entry) => entry.characterId === event.characterId);
1030 if (session)
1031 {
1032 send(session, {
1033 type: MessageType.gatherComplete,
1034 kind: event.kind,
1035 materialId: event.materialId,
1036 itemId: event.itemId
1037 });
1038 }
1039 continue;
1040 }
1041 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" || event.type === "skill-level-up")
1042 { publishEntity(event); }
1043 }
1044 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
1045 { broadcastStatus(); }
1046 }
1047
1048 function publishReplication (events)
1049 {
1050 for (const event of events ?? [])
1051 { publishEntity(event); }
1052 }
1053
1054 function publishEntity (event)
1055 {
1056 const fromKey = event.fromTileX != null
1057 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
1058 : null;
1059 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
1060 for (const session of sessions.values())
1061 {
1062 if (!session.entityId)
1063 { continue; }
1064 const seesFrom = fromKey ? session.entitySubscribed.has(fromKey) : false;
1065 const seesTo = session.entitySubscribed.has(toKey);
1066 const seesStaticTo = session.staticSubscribed.has(toKey);
1067 if (event.type === "entity-spawn")
1068 {
1069 if (session.entityId === event.entityId || !seesTo)
1070 { continue; }
1071 send(session, spawnPayload(event));
1072 continue;
1073 }
1074 if (event.type === "entity-despawn")
1075 {
1076 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
1077 { continue; }
1078 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
1079 continue;
1080 }
1081 if (event.type === "entity-appearance")
1082 {
1083 if (!seesTo)
1084 { continue; }
1085 send(session, {
1086 type: MessageType.entityAppearance,
1087 entityId: event.entityId,
1088 sprite: event.sprite,
1089 layers: event.layers ?? [],
1090 lightRadiusTiles: event.lightRadiusTiles ?? 0
1091 });
1092 continue;
1093 }
1094 if (event.type === "ground-item-appear")
1095 {
1096 if (!seesTo)
1097 { continue; }
1098 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
1099 continue;
1100 }
1101 if (event.type === "ground-item-despawn")
1102 {
1103 if (!seesTo)
1104 { continue; }
1105 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
1106 continue;
1107 }
1108 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss" || event.type === "combat-block")
1109 {
1110 if (!seesTo && !seesFrom)
1111 { continue; }
1112 const type = event.type === "combat-swing"
1113 ? MessageType.combatSwing
1114 : event.type === "combat-hit"
1115 ? MessageType.combatHit
1116 : event.type === "combat-block"
1117 ? MessageType.combatBlock
1118 : MessageType.combatMiss;
1119 send(session, {
1120 type,
1121 attackerId: event.attackerId,
1122 targetId: event.targetId,
1123 damage: event.damage,
1124 health: event.health,
1125 maxHealth: event.maxHealth,
1126 tileX: event.tileX,
1127 tileY: event.tileY,
1128 fromTileX: event.fromTileX,
1129 fromTileY: event.fromTileY
1130 });
1131 continue;
1132 }
1133 if (event.type === "gather-swing" || event.type === "tile-shove")
1134 {
1135 if (!seesTo && !seesFrom)
1136 { continue; }
1137 if (event.type === "gather-swing")
1138 {
1139 send(session, {
1140 type: MessageType.gatherSwing,
1141 attackerId: event.attackerId,
1142 tileX: event.tileX,
1143 tileY: event.tileY,
1144 fromTileX: event.fromTileX,
1145 fromTileY: event.fromTileY,
1146 toolItemId: event.toolItemId ?? null
1147 });
1148 }
1149 else
1150 {
1151 send(session, {
1152 type: MessageType.tileShove,
1153 attackerId: event.attackerId,
1154 tileX: event.tileX,
1155 tileY: event.tileY,
1156 fromTileX: event.fromTileX,
1157 fromTileY: event.fromTileY
1158 });
1159 }
1160 continue;
1161 }
1162 if (event.type === "skill-level-up")
1163 {
1164 if (session.entityId !== event.entityId && !seesTo)
1165 { continue; }
1166 send(session, {
1167 type: MessageType.skillLevelUp,
1168 entityId: event.entityId,
1169 characterId: event.characterId,
1170 skillId: event.skillId,
1171 level: event.level,
1172 displayName: event.displayName,
1173 icon: event.icon
1174 });
1175 continue;
1176 }
1177 if (event.type === "chunk-delta")
1178 {
1179 if (!seesStaticTo)
1180 { continue; }
1181 send(session, {
1182 type: MessageType.chunkDelta,
1183 chunkX: event.chunkX,
1184 chunkY: event.chunkY,
1185 tiles: [{
1186 localX: event.localX,
1187 localY: event.localY,
1188 block: event.block
1189 }]
1190 });
1191 continue;
1192 }
1193 if (event.type !== "entity-move")
1194 { continue; }
1195 if (seesTo)
1196 {
1197 if (!seesFrom)
1198 { send(session, spawnPayload(event)); }
1199 else
1200 {
1201 send(session, {
1202 type: MessageType.entityMove,
1203 entityId: event.entityId,
1204 tileX: event.tileX,
1205 tileY: event.tileY,
1206 worldX: event.worldX,
1207 worldY: event.worldY,
1208 gait: event.gait,
1209 lerpMs: event.lerpMs,
1210 freeFlight: !!event.freeFlight
1211 });
1212 }
1213 }
1214 else if (seesFrom)
1215 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
1216 if (session.entityId === event.entityId)
1217 { syncSubscriptions(session, false); }
1218 }
1219 }
1220
1221 function spawnPayload (event)
1222 {
1223 const record = simulation.entityRecord(event.entityId) ?? event;
1224 return {
1225 type: MessageType.entitySpawn,
1226 entityId: event.entityId,
1227 characterId: record.characterId ?? event.characterId ?? null,
1228 tileX: event.tileX ?? record.tileX,
1229 tileY: event.tileY ?? record.tileY,
1230 worldX: event.worldX ?? record.worldX,
1231 worldY: event.worldY ?? record.worldY,
1232 gait: event.gait ?? record.gait,
1233 sex: record.sex ?? event.sex ?? null,
1234 firstName: record.firstName ?? event.firstName ?? "",
1235 lastName: record.lastName ?? event.lastName ?? "",
1236 sprite: record.sprite ?? event.sprite ?? null,
1237 layers: record.layers ?? event.layers ?? [],
1238 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
1239 canFight: !!(record.canFight ?? event.canFight),
1240 hostile: !!(record.hostile ?? event.hostile),
1241 talkable: !!(record.talkable ?? event.talkable),
1242 untargetable: !!(record.untargetable ?? event.untargetable),
1243 freeFlight: !!(record.freeFlight ?? event.freeFlight),
1244 health: record.health ?? event.health,
1245 maxHealth: record.maxHealth ?? event.maxHealth,
1246 lightRadiusTiles: record.lightRadiusTiles ?? event.lightRadiusTiles ?? 0
1247 };
1248 }
1249
1250 return {
1251 sessions,
1252 onTickResult,
1253 wss,
1254 async shutdown ()
1255 {
1256 await Promise.all([...sessions.values()].map(async (session) =>
1257 {
1258 await sendAsync(session, {
1259 type: MessageType.forceLogout,
1260 reason: "Server shutting down."
1261 });
1262 leaveWorld(session);
1263 await closeAsync(session, 1001, "Server shutting down.");
1264 }));
1265 sessions.clear();
1266 await simulation.shutdown();
1267 }
1268 };
1269}
1270
1271function send (session, payload)
1272{
1273 if (session.socket.readyState === 1)
1274 { session.socket.send(JSON.stringify(payload)); }
1275}
1276
1277function sendAsync (session, payload)
1278{
1279 return new Promise((resolve) =>
1280 {
1281 if (session.socket.readyState !== 1)
1282 {
1283 resolve();
1284 return;
1285 }
1286 session.socket.send(JSON.stringify(payload), () => resolve());
1287 });
1288}
1289
1290function closeAsync (session, code, reason)
1291{
1292 return new Promise((resolve) =>
1293 {
1294 if (session.socket.readyState !== 1)
1295 {
1296 resolve();
1297 return;
1298 }
1299 session.socket.once("close", resolve);
1300 try
1301 { session.socket.close(code, reason); }
1302 catch
1303 { resolve(); }
1304 });
1305}