BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

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