Toward a Ritual Magic System, Part 3: Lore Redux and Ritual Procedure

Lore Revisited

Last time I defined Lore thus:

Lore is a measure of how much the character understands the working of magic. It’s stated in the same terms as a system’s skills: percentiles in D100, modifiers to a d20 roll in d20, a number of dice in dice pool systems, etc.

After some thought I decided I’d rather have a system-independent definition of Lore to match the system-independent definition of Essence.

Lore is independent of what host system skills a magician uses to translate a ritual from Ancient Illyrian or whatever. It’s the ability to see beyond the details of the ritual to its fundamentals, and perform only what’s necessary.

Since I settled on d6es for Essence, I’ve decided the mechanic for deciphering and understanding a Ritual will be as follows:

0. If the character has never performed a ritual before, their Lore always starts at 0. The lists of Known Rituals, Used Rituals, and Unknown Rituals start off empty.
1. The character has a starting dice pool equal to their Lore.
   • Subtract two dice if they are inventing a ritual from scratch.
   • Subtract one die if they are attempting to modify a ritual.
   • Subtract one die if the ritual was translated from a language the ritualist does not know well.
   • Subtract one die if the ritual isn’t part of the character’s Tradition, as noted by the spell or decided by the GM.
   • Add one die if they have deciphered this ritual before.
   • Add two dice if they have successfully performed this ritual before.
2. If the dice pool is 0 the player rolls two dice; the result is the lower die. Otherwise the player rolls the dice pool; the result is the highest die.
3. The result of the Lore check must be equal or greater to the Ritual Difficulty, a number from 1 (Trivial) to 6 (Very Difficult).
   • If the Ritual Difficulty is 1, no roll need be made; it succeeds automatically.
4. If the Lore Check succeeds, the character may add the Ritual to their list of Known Rituals. If it fails, the character adds that ritual to their list of Unknown Rituals. They may not attempt to decipher that particular ritual again until their Lore increases.
5. At the end of each session in which the Ritualist performs a Lore Check, whether it succeeds or fails, the player may rolls their most difficult Lore Check again. If the Check fails, the character’s Lore increases by one. They also remove all Rituals from the set of Unknown Rituals.
   • From this it follows that Lore increases more quickly from trying to decipher difficult rituals, as often as possible.

Optional Rule: Recording and Memorizing Rituals

Under the rules above, once a character deciphers a ritual, they know it forever. Here we consider whether the ritual is recorded and/or memorized.

• A character may translate a ritual from its original source to their own spellbook, Book of Shadows, etc. Doing so requires only time, ink, and paper.
• A character may cast a ritual from their own notes without making a Lore Check.
  • Many ritual magicians keep small chapbooks with one ritual each instead of or in addition to large tomes full of rituals. The latter may be written in a form of code which must first be broken using mundane skills.
• A character may also memorize a single ritual with no difficulty. To remember additional rituals, the character must make a Lore Check. Failure to remember the ritual means returning to either the original source (requiring a Lore Check to re-decipher it) or one’s own notes (which requires no check).

Performing a Ritual

The procedure for handling Ritual Magic in a game using these rules is this:

1. The Ritual Leader assembles any required Assistants, implements, and Offerings at an appointed place and time.
   • Assistants are co-celebrants who lend their Essence to the Ritual.
   • Implements are tools or components that are not consumed during the Ritual.
   • Offerings are components that are consumed, or at least transformed, during the ritual. They may be raw materials, finished goods, animal sacrifices, or in the darkest rituals human sacrifices.
2. The Leader begins the ritual, with Assistants joining in as required.
3. If a Offering is required, the Offering is made at the end of the Ritual.
4. The Leader’s player collects a pool of d6s by adding the following:
   • The Leader’s Essence
   • The Assistants’ Essence
   • Essence derived from the Time and Place.
   • Essence derived from any Relics present.
   • Essence derived from the Offering(s).
