OpenQuest: Toward A Ritual Magic System

If anyone besides me got anything out of “OpenQuest: Other Magic” it’s that I need to develop systems for Ritual Magic and Making Magic Stuff (Alchemy/Artificing/Herbology) ASAP. (Why, you ask?)

Luckily both have analogues in Barbarians of Lemuria’s Sorcery and Alchemy systems and Everywhen’s analogous Sorcery and Inventing systems. Problem solved, right?

Well, no.

Bol/EW use a roll-over die system, so it’s easy to express difficulty as a modifier to the roll. Since it’s a 2d6 system, every +1 to the Target Number or -1 to the roll reduces probabilities enormously.

On the other hand, OpenQuest can only reduce probabilities by adjusting the player’s percentile skill, and the rules suggest that only ±20% or ±50% are significant enough to make a difference. (Presumably ±70% or more is tantamount to saying the player has next to no chance.)

So we have to consider other methods.

Essence Dice

I’ll start with the solution I prefer: Essence Dice.

The Idea

This mechanic I stole from King Arthur Pendragon 4th Edition, which introduced magician player characters. (They were gone in 5th edition.) Magicians cast spells by summoning enough “life force”, their own and ambient force found more readily in nature and magical power spots. If they had enough life force for the effect they wanted, the spell worked. If they didn’t, either a lesser version of the spell took effect or it fizzled.

Mechanically, magicians collected a number of D20s’ worth of power, then rolled them. What happened depended on whether the total hit the right target number. Too little and their spell fizzled. More than enough might mean making the spell that much stronger.

The Probabilities

Naturally to explore this idea I wrote a Lua program to compute the probabilities of rolling a D2¹, D6, D10, and, yes, D20s. The result is below.

I chose the target numbers per “level” for all but the D2 so that the roll had a ≥50% of succeeding when the number of dice equalled the level. With D2, the 50% mark lies when the number of successes needed is equal to half the dice rolled rounded up.

An advantage of the D2 is that once can use any dice: d6s, d10s, d12s, d4s (if you like caltrops), even pulling cards from a deck and regarding all the blacks as 1 and all the reds as 0.

The Objections

I can think of a few objections to this mechanic:

1. PC skill becomes irrelevant.
2. That’s a lot of dice to roll (or cards to draw) …
3. That’s a lot of levels …

PC Skill

While I can appreciate that a PC’s abilities have no obvious connection to the number of “life force” dice they roll, the following additional rules may restore the PC’s relevance.

• The GM secretly rolls a check on the appropriate Religion, Lore, or other ritual magic skill to determine if the ritualist remembered the ritual accurately. The ritualist gets a +20% on his skill if he works from a clear, complete written account of the ritual, or +50% if it’s from their own² grimoire, while another’s messy grimoire could impose -20% or even -50%. Even with their own rituals they still could miss a detail or fail to understand the ritual’s nuances. Failure could mean the ritual doesn’t work as expected, and a Fumble means an unexpected guest …

• Ritual Magic depends on what we’ll call Channelling. The GM may choose Magic Casting as the Channelling skill under the One Magic system, Personal Magic under Personal Magic, Subtle Magic in Rurikania, or a new skill called Channelling equal to POW × 3%. It reflects the ritualist’s ability to channel their own life force. Remaining dice come from advanced planning and situational factors.

  The number of Essence Dice the ritualist themselves can contribute is equal to POW x Channelling / 400, rounding to the nearest whole number.³ The player may want to write that number down, and update it when they increase POW or Chanelling. (A chart solving for Channelling for values of POW and Essence Dice is left as an exercise for the reader.)

  Since the maximum human POW is 21, this means no more than five dice can dome from a human ritualist even if they raise both POW and skill to their maximums. Non-humans, demi-humans, and human subspecies may be better ritualists than baseline humans …

• Certain subtypes of Ritual Magic like Diabolism or Thaumaturgy may have additional skills reflecting their peculiar elaborations on the basic procedure. (I haven’t designed them yet.)

Totalling Dice

Another lingering question is whether players will want to throw handfuls of D6es, D10s, or (gulp) D20s whenever they cast a ritual spell, then total them all up. As my perverse admiration for Tunnels & Trolls demonstates, I have no problem, but others might.

