Game Systems

Package provenance — this chapter ships with the Ontology & Structure Engine. Provenance tag: source-ontology-project. When loaded into a new world, grep the tag to find the engine's templates and instructions.

The engine is system-agnostic — it does not ship a ruleset — but it can generate the mechanics a chosen system needs. Startup pins the system: the World Profile records which one the world runs on (gameSystem) and the mechanics summary that drives generation (gameSystemSummary). This chapter holds the template summaries for the stock families and the capture shape for a written-in system.

The families (and writing your own)

Presented at startup as a pick; the user can also type their own. A family is a shape of mechanics, not a license: "d20" means a d20-rolls-high, stat-and-armor-class system — it claims no brand.

For each family below: resolution (how actions are decided), stats (the character frame), combat (how fights are modeled), progression (how characters grow), and what to generate (the rule files and stat conventions the engine scaffolds to play it). The resolution grid is the engine's first and most important fact about a system — it decides every derived number downstream.

d20 — stat-and-class, roll high (the D&D family)

• Resolution — d20 + modifier vs a difficulty; roll high. 20 auto-succeeds and 1 auto-fails on attacks. Advantage/disadvantage = roll twice, keep the better (or worse).
• Stats — ~6 abilities (strength, dexterity, constitution, intelligence, wisdom, charisma), scores ~3–18, modifier = (score − 10) / 2 (floor). Proficiency and skill bonuses scale with level.
• Combat — Armor Class vs attack roll, hit points, weapon damage dice, an action economy (action, bonus, move, sometimes reaction). Saving throws resist effects. Critical hits and damage dice as discrete side rules.
• Progression — levels from XP or milestones; a hit die per class; proficiency bonus; feat/ability-ASI checkpoints.
• Derived numbers — AC = 10 + Dex mod + armor; HP = hit die + Con mod per level; hit bonus = proficiency + ability mod. These belong as rule files, never restated per monster.
• What to generate — rule files for checks (a DC ladder), combat (initiative, AC, HP, action economy), rests and healing; monster stat blocks (HP, AC, attacks, level-appropriate mods); weapon / armor equipment entries carrying their dice and bonus.

d100 — skill-hundreds, roll low (the BRP family: Call of Cthulhu, RuneQuest)

• Resolution — percentile d100 vs a skill or stat; roll under to succeed. Criticals and fumbles cluster at the extremes of the roll.
• Stats — characteristics (STR, CON, POW, EDU, …) plus skills scored as percentages that grow with use.
• Combat — skills govern attack, parry, and dodge; hit points, sometimes per-location; armor reduces damage; a damage bonus derived from build.
• Progression — experience checks: mark a skill used in a session and roll to improve it; skill points spent at creation.
• Derived numbers — damage bonus from STR (+ SIZ), HP from CON (+ SIZ), sanity/power for horror registers.
• What to generate — rule files for skill tests (fumble / success / special / auto), combat (parry, armor reduction), experience checks, and sanity/coercion where the register calls for it; monster stat blocks as skill-percentile ranges; a starting skill list as a rule or character default.

narrative — fiction-first, moves and clocks (PbtA / FitD / dice-lite)

• Resolution — fiction decides what is possible; a single small die roll, or none, resolves uncertainty. Common: 2d6 with 6− / 7–9 / 10+ (miss / partial / full), or outcomes declared by stakes with no arithmetic.
• Stats — 3–6 tags, approaches, or playbook stats rather than a stat block; no hit points by default — conditions, harm, and consequences instead.
• Combat — scene-level: stakes are declared and consequences paid in harm, conditions, or forward, not hit-point attrition.
• Progression — advancement by milestones and playbook triggers, not XP math.
• Derived numbers — nearly none. The engine must not invent AC, HP, or stat-derived modifiers for this family.
• What to generate — rule files for the resolution ladder, clocks/tension, conditions, and consequence language; monster / NPC files as obstacles and impending harm, not stat blocks.

wow-derived — MMO-style, item-level and roles (World of Warcraft-derived)

• Resolution — the interesting numbers are stats and cooldowns, not a central die; a d20 or % may settle individual hits, but damage, healing, and tanking come from character stats and item level.
• Stats — primary stats (strength / agility / intellect / wisdom) and secondary stats (crit, haste, mastery, versatility); stamina → HP; mana, rage, or energy resources; threat and aggro.
• Combat — rotational abilities with cooldowns; a tank / healer / dps role split; boss encounters with scripted mechanics (phases, soak, interruptables).
• Progression — leveling to a cap; gear item-level gates content; talent trees; raids and instances as location adventure sets.
• Derived numbers — HP scales with stamina and item level; damage from weapon / attack-power / spell-power stats; much of a character's power comes from gear, not class level. These are rule and equipment-modeling problems, not restated per monster.
• What to generate — rule files for resources, cooldowns, threat, and item level; role guidance (tank / healer / dps); monster stat blocks as boss ability lists; equipment entries carrying item level and primary/secondary stats.

Writing your own system

If the user picks none of the families, capture their system in their own words and shape it into the same pattern the families use — wherever an answer is unknown, leave it unset and generate only what is known. Five prompts:

1. How are actions resolved? Dice — which, roll high or low, target number? Success tiers, fumble and critical?
2. What do characters have? Attributes, skills, tags, hit points, resources — and how are the numbers derived?
3. How does combat work? Attack/defense model, armor, damage, action economy, initiative — or scene-level?
4. How do characters progress? XP, levels, milestones, gear — and does advancement change those numbers?
5. Where should the engine stay hands-off? Some systems must not have derived math imposed on them.

Record the write-up as gameSystemSummary on the World Profile; generate rule files only where the answers give the engine a rule to scaffold, and leave the rest unstated rather than guessing.

Using this at startup

The Startup Protocol (§ Pin the game system) presents the four families plus write-your-own, records the pick as gameSystem, and fills gameSystemSummary from this chapter (or from the user, for a custom system). Execution then scaffolds rule files per the summary. When the system changes later, edit these two profile fields and regenerate the affected rule files — the profile is the single source of truth for mechanics.