refactor: Changes BaseCreature to the SerializationGenerator (delta save requirement) (#2611)

The pure SerializationGenerator conversion of `BaseCreature`, split out of #2592 so it can serve as the reference for converting every other large hand-written class in the Delta Saves project (#7, phase 3). Two behaviour changes from #2592 are deliberately not here and follow in their own PRs on top of this one: `SpeedClass`, and the collapse of `ControlMaster`/`SummonMaster` into one reference (a creature can lose or keep either independently: Blade Spirits and Energy Vortexes are summoned but never controlled, EnragedCreature and talisman summons keep a summon master with neither flag set). ## What this is - `BaseCreature` becomes `[SerializationGenerator(23, false)]` with a `[SerializableField]` per serialized slot and `[SaveFlag]` elision on nearly every field, so a stock creature serializes to its version plus flags. Field orders run 0..53 with no gaps (54 fields). - The hand-written reader stays as `private void Deserialize(IGenericReader reader, int version)` for every pre-codegen version (0..22); post-codegen bumps use `MigrateFrom` from here on. `[AfterDeserialization]` carries the post-load fixups main did after reading (stat timers, AI type, followers, reacquire seeding). - `ControlMaster` and `SummonMaster` stay two independent fields with main's semantics, each elided when null. - `DamageMin`/`DamageMax`/`ActiveSpeed`/`PassiveSpeed` are no longer virtual (nothing in the tree overrode them); comments swept to the constraints that matter. - Direct writes to serialized backing fields outside the generated setters (`SetDamage`, `SetResistance`, the move-speed helpers, the loot flag, feed loyalty, the delete timer) call `this.MarkDirty()`, matching the #2609 standard, so the class is ready for delta saves once `Mobile` is audited. - Schema `Server.Mobiles.BaseCreature.v23.json` regenerated by the tool (a second run produces no diff). ## Deferred to follow-up PRs SpeedClass: the serialized `_speedClass` field, `DefaultSpeedClass` replacing the type constant, `ApplySpeedClass`/`OnSpeedClassChange`, "None means custom", the four-speeds-as-one-block elision, `NPCSpeeds.FindEntry(SpeedLevel)`, the constructor fallback to Medium, and their tests. Master references: serializing one `Master` with a `Controlled`/`Summoned` fan-out and the `SetControlMaster` lockstep. ## Tests UOContent.Tests 776 / Server.Tests 855 green. `BaseCreatureSerializationTests` covers: a default creature elides to version + flags; a populated creature round-trips with exact byte consumption; back-to-back saves are byte-identical; an uncontrolled summon keeps its SummonMaster; byte-authentic v22 legacy streams (replicas of main's `Serialize`) load through the legacy reader for a wild tamable, a controlled pet, a controlled summon with an anchored `SummonEnd`, and a summon-master-only creature (the EnragedCreature shape); a running delete timer round-trips through `[DeserializeTimer]`; `Friends`, `CurrentWayPoint` and `HomeMap` round-trip; a `BaseVendor` stub round-trips the generated BaseVendor v2 → generated BaseCreature v23 chain. ## Behaviour notes for reviewers - `ActiveMoveSpeed`/`PassiveMoveSpeed` getters return the raw override (0 = inherit); `CurrentMoveSpeed` is the resolved pace. - Speeds elided as table defaults re-snap to the current `npc-speeds.json` on load, so table edits reach unmodified spawns on restart. - `GetSpeeds` no longer throws on the save/load path when the table has no entry for the type: saves elide against the creature's own values and loads keep the stream. Construction still throws (`InvalidOperationException`, was `KeyNotFoundException`). An elided load with no table entry would otherwise resume at speed 0, so `[AfterDeserialization]` logs once and paces it at Medium. - `virtual` removed from `ActiveSpeed`, `PassiveSpeed`, `DamageMin`, `DamageMax` (no overrides in the tree; forks may have some). - `ControlMaster`, `SummonMaster`, `ControlOrder`, `Tamable`, `IsParagon` are `[SerializableProperty]` over hand-written setters because follower bookkeeping must run before the assignment, which a `fieldChanged` hook cannot express; the wire format is identical. ## Prerequisites for cherry-picking #2609 (BaseVendor is already generated on top of BaseCreature) and SerializationGenerator 4.1.0.
2026-09-06 14:11:51 -07:00 · 2026-09-06 14:11:51 -07:00 · 392c4e16d5
commit 392c4e16d5
parent 003491472f
19 changed files with 1763 additions and 741 deletions
--- a/Projects/UOContent.Tests/Tests/Mobiles/AI/MoveSpeedTests.cs
+++ b/Projects/UOContent.Tests/Tests/Mobiles/AI/MoveSpeedTests.cs
@ -57,8 +57,9 @@ public class MoveSpeedTests : IDisposable
    {
        var bc = NewCreature();

-        Assert.Equal(0.3, bc.ActiveMoveSpeed);
-        Assert.Equal(0.6, bc.PassiveMoveSpeed);
+        // 0 = no override; the resolved pace comes from CurrentMoveSpeed.
+        Assert.Equal(0, bc.ActiveMoveSpeed);
+        Assert.Equal(0, bc.PassiveMoveSpeed);
        Assert.Equal(bc.CurrentSpeed, bc.CurrentMoveSpeed);
    }

@ -96,8 +97,8 @@ public class MoveSpeedTests : IDisposable

        bc.SetSpeed(0.2, 0.4);

-        Assert.Equal(0.2, bc.ActiveMoveSpeed);
-        Assert.Equal(0.4, bc.PassiveMoveSpeed);
+        Assert.Equal(0, bc.ActiveMoveSpeed);
+        Assert.Equal(0, bc.PassiveMoveSpeed);
    }

    [Fact]