5. The Essence Pool loses one die for every repeated attempt at a ritual until all Ritualists get a full night’s sleep. Certain other influence, such as ritual contamination, may subtract from the die pool.
6. The player rolls all Essence Dice and compares the total to the ritual’s Essence Threshold(s). The total must equal or exceed the (highest) threshold in order to get the corresponding effect. If the total falls under the (lowest) Threshold, the ritual failed.
   • If the player does not want to roll a large number of dice, they may subtract pairs of dice and add 7 to the Essence Total for each pair. The player must still roll at least five dice unless the Total already exceeds the threshold for the desired effect.
7. The ritual has the effects determined by the Essence Total.

Next Time

In the next segment we will drill down into the game description of a ritual, and some sample rituals that nearly every ritual magician would know.

Appendix A: Lore Check vs. Ritual Difficulty

Below are the probabilities of beating each Ritual Difficulty by number of Lore dice.

Difficulty 1 rituals always have a 100% chance of being deciphered.

Appendix B: Essence Check vs. Essence Threshold

Below are the probabilities of succeeding at a specific Threshold (TN) with a number of Essence Dice. This will prove useful when we begin defining Ritual Thresholds next time.

Note that instead of using Thresholds that are multiples of 3.5 rounded up, I decided to use a straight 3.

Appendix C: Program for Lore Checks

Generator for this table.

#!/usr/bin/env lua

local NSIDES = 6

-- Chance of rolling `t` or better on one die 
local function success_1(t)
    if t <= 1 then
        return 1.0
    elseif t > NSIDES then
        return 0.0
    else
        return (NSIDES + 1 - t) / NSIDES
    end
end

-- Chances of rolling `t` or better on `n` 6-sided dice.
local function success(n, t)
    local p = success_1(t)
    if n < 1 then
        -- Special rule for dice pool <= 0:
        -- roll 2 dice, get `t` or higher on BOTH
        return p * p
    else
        return 1 - (1 - p)^n
    end
end

local function format_col(t)
    return string.format(" %-7d ", t)
end

local function format_percent(p)
    if p == 0 then
        return string.rep(" ", 9)
    end
    return string.format(" %6.2f%% ", p * 100)
end

local function print_header()
    local rowbuf

    rowbuf = { "Dice " }

    for t = 2,NSIDES do
        table.insert(rowbuf, format_col(t))
    end

    table.insert(rowbuf, "")
    print(table.concat(rowbuf, '|'))

    rowbuf = { ":---:" }
    for t = 2,NSIDES do
        table.insert(rowbuf, "--------:")
    end

    table.insert(rowbuf, "")
    print(table.concat(rowbuf, '|'))
end

local function print_row(n)
    local rowbuf = { string.format(" %2dd ", n) }

    for t = 2,NSIDES do
        table.insert(rowbuf, format_percent(success(n,t)))
    end

    table.insert(rowbuf, "")
    print(table.concat(rowbuf, '|'))
end

local function print_table(maxdice)
    local md = (maxdice or 10)

    print_header()

    for n = 0, md do
       print_row(n)
    end
end

print_table(12)

Appendix D: Program for Essence Checks

Generator for this table.

Modified from an earlier version.

#!/usr/bin/env lua

local NSIDES  <const> = 6
local MAXDICE <const> = 24
local PAGESIZ <const> = 8

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

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

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

local function format_row(target, results)
    local buf = { "", 
        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 feq(f1, f2)
    return math.abs(f1 - f2) < 0.0001
end

local function print_table(nsides, mindice, maxdice)
    print(format_header(mindice, maxdice))
    print(format_bar(mindice, maxdice))

    local step = nsides // 2
    local max = maxdice * nsides
    local min = step

    for t = min, max, step do
        -- Avoid rows with all 100% or all 0%
        if not (feq(p_roll_ge(mindice, nsides, t), 1.0)
                or feq(p_roll_ge(maxdice, nsides, t), 0.0)) then
            local result = {}
            for d = mindice, maxdice do
                local i = 1 + d - mindice
                result[i] = p_roll_ge(d, nsides, t)
            end
            print(format_row(t, result))
        end
    end
end

local function min(a, b)
    if a < b then
        return a
    else
        return b
    end
end

local function print_pages(nsides, maxdice, pagesiz)
    for p = 1, maxdice, pagesiz do
        print()
        print_table(nsides, p, min(maxdice, p + pagesiz - 1))
    end
end

print_pages(NSIDES, MAXDICE, PAGESIZ)