Merge branch 'phase/69-offense-memory'

Co-authored-by: Cursor <cursoragent@cursor.com> # Conflicts: # src/HSchool.Server/Api/PeopleModels.cs # src/HSchool.Server/Game/PersonCardReader.cs
2026-08-21 09:58:31 +03:00
parent 9850724803 79d9a3e904
commit bb0b799d41
23 changed files with 761 additions and 17 deletions
@@ -0,0 +1,118 @@
+using HSchool.Content;
+
+namespace HSchool.People.Tests;
+
+public class OffenseMemoryTests
+{
+    [Fact]
+    public void OverCeiling_DropsTheOldest()
+    {
+        var person = Blank("a");
+        var rules = Rules(max: 2);
+        var t0 = new DateTime(2012, 4, 3, 10, 0, 0, DateTimeKind.Utc);
+        Assert.True(OffenseMemory.Record(person, OffenseKinds.Quarrel, t0, "b", rules));
+        Assert.True(OffenseMemory.Record(person, OffenseKinds.Fight, t0.AddMinutes(1), "b", rules));
+        Assert.True(OffenseMemory.Record(person, OffenseKinds.Reprimand, t0.AddMinutes(2), "b", rules));
+
+        Assert.Equal(2, person.Offenses!.Count);
+        Assert.Equal(OffenseKinds.Fight, person.Offenses[0].Kind);
+        Assert.Equal(OffenseKinds.Reprimand, person.Offenses[1].Kind);
+    }
+
+    [Fact]
+    public void DisabledKind_DoesNotWrite()
+    {
+        var person = Blank("a");
+        var rules = new BehaviorDef
+        {
+            DefName = "Behavior",
+            OffenseMemoryMax = 5,
+            OffenseMemoryKinds = [OffenseKinds.Fight],
+        };
+        Assert.False(OffenseMemory.Record(
+            person,
+            OffenseKinds.Quarrel,
+            new DateTime(2012, 4, 3, 10, 0, 0, DateTimeKind.Utc),
+            "b",
+            rules));
+        Assert.Null(person.Offenses);
+    }
+
+    [Fact]
+    public void RosterJson_RoundTripsOffenses_AndOmitsEmpty()
+    {
+        var roster = Fixtures.Generate(Fixtures.Classrooms(4));
+        var pupil = roster.People.First(person => person.IsStudent && !person.IsParent);
+        var other = roster.People.First(person =>
+            person.IsStudent && !person.Id.Equals(pupil.Id, StringComparison.Ordinal));
+        var time = new DateTime(2012, 4, 3, 11, 20, 0, DateTimeKind.Utc);
+        OffenseMemory.Record(pupil, OffenseKinds.Fight, time, other.Id, Rules(max: 5));
+
+        var json = RosterJson.Serialize(RosterDocument.From(1, roster));
+        Assert.Contains("\"offenses\"", json, StringComparison.Ordinal);
+        Assert.Contains("\"kind\": \"fight\"", json, StringComparison.Ordinal);
+
+        var without = roster.People.First(person => person.Offenses is null || person.Offenses.Count == 0);
+        var withoutSlice = PersonJsonSlice(json, without.Id);
+        Assert.DoesNotContain("\"offenses\"", withoutSlice, StringComparison.Ordinal);
+
+        var loaded = RosterJson.Parse(json).ToRoster();
+        var loadedPupil = loaded.People.First(person => person.Id.Equals(pupil.Id, StringComparison.Ordinal));
+        Assert.NotNull(loadedPupil.Offenses);
+        Assert.Single(loadedPupil.Offenses!);
+        Assert.Equal(OffenseKinds.Fight, loadedPupil.Offenses[0].Kind);
+        Assert.Equal(other.Id, loadedPupil.Offenses[0].OtherPersonId);
+        Assert.Equal(time, loadedPupil.Offenses[0].Time);
+    }
+
+    private static string PersonJsonSlice(string json, string personId)
+    {
+        var marker = $"\"id\": \"{personId}\"";
+        var start = json.IndexOf(marker, StringComparison.Ordinal);
+        Assert.True(start >= 0);
+        var end = json.IndexOf("},", start, StringComparison.Ordinal);
+        if (end < 0)
+        {
+            end = json.Length;
+        }
+
+        return json[start..end];
+    }
+
+    private static BehaviorDef Rules(int max) => new()
+    {
+        DefName = "Behavior",
+        OffenseMemoryMax = max,
+        OffenseMemoryKinds = BehaviorDef.DefaultOffenseMemoryKinds,
+    };
+
+    private static Person Blank(string id)
+    {
+        var cases = new CaseTable
+        {
+            Nom = id,
+            Gen = id,
+            Dat = id,
+            Acc = id,
+            Ins = id,
+            Pre = id,
+        };
+        return new Person
+        {
+            Id = id,
+            FamilyId = "f",
+            Female = false,
+            BirthDate = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc),
+            Name = new PersonName(id, id, id, cases, cases, cases),
+            IsStudent = true,
+            IsStaff = false,
+            IsParent = false,
+            Numbers = new Dictionary<string, int>(StringComparer.Ordinal),
+            Choices = new Dictionary<string, string>(StringComparer.Ordinal),
+            Skills = new Dictionary<string, int>(StringComparer.Ordinal),
+            Traits = [],
+            Needs = new Dictionary<string, float>(StringComparer.Ordinal),
+            Opinions = new Dictionary<string, int>(StringComparer.Ordinal),
+        };
+    }
+}
@@ -22,4 +22,11 @@
    <Using Include="Xunit" />
  </ItemGroup>