@ -108,8 +109,10 @@ public class MoveSpeedTests : IDisposable

        bc.ActiveMoveSpeed = 0;

-        Assert.Equal(0.3, bc.ActiveMoveSpeed);  // inheriting again
+        Assert.Equal(0, bc.ActiveMoveSpeed);    // inheriting again
        Assert.Equal(0.9, bc.PassiveMoveSpeed); // other override untouched
+        bc.SetCurrentSpeedToActive();
+        Assert.Equal(0.3, bc.CurrentMoveSpeed); // resolves to the think clock
    }

    [Fact]
@ -121,7 +124,7 @@ public class MoveSpeedTests : IDisposable
        bc.ScaleMoveSpeed(1.0 / 1.2);

        Assert.Equal(0.5, bc.ActiveMoveSpeed);
-        Assert.Equal(bc.PassiveSpeed, bc.PassiveMoveSpeed); // still inheriting, not 0 * scalar
+        Assert.Equal(0, bc.PassiveMoveSpeed); // still inheriting, not 0 * scalar
    }

    [Fact]
@ -185,8 +188,8 @@ public class MoveSpeedTests : IDisposable

        bc.MigrateMoveSpeeds();

-        Assert.Equal(0.35, bc.ActiveMoveSpeed);
-        Assert.Equal(0.6, bc.PassiveMoveSpeed);
+        Assert.Equal(0, bc.ActiveMoveSpeed); // still inheriting the (tuned) think clock
+        Assert.Equal(0, bc.PassiveMoveSpeed);
    }

    [Theory]
@ -211,9 +214,9 @@ public class MoveSpeedTests : IDisposable
        var reader = new BufferReader(buffer);
        copy.Deserialize(reader);

-        // The v22 tail is the last block; exact consumption catches any offset mistake.
+        // The BaseCreature tail is the last block; exact consumption catches any offset mistake.
        Assert.Equal(buffer.Length, reader.Position);
-        Assert.Equal(overridden ? 0.45 : 0.3, copy.ActiveMoveSpeed);
-        Assert.Equal(overridden ? 0.9 : 0.6, copy.PassiveMoveSpeed);
+        Assert.Equal(overridden ? 0.45 : 0, copy.ActiveMoveSpeed);
+        Assert.Equal(overridden ? 0.9 : 0, copy.PassiveMoveSpeed);
    }
 }
