D100 Opposed Rolls

#!/usr/bin/env lua

-- Status code for a Fumble, defined variously in various rules.
local STATUS_FUMBLE <const>   = -1
-- Status code for an ordinary Failure, i.e. > skill and not a Fumble.
local STATUS_FAILURE <const>  = 0
-- Status code for an ordinary Success, i.e. <= skill and not a higher level.
local STATUS_SUCCESS <const>  = 1
-- Status code for a CoC "hard" success, i.e. <= skill/2
local STATUS_HARD <const>     = 2
-- Status code for a CoC "extreme" success, i.e. <= skill/5
local STATUS_EXTREME <const>  = 3
-- Status code for a BRP "special" success, i.e. <= skill/5
local STATUS_SPECIAL <const>  = 4
-- Status code for a critical success, defined variously in various rules.
local STATUS_CRITICAL <const> = 5

-- What level of success a roll of `p` indicates for a percentile `pct`
-- in Basic Roleplaying (2023)
local function success_level_brp(p, pct)
    if (p <= pct) then
        if p < math.ceil(p / 20) then
            return STATUS_CRITICAL
        elseif p < math.ceil(p / 5) then
            return STATUS_SPECIAL
        else
            return STATUS_SUCCESS
        end
    else
        local fumble = 100 - math.floor((100 - pct) / 20)
        if p == 100 or p >= fumble then
            return STATUS_FUMBLE
        end
        return STATUS_FAILURE
    end
end

-- Whether player wins on opposed rolls `p` vs `r`
-- with skills `player` vs. `resist`
-- in Basic Roleplaying (2023)
local function is_player_win_brp(p, r, player, resist)
    local pstat, rstat = 
        success_level_brp(p, player), 
        success_level_brp(r, resist)

    return pstat > rstat or (pstat == rstat and p >= r)
end

-- What level of success a roll of `p` indicates for a percentile `pct`
-- in Call of Cthulhu 7th Edition
local function success_level_coc7(p, pct) 
    if p == 100 then
        return STATUS_FUMBLE
    elseif p <= pct then
        if p == 1 then
            return STATUS_CRITICAL
        elseif p <= math.ceil(pct / 5) then
            return STATUS_HARD
        elseif p <= math.ceil(pct / 2) then
            return STATUS_EXTREME
        else
            return STATUS_SUCCESS
        end
    else
        if p >= 96 then
            return STATUS_FUMBLE
        else
            return STATUS_FAILURE
        end
    end
end

-- Whether player wins on opposed rolls `p` vs `r`
-- with skills `player` vs. `resist`
-- in Call of Cthulhu 7th Edition
local function is_player_win_coc7(p, r, player, resist)
    local pstat, rstat = 
        success_level_coc7(p, player), 
        success_level_coc7(r, resist)

    if pstat > rstat then
        return true
    elseif pstat == rstat then
        -- According to the CoC7 Quickstart p. 10,
        -- "In the case of a draw, the side with the higher
        -- skill value wins. If both skills are equal then have 
        -- both sides roll 1D100, with the lower result winning."
        if player > resist then
            return true
        elseif player == resist then
            -- Best approximation to random second roll.
            return (p + r) % 2 == 0
        end
    end
end

-- What level of success a roll of `p` indicates for a percentile `pct`
-- in Mythras
local function success_level_mythras(p, pct)
    if p >= 96 then
        -- 96 ... 100 is always a failure
        if p == 100 or (p == 99 and pct <= 100) then
            return STATUS_FUMBLE
        end
        return STATUS_FAILURE
    end

    if p <= pct or p <= 5 then
        -- 1 ... 5 is always a success
        if p <= math.ceil(pct / 10) then
            return STATUS_CRITICAL
        end
        return STATUS_SUCCESS
    else
        return STATUS_FAILURE
    end
end

-- Whether player wins on opposed rolls `p` vs `r`
-- with skills `player` vs. `resist`
-- in Mythras
local function is_player_win_mythras(p, r, player, resist)
    local pstat, rstat = 
        success_level_mythras(p, player), 
        success_level_mythras(r, resist)

    return pstat > rstat 
        or (pstat == rstat and pstat >= STATUS_SUCCESS and p >= r)
end

-- Whether the roll is a critical success or critical failure (fumble)
-- in OpenQuest 3rd edition.
local function is_oq3_crit(r)
    return r % 11 == 0 or r == 100
end

-- What level of success a roll of `p` indicates for a percentile `pct`
-- in OpenQuest 3rd edition.
local function success_level_oq3(p, pct)
    if p <= pct then
        if is_oq3_crit(p) then
            return STATUS_CRITICAL
        else
            return STATUS_SUCCESS
        end
    else
        if is_oq3_crit(p) then
            return STATUS_FUMBLE
        else
            return STATUS_FAILURE
        end
    end
end

-- Whether player wins on opposed rolls `p` vs `r`
-- with skills `player` vs. `resist`
-- in OpenQuest 3rd edition.
local function is_player_win_oq3(p, r, player, resist)
    local pstat, rstat = 
        success_level_oq3(p, player), 
        success_level_oq3(r, resist)

    if pstat > rstat then
        return true
    elseif pstat == rstat then
        if pstat >= STATUS_SUCCESS then
            return p >= r
        elseif pstat == STATUS_FAILURE then
            return p <= r
        end
        -- STATUS_FUMBLE is never a player win
    end
end

-- Figure out probabilities of opposed rolls through brute force
local function opposed_roll(player, resist, pfunc)
    local sum = 0
    for p = 1, 100 do
        for r = 1, 100 do
            if pfunc(p, r, player, resist) then
                sum = sum + 1
            end
        end
    end
    return sum/10000
end

local function format_header(min, max, step)
    local buf = { "", " Pl." }
    for i = min, max, step do
        table.insert(buf, string.format(" %5d ", i))
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function format_bar(min, max, step)
    local buf = { "", ":--:" }
    for i = min, max, step do
        table.insert(buf, "------:")
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function format_row(percent, results)
    local buf = { "", string.format("%3d ", percent), }
    for n = 1, #results do
        table.insert(buf, string.format("%5.1f%% ", results[n] * 100))
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function print_table(min, max, step)
    local RULES_LIST <const> = {
        {n = "Basic Roleplaying",  f = is_player_win_brp},
        {n = "Call of Cthulhu 7",  f = is_player_win_coc7},
        {n = "Mythras",            f = is_player_win_mythras},
        {n = "OpenQuest 3",        f = is_player_win_oq3},
    }

    for i, rules in ipairs(RULES_LIST) do
        print("###", rules.n, "###")

        print(format_header(min, max, step))
        print(format_bar(min, max, step))

        for p = min, max, step do
            local results = {}
            for r = min, max, step do
                table.insert(results, opposed_roll(p, r, rules.f))
            end
            print(format_row(p, results))
        end
    end
end

print_table(0, 100, 10)