BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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