The “D{0,1}” procedure seems ideal, since GMs can use whatever dice they have on hand or even playing cards. They need only count how many came out high, or even, or red (or was it black?) On the other hand, I specifically chose the target numbers for D6 and D10 (and D20) so that the “level” of a ritual equaled the number of dice needed for an approximate 50/50 chance, whereas the 50/50 chance for each level in D{0,1} is twice the level. I wanted as few “levels” as possible, but maybe D{0,1} would leave too few.

And on the third hand, I can’t see anyone but me using this system and I have literal hundreds of d6es and dozens of d10s. Plus I play over Discord a lot lately, so physical dice aren’t a problem.

Number of Levels

As I touched on earlier, I wanted a minimum of four levels corresponding to the four levels of Sorcery in Barbarians of Lemuria:

1. Cantrips, minor “special effects” with no ongoing story effect, e.g. cleaning the dirt off your robes, making obviously fake illusions.
2. Minor Magic, something a trained human could do with the right equipment, e.g. climb a wall, cause a brief distraction for the guards.
3. Major Magic, something beyond human ability, e.g. fly, create realistic illusions.
4. Catastrophic Magic that can change the entire campaign, e.g. cause a flood, permanently warp reality.

Because of the relationship between dice and levels, I thought I’d interpolate levels between the ones above.

However, the system I stole mine from – the ones that used D20s – used the following descriptors for its target numbers:

The fuzzy border between High and Grandiose is concerning, but assuming the writers actually tested the system and knew what they were doing, perhaps I need to keep about 26 levels or more, in five or six bands, like so:

If the number of dice goes past 5 I’ll simply add the average of remaining dice, e.g.

The Verdict

As the foregoing indicates I’m really pushing this idea.

1. Success of the ritual depends in part of the training of the player character and in part on the planning of the player.
2. The mechanic can handle subtle changes in difficulty that, for example, OpenQuest doesn’t and that other percentile systems struggle to without lots of math at the table. Here, the dice pool does the math; one just counts them up and compares them to a set of numbers.
3. Rolling lots of dice is fun.

Repeated Skill Rolls

Another idea I’ve seen involves making multiple skill rolls.

The Idea

d20 Incantations presents a system wherein non-spellcasters can cast ceremonial magic. (Sound familiar?) It has the following features:

1. Anyone can cast a spell written in an old book, if they can decipher the author’s prose.
2. The incantation’s description specifies how many skill checks the incantation requires, which skills, and in what order.
3. If someone performing an incantation fails one check, they can save their work by succeeding at a second check of the same skill.
4. If the second skill check fails, the incantation fails and the invoker usually suffers some sort of magical backlash.

Obviously making multiple skill checks would be annoying for ritual magic. The discussion below assumes a single series of checks on a single skill, probably some form of Religion or Lore. However, artificing might interleave checks of Lore (Artificing) and Craft to represent an artificer building magic into an artifact.

The Probabilities

Once again I wrote a Lua program to explore the idea. The table below crossreferences the base probability of a skill with the probability of casting it a number of times with one reroll in the event of failure.

The Verdict

As we see from the table above, the more skill rolls one adds, the less likely success becomes … until one hits a tipping point around 75%, where success percentages remain high despite the number of repetitions. By about 85%, the skill percentage remains as high or higher than the base percentage.

This implies that only a master should attempt anything with more than one or two skill rolls. To me this suggests a craftsman making a complicated object, and the Incantation description even likens Incantations to making a cake from a recipe.

These numbers raise the question of how one gets good at rituals if only a master can succeed. A craftsman can make easier works while learning from a master, or perhaps even perform part of the master’s work themselves. Depending how severe the magical backlash is, a novice might not survive to become a master.

A mechanic that assumes player characters have to be experts in order to succeed means that most players will not use it. (Except for the masters, the crazies, and the masochists.) There’s also something inherently masochistic about rolling the same skill three or four or seven or ten times to cast a spell, particularly on d100. On a d20 one can roll that many d20s simultaneously, then reroll the ones that miss; even one missed reroll means the procedure failed somewhere along the way. One could devise a procedure using multiple d10s but it might get messy. And if we’re rolling multiple d10s …

Opposed Skill Rolls

Yet another mechanic could represent some force actively fighting against the spell.

The Idea

When someone attempts ritual magic, the spell fights back. This is represented by an opposed roll between the ritualist’s relevant ritual magic skill and a “skill” percentage attached to the spell. This could be a constant or variable depending on time of year, material components present or absent, place, time of day, etc.

The Probabilities

Yet again I wrote a Lua program to explore the idea. The column marked “Pl.” represents a player character’s skill, and the header row represent’s the resisting or opposing skill.

Note that the diagonal has a ≥50% chance of success. The OpenQuest rules let the player win if there’s an unresolvable tie.

The Verdict

Years ago I created a similar but messier program for Call of Cthulhu 7 when it replaced its venerable “resistance table” with opposed rolls. I also wrote a program for HeroQuest which had the same tiers of success and similar opposed roll rules. So I pretty much knew what to expect.

The tiebreaker when both parties lose surprised me a little; I’m not sure why the lower failed die would win, as that gives the edge to lower skill. Maybe the idea is that it’s further from that dreaded fumble number 00 (100). I was also surprised that, unlike my CoC7 table, the increase of success percentages with higher skill isn’t quite so sharp, although it appears nonlinear to me. (Haven’t tried to graph the curves.)

Still, the method itself implies I should assign resistances based on what skill level should have a 50/50 chance of successfully performing it. (“You must be this skilled to use this ritual.”) That there’s a simple halfway point, like in the first method, is a plus. But even if I use only multiples of 10%, that’s 10 levels of difficulty, which is about three to four more than I really wanted.

This table provides good information when assigning Persistence scores to summoned creatures and resistances in similar situations. As a primary mechanic for rituals, though, opposed rolls just leave me (clatter of two sets of dice) cold.

Conclusions

Really all three systems would make for an interesting Ritual Magic system.

1. Much like the gold standard Sorcery system from Barbarians of Lemuria the “Essence Dice” system encourages the player to creatively gather more power. Cast the spell at an intersection of ley lines? Wait for an auspicious day? Quest for a relic that yields Essence Dice? It’s more than just rolling a skill number and seeing what the dice say. It’s rolling a whole lot of dice and seeing what they say.

2. The Incantation-style system creates an incentive to practice with small rituals and study one’s Religion or Lore. Rituals are for priests, “loremasters”, and others with high enough skills to perform them reliably. Which is a shame; why build a system that only matters in the end game (if it ever comes)?

3. The table of opposed rolls in OpenQuest turned out less skewed than I assumed it would. Still, opposed rolls create a system of rituals marked by the skill level required to have a 50/50 chance of performing them correctly. Since skills have a cap at 100% rituals have an upper limit to their power.

   Essence Dice have no upper limit, so a good roll could yield more power than the ritualist knows what to do with. Just saying.

Ultimately I’ll have to go with my biases and start with the first system: Essence Dice. The system encourages player ingenuity, has no upper limit, ahd can have unpredictable effects if they yield too much or too little power.

Appendix A: Why Ritual Magic?

Consider the following scenes:

• A bunch of kids find an old book bound in “leather” with a horrific face worked into the front cover. They decide to read it. Aloud. A demon appears.

• A man who left childhood far behind chants in black robes before an octagram. The octagram has been inlaid in the granite floor with blue tile and silver inlay; mystic symbols around and inside the octagram gltter strangely. Suddenly the silver shines with white light … as does the smaller triangle in which the summoner stands. A demon erupts from the octagram and bellows in rage. The summoner smiles grimly and proposes a bargain …

• A wizard stands atop a cliff, arms outstretched. Before him two armies clash. As he finishes his chant a mysterious mist sweeps through the battlefield.

• The magician Arnaud du Lac needs a healing spell for his wife, so he goes to see his good friend Bors Halfhand. “You’ll cast the spell, right?” Arnaud asks anxiously.

  Arnaud pulls a huge tome from a dusty shelf. “My researches are in a delicate stage.”

  “But –”

  “You’ll cast the spell, my friend.” Bors opens the book to a page that’s surprisingly in plain Latin. “The instructions are in here. They’re all in here.”

All four of these vignettes revolve around ritual magic. Rituals are slower and harder to cast than the spells magicians normally cast, but they have a few advantages:

1. One need not have the spell memorized (or burned into one’s brain). Simply read the instructions, understand the assumptions behind the terminology and symbolism, and use the the words, actions, and material components.

2. Unlike scrolls, one can use the same pages again and again. The power rests in the ceremony and performer(s), not the parchment.

3. Rituals can command far more power than ordinary spells … if one chooses the time, location, and circumstances wisely.

