Christopher Wiebe
e1fb988969
Adds character Sex (male/female) as a top-level CharacterDraft field
required for every character, and species variants as a layer on top
of the base species record. Two variant axes:
- "sex": auto-resolves from CharacterDraft.Sex for purebreds; for
hybrids, pinned by parent role (sire = male, dam = female)
by definition. No picker needed beyond Step 0.
- "lineage": explicit per-species pick (Ram-Folk's sheep/goat). Has
its own picker on Step 1 (purebred path under the grid;
hybrid path embedded into the per-parent pick column).
Schema (Theriapolis.Core/Data):
- SpeciesDef gains VariantAxis (string) and Variants (array of
SpeciesVariantDef { Id, Name, Traits, Detriments }).
- JSON content not yet populated — that's M6.14.
CharacterDraft adds:
- Sex (required by Step 0 validation)
- SpeciesVariant / SireSpeciesVariant / DamSpeciesVariant
- ResolveVariantId(species, role) that returns the active variant
id for a given context — used by Aside to layer variant traits
onto the base species traits.
Step 0 (StepClade): sex picker row above the hybrid toggle. Two
toggle buttons radio-style.
Step 1 (StepSpecies): purebred path renders a lineage picker below
the grid when the picked species has VariantAxis == "lineage";
hybrid path embeds a lineage picker at the top of each parent's
pick column. Hover popovers summarise each variant's contents.
Validation: Sex is required at Step 0. Lineage variant required at
Step 1 for any picked species (purebred or per-hybrid-parent) with
VariantAxis == "lineage".
Aside: AddVariantContent layers the resolved variant's extra
traits/detriments onto the base species rendering, for both purebred
and hybrid paths.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
249 lines
13 KiB
C#
249 lines
13 KiB
C#
using Godot;
|
|
using System.Collections.Generic;
|
|
using Theriapolis.Core.Data;
|
|
using Theriapolis.GodotHost.Platform;
|
|
|
|
namespace Theriapolis.GodotHost.UI;
|
|
|
|
/// <summary>
|
|
/// In-progress character record. Resource (not Node) per
|
|
/// GODOT_PORTING_GUIDE.md §2.1: serializable via ResourceSaver.save,
|
|
/// inspectable in the editor, doesn't need tree presence.
|
|
///
|
|
/// Mirrors <c>app.jsx</c>'s <c>state</c> shape — clade/species/class/etc.,
|
|
/// stat assignment, chosen skills, name. Mutate via <see cref="Patch"/> so
|
|
/// every change emits <see cref="Changed"/>; the Aside and Wizard listen
|
|
/// and re-render on that single signal.
|
|
/// </summary>
|
|
[GlobalClass]
|
|
public partial class CharacterDraft : Resource
|
|
{
|
|
// NB: Resource defines its own `Changed` signal (emitted via EmitChanged()).
|
|
// We piggyback on it instead of declaring our own to avoid a name clash —
|
|
// listeners do `draft.Changed += ...` exactly the same way either way.
|
|
|
|
[Export] public string CladeId { get; set; } = "";
|
|
[Export] public string SpeciesId { get; set; } = "";
|
|
[Export] public string ClassId { get; set; } = "";
|
|
[Export] public string SubclassId { get; set; } = "";
|
|
[Export] public string BackgroundId { get; set; } = "";
|
|
|
|
/// <summary>"male" or "female". Required for every character. For
|
|
/// purebreds with sex-axis variants (Elk, Lion), drives variant
|
|
/// resolution. For hybrids, sire variant always resolves to "male"
|
|
/// and dam variant to "female" by parent-role definition — the
|
|
/// character's own Sex remains an identity field.</summary>
|
|
[Export] public string Sex { get; set; } = "";
|
|
|
|
/// <summary>Lineage-axis variant id picked for the purebred species
|
|
/// (e.g. "sheep" or "goat" for Ram-Folk). Empty if the picked species
|
|
/// has no lineage variant.</summary>
|
|
[Export] public string SpeciesVariant { get; set; } = "";
|
|
|
|
/// <summary>Hybrid: lineage-axis variant for sire's species.</summary>
|
|
[Export] public string SireSpeciesVariant { get; set; } = "";
|
|
/// <summary>Hybrid: lineage-axis variant for dam's species.</summary>
|
|
[Export] public string DamSpeciesVariant { get; set; } = "";
|
|
|
|
// ── Phase 6.5 hybrid origin ────────────────────────────────────────
|
|
/// <summary>True when the PC is a hybrid (two parent lineages).</summary>
|
|
[Export] public bool IsHybrid { get; set; }
|
|
[Export] public string SireCladeId { get; set; } = "";
|
|
[Export] public string SireSpeciesId { get; set; } = "";
|
|
[Export] public string DamCladeId { get; set; } = "";
|
|
[Export] public string DamSpeciesId { get; set; } = "";
|
|
/// <summary>"sire" or "dam" — which parent the PC presents as.</summary>
|
|
[Export] public string DominantParent { get; set; } = "sire";
|
|
|
|
// Per theriapolis-rpg-clades.md "Building a Hybrid", simplified:
|
|
// hybrids take ONE ability modifier from each parent Clade. The
|
|
// original no-stack rule (take +1 + free elsewhere on overlap) was
|
|
// dropped — overlapping picks just sum.
|
|
/// <summary>Ability key picked from sire's clade mods (e.g. "STR").</summary>
|
|
[Export] public string SireChosenAbility { get; set; } = "";
|
|
/// <summary>Ability key picked from dam's clade mods.</summary>
|
|
[Export] public string DamChosenAbility { get; set; } = "";
|
|
|
|
// Phase B trait pickers, per theriapolis-rpg-clades.md "Building a Hybrid":
|
|
// Clade traits: 2 from dominant parent + 1 from non-dominant (player's
|
|
// split). Detriments are inherited fully from both clades
|
|
// — no pick.
|
|
// Species trait: 1 per parent.
|
|
// Species detriment: 1 per parent.
|
|
/// <summary>Clade trait IDs picked from sire's clade. Length depends on
|
|
/// dominant: 2 if sire is dominant, 1 if dam is.</summary>
|
|
[Export] public Godot.Collections.Array<string> SireChosenCladeTraits { get; set; } = new();
|
|
[Export] public Godot.Collections.Array<string> DamChosenCladeTraits { get; set; } = new();
|
|
[Export] public string SireChosenSpeciesTrait { get; set; } = "";
|
|
[Export] public string DamChosenSpeciesTrait { get; set; } = "";
|
|
[Export] public string SireChosenSpeciesDetriment { get; set; } = "";
|
|
[Export] public string DamChosenSpeciesDetriment { get; set; } = "";
|
|
|
|
/// <summary>Number of clade traits the named lineage is allowed to pick:
|
|
/// 2 if it's the dominant parent, 1 otherwise.</summary>
|
|
public int CladeTraitLimit(string lineage) =>
|
|
lineage == DominantParent ? 2 : 1;
|
|
|
|
/// <summary>
|
|
/// Resolves the active variant id for a species. <paramref name="role"/>
|
|
/// is "" for purebred, "sire" or "dam" for hybrid lineages. Returns
|
|
/// empty when the species has no variants or the relevant pick/sex is
|
|
/// missing.
|
|
/// </summary>
|
|
public string ResolveVariantId(Theriapolis.Core.Data.SpeciesDef? species, string role)
|
|
{
|
|
if (species is null || string.IsNullOrEmpty(species.VariantAxis)) return "";
|
|
return species.VariantAxis switch
|
|
{
|
|
// Sex-axis: purebred uses character Sex; hybrid lineages are
|
|
// pinned by parent role (sire = male, dam = female).
|
|
"sex" => role switch
|
|
{
|
|
"sire" => "male",
|
|
"dam" => "female",
|
|
_ => Sex,
|
|
},
|
|
// Lineage-axis: explicit per-species pick.
|
|
"lineage" => role switch
|
|
{
|
|
"sire" => SireSpeciesVariant,
|
|
"dam" => DamSpeciesVariant,
|
|
_ => SpeciesVariant,
|
|
},
|
|
_ => "",
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resolves the "active" clade for downstream steps (Class / Subclass
|
|
/// / Background). Purebred uses <see cref="CladeId"/>; hybrids use
|
|
/// the dominant parent's clade.
|
|
/// </summary>
|
|
public string EffectiveCladeId => IsHybrid
|
|
? (DominantParent == "sire" ? SireCladeId : DamCladeId)
|
|
: CladeId;
|
|
|
|
/// <summary>Same logic as <see cref="EffectiveCladeId"/>, for species.</summary>
|
|
public string EffectiveSpeciesId => IsHybrid
|
|
? (DominantParent == "sire" ? SireSpeciesId : DamSpeciesId)
|
|
: SpeciesId;
|
|
|
|
/// <summary>True iff the character includes <paramref name="cladeId"/>
|
|
/// in its lineage. Purebred matches CladeId; hybrid matches if either
|
|
/// Sire or Dam clade equals the id (case-insensitive).</summary>
|
|
public bool HasClade(string cladeId)
|
|
{
|
|
if (string.IsNullOrEmpty(cladeId)) return false;
|
|
if (IsHybrid)
|
|
return string.Equals(SireCladeId, cladeId, System.StringComparison.OrdinalIgnoreCase)
|
|
|| string.Equals(DamCladeId, cladeId, System.StringComparison.OrdinalIgnoreCase);
|
|
return string.Equals(CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
/// <summary>True iff any clade in the character's lineage has the
|
|
/// given <paramref name="kind"/> ("predator" or "prey").</summary>
|
|
public bool HasAnyCladeOfKind(string kind)
|
|
{
|
|
if (IsHybrid)
|
|
{
|
|
return CodexContent.Clade(SireCladeId)?.Kind == kind
|
|
|| CodexContent.Clade(DamCladeId)?.Kind == kind;
|
|
}
|
|
return CodexContent.Clade(CladeId)?.Kind == kind;
|
|
}
|
|
|
|
/// <summary>"array" or "roll" — assignment method for ability scores.</summary>
|
|
[Export] public string StatMethod { get; set; } = "array";
|
|
[Export] public Godot.Collections.Array<int> StatPool { get; set; }
|
|
= new() { 15, 14, 13, 12, 10, 8 };
|
|
[Export] public Godot.Collections.Dictionary StatAssign { get; set; } = new();
|
|
|
|
[Export] public Godot.Collections.Array<string> ChosenSkills { get; set; } = new();
|
|
[Export] public string CharacterName { get; set; } = "";
|
|
|
|
/// <summary>
|
|
/// Mutate one or more fields, then emit Changed once. Mirrors
|
|
/// the JS prototype's <c>set(patch)</c> from app.jsx.
|
|
/// </summary>
|
|
public void Patch(Godot.Collections.Dictionary patch)
|
|
{
|
|
foreach (var key in patch.Keys)
|
|
{
|
|
string k = (string)key;
|
|
switch (k)
|
|
{
|
|
case "clade_id": CladeId = (string)patch[key]; break;
|
|
case "species_id": SpeciesId = (string)patch[key]; break;
|
|
case "class_id": ClassId = (string)patch[key]; break;
|
|
case "subclass_id": SubclassId = (string)patch[key]; break;
|
|
case "background_id": BackgroundId = (string)patch[key]; break;
|
|
case "stat_method": StatMethod = (string)patch[key]; break;
|
|
case "stat_pool": StatPool = (Godot.Collections.Array<int>)patch[key]; break;
|
|
case "stat_assign": StatAssign = (Godot.Collections.Dictionary)patch[key]; break;
|
|
case "chosen_skills": ChosenSkills = (Godot.Collections.Array<string>)patch[key]; break;
|
|
case "character_name": CharacterName = (string)patch[key]; break;
|
|
case "is_hybrid": IsHybrid = (bool)patch[key]; break;
|
|
case "sire_clade_id": SireCladeId = (string)patch[key]; break;
|
|
case "sire_species_id": SireSpeciesId = (string)patch[key]; break;
|
|
case "dam_clade_id": DamCladeId = (string)patch[key]; break;
|
|
case "dam_species_id": DamSpeciesId = (string)patch[key]; break;
|
|
case "dominant_parent": DominantParent = (string)patch[key]; break;
|
|
case "sire_chosen_ability": SireChosenAbility = (string)patch[key]; break;
|
|
case "dam_chosen_ability": DamChosenAbility = (string)patch[key]; break;
|
|
case "sire_chosen_clade_traits": SireChosenCladeTraits = (Godot.Collections.Array<string>)patch[key]; break;
|
|
case "dam_chosen_clade_traits": DamChosenCladeTraits = (Godot.Collections.Array<string>)patch[key]; break;
|
|
case "sire_chosen_species_trait": SireChosenSpeciesTrait = (string)patch[key]; break;
|
|
case "dam_chosen_species_trait": DamChosenSpeciesTrait = (string)patch[key]; break;
|
|
case "sire_chosen_species_detriment":SireChosenSpeciesDetriment = (string)patch[key]; break;
|
|
case "dam_chosen_species_detriment": DamChosenSpeciesDetriment = (string)patch[key]; break;
|
|
case "sex": Sex = (string)patch[key]; break;
|
|
case "species_variant": SpeciesVariant = (string)patch[key]; break;
|
|
case "sire_species_variant": SireSpeciesVariant = (string)patch[key]; break;
|
|
case "dam_species_variant": DamSpeciesVariant = (string)patch[key]; break;
|
|
default:
|
|
GD.PushWarning($"[CharacterDraft] unknown patch key: {k}");
|
|
break;
|
|
}
|
|
}
|
|
EmitChanged();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lazy-loaded immutable content tables. Replaces the React prototype's
|
|
/// data.jsx + autoload Content per GODOT_PORTING_GUIDE.md §2.2 — same
|
|
/// purpose, idiomatic C#.
|
|
/// </summary>
|
|
public static class CodexContent
|
|
{
|
|
private static CladeDef[]? _clades;
|
|
private static SpeciesDef[]? _species;
|
|
private static ClassDef[]? _classes;
|
|
private static SubclassDef[]? _subclasses;
|
|
private static BackgroundDef[]? _backgrounds;
|
|
|
|
public static CladeDef[] Clades => _clades ??= Load(l => l.LoadClades());
|
|
public static SpeciesDef[] Species => _species ??= Load(l => l.LoadSpecies(Clades));
|
|
public static ClassDef[] Classes => _classes ??= Load(l => l.LoadClasses());
|
|
public static SubclassDef[] Subclasses => _subclasses ??= Load(l => l.LoadSubclasses(Classes));
|
|
public static BackgroundDef[] Backgrounds => _backgrounds ??= Load(l => l.LoadBackgrounds());
|
|
|
|
public static CladeDef? Clade(string id) => System.Array.Find(Clades, c => c.Id == id);
|
|
public static SpeciesDef? SpeciesById(string id) => System.Array.Find(Species, s => s.Id == id);
|
|
public static ClassDef? Class(string id) => System.Array.Find(Classes, c => c.Id == id);
|
|
public static BackgroundDef? Background(string id) => System.Array.Find(Backgrounds, b => b.Id == id);
|
|
|
|
public static IEnumerable<SpeciesDef> SpeciesOfClade(string cladeId)
|
|
{
|
|
foreach (var s in Species)
|
|
if (string.Equals(s.CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase))
|
|
yield return s;
|
|
}
|
|
|
|
private static T Load<T>(System.Func<Theriapolis.Core.Data.ContentLoader, T> fn)
|
|
{
|
|
var loader = new Theriapolis.Core.Data.ContentLoader(ContentPaths.DataDir);
|
|
return fn(loader);
|
|
}
|
|
}
|