--- a/Projects/UOContent.Tests/Tests/Mobiles/BaseCreatureSerializationTests.cs
+++ b/Projects/UOContent.Tests/Tests/Mobiles/BaseCreatureSerializationTests.cs
@ -0,0 +1,455 @@
+using System;
+using System.Collections.Generic;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Xunit;
+
+namespace UOContent.Tests.Mobiles;
+
+// BaseCreature's move to the SerializationGenerator (v23) is guarded three ways: the new
+// SaveFlag format round-trips both a default and a fully-populated creature with exact
+// byte consumption, back-to-back saves are byte-identical (freeze-time stability), and a
+// byte-authentic pre-codegen v22 stream (written by a fossilized replica of the old
+// Serialize) loads through the legacy path with the table-speed migration applied.
+[Collection("Sequential UOContent Tests")]
+public class BaseCreatureSerializationTests : IDisposable
+{
+    private readonly List<Mobile> _created = new();
+    private readonly List<Item> _createdItems = new();
+
+    public void Dispose()
+    {
+        for (var i = 0; i < _created.Count; i++)
+        {
+            _created[i].Delete();
+        }
+
+        for (var i = 0; i < _createdItems.Count; i++)
+        {
+            _createdItems[i].Delete();
+        }
+    }
+
+    private class CreatureStub : BaseCreature
+    {
+        public CreatureStub() : base(AIType.AI_Melee) => Body = 0xC9;
+
+        public CreatureStub(Serial serial) : base(serial) => Body = 0xC9;
+
+        public DateTime SummonEndValue => SummonEnd;
+
+        // Stands in for the npc-speeds table (unconfigured in the test fixture).
+        public override void GetSpeeds(out double activeSpeed, out double passiveSpeed)
+        {
+            activeSpeed = 0.3;
+            passiveSpeed = 0.6;
+        }
+
+        public override void GetMoveSpeeds(out double activeMoveSpeed, out double passiveMoveSpeed)
+        {
+            activeMoveSpeed = 0.6;
+            passiveMoveSpeed = 1.2;
+        }
+    }
+
+    private CreatureStub NewCreature()
+    {
+        var bc = new CreatureStub();
+        _created.Add(bc);
+        return bc;
+    }
+
+    // ReadEntity resolves references through the world table, so the master must be registered.
+    private PlayerMobile NewMaster()
+    {
+        var master = new PlayerMobile(World.NewMobile);
+        master.DefaultMobileInit();
+        World.AddEntity(master);
+        _created.Add(master);
+        return master;
+    }
+
+    private static byte[] Snapshot(Mobile m)
+    {
+        var writer = new BufferWriter(true);
+        m.Serialize(writer);
+
+        var buffer = new byte[writer.Position];
+        writer.Buffer.AsSpan(0, (int)writer.Position).CopyTo(buffer);
+        return buffer;
+    }
+
+    private CreatureStub Load(byte[] buffer)
+    {
+        var copy = new CreatureStub(World.NewMobile);
+        _created.Add(copy);
+        var reader = new BufferReader(buffer);
+        copy.Deserialize(reader);
+
+        Assert.Equal(buffer.Length, reader.Position); // exact consumption
+        return copy;
+    }
+
+    [Fact]
+    public void DefaultCreature_RoundTrips_AndElidesEverything()
+    {
+        var bc = NewCreature();
+
+        var buffer = Snapshot(bc);
+        var copy = Load(buffer);
+
+        Assert.Equal(AIType.AI_Melee, copy.AI);
+        Assert.Equal(BaseCreature.DefaultRangePerception, copy.RangePerception);
+        Assert.Equal(0.3, copy.ActiveSpeed);
+        Assert.Equal(0.6, copy.PassiveSpeed);
+        Assert.Equal(0.6, copy.CurrentSpeed);
+        Assert.Equal(0.6, copy.ActiveMoveSpeed);   // pulled from the table, not the wire
+        Assert.Equal(1.2, copy.PassiveMoveSpeed);
+        Assert.Equal(100, copy.PhysicalDamage);
+        Assert.Equal(BaseCreature.MaxLoyalty, copy.Loyalty);
+        Assert.Equal(1, copy.ControlSlots);
+        Assert.NotNull(copy.Owners);
+        Assert.Empty(copy.Owners);
+    }
+
+    [Fact]
+    public void BackToBackSaves_AreByteIdentical()
+    {
+        var bc = NewCreature();
+        bc.SetDamage(5, 10);
+        bc.PhysicalResistanceSeed = 25;
+
+        Assert.Equal(Snapshot(bc), Snapshot(bc));
+    }
+
+    [Fact]
+    public void PopulatedCreature_RoundTrips()
+    {
+        var bc = NewCreature();
+        var master = NewMaster();
+
+        bc.Tamable = true;
+        bc.MinTameSkill = 47.1;
+        bc.SetControlMaster(master);
+        bc.Owners.Add(master);
+        bc.ControlOrder = OrderType.Guard;
+        bc.SetDamage(11, 17);
+        bc.SetSpeed(0.2, 0.4); // hand-tuned: no longer matches the stub table
+        bc.SetMoveSpeed(0.25, 0.5);
+        bc.PhysicalResistanceSeed = 40;
+        bc.EnergyResistSeed = 15;
+        bc.FireDamage = 25;
+        bc.PhysicalDamage = 75;
+        bc.HitsMaxSeed = 250;
+        bc.Loyalty = 55;
+        bc.Home = new Point3D(1000, 1100, 5);
+        bc.RangeHome = 4;
+        bc.Team = 3;
+        bc.IsBonded = true;
+        bc.BondingBegin = Core.Now;
+        bc.RemoveIfUntamed = true;
+        bc.RemoveStep = 2;
+        bc.CorpseNameOverride = "a test corpse";
+
+        var copy = Load(Snapshot(bc));
+
+        Assert.True(copy.Controlled);
+        Assert.Equal(master, copy.ControlMaster);
+        Assert.Equal(OrderType.Guard, copy.ControlOrder);
+        Assert.True(copy.Tamable);
+        Assert.Equal(47.1, copy.MinTameSkill);
+        Assert.Equal(11, copy.DamageMin);
+        Assert.Equal(17, copy.DamageMax);
+        Assert.Equal(0.2, copy.ActiveSpeed);
+        Assert.Equal(0.4, copy.PassiveSpeed);
+        Assert.Equal(0.25, copy.ActiveMoveSpeed);
+        Assert.Equal(0.5, copy.PassiveMoveSpeed);
+        Assert.Equal(40, copy.PhysicalResistanceSeed);
+        Assert.Equal(15, copy.EnergyResistSeed);
+        Assert.Equal(25, copy.FireDamage);
+        Assert.Equal(75, copy.PhysicalDamage);
+        Assert.Equal(250, copy.HitsMaxSeed);
+        Assert.Equal(55, copy.Loyalty);
+        Assert.Equal(new Point3D(1000, 1100, 5), copy.Home);
+        Assert.Equal(4, copy.RangeHome);
+        Assert.Equal(3, copy.Team);
+        Assert.True(copy.IsBonded);
+        Assert.Equal(bc.BondingBegin, copy.BondingBegin);
+        Assert.True(copy.RemoveIfUntamed);
+        Assert.Equal(2, copy.RemoveStep);
+        Assert.Equal("a test corpse", copy.CorpseNameOverride);
+        Assert.Equal(master, copy.LastOwner);
+    }
+
+    [Fact]
+    public void UncontrolledSummon_KeepsItsSummonMaster()
+    {
+        var bc = NewCreature();
+        var master = NewMaster();
+
+        // Energy vortex-style: summoned with a master, never controlled.
+        bc.Summoned = true;
+        bc.SummonMaster = master;
+
+        var copy = Load(Snapshot(bc));
+
+        Assert.True(copy.Summoned);
+        Assert.False(copy.Controlled);
+        Assert.Equal(master, copy.SummonMaster);
+        Assert.Null(copy.ControlMaster);
+    }
+
+    [Fact]
+    public void ReferenceFields_RoundTrip()
+    {
+        var bc = NewCreature();
+        var friend = NewMaster();
+        var wayPoint = new WayPoint();
+        _createdItems.Add(wayPoint);
+
+        bc.AddPetFriend(friend);
+        bc.CurrentWayPoint = wayPoint;
+        bc.HomeMap = Map.Felucca;
+
+        var copy = Load(Snapshot(bc));
+
+        Assert.Equal(friend, Assert.Single(copy.Friends));
+        Assert.Equal(wayPoint, copy.CurrentWayPoint);
+        Assert.Equal(Map.Felucca, copy.HomeMap);
+    }
+
+    [Fact]
+    public void RunningDeleteTimer_RoundTrips()
+    {
+        var bc = NewCreature();
+        bc.BeginDeleteTimer();
+        Assert.True(bc.DeleteTimeLeft > TimeSpan.Zero);
+
+        var copy = Load(Snapshot(bc));
+
+        // Anchored: the remaining countdown survives, not the absolute deadline.
+        Assert.InRange(copy.DeleteTimeLeft, TimeSpan.FromDays(3.0) - TimeSpan.FromSeconds(5), TimeSpan.FromDays(3.0));
+    }
+
+    private sealed class VendorStub : BaseVendor
+    {
+        private static readonly List<SBInfo> _sbInfos = [];
+
+        public VendorStub() : base("the stub")
+        {
+        }
+
+        public VendorStub(Serial serial) : base(serial)
+        {
+        }
+
+        protected override List<SBInfo> SBInfos => _sbInfos;
+
+        public override void InitSBInfo()
+        {
+        }
+
+        public override void InitOutfit()
+        {
+        }
+
+        public override void GetSpeeds(out double activeSpeed, out double passiveSpeed)
+        {
+            activeSpeed = 0.3;
+            passiveSpeed = 0.6;
+        }
+    }
+
+    // BaseVendor is generated on top of the generated BaseCreature; the chain must write
+    // and read both sections in order with exact consumption.
+    [Fact]
+    public void GeneratedVendorChain_RoundTrips()
+    {
+        var vendor = new VendorStub();
+        _created.Add(vendor);
+        vendor.Home = new Point3D(1500, 1600, 0);
+        vendor.RangeHome = 2;
+
+        var buffer = Snapshot(vendor);
+
+        var copy = new VendorStub(World.NewMobile);
+        _created.Add(copy);
+        var reader = new BufferReader(buffer);
+        copy.Deserialize(reader);
+
+        Assert.Equal(buffer.Length, reader.Position);
+        Assert.Equal(AIType.AI_Vendor, copy.AI);
+        Assert.Equal(FightMode.None, copy.FightMode);
+        Assert.Equal(new Point3D(1500, 1600, 0), copy.Home);
+        Assert.Equal(2, copy.RangeHome);
+    }
+
+    private sealed class MobileStub : Mobile
+    {
+        public MobileStub() => Body = 0xC9;
+    }
+
+    // Byte-authentic replica of the pre-codegen v22 tail — fossilized so the legacy
+    // upgrade path stays covered without an old save binary. The full stream is a plain
+    // Mobile section (identical layout for every Mobile subclass) followed by this tail.
+    private static void WriteLegacyV22Tail(
+        IGenericWriter writer,
+        bool controlled = false,
+        Mobile controlMaster = null,
+        bool summoned = false,
+        Mobile summonMaster = null,
+        DateTime summonEnd = default
+    )
+    {
+        writer.Write(22);                      // version
+        writer.Write((int)AIType.AI_Melee);    // current AI
+        writer.Write((int)AIType.AI_Melee);    // default AI
+        writer.Write(10);                      // RangePerception
+        writer.Write(1);                       // RangeFight
+        writer.Write(0);                       // Team
+        writer.Write(0.3);                     // active (matches the stub table)
+        writer.Write(0.6);                     // passive
+        writer.Write(0.6);                     // current
+        writer.Write(2000);                    // Home X
+        writer.Write(2100);                    // Home Y
+        writer.Write(7);                       // Home Z
+        writer.Write(6);                       // RangeHome
+        writer.Write((int)FightMode.Closest);
+        writer.Write(controlled);
+        writer.Write(controlMaster);
+        writer.Write((Mobile)null);            // control target
+        writer.Write(Point3D.Zero);            // control dest
+        writer.Write((int)OrderType.None);
+        writer.Write(0.0);                     // min tame skill
+        writer.Write(true);                    // tamable
+        writer.Write(summoned);
+        if (summoned)
+        {
+            writer.WriteAnchoredTime(summonEnd);
+        }
+
+        writer.Write(2);                       // control slots
+        writer.Write(73);                      // loyalty
+        writer.Write((Item)null);              // waypoint
+        writer.Write(summonMaster);
+        writer.Write(180);                     // hits seed
+        writer.Write(-1);                      // stam seed
+        writer.Write(-1);                      // mana seed
+        writer.Write(7);                       // damage min
+        writer.Write(14);                      // damage max
+        writer.Write(30);                      // phys resist
+        writer.Write(100);                     // phys damage
+        writer.Write(10);                      // fire resist
+        writer.Write(0);                       // fire damage
+        writer.Write(0);                       // cold resist
+        writer.Write(0);                       // cold damage
+        writer.Write(0);                       // poison resist
+        writer.Write(0);                       // poison damage
+        writer.Write(0);                       // energy resist
+        writer.Write(0);                       // energy damage
+        writer.Write(new List<Mobile>());      // owners
+        writer.Write(false);                   // dead pet
+        writer.Write(false);                   // bonded
+        writer.Write(DateTime.MinValue);       // bonding begin
+        writer.Write(DateTime.MinValue);       // abandon time
+        writer.Write(true);                    // has generated loot
+        writer.Write(false);                   // paragon
+        writer.Write(false);                   // has friends
+        writer.Write(false);                   // remove if untamed
+        writer.Write(0);                       // remove step
+        writer.Write(TimeSpan.Zero);           // delete time left
+        writer.Write((string)null);            // corpse name override
+        writer.Write((Map)null);               // home map
+        writer.Write(0.0);                     // active move speed (v22)
+        writer.Write(0.0);                     // passive move speed (v22)
+    }
+
+    private CreatureStub LoadLegacyV22(
+        bool controlled = false,
+        Mobile controlMaster = null,
+        bool summoned = false,
+        Mobile summonMaster = null,
+        DateTime summonEnd = default
+    )
+    {
+        // Every serialized BaseCreature starts with the Mobile base section; a plain
+        // Mobile donor produces a byte-authentic one.
+        var donor = new MobileStub();
+        donor.DefaultMobileInit();
+        _created.Add(donor);
+
+        var writer = new BufferWriter(true);
+        donor.Serialize(writer);
+        WriteLegacyV22Tail(writer, controlled, controlMaster, summoned, summonMaster, summonEnd);
+
+        var buffer = new byte[writer.Position];
+        writer.Buffer.AsSpan(0, (int)writer.Position).CopyTo(buffer);
+
+        var copy = new CreatureStub(World.NewMobile);
+        _created.Add(copy);
+        var reader = new BufferReader(buffer);
+        copy.Deserialize(reader);
+
+        Assert.Equal(buffer.Length, reader.Position);
+        return copy;
+    }
+
+    [Fact]
+    public void LegacyV22Stream_LoadsThroughLegacyPath()
+    {
+        var copy = LoadLegacyV22();
+
+        Assert.Equal(10, copy.RangePerception);
+        Assert.Equal(new Point3D(2000, 2100, 7), copy.Home);
+        Assert.Equal(6, copy.RangeHome);
+        Assert.True(copy.Tamable);
+        Assert.Equal(2, copy.ControlSlots);
+        Assert.Equal(73, copy.Loyalty);
+        Assert.Equal(180, copy.HitsMaxSeed);
+        Assert.Equal(7, copy.DamageMin);
+        Assert.Equal(14, copy.DamageMax);
+        Assert.Equal(30, copy.PhysicalResistanceSeed);
+        Assert.Equal(10, copy.FireResistSeed);
+        Assert.Equal(0.3, copy.ActiveSpeed);
+        // v22 wrote explicit zeros for the move overrides ("inherit"), so the resolved
+        // pace falls back to the think clock.
+        Assert.Equal(0, copy.ActiveMoveSpeed);
+        Assert.Equal(0.6, copy.CurrentMoveSpeed); // passive mode, inheriting
+    }
+
+    // ControlMaster and SummonMaster are independent references: a summon master can
+    // exist without Summoned (EnragedCreature), and a controlled summon carries both.
+    [Theory]
+    [InlineData(true, true, false, false)]  // controlled pet
+    [InlineData(true, true, true, true)]    // controlled summon, SummonEnd on the wire
+    [InlineData(false, false, false, true)] // EnragedCreature shape: SummonMaster only
+    public void LegacyV22Stream_KeepsBothMasterReferences(
+        bool controlled,
+        bool hasControlMaster,
+        bool summoned,
+        bool hasSummonMaster
+    )
+    {
+        var master = NewMaster();
+        var summonEnd = Core.Now + TimeSpan.FromMinutes(5);
+
+        var copy = LoadLegacyV22(
+            controlled,
+            hasControlMaster ? master : null,
+            summoned,
+            hasSummonMaster ? master : null,
+            summonEnd
+        );
+
+        Assert.Equal(controlled, copy.Controlled);
+        Assert.Equal(summoned, copy.Summoned);
+        Assert.Equal(hasControlMaster ? master : null, copy.ControlMaster);
+        Assert.Equal(hasSummonMaster ? master : null, copy.SummonMaster);
+
+        if (summoned)
+        {
+            Assert.InRange(copy.SummonEndValue, summonEnd - TimeSpan.FromSeconds(1), summonEnd + TimeSpan.FromSeconds(1));
+        }
+    }
+}
--- a/Projects/UOContent.Tests/Tests/Spells/Necromancy/BloodOathSpellTests.cs
+++ b/Projects/UOContent.Tests/Tests/Spells/Necromancy/BloodOathSpellTests.cs
@ -121,7 +121,7 @@ public class BloodOathSpellTests

        BloodOathSpell.RegisterOath(caster, target, TimeSpan.FromMinutes(5));