4. Nevertheless, anyone who understands the ritual can perform the ritual. Successfully? That’s another matter. Some (like the demon who left his book lying around) are too easy to perform, others like are difficult for a reason, and many are easier once they’re shorn of ciphers, codes, and a mad wizard’s ramblings.

5. From a game perspective, ritual magic needs fewer checks and balances. It’s not something you use in the dungeon to slay orcs; it won’t immediately let you take over the city or rake in gold. It’s more like the magic system in Call of Cthulhu: it’s what player characters indulge in between adventures, and it’s how they can screw themselves over if they’re not careful.

So that’s why I’ve been trying to write a Ritual Magic or Ceremonial Magic system for years, and why I’m using OpenQuest to test out some ideas.

Appendix B: Essence Dice Probability Program

Astute readers will note that I cannibalized several functions from a previous program.

#!/usr/bin/env lua

local function target(nsides, level)
    if level % 2 == 0 then
        return (nsides + 1) * level // 2
    else
        return (nsides + 1) * (level - 1) // 2 + (nsides // 2) + 1
    end
end

local CACHE = {}

--[[
-- Chance that a roll of `ndice`D`nsides` == `target`
]]--
local function p_roll_eq(ndice, nsides, target)
    if ndice == 1 then
        if target >= 1 and target <= nsides then
            return (1/nsides)
        end
    elseif target >= ndice and target <= ndice * nsides then
        local key = string.format("%02d\t%02d\t%02d", ndice, nsides, target)
        local result = CACHE[key]
        if result then
            return result
        end

        -- sum(1, nsides, p(one die is i) * p(remaining dice == target - i))
        local sum = 0.0
        for i = 1, nsides do
            sum = sum + p_roll_eq(1, nsides, i) 
                            * p_roll_eq(ndice - 1, nsides, target - i)
        end
        CACHE[key] = sum
        return sum
    end
    return 0.0
end

--[[
-- Chance that a roll of `ndice` D `nsides` >= `target`
]]--
local function p_roll_ge(ndice, nsides, target)
    local sum = 0.0
    for t = target, nsides * ndice do
        sum = sum + p_roll_eq(ndice, nsides, t)
    end
    return sum
end

-- choose function
local function choose(n, k)
    if n < 1 or k < 0 or k > n then
        return 0
    end

    local result = 1
    for i = 1, k do
        result = result * (n + 1 - i) / i
    end
    return result
end

-- binomial probability
local function binomial(n, k, p)
    return choose(n, k) * (p)^k * (1-p)^(n-k)
end

-- chance of rolling at least `k` successes on `n` dice
-- with probability `p`
local function success_at_least(n, k, p)
    if k <= 0 then
        return 1.0
    end

    if k == 1 then
        return 1 - (1 - p)^n
    end

    local result = 0
    for i = k, n do
        result = result + binomial(n, i, p)
    end
    return result
end

local function format_header(ndice)
    local buf = { "", "Lvl", " TN " }
    for n = 1, ndice do
        table.insert(buf, string.format(" %6dD ", n))
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function format_bar(high)
    local buf = { "", ":-:", ":--:" }
    for n = 1, high do
        table.insert(buf, "--------:")
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function format_row(level, target, results)
    local buf = { "", 
        string.format("%2d ", level),
        string.format("%3d ", target),
    }
    for n = 1, #results do
        if results[n] == 0.0 then
            table.insert(buf, string.rep(' ', 9))
        else
            table.insert(buf, string.format(" %6.2f%% ", results[n] * 100))
        end
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function print_table(levels, maxdice)
    print(format_header(maxdice))
    print(format_bar(maxdice))

    -- Dice with 2 sides
    print("| ***D{0,1}***")
    for n = 1, maxdice do
        local t = n
        local result = {}
        for d = 1, maxdice do
            result[d] = success_at_least(d, t, 0.5)
        end
        print(format_row(n, t, result))
    end

    -- Dice with > 2 sides
    local DICE <const> = { 6, 10, 20 }

    for i, s in ipairs(DICE) do
        print(string.format("| ***D%d***", s))
        for n = 1, levels do
            local t = target(s, n)
            local result = {}
            for d = 1, maxdice do
                result[d] = p_roll_ge(d, s, t)
            end
            print(format_row(n, t, result))
        end
    end
end

print_table(12, 7)

--[[
for k, v in pairs(CACHE) do
    print(k, v)
end
]]--

Appendix C: Repeated Skill Rolls Probability Program

