BlueGit

timfa questward

Files

questward / server / src / gateway / websocket.js

websocket.js

websocket.js 19.1 KiB Download Raw
1import { WebSocketServer } from "ws";
2import { MessageType, GAIT } from "../../../shared/protocol/constants.js";
3import { chunkKey, tileToChunk, visibleChunkCoords } from "../world/coordinates.js";
4import { VISIBLE_CHUNK_RADIUS } from "../../../shared/protocol/constants.js";
5import { broadcastSpeech } from "../chat/speech.js";
6
7let nextSessionId = 1;
8
9export function attachGateway ({ httpServer, auth, stateDb, characters, friends, editor, simulation })
10{
11 const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
12 const sessions = new Map();
13
14 wss.on("connection", (socket) =>
15 {
16 const identity = auth.claimIdentity();
17 const account = stateDb.ensureAccount(identity.authSubject, identity.isAdmin, identity.email);
18 const session = {
19 id: nextSessionId++,
20 socket,
21 account,
22 authSubject: identity.authSubject,
23 characterId: null,
24 entityId: null,
25 subscribed: new Set()
26 };
27 auth.register(session);
28 sessions.set(session.id, session);
29 send(session, {
30 type: MessageType.session,
31 accountId: account.account_id,
32 authSubject: account.auth_subject,
33 isAdmin: !!account.is_admin,
34 characters: characters.list(account.account_id)
35 });
36
37 socket.on("message", (raw) =>
38 {
39 let message;
40 try
41 { message = JSON.parse(String(raw)); }
42 catch
43 {
44 send(session, { type: MessageType.error, message: "Invalid JSON." });
45 return;
46 }
47 try
48 { handleMessage(session, message); }
49 catch (error)
50 {
51 send(session, {
52 type: MessageType.error,
53 message: error.userFacing ? error.message : "Request failed."
54 });
55 }
56 });
57
58 socket.on("close", () =>
59 {
60 leaveWorld(session);
61 auth.release(session);
62 sessions.delete(session.id);
63 });
64 });
65
66 function handleMessage (session, message)
67 {
68 switch (message.type)
69 {
70 case MessageType.createCharacter:
71 characters.create(session.account, message.firstName, message.lastName, message.sex);
72 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
73 break;
74 case MessageType.selectCharacter:
75 enterWorld(session, message.characterId);
76 break;
77 case MessageType.scheduleDeleteCharacter:
78 characters.scheduleDelete(session.account, message.characterId, simulation.settings.characterDeletionDelayMs);
79 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
80 break;
81 case MessageType.cancelDeleteCharacter:
82 characters.cancelDelete(session.account, message.characterId);
83 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
84 break;
85 case MessageType.leaveWorld:
86 leaveWorld(session);
87 send(session, { type: MessageType.characterList, characters: characters.list(session.account.account_id) });
88 break;
89 case MessageType.moveTo:
90 requirePlaying(session);
91 simulation.enqueue(session.id, {
92 type: "move-to",
93 characterId: session.characterId,
94 tileX: message.tileX | 0,
95 tileY: message.tileY | 0
96 });
97 break;
98 case MessageType.setGait:
99 requirePlaying(session);
100 simulation.enqueue(session.id, {
101 type: "set-gait",
102 characterId: session.characterId,
103 gait: message.gait === GAIT.run ? GAIT.run : GAIT.walk
104 });
105 break;
106 case MessageType.friendRequest:
107 requirePlaying(session);
108 friends.request(session.characterId, message.characterId);
109 pushFriends(session.characterId, message.characterId);
110 break;
111 case MessageType.friendAccept:
112 requirePlaying(session);
113 friends.accept(session.characterId, message.characterId);
114 pushFriends(session.characterId, message.characterId);
115 break;
116 case MessageType.friendDecline:
117 requirePlaying(session);
118 friends.decline(session.characterId, message.characterId);
119 pushFriends(session.characterId, message.characterId);
120 break;
121 case MessageType.friendRemove:
122 requirePlaying(session);
123 friends.remove(session.characterId, message.characterId);
124 pushFriends(session.characterId, message.characterId);
125 break;
126 case MessageType.chatSay:
127 requirePlaying(session);
128 broadcastSpeech(sessions, simulation, session, message.text);
129 break;
130 case MessageType.dropItem:
131 requirePlaying(session);
132 simulation.enqueue(session.id, {
133 type: "drop-item",
134 characterId: session.characterId,
135 slotIndex: message.slotIndex | 0,
136 quantity: message.quantity ?? null
137 });
138 break;
139 case MessageType.pickupItem:
140 requirePlaying(session);
141 simulation.enqueue(session.id, {
142 type: "pickup-item",
143 characterId: session.characterId,
144 groundItemId: message.groundItemId | 0
145 });
146 break;
147 case MessageType.equipItem:
148 requirePlaying(session);
149 simulation.enqueue(session.id, {
150 type: "equip-item",
151 characterId: session.characterId,
152 slotIndex: message.slotIndex | 0
153 });
154 break;
155 case MessageType.unequipItem:
156 requirePlaying(session);
157 simulation.enqueue(session.id, {
158 type: "unequip-item",
159 characterId: session.characterId,
160 equipSlot: message.equipSlot
161 });
162 break;
163 case MessageType.openBank:
164 requirePlaying(session);
165 simulation.enqueue(session.id, {
166 type: "open-bank",
167 characterId: session.characterId
168 });
169 break;
170 case MessageType.bankDeposit:
171 requirePlaying(session);
172 simulation.enqueue(session.id, {
173 type: message.money ? "bank-deposit-money" : "bank-deposit",
174 characterId: session.characterId,
175 slotIndex: message.slotIndex | 0,
176 quantity: message.quantity ?? null,
177 amount: message.amount | 0
178 });
179 break;
180 case MessageType.bankWithdraw:
181 requirePlaying(session);
182 simulation.enqueue(session.id, {
183 type: message.money ? "bank-withdraw-money" : "bank-withdraw",
184 characterId: session.characterId,
185 slotIndex: message.slotIndex | 0,
186 quantity: message.quantity ?? null,
187 amount: message.amount | 0
188 });
189 break;
190 case MessageType.claimInheritance:
191 requirePlaying(session);
192 {
193 const inheritance = stateDb.getInheritance(session.account.account_id);
194 simulation.enqueue(session.id, {
195 type: "claim-inheritance",
196 characterId: session.characterId,
197 stacks: (inheritance.slots ?? []).filter(Boolean),
198 currency: inheritance.currency | 0
199 });
200 }
201 break;
202 case MessageType.attack:
203 requirePlaying(session);
204 simulation.enqueue(session.id, {
205 type: "attack",
206 characterId: session.characterId,
207 targetEntityId: message.targetEntityId | 0
208 });
209 break;
210 case MessageType.cancelAttack:
211 requirePlaying(session);
212 simulation.enqueue(session.id, {
213 type: "cancel-attack",
214 characterId: session.characterId
215 });
216 break;
217 case MessageType.interact:
218 requirePlaying(session);
219 simulation.enqueue(session.id, {
220 type: "interact",
221 characterId: session.characterId,
222 targetEntityId: message.targetEntityId | 0
223 });
224 break;
225 case MessageType.follow:
226 requirePlaying(session);
227 simulation.enqueue(session.id, {
228 type: "follow",
229 characterId: session.characterId,
230 targetEntityId: message.targetEntityId | 0
231 });
232 break;
233 case MessageType.cancelFollow:
234 requirePlaying(session);
235 simulation.enqueue(session.id, {
236 type: "cancel-follow",
237 characterId: session.characterId
238 });
239 break;
240 case MessageType.sendPigeon:
241 requirePlaying(session);
242 {
243 const result = simulation.dispatchPigeon({
244 characterId: session.characterId,
245 destination: message.destination,
246 cargo: message.cargo
247 });
248 send(session, {
249 type: MessageType.pigeonDispatched,
250 courierId: result.transit.courierId,
251 destinationKind: result.transit.destinationKind,
252 destinationCharacterId: result.transit.destinationCharacterId
253 });
254 send(session, { type: MessageType.inventory, ...result.bag });
255 }
256 break;
257 case MessageType.editorLoadChunk:
258 requireAdmin(session);
259 send(session, { type: MessageType.editorChunk, ...editor.loadChunk(message.chunkX | 0, message.chunkY | 0) });
260 break;
261 case MessageType.editorSaveChunk:
262 requireAdmin(session);
263 send(session, {
264 type: MessageType.editorChunk,
265 ...editor.saveChunk(message.chunkX | 0, message.chunkY | 0, message.draft, session.authSubject)
266 });
267 break;
268 case MessageType.editorLoadSettings:
269 requireAdmin(session);
270 send(session, { type: MessageType.editorSettings, ...editor.loadSettings() });
271 break;
272 case MessageType.editorSaveSettings:
273 requireAdmin(session);
274 {
275 const saved = editor.saveSettings(message.settings ?? {}, session.authSubject);
276 simulation.applySettings(saved.settings);
277 broadcastStatus();
278 broadcastSettings(saved);
279 }
280 break;
281 case MessageType.editorApplyRevision:
282 requireAdmin(session);
283 editor.applyPendingRevision();
284 simulation.reloadWorld();
285 for (const other of sessions.values())
286 {
287 if (other.entityId)
288 { syncSubscriptions(other, true); }
289 }
290 broadcastStatus();
291 break;
292 default:
293 send(session, { type: MessageType.error, message: `Unknown message ${message.type}` });
294 }
295 }
296
297 function enterWorld (session, characterId)
298 {
299 leaveWorld(session);
300 const character = characters.getOwned(session.account.account_id, characterId);
301 if (character.deletion_scheduled_at)
302 {
303 const error = new Error("That character is marked for deletion.");
304 error.userFacing = true;
305 throw error;
306 }
307 for (const other of sessions.values())
308 {
309 if (other !== session && other.account.account_id === session.account.account_id && other.characterId)
310 {
311 const error = new Error("This account already has a character in the world.");
312 error.userFacing = true;
313 throw error;
314 }
315 }
316 session.characterId = character.character_id;
317 session.entityId = simulation.spawnCharacter(session.id, character);
318 const spawned = simulation.entityRecord(session.entityId);
319 send(session, {
320 type: MessageType.enterWorld,
321 entityId: session.entityId,
322 characterId: session.characterId,
323 tileX: spawned.tileX,
324 tileY: spawned.tileY,
325 gait: spawned.gait,
326 sex: spawned.sex,
327 firstName: spawned.firstName,
328 lastName: spawned.lastName,
329 layers: spawned.layers ?? [],
330 settings: simulation.settings,
331 worldTime: simulation.worldTime()
332 });
333 syncSubscriptions(session, true);
334 send(session, { type: MessageType.friends, ...friends.snapshot(session.characterId) });
335 const bag = simulation.bagOf(session.entityId);
336 if (bag)
337 { send(session, { type: MessageType.inventory, ...bag }); }
338 publishReplication(simulation.drainReplication());
339 }
340
341 function leaveWorld (session)
342 {
343 if (session.characterId)
344 { simulation.despawnCharacter(session.characterId); }
345 publishReplication(simulation.drainReplication());
346 session.characterId = null;
347 session.entityId = null;
348 session.subscribed.clear();
349 }
350
351 function syncSubscriptions (session, forceSnapshots)
352 {
353 if (!session.entityId)
354 { return; }
355 const position = simulation.positionOf(session.entityId);
356 if (!position)
357 { return; }
358
359 const next = new Set(
360 visibleChunkCoords(tileToChunk(position.tileX), tileToChunk(position.tileY), VISIBLE_CHUNK_RADIUS)
361 .map((coord) => chunkKey(coord.chunkX, coord.chunkY))
362 );
363 for (const key of session.subscribed)
364 {
365 if (!next.has(key))
366 {
367 const [chunkX, chunkY] = key.split(",").map(Number);
368 send(session, { type: MessageType.unsubscribeChunk, chunkX, chunkY });
369 }
370 }
371 const snapshots = simulation.snapshotFor(session.entityId);
372 for (const snapshot of snapshots)
373 {
374 const key = chunkKey(snapshot.chunkX, snapshot.chunkY);
375 if (forceSnapshots || !session.subscribed.has(key))
376 { send(session, { type: MessageType.chunkSnapshot, ...snapshot }); }
377 }
378 session.subscribed = next;
379 }
380
381 function requirePlaying (session)
382 {
383 if (!session.characterId)
384 {
385 const error = new Error("Select a character first.");
386 error.userFacing = true;
387 throw error;
388 }
389 }
390
391 function requireAdmin (session)
392 {
393 if (!session.account.is_admin)
394 {
395 const error = new Error("Admin only.");
396 error.userFacing = true;
397 throw error;
398 }
399 }
400
401 function broadcastStatus ()
402 {
403 const worldTime = simulation.worldTime();
404 for (const session of sessions.values())
405 {
406 if (session.entityId)
407 {
408 send(session, {
409 type: MessageType.worldStatus,
410 worldTime,
411 settings: simulation.settings,
412 activeRevisionId: simulation.activeRevisionId
413 });
414 }
415 }
416 }
417
418 function pushFriends (...characterIds)
419 {
420 const seen = new Set();
421 for (const characterId of characterIds)
422 {
423 const id = Number(characterId);
424 if (!id || seen.has(id))
425 { continue; }
426 seen.add(id);
427 const payload = { type: MessageType.friends, ...friends.snapshot(id) };
428 for (const session of sessions.values())
429 {
430 if (session.characterId === id)
431 { send(session, payload); }
432 }
433 }
434 }
435
436 function broadcastSettings (payload)
437 {
438 for (const session of sessions.values())
439 {
440 if (session.account.is_admin)
441 { send(session, { type: MessageType.editorSettings, ...payload }); }
442 }
443 }
444
445 function onTickResult (result)
446 {
447 publishReplication(result.replication ?? []);
448 for (const event of result.events)
449 {
450 if (event.type === "command-error")
451 {
452 const session = sessions.get(event.sessionId);
453 if (session)
454 { send(session, { type: MessageType.error, message: event.message }); }
455 continue;
456 }
457 if (event.type === "inventory")
458 {
459 const session = event.sessionId != null
460 ? sessions.get(event.sessionId)
461 : [...sessions.values()].find((entry) => entry.characterId === event.characterId);
462 if (!session)
463 { continue; }
464 send(session, {
465 type: MessageType.inventory,
466 inventory: event.inventory,
467 equipment: event.equipment,
468 currency: event.currency,
469 vault: event.vault,
470 vaultCurrency: event.vaultCurrency
471 });
472 if (event.bank)
473 {
474 send(session, {
475 type: MessageType.bankSnapshot,
476 vault: event.vault,
477 vaultCurrency: event.vaultCurrency,
478 currency: event.currency,
479 inheritance: stateDb.getInheritance(session.account.account_id)
480 });
481 }
482 continue;
483 }
484 if (event.type === "pigeon-delivered")
485 {
486 for (const session of sessions.values())
487 {
488 if (session.characterId === event.senderCharacterId
489 || session.characterId === event.destinationCharacterId)
490 {
491 send(session, {
492 type: MessageType.pigeonDelivered,
493 courierId: event.courierId,
494 destinationKind: event.destinationKind,
495 cargo: event.cargo
496 });
497 }
498 }
499 continue;
500 }
501 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")
502 { publishEntity(event); }
503 }
504 if (simulation.tickIndex % simulation.settings.simulationTickHz === 0)
505 { broadcastStatus(); }
506 }
507
508 function publishReplication (events)
509 {
510 for (const event of events ?? [])
511 { publishEntity(event); }
512 }
513
514 function publishEntity (event)
515 {
516 const fromKey = event.fromTileX != null
517 ? chunkKey(tileToChunk(event.fromTileX), tileToChunk(event.fromTileY))
518 : null;
519 const toKey = chunkKey(tileToChunk(event.tileX), tileToChunk(event.tileY));
520 for (const session of sessions.values())
521 {
522 if (!session.entityId)
523 { continue; }
524 const seesFrom = fromKey ? session.subscribed.has(fromKey) : false;
525 const seesTo = session.subscribed.has(toKey);
526 if (event.type === "entity-spawn")
527 {
528 if (session.entityId === event.entityId || !seesTo)
529 { continue; }
530 send(session, spawnPayload(event));
531 continue;
532 }
533 if (event.type === "entity-despawn")
534 {
535 if (session.entityId === event.entityId || (!seesTo && !seesFrom))
536 { continue; }
537 send(session, { type: MessageType.entityDespawn, entityId: event.entityId });
538 continue;
539 }
540 if (event.type === "entity-appearance")
541 {
542 if (!seesTo)
543 { continue; }
544 send(session, {
545 type: MessageType.entityAppearance,
546 entityId: event.entityId,
547 sprite: event.sprite,
548 layers: event.layers ?? []
549 });
550 continue;
551 }
552 if (event.type === "ground-item-appear")
553 {
554 if (!seesTo)
555 { continue; }
556 send(session, { type: MessageType.groundItemAppear, ...event, type: MessageType.groundItemAppear });
557 continue;
558 }
559 if (event.type === "ground-item-despawn")
560 {
561 if (!seesTo)
562 { continue; }
563 send(session, { type: MessageType.groundItemDespawn, groundItemId: event.groundItemId });
564 continue;
565 }
566 if (event.type === "combat-swing" || event.type === "combat-hit" || event.type === "combat-miss")
567 {
568 if (!seesTo && !seesFrom)
569 { continue; }
570 const type = event.type === "combat-swing"
571 ? MessageType.combatSwing
572 : event.type === "combat-hit"
573 ? MessageType.combatHit
574 : MessageType.combatMiss;
575 send(session, {
576 type,
577 attackerId: event.attackerId,
578 targetId: event.targetId,
579 damage: event.damage,
580 health: event.health,
581 tileX: event.tileX,
582 tileY: event.tileY,
583 fromTileX: event.fromTileX,
584 fromTileY: event.fromTileY
585 });
586 continue;
587 }
588 if (event.type !== "entity-move")
589 { continue; }
590 if (seesTo)
591 {
592 if (!seesFrom)
593 { send(session, spawnPayload(event)); }
594 else
595 {
596 send(session, {
597 type: MessageType.entityMove,
598 entityId: event.entityId,
599 tileX: event.tileX,
600 tileY: event.tileY,
601 worldX: event.worldX,
602 worldY: event.worldY,
603 gait: event.gait,
604 lerpMs: event.lerpMs,
605 freeFlight: !!event.freeFlight
606 });
607 }
608 }
609 else if (seesFrom)
610 { send(session, { type: MessageType.entityDespawn, entityId: event.entityId }); }
611 if (session.entityId === event.entityId)
612 { syncSubscriptions(session, false); }
613 }
614 }
615
616 function spawnPayload (event)
617 {
618 const record = simulation.entityRecord(event.entityId) ?? event;
619 return {
620 type: MessageType.entitySpawn,
621 entityId: event.entityId,
622 characterId: record.characterId ?? event.characterId ?? null,
623 tileX: event.tileX ?? record.tileX,
624 tileY: event.tileY ?? record.tileY,
625 worldX: event.worldX ?? record.worldX,
626 worldY: event.worldY ?? record.worldY,
627 gait: event.gait ?? record.gait,
628 sex: record.sex ?? event.sex ?? null,
629 firstName: record.firstName ?? event.firstName ?? "",
630 lastName: record.lastName ?? event.lastName ?? "",
631 sprite: record.sprite ?? event.sprite ?? null,
632 layers: record.layers ?? event.layers ?? [],
633 mobTypeId: record.mobTypeId ?? event.mobTypeId ?? null,
634 hostile: !!(record.hostile ?? event.hostile),
635 talkable: !!(record.talkable ?? event.talkable),
636 untargetable: !!(record.untargetable ?? event.untargetable),
637 freeFlight: !!(record.freeFlight ?? event.freeFlight)
638 };
639 }
640
641 return {
642 sessions,
643 onTickResult,
644 wss,
645 async shutdown ()
646 {
647 for (const session of [...sessions.values()])
648 {
649 leaveWorld(session);
650 try
651 { session.socket.close(1001, "Server shutting down"); }
652 catch
653 { /* ignore */ }
654 }
655 sessions.clear();
656 await simulation.shutdown();
657 }
658 };
659}
660
661function send (session, payload)
662{
663 if (session.socket.readyState === 1)
664 { session.socket.send(JSON.stringify(payload)); }
665}