-        BaseCreature.CreatureDeletedEvent(target); // central handler breaks the oath from the target side
+        CreatureEvents.CreatureDeletedEvent(target); // central handler breaks the oath from the target side

        Assert.Null(BloodOathSpell.GetBloodOath(target));
        Assert.False(BloodOathSpell.RemoveCurse(caster));
--- a/Projects/UOContent/Engines/CannedEvil/ChampionTitleSystem.cs
+++ b/Projects/UOContent/Engines/CannedEvil/ChampionTitleSystem.cs
@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using ModernUO.CodeGeneratedEvents;
-using Server.Collections;
 using Server.Mobiles;

 namespace Server.Engines.CannedEvil;
--- a/Projects/UOContent/Engines/Player
+++ b/Projects/UOContent/Engines/Player
@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using ModernUO.CodeGeneratedEvents;
-using Server.Collections;
 using Server.Logging;
 using Server.Misc;
 using Server.Mobiles;
--- a/Projects/UOContent/Engines/Virtues/VirtueSystem.cs
+++ b/Projects/UOContent/Engines/Virtues/VirtueSystem.cs
@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using ModernUO.CodeGeneratedEvents;
-using Server.Collections;
 using Server.Logging;
 using Server.Mobiles;

--- a/Projects/UOContent/Items/Misc/ProjectedItem.cs
+++ b/Projects/UOContent/Items/Misc/ProjectedItem.cs
@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using ModernUO.Serialization;
-using Server.Collections;
 using Server.Network;

 namespace Server.Items;
