Abilities

abilities

Abilities are named actions characters can attempt - magical powers, combat techniques, special manoeuvres. Each is gated behind skill or trait prerequisites and modifies how the engine resolves the resulting roll.

In the editor

"Character abilities"

Editor location
Files → Mechanics → Abilities
Editor type
Edit in Studio + View JSON
Size limits
  • abilities (entry count)1,500 entries
  • abilities.*.description2,000
  • abilities.*.requirements (array length)10 entries
  • abilities.*.bonus0

Schema

json
{
  "abilities": {
    "<key>": {
      "name": "string",
      "description": "string",
      "requirements": [
        {
          "type": "resource | attribute | skill | trait",
          "variable": "string",
          "amount": "number"
        }
      ],
      "bonus": "number",
      "cooldown": "number"
    }
  }
}

Example

json
{
  "abilities": {
    "Precision Strike": {
      "name": "Precision Strike",
      "description": "Drive the blade into an exposed joint, throat gap, or visor seam — the technique trades power for placement. The strike bypasses armour entirely and delivers damage directly to the opponent underneath it. Most effective against heavily-armoured opponents where a direct exchange would otherwise favour them. Moderately increases the effectiveness of your next attack action and ignores armour bonuses.",
      "requirements": [
        { "type": "skill", "variable": "athletics", "amount": 30 }
      ],
      "bonus": 30,
      "cooldown": 0
    },
    "Whirlwind": {
      "name": "Whirlwind",
      "description": "Pivot on the back foot and drive a sweeping arc through every opponent within reach, momentum carrying the weapon through multiple targets in a single motion. The follow-through leaves the attacker briefly open — the tradeoff is reach and simultaneous coverage. Slightly increases the effectiveness of your next attack action against all adjacent targets.",
      "requirements": [
        { "type": "skill", "variable": "athletics", "amount": 55 }
      ],
      "bonus": 55,
      "cooldown": 0
    },
    "Magic Arrow": {
      "name": "Magic Arrow",
      "description": "Condense raw arcane force into a bolt that ignores the physical difference between armour and flesh — it does not cut or bludgeon, it transfers energy directly. No arc, no wind correction, reliable at any range. Slightly increases the effectiveness of your next arcane attack action.",
      "requirements": [
        { "type": "skill", "variable": "arcana", "amount": 10 }
      ],
      "bonus": 10,
      "cooldown": 0
    }
  }
}

Fields

name

Display name of the ability, and must be byte-identical to the outer map key — the engine matches entries by key, so the key and name have to be exactly equal (same case, same spaces). A mismatch is a validation error. Build the map as { ability["name"]: ability }. (This is separate from how player input resolves to an ability at runtime, covered under Name matching below, which is case-insensitive.)

Note (runtime control via triggers/scripts): abilities become available through their requirements (skill / trait / resource / characterLevel), so triggers gate them indirectly — granting a trait (player-traits) or raising a resource (player-resource) that satisfies a requirement makes the ability available. Granting a trait that names the ability in its own abilities list hands it over immediately instead, without checking the requirements. Replacing an ability with a stronger version is commonly done as a trigger/script trait-swap gated on a threshold (see the evolution snippet on the Triggers page).

requirements

All requirements in the array use AND logic — all must be satisfied simultaneously; the per-ability cap on requirements is shown in the Size Limits panel. Meeting them makes the ability available to unlock rather than owned outright — taking it spends one of the character's ability points. A trait that names the ability in its own abilities list skips this list entirely, covered under Unlocking one ability from several classes.

The variable field is validated differently per type. Using an invalid variable triggers a validator warning on import.

  • skillvariable must be a key in the world's skills dict. amount is the minimum skill level required.
  • attributevariable must be a value from attributeSettings.attributeNames (e.g. "strength", "intelligence"). amount is the minimum attribute value.
  • resourcevariable must be a key in resourceSettings. amount is the minimum resource maximum: the resource's max value must be at least amount.
  • traitvariable must be a key in the world's traits dict. amount is typically 1.
  • characterLevelno variable field (codec rejects it). Only type and amount are valid; amount is the minimum character level required.

'ability' is not a valid requirement type. Only resource, attribute, skill, characterLevel, trait are accepted.

bonus

Check bonus added to the skill check total when the ability is used. This contribution is capped by skillSettings.maxSkillSuccessLevel alongside skill bonuses, attribute bonuses, and context modifiers — authoring a bonus above that cap is silently wasted. Note that Whirlwind above trades raw bonus for AOE coverage (lower bonus, higher skill requirement).

cooldown

Turns before the ability can be used again. Default to 0 — most abilities should be freely usable. Only add a non-zero cooldown for abilities that would trivialize gameplay if spammed (instant full-health restore, guaranteed escape, auto-win combat effects). A cooldown is enforced during action evaluation: while an ability is still on cooldown the narrator treats it as unavailable and explains why, rather than letting it fire.

description

What the ability does, shown to the player. The AI reads this text and infers the ability's mechanical behavior from it, non-deterministically. The authored bonus and cooldown values stay exact; the narrative interpretation follows this description.

Name matching

Case-insensitive. Player input "Fireball", "fireball", and "FIREBALL" all match an ability named Fireball. Whitespace is also normalized. Pick whichever capitalization reads best for the world.

How the bonus and cooldown apply

An ability's bonus (shown in-game as Power) is added to the relevant check as a flat modifier, summed alongside the acting attribute's bonus and the relevant skill's bonus. A check reads as a sum of separate contributions (attribute, skill, and the ability's Power), not a product. The per-ability bonus is the value that reaches the check directly: it is not multiplied or scaled by any global setting. Each contribution is capped separately by skillSettings.maxSkillSuccessLevel — it limits what any single skill, attribute, ability, random roll, or context modifier may add, rather than the sum — so a bonus above that cap is silently wasted while the other contributions still land in full.

The per-ability cooldown applies directly as authored, measured in actions. combatSettings.abilityBonus and combatSettings.abilityCooldown are global defaults, not multipliers: they supply the bonus and cooldown an ability is given when it does not define its own, while authored abilities use their own values. abilityCooldown additionally sets the minimum number of turns that must pass before a character can learn another new ability.

What the schema natively supports

A check bonus (bonus) and a cooldown. Everything else is narrator-interpreted from the description text. Save DCs, area-of-effect targeting, status effects (blind, stun, poison, fear), knockback, persistent auras — none of these have dedicated schema fields. Write them as plain-language instructions in description and the narrator applies them during play. The more precisely you write the effect, the more consistently the narrator honors it. Vague ("applies a debuff") produces inconsistent results; specific ("the target cannot take reactions until the start of your next turn") does not.

Abilities don't scale in power

For systems with progression (spell tiers, martial-arts ladders, magic schools), author a sequence of escalating abilities tied to ascending skill thresholds. For grounded worlds, a flat set of distinct named techniques works fine — no ladder required.

Authoring tips

Abilities are optional

Most worlds don't need one for every skill. A skill works on its own: the AI resolves narrated actions through skill checks based on the world's existing skill + attribute + difficulty math. The 28 skills in a grounded scenario do not need 28 corresponding abilities. Abilities are an additional layer for discrete trained techniques worth naming — they're at their most useful when you have a tier-gated system (spell tiers, martial-arts progressions, magic-tradition ladders), or when an action's mechanical effect cannot be reached through a normal skill check (armour bypass, AOE, status effects). Grounded-realistic worlds typically author 30-80 abilities for the techniques worth naming and leave the other skills to resolve via prose + skill checks alone. Tier-gated systems (high fantasy, hard magic) typically author hundreds, with most skills serving as the gate variable for a ladder of named techniques.

What stops the player from just using the raw skill?

Nothing — the player can always attempt the same action through ordinary play and the AI resolves it as a skill check. The ability is an opt-in unlock. Choosing the ability gives the character (a) the check bonus on top of the raw skill result, and (b) access to mechanical effects the skill alone cannot produce — armour bypass, AOE targeting, named status effects, narrator-honoured constraints written into the description. If an ability's effect is identical to what the raw skill already accomplishes, it adds no value and the player will skip it.

Design advice

"Avoid abilities that just let you do what your skill already allows." Think of an ability as "permission to do something you normally couldn't" — Precision Strike isn't just +10 to an attack roll, it bypasses armor entirely on a hit. That's a qualitatively different outcome from a naked skill check. Abilities with narrative versatility have more longevity: a Burning Blade ability is useful in combat, lighting caves, cooking in the field, and cauterizing wounds — four different contexts where it could be invoked.

Tiered ability system

Abilities unlock as a skill rises naturally — no ability chains or prerequisites between abilities. A six-tier structure works well:

TierSkill amountCharacter stage
1 - Novice10Early game
2 - Apprentice20–25Early–mid
3 - Competent35Mid game
4 - Expert50–55Mid–late
5 - Master65Late game
6 - Legendary80Endgame

Set bonus equal to the skill level requirement — if the ability requires skill level 35, set bonus: 35. Lower is acceptable for AOE, passive, or broadly versatile abilities. Default cooldown to 0; reserve non-zero values for abilities that would trivialize gameplay if spammed.

A player's skill naturally rises with use — as it crosses each threshold, new abilities in that tier become available to unlock. The player does not need to complete one ability to access the next; the skill level itself is the only gate.

Class-gated abilities

Every entry in requirements must be met. The list is read as AND for every requirement type, so switching an entry from skill to trait changes what is checked, never how the entries combine. An ability with two entries is unlocked only by a character who satisfies both, and there is no way to write OR inside one ability. An empty list leaves the ability open to everyone.

A single class gate is one trait entry naming that class's trait, or a skill entry set to a level the class is built to reach. Trait gates are direct and exact; skill gates keep the ability trainable by other classes, which is what you want when the class shouldn't strictly own it. Requiring two skills at once is a deliberate double gate, not a choice between them (e.g., Hazy Mist requiring both blood magic 6 and acrobatics 6).

Unlocking one ability from several classes

A trait that names an ability in its own abilities list hands that ability to the character directly, without reading the ability's requirements at all. The two routes are independent, and that is what makes an either/or gate possible.

To open one ability to several classes, name it in the abilities list of each class's trait. Every one of those traits grants it, a character holding two of them still gets a single copy, and nobody else receives it.

To open it to a class or to anyone who trains far enough, use both at once: keep the skill threshold in requirements and name the ability in the class trait as well. The class receives it outright, and everyone else can unlock it once they reach the threshold.

The two routes are not the same deal. A trait grant is automatic and free the moment the trait applies, while meeting requirements only makes the ability available and taking it still costs an ability point. The granted class starts with it; everyone else pays for it.

Adding new abilities

  1. Identify which tier slot is missing for the target skill — don't stack multiple abilities at the same level unless they serve different functions.
  2. Set bonus equal to the skill level requirement. Lower is acceptable for AOE, passive, or broadly versatile abilities.
  3. Cooldown 0 is valid for passive or out-of-combat abilities (Detect Magic, Keen Eye, Beast Mastery).
  4. A trait requirement gates an ability directly: only a character who has that trait can unlock it ({ "type": "trait", "variable": "<trait key>", "amount": 1 }, with amount ignored). This is the cleanest way to bind a class-, race-, or character-specific ability to its owner. Alternatively, gate by a skill threshold the class is built to reach (calibrate the class's starting skill bonuses to the intended first ability), which keeps the ability trainable by other classes too. Use trait gates for "only this kind of character has this," skill gates for "anyone who trains this far earns this."
  5. Write descriptions as 1-2 sentences that integrate the narrative moment and the mechanical effect — not two separate sentences but one flowing description that naturally concludes with what changes. End with a plain-language effect statement: "Bypasses armor and deals enhanced damage", "Moderately increases the effectiveness of your next attack action." No numbers or dice notation — natural language only. The AI reads this as its instruction for what the ability produces.