+  <ItemGroup>
+    <Content Include="..\..\src\HSchool.Server\mods\core\**\*">
+      <Link>vanilla\%(RecursiveDir)%(Filename)%(Extension)</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
 </Project>
@@ -0,0 +1,69 @@
+using HSchool.Content;
+using HSchool.People;
+using HSchool.Server.Game;
+using HSchool.Simulation;
+
+namespace HSchool.Server.Tests;
+
+public class PersonCardReaderOffensesTests
+{
+    private static readonly DateTime Start = new(2012, 4, 3, 9, 0, 0, DateTimeKind.Utc);
+
+    [Fact]
+    public void Card_ReturnsOffensesInSameOrderAsPerson()
+    {
+        var (catalog, map) = Vanilla();
+        var roster = RosterGenerator.Generate(catalog, map, schoolSeed: 42, "Russia", Start);
+        var pupil = roster.People.First(person => person.IsStudent && !person.IsParent);
+        var other = roster.People.First(person =>
+            person.IsStudent && !person.Id.Equals(pupil.Id, StringComparison.Ordinal));
+        var t0 = new DateTime(2012, 4, 3, 10, 0, 0, DateTimeKind.Utc);
+        var rules = catalog.BehaviorRules!;
+        OffenseMemory.Record(pupil, OffenseKinds.Quarrel, t0, other.Id, rules);
+        OffenseMemory.Record(pupil, OffenseKinds.Fight, t0.AddMinutes(5), other.Id, rules);
+
+        var school = School.Create(42, "OffensesCard", Start, catalog, map);
+        using (school)
+        {
+            school.InstallPeople(roster, 42, "Russia", ApplicantPool.Empty);
+            var card = PersonCardReader.Read(school, pupil.Id, "ru");
+            Assert.NotNull(card);
+            Assert.NotNull(card!.Offenses);
+            Assert.Equal(2, card.Offenses!.Count);
+            Assert.Equal(
+                pupil.Offenses!.Select(row => row.Kind).ToArray(),
+                card.Offenses.Select(row => row.Kind).ToArray());
+            Assert.Equal(OffenseKinds.Quarrel, card.Offenses[0].Kind);
+            Assert.Equal("ссора", card.Offenses[0].KindLabel);
+            Assert.Equal(other.Id, card.Offenses[0].OtherPersonId);
+            Assert.Equal(other.Name.Full, card.Offenses[0].OtherFullName);
+            Assert.Equal(OffenseKinds.Fight, card.Offenses[1].Kind);
+            Assert.Equal("драка", card.Offenses[1].KindLabel);
+        }
+    }
+
+    private static (DefCatalog Catalog, MapLayout Map) Vanilla()
+    {
+        var root = Path.Combine(AppContext.BaseDirectory, "vanilla");
+        Assert.True(Directory.Exists(root), $"Vanilla pack missing at {root}.");
+        var documents = new List<ContentDocument>();
+        foreach (var path in Directory.EnumerateFiles(root, "*.*", SearchOption.AllDirectories))
+        {
+            if (!path.EndsWith(".jsonc", StringComparison.OrdinalIgnoreCase)
+                && !path.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            documents.Add(new ContentDocument(
+                CatalogLoader.CorePackId,
+                Path.GetRelativePath(root, path).Replace('\\', '/'),
+                File.ReadAllText(path)));
+        }
+
+        var catalog = new CatalogLoader().Load([CatalogLoader.CorePackId], documents);
+        var map = CatalogLoader.LastDefaultMap([CatalogLoader.CorePackId], documents);
+        Assert.NotNull(map);
+        return (catalog, map);
+    }
+}
@@ -0,0 +1,198 @@
+using Arch.Core;
+using HSchool.Ai;
+using HSchool.Content;
+using HSchool.People;
+using HSchool.Simulation;
+
+namespace HSchool.Simulation.Tests;
+
+public class OffenseMemorySimulationTests
+{
+    private static readonly DateTime TuesdayMorning = new(2012, 4, 3, 6, 0, 0, DateTimeKind.Utc);
+
+    [Fact]
+    public void FightBrokenByStaff_AddsFightAndReprimandToBothPupils()
+    {
+        var (school, first, second, staffId) = TwoPupilsAndStaffOnBreak();
+        using (school)
+        {
+            OpinionStore.Set(first, second.Id, -55);
+            OpinionStore.Set(second, first.Id, -55);
+            PlaceAt(school, first.Id, "yard");
+            PlaceAt(school, second.Id, "yard");
+            PlaceAt(school, staffId, "yard");
+
+            Assert.True(school.TryStartAction(first.Id, TalkActions.Fight));
+            PlaceAt(school, staffId, "yard");
+            TalkCircleSystem.Apply(school, 1d);
+
+            first = school.Roster!.People.First(person => person.Id == first.Id);
+            second = school.Roster.People.First(person => person.Id == second.Id);
+            AssertFightAndReprimand(first, second.Id);
+            AssertFightAndReprimand(second, first.Id);
+        }
+    }
+
+    [Fact]
+    public void OverCeiling_InWorld_DropsOldestAfterRepeatedFights()
+    {
+        var (school, first, second) = TwoPupilsOnBreak();
+        using (school)
+        {
+            var rules = school.Catalog!.BehaviorRules!;
+            var max = rules.OffenseMemoryMax;
+            Assert.True(max > 0);
+
+            for (var i = 0; i < max + 1; i++)
+            {
+                OpinionStore.Set(first, second.Id, -55);
+                OpinionStore.Set(second, first.Id, -55);
+                PlaceAt(school, first.Id, "yard");
+                PlaceAt(school, second.Id, "yard");
+                Assert.True(school.TryStartAction(first.Id, TalkActions.Fight));
+                TickWhile(school, personId => TalkActions.IsFight(ActivityOf(school, personId)), first.Id, second.Id);
+                first = school.Roster!.People.First(person => person.Id == first.Id);
+                second = school.Roster.People.First(person => person.Id == second.Id);
+            }
+
+            Assert.NotNull(first.Offenses);
+            Assert.Equal(max, first.Offenses!.Count);
+            Assert.All(first.Offenses, row => Assert.Equal(OffenseKinds.Fight, row.Kind));
+        }
+    }
+
+    private static void AssertFightAndReprimand(Person person, string otherId)
+    {
+        Assert.NotNull(person.Offenses);
+        Assert.Contains(
+            person.Offenses!,
+            row => row.Kind == OffenseKinds.Fight && row.OtherPersonId == otherId);
+        Assert.Contains(
+            person.Offenses!,
+            row => row.Kind == OffenseKinds.Reprimand && row.OtherPersonId == otherId);
+    }
+
+    private static (School School, Person First, Person Second) TwoPupilsOnBreak()
+    {
+        var (catalog, map) = Vanilla();
+        var school = OpenSchool(catalog, map, seed: 42, TuesdayMorning, advanceToBreak: true);
+        var schoolClass = school.Roster!.Classes.First(row => row.RoomId == "classroom-101");
+        var pupils = schoolClass.PupilIds
+            .Select(id => school.Roster.People.First(person => person.Id == id))
+            .Take(2)
+            .ToArray();
+        return (school, pupils[0], pupils[1]);
+    }
+
+    private static (School School, Person First, Person Second, string StaffId) TwoPupilsAndStaffOnBreak()
+    {
+        var (school, first, second) = TwoPupilsOnBreak();
+        const float cap = 100_000f;
+        var roster = school.Roster!;
+        var pool = school.Applicants!;
+        var hired = Staffing.Hire(
+            school.Catalog!,
+            school.Map!,
+            roster,
+            pool,
+            pool.Applicants[0].Person.Id,
+            Staffing.TeacherPosition,
+            cap);
+        Assert.Equal(StaffingError.None, hired.Error);
+        school.ApplyStaffing(hired.Roster, hired.Pool);
+        first = school.Roster!.People.First(person => person.Id == first.Id);
+        second = school.Roster.People.First(person => person.Id == second.Id);
+        var staffId = school.Roster.People.First(person => person.IsStaff).Id;
+        return (school, first, second, staffId);
+    }
+
+    private static School OpenSchool(DefCatalog catalog, MapLayout map, int seed, DateTime start, bool advanceToBreak)
+    {
+        var roster = RosterGenerator.Generate(catalog, map, seed, "Russia", start);
+        var pool = ApplicantPool.Create(catalog, roster, seed, "Russia", start);
+        var schoolClass = roster.Classes.First(row => row.RoomId == "classroom-101");
+        var school = School.Create(seed, "OffenseMemory", start, catalog, map);
+        school.InstallPeople(roster, seed, "Russia", pool);
+        school.SetTimetable(new HSchool.Schedule.Timetable(
+            [
+                new HSchool.Schedule.LessonPlacement(schoolClass.Id, "Mathematics", "t1", schoolClass.RoomId, Day: 1, Period: 1),
+            ],
+            []));
+        school.ConfigurePresence(weekDays: 5, maxDecisionsPerTick: 10_000);
+        if (advanceToBreak)
+        {
+            AdvanceTo(school, new DateTime(2012, 4, 3, 9, 18, 0, DateTimeKind.Utc));
+        }
+
+        return school;
+    }
+
+    private static void AdvanceTo(School school, DateTime until)
+    {
+        while (school.Clock.Time < until)
+        {
+            school.Tick(0.2d, 5d);
+        }
+    }
+
+    private static void PlaceAt(School school, string personId, string? nodeId)
+    {
+        TalkCircleSystem.Interrupt(school, personId);
+        var query = new QueryDescription().WithAll<PersonIdentity, Presence, PersonActivity, Intent>();
+        school.World.Query(in query, (ref PersonIdentity identity, ref Presence presence, ref PersonActivity activity, ref Intent intent) =>
+        {
+            if (identity.Id.Equals(personId, StringComparison.Ordinal))
+            {
+                presence = nodeId is null ? Presence.OffCampus : new Presence(nodeId, 0f, nodeId, false, []);
+                activity = PersonActivity.Idle;
+                intent = Intent.None;
+            }
+        });
+    }
+
+    private static void TickWhile(School school, Func<string, bool> stillGoing, params string[] personIds)
+    {
+        for (var i = 0; i < 12 && personIds.Any(stillGoing); i++)
+        {
+            school.Tick(0.2d, 5d);
+        }
+    }
+
+    private static string? ActivityOf(School school, string personId)
+    {
+        string? found = null;
+        var query = new QueryDescription().WithAll<PersonIdentity, PersonActivity>();
+        school.World.Query(in query, (ref PersonIdentity identity, ref PersonActivity activity) =>
+        {
+            if (identity.Id.Equals(personId, StringComparison.Ordinal) && activity.IsActive)
+            {
+                found = activity.ActionId;
+            }
+        });
+        return found;
+    }
+
+    private static (DefCatalog Catalog, MapLayout Map) Vanilla()
+    {
+        var root = Path.Combine(AppContext.BaseDirectory, "vanilla");
+        var documents = new List<ContentDocument>();
+        foreach (var path in Directory.EnumerateFiles(root, "*.*", SearchOption.AllDirectories))
+        {
+            if (!path.EndsWith(".jsonc", StringComparison.OrdinalIgnoreCase)
+                && !path.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            documents.Add(new ContentDocument(
+                CatalogLoader.CorePackId,
+                Path.GetRelativePath(root, path).Replace('\\', '/'),
+                File.ReadAllText(path)));
+        }
+
+        var catalog = new CatalogLoader().Load([CatalogLoader.CorePackId], documents);
+        var map = CatalogLoader.LastDefaultMap([CatalogLoader.CorePackId], documents);
+        Assert.NotNull(map);
+        return (catalog, map);
+    }
+}