--- a/Projects/UOContent/Items/Weapons/BaseWeapon.Migrations.cs
+++ b/Projects/UOContent/Items/Weapons/BaseWeapon.Migrations.cs
@ -1,5 +1,4 @@
 using System;
-using Server.Engines.Craft;

 namespace Server.Items;

--- a/Projects/UOContent/Migrations/Server.Mobiles.BaseCreature.v23.json
+++ b/Projects/UOContent/Migrations/Server.Mobiles.BaseCreature.v23.json
@ -0,0 +1,471 @@
+{
+  "version": 23,
+  "type": "Server.Mobiles.BaseCreature",
+  "properties": [
+    {
+      "name": "DefaultAI",
+      "type": "Server.Mobiles.AIType",
+      "rule": "EnumMigrationRule"
+    },
+    {
+      "name": "CurrentAI",
+      "type": "Server.Mobiles.AIType",
+      "usesSaveFlag": true,
+      "rule": "EnumMigrationRule"
+    },
+    {
+      "name": "RangePerception",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "RangeFight",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "RangeHome",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "Team",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "FightMode",
+      "type": "Server.Mobiles.FightMode",
+      "usesSaveFlag": true,
+      "rule": "EnumMigrationRule"
+    },
+    {
+      "name": "ActiveSpeed",
+      "type": "double",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "PassiveSpeed",
+      "type": "double",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "CurrentSpeed",
+      "type": "double",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "ActiveMoveSpeed",
+      "type": "double",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "PassiveMoveSpeed",
+      "type": "double",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "Home",
+      "type": "Server.Point3D",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveUOTypeMigrationRule",
+      "ruleArguments": [
+        "Point3D"
+      ]
+    },
+    {
+      "name": "HomeMap",
+      "type": "Server.Map",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveUOTypeMigrationRule",
+      "ruleArguments": [
+        "Map"
+      ]
+    },
+    {
+      "name": "Controlled",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "ControlMaster",
+      "type": "Server.Mobile",
+      "usesSaveFlag": true,
+      "rule": "SerializableInterfaceMigrationRule"
+    },
+    {
+      "name": "ControlTarget",
+      "type": "Server.Mobile",
+      "usesSaveFlag": true,
+      "rule": "SerializableInterfaceMigrationRule"
+    },
+    {
+      "name": "ControlDest",
+      "type": "Server.Point3D",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveUOTypeMigrationRule",
+      "ruleArguments": [
+        "Point3D"
+      ]
+    },
+    {
+      "name": "ControlOrder",
+      "type": "Server.Mobiles.OrderType",
+      "usesSaveFlag": true,
+      "rule": "EnumMigrationRule"
+    },
+    {
+      "name": "MinTameSkill",
+      "type": "double",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "Tamable",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "Summoned",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "SummonEnd",
+      "type": "System.DateTime",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "AnchoredTime"
+      ]
+    },
+    {
+      "name": "SummonMaster",
+      "type": "Server.Mobile",
+      "usesSaveFlag": true,
+      "rule": "SerializableInterfaceMigrationRule"
+    },
+    {
+      "name": "ControlSlots",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "Loyalty",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "CurrentWayPoint",
+      "type": "Server.Items.WayPoint",
+      "usesSaveFlag": true,
+      "rule": "SerializableInterfaceMigrationRule"
+    },
+    {
+      "name": "HitsMaxSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "StamMaxSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "ManaMaxSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "DamageMin",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "DamageMax",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "PhysicalResistanceSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "FireResistSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "ColdResistSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "PoisonResistSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "EnergyResistSeed",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "PhysicalDamage",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "FireDamage",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "ColdDamage",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "PoisonDamage",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "EnergyDamage",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "Owners",
+      "type": "System.Collections.Generic.List\u003CServer.Mobile\u003E",
+      "usesSaveFlag": true,
+      "rule": "ListMigrationRule",
+      "ruleArguments": [
+        "@Tidy",
+        "Server.Mobile",
+        "SerializableInterfaceMigrationRule"
+      ]
+    },
+    {
+      "name": "IsDeadPet",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "IsBonded",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "BondingBegin",
+      "type": "System.DateTime",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "OwnerAbandonTime",
+      "type": "System.DateTime",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "HasGeneratedLoot",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "IsParagon",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "Friends",
+      "type": "System.Collections.Generic.List\u003CServer.Mobile\u003E",
+      "usesSaveFlag": true,
+      "rule": "ListMigrationRule",
+      "ruleArguments": [
+        "@Tidy",
+        "Server.Mobile",
+        "SerializableInterfaceMigrationRule"
+      ]
+    },
+    {
+      "name": "RemoveIfUntamed",
+      "type": "bool",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    },
+    {
+      "name": "RemoveStep",
+      "type": "int",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        "EncodedInt"
+      ]
+    },
+    {
+      "name": "PendingDeleteTimer",
+      "type": "Server.Timer",
+      "usesSaveFlag": true,
+      "rule": "TimerMigrationRule",
+      "ruleArguments": [
+        "@AnchoredTimer"
+      ]
+    },
+    {
+      "name": "CorpseNameOverride",
+      "type": "string",
+      "usesSaveFlag": true,
+      "rule": "PrimitiveTypeMigrationRule",
+      "ruleArguments": [
+        ""
+      ]
+    }
+  ]
+}
--- a/Projects/UOContent/Mobiles/Abilities/MonsterAbility.cs
+++ b/Projects/UOContent/Mobiles/Abilities/MonsterAbility.cs
@ -99,8 +99,8 @@ public abstract class MonsterAbility
    {
    }

