Classes

A class (a playbook, a calling: you name it) is a package of rules a character takes on. It isn't d20 code: any system can have classes, and every part of one is data you can change. A class can say:

• Numbers the rules read: a fighter's hit die is 10, a wizard casts at their full level, a paladin at half. Your system's formulas read them as @class.hit_die, @class.caster.
• Formulas it replaces: a wizard's spellcasting modifier is Intelligence, a cleric's Wisdom.
• What it is trained in: a fighter's Strength and Constitution saves. A roll reads it as @trained.
• Skills to pick: at creation, two of the fighter's skills among the character's trained picks.
• Features by level: abilities it grants as the character levels. Always-on ones change numbers (Unarmoured Defence sets Armour Class); others are used like any ability (Rage, Second Wind).
• What it learns from: the spell lists its picks may take (the wizard list), how high, and picks of its own (two Magic Skills, or none at all).
• Who can take it, and what it never takes: only a non-sprite can be a Brute; a Brute never takes any Magic Skill. See Who can have what.
• What it starts with: its kit, by item name, worn where it says. See Gear.
• Subclasses: classes of its own, chosen at a level (a fighter becomes a Champion at 3).

A character's people brings its own part beside the class: adjustments, traits, and for some, no magic (a wizard of a people that can't use magic casts nothing). See Peoples under your rules.

A system can also run classless: then the defaults hold (Classic d20: a d8, a full caster's slots, Extra Attack at 5), and a character learns anything the rules allow. Engine

A system can let a character hold more than one class, each with its own level: fifth-edition-style multiclassing (a fighter 3 / wizard 2), or a JRPG-style game where a hero masters a class and moves on to the next. Switch it on in Studio › Rules › Classes › Settings, under Several classes: Characters can hold several classes, each with its own level. Without it, a character has one class at their own level, as above. Classic d20 comes with it on: see Several classes in Classic d20. Engine

A class goes up to level N

A class's own cap. Reaching it is mastery: a mastered class takes no more levels. Leave it blank for no cap but the character's level. A class's own Highest level, in its editor, overrides it for that class.

At most N classes

The most classes one character can hold.

At most N not yet mastered

The most classes held at once that are not yet mastered. A mastered class doesn't count, so mastering one makes room for a new one.

Each level in a class earns N picks from its own lists, called …

Every level in a class gives that many ability picks, taken only from that class's own lists, under the name you give (“A skill”).

How a number adds up across classes

For each number classes give (@class.hp): added together (the default), the highest, or their first class's.

Only the first class gives its trained checks

The checks a class trains (@trained) come from the class they took first, never from one taken up later: fifth edition's saving throws. Everything else a class gives still comes from each of them.

A level goes into a class

The character's level is still the system's own, earned the usual way. Each level they gain is a choice: they put it into a class they hold or into a new one, so their class levels add up to their level once it is placed. The sheet offers the classes they can raise (theirs below the cap) and the new ones they may take (who can take it, what taking it up needs, the most classes, the most not yet mastered). A new class starts at level 1. A character with no class yet puts every level waiting into the first one they take, up to its cap. Engine

Everything a class gives comes by their level in that class, not their character level: its features, its subclass (a fighter's Champion opens at fighter level 3), and its picks. The storyteller is told each class with its level, and which are mastered (“Sentinel 10 (mastered), Spellweaver 3”). Storyteller

What taking up another needs

In a class's editor, Taking it up beside another class needs is a gate like Who can take it, but only for a class taken up beside one they already hold: fifth edition's 13 in the class's main ability (@str >= 13). It is checked both ways: the new class's needs, and the needs of every class they hold, since they are leaving each for another. A fighter with Intelligence 13 can take up wizard only if they also have the fighter's Strength or Dexterity 13. Their first class never asks it. A class they don't meet isn't offered, and the server refuses it in words (leaving Fighter for another needs Strength or Dexterity 13). Engine

Picks by class level, and mastery picks

Under several classes, a class's own learning picks come by its own level: a pick “at class level 10” comes when they reach level 10 in that class. With picks per class level set, every level in a class earns that many more. Each one takes from that class's own lists only, and is labelled with the class (“Sentinel: A skill”). They wait on the sheet one class at a time, in the order the classes were taken. A class's pick can't be spent on an ability of the character's own. Engine

Any pick can name From lists: then it takes from those lists instead. That is how a mastery reward works: a pick at class level 10 “from the heroic list”, where each heroic ability carries its own gate (@classlevel.sentinel >= 10, or @mastered >= 1).

A class whose Learns from sets no picks of its own learns as the system says, by its own level: the system's picks by level (Abilities › Settings › Picks as they level) count that class's levels instead of the character's. A class that sets its picks to none learns nothing by level. The system's own picks are then a classless character's: once they hold a class, every pick comes through one. And a class pick's highest level reads that class's level: in Classic d20, a Fighter 5 / Wizard 3 learns wizard spells up to 2nd level, as a 3rd-level wizard does. Engine

Numbers across classes

Each class a character holds gives its own numbers, and @class.<name> adds them up. Inside a class's own numbers, @classlevel is their level in that class, so a number can grow with it. Engine

A class that gives no value for a name takes the system's default for it (Numbers a classless character gets), worked out as that class's own: at its level, as described below. A name neither the class nor the defaults give doesn't count toward it. Formulas anywhere can also read @classlevel.<class> (their level in it, 0 if they don't hold it), @classes (how many they hold) and @mastered (how many are at their cap). See the dice language.

A default worked out per class

A default is worked out once for each class that takes it, as if it were that class's own number. Inside it, and inside any class's own numbers, two more values read: Engine

@classfirst

1 for the class they took first, 0 for every other. Something only the first class gets: fifth edition's whole hit die at level 1.

@own.<name>

That class's own value of another name: @own.hit_die is the fighter's 10 while working out the fighter's part, the wizard's 6 for the wizard's. @class.hit_die would read the added-up one instead.

That is how Classic d20 gives hit points by each class's own die with one default, written once:

"classRules": { "values": {
  "hit_die": "8",
  "hit_points": "@classfirst * (floor(@own.hit_die / 2) - 1) + @classlevel * (floor(@own.hit_die / 2) + 1)" } }

hit points' maximum:  @class.hit_points + @level * @con.mod

No class sets hit_points, so each takes the default. The first class gets its whole die at its first level and the die's average after; any other class, its average every level. A Fighter 1 / Wizard 1 with Constitution 14: 10 (the fighter's d10, whole) + 4 (the wizard's d6, average) + 2 × 2 = 18. One class alone reads as it always did: a level 5 fighter has 10 + 4 × 6 + 5 × 2 = 44.

Features that scale with their class

An ability's formulas read @level as the character's level. Set Scales with the level in to a class in the ability's editor, and its @level becomes their level in that class, while they hold it: in its uses, its effects, its cost and its always-on modifiers. Classic d20's Action Surge reads if @level >= 17 then 2 else 1 and scales with fighter: a Fighter 2 / Wizard 15 is level 17 but surges once a rest; a Fighter 17 twice. Rage, Second Wind, Lay on Hands, Arcane Recovery and the other class features do the same. A formula outside the ability reads the class's level directly: Sneak Attack's dice are ceil(@classlevel.rogue / 2) (by their own level when they hold no rogue levels). Engine

Starting in several

A system can start characters above level 1 and spread those levels over a few classes: Start at level and Classes to start in in Rules › Sheet › New characters. A system that starts at level 5 in two to three classes has the creator place all five (Sentinel 3, Spellweaver 2), each class up to its cap. Each class they start in brings its starting kit. See Making and growing a character. Engine

Two ways to use it

Fifth-edition style. No cap per class; each level goes where the player likes. Each class writes its numbers by its own level, and the spell slots (which read @class.caster) follow the combined caster level. This is how Classic d20 plays (see below):

"classRules": { "multi": { "firstOnly": ["trained"],
                           "combine": { "attacks": "max", "hit_die": "first" } } }

{ "id": "fighter", "multiclass": "@str >= 13 or @dex >= 13",
  "values": { "hit_die": "10", "caster": "0", "attacks": "if @classlevel >= 5 then 2 else 1" } }
{ "id": "wizard",  "multiclass": "@int >= 13",
  "values": { "hit_die": "6", "caster": "@classlevel", "attacks": "1" } }
{ "id": "paladin", "multiclass": "@str >= 13 and @cha >= 13",
  "values": { "hit_die": "10", "caster": "floor(@classlevel / 2)",
              "attacks": "if @classlevel >= 5 then 2 else 1" } }

A fighter 3 / wizard 2 is level 5: @class.caster is 0 + 2 = 2, so three 1st-level slots, as a 2nd-level wizard has; attacks are the highest, 1, not 1 + 1; their saves are the fighter's alone. A formula that belongs to one class alone reads its level directly: a wizard-only track whose maximum is ceil(@classlevel.wizard / 2) is 1 for this character, and 0 for someone with no wizard levels.

A step-dice game. Stats are dice (d6 to d12), heroes start at level 5 over two or three classes, every class caps at 10, and each class level is a skill from that class's list:

"classRules": { "required": true,
  "multi": { "maxLevel": 10, "maxOpen": 3, "picks": { "count": 1, "label": "A skill" } } }

{ "id": "sentinel", "name": "Sentinel", "lists": ["sentinel"], "values": { "hp": "5" },
  "learning": { "picks": [{ "atLevels": [10], "count": 1, "label": "A heroic skill", "lists": ["heroic"] }] } }
{ "id": "spellweaver", "name": "Spellweaver", "lists": ["spellweaver"], "values": { "mp": "5" } }
{ "id": "tinker", "name": "Tinker", "lists": ["tinker"], "values": { "kit": "2 * @classlevel" } }

Every preset has classes of its own, under its own word. Forged in the Dark has playbooks: each starts with its signature special ability and learns the rest from its own list. Moves has Dungeon World's nine classes, with their starting moves and their advanced moves to learn from level 2. The two d100 systems have professions and careers: the skills they are good at, which a new hero picks from, and a starting kit. Hope and Fear's eight classes start with two abilities each. See what each comes with.

The SRD 5.1's twelve classes, each with its subclass: Barbarian (Berserker), Bard (Lore), Cleric (Life), Druid (Land), Fighter (Champion), Monk (Open Hand), Paladin (Devotion), Ranger (Hunter), Rogue (Thief), Sorcerer (Draconic), Warlock (Fiend) and Wizard (Evocation). Each has its hit die, saves, skills, Extra Attack where it has one, its casting (full, half or none) and spell list, a starting kit, and two to five of its features. The spells in the library carry the lists they are on.

{ "id": "fighter", "name": "Fighter",
  "multiclass": "@str >= 13 or @dex >= 13",
  "values": { "hit_die": "10", "caster": "0",
              "attacks": "if @classlevel >= 20 then 4 else if @classlevel >= 11 then 3 else if @classlevel >= 5 then 2 else 1" },
  "trained": { "save": ["str", "con"] },
  "skills": { "from": ["acrobatics", "animal_handling", "athletics", "history", "insight", "intimidation", "perception", "survival"], "count": 2 },
  "features": [{ "level": 1, "abilities": ["second_wind", "fighting_style_defence"] },
               { "level": 2, "abilities": ["action_surge"] }],
  "gear": [{ "name": "Chain Mail", "equipped": true }, { "name": "Longsword", "equipped": true },
           { "name": "Shield", "equipped": true }, { "name": "Light crossbow" }] }

{ "id": "champion", "name": "Champion", "parent": "fighter", "atLevel": 3,
  "features": [{ "level": 3, "abilities": ["improved_critical"] }] }

How Classic d20 reads them

• Hit points: @class.hit_points + @level * @con.mod, where each class's share comes by its own die (see A default worked out per class). A classless character's go by a d8.
• Spell slots: the full caster's table by @class.caster, for anyone who knows a spell.
• Saving throws add @trained * @proficiency; attacks a turn are @class.attacks.

Several classes in Classic d20

Classic d20 plays the SRD 5.1's multiclassing. Each level a character gains goes into a class they hold or a new one, and everything below is code: Engine

A character made before several classes keeps their class at the level they had: a level 4 fighter is Fighter 4, and the next level they gain is placed like any other. The picks they already spent count against that class, so nobody is handed their picks twice. The storyteller is told each class with its level, and when a level waits to be placed. Storyteller

The Studio

Studio › Rules › Classes: the classes with their subclasses, one line each saying what it gives; open one to change any of it. Settings holds what a class is called, whether one is required, the defaults when classless, and several classes.

Hob

“A Hexblade: d8 hit die, half caster with Charisma, trained in Wisdom and Charisma saves, starts with a longsword” writes one. “Make classes required” changes the settings.

Any system

A PbtA world's playbooks are classes: their moves are features, their stat lines are values. A Forged world's playbooks give special abilities and starting gear. A d100 world's careers can train skills and grant talents.

Features change the numbers when they can: Action Surge gives one more Action that turn (its attacks are rolled), Improved Critical makes a 19 on an attack roll a critical, Disciple of Life adds 2 + the slot's level to healing spells, Rage halves cuts, blows and stabs. A feature is any of the pieces an ability has: an extra action (an effect), a wider critical or more healing (an always-on ability's modifiers), resistances (a condition's or a modifier's). See Fights under your rules.