Astute readers will note that I cannibalized several functions from a previous program.

#!/usr/bin/env lua

-- choose function
local function choose(n, k)
    if n < 1 or k < 0 or k > n then
        return 0
    end

    local result = 1
    for i = 1, k do
        result = result * (n + 1 - i) / i
    end
    return result
end

-- binomial probability
local function binomial(n, k, p)
    return choose(n, k) * (p)^k * (1-p)^(n-k)
end

-- chance of rolling at least `k` successes on `n` dice
-- with probability `p`
local function success_at_least(n, k, p)
    if k <= 0 then
        return 1.0
    end

    if k == 1 then
        return 1 - (1 - p)^n
    end

    local result = 0
    for i = k, n do
        result = result + binomial(n, i, p)
    end
    return result
end

-- chance of rolling at least `k` successes on `n` dice with reroll
-- with probability `p`
local function reroll_success_at_least(n, k, p)
    local result = success_at_least(n, k, p)
    -- only `j` successes from first roll
    for j = 0, k-1 do
        local first = binomial(n, j, p)
        result = result + first * success_at_least(n-j, k-j, p)
    end
    return result
end

local function format_header(nrolls)
    local buf = { "", " %  " }
    for n = 1, nrolls do
        table.insert(buf, string.format(" x%-6d ", n))
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function format_bar(nrolls)
    local buf = { "", ":--:" }
    for n = 1, nrolls 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
        if results[n] == 0.0 then
            table.insert(buf, string.rep(' ', 9))
        else
            table.insert(buf, string.format(" %6.2f%% ", results[n] * 100))
        end
    end
    table.insert(buf, "")
    return table.concat(buf, "|")
end

local function print_table(maxrolls)
    print(format_header(maxrolls))
    print(format_bar(maxrolls))

    for pct = 5, 100, 5 do
        local result = {}
        for n = 1, maxrolls do
            result[n] = reroll_success_at_least(n, n, pct/100)
        end
        print(format_row(pct, result))
    end
end

print_table(7)

Appendix D: Opposed Skill Probability Program

I meant to calculate probabilities analytically. I really did. However the tie resolution procedure defeated my weak probability-fu, so I had to use brute force methods. At least I only had 10,000 possibilities per probability and Lua is amazingly fast for a scripting language.

#!/usr/bin/env lua

--
-- According to OpenQuest 3rd edition (pp 40-41):
-- "If both characters succeed, then whoever rolled the highest 
-- in their skill test wins the opposed test.
-- If one character rolls a critical, while the other rolls an 
-- ordinary success, then the character that rolled the critical, 
-- which is a higher level of success, wins."
-- ... "[If both characters fail,]
-- [w]hoever rolled the lowest in their skill test wins the opposed test. 
-- In the case of ties for both the player wins."
--
-- HOWEVER:
-- A chart on page 44 of _SimpleQuest_ implies that he who fumbles
-- (crit-fails) loses.  If both sides fumble, both lose.
--

-- Whether the roll is a critical success or critical failure (fumble).
local function is_crit(r)
    return r % 11 == 0 or r == 100
end

-- Whether player wins on opposed rolls `p` vs `r`
-- with skills `player` vs. `resist`
local function is_player_win(p, r, player, resist)
    -- TODO: This logic is in no way optimized
    -- I was aiming for clarity and completeness
    -- at the expense of efficiency.

    if p <= player and r > resist then
        -- player succeeded, resist failed
        return true
    elseif p <= player and r <= resist then
        -- both succeeded
        local pcrit, rcrit = is_crit(p), is_crit(r)
        if pcrit and not rcrit then
            -- only player has p critical success
            return true
        elseif pcrit == rcrit then
            -- neither or both have critical successes
            if p >= r then
               -- player's roll is higher
               return true
            end
        end
    elseif p > player and r > resist then
        -- both failed
        local pfumb, rfumb = is_crit(p), is_crit(r)
        if not pfumb then
            -- player didn't fumble
            if rfumb or p <= r then
                -- resist fumbled
                -- or player's dice are equal or lower
                return true
            end
        end
    end -- big if
    return false
end

-- Figure out probabilities of opposed rolls through brute force
local function opposed_roll(player, resist)
    local sum = 0
    for p = 1, 100 do
        for r = 1, 100 do
            if is_player_win(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)
    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))
        end
        print(format_row(p, results))
    end
end

print_table(0, 100, 10)