-    [OnEvent(nameof(BaseCreature.CreatureDeathEvent))]
-    [OnEvent(nameof(BaseCreature.CreatureDeletedEvent))]
+    [OnEvent(nameof(CreatureEvents.CreatureDeathEvent))]
+    [OnEvent(nameof(CreatureEvents.CreatureDeletedEvent))]
    public static void InvalidateNextAbilityTriggers(BaseCreature source)
    {
        var abilities = source.GetMonsterAbilities();
--- a/Projects/UOContent/Mobiles/BaseCreature.cs
+++ b/Projects/UOContent/Mobiles/BaseCreature.cs
--- a/Projects/UOContent/Mobiles/CreatureEvents.cs
+++ b/Projects/UOContent/Mobiles/CreatureEvents.cs
@ -0,0 +1,13 @@
+using ModernUO.CodeGeneratedEvents;
+
+namespace Server.Mobiles;
+
+// Hosts BaseCreature's generated events: two generators cannot both emit [GeneratedCode] on one type (CS0579).
+public static partial class CreatureEvents
+{
+    [GeneratedEvent(nameof(CreatureDeathEvent))]
+    public static partial void CreatureDeathEvent(BaseCreature bc);
+
+    [GeneratedEvent(nameof(CreatureDeletedEvent))]
+    public static partial void CreatureDeletedEvent(BaseCreature bc);
+}
--- a/Projects/UOContent/Mobiles/Monsters/LBR/Meers/MeerMage.cs
+++ b/Projects/UOContent/Mobiles/Monsters/LBR/Meers/MeerMage.cs
@ -154,7 +154,7 @@ namespace Server.Mobiles
        public static bool UnderEffect(Mobile m) => m_Table.ContainsKey(m);

        [OnEvent(nameof(PlayerMobile.PlayerDeathEvent))]
-        [OnEvent(nameof(CreatureDeathEvent))]
+        [OnEvent(nameof(CreatureEvents.CreatureDeathEvent))]
        public static void StopEffect(Mobile m, bool message = false)
        {
            if (m_Table.Remove(m, out var timer))
--- a/Projects/UOContent/Mobiles/NPCSpeeds.cs
+++ b/Projects/UOContent/Mobiles/NPCSpeeds.cs
@ -26,32 +26,16 @@ public static class NPCSpeeds
    public static int MinIdleSeconds { get; private set; }
    public static int MaxIdleSeconds { get; private set; }

-    public static void GetSpeeds(BaseCreature bc, out double activeSpeed, out double passiveSpeed)
+    // Null when the table is unloaded (test fixtures). Immutable after Configure, so creatures cache it.
+    public static SpeedClassEntry FindEntry(BaseCreature bc)
    {
        if ((bc.SpeedClass == SpeedLevel.None || !_speedsByLevel.TryGetValue(bc.SpeedClass, out var sp)) &&
            !_speedsByType.TryGetValue(bc.GetType(), out sp))
        {
-            sp = _speedsByLevel[SpeedLevel.Medium];
+            _speedsByLevel.TryGetValue(SpeedLevel.Medium, out sp);
        }

-        activeSpeed = sp.ActiveSpeed;
-        passiveSpeed = sp.PassiveSpeed;
-    }
-
-    // Move speeds are optional (0 = inherit), so this tolerates a missing entry or table.
-    public static void GetMoveSpeeds(BaseCreature bc, out double activeMoveSpeed, out double passiveMoveSpeed)
-    {
-        if ((bc.SpeedClass == SpeedLevel.None || !_speedsByLevel.TryGetValue(bc.SpeedClass, out var sp)) &&
-            !_speedsByType.TryGetValue(bc.GetType(), out sp) &&
-            !_speedsByLevel.TryGetValue(SpeedLevel.Medium, out sp))
-        {
-            activeMoveSpeed = 0;
-            passiveMoveSpeed = 0;
-            return;
-        }
-
-        activeMoveSpeed = sp.ActiveMoveSpeed;
-        passiveMoveSpeed = sp.PassiveMoveSpeed;
+        return sp;
    }

    public static void RegisterSpeed(SpeedClassEntry entry)
--- a/Projects/UOContent/Skills/AntiMacroSystem.cs
+++ b/Projects/UOContent/Skills/AntiMacroSystem.cs
@ -5,7 +5,6 @@ using System.IO;
 using System.Runtime.InteropServices;
 using System.Text.Json.Serialization;
 using ModernUO.CodeGeneratedEvents;
-using Server.Collections;
 using Server.Json;
 using Server.Mobiles;

--- a/Projects/UOContent/Skills/DetectHidden.cs
+++ b/Projects/UOContent/Skills/DetectHidden.cs
@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Server.Collections;
 using Server.Engines.PartySystem;
 using Server.Factions;
 using Server.Guilds;
--- a/Projects/UOContent/Spells/Necromancy/BloodOathSpell.cs
+++ b/Projects/UOContent/Spells/Necromancy/BloodOathSpell.cs
@ -151,8 +151,8 @@ public class BloodOathSpell : NecromancerSpell, ITargetingSpell<Mobile>
    // shared timer from either the caster or the target key, so a single call per mobile is enough.
    [OnEvent(nameof(PlayerMobile.PlayerDeathEvent))]
    [OnEvent(nameof(PlayerMobile.PlayerDeletedEvent))]
-    [OnEvent(nameof(BaseCreature.CreatureDeathEvent))]
-    [OnEvent(nameof(BaseCreature.CreatureDeletedEvent))]
+    [OnEvent(nameof(CreatureEvents.CreatureDeathEvent))]
+    [OnEvent(nameof(CreatureEvents.CreatureDeletedEvent))]
    public static void OnCurseEnds(Mobile m) => RemoveCurse(m);

    private class ExpireTimer : Timer
--- a/Projects/UOContent/Spells/Spellweaving/GiftOfLife.cs
+++ b/Projects/UOContent/Spells/Spellweaving/GiftOfLife.cs
@ -79,7 +79,7 @@ namespace Server.Spells.Spellweaving
            Caster.Target = new SpellTarget<Mobile>(this, TargetFlags.Beneficial);
        }

-        [OnEvent(nameof(BaseCreature.CreatureDeathEvent))]
+        [OnEvent(nameof(CreatureEvents.CreatureDeathEvent))]
        [OnEvent(nameof(PlayerMobile.PlayerDeathEvent))]
        public static void OnDeathEvent(Mobile m)
        {
--- a/dev-docs/content-patterns.md
+++ b/dev-docs/content-patterns.md
@ -262,8 +262,9 @@ All "speed" values are **delays in seconds** (smaller = faster). A creature runs
  (combat decisions, target acquisition, spell timing).
 - **Move clock** — `ActiveMoveSpeed`/`PassiveMoveSpeed`/`CurrentMoveSpeed`: seconds per
  step. Inherits the matching think value until overridden, so a creature configured with
-  only think speeds behaves as one clock. Any value is legal — steps are scheduled
-  independently of think ticks, so the two need not divide evenly.
+  only think speeds behaves as one clock. The properties read the raw override (`0` =
+  inheriting); `CurrentMoveSpeed` is the resolved pace. Any value is legal — steps are
+  scheduled independently of think ticks, so the two need not divide evenly.

 Speeds normally come from `Distribution/Data/npc-speeds.json` (via `SpeedClass` or type
 lists); `activeMove`/`passiveMove` are optional per bucket. Prefer data over code: