BlueGit

timfa questward

Files

questward / server / src / alchemy / service.js

service.js

service.js 11.5 KiB Download Raw
1import { Component } from "../ecs/components.js";
2import { BlockType } from "../../../shared/definitions/tiles.js";
3import { AlchemyStepKind, CAULDRON_SLOT_COUNT } from "../../../shared/definitions/alchemy.js";
4import { ItemId, itemDefinition } from "../../../shared/definitions/items.js";
5import {
6 evaluateAlchemyBottle,
7 potionItemInstance,
8 recipePaperBody,
9 resolvedAlchemyPotions
10} from "../../../shared/alchemy/recipes.js";
11import { bagView } from "../items/bags.js";
12import {
13 countItemInSlots,
14 emptySlots,
15 insertStack,
16 normalizeInventorySlots,
17 takeMatchingFromSlots,
18 stackQuantity
19} from "../../../shared/items/inventory.js";
20import { tileToChunk, tileToLocal } from "../world/coordinates.js";
21import { CHUNK_SIZE } from "../../../shared/protocol/constants.js";
22import { randomUUID } from "node:crypto";
23
24/**
25 * Cauldron sessions live on the worker world (per character while the UI is open).
26 * Clients send intents only; all brew outcomes are evaluated here.
27 */
28
29function userError (message)
30{
31 const error = new Error(message);
32 error.userFacing = true;
33 return error;
34}
35
36function ensureSessions (world)
37{
38 if (!world.cauldronSessions)
39 { world.cauldronSessions = new Map(); }
40 return world.cauldronSessions;
41}
42
43function emptySession ()
44{
45 return {
46 slots: Array.from({ length: CAULDRON_SLOT_COUNT }, () => null),
47 brew: [],
48 steps: [],
49 lastSuccessRecipe: null
50 };
51}
52
53function sessionView (session)
54{
55 return {
56 slots: (session.slots ?? []).map((slot) => (slot
57 ? { itemId: slot.itemId, quantity: slot.quantity | 0 }
58 : null)),
59 brew: (session.brew ?? []).map((row) => ({ itemId: row.itemId, quantity: row.quantity | 0 })),
60 steps: (session.steps ?? []).map((step) => ({ ...step })),
61 canSaveRecipe: !!session.lastSuccessRecipe,
62 lastSuccess: session.lastSuccessRecipe
63 ? {
64 potionKey: session.lastSuccessRecipe.potionKey,
65 displayName: session.lastSuccessRecipe.displayName,
66 minAlchemyLevel: session.lastSuccessRecipe.minAlchemyLevel ?? 1
67 }
68 : null
69 };
70}
71
72function nearCauldron (world, tileX, tileY)
73{
74 for (let dy = -1; dy <= 1; dy++)
75 {
76 for (let dx = -1; dx <= 1; dx++)
77 {
78 const data = world.chunkData(tileToChunk(tileX + dx), tileToChunk(tileY + dy));
79 const index = tileToLocal(tileY + dy) * CHUNK_SIZE + tileToLocal(tileX + dx);
80 if (data.blocks[index]?.typeId === BlockType.cauldron)
81 { return true; }
82 }
83 }
84 return false;
85}
86
87function requireNearCauldron (world, handle)
88{
89 const position = world.ecs.get(handle, Component.position);
90 if (!nearCauldron(world, position.tileX, position.tileY))
91 { throw userError("Stand next to a cauldron."); }
92}
93
94function requireSession (world, characterId)
95{
96 const session = ensureSessions(world).get(characterId);
97 if (!session)
98 { throw userError("Open a cauldron first."); }
99 return session;
100}
101
102function clearBrew (session)
103{
104 session.slots = Array.from({ length: CAULDRON_SLOT_COUNT }, () => null);
105 session.brew = [];
106 session.steps = [];
107}
108
109function ensureInventory (world, handle)
110{
111 let inventory = world.ecs.get(handle, Component.inventory);
112 if (!inventory)
113 { inventory = world.ecs.add(handle, Component.inventory, { slots: emptySlots() }); }
114 inventory.slots = normalizeInventorySlots(inventory.slots ?? emptySlots());
115 return inventory;
116}
117
118export function handleAlchemyCommand (world, sessionId, command)
119{
120 switch (command.type)
121 {
122 case "open-cauldron":
123 return openCauldron(world, sessionId, command);
124 case "cauldron-set-slot":
125 return setSlot(world, sessionId, command);
126 case "cauldron-insert":
127 return insertFromSlot(world, sessionId, command);
128 case "cauldron-action":
129 return action(world, sessionId, command);
130 case "cauldron-bottle":
131 return bottle(world, sessionId, command);
132 case "cauldron-clear":
133 return clear(world, sessionId, command);
134 case "cauldron-save-recipe":
135 return saveRecipe(world, sessionId, command);
136 case "cauldron-close":
137 return closeCauldron(world, sessionId, command);
138 default:
139 return null;
140 }
141}
142
143function openCauldron (world, sessionId, command)
144{
145 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
146 requireNearCauldron(world, handle);
147 const sessions = ensureSessions(world);
148 const existing = sessions.get(command.characterId) ?? emptySession();
149 sessions.set(command.characterId, existing);
150 return {
151 events: [],
152 private: bagView(world.ecs, handle),
153 cauldron: true,
154 cauldronState: sessionView(existing)
155 };
156}
157
158function closeCauldron (world, sessionId, command)
159{
160 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
161 ensureSessions(world).delete(command.characterId);
162 return { events: [], private: bagView(world.ecs, handle), cauldron: false };
163}
164
165function setSlot (world, sessionId, command)
166{
167 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
168 requireNearCauldron(world, handle);
169 const session = requireSession(world, command.characterId);
170 const slotIndex = command.slotIndex | 0;
171 if (slotIndex < 0 || slotIndex >= CAULDRON_SLOT_COUNT)
172 { throw userError("Invalid cauldron slot."); }
173
174 const itemId = command.itemId | 0;
175 const quantity = Math.max(0, command.quantity | 0);
176 if (!itemId || quantity <= 0)
177 {
178 session.slots[slotIndex] = null;
179 return {
180 events: [],
181 private: bagView(world.ecs, handle),
182 cauldron: true,
183 cauldronState: sessionView(session)
184 };
185 }
186
187 const def = itemDefinition(itemId);
188 if (!def || def.uniqueInstance || def.equipment || itemId === ItemId.potion || itemId === ItemId.glassBottle)
189 { throw userError("That cannot go in a cauldron slot."); }
190
191 const inventory = ensureInventory(world, handle);
192 const have = countItemInSlots(inventory.slots, itemId);
193 if (have < quantity)
194 { throw userError("Not enough of that item in your inventory."); }
195
196 session.slots[slotIndex] = { itemId, quantity };
197 return {
198 events: [],
199 private: bagView(world.ecs, handle),
200 cauldron: true,
201 cauldronState: sessionView(session)
202 };
203}
204
205function insertFromSlot (world, sessionId, command)
206{
207 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
208 requireNearCauldron(world, handle);
209 const session = requireSession(world, command.characterId);
210 const slotIndex = command.slotIndex | 0;
211 const reserved = session.slots[slotIndex];
212 if (!reserved)
213 { throw userError("That cauldron slot is empty."); }
214
215 const inventory = ensureInventory(world, handle);
216 const pulled = takeMatchingFromSlots(inventory.slots, {
217 itemId: reserved.itemId,
218 quantity: reserved.quantity,
219 compact: false
220 });
221 if (!pulled.ok)
222 { throw userError("Not enough of that item in your inventory."); }
223 inventory.slots = pulled.slots;
224 session.slots[slotIndex] = null;
225
226 const existing = session.brew.find((row) => row.itemId === reserved.itemId);
227 if (existing)
228 { existing.quantity += reserved.quantity; }
229 else
230 { session.brew.push({ itemId: reserved.itemId, quantity: reserved.quantity }); }
231
232 session.steps.push({ kind: AlchemyStepKind.insert, itemId: reserved.itemId });
233 session.lastSuccessRecipe = null;
234
235 return {
236 events: [],
237 private: bagView(world.ecs, handle),
238 cauldron: true,
239 cauldronState: sessionView(session)
240 };
241}
242
243function action (world, sessionId, command)
244{
245 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
246 requireNearCauldron(world, handle);
247 const session = requireSession(world, command.characterId);
248 const kind = command.action;
249 if (kind !== AlchemyStepKind.stir && kind !== AlchemyStepKind.heat && kind !== AlchemyStepKind.cool)
250 { throw userError("Unknown cauldron action."); }
251 session.steps.push({ kind });
252 session.lastSuccessRecipe = null;
253 return {
254 events: [],
255 private: bagView(world.ecs, handle),
256 cauldron: true,
257 cauldronState: sessionView(session)
258 };
259}
260
261function bottle (world, sessionId, command)
262{
263 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
264 requireNearCauldron(world, handle);
265 const session = requireSession(world, command.characterId);
266 if (!(session.brew?.length > 0) && !(session.steps?.length > 0))
267 { throw userError("The cauldron is empty."); }
268
269 const inventory = ensureInventory(world, handle);
270 const skills = world.ecs.get(handle, Component.skills) ?? {};
271
272 const evaluation = evaluateAlchemyBottle({
273 skills,
274 brewStacks: session.brew,
275 takenSteps: session.steps,
276 potions: resolvedAlchemyPotions()
277 });
278
279 const wanted = Math.max(1, evaluation.batch | 0);
280 const bottles = countItemInSlots(inventory.slots, ItemId.glassBottle);
281 const produced = Math.min(wanted, bottles);
282 if (produced <= 0)
283 { throw userError("You need glass bottles to bottle the brew."); }
284
285 const takeBottles = takeMatchingFromSlots(inventory.slots, {
286 itemId: ItemId.glassBottle,
287 quantity: produced,
288 compact: false
289 });
290 if (!takeBottles.ok)
291 { throw userError("You need glass bottles to bottle the brew."); }
292 inventory.slots = takeBottles.slots;
293
294 const instance = potionItemInstance(evaluation.result);
295 const potionDef = itemDefinition(ItemId.potion);
296 const inserted = insertStack(inventory.slots, {
297 itemId: ItemId.potion,
298 quantity: produced,
299 instance
300 }, potionDef);
301 if (!inserted.ok)
302 {
303 const refund = insertStack(inventory.slots, {
304 itemId: ItemId.glassBottle,
305 quantity: produced
306 }, itemDefinition(ItemId.glassBottle));
307 inventory.slots = refund.ok ? refund.slots : inventory.slots;
308 throw userError("Not enough inventory space for potions.");
309 }
310 inventory.slots = inserted.slots;
311
312 session.lastSuccessRecipe = evaluation.success ? evaluation.recipe : null;
313 clearBrew(session);
314
315 return {
316 events: [],
317 private: bagView(world.ecs, handle),
318 cauldron: true,
319 cauldronState: sessionView(session),
320 alchemyResult: {
321 success: !!evaluation.success,
322 reason: evaluation.reason ?? null,
323 produced,
324 wanted,
325 lost: Math.max(0, wanted - produced),
326 potion: {
327 potionKey: instance.potionKey,
328 displayName: instance.displayName,
329 unstable: instance.unstable,
330 color: instance.color,
331 fillLevel: instance.fillLevel
332 }
333 }
334 };
335}
336
337function clear (world, sessionId, command)
338{
339 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
340 requireNearCauldron(world, handle);
341 const session = requireSession(world, command.characterId);
342 clearBrew(session);
343 session.lastSuccessRecipe = null;
344 return {
345 events: [],
346 private: bagView(world.ecs, handle),
347 cauldron: true,
348 cauldronState: sessionView(session)
349 };
350}
351
352function saveRecipe (world, sessionId, command)
353{
354 const { handle } = world.requireOwnedEntity(sessionId, command.characterId);
355 requireNearCauldron(world, handle);
356 const session = requireSession(world, command.characterId);
357 const recipe = session.lastSuccessRecipe;
358 if (!recipe)
359 { throw userError("No successful recipe to save."); }
360
361 const inventory = ensureInventory(world, handle);
362 const paperIndex = inventory.slots.findIndex((slot) => slot?.itemId === ItemId.paper);
363 if (paperIndex < 0)
364 { throw userError("You need a sheet of paper."); }
365
366 const paperSlot = inventory.slots[paperIndex];
367 const recipeStack = {
368 itemId: ItemId.recipePaper,
369 quantity: 1,
370 instance: {
371 kind: "recipe-paper",
372 recipeId: randomUUID(),
373 potionKey: recipe.potionKey,
374 displayName: `${recipe.displayName} recipe`,
375 minAlchemyLevel: recipe.minAlchemyLevel ?? 1,
376 body: recipePaperBody(recipe),
377 writtenAt: Date.now()
378 }
379 };
380
381 if (stackQuantity(paperSlot.quantity) <= 1)
382 { inventory.slots[paperIndex] = recipeStack; }
383 else
384 {
385 const free = inventory.slots.findIndex((entry) => !entry);
386 if (free < 0)
387 { throw userError("Need a free inventory slot for the recipe paper."); }
388 paperSlot.quantity -= 1;
389 inventory.slots[free] = recipeStack;
390 }
391
392 session.lastSuccessRecipe = null;
393 return {
394 events: [],
395 private: bagView(world.ecs, handle),
396 cauldron: true,
397 cauldronState: sessionView(session)
398 };
399}