dnd5e-character-builder 0.1.0__py3-none-any.whl

dnd5e_character_builder/__init__.py

@@ -0,0 +1,34 @@
+"""Build, level up and check 2024 (SRD 5.2.1) character sheets, on top of the nat20 rules engine.
+
+``check`` lists every problem with a sheet; ``fill`` writes in the numbers nat20 derives; ``options`` says what a sheet
+may still pick; ``level_up`` reports what a new level gives and which picks it makes due. ``load_content`` layers
+homebrew over the SRD.
+"""
+
+from dnd5e_character_builder.advance import Choice, FeatSlot, Gained, LevelUp, Options, SpellOption, SpellOptions, level_up, options
+from dnd5e_character_builder.check import build_spec, check, derive, fill
+from dnd5e_character_builder.content import Content, ContentError, load_content
+from dnd5e_character_builder.sheet import Feat, Issue, MagicInitiate, Sheet
+
+__all__ = [
+    'Choice',
+    'Content',
+    'ContentError',
+    'Feat',
+    'FeatSlot',
+    'Gained',
+    'Issue',
+    'LevelUp',
+    'MagicInitiate',
+    'Options',
+    'Sheet',
+    'SpellOption',
+    'SpellOptions',
+    'build_spec',
+    'check',
+    'derive',
+    'fill',
+    'level_up',
+    'load_content',
+    'options',
+]

dnd5e_character_builder/advance.py

