Howlwind/TheriapolisV3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

M6.5: StepSkills + ability-bonus breakdown + Aside redesign

Browse Source 
The skills step lands as the last data-driven character creation step
(only Sign — name + confirm — remains for M6.6). Brought a few cross-
cutting refactors with it.

Scenes/Steps/StepSkills.cs:
  Direct port of StepSkills in src/steps.jsx — all 18 skills laid out
  in 6 ability-grouped panels (STR/DEX/CON/INT/WIS/CHA), 2-column
  grid. Background-granted skills appear pre-checked and locked;
  user picks `class.SkillsChoose` more from `class.SkillOptions`.
  Hover the skill name → popover with the codex flavor description
  (limited to the title only — hovering checkboxes / source tags
  doesn't trigger the popover, avoids interference with adjacent
  rows' click targets). Fixed-width [✓] / [ ] / [—] checkbox slot
  so toggling doesn't shift the row layout.

UI/SkillsCatalog.cs (new):
  Static skill table — JSON id, display label, governing ability,
  and the codex SKILL_DESC text ported verbatim from src/data.jsx.
  Mirrors Theriapolis.Core.Rules.Stats.SkillId; descriptions live
  here because backgrounds.json and classes.json don't carry them.

UI/AbilityCalc.cs (new):
  Final-score math — base assignment + clade and species mods, with
  per-source breakdown for the bonus popover ("+1 from Canidae · +2
  from Wolf"). Hybrid mode tags each clade source with its lineage
  ("(sire)" / "(dam)"). Used by both StepStats and the Aside so the
  two views can never disagree on what a +N badge means.

UI/BackgroundAvailability.cs (new):
  Extracted from StepBackground — shared rules table for hybrid-only
  and clade-restricted backgrounds. Now also consulted by StepClade
  when the player changes lineage: the currently-selected background
  is auto-cleared if the new lineage no longer satisfies its rule
  (e.g., Pack-Raised clears when switching from Canidae to Felidae,
  Passer clears when toggling Hybrid off). Implemented via
  Resource.Duplicate + Patch on the duplicate to evaluate the
  hypothetical post-patch state without committing prematurely.

StepStats.cs:
  Per-row layout extended: ability label | slot | bonus chip | final
  | d20 mod. Bonus chip is a TraitChip with the per-source breakdown
  in its hover description. Auto-assign now sorts empty abilities by
  AbilityCalc.TotalBonus DESCENDING (with class.PrimaryAbility as
  tiebreaker) — biggest pool value lands on the ability already
  receiving the biggest lineage bonus, maximising final scores.

Aside.cs (significant redesign):
  - Name centered at top.
  - Lineage details: 2-column grid, full-width.
    - Purebred:  Clade | Species, then Calling | Background, then
                 Subclass | (empty).
    - Hybrid:    SIRE ★ | DAM (centered + underlined column heads),
                 Clade | Clade, Species | Species, then the same
                 calling/background/subclass rows.
  - Attributes: STR/DEX/CON/INT/WIS/CHA each with bonus chip (omitted
    when +0), final score, d20 modifier. Self-contained min-width
    table so it can't widen the panel beyond its alloc.
  - Pills: traits, detriments, level-1 features, background feature,
    skill chips (BG-locked + user-chosen). All hoverable for descriptions.
  - Whole panel wraps in a ScrollContainer so an over-tall summary
    scrolls in place instead of pushing the wizard layout off-screen.
  - Width nudged 320 → 360px. Smaller font on label tags, autowrap
    on value labels so long names ("Hybrid Underground") wrap rather
    than push the panel wider.

Card grids: changed all five card-grid steps (Clade, Species, Class,
Subclass, Background) from SizeFlagsHorizontal.ExpandFill →
ShrinkCenter. Cards stay at their CustomMinimumSize 200 wide and
the grid horizontally centers in PageMain. The right-side gap
between content and Aside is now uniform regardless of how many
cards or whether the last row is partial — fixes the "Clade tab
feels too padded, Background tab too tight" perception.

Closes M6.5. Per guide §12, what's left in M6: M6.6 (StepReview —
name + summary + Confirm handoff per guide §11) and M6.7 (parchment
Theme pass).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Christopher Wiebe
2026-05-03 18:10:05 -07:00
parent ce87eb11ad
commit 0e5d4b7425
13 changed files with 793 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Theriapolis.Godot/Scenes/Aside.cs
+286 -31
View File
@@ -1,14 +1,22 @@
using Godot;
using System.Collections.Generic;
using Theriapolis.GodotHost.Scenes.Widgets;
using Theriapolis.GodotHost.UI;
namespace Theriapolis.GodotHost.Scenes;
/// <summary>
/// Right-rail summary of the in-progress character. Single
/// <see cref="Refresh"/> rebuilds every section per
/// GODOT_PORTING_GUIDE.md §10 — the panel is small enough that full
/// rebuild is cheap and partial-update logic isn't worth it. Connect
/// the draft via <see cref="SetDraft"/>; the Wizard does this on _Ready.
/// Right-rail summary of the in-progress character. Sections, top-down:
/// 1. Name (or placeholder until Step VIII).
/// 2. Lineage details — 2-column grid:
/// purebred: Clade | Species, then Calling | Background.
/// hybrid: Sire | Dam (column headers); each parent's
/// clade and species below; Calling | Background.
/// 3. Attributes — final score + d20 modifier per ability.
/// 4. Pills — traits + skills selected so far, with hover popovers.
///
/// One Refresh() rebuild per draft change; the panel is small enough
/// that partial-update logic isn't worth the complexity.
/// </summary>
public partial class Aside : MarginContainer
{
@@ -22,9 +30,21 @@ public partial class Aside : MarginContainer
AddThemeConstantOverride("margin_top", 18);
AddThemeConstantOverride("margin_bottom", 18);
_content = new VBoxContainer();
// Wrap content in a ScrollContainer so the Aside's intrinsic
// height stays bounded by the panel's allocated size — without
// this, an over-tall summary (lots of pills) forces the parent
// Layout to expand and pushes the navbar off the viewport.
var scroll = new ScrollContainer
{
SizeFlagsHorizontal = SizeFlags.ExpandFill,
SizeFlagsVertical = SizeFlags.ExpandFill,
HorizontalScrollMode = ScrollContainer.ScrollMode.Disabled,
};
AddChild(scroll);
_content = new VBoxContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
_content.AddThemeConstantOverride("separation", 18);
AddChild(_content);
scroll.AddChild(_content);
}
public void SetDraft(CharacterDraft draft)
@@ -39,42 +59,277 @@ public partial class Aside : MarginContainer
if (_draft is null || _content is null) return;
foreach (var c in _content.GetChildren()) c.QueueFree();
_content.AddChild(new Label { Text = "SUMMARY" });
BuildName();
BuildDetailsGrid();
BuildAttributes();
BuildPills();
}
if (_draft.IsHybrid)
// ──────────────────────────────────────────────────────────────────────
// Section 1 — Name
private void BuildName()
{
AddBlock("Origin", "Hybrid");
AddBlock(_draft.DominantParent == "sire" ? "Sire (dominant)" : "Sire",
FormatLineage(_draft.SireCladeId, _draft.SireSpeciesId));
AddBlock(_draft.DominantParent == "dam" ? "Dam (dominant)" : "Dam",
FormatLineage(_draft.DamCladeId, _draft.DamSpeciesId));
var name = string.IsNullOrEmpty(_draft!.CharacterName) ? "Unnamed" : _draft.CharacterName;
_content.AddChild(new Label
{
Text = name,
HorizontalAlignment = HorizontalAlignment.Center,
});
_content.AddChild(new HSeparator());
}
// ──────────────────────────────────────────────────────────────────────
// Section 2 — Lineage details (2-column grid)
private void BuildDetailsGrid()
{
if (_draft!.IsHybrid)
{
// Hybrid layout: SIRE / DAM column headers above the parent
// detail rows, then the Calling / Background row spans both
// halves of the same kind of grid.
var headers = new HBoxContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
headers.AddThemeConstantOverride("separation", 12);
_content.AddChild(headers);
headers.AddChild(MakeColumnHeader("SIRE" + (_draft.DominantParent == "sire" ? " ★" : "")));
headers.AddChild(MakeColumnHeader("DAM" + (_draft.DominantParent == "dam" ? " ★" : "")));
var lineageGrid = MakeFullWidthGrid();
_content.AddChild(lineageGrid);
lineageGrid.AddChild(MakeCell("Clade", CodexContent.Clade(_draft.SireCladeId)?.Name));
lineageGrid.AddChild(MakeCell("Clade", CodexContent.Clade(_draft.DamCladeId)?.Name));
lineageGrid.AddChild(MakeCell("Species", CodexContent.SpeciesById(_draft.SireSpeciesId)?.Name));
lineageGrid.AddChild(MakeCell("Species", CodexContent.SpeciesById(_draft.DamSpeciesId)?.Name));
}
else
{
AddBlock("Clade", CodexContent.Clade(_draft.CladeId)?.Name);
AddBlock("Species", CodexContent.SpeciesById(_draft.SpeciesId)?.Name);
var lineageGrid = MakeFullWidthGrid();
_content.AddChild(lineageGrid);
lineageGrid.AddChild(MakeCell("Clade", CodexContent.Clade(_draft.CladeId)?.Name));
lineageGrid.AddChild(MakeCell("Species", CodexContent.SpeciesById(_draft.SpeciesId)?.Name));
}
AddBlock("Calling", CodexContent.Class(_draft.ClassId)?.Name);
AddBlock("Background", CodexContent.Background(_draft.BackgroundId)?.Name);
AddBlock("Name", string.IsNullOrEmpty(_draft.CharacterName) ? null : _draft.CharacterName);
// Calling + Background — last row of the lineage block, with
// Subclass tucked underneath Calling in the same column.
var callingGrid = MakeFullWidthGrid();
_content.AddChild(callingGrid);
callingGrid.AddChild(MakeCell("Calling", CodexContent.Class(_draft.ClassId)?.Name));
callingGrid.AddChild(MakeCell("Background", CodexContent.Background(_draft.BackgroundId)?.Name));
var subclassDef = System.Array.Find(CodexContent.Subclasses, s => s.Id == _draft.SubclassId);
callingGrid.AddChild(MakeCell("Subclass", subclassDef?.Name));
callingGrid.AddChild(new Control()); // empty cell to align grid
_content.AddChild(new HSeparator());
}
private static string? FormatLineage(string cladeId, string speciesId)
private static GridContainer MakeFullWidthGrid()
{
var clade = CodexContent.Clade(cladeId);
var species = CodexContent.SpeciesById(speciesId);
if (clade is null && species is null) return null;
if (species is not null) return $"{species.Name} ({clade?.Name ?? cladeId})";
return clade?.Name;
var grid = new GridContainer { Columns = 2, SizeFlagsHorizontal = SizeFlags.ExpandFill };
grid.AddThemeConstantOverride("h_separation", 12);
grid.AddThemeConstantOverride("v_separation", 8);
return grid;
}
private void AddBlock(string label, string? value)
private static Control MakeColumnHeader(string label)
{
var v = new VBoxContainer();
v.AddThemeConstantOverride("separation", 4);
_content.AddChild(v);
v.AddChild(new Label { Text = label.ToUpperInvariant() });
v.AddChild(new Label { Text = value ?? "—" });
// Centered label + underline; sized to take half the parent
// HBoxContainer width so SIRE and DAM align over their data
// columns.
var col = new VBoxContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
col.AddThemeConstantOverride("separation", 2);
col.AddChild(new Label
{
Text = label,
HorizontalAlignment = HorizontalAlignment.Center,
});
col.AddChild(new HSeparator());
return col;
}
private static Control MakeCell(string label, string? value)
{
var v = new VBoxContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
v.AddThemeConstantOverride("separation", 2);
// Smaller font on the label tag — keeps the row compact in the
// narrow side rail.
var lbl = new Label { Text = label.ToUpperInvariant() };
lbl.AddThemeFontSizeOverride("font_size", 11);
v.AddChild(lbl);
// Autowrap on the value so long names ("Hybrid Underground")
// wrap rather than push the whole panel wider than its alloc.
var val = new Label
{
Text = string.IsNullOrEmpty(value) ? "—" : value,
AutowrapMode = TextServer.AutowrapMode.WordSmart,
CustomMinimumSize = new Vector2(0, 0),
};
v.AddChild(val);
return v;
}
// ──────────────────────────────────────────────────────────────────────
// Section 3 — Attributes (final score + modifier)
private void BuildAttributes()
{
_content.AddChild(new Label { Text = "ATTRIBUTES" });
// Self-contained sub-panel so the attributes table never widens
// beyond the Aside's own rect. Columns: ab | bonus | final | d20.
// Cells have explicit min widths but DON'T ExpandFill, so the
// grid's total width is bounded by the cell mins instead of
// taking whatever parent width is available.
var grid = new GridContainer { Columns = 4 };
grid.AddThemeConstantOverride("h_separation", 6);
grid.AddThemeConstantOverride("v_separation", 6);
_content.AddChild(grid);
foreach (var ab in SkillsCatalog.Abilities)
{
int baseScore = AbilityCalc.BaseScore(ab, _draft!);
int bonus = AbilityCalc.TotalBonus(ab, _draft!);
int final = baseScore + bonus;
int dMod = AbilityCalc.D20Modifier(final);
grid.AddChild(new Label
{
Text = ab,
CustomMinimumSize = new Vector2(36, 0),
});
// Bonus chip — only render when non-zero. +0 entries get an
// empty Control so the column stays aligned without the
// panel chrome of an empty TraitChip pushing the row wider.
if (bonus != 0)
{
grid.AddChild(new Widgets.TraitChip
{
TraitName = AbilityCalc.FormatSigned(bonus),
Description = AbilityCalc.FormatBreakdown(AbilityCalc.Sources(ab, _draft!)),
Tag = "bonus",
});
}
else
{
grid.AddChild(new Control { CustomMinimumSize = new Vector2(40, 0) });
}
grid.AddChild(new Label
{
Text = baseScore == 0 ? "—" : final.ToString(),
HorizontalAlignment = HorizontalAlignment.Right,
CustomMinimumSize = new Vector2(36, 0),
});
grid.AddChild(new Label
{
Text = baseScore == 0 ? "" : AbilityCalc.FormatSigned(dMod),
HorizontalAlignment = HorizontalAlignment.Right,
CustomMinimumSize = new Vector2(36, 0),
});
}
_content.AddChild(new HSeparator());
}
// ──────────────────────────────────────────────────────────────────────
// Section 4 — Pills (traits, skills, features chosen so far)
private void BuildPills()
{
_content.AddChild(new Label { Text = "TRAITS · FEATS · SKILLS" });
var flow = new HFlowContainer();
flow.AddThemeConstantOverride("h_separation", 6);
flow.AddThemeConstantOverride("v_separation", 6);
_content.AddChild(flow);
// Clade traits (purebred = single clade; hybrid = both).
if (_draft!.IsHybrid)
{
AddCladeTraits(flow, CodexContent.Clade(_draft.SireCladeId));
AddCladeTraits(flow, CodexContent.Clade(_draft.DamCladeId));
}
else
{
AddCladeTraits(flow, CodexContent.Clade(_draft.CladeId));
}
// Species traits.
var sp = CodexContent.SpeciesById(_draft.EffectiveSpeciesId);
if (sp is not null)
{
foreach (var t in sp.Traits)
flow.AddChild(new TraitChip { TraitName = t.Name, Description = t.Description });
foreach (var d in sp.Detriments)
flow.AddChild(new TraitChip { TraitName = d.Name, Description = d.Description, Detriment = true });
}
// Class level-1 features.
var cls = CodexContent.Class(_draft.ClassId);
if (cls is not null)
{
var lvl1 = System.Array.Find(cls.LevelTable, e => e.Level == 1);
if (lvl1 is not null)
{
foreach (var fid in lvl1.Features)
{
if (!cls.FeatureDefinitions.TryGetValue(fid, out var fd)) continue;
if (fd.Kind == "stub" || fid.StartsWith("subclass_")) continue;
flow.AddChild(new TraitChip
{
TraitName = fd.Name,
Description = fd.Description,
Tag = fd.Kind,
});
}
}
}
// Background feature + granted skills.
var bg = CodexContent.Background(_draft.BackgroundId);
if (bg is not null && !string.IsNullOrEmpty(bg.FeatureName))
{
flow.AddChild(new TraitChip
{
TraitName = bg.FeatureName,
Description = bg.FeatureDescription,
Tag = "history",
});
}
// Skills — background-locked first, then user-chosen class skills.
if (bg is not null)
{
foreach (var skillId in bg.SkillProficiencies)
AddSkillChip(flow, skillId, "BG");
}
foreach (var skillId in _draft.ChosenSkills)
AddSkillChip(flow, skillId, "skill");
}
private static void AddCladeTraits(HFlowContainer flow, Theriapolis.Core.Data.CladeDef? clade)
{
if (clade is null) return;
foreach (var t in clade.Traits)
flow.AddChild(new TraitChip { TraitName = t.Name, Description = t.Description });
foreach (var d in clade.Detriments)
flow.AddChild(new TraitChip { TraitName = d.Name, Description = d.Description, Detriment = true });
}
private static void AddSkillChip(HFlowContainer flow, string skillId, string tag)
{
var s = SkillsCatalog.Get(skillId);
if (s is null) return;
flow.AddChild(new TraitChip
{
TraitName = s.Label,
Description = s.Description,
Tag = tag,
});
}
}
Theriapolis.Godot/Scenes/Aside.tscn
+1 -1
View File
@@ -4,6 +4,6 @@
[node name="Aside" type="MarginContainer"]
unique_name_in_owner = true
custom_minimum_size = Vector2(320, 0)
custom_minimum_size = Vector2(360, 0)
size_flags_horizontal = 0
script = ExtResource("1_aside")
Theriapolis.Godot/Scenes/Steps/StepBackground.cs
+2 -26
View File
@@ -43,7 +43,7 @@ public partial class StepBackground : VBoxContainer, IStep
AutowrapMode = TextServer.AutowrapMode.WordSmart,
});
_grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
_grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
_grid.AddThemeConstantOverride("h_separation", 16);
_grid.AddThemeConstantOverride("v_separation", 16);
AddChild(_grid);
@@ -51,37 +51,13 @@ public partial class StepBackground : VBoxContainer, IStep
Refresh();
}
/// <summary>
/// Background-availability rules. The backgrounds.json schema doesn't
/// carry restriction fields — the gating lives in flavor text only —
/// so they're hardcoded here. Each predicate returns true when the
/// background is available to the given draft; missing entries are
/// universally available.
///
/// If backgrounds.json ever gains structured restriction fields,
/// swap these out for a property-driven check.
/// </summary>
private static readonly System.Collections.Generic.Dictionary<string, System.Func<UI.CharacterDraft, bool>> AvailabilityRules = new()
{
// Hybrid-only backgrounds — flavor text explicitly hybrid.
{ "passer", d => d.IsHybrid },
{ "hybrid_underground", d => d.IsHybrid },
{ "former_chattel", d => d.IsHybrid },
// Clade-restricted backgrounds.
{ "warren_runner", d => d.HasClade("leporidae") },
{ "pack_raised", d => d.HasClade("canidae") },
{ "herd_city_born", d => d.HasAnyCladeOfKind("prey") },
};
private void Refresh()
{
if (_grid is null) return;
foreach (var c in _grid.GetChildren()) c.QueueFree();
foreach (var bg in CodexContent.Backgrounds)
{
if (AvailabilityRules.TryGetValue(bg.Id, out var rule) && !rule(_draft))
continue;
if (!BackgroundAvailability.IsAvailable(bg.Id, _draft)) continue;
_grid.AddChild(BuildCard(bg));
}
}
Theriapolis.Godot/Scenes/Steps/StepClade.cs
+25 -3
View File
@@ -101,7 +101,7 @@ public partial class StepClade : VBoxContainer, IStep
private static GridContainer MakeGrid()
{
var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
grid.AddThemeConstantOverride("h_separation", 16);
grid.AddThemeConstantOverride("v_separation", 16);
return grid;
@@ -132,6 +132,7 @@ public partial class StepClade : VBoxContainer, IStep
patch["dam_clade_id"] = "";
patch["dam_species_id"] = "";
}
ClearBackgroundIfInvalidated(patch);
_draft.Patch(patch);
}
@@ -172,11 +173,13 @@ public partial class StepClade : VBoxContainer, IStep
var sp = CodexContent.SpeciesById(speciesId);
if (sp is null || !string.Equals(sp.CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase))
speciesId = "";
_draft.Patch(new Godot.Collections.Dictionary
var patch = new Godot.Collections.Dictionary
{
{ "clade_id", cladeId },
{ "species_id", speciesId },
});
};
ClearBackgroundIfInvalidated(patch);
_draft.Patch(patch);
}
private void OnLineageCladePicked(string lineage, string cladeId)
@@ -189,9 +192,28 @@ public partial class StepClade : VBoxContainer, IStep
var sp = CodexContent.SpeciesById(currentSpecies);
if (sp is null || !string.Equals(sp.CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase))
patch[lineage + "_species_id"] = "";
ClearBackgroundIfInvalidated(patch);
_draft.Patch(patch);
}
/// <summary>
/// Clade changes can make a previously-valid background unavailable
/// (e.g. picking Felidae while Pack-Raised is selected). Build the
/// hypothetical post-patch state via Resource.Duplicate, run it
/// through BackgroundAvailability, and clear background_id in the
/// patch if the rule no longer matches.
/// </summary>
private void ClearBackgroundIfInvalidated(Godot.Collections.Dictionary patch)
{
if (string.IsNullOrEmpty(_draft.BackgroundId)) return;
var future = (CharacterDraft)_draft.Duplicate();
// Apply the same patch we're about to commit, in-place on the copy.
future.Patch(patch);
if (!BackgroundAvailability.IsAvailable(_draft.BackgroundId, future))
patch["background_id"] = "";
}
private PanelContainer BuildCard(CladeDef clade, System.Action<string> onClick)
{
var card = new PanelContainer
Theriapolis.Godot/Scenes/Steps/StepClass.cs
+1 -1
View File
@@ -47,7 +47,7 @@ public partial class StepClass : VBoxContainer, IStep
AutowrapMode = TextServer.AutowrapMode.WordSmart,
});
_grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
_grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
_grid.AddThemeConstantOverride("h_separation", 16);
_grid.AddThemeConstantOverride("v_separation", 16);
AddChild(_grid);
Theriapolis.Godot/Scenes/Steps/StepSkills.cs
+233
View File
@@ -0,0 +1,233 @@
using Godot;
using System.Collections.Generic;
using Theriapolis.GodotHost.Scenes.Widgets;
using Theriapolis.GodotHost.UI;
namespace Theriapolis.GodotHost.Scenes.Steps;
/// <summary>
/// Step VII — Skills. Direct port of <c>StepSkills</c> in
/// <c>src/steps.jsx</c>: 18 skills laid out in 6 ability groups
/// (STR / DEX / CON / INT / WIS / CHA). Background-granted skills are
/// pre-checked and locked; the user picks <c>class.SkillsChoose</c>
/// more from <c>class.SkillOptions</c>. Hover any skill row → popover
/// with the description.
///
/// State:
/// - "locked" → granted by background, can't toggle (✓ shown)
/// - "checked" → user-picked from class options (✓ shown)
/// - "available" → in class options, unchecked
/// - "unavailable" → not in class options, dimmed and unclickable
/// </summary>
public partial class StepSkills : VBoxContainer, IStep
{
private CharacterDraft _draft = null!;
private Label _countLabel = null!;
private Label _classBgLabel = null!;
private GridContainer _groupsGrid = null!;
public void Bind(CharacterDraft draft)
{
_draft = draft;
_draft.Changed += () => Callable.From(Refresh).CallDeferred();
Build();
}
public string? Validate() => WizardValidation.Validate(6, _draft);
private void Build()
{
AddThemeConstantOverride("separation", 16);
var intro = new VBoxContainer();
intro.AddThemeConstantOverride("separation", 6);
AddChild(intro);
intro.AddChild(new Label { Text = "FOLIO VII · SKILLS" });
intro.AddChild(new Label { Text = "Choose Your Skills" });
intro.AddChild(new Label
{
Text = "Your background grants two skills automatically (sealed). From your "
+ "calling's offered list, choose the rest. Hover any skill for its codex "
+ "reading.",
AutowrapMode = TextServer.AutowrapMode.WordSmart,
});
var meta = new HBoxContainer();
meta.AddThemeConstantOverride("separation", 24);
AddChild(meta);
_countLabel = new Label { Text = "0 / 0 chosen" };
meta.AddChild(_countLabel);
var spacer = new Control { SizeFlagsHorizontal = SizeFlags.ExpandFill };
meta.AddChild(spacer);
_classBgLabel = new Label { Text = "" };
meta.AddChild(_classBgLabel);
_groupsGrid = new GridContainer
{
Columns = 2,
SizeFlagsHorizontal = SizeFlags.ExpandFill,
};
_groupsGrid.AddThemeConstantOverride("h_separation", 18);
_groupsGrid.AddThemeConstantOverride("v_separation", 18);
AddChild(_groupsGrid);
Refresh();
}
private void Refresh()
{
if (_groupsGrid is null) return;
var cls = CodexContent.Class(_draft.ClassId);
var bg = CodexContent.Background(_draft.BackgroundId);
int required = cls?.SkillsChoose ?? 0;
var lockedFromBg = new HashSet<string>(bg?.SkillProficiencies ?? System.Array.Empty<string>());
var classOptions = new HashSet<string>(cls?.SkillOptions ?? System.Array.Empty<string>());
var chosen = new HashSet<string>(_draft.ChosenSkills);
_countLabel.Text = $"{chosen.Count} / {required} chosen +{lockedFromBg.Count} sealed by background";
_classBgLabel.Text = (cls is null ? "Pick a calling first." :
$"Calling: {cls.Name} · History: {bg?.Name ?? "—"}").ToUpperInvariant();
foreach (var c in _groupsGrid.GetChildren()) c.QueueFree();
if (cls is null) return;
foreach (var ability in SkillsCatalog.Abilities)
_groupsGrid.AddChild(BuildAbilityGroup(ability, lockedFromBg, classOptions, chosen, required));
}
private Control BuildAbilityGroup(string ability,
HashSet<string> lockedFromBg,
HashSet<string> classOptions,
HashSet<string> chosen,
int required)
{
var panel = new PanelContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
var col = new VBoxContainer();
col.AddThemeConstantOverride("separation", 4);
panel.AddChild(col);
// Header — full ability name + abbreviation.
var header = new HBoxContainer();
header.AddThemeConstantOverride("separation", 8);
col.AddChild(header);
header.AddChild(new Label { Text = SkillsCatalog.AbilityFullName[ability] });
var spacer = new Control { SizeFlagsHorizontal = SizeFlags.ExpandFill };
header.AddChild(spacer);
header.AddChild(new Label { Text = ability });
foreach (var s in SkillsCatalog.ByAbility(ability))
col.AddChild(BuildSkillRow(s, lockedFromBg, classOptions, chosen, required));
return panel;
}
private Control BuildSkillRow(SkillsCatalog.SkillEntry skill,
HashSet<string> lockedFromBg,
HashSet<string> classOptions,
HashSet<string> chosen,
int required)
{
bool fromBg = lockedFromBg.Contains(skill.JsonId);
bool fromClass = classOptions.Contains(skill.JsonId);
bool isChecked = chosen.Contains(skill.JsonId);
bool clickable = fromClass && !fromBg;
var row = new PanelContainer
{
MouseFilter = MouseFilterEnum.Stop,
};
// Visual state: dim unavailable rows, gild-tint background-locked,
// brighten chosen. Theming pass will replace Modulate with proper
// styleboxes per state.
if (fromBg)
row.Modulate = new Color(1f, 0.95f, 0.7f);
else if (!fromClass)
row.Modulate = new Color(1f, 1f, 1f, 0.4f);
else if (isChecked)
row.Modulate = new Color(0.95f, 1f, 0.95f);
var rowH = new HBoxContainer { MouseFilter = MouseFilterEnum.Pass };
rowH.AddThemeConstantOverride("separation", 8);
row.AddChild(rowH);
// Fixed-width slot for the checkbox so the name doesn't jump
// horizontally when toggling — "[✓]" and "[ ]" render at slightly
// different widths in proportional fonts.
var checkbox = new Label
{
Text = (fromBg || isChecked) ? "[✓]" : (clickable ? "[ ]" : "[—]"),
CustomMinimumSize = new Vector2(36, 0),
HorizontalAlignment = HorizontalAlignment.Center,
MouseFilter = MouseFilterEnum.Ignore,
};
rowH.AddChild(checkbox);
// Skill name — the only hover trigger for the popover. MouseFilter
// = Stop so MouseEntered/Exited fire on this label specifically;
// GuiInput handles click here too so toggling works whether you
// click the name or the row's other areas.
var nameLabel = new Label
{
Text = skill.Label,
SizeFlagsHorizontal = SizeFlags.ExpandFill,
MouseFilter = MouseFilterEnum.Stop,
};
rowH.AddChild(nameLabel);
nameLabel.MouseEntered += () =>
PopoverLayer.Instance?.ShowFor(nameLabel, skill.Label, skill.Description, skill.Ability, false);
nameLabel.MouseExited += () =>
PopoverLayer.Instance?.ScheduleClose();
if (clickable)
{
nameLabel.GuiInput += (InputEvent e) =>
{
if (e is InputEventMouseButton mb && mb.Pressed && mb.ButtonIndex == MouseButton.Left)
Toggle(skill.JsonId, isChecked, required);
};
}
rowH.AddChild(new Label
{
Text = fromBg ? "BG" : (fromClass ? "CLASS" : "—"),
MouseFilter = MouseFilterEnum.Ignore,
});
// Click anywhere else on the row → also toggles. Hover here doesn't
// trigger the popover; only the name label does.
if (clickable)
{
row.GuiInput += (InputEvent e) =>
{
if (e is InputEventMouseButton mb && mb.Pressed && mb.ButtonIndex == MouseButton.Left)
Toggle(skill.JsonId, isChecked, required);
};
}
return row;
}
private void Toggle(string skillId, bool isCurrentlyChecked, int required)
{
var newChosen = new Godot.Collections.Array<string>(_draft.ChosenSkills);
if (isCurrentlyChecked)
{
newChosen.Remove(skillId);
}
else if (newChosen.Count < required)
{
newChosen.Add(skillId);
}
else
{
return; // already at the cap; no-op
}
_draft.Patch(new Godot.Collections.Dictionary
{
{ "chosen_skills", newChosen },
});
}
}
Theriapolis.Godot/Scenes/Steps/StepSpecies.cs
+1 -1
View File
@@ -72,7 +72,7 @@ public partial class StepSpecies : VBoxContainer, IStep
private static GridContainer MakeGrid()
{
var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
var grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
grid.AddThemeConstantOverride("h_separation", 16);
grid.AddThemeConstantOverride("v_separation", 16);
return grid;
Theriapolis.Godot/Scenes/Steps/StepStats.cs
+54 -2
View File
@@ -33,6 +33,9 @@ public partial class StepStats : VBoxContainer, IStep
private CharacterDraft _draft = null!;
private AbilityPool _pool = null!;
private readonly Dictionary<string, AbilitySlot> _slots = new();
private readonly Dictionary<string, TraitChip> _bonusChips = new();
private readonly Dictionary<string, Label> _finalLabels = new();
private readonly Dictionary<string, Label> _dModLabels = new();
private Button _arrayBtn = null!;
private Button _rollBtn = null!;
private Button _rerollBtn = null!;
@@ -125,6 +128,34 @@ public partial class StepStats : VBoxContainer, IStep
=> HandleSlotDrop(payload, captured);
_slots[captured] = slot;
row.AddChild(slot);
// Bonus chip — hover for the per-source breakdown.
var bonus = new TraitChip { TraitName = "+0", Description = "" };
bonus.CustomMinimumSize = new Vector2(56, 0);
_bonusChips[captured] = bonus;
row.AddChild(bonus);
// Final score (= base + total bonus).
var finalLbl = new Label
{
Text = "—",
CustomMinimumSize = new Vector2(48, 0),
HorizontalAlignment = HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Center,
};
_finalLabels[captured] = finalLbl;
row.AddChild(finalLbl);
// d20 modifier from final score.
var dModLbl = new Label
{
Text = "",
CustomMinimumSize = new Vector2(48, 0),
HorizontalAlignment = HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Center,
};
_dModLabels[captured] = dModLbl;
row.AddChild(dModLbl);
}
Refresh();
@@ -161,6 +192,23 @@ public partial class StepStats : VBoxContainer, IStep
_pool.AddChild(token);
}
// Bonus / final / d20 mod per ability — updated in place from the
// computed mod sources so the row stays stable across drops.
foreach (var ab in Abilities)
{
int bonus = AbilityCalc.TotalBonus(ab, _draft);
int baseScore = AbilityCalc.BaseScore(ab, _draft);
int final = baseScore + bonus;
int dMod = AbilityCalc.D20Modifier(final);
_bonusChips[ab].SetTrait(
AbilityCalc.FormatSigned(bonus),
AbilityCalc.FormatBreakdown(AbilityCalc.Sources(ab, _draft)),
tag: "bonus");
_finalLabels[ab].Text = baseScore == 0 ? "—" : final.ToString();
_dModLabels[ab].Text = baseScore == 0 ? "" : AbilityCalc.FormatSigned(dMod);
}
// Slots: token if assigned, otherwise dash placeholder.
foreach (var (ab, slot) in _slots)
{
@@ -265,12 +313,16 @@ public partial class StepStats : VBoxContainer, IStep
{
if (_draft.StatPool.Count == 0) return;
// Empty slots, ordered by class primary abilities first.
// Empty slots, ordered DESCENDING by their clade+species bonus —
// highest pool value goes to the ability with the highest bonus
// already coming in, maximising the final score on each. Ties
// broken by class.PrimaryAbility order.
var cls = CodexContent.Class(_draft.ClassId);
var primary = cls?.PrimaryAbility ?? System.Array.Empty<string>();
var emptyAbilities = Abilities
.Where(a => !_draft.StatAssign.ContainsKey(a))
.OrderBy(a =>
.OrderByDescending(a => AbilityCalc.TotalBonus(a, _draft))
.ThenBy(a =>
{
int idx = System.Array.IndexOf(primary, a);
return idx < 0 ? 99 : idx;
Theriapolis.Godot/Scenes/Steps/StepSubclass.cs
+1 -1
View File
@@ -50,7 +50,7 @@ public partial class StepSubclass : VBoxContainer, IStep
AutowrapMode = TextServer.AutowrapMode.WordSmart,
});
_grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ExpandFill };
_grid = new GridContainer { Columns = 3, SizeFlagsHorizontal = SizeFlags.ShrinkCenter };
_grid.AddThemeConstantOverride("h_separation", 16);
_grid.AddThemeConstantOverride("v_separation", 16);
AddChild(_grid);
Theriapolis.Godot/Scenes/Wizard.cs
+1 -1
View File
@@ -50,7 +50,7 @@ public partial class Wizard : Control
typeof(Steps.StepSubclass), // 3 Subclass
typeof(Steps.StepBackground), // 4 History
typeof(Steps.StepStats), // 5 Abilities
null, // 6 Skills — M6.5
typeof(Steps.StepSkills), // 6 Skills
null, // 7 Sign — M6.6
};
Theriapolis.Godot/UI/AbilityCalc.cs
+69
View File
@@ -0,0 +1,69 @@
using System.Collections.Generic;
using System.Linq;
using Theriapolis.Core.Data;
namespace Theriapolis.GodotHost.UI;
/// <summary>
/// Final ability score math — base assignment + clade and species mods.
/// Used by StepStats and Aside to render the score breakdown with a
/// "+N from Canidae · +2 from Wolf" hover popover.
///
/// For hybrids the lineage contribution comes from BOTH parent clades
/// (each tagged with its lineage in the source label) and the dominant
/// species. Core's CharacterBuilder.TryBuildHybrid is the authority on
/// the final mechanical rules at character-finalize time; this is a
/// preview-display helper.
/// </summary>
public static class AbilityCalc
{
public readonly record struct ModSource(string Label, int Value);
public static List<ModSource> Sources(string ability, CharacterDraft draft)
{
var list = new List<ModSource>();
if (draft.IsHybrid)
{
AddCladeSource(list, ability, CodexContent.Clade(draft.SireCladeId), " (sire)");
AddCladeSource(list, ability, CodexContent.Clade(draft.DamCladeId), " (dam)");
}
else
{
AddCladeSource(list, ability, CodexContent.Clade(draft.CladeId), "");
}
var sp = CodexContent.SpeciesById(draft.EffectiveSpeciesId);
if (sp is not null) AddDictSource(list, ability, sp.Name, sp.AbilityMods);
return list;
}
public static int TotalBonus(string ability, CharacterDraft draft)
=> Sources(ability, draft).Sum(s => s.Value);
public static int BaseScore(string ability, CharacterDraft draft)
=> draft.StatAssign.ContainsKey(ability) ? (int)draft.StatAssign[ability] : 0;
public static int FinalScore(string ability, CharacterDraft draft)
=> BaseScore(ability, draft) + TotalBonus(ability, draft);
public static int D20Modifier(int score) => (int)System.Math.Floor((score - 10) / 2.0);
public static string FormatSigned(int n) => n >= 0 ? $"+{n}" : n.ToString();
/// <summary>"+1 from Canidae · +2 from Wolf" — empty when no sources.</summary>
public static string FormatBreakdown(IEnumerable<ModSource> sources) =>
string.Join(" · ", sources.Select(s => $"{FormatSigned(s.Value)} from {s.Label}"));
private static void AddCladeSource(List<ModSource> list, string ability, CladeDef? clade, string suffix)
{
if (clade is null) return;
AddDictSource(list, ability, clade.Name + suffix, clade.AbilityMods);
}
private static void AddDictSource(List<ModSource> list, string ability, string sourceName, Dictionary<string, int> mods)
{
if (mods.TryGetValue(ability, out int v) && v != 0)
list.Add(new ModSource(sourceName, v));
}
}
Theriapolis.Godot/UI/BackgroundAvailability.cs
+41
View File
@@ -0,0 +1,41 @@
using System.Collections.Generic;
namespace Theriapolis.GodotHost.UI;
/// <summary>
/// Per-background availability rules — which backgrounds are visible /
/// pickable for a given <see cref="CharacterDraft"/>. The
/// backgrounds.json schema doesn't carry restriction fields (gating
/// lives in flavor text), so they're hardcoded here.
///
/// Used by StepBackground to filter the visible card list and by
/// StepClade to clear the currently-selected background when a clade
/// change makes it no longer valid (e.g. picking a non-canid lineage
/// while Pack-Raised is selected).
/// </summary>
public static class BackgroundAvailability
{
private static readonly Dictionary<string, System.Func<CharacterDraft, bool>> Rules = new()
{
// Hybrid-only backgrounds — flavor text explicitly hybrid.
{ "passer", d => d.IsHybrid },
{ "hybrid_underground", d => d.IsHybrid },
{ "former_chattel", d => d.IsHybrid },
// Clade-restricted backgrounds.
{ "warren_runner", d => d.HasClade("leporidae") },
{ "pack_raised", d => d.HasClade("canidae") },
{ "herd_city_born", d => d.HasAnyCladeOfKind("prey") },
};
/// <summary>True if the background id can be picked under the given
/// draft state. Backgrounds not in the rules table are universally
/// available; the empty id is also "available" (means no
/// background selected).</summary>
public static bool IsAvailable(string backgroundId, CharacterDraft draft)
{
if (string.IsNullOrEmpty(backgroundId)) return true;
if (!Rules.TryGetValue(backgroundId, out var rule)) return true;
return rule(draft);
}
}
Theriapolis.Godot/UI/SkillsCatalog.cs
+78
View File
@@ -0,0 +1,78 @@
namespace Theriapolis.GodotHost.UI;
/// <summary>
/// All 18 skills with display labels, governing ability, and codex
/// flavor descriptions. Entries are keyed by their snake_case JSON id —
/// the same string that appears in <c>class.skill_options</c> and
/// <c>background.skill_proficiencies</c> in <c>Content/Data</c>.
///
/// Labels and ability mapping mirror Theriapolis.Core.Rules.Stats.SkillId;
/// descriptions are ported verbatim from <c>src/data.jsx</c>'s
/// <c>SKILL_DESC</c> table in the React prototype. If the JSON schema
/// gains a description field later, swap to a data-driven lookup.
/// </summary>
public static class SkillsCatalog
{
public record SkillEntry(string JsonId, string Label, string Ability, string Description);
public static readonly SkillEntry[] All =
{
new("acrobatics", "Acrobatics", "DEX",
"Tumbling, balance, and the kind of footwork that keeps you upright on a coliseum sand-floor or a warren-rope. Body-cunning under pressure."),
new("animal_handling", "Animal Handling", "WIS",
"Reading and steering non-sentient beasts — feral hounds, draft-kine, the wild cousins of your own clade. Calming, herding, riding."),
new("arcana", "Arcana", "INT",
"Knowledge of the older magics: scent-sorcery, blood-sigil, the half-forgotten rites that pre-date the Covenant of Claws."),
new("athletics", "Athletics", "STR",
"Raw physical effort. Climbing scaffold, swimming the foul canal, hauling a packmate from the pit, breaking a hold."),
new("deception", "Deception", "CHA",
"Speaking convincingly past your scent. The art of the false posture, the planted rumor, the answer that is technically true."),
new("history", "History", "INT",
"The long memory of Theriapolis — the Imperium's fall, the Compact's ratification, which clade owes which other a centuries-old debt."),
new("insight", "Insight", "WIS",
"Reading another's true posture beneath their words. Catching the off-note in a snarl, the held breath, the lie in a friendly tail."),
new("intimidation", "Intimidation", "CHA",
"Bared-teeth diplomacy. The threat made plain enough that violence is not required to extract compliance."),
new("investigation", "Investigation", "INT",
"Methodical search and inference: scene-reading, document-sifting, the patient accumulation of small facts into a verdict."),
new("medicine", "Medicine", "WIS",
"Field surgery, poultice-craft, knowing which clade tolerates which tincture. Stabilizing the dying without finishing them."),
new("nature", "Nature", "INT",
"Knowledge of the wild outside the city wall — terrain, weather, plant-lore, and the unsigned beasts that observe no Covenant."),
new("perception", "Perception", "WIS",
"Awareness through every sense your clade gives you: ear-cock, scent-prickle, the half-glimpsed shape at the edge of vision."),
new("performance", "Performance", "CHA",
"Holding an audience — coliseum crowd, courtroom gallery, market square. Song, oratory, the body that compels watching."),
new("persuasion", "Persuasion", "CHA",
"Open-handed argument. The case made on its merits, the appeal to mutual benefit, the patient construction of agreement."),
new("religion", "Religion", "INT",
"The hymn-cycles of the Cervid liturgy, the Compact's sacred clauses, the small household rites your clade keeps without thinking."),
new("sleight_of_hand", "Sleight of Hand", "DEX",
"Quiet fingers — pickpocketing, palmed coins, the swap performed under another's nose. Useful in markets and courtrooms alike."),
new("stealth", "Stealth", "DEX",
"Movement unseen and unsmelled. Wind-checking, scent-suppression, the slow weight-shift on a creaking floor."),
new("survival", "Survival", "WIS",
"Field-craft beyond the wall: tracking, foraging, fire-making, knowing which run-off is safe to drink and which carries the upstream butcher's leavings."),
};
public static readonly string[] Abilities = { "STR", "DEX", "CON", "INT", "WIS", "CHA" };
public static readonly System.Collections.Generic.Dictionary<string, string> AbilityFullName = new()
{
{ "STR", "Strength" },
{ "DEX", "Dexterity" },
{ "CON", "Constitution" },
{ "INT", "Intellect" },
{ "WIS", "Wisdom" },
{ "CHA", "Charisma" },
};
public static SkillEntry? Get(string jsonId) =>
System.Array.Find(All, s => s.JsonId == jsonId);
public static System.Collections.Generic.IEnumerable<SkillEntry> ByAbility(string ability)
{
foreach (var s in All)
if (s.Ability == ability) yield return s;
}
}