Split SchoolWorker and the person card along existing seams without a second thread or public API.

Co-authored-by: Cursor <cursoragent@cursor.com>

src/HSchool.Server/Game/PersonCardReader.Overview.cs

@@ -0,0 +1,194 @@
+using HSchool.Content;
+using HSchool.People;
+using HSchool.Server.Api;
+
+namespace HSchool.Server.Game;
+
+internal static partial class PersonCardReader
+{
+    private static IReadOnlyList<LabeledStatResponse> Body(Person person, DefCatalog? catalog, string locale)
+    {
+        var rows = new List<LabeledStatResponse>();
+        if (catalog is not null)
+        {
+            foreach (var def in catalog.BodyAttributes.Values)
+            {
+                if (def.Abstract)
+                {
+                    continue;
+                }
+
+                if (def.Kind == BodyAttributeKind.Number && person.Numbers.TryGetValue(def.DefName, out var number))
+                {
+                    rows.Add(new LabeledStatResponse(def.DefName, catalog.Label(locale, def), number.ToString()));
+                }
+                else if (def.Kind == BodyAttributeKind.Choice && person.Choices.TryGetValue(def.DefName, out var choice))
+                {
+                    rows.Add(new LabeledStatResponse(def.DefName, catalog.Label(locale, def), catalog.Text(locale, choice)));
+                }
+            }
+        }
+        else
+        {
+            foreach (var (id, number) in person.Numbers)
+            {
+                rows.Add(new LabeledStatResponse(id, id, number.ToString()));
+            }
+
+            foreach (var (id, choice) in person.Choices)
+            {
+                rows.Add(new LabeledStatResponse(id, id, choice));
+            }
+        }
+
+        if (person.Choices.TryGetValue(BodyBuilds.Attribute, out var build)
+            && rows.TrueForAll(row => row.Id != BodyBuilds.Attribute))
+        {
+            var label = catalog?.Text(locale, BodyBuilds.Attribute) ?? BodyBuilds.Attribute;
+            var value = catalog?.Text(locale, build) ?? build;
+            rows.Add(new LabeledStatResponse(BodyBuilds.Attribute, label, value));
+        }
+
+        return rows;
+    }
+
+    private static IReadOnlyList<LabeledStatResponse> Skills(
+        Person person,
+        IReadOnlyDictionary<string, float>? live,
+        DefCatalog? catalog,
+        string locale)
+    {
+        if (catalog is null)
+        {
+            if (live is not null)
+            {
+                return live
+                    .Select(pair => new LabeledStatResponse(pair.Key, pair.Key, FormatSkill(pair.Value)))
+                    .ToArray();
+            }
+
+            return person.Skills
+                .Select(pair => new LabeledStatResponse(pair.Key, pair.Key, pair.Value.ToString()))
+                .ToArray();
+        }
+
+        var rows = new List<LabeledStatResponse>();
+        foreach (var def in catalog.Skills.Values)
+        {
+            if (def.Abstract)
+            {
+                continue;
+            }
+
+            if (live is not null)
+            {
+                if (!live.TryGetValue(def.DefName, out var liveValue))
+                {
+                    continue;
+                }
+
+                rows.Add(new LabeledStatResponse(def.DefName, catalog.Label(locale, def), FormatSkill(liveValue)));
+                continue;
+            }
+
+            if (!person.Skills.TryGetValue(def.DefName, out var value))
+            {
+                continue;
+            }
+
+            rows.Add(new LabeledStatResponse(def.DefName, catalog.Label(locale, def), value.ToString()));
+        }
+
+        return rows;
+    }
+
+    private static string FormatSkill(float value) => Math.Round(value, 2).ToString("0.##");
+
+    private static IReadOnlyList<DefLabelResponse> Traits(Person person, DefCatalog? catalog, string locale)
+    {
+        var rows = new List<DefLabelResponse>(person.Traits.Count);
+        foreach (var id in person.Traits)
+        {
+            var label = catalog is not null && catalog.Traits.TryGetValue(id, out var def)
+                ? catalog.Label(locale, def)
+                : id;
+            rows.Add(new DefLabelResponse(id, label));
+        }
+
+        return rows;
+    }
+
+    private static IReadOnlyList<NeedStatResponse> Needs(
+        IReadOnlyDictionary<string, float> values,
+        DefCatalog? catalog,
+        string locale)
+    {
+        if (catalog is null)
+        {
+            return values.Select(pair => new NeedStatResponse(pair.Key, pair.Key, pair.Value)).ToArray();
+        }
+
+        var rows = new List<NeedStatResponse>();
+        foreach (var def in catalog.Needs.Values)
+        {
+            if (def.Abstract || !values.TryGetValue(def.DefName, out var value))
+            {
+                continue;
+            }
+
+            rows.Add(new NeedStatResponse(def.DefName, catalog.Label(locale, def), value));
+        }
+
+        return rows;
+    }
+
+    private static PersonFamilyResponse Family(Roster roster, Person person)
+    {
+        var family = roster.Families.FirstOrDefault(candidate => candidate.Id.Equals(person.FamilyId, StringComparison.Ordinal));
+        if (family is null)
+        {
+            return new PersonFamilyResponse([], [], [], []);
+        }
+
+        var people = roster.People.ToDictionary(member => member.Id, StringComparer.Ordinal);
+        var inParents = InFamily(family.ParentIds, person.Id);
+        var inChildren = InFamily(family.ChildIds, person.Id);
+        return new PersonFamilyResponse(
+            inChildren ? Relatives(family.ParentIds, people, except: person.Id) : [],
+            inParents ? Relatives(family.ChildIds, people, except: person.Id) : [],
+            inChildren ? Relatives(family.ChildIds, people, except: person.Id) : [],
+            inParents ? Relatives(family.ParentIds, people, except: person.Id) : []);
+    }
+
+    private static bool InFamily(IReadOnlyList<string> ids, string id)
+    {
+        foreach (var candidate in ids)
+        {
+            if (candidate.Equals(id, StringComparison.Ordinal))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static IReadOnlyList<PersonRelResponse> Relatives(
+        IReadOnlyList<string> ids,
+        IReadOnlyDictionary<string, Person> people,
+        string except)
+    {
+        var rows = new List<PersonRelResponse>();
+        foreach (var id in ids)
+        {
+            if (id.Equals(except, StringComparison.Ordinal) || !people.TryGetValue(id, out var relative))
+            {
+                continue;
+            }
+
+            rows.Add(new PersonRelResponse(relative.Id, relative.Name.Full, relative.Female));
+        }
+
+        return rows;
+    }
+}