@@ -0,0 +1,208 @@
+"""``options``: every pick a sheet has at its level and what fills it; ``level_up``: what a new level gives and which
+picks it makes due.
+
+Both report; neither changes the sheet. The caller writes the picks, then runs ``fill`` and ``check``.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+from dnd5e_character_builder.build import Build, read
+from dnd5e_character_builder.check import SKILLS, _skill_names, _srd, derived_numbers, skill_pools
+from dnd5e_character_builder.content import Content
+from dnd5e_character_builder.sheet import Sheet
+from dnd5e_character_builder.spells import caster, granted, slots, state
+
+
+class Choice(BaseModel):
+    """A pick the build has: ``count`` from ``options`` by this level, ``chosen`` the sheet's own. Open while
+    ``len(chosen) < count``."""
+
+    title: str
+    count: int
+    options: list[str]
+    chosen: list[str] = Field(default_factory=list)
+
+
+class SpellOption(BaseModel):
+    name: str
+    level: int
+
+
+class FeatSlot(BaseModel):
+    """An Ability Score Improvement level reached with no feat recorded, and the feats that fit it."""
+
+    level: int
+    options: list[str]
+
+
+class SpellOptions(BaseModel):
+    """The class table's spell picks: ``cantrips`` and ``prepared`` are the limits, ``known_cantrips`` and
+    ``prepared_spells`` the sheet's entries that count against them, the options by level then name. Granted spells
+    count against nothing and are offered nowhere. A wizard prepares from the spellbook (``options``) and writes
+    new spells from ``spellbook_options``; ``spellbook`` is the least the book holds at this level."""
+
+    cantrips: int
+    prepared: int
+    max_level: int
+    known_cantrips: list[str] = Field(default_factory=list)
+    prepared_spells: list[str] = Field(default_factory=list)
+    cantrip_options: list[SpellOption] = Field(default_factory=list)
+    options: list[SpellOption] = Field(default_factory=list)
+    spellbook: int = 0
+    spellbook_options: list[SpellOption] = Field(default_factory=list)
+    granted: list[str] = Field(default_factory=list)
+
+
+class Options(BaseModel):
+    """Every pick a sheet has at its level, open or made."""
+
+    subclasses: list[str] = Field(default_factory=list)  # when the level has reached the subclass and none is chosen
+    choices: list[Choice] = Field(default_factory=list)
+    feat_slots: list[FeatSlot] = Field(default_factory=list)
+    skills: list[Choice] = Field(default_factory=list)
+    expertise: list[Choice] = Field(default_factory=list)
+    spells: SpellOptions | None = None
+    magic_initiate: int = 0  # Magic Initiate feats with no record of their picks
+
+
+class Gained(BaseModel):
+    """What a level gives without a choice."""
+
+    features: list[str] = Field(default_factory=list)
+    spells: list[str] = Field(default_factory=list)  # newly always prepared
+    proficiency_bonus: int | None = None
+    max_hp: int | None = None
+    spell_slots: dict[int, int] = Field(default_factory=dict)
+
+
+class LevelUp(BaseModel):
+    """``level_up``'s report: ``gained`` automatically, ``due`` the picks open at the new level."""
+
+    from_level: int
+    to_level: int
+    gained: Gained
+    due: Options
+
+
+def _names(content: Content, slugs: set[str]) -> list[str]:
+    return [o.name for o in _spells(content, slugs)]
+
+
+def _spells(content: Content, slugs: set[str]) -> list[SpellOption]:
+    found = [content.spells[s] for s in slugs if s in content.spells]
+    return [SpellOption(name=s.name, level=s.level) for s in sorted(found, key=lambda s: (s.level, s.name.lower()))]
+
+
+def _feat_options(b: Build, level: int) -> list[str]:
+    """Feats a single-class character may take at an Ability Score Improvement of ``level`` (its character level)."""
+    loader = b.content.loader
+    owned = {p.slug for p in b.feats if p.slug} | set(b.derived.features if b.derived else ())
+    styles = any(p.title == 'Fighting Style' for p in b.pools)
+    out = []
+    for slug in loader.list_slugs('feats'):
+        feat = loader.get_feat(slug)
+        if feat is None or (slug in owned and not feat.repeatable):
+            continue
+        category = str(getattr(feat.category, 'value', feat.category))
+        if (category == 'epic_boon' and level < 19) or (category == 'fighting_style' and not styles):
+            continue
+        if any((p.level or 0) > level or (set(p.feats) - owned - ({'fighting-style'} if styles else set())) for p in feat.prerequisites):
+            continue
+        out.append(feat.name)
+    return sorted(out)
+
+
+def _spell_options(b: Build) -> SpellOptions | None:
+    st = state(b)
+    if not st.caster:
+        return None
+    c = b.content
+    _, own = caster(b)
+    out = SpellOptions(
+        cantrips=st.cantrip_limit,
+        prepared=st.prepared_limit,
+        max_level=st.max_level,
+        known_cantrips=st.cantrips,
+        prepared_spells=st.prepared,
+        cantrip_options=_spells(c, c.spell_list(own, 0) - st.granted),
+        options=_spells(c, c.spell_list(own, st.max_level, 1) - st.granted) if st.max_level else [],
+        granted=_names(c, st.granted),
+    )
+    if b.klass == 'wizard':
+        book = {s.slug for s in (c.spell(e) for e in b.sheet.spellbook) if s is not None}
+        out.options = _spells(c, {s for s in book if 1 <= c.spells[s].level <= st.max_level} - st.granted)
+        out.spellbook = 6 + 2 * (b.sheet.level - 1)  # "six level 1 Wizard spells"; "two Wizard spells of your choice" each level after
+        out.spellbook_options = _spells(c, c.spell_list('wizard', st.max_level, 1))
+    return out
+
+
+def _options(b: Build) -> Options:
+    loader, sheet = b.content.loader, b.sheet
+    out = Options()
+    gate = b.subclass_gate
+    if b.klass and not sheet.subclass.strip() and '(' not in sheet.character_class and gate is not None and sheet.level >= gate:
+        out.subclasses = sorted(
+            s.name
+            for slug in loader.list_slugs('subclasses')
+            if (s := loader.get_subclass(slug)) is not None and str(s.class_identifier) == b.klass
+        )
+    out.choices = [Choice(title=p.title, count=p.count, options=list(p.options), chosen=p.chosen) for p in b.pools]
+    taken = {p.level for p in b.feats if p.source == 'slot'}
+    out.feat_slots = [FeatSlot(level=lv, options=_feat_options(b, lv)) for lv in b.asi_levels if lv <= sheet.level and lv not in taken]
+    proficient, expertise, _ = _skill_names(sheet.skills)
+    expertise += _skill_names(sheet.expertise)[0]
+    pools = list(skill_pools(b, sheet.level))
+    background = loader.get_background(b.background) if b.background else None
+    fixed = [SKILLS[s] for s in background.skill_proficiencies if s in SKILLS] if background is not None else []
+    spare = len([s for s in proficient if s not in fixed])
+    for mode, title, count, options in pools:
+        have = set(expertise) if mode == 'expertise' else set(proficient)
+        mine = [o for o in options if o in have]
+        if mode != 'expertise':  # proficiencies the sheet already has fill the pools in order
+            used = min(count, spare)
+            spare -= used
+        else:
+            used = min(count, len(expertise))
+            expertise = expertise[used:]
+        target = out.expertise if mode == 'expertise' else out.skills
+        target.append(Choice(title=title, count=count, options=options, chosen=mine[:used]))
+    out.spells = _spell_options(b)
+    out.magic_initiate = max(0, sum(1 for p in b.feats if p.slug == 'magic-initiate') - len(sheet.magic_initiate))
+    return out
+
+
+def options(sheet: Sheet, *, content: Content | None = None) -> Options:
+    """What a sheet may still pick at its level: subclass, feature choices, feats, skills and spells."""
+    return _options(read(sheet, content or _srd()))
+
+
+def level_up(sheet: Sheet, to_level: int, *, content: Content | None = None) -> LevelUp:
+    """What reaching ``to_level`` gives automatically and which picks are then due. The sheet is not changed.
+
+    :raises ValueError: When ``to_level`` is not above the sheet's level or is above 20.
+    """
+    if not sheet.level < to_level <= 20:
+        raise ValueError(f'to_level must be above {sheet.level} and at most 20, not {to_level}')
+    content = content or _srd()
+    now = read(sheet, content)
+    after = read(sheet.model_copy(update={'level': to_level}), content)
+    loader = content.loader
+    features: list[str] = []
+    for doc in (loader.get_class(after.klass) if after.klass else None, loader.get_subclass(after.subclass) if after.subclass else None):
+        for g in getattr(doc, 'granted_features', None) or []:
+            if g.ref_type == 'feature' and sheet.level < g.level <= to_level and (f := loader.get_feature(g.slug)) is not None:
+                features.append(f.name)
+    numbers = derived_numbers(after)
+    gained = Gained(
+        features=list(dict.fromkeys(features)),
+        spells=_names(content, granted(after, to_level) - granted(now)),
+        proficiency_bonus=after.derived.proficiency_bonus if after.derived else None,
+        max_hp=numbers.get('max_hp'),
+        spell_slots=numbers.get('spell_slots') or slots(after, to_level),
+    )
+    return LevelUp(from_level=sheet.level, to_level=to_level, gained=gained, due=_options(after))
+
+
+__all__ = ['Choice', 'FeatSlot', 'Gained', 'LevelUp', 'Options', 'SpellOption', 'SpellOptions', 'level_up', 'options']

