Brewing, aging and intoxication

-- Each possible result of aging is a bell curve over time, tuned by a designer:
--   time  = when it peaks (minutes),  peak = how strong it gets,  sigma = how fast it falls off.
-- (Example values, not the live tuning.)
--   ["young_wine"] = { time = 20, peak = 0.75, sigma = 5 },
--   ["vinegar"]    = { time = 90, peak = 0.85, sigma = 8 },

function AgingBarrel.ComputeProbability(o, t)
    local sigma = o.sigma or 6
    local peak = o.peak or 1
    local d = t - o.time
    return peak * math.exp(-(d * d) / (2 * sigma * sigma))
end

-- The score of every result at time t, keyed by result.
function AgingBarrel.ComputeProbabilities(outcomes, t)
    local scores = {}
    for name, o in pairs(outcomes) do
        scores[name] = AgingBarrel.ComputeProbability(o, t)
    end
    return scores
end

-- Weighted roll over the scores. They don't need to sum to 1.
function AgingBarrel.Roll(probs)
    local total = 0
    for _, p in pairs(probs) do
        total = total + p
    end
    local roll = math.Rand(0, total)

    local cumulative = 0
    local bestName, bestP = nil, -1
    for name, p in pairs(probs) do
        cumulative = cumulative + p
        if p > bestP then bestName, bestP = name, p end
        if roll <= cumulative then
            return name
        end
    end

    -- Floating-point safety net: fall back to the most likely result.
    return bestName
end

function AgingBarrel.ResolveOutcome(config, t)
    return AgingBarrel.Roll(AgingBarrel.ComputeProbabilities(config, t))
end

-- The client sends only the cask's item ID. Everything else is checked
-- and decided here, on the server.
net.Receive("nutBrewingCaskSeal", function(_, ply)
    local cask = nut.item.instances[net.ReadUInt(32)]
    if (not cask or cask.uniqueID ~= "brewing_cask") then return reject(ply, "That isn't a brewing cask.") end

    local inv = cask:getInv()
    if (not inv) then return reject(ply, "That cask has no inventory.") end

    -- Only someone who currently has this cask open can seal it.
    if (not inv.currentUsers[ply]) then return reject(ply, "You aren't using this cask.") end

    -- Every ingredient must be valid and sit in one of the four slots.
    local items = {}
    for _, item in pairs(inv:getItems(true)) do
        local x, y = item:getData("x"), item:getData("y")
        if (not x or y ~= 1 or x < 1 or x > 4) then return reject(ply, "An ingredient is in an invalid slot.") end
        if (not PLUGIN:IsValidBrewingIngredient(item)) then return reject(ply, "That isn't a valid ingredient.") end
        items[x] = item
    end

    local base = table.remove(items, 1)   -- slot 1 is the base
    local additives = table.ClearKeys(items)
    if (not base) then return reject(ply, "You need a base ingredient to start brewing.") end

    -- The base defines the possible results. Additives add weight to results
    -- they share with it; an additive that shares nothing pushes toward the bad result.
    local results = table.Copy(PLUGIN.Data.Recipes[base.uniqueID])
    local bad = results._bad
    results._bad = nil

    for _, item in pairs(additives) do
        local shared = false
        for result, weight in pairs(PLUGIN.Data.Recipes[item.uniqueID]) do
            if (results[result]) then
                results[result] = results[result] + weight
                shared = true
            end
        end
        if (not shared) then
            results[bad] = (results[bad] or 0) + 1
        end
    end

    local outcome = weightedRoll(results)   -- same cumulative roll as the aging module
    if (not outcome) then return reject(ply, "Couldn't pick a result. Please report this.") end

    -- Clearing the users list closes the cask for everyone, so a second
    -- seal request fails the check above. Then the ingredients are consumed.
    inv.currentUsers = {}
    for _, item in pairs(inv:getItems(true)) do
        item:remove()
    end

    cask:setData("producing", true)
    local ent = cask.entity

    timer.Create("Brewing_" .. cask:getID(), PLUGIN.BrewingTime, 1, function()
        -- Re-check everything before paying out: the cask may have been
        -- picked up, deleted or already collected while we waited.
        if (not IsValid(ent) or cask.entity ~= ent or not nut.item.instances[cask:getID()]) then return end
        if (not cask:getData("producing") or cask:getData("collect")) then return end

        cask:setData("producing", nil)
        cask:setData("collect", outcome)
    end)

    -- ... sound, chat emote and closing the player's window omitted
end)