import { Component } from "../ecs/components.js"; import { BlockType } from "../../../shared/definitions/tiles.js"; import { AlchemyStepKind, CAULDRON_SLOT_COUNT } from "../../../shared/definitions/alchemy.js"; import { ItemId, itemDefinition } from "../../../shared/definitions/items.js"; import { evaluateAlchemyBottle, potionItemInstance, recipePaperBody, resolvedAlchemyPotions } from "../../../shared/alchemy/recipes.js"; import { dyeItemInstance, DEFAULT_DYE_FILL, mixDyeBatches } from "../../../shared/definitions/dyes.js"; import { bagView } from "../items/bags.js"; import { countItemInSlots, emptySlots, insertStack, normalizeInventorySlots, takeMatchingFromSlots, stackQuantity } from "../../../shared/items/inventory.js"; import { tileToChunk, tileToLocal } from "../world/coordinates.js"; import { CHUNK_SIZE } from "../../../shared/protocol/constants.js"; import { randomUUID } from "node:crypto"; import { tileShoveTowardBlock } from "../simulation/tileInteract.js"; /** * Cauldron sessions live on the worker world (per character while the UI is open). * Clients send intents only; all brew outcomes are evaluated here. */ function userError (message) { const error = new Error(message); error.userFacing = true; return error; } function ensureSessions (world) { if (!world.cauldronSessions) { world.cauldronSessions = new Map(); } return world.cauldronSessions; } function emptySession () { return { slots: Array.from({ length: CAULDRON_SLOT_COUNT }, () => null), brew: [], steps: [], lastSuccessRecipe: null }; } function sessionView (session) { return { slots: (session.slots ?? []).map((slot) => (slot ? { itemId: slot.itemId, quantity: slot.quantity | 0 } : null)), brew: (session.brew ?? []).map((row) => ({ itemId: row.itemId, quantity: row.quantity | 0 })), steps: (session.steps ?? []).map((step) => ({ ...step })), canSaveRecipe: !!session.lastSuccessRecipe, lastSuccess: session.lastSuccessRecipe ? { potionKey: session.lastSuccessRecipe.potionKey, displayName: session.lastSuccessRecipe.displayName, minAlchemyLevel: session.lastSuccessRecipe.minAlchemyLevel ?? 1 } : null }; } function nearCauldron (world, tileX, tileY) { for (let dy = -1; dy <= 1; dy++) { for (let dx = -1; dx <= 1; dx++) { const data = world.chunkData(tileToChunk(tileX + dx), tileToChunk(tileY + dy)); const index = tileToLocal(tileY + dy) * CHUNK_SIZE + tileToLocal(tileX + dx); if (data.blocks[index]?.typeId === BlockType.cauldron) { return true; } } } return false; } function requireNearCauldron (world, handle) { const position = world.ecs.get(handle, Component.position); if (!nearCauldron(world, position.tileX, position.tileY)) { throw userError("Stand next to a cauldron."); } } function requireSession (world, characterId) { const session = ensureSessions(world).get(characterId); if (!session) { throw userError("Open a cauldron first."); } return session; } function clearBrew (session) { session.slots = Array.from({ length: CAULDRON_SLOT_COUNT }, () => null); session.brew = []; session.steps = []; } function ensureInventory (world, handle) { let inventory = world.ecs.get(handle, Component.inventory); if (!inventory) { inventory = world.ecs.add(handle, Component.inventory, { slots: emptySlots() }); } inventory.slots = normalizeInventorySlots(inventory.slots ?? emptySlots()); return inventory; } export function handleAlchemyCommand (world, sessionId, command) { switch (command.type) { case "open-cauldron": return openCauldron(world, sessionId, command); case "cauldron-set-slot": return setSlot(world, sessionId, command); case "cauldron-insert": return insertFromSlot(world, sessionId, command); case "cauldron-action": return action(world, sessionId, command); case "cauldron-bottle": return bottle(world, sessionId, command); case "cauldron-clear": return clear(world, sessionId, command); case "cauldron-save-recipe": return saveRecipe(world, sessionId, command); case "cauldron-close": return closeCauldron(world, sessionId, command); default: return null; } } function openCauldron (world, sessionId, command) { const { handle, entityId } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const sessions = ensureSessions(world); const existing = sessions.get(command.characterId) ?? emptySession(); sessions.set(command.characterId, existing); const shove = tileShoveTowardBlock(world, handle, entityId, BlockType.cauldron); return { events: shove ? [shove] : [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(existing) }; } function closeCauldron (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); ensureSessions(world).delete(command.characterId); return { events: [], private: bagView(world.ecs, handle), cauldron: false }; } function setSlot (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const session = requireSession(world, command.characterId); const slotIndex = command.slotIndex | 0; if (slotIndex < 0 || slotIndex >= CAULDRON_SLOT_COUNT) { throw userError("Invalid cauldron slot."); } const itemId = command.itemId | 0; const quantity = Math.max(0, command.quantity | 0); if (!itemId || quantity <= 0) { session.slots[slotIndex] = null; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session) }; } const def = itemDefinition(itemId); if (!def || def.uniqueInstance || def.equipment || itemId === ItemId.potion || itemId === ItemId.glassBottle) { throw userError("That cannot go in a cauldron slot."); } if (itemId === ItemId.dye || itemId === ItemId.flower) { // Allowed — instances are captured on insert. } else if (def.dye || def.flower) { /* ok */ } const inventory = ensureInventory(world, handle); let instance = null; if (itemId === ItemId.flower || itemId === ItemId.dye) { const wanted = command.instance ? structuredClone(command.instance) : null; if (wanted) { instance = wanted; } else { for (const slot of inventory.slots) { if (slot?.itemId === itemId && slot.instance) { instance = structuredClone(slot.instance); break; } } } if (!instance && itemId === ItemId.flower) { throw userError("That flower has no colour."); } if (!instance && itemId === ItemId.dye) { throw userError("That dye has no colour."); } const have = countMatchingInstance(inventory.slots, itemId, instance); if (have < quantity) { throw userError("Not enough of that item in your inventory."); } } else { const have = countItemInSlots(inventory.slots, itemId); if (have < quantity) { throw userError("Not enough of that item in your inventory."); } } session.slots[slotIndex] = { itemId, quantity, instance }; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session) }; } function insertFromSlot (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const session = requireSession(world, command.characterId); const slotIndex = command.slotIndex | 0; const reserved = session.slots[slotIndex]; if (!reserved) { throw userError("That cauldron slot is empty."); } const inventory = ensureInventory(world, handle); const pulled = takeMatchingFromSlots(inventory.slots, { itemId: reserved.itemId, quantity: reserved.quantity, instance: reserved.instance ?? null, compact: false }); if (!pulled.ok) { throw userError("Not enough of that item in your inventory."); } inventory.slots = pulled.slots; session.slots[slotIndex] = null; const brewRow = { itemId: reserved.itemId, quantity: reserved.quantity, instance: reserved.instance ? structuredClone(reserved.instance) : (pulled.taken?.instance ? structuredClone(pulled.taken.instance) : null) }; const existing = session.brew.find((row) => row.itemId === brewRow.itemId && JSON.stringify(row.instance ?? null) === JSON.stringify(brewRow.instance ?? null)); if (existing) { existing.quantity += brewRow.quantity; } else { session.brew.push(brewRow); } session.steps.push({ kind: AlchemyStepKind.insert, itemId: reserved.itemId }); session.lastSuccessRecipe = null; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session) }; } function action (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const session = requireSession(world, command.characterId); const kind = command.action; if (kind !== AlchemyStepKind.stir && kind !== AlchemyStepKind.heat && kind !== AlchemyStepKind.cool) { throw userError("Unknown cauldron action."); } session.steps.push({ kind }); session.lastSuccessRecipe = null; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session) }; } function bottle (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const session = requireSession(world, command.characterId); if (!(session.brew?.length > 0) && !(session.steps?.length > 0)) { throw userError("The cauldron is empty."); } const inventory = ensureInventory(world, handle); const dyePath = evaluateDyeBrew(session.brew); if (dyePath) { if (!dyePath.ok) { throw userError(dyePath.reason); } return bottleDyeResult(world, handle, session, inventory, dyePath); } const skills = world.ecs.get(handle, Component.skills) ?? {}; const evaluation = evaluateAlchemyBottle({ skills, brewStacks: session.brew, takenSteps: session.steps, potions: resolvedAlchemyPotions() }); const wanted = Math.max(1, evaluation.batch | 0); const bottles = countItemInSlots(inventory.slots, ItemId.glassBottle); const produced = Math.min(wanted, bottles); if (produced <= 0) { throw userError("You need glass bottles to bottle the brew."); } const takeBottles = takeMatchingFromSlots(inventory.slots, { itemId: ItemId.glassBottle, quantity: produced, compact: false }); if (!takeBottles.ok) { throw userError("You need glass bottles to bottle the brew."); } inventory.slots = takeBottles.slots; const instance = potionItemInstance(evaluation.result); const potionDef = itemDefinition(ItemId.potion); const inserted = insertStack(inventory.slots, { itemId: ItemId.potion, quantity: produced, instance }, potionDef); if (!inserted.ok) { const refund = insertStack(inventory.slots, { itemId: ItemId.glassBottle, quantity: produced }, itemDefinition(ItemId.glassBottle)); inventory.slots = refund.ok ? refund.slots : inventory.slots; throw userError("Not enough inventory space for potions."); } inventory.slots = inserted.slots; session.lastSuccessRecipe = evaluation.success ? evaluation.recipe : null; clearBrew(session); return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session), alchemyResult: { success: !!evaluation.success, reason: evaluation.reason ?? null, produced, wanted, lost: Math.max(0, wanted - produced), potion: { potionKey: instance.potionKey, displayName: instance.displayName, unstable: instance.unstable, color: instance.color, fillLevel: instance.fillLevel } } }; } /** * @returns {null | { ok: false, reason: string } | { ok: true, mode: "flower"|"mix", ... }} */ function evaluateDyeBrew (brew) { const rows = brew ?? []; if (!rows.length) { return null; } const hasFlower = rows.some((row) => row.itemId === ItemId.flower); const hasDye = rows.some((row) => row.itemId === ItemId.dye); const hasOther = rows.some((row) => row.itemId !== ItemId.flower && row.itemId !== ItemId.dye); if (!hasFlower && !hasDye) { return null; } if (hasOther) { return { ok: false, reason: "Do not mix dyes or flowers with alchemy ingredients." }; } if (hasFlower && hasDye) { return { ok: false, reason: "Cannot mix flowers and dyes together." }; } if (hasFlower) { const colors = new Set(rows.map((row) => row.instance?.colorId).filter(Boolean)); if (colors.size === 0) { return { ok: false, reason: "Those flowers have no colour." }; } if (colors.size > 1) { return { ok: false, reason: "Use flowers of a single colour for dye." }; } const sample = rows.find((row) => row.instance?.color); const quantity = rows.reduce((sum, row) => sum + (row.quantity | 0), 0); return { ok: true, mode: "flower", quantity: Math.max(1, quantity), instance: dyeItemInstance(sample.instance.color, DEFAULT_DYE_FILL, sample.instance.colorId) }; } const mixed = mixDyeBatches(rows); if (!mixed.ok) { return { ok: false, reason: mixed.reason }; } return { ok: true, mode: "mix", ...mixed }; } function bottleDyeResult (world, handle, session, inventory, dyePath) { const outputs = dyePath.mode === "flower" ? Array.from({ length: dyePath.quantity }, () => ({ quantity: 1, instance: dyePath.instance })) : dyePath.outputs; // Flowers need empty glass bottles. Dye remixes reuse the bottles already // consumed into the brew; only overflow bottles need extra glass. const bottleNeed = dyePath.mode === "flower" ? outputs.length : Math.max(0, dyePath.extraBottles | 0); if (bottleNeed > 0) { const bottles = countItemInSlots(inventory.slots, ItemId.glassBottle); if (bottles < bottleNeed) { throw userError( `You need ${bottleNeed} glass bottle${bottleNeed === 1 ? "" : "s"}.` ); } const takeBottles = takeMatchingFromSlots(inventory.slots, { itemId: ItemId.glassBottle, quantity: bottleNeed, compact: false }); if (!takeBottles.ok) { throw userError("You need glass bottles to bottle the dye."); } inventory.slots = takeBottles.slots; } const dyeDef = itemDefinition(ItemId.dye); let slots = inventory.slots; for (const out of outputs) { const inserted = insertStack(slots, { itemId: ItemId.dye, quantity: out.quantity, instance: out.instance }, dyeDef); if (!inserted.ok) { throw userError("Not enough inventory space for dye."); } slots = inserted.slots; } inventory.slots = slots; session.lastSuccessRecipe = null; clearBrew(session); const sample = outputs[0]?.instance; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session), alchemyResult: { success: true, reason: null, produced: outputs.length, wanted: outputs.length, lost: 0, potion: { potionKey: "dye", displayName: "Dye", unstable: false, color: sample?.color ?? null, fillLevel: sample?.fillLevel ?? DEFAULT_DYE_FILL } } }; } function clear (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const session = requireSession(world, command.characterId); clearBrew(session); session.lastSuccessRecipe = null; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session) }; } function saveRecipe (world, sessionId, command) { const { handle } = world.requireOwnedEntity(sessionId, command.characterId); requireNearCauldron(world, handle); const session = requireSession(world, command.characterId); const recipe = session.lastSuccessRecipe; if (!recipe) { throw userError("No successful recipe to save."); } const inventory = ensureInventory(world, handle); const paperIndex = inventory.slots.findIndex((slot) => slot?.itemId === ItemId.paper); if (paperIndex < 0) { throw userError("You need a sheet of paper."); } const paperSlot = inventory.slots[paperIndex]; const recipeStack = { itemId: ItemId.recipePaper, quantity: 1, instance: { kind: "recipe-paper", recipeId: randomUUID(), potionKey: recipe.potionKey, displayName: `${recipe.displayName} recipe`, minAlchemyLevel: recipe.minAlchemyLevel ?? 1, body: recipePaperBody(recipe), writtenAt: Date.now() } }; if (stackQuantity(paperSlot.quantity) <= 1) { inventory.slots[paperIndex] = recipeStack; } else { const free = inventory.slots.findIndex((entry) => !entry); if (free < 0) { throw userError("Need a free inventory slot for the recipe paper."); } paperSlot.quantity -= 1; inventory.slots[free] = recipeStack; } session.lastSuccessRecipe = null; return { events: [], private: bagView(world.ecs, handle), cauldron: true, cauldronState: sessionView(session) }; } function countMatchingInstance (slots, itemId, instance) { let total = 0; const key = JSON.stringify(instance ?? null); for (const slot of slots ?? []) { if (!slot || slot.itemId !== itemId) { continue; } if (JSON.stringify(slot.instance ?? null) !== key) { continue; } total += stackQuantity(slot.quantity); } return total; }