dnd5e_character_builder/build.py

@@ -0,0 +1,323 @@
+"""One reading of a sheet: what it names in the content, the nat20 build it describes, and what nat20 derives from it.
+
+``read`` is the single pass ``check``, ``fill``, ``options`` and ``level_up`` share. Every name is resolved here,
+feats are placed in the slots that allow them, picks become nat20 ``selected_choices`` tokens, and nat20's
+``derive_sheet`` runs; its ``ValueError`` becomes a ``build.rejected`` issue.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+from dnd5e_engine.build_spec import CharacterBuildSpec, DerivedSheet, derive_sheet, make_build_spec
+from dnd5e_engine.rules.character import ability_score_improvement, subclass_gate_level
+
+from dnd5e_character_builder.content import Content, clean_name, key
+from dnd5e_character_builder.sheet import Feat, Issue, Severity, Sheet
+
+_PAREN = re.compile(r'\s*\((.*?)\)\s*')
+_POOL_TITLES = {'fightingStyle': 'Fighting Style', 'metamagic': 'Metamagic', 'eldritchInvocation': 'Eldritch Invocations'}
+_ASI = 'ability-score-improvement'
+_MAGIC_INITIATE = 'magic-initiate'
+
+
+@dataclass
+class Pool:
+    """A feature choice the build has opened (Fighting Style, Metamagic, Divine Order): ``count`` picks due by the
+    sheet's level, its options by name and slug, and the sheet's picks (names) credited to it."""
+
+    title: str
+    source: str
+    count: int
+    options: dict[str, str]
+    chosen: list[str] = field(default_factory=list)
+    schedule: tuple[tuple[int, int], ...] = ()
+
+
+@dataclass
+class PlacedFeat:
+    """A sheet feat and where it came from: ``background``, ``species``, ``pool`` (a style taken through Fighting
+    Style), ``slot`` (the Ability Score Improvement at ``level``) or ``None`` when nothing on the sheet grants it."""
+
+    feat: Feat
+    slug: str | None
+    source: str | None = None
+    level: int | None = None
+    delivered: bool = False  # nat20 knows the build takes it
+
+
+@dataclass
+class Build:
+    sheet: Sheet
+    content: Content
+    klass: str | None = None
+    subclass: str | None = None
+    species: str | None = None
+    background: str | None = None
+    pools: list[Pool] = field(default_factory=list)
+    feats: list[PlacedFeat] = field(default_factory=list)
+    asi_levels: list[int] = field(default_factory=list)
+    spec: CharacterBuildSpec | None = None
+    derived: DerivedSheet | None = None
+    partial: list[str] = field(default_factory=list)  # why derived numbers may not match the sheet
+    issues: list[Issue] = field(default_factory=list)
+
+    def issue(self, code: str, severity: Severity, field_: str, message: str, **detail: Any) -> None:
+        self.issues.append(Issue(code=code, severity=severity, field=field_, message=message, detail=detail))
+
+    @property
+    def subclass_gate(self) -> int | None:
+        doc = self.content.loader.get_class(self.klass) if self.klass else None
+        return subclass_gate_level(doc) if doc is not None else None
+
+    def feat_count(self, slug: str) -> int:
+        return sum(1 for f in self.feats if f.slug == slug)
+
+
+def split_class(character_class: str, subclass: str) -> tuple[str, str]:
+    """Move a parenthesised subclass out of the class text when the subclass is empty: ``"Rogue (Thief)"``."""
+    match = _PAREN.search(character_class)
+    if match and not subclass.strip():
+        return _PAREN.sub(' ', character_class).strip(), match.group(1).strip()
+    return character_class.strip(), subclass.strip()
+
+
+def _classes_named(content: Content, text: str) -> list[str]:
+    whole = content.resolve('classes', text)
+    if whole:
+        return [whole]
+    words = key(re.sub(r'\d+', ' ', text)).split()
+    found = [s for w in words if (s := content.resolve('classes', w))]
+    return list(dict.fromkeys(found))
+
+
+def _option_doc(content: Content, ref: Any) -> Any:
+    return content.loader.get_feat(ref.slug) if ref.ref_type == 'feat' else content.loader.get_feature(ref.slug)
+
+
+def _option_name(doc: Any) -> str:
+    return str(doc.name).split(': ', 1)[-1]
+
+
+def pools_at(b: Build, level: int) -> list[Pool]:
+    """The feature choices a build has opened by ``level``, the sheet's picks credited to them.
+
+    A species pool of origin feats (the human's Versatile) is left to the feats. Two pools offering the same options
+    (a fighter's Fighting Style at 1 and the Champion's Additional Fighting Style at 7) share the picks: each takes up
+    to its count of the ones not yet taken. A style listed in ``choices`` fills a pool first; one listed only in
+    ``feats`` beyond the pools was taken with a feat slot.
+    """
+    loader = b.content.loader
+    sources = [(d, 'class') for d in [loader.get_class(b.klass) if b.klass else None] if d is not None]
+    sources += [(d, 'subclass') for d in [loader.get_subclass(b.subclass) if b.subclass else None] if d is not None]
+    sources += [(d, 'species') for d in [loader.get_species(b.species) if b.species else None] if d is not None]
+    taken = {clean_name(c) for c in [*b.sheet.choices, *(f.name for f in b.sheet.feats)]}
+    pools: list[Pool] = []
+    for doc, source in sources:
+        for choice in doc.feature_choices or []:
+            if source == 'species' and all(ref.ref_type == 'feat' for ref in choice.pool):
+                continue
+            count = sum(step.count for step in choice.schedule if step.level <= level)
+            schedule = tuple((step.level, step.count) for step in choice.schedule if step.count)
+            if not schedule:
+                continue
+            options = {_option_name(d): ref.slug for ref in choice.pool if (d := _option_doc(b.content, ref)) is not None}
+            first = _option_doc(b.content, choice.pool[0]) if choice.pool else None
+            title = _POOL_TITLES.get(choice.restriction_subtype) or (
+                str(first.name).split(': ', 1)[0] if first is not None and ': ' in first.name else f'{doc.name} option'
+            )
+            chosen = [name for name, slug in options.items() if key(name) in taken or slug in taken]
+            pools.append(Pool(title, source, count, options, chosen, schedule))
+    only_choice = {clean_name(c) for c in b.sheet.choices} - {clean_name(f.name) for f in b.sheet.feats}
+    assigned: set[str] = set()
+    for i, pool in enumerate(pools):
+        free = sorted((n for n in pool.chosen if n not in assigned), key=lambda n: key(n) not in only_choice)
+        later = any(set(pool.chosen) & set(p.options) for p in pools[i + 1 :])
+        pool.chosen = free[: pool.count] if later else free[: pool.count] + [n for n in free[pool.count :] if key(n) in only_choice]
+        assigned.update(pool.chosen)
+    return [p for p in pools if p.count > 0 or p.chosen]
+
+
+def _place_feats(b: Build) -> None:
+    """Put each sheet feat where the rules allow it; an unplaceable feat is an issue."""
+    loader = b.content.loader
+    background = loader.get_background(b.background) if b.background else None
+    species = loader.get_species(b.species) if b.species else None
+    origin_pools = [
+        {r.slug for r in c.pool} for c in (species.feature_choices if species else []) if all(r.ref_type == 'feat' for r in c.pool)
+    ]
+    in_pools = {key(n) for p in b.pools for n in p.chosen}
+    background_feat = background.starting_feat_slug if background is not None else None
+    # A custom background (any the content does not know): "+2 and +1, or +1 to three" to any abilities, two skills
+    # and one Origin feat of the player's choice.
+    custom_feat = background is None
+    free_slots = [lv for lv in b.asi_levels if lv <= b.sheet.level]
+    used: set[int] = set()
+    unplaced: list[PlacedFeat] = []
+    for feat in b.sheet.feats:
+        slug = b.content.resolve('feats', feat.name)
+        doc = loader.get_feat(slug) if slug else None
+        placed = PlacedFeat(feat, slug)
+        b.feats.append(placed)
+        category = str(getattr(doc.category, 'value', doc.category)) if doc is not None else ''
+        if slug is None:
+            b.issue('feat.unknown', 'error', 'feats', f'"{feat.name}" is not a feat in the content', feat=feat.name)
+        if feat.level is None and key(feat.name) in in_pools:
+            placed.source, placed.delivered = 'pool', True
+            continue
+        if feat.level is None and (category == 'origin' or slug is None):
+            if slug is not None and slug == background_feat:
+                placed.source, placed.delivered, background_feat = 'background', True, None
+            elif slug is not None and (pool := next((p for p in origin_pools if slug in p), None)) is not None:
+                placed.source, placed.delivered = 'species', True
+                origin_pools.remove(pool)
+            elif custom_feat:
+                placed.source, custom_feat = 'background', False  # nat20 has no custom background to tell
+            elif slug is not None and len(unplaced) < len([lv for lv in free_slots if lv not in used]):
+                unplaced.append(placed)  # an origin feat may also fill an Ability Score Improvement
+            elif slug is not None:
+                gives = (
+                    (background.name + ' gives ' + (background_feat or 'none left')) if background is not None else 'its one already taken'
+                )
+                b.issue(
+                    'feat.no_slot',
+                    'error',
+                    'feats',
+                    f'"{feat.name}": an origin feat comes from the background ({gives}) or the species',
+                    feat=feat.name,
+                )
+            continue
+        if feat.level is None:
+            unplaced.append(placed)
+            continue
+        if feat.level not in free_slots or feat.level in used:
+            why = (
+                'already taken by another feat'
+                if feat.level in used
+                else f'not a {b.klass} level with an Ability Score Improvement the sheet has reached'
+            )
+            b.issue('feat.no_slot', 'error', 'feats', f'"{feat.name}" at level {feat.level}: {why}', feat=feat.name, level=feat.level)
+            continue
+        placed.source, placed.level = 'slot', feat.level
+        used.add(feat.level)
+    for placed in unplaced:  # a general feat with no level: the first free slot, and a warning to record it
+        level = next((lv for lv in free_slots if lv not in used), None)
+        b.issue(
+            'feat.level_missing',
+            'info',
+            'feats',
+            f'"{placed.feat.name}": record the level it was taken at' + ('' if level else ' (no Ability Score Improvement left for it)'),
+            feat=placed.feat.name,
+        )
+        if level is not None:
+            placed.source, placed.level = 'slot', level
+            used.add(level)
+    for placed in b.feats:
+        if placed.source == 'slot' and placed.slug not in (None, _ASI):
+            placed.delivered = True
+    for level in (lv for lv in free_slots if lv not in used):
+        b.issue(
+            'feat.slot_empty',
+            'warning',
+            'feats',
+            f'Level {level}: no feat recorded for the Ability Score Improvement (list "Ability Score Improvement" or the feat taken)',
+            level=level,
+        )
+    if custom_feat:
+        b.issue('feat.missing', 'warning', 'feats', 'A background gives one origin feat; none is on the sheet')
+    if background_feat and background is not None:
+        found = loader.get_feat(background_feat)
+        b.issue(
+            'feat.missing',
+            'warning',
+            'feats',
+            f'The {background.name} background gives the {found.name if found else background_feat} feat',
+            feat=background_feat,
+        )
+
+
+def _tokens(b: Build) -> tuple[str, ...]:
+    tokens = [p.options[name] for p in b.pools for name in p.chosen[: p.count]]
+    tokens += [p.slug for p in b.feats if p.source == 'species' and p.slug]
+    tokens += [f'feat:{b.klass}:{p.level}:{p.slug}' for p in b.feats if p.source == 'slot' and p.slug not in (None, _ASI)]
+    delivered = sum(1 for p in b.feats if p.slug == _MAGIC_INITIATE and p.delivered)
+    for record in b.sheet.magic_initiate[:delivered]:
+        found = [b.content.spell(s) for s in [*record.cantrips, record.spell]]
+        if all(s is not None and b.content.loader.get_spell(s.slug) is not None for s in found):
+            slugs = [s.slug for s in found if s is not None]
+            tokens.append(f'magic-initiate:{record.spell_list}:{record.ability}:{slugs[0]},{slugs[1]}:{slugs[2]}')
+    return tuple(dict.fromkeys(tokens))
+
+
+def read(sheet: Sheet, content: Content) -> Build:
+    """Resolve a sheet against the content and derive it with nat20."""
+    b = Build(sheet, content)
+    class_text, sub_text = split_class(sheet.character_class, sheet.subclass)
+    named = _classes_named(content, class_text) if class_text else []
+    if len(named) > 1:
+        b.issue(
+            'class.multiclass',
+            'error',
+            'class',
+            f'"{sheet.character_class}" names {len(named)} classes; multiclass sheets are not supported yet',
+            classes=named,
+        )
+    elif not named:
+        b.issue('class.unknown', 'error', 'class', f'"{sheet.character_class}" is not a class in the content')
+    else:
+        b.klass = named[0]
+    if sheet.species.strip():
+        b.species = content.resolve('species', sheet.species)
+        if b.species is None:
+            b.issue('species.unknown', 'error', 'species', f'"{sheet.species}" is not a species in the content')
+    else:
+        b.issue('species.missing', 'error', 'species', 'No species')
+    if sheet.background.strip():
+        b.background = content.resolve('backgrounds', sheet.background)
+    if b.klass:
+        doc = content.loader.get_class(b.klass)
+        b.asi_levels = [lv for lv in range(1, 21) if ability_score_improvement(doc, lv) is not None]
+        gate = b.subclass_gate
+        if sub_text:
+            b.subclass = content.resolve('subclasses', sub_text)
+            if b.subclass is None:
+                b.issue('subclass.unknown', 'error', 'subclass', f'"{sub_text}" is not a subclass in the content')
+                b.partial.append('the subclass is unknown')
+        elif gate is not None and sheet.level >= gate:
+            b.issue(
+                'subclass.missing',
+                'error',
+                'subclass',
+                f'A level {sheet.level} {doc.name} has chosen a subclass (at level {gate})',
+                level=gate,
+            )
+    b.pools = pools_at(b, sheet.level)
+    _place_feats(b)
+    # A known feat nat20 is not told about (an origin feat from a background outside the content) changes no derived
+    # number: nat20 feats carry no passive effects, and the one that adds AC (Defense) always comes through a pool or slot.
+    if any(p.slug is None for p in b.feats):
+        b.partial.append('a feat is not in the content')
+    if b.klass is None or b.species is None or len(named) > 1:
+        return b
+    equipment = tuple(s for s in (content.resolve('items', x) for x in sheet.inventory) if s)
+    try:
+        b.spec = make_build_spec(
+            species_slug=b.species,
+            class_slug=b.klass,
+            level=sheet.level,
+            subclass_slug=b.subclass,
+            ability_scores=dict(sheet.abilities),
+            equipment=equipment,
+            background_slug=b.background,
+            selected_choices=_tokens(b),
+        )
+        b.derived = derive_sheet(b.spec, loader=content.loader)
+    except ValueError as exc:
+        b.issue('build.rejected', 'error', 'build', f'nat20 cannot build this sheet: {exc}', reason=str(exc))
+        b.derived = None
+    return b
+
+
+__all__ = ['Build', 'PlacedFeat', 'Pool', 'pools_at', 'read', 'split_class']