BlueGit

timfa questward

Files

questward / server / src / courier / service.js

service.js

service.js 12.4 KiB Download Raw
1import { CHUNK_SIZE } from "../../../shared/protocol/constants.js";
2import { BlockType } from "../../../shared/definitions/tiles.js";
3import { MobId, mobDefinition, mobSpriteName } from "../../../shared/definitions/mobs.js";
4import { ItemId, itemDefinition } from "../../../shared/definitions/items.js";
5import { insertStack, takeFromSlot, emptySlots } from "../../../shared/items/inventory.js";
6import { advanceCourierFlight } from "../../../shared/courier/flight.js";
7import { GAIT } from "../../../shared/protocol/constants.js";
8import { decodeChunkBlob } from "../world/chunkData.js";
9
10export class CourierService
11{
12 constructor ({ stateDb, worldDb, simulation })
13 {
14 this.stateDb = stateDb;
15 this.worldDb = worldDb;
16 this.simulation = simulation;
17 this.bankTiles = [];
18 this.refreshBankIndex();
19 }
20
21 refreshBankIndex ()
22 {
23 const revisionId = this.worldDb.getActiveRevisionId();
24 const banks = [];
25 for (const coord of this.worldDb.listChunkCoords(revisionId))
26 {
27 const row = this.worldDb.getChunkVersion(coord.chunk_x, coord.chunk_y, revisionId);
28 if (!row)
29 { continue; }
30 const data = decodeChunkBlob(row.data_blob, this.simulation.settings.defaultGroundTypeId);
31 for (let localY = 0; localY < CHUNK_SIZE; localY++)
32 {
33 for (let localX = 0; localX < CHUNK_SIZE; localX++)
34 {
35 const block = data.blocks[localY * CHUNK_SIZE + localX];
36 if (block?.typeId !== BlockType.bank)
37 { continue; }
38 banks.push({
39 tileX: coord.chunk_x * CHUNK_SIZE + localX,
40 tileY: coord.chunk_y * CHUNK_SIZE + localY
41 });
42 }
43 }
44 }
45 this.bankTiles = banks;
46 }
47
48 nearestBank (tileX, tileY)
49 {
50 if (!this.bankTiles.length)
51 { return null; }
52 let best = null;
53 let bestDist = Infinity;
54 for (const bank of this.bankTiles)
55 {
56 const dist = Math.hypot(bank.tileX - tileX, bank.tileY - tileY);
57 if (dist < bestDist)
58 {
59 bestDist = dist;
60 best = bank;
61 }
62 }
63 return best;
64 }
65
66 /**
67 * Player dispatch: cargo is money or one inventory stack.
68 * destination: { kind: "bank" } | { kind: "player", firstName, lastName }
69 */
70 dispatchFromPlayer ({ characterId, originTileX, originTileY, destination, cargo })
71 {
72 const onlineId = this.simulation.characterEntities.get(characterId);
73 const bag = onlineId
74 ? this.simulation.bagOf(onlineId)
75 : this.stateDb.getBag(characterId);
76 if (!bag)
77 {
78 const error = new Error("No bag.");
79 error.userFacing = true;
80 throw error;
81 }
82
83 let takenCargo;
84 if (cargo?.kind === "money")
85 {
86 const amount = Math.max(0, cargo.amount | 0);
87 if (amount <= 0 || amount > (bag.currency | 0))
88 {
89 const error = new Error("Not enough coins.");
90 error.userFacing = true;
91 throw error;
92 }
93 bag.currency -= amount;
94 takenCargo = { kind: "money", amount };
95 }
96 else if (cargo?.kind === "item")
97 {
98 const slot = bag.inventory?.[cargo.slotIndex | 0];
99 if (slot?.itemId === ItemId.letter)
100 {
101 if (Number(slot.instance?.authorCharacterId) !== Number(characterId))
102 {
103 const error = new Error("You can only send letters you wrote.");
104 error.userFacing = true;
105 throw error;
106 }
107 }
108 const taken = takeFromSlot(bag.inventory, cargo.slotIndex | 0, cargo.quantity ?? null);
109 if (!taken.ok || !taken.taken)
110 {
111 const error = new Error("That item is not available.");
112 error.userFacing = true;
113 throw error;
114 }
115 bag.inventory = taken.slots;
116 const stack = taken.taken;
117 if (stack.itemId === ItemId.letter && stack.instance)
118 { stack.instance = { ...stack.instance, opened: false }; }
119 takenCargo = { kind: "item", stack };
120 }
121 else
122 {
123 const error = new Error("Pigeon cargo must be money or one item stack.");
124 error.userFacing = true;
125 throw error;
126 }
127
128 const dest = this.#resolveDestination(destination, originTileX, originTileY);
129 this.#persistBag(characterId, bag);
130 const transit = this.stateDb.insertCourierTransit({
131 senderCharacterId: characterId,
132 destinationKind: dest.kind,
133 destinationCharacterId: dest.characterId ?? null,
134 cargo: takenCargo,
135 originX: originTileX + 0.5,
136 originY: originTileY + 0.5,
137 destX: dest.tileX + 0.5,
138 destY: dest.tileY + 0.5,
139 traveled: 0,
140 status: "in_transit",
141 entityId: null
142 });
143 return { transit, bag };
144 }
145
146 /** Market / system dispatch already holding cargo (no bag take). */
147 dispatchHeldCargo ({ senderCharacterId, originTileX, originTileY, destination, cargo })
148 {
149 const dest = this.#resolveDestination(destination, originTileX, originTileY);
150 return this.stateDb.insertCourierTransit({
151 senderCharacterId,
152 destinationKind: dest.kind,
153 destinationCharacterId: dest.characterId ?? null,
154 cargo,
155 originX: originTileX + 0.5,
156 originY: originTileY + 0.5,
157 destX: dest.tileX + 0.5,
158 destY: dest.tileY + 0.5,
159 traveled: 0,
160 status: "in_transit",
161 entityId: null
162 });
163 }
164
165 step (now, dt)
166 {
167 const events = [];
168 const settings = this.simulation.settings;
169 for (const transit of this.stateDb.listActiveCourierTransits())
170 {
171 this.#retargetPlayerDest(transit);
172 const advanced = advanceCourierFlight({
173 originX: transit.originX,
174 originY: transit.originY,
175 destX: transit.destX,
176 destY: transit.destY,
177 traveled: transit.traveled,
178 dt,
179 settings
180 });
181 transit.traveled = advanced.traveled;
182 transit.updatedAt = now;
183
184 if (advanced.arrived)
185 {
186 events.push(...this.#deliver(transit, now));
187 continue;
188 }
189
190 events.push(...this.#syncVisiblePigeon(transit, advanced, now));
191 this.stateDb.updateCourierTransit(transit);
192 }
193 return events;
194 }
195
196 #retargetPlayerDest (transit)
197 {
198 if (transit.destinationKind !== "player" || !transit.destinationCharacterId)
199 { return; }
200 const onlineId = this.simulation.characterEntities.get(transit.destinationCharacterId);
201 if (onlineId)
202 {
203 const pos = this.simulation.positionOf(onlineId);
204 if (pos)
205 {
206 transit.destX = pos.tileX + 0.5;
207 transit.destY = pos.tileY + 0.5;
208 }
209 return;
210 }
211 const character = this.stateDb.getCharacter(transit.destinationCharacterId);
212 if (character)
213 {
214 transit.destX = character.tile_x + 0.5;
215 transit.destY = character.tile_y + 0.5;
216 }
217 }
218
219 #resolveDestination (destination, originTileX, originTileY)
220 {
221 if (destination?.kind === "player")
222 {
223 const character = this.stateDb.getCharacterByName(destination.firstName, destination.lastName);
224 if (!character)
225 {
226 const error = new Error("No character with that name.");
227 error.userFacing = true;
228 throw error;
229 }
230 const onlineId = this.simulation.characterEntities.get(character.character_id);
231 const pos = onlineId ? this.simulation.positionOf(onlineId) : null;
232 return {
233 kind: "player",
234 characterId: character.character_id,
235 tileX: pos?.tileX ?? character.tile_x,
236 tileY: pos?.tileY ?? character.tile_y
237 };
238 }
239 if (destination?.kind === "bank")
240 {
241 const bank = this.nearestBank(originTileX, originTileY);
242 if (!bank)
243 {
244 const error = new Error("No bank exists in the world yet.");
245 error.userFacing = true;
246 throw error;
247 }
248 return { kind: "bank", tileX: bank.tileX, tileY: bank.tileY };
249 }
250 const error = new Error("Pigeon destination must be bank or player.");
251 error.userFacing = true;
252 throw error;
253 }
254
255 #syncVisiblePigeon (transit, advanced, now)
256 {
257 const events = [];
258 const tileX = Math.floor(advanced.x);
259 const tileY = Math.floor(advanced.y);
260 if (!this.simulation.chunkIsSimulating(tileX, tileY))
261 {
262 if (transit.entityId)
263 {
264 this.simulation.despawnEntity(transit.entityId);
265 events.push({ type: "entity-despawn", entityId: transit.entityId, tileX, tileY });
266 transit.entityId = null;
267 }
268 return events;
269 }
270
271 if (!transit.entityId || !this.simulation.entityRecord(transit.entityId))
272 {
273 transit.entityId = null;
274 const def = mobDefinition(MobId.pigeon);
275 const entityId = this.simulation.spawnEntity({
276 position: { tileX, tileY },
277 movement: { gait: GAIT.walk, walkCarry: 0 },
278 path: { tiles: [] },
279 flight: {
280 x: advanced.x,
281 y: advanced.y,
282 targetX: transit.destX,
283 targetY: transit.destY,
284 speed: advanced.speed,
285 nextPickAt: now + 60_000,
286 lastAt: now,
287 courierId: transit.courierId
288 },
289 appearance: {
290 sex: def.sex,
291 firstName: def.displayName,
292 lastName: "",
293 sprite: mobSpriteName(MobId.pigeon)
294 },
295 creature: { mobTypeId: MobId.pigeon },
296 health: { current: 1, max: 1 }
297 }, { requireResident: true });
298 if (entityId != null)
299 { transit.entityId = entityId; }
300 return events;
301 }
302
303 const moved = this.simulation.updateCourierFlight(transit.entityId, {
304 x: advanced.x,
305 y: advanced.y,
306 targetX: transit.destX,
307 targetY: transit.destY,
308 speed: advanced.speed,
309 lastAt: now,
310 courierId: transit.courierId
311 }, now);
312 if (moved?.despawned)
313 {
314 transit.entityId = null;
315 events.push({ type: "entity-despawn", entityId: moved.entityId, tileX, tileY });
316 }
317 else if (moved?.event)
318 { events.push(moved.event); }
319 return events;
320 }
321
322 #deliver (transit, now)
323 {
324 const events = [];
325 if (transit.entityId)
326 {
327 this.simulation.despawnEntity(transit.entityId);
328 events.push({
329 type: "entity-despawn",
330 entityId: transit.entityId,
331 tileX: Math.floor(transit.destX),
332 tileY: Math.floor(transit.destY)
333 });
334 transit.entityId = null;
335 }
336
337 if (transit.destinationKind === "bank")
338 { this.#creditVault(transit.senderCharacterId, transit.cargo); }
339 else if (transit.destinationKind === "player")
340 {
341 const delivered = this.#tryDeliverToPlayer(transit.destinationCharacterId, transit.cargo);
342 if (!delivered)
343 {
344 const bank = this.nearestBank(Math.floor(transit.destX), Math.floor(transit.destY))
345 ?? this.nearestBank(Math.floor(transit.originX), Math.floor(transit.originY));
346 if (bank)
347 {
348 transit.originX = transit.destX;
349 transit.originY = transit.destY;
350 transit.destX = bank.tileX + 0.5;
351 transit.destY = bank.tileY + 0.5;
352 transit.traveled = 0;
353 transit.destinationKind = "bank";
354 transit.updatedAt = now;
355 this.stateDb.updateCourierTransit(transit);
356 events.push({
357 type: "pigeon-reroute-bank",
358 courierId: transit.courierId,
359 characterId: transit.destinationCharacterId
360 });
361 return events;
362 }
363 this.#creditVault(transit.destinationCharacterId, transit.cargo);
364 }
365 }
366
367 transit.status = "delivered";
368 transit.traveled = Math.hypot(transit.destX - transit.originX, transit.destY - transit.originY);
369 transit.updatedAt = now;
370 this.stateDb.updateCourierTransit(transit);
371 events.push({
372 type: "pigeon-delivered",
373 courierId: transit.courierId,
374 senderCharacterId: transit.senderCharacterId,
375 destinationKind: transit.destinationKind,
376 destinationCharacterId: transit.destinationCharacterId,
377 cargo: transit.cargo
378 });
379 return events;
380 }
381
382 #tryDeliverToPlayer (characterId, cargo)
383 {
384 const onlineId = this.simulation.characterEntities.get(characterId);
385 if (onlineId)
386 {
387 if (cargo.kind === "money")
388 {
389 const bag = this.simulation.bagOf(onlineId);
390 if (!bag)
391 { return false; }
392 bag.currency = (bag.currency | 0) + (cargo.amount | 0);
393 this.#persistBag(characterId, bag);
394 return true;
395 }
396 if (cargo.kind === "item")
397 {
398 const bag = this.simulation.bagOf(onlineId);
399 if (!bag)
400 { return false; }
401 const def = itemDefinition(cargo.stack.itemId);
402 const result = insertStack(bag.inventory, cargo.stack, def);
403 if (!result.ok || result.remainder)
404 { return false; }
405 bag.inventory = result.slots;
406 this.#persistBag(characterId, bag);
407 return true;
408 }
409 }
410
411 if (cargo.kind === "money")
412 {
413 this.#creditVault(characterId, cargo);
414 return true;
415 }
416 return false;
417 }
418
419 #creditVault (characterId, cargo)
420 {
421 const onlineId = this.simulation.characterEntities.get(characterId);
422 const bag = onlineId
423 ? this.simulation.bagOf(onlineId)
424 : this.stateDb.getBag(characterId);
425 if (!bag)
426 { return; }
427 if (cargo.kind === "money")
428 {
429 bag.vaultCurrency = (bag.vaultCurrency | 0) + (cargo.amount | 0);
430 this.#persistBag(characterId, bag);
431 return;
432 }
433 if (cargo.kind === "item")
434 {
435 const def = itemDefinition(cargo.stack.itemId);
436 const result = insertStack(bag.vault ?? emptySlots(), cargo.stack, def);
437 bag.vault = result.ok ? result.slots : [...(bag.vault ?? []), cargo.stack];
438 this.#persistBag(characterId, bag);
439 }
440 }
441
442 #persistBag (characterId, bag)
443 {
444 this.stateDb.saveBag(characterId, bag);
445 const onlineId = this.simulation.characterEntities.get(characterId);
446 if (onlineId)
447 {
448 this.simulation.applyBag(onlineId, bag);
449 this.simulation.pushInventory(characterId, bag);
450 }
451 }
452}