fix(ai): FamiliarAI owns familiar movement and combat; herding reaches its tile; ForcedAI read once (#2644)

## Problem

`BaseFamiliar.OnThink` drove its own movement (`WalkMobileRange` toward the master) while the familiar was also a controlled pet running `Obey()`. `Summon → SetControlMaster` issues `Come`; `DoOrderCome` converts it to `Stay` within two tiles and anchors `Home`; from then on `OnThink` walked toward the caster while `DoOrderStay` greedy-stepped back toward the stale post — the backtracking. Combat never approached anything: main only copied `Combatant` while already adjacent to the caster. `CurrentSpeed = 0.01` was a 10 ms think / 50 ms step sprint hack, and `RangeCheck` teleported the familiar to a spot eight tiles *from* the caster.

## Change

A dedicated `FamiliarAI : BaseAI` (registered through `ForcedAI`, like `CloneAI`) owns every familiar decision, for both the controlled (`Obey`) and uncontrolled (`Think`) dispatch:

1. **Lifecycle** — caster gone → drop pack, delete. Caster on another map → stand down and wait for `TeleportPets`.
2. **Herding** (Dark Tides) — stands down, then `CheckHerding()`. Outranks combat.
3. **Assist** — combat-capable familiars (dark wolf, vampire bat, horde minion) engage the caster's target; otherwise anything in a fight with the caster's side — attacked the caster or the familiar, or attacked by the caster (a pet's attack is credited to the caster) — that is still fighting the caster, the familiar, or one of the caster's pets. Leashed to `RangePerception` of the caster; dropped when the caster hides. Shadow wisp and death adder never fight (`AssistsMaster => false`, enforced at the `Combatant` setter so no path can hand them a target).
4. **Follow** — `MoveTo(master, 1)` through the centralized `ApproachTarget` (greedy step / persistent `PathFollower` / stall detection).
5. **Keep-up** — snap to a validated tile beside the caster (on the caster's floor) when outpaced on open ground beyond 10 tiles, or when `ApproachTarget` gave up; never while a detour is working.

**Command immunity** is expressed inside the order machinery rather than around it: `FamiliarAI.IssueOrder` does nothing and rests the order on `Come`, so `TeleportPets` keeps working and no system-issued `Attack` (retaliation on ML's stand-down rule) can strand the familiar. `StandsDownOnCommand => false` so the ML rule never mutes it.

**Visibility** mirrors the caster from the familiar's own state (a step reveals a hidden NPC in `Mobile.OnMove`; the old cache compared the caster's previous state), `RevealingAction` is suppressed while the caster is hidden, and becoming hidden drops Warmode so no swing gives the caster away.

**Speed** is a flat 0.1 (`ReduceSpeedWithDamage => false`).

### Engine-side (all `Projects/UOContent`)

- `ApproachTarget` records which exit it took in `BaseAI.LastApproach` (`ApproachOutcome`: Arrived / Waiting / DirectProgress / Routing / Blocked / GaveUp / InvalidGoal). Callers' booleans are unchanged; keep-up reads this instead of running a second scheduler. `MoveTo`'s arrival return now also clears the move intent, as `ApproachTarget`'s own arrival does.
- `MoveToPoint(goal, range = 1)`; `CheckHerding` passes 0. **Fixes a main regression from #2591:** herding stopped one tile short, never cleared `TargetLocation`, and left the creature pinned to the herding pace — affects the shepherd's crook and the Dark Tides scroll fetch for every herded creature, not just familiars.
- `ChangeAIType` reads `ForcedAI` once. It read it twice, and each `BaseAI` ctor activates its timer for a non-sector-gated creature, so a `ForcedAI` creature with `PlayerRangeSensitive => false` got an orphan AI ticking it.

## Tests

`FamiliarAITests` are timer-wheel driven (the real `AITimer` thinks and moves; `PetPacingTests` style) against live Trammel statics, gated on client map data: follow without backtracking, the five-way assist theory, leash, retaliation, aggressor fallback (caster's own `Combatant` expired; caster's pet in the fight), target dropped when it stops fighting, keep-up on open ground / not while routing / after give-up, hidden mirror across steps, herding priority with a visible fighting caster, stand-down when left behind, no stale move intent. `ApproachOutcomeTests`, `HerdingTests` (fails on main), `ForcedAITests` (fails on main) cover the engine-side pieces.

Against `origin/main` with the familiar tests dropped in: 16/16 fail, including the reported backtracking. On this branch: `UOContent.Tests` 1082 passed / 2 skipped, `Server.Tests` 891/891, solution builds with 0 warnings.

Projects/UOContent/Items/Weapons/BaseWeapon.cs

@@ -2102,14 +2102,10 @@ public abstract partial class BaseWeapon
             {
                 var caster = bc.ControlMaster ?? bc.SummonMaster;
 
-                if (caster != null && caster.Map == bc.Map && caster.InRange(bc, 2))
+                if (caster != null && caster.Map == bc.Map)
                 {
                     caster.Hits += damage;
                 }
-                else
-                {
-                    bc.Hits += damage;
-                }
             }
 
             if (Core.AOS)

Projects/UOContent/Mobiles/AI/BaseAI/AIMovement.cs

@@ -39,6 +39,11 @@ public abstract partial class BaseAI
     private bool _approachGaveUp;
     private Point3D _approachGaveUpGoalLoc;
 
+    /// <summary>Which exit the last <see cref="ApproachTarget"/> (via <see cref="MoveTo"/> or
+    /// <see cref="WalkMobileRange"/>) took. A <see cref="WalkMobileRange"/> retreat step does not
+    /// classify.</summary>
+    public ApproachOutcome LastApproach { get; private set; }
+
     // --- Move intent (see ContinueMove) ------------------------------------------------
     // Durable movement goal renewed by en-route ApproachTarget/MoveToPoint calls; while
     // live, the AITimer wakes at NextMove between think ticks to advance the step.
@@ -359,12 +364,14 @@ public abstract partial class BaseAI
     {
         if (Mobile.Deleted || Mobile.DisallowAllMoves || target?.Deleted != false)
         {
+            LastApproach = ApproachOutcome.InvalidGoal;
             ClearMoveIntent();
             return false;
         }
 
         if (Mobile.InRange(target, range))
         {
+            LastApproach = ApproachOutcome.Arrived;
             ResetApproach();
             ClearMoveIntent();
             return true;
@@ -375,6 +382,7 @@ public abstract partial class BaseAI
         {
             if (target.Location == _approachGaveUpGoalLoc)
             {
+                LastApproach = ApproachOutcome.GaveUp;
                 ClearMoveIntent();
                 return false;
             }
@@ -398,12 +406,13 @@ public abstract partial class BaseAI
 
             if (res == MoveResult.BadState)
             {
+                LastApproach = ApproachOutcome.Waiting;
                 return true; // not allowed to move this tick (frozen/casting/throttled); not a failure
             }
 
             if (res == MoveResult.Success && Mobile.GetDistanceToSqrt(target) < distBefore)
             {
-
+                LastApproach = ApproachOutcome.DirectProgress;
                 ResetApproach();
                 return true; // healthy en-route progress
             }
@@ -414,7 +423,6 @@ public abstract partial class BaseAI
         // PLANNING PATH: a persistent PathFollower, never discarded by a greedy step.
         if (Path == null || Path.Goal != target)
         {
-
             Path = new PathFollower(Mobile, target) { Mover = DoMoveImpl };
         }
 
@@ -425,24 +433,33 @@ public abstract partial class BaseAI
 
         if (Path.Follow(range))
         {
+            LastApproach = ApproachOutcome.Arrived;
             ResetApproach();
             return true;
         }
 
         TrackApproachProgress(target, couldMove);
 
+        if (_approachGaveUp)
+        {
+            LastApproach = ApproachOutcome.GaveUp;
+            return false;
+        }
+
         // En-route progress is success; failure only when a move-eligible tick took no step
-        // (no working path), or the approach has given up.
-        var progressed = !_approachGaveUp && (Mobile.Location != locBefore || !couldMove);
+        // (no working path).
+        var progressed = Mobile.Location != locBefore || !couldMove;
+        LastApproach = progressed ? ApproachOutcome.Routing : ApproachOutcome.Blocked;
 
         return progressed;
     }
 
     /// <summary>
     /// Walks toward a fixed point (e.g. a target's last-known position), pathfinding around
-    /// obstacles. Returns false on arrival or when genuinely unable to make progress.
+    /// obstacles, until within <paramref name="range"/> (0 = onto the tile). Returns false on
+    /// arrival or when genuinely unable to make progress.
     /// </summary>
-    public bool MoveToPoint(IPoint3D goal)
+    public bool MoveToPoint(IPoint3D goal, int range = 1)
     {
         if (Mobile.Deleted || Mobile.DisallowAllMoves || goal == null)
         {
@@ -455,12 +472,12 @@ public abstract partial class BaseAI
             Path = new PathFollower(Mobile, goal) { Mover = DoMoveImpl };
         }
 
-        RenewMoveIntent(null, goal, 1);
+        RenewMoveIntent(null, goal, range);
 
         var couldMove = CanMoveNow(out _) && !IsInBadState();
         var locBefore = Mobile.Location;
 
-        if (Path.Follow(1))
+        if (Path.Follow(range))
         {
             Path = null;
             ClearMoveIntent();
@@ -536,6 +553,13 @@ public abstract partial class BaseAI
         _approachGaveUp = false;
     }
 
+    /// <summary>Drops the path, stall state, and move intent (after a relocation).</summary>
+    public void ResetApproachState()
+    {
+        ResetApproach();
+        ClearMoveIntent();
+    }
+
     private void RenewMoveIntent(Mobile target, IPoint3D point, int range)
     {
         _moveIntentTarget = target;
@@ -580,7 +604,7 @@ public abstract partial class BaseAI
         }
         else
         {
-            MoveToPoint(_moveIntentPoint);
+            MoveToPoint(_moveIntentPoint, _moveIntentRange);
         }
     }
 
@@ -588,12 +612,16 @@ public abstract partial class BaseAI
     {
         if (Mobile.Deleted || Mobile.DisallowAllMoves || m?.Deleted != false)
         {
+            LastApproach = ApproachOutcome.InvalidGoal;
+            ClearMoveIntent();
             return false;
         }
 
         if (Mobile.InRange(m, range))
         {
+            LastApproach = ApproachOutcome.Arrived;
             ResetApproach();
+            ClearMoveIntent();
             return true;
         }
 
@@ -676,6 +704,7 @@ public abstract partial class BaseAI
     {
         if (Mobile.Deleted || Mobile.DisallowAllMoves || m == null)
         {
+            LastApproach = ApproachOutcome.InvalidGoal;
             return false;
         }
 
@@ -685,6 +714,7 @@ public abstract partial class BaseAI
 
             if (iCurrDist >= iWantDistMin && iCurrDist <= iWantDistMax)
             {
+                LastApproach = ApproachOutcome.Arrived;
                 return true;
             }
 

Projects/UOContent/Mobiles/AI/BaseAI/ApproachOutcome.cs

@@ -0,0 +1,30 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2026 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: ApproachOutcome.cs                                              *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.  *
+ ************************************************************************/
+
+namespace Server.Mobiles;
+
+/// <summary>Which exit <see cref="BaseAI.ApproachTarget"/> took, for policies that need more
+/// than its bool.</summary>
+public enum ApproachOutcome
+{
+    None,
+    Arrived,        // already within range
+    Waiting,        // frozen, casting, or the move budget has not elapsed
+    DirectProgress, // greedy step succeeded and closed the distance (open ground)
+    Routing,        // a PathFollower is active and working the detour
+    Blocked,        // move-eligible tick took no step; stall counter still running
+    GaveUp,         // stall counter exhausted on a stationary goal
+    InvalidGoal     // deleted target, deleted self, or DisallowAllMoves
+}

Projects/UOContent/Mobiles/AI/BaseAI/BaseAI.cs

@@ -632,13 +632,13 @@ public abstract partial class BaseAI
         {
             // A cached boxed goal keeps the PathFollower persistent across ticks; walking
             // through MoveToPoint paces herding on the movement clock and paths around
-            // obstacles.
+            // obstacles. Range 0: the exit below is distance < 1.
             if (_herdGoal == null || _herdGoal.X != target.X || _herdGoal.Y != target.Y)
             {
                 _herdGoal = new Point3D(target.X, target.Y, Mobile.Map?.GetAverageZ(target.X, target.Y) ?? Mobile.Z);
             }
 
-            MoveToPoint(_herdGoal);
+            MoveToPoint(_herdGoal, 0);
             return true;
         }
 

Projects/UOContent/Mobiles/AI/FamiliarAI.cs

@@ -0,0 +1,268 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2026 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: FamiliarAI.cs                                                   *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.  *
+ ************************************************************************/
+
+using System.Collections.Generic;
+
+namespace Server.Mobiles;
+
+/// <summary>
+/// Necromancy familiars: command-immune, glued to the caster, assist its fights if combat-capable,
+/// snap to it when outpaced or stuck. <see cref="Obey"/> and <see cref="Think"/> share one decision.
+/// </summary>
+public class FamiliarAI : BaseAI
+{
+    public FamiliarAI(BaseFamiliar familiar) : base(familiar)
+    {
+    }
+
+    private BaseFamiliar Familiar => (BaseFamiliar)Mobile;
+
+    // Assist targets, and the familiar itself, stay within this of the caster.
+    public int LeashRange => Mobile.RangePerception;
+
+    public override bool CanDetectHidden => false;
+
+    public override bool Think() => Act();
+
+    public override bool Obey() => Act();
+
+    // Command immunity: no issue-phase side effects; rests on Come so TeleportPets still applies.
+    public override OrderType IssueOrder(
+        OrderType order, OrderType previous, Mobile issuer, bool resuming, Mobile interruptedTarget
+    )
+    {
+        AITimer.Prod();
+        return Mobile.Controlled ? OrderType.Come : OrderType.None;
+    }
+
+    public override void OnAggressiveAction(Mobile aggressor)
+    {
+        if (!Familiar.AssistsMaster || aggressor.Hidden || Familiar.ControlMaster?.Hidden == true)
+        {
+            return;
+        }
+
+        if (Mobile.Combatant == null)
+        {
+            Mobile.Warmode = true;
+            Mobile.Combatant = aggressor;
+            return;
+        }
+
+        base.OnAggressiveAction(aggressor);
+    }
+
+    private bool Act()
+    {
+        var master = Familiar.ControlMaster;
+
+        // Deletion is BaseFamiliar.OnThink's.
+        if (Mobile.Deleted || master?.Deleted != false)
+        {
+            return true;
+        }
+
+        // Left behind: stand down until TeleportPets or the unsummon.
+        if (master.Map != Mobile.Map)
+        {
+            StandDown();
+            return true;
+        }
+
+        // Herding outranks combat.
+        if (Mobile.TargetLocation != null)
+        {
+            StandDown();
+
+            if (CheckHerding())
+            {
+                DebugSay("Fetching for my master.");
+                return true;
+            }
+        }
+
+        if (Familiar.AssistsMaster && !master.Hidden && TryAssist(master))
+        {
+            return true;
+        }
+
+        Follow(master);
+        return true;
+    }
+
+    // The caster's target; else the closest mobile in a fight with the caster's side that is
+    // still fighting one of us (the caster's own Combatant expires while a monster keeps hitting).
+    private bool TryAssist(Mobile master)
+    {
+        var target = master.Combatant;
+
+        if (!IsValidAssistTarget(master, target))
+        {
+            target = Mobile.Combatant;
+
+            if (!IsValidAssistTarget(master, target) || !IsFightingUs(master, target))
+            {
+                target = FindAggressor(master);
+
+                if (target == null)
+                {
+                    return false;
+                }
+            }
+        }
+
+        if (!Mobile.InRange(master, LeashRange))
+        {
+            DebugSay("Too far from my master; returning.");
+            return false;
+        }
+
+        Mobile.Warmode = true;
+        Mobile.Combatant = target;
+
+        if (Mobile.Combatant != target)
+        {
+            return false; // setter refused it
+        }
+
+        Mobile.SetCurrentSpeedToActive();
+        this.DebugSayFormatted($"Assisting my master against {target.Name}.");
+        MoveTo(target, Mobile.RangeFight);
+        return true;
+    }
+
+    private bool IsFightingUs(Mobile master, Mobile target)
+    {
+        var combatant = target.Combatant;
+
+        return combatant == Mobile || combatant == master ||
+               combatant is BaseCreature { Controlled: true } pet && pet.ControlMaster == master;
+    }
+
+    // Closest mobile in a fight with the caster's side.
+    private Mobile FindAggressor(Mobile master)
+    {
+        Mobile best = null;
+        var bestDist = double.MaxValue;
+
+        ScanAggression(master, master.Aggressors, false, ref best, ref bestDist);
+        ScanAggression(master, Mobile.Aggressors, false, ref best, ref bestDist);
+        ScanAggression(master, master.Aggressed, true, ref best, ref bestDist);
+
+        return best;
+    }
+
+    // defenders: an Aggressed list, read the Defender.
+    private void ScanAggression(
+        Mobile master, List<AggressorInfo> list, bool defenders, ref Mobile best, ref double bestDist
+    )
+    {
+        for (var i = 0; i < list.Count; i++)
+        {
+            var info = list[i];
+
+            if (info.Expired)
+            {
+                continue;
+            }
+
+            var other = defenders ? info.Defender : info.Attacker;
+
+            if (other == best || !IsValidAssistTarget(master, other) || !IsFightingUs(master, other))
+            {
+                continue;
+            }
+
+            var dist = master.GetDistanceToSqrt(other);
+
+            if (dist < bestDist)
+            {
+                best = other;
+                bestDist = dist;
+            }
+        }
+    }
+
+    private bool IsValidAssistTarget(Mobile master, Mobile target) =>
+        target?.Deleted == false && target != Mobile && target != master && target.Alive &&
+        !target.Hidden && target.Map == Mobile.Map && !target.IsDeadBondedPet &&
+        target.AccessLevel == AccessLevel.Player && master.InRange(target, LeashRange) &&
+        Mobile.CanBeHarmful(target, false);
+
+    // Clears the move intent too, or a move-wake resumes the abandoned pursuit.
+    private void StandDown()
+    {
+        Mobile.Warmode = false;
+        Mobile.Combatant = null;
+        Mobile.SetCurrentSpeedToActive();
+        ClearMoveIntent();
+    }
+
+    private void Follow(Mobile master)
+    {
+        StandDown();
+
+        MoveTo(master, 1);
+        TryKeepUp(master);
+    }
+
+    // Outpaced on open ground, or given up: snap. A live detour finishes; Blocked is still counting.
+    private void TryKeepUp(Mobile master)
+    {
+        var snap = LastApproach switch
+        {
+            ApproachOutcome.GaveUp         => true,
+            ApproachOutcome.DirectProgress => !Mobile.InRange(master, BaseFamiliar.KeepUpRange),
+            _                              => false
+        };
+
+        if (!snap || !TryFindLanding(master, out var loc))
+        {
+            return;
+        }
+
+        DebugSay("Keeping up with my master.");
+        Mobile.SetLocation(loc, true);
+        ResetApproachState();
+    }
+
+    private static readonly (int dx, int dy)[] _landingRing =
+    [
+        (0, 1), (1, 0), (0, -1), (-1, 0), (1, 1), (-1, 1), (1, -1), (-1, -1)
+    ];
+
+    // An adjacent tile on the caster's floor this creature can stand on.
+    private bool TryFindLanding(Mobile master, out Point3D loc)
+    {
+        var map = master.Map;
+        var start = Utility.Random(_landingRing.Length); // no favoured side
+
+        for (var i = 0; i < _landingRing.Length; i++)
+        {
+            var (dx, dy) = _landingRing[(start + i) % _landingRing.Length];
+            var x = master.X + dx;
+            var y = master.Y + dy;
+
+            if (map.CanSpawnMobile(x, y, master.Z - 5, master.Z + 5, Mobile.CanSwim, Mobile.CantWalk, out var z))
+            {
+                loc = new Point3D(x, y, z);
+                return true;
+            }
+        }
+
+        loc = Point3D.Zero;
+        return false;
+    }
+}

Projects/UOContent/Mobiles/BaseCreature.cs

@@ -2524,9 +2524,12 @@ namespace Server.Mobiles
         {
             AIObject?.AITimer.Stop();
 
-            if (ForcedAI != null)
+            // Read once: each read constructs an AI whose ctor may start its timer.
+            var forced = ForcedAI;
+
+            if (forced != null)
             {
-                AIObject = ForcedAI;
+                AIObject = forced;
                 return;
             }
 
@@ -3102,13 +3105,20 @@ namespace Server.Mobiles
                 pack?.DisplayTo(from);
             }
 
-            if (DeathAdderCharmable && from.CanBeHarmful(this, false))
+            if (DeathAdderCharmable && from.CanBeHarmful(this, false) &&
+                SummonFamiliarSpell.Table.TryGetValue(from, out var bc) && bc is DeathAdder { Deleted: false } deathAddr &&
+                deathAddr.Map == from.Map)
             {
-                if (SummonFamiliarSpell.Table.TryGetValue(from, out var bc) && (bc as DeathAdder)?.Deleted == false)
+                if (from.NetState.HasProtocolChanges(ProtocolChanges.Version7000))
+                {
+                    from.SendLocalizedMessage(1114362); // You charm the snake.  Select a target to attack.
+                }
+                else
                 {
                     from.SendAsciiMessage("You charm the snake.  Select a target to attack.");
-                    from.Target = new DeathAdderCharmTarget(this);
                 }
+
+                from.Target = new DeathAdderCharmTarget(this);
             }
 
             if (MLQuestSystem.Enabled && CanGiveMLQuest && from is PlayerMobile mobile)

Projects/UOContent/Mobiles/Familiars/BaseFamiliar.cs

@@ -8,13 +8,16 @@ namespace Server.Mobiles;
 [SerializationGenerator(0, false)]
 public abstract partial class BaseFamiliar : BaseCreature
 {
-    private bool m_LastHidden;
+    // Open-ground distance beyond which the familiar snaps to the caster.
+    public const int KeepUpRange = 10;
 
     public BaseFamiliar() : base(AIType.AI_Melee)
     {
-        SetSpeed(0.1, 0.11);
+        SetSpeed(0.1, 0.1);
     }
 
+    protected override BaseAI ForcedAI => new FamiliarAI(this);
+
     public override bool BardImmune => true;
     public override Poison PoisonImmune => Poison.Lethal;
     public override bool Commandable => false;
@@ -22,89 +25,68 @@ public abstract partial class BaseFamiliar : BaseCreature
 
     public override bool PlayerRangeSensitive => false;
 
-    public virtual void RangeCheck()
+    // Joins the caster's fights; false never fights.
+    public virtual bool AssistsMaster => true;
+
+    // FamiliarAI decides whether it fights, not the ML stand-down rule.
+    public override bool StandsDownOnCommand => false;
+
+    // A wounded familiar still keeps up.
+    public override bool ReduceSpeedWithDamage => false;
+
+    // The one choke point for "never fights" / "not while the caster is hidden":
+    // BaseCreature.AggressiveAction assigns Combatant unconditionally. GetCPA does not inherit.
+    [CommandProperty(AccessLevel.GameMaster)]
+    public override Mobile Combatant
     {
-        if (Deleted || ControlMaster?.Deleted != false)
+        get => base.Combatant;
+        set
         {
-            return;
-        }
-
-        var range = RangeHome - 2;
-
-        if (InRange(ControlMaster.Location, RangeHome))
-        {
-            return;
-        }
-
-        var master = ControlMaster;
-
-        var m_Loc = Point3D.Zero;
-
-        if (Map != master.Map)
-        {
-            return;
-        }
-
-        var x = X > master.X ? master.X + range : master.X - range;
-        var y = Y > master.Y ? master.Y + range : master.Y - range;
-
-        for (var i = 0; i < 10; i++)
-        {
-            m_Loc.X = x + Utility.RandomMinMax(-1, 1);
-            m_Loc.Y = y + Utility.RandomMinMax(-1, 1);
-
-            m_Loc.Z = Map.GetAverageZ(m_Loc.X, m_Loc.Y);
-
-            if (Map.CanSpawnMobile(m_Loc))
+            if (value != null && (!AssistsMaster || ControlMaster?.Hidden == true))
             {
-                break;
+                return;
             }
 
-            m_Loc = master.Location;
-        }
-
-        if (!Deleted)
-        {
-            SetLocation(m_Loc, true);
+            base.Combatant = value;
         }
     }
 
     public override void OnThink()
     {
-        var master = ControlMaster;
+        base.OnThink();
 
         if (Deleted)
         {
             return;
         }
 
+        var master = ControlMaster;
+
         if (master?.Deleted != false)
         {
             DropPackContents();
-            EndRelease(null);
+            Delete();
             return;
         }
 
-        RangeCheck();
-
-        if (m_LastHidden != master.Hidden)
+        // Compare our own state: Mobile.OnMove reveals a stepping NPC.
+        if (Hidden != master.Hidden)
         {
-            Hidden = m_LastHidden = master.Hidden;
+            Hidden = master.Hidden;
+
+            if (Hidden)
+            {
+                Warmode = false; // nulls Combatant
+            }
         }
+    }
 
-        if (AIObject?.WalkMobileRange(master, 5, 1, 1) == true)
+    // Nothing reveals a hidden caster's familiar.
+    public override void RevealingAction()
+    {
+        if (ControlMaster?.Hidden != true)
         {
-            Warmode = master.Warmode;
-            Combatant = master.Combatant;
-
-            CurrentSpeed = 0.1;
-        }
-        else
-        {
-            Warmode = false;
-            FocusMob = Combatant = null;
-
-            CurrentSpeed = 0.01;
+            base.RevealingAction();
         }
     }
 

Projects/UOContent/Mobiles/Familiars/DeathAdder.cs

@@ -40,5 +40,7 @@ public partial class DeathAdder : BaseFamiliar
     public override string CorpseName => "a death adder corpse";
     public override string DefaultName => "a death adder";
 
+    public override bool AssistsMaster => false;
+
     public override Poison HitPoison => Utility.RandomDouble() < 0.8 ? Poison.Greater : Poison.Deadly;
 }

Projects/UOContent/Mobiles/Familiars/HordeMinion.cs

@@ -10,7 +10,7 @@ namespace Server.Mobiles;
 [SerializationGenerator(0, false)]
 public partial class HordeMinionFamiliar : BaseFamiliar
 {
-    private DateTime m_NextPickup;
+    private long _nextPickup;
 
     public HordeMinionFamiliar()
     {
@@ -59,51 +59,60 @@ public partial class HordeMinionFamiliar : BaseFamiliar
     {
         base.OnThink();
 
-        if (Core.Now < m_NextPickup)
+        if (Core.TickCount - _nextPickup <= 0)
         {
             return;
         }
 
-        m_NextPickup = Core.Now + TimeSpan.FromSeconds(Utility.RandomMinMax(5, 10));
-
-        var pack = Backpack;
-
-        if (pack == null)
-        {
-            return;
-        }
-
-        using var queue = PooledRefQueue<Item>.Create();
-        foreach (var item in GetItemsInRange(2))
-        {
-            if (item.Movable && item.Stackable)
-            {
-                queue.Enqueue(item);
-            }
-        }
-
         var pickedUp = 3;
 
-        while (pickedUp > 0 && queue.Count > 0)
+        try
         {
-            var item = queue.Dequeue();
+            var pack = Backpack;
 
-            if (!pack.CheckHold(this, item, false, true))
+            if (pack == null)
             {
                 return;
             }
 
-            NextActionTime = Core.TickCount;
-
-            Lift(item, item.Amount, out var rejected, out var _);
-
-            if (rejected)
+            using var queue = PooledRefQueue<Item>.Create();
+            foreach (var item in GetItemsInRange(2))
             {
-                continue;
+                if (item.Movable && item.Stackable)
+                {
+                    queue.Enqueue(item);
+                }
             }
 
-            Drop(this, Point3D.Zero);
-            pickedUp--;
+            while (pickedUp > 0 && queue.Count > 0)
+            {
+                var item = queue.Dequeue();
+
+                if (!pack.CheckHold(this, item, false, true))
+                {
+                    return;
+                }
+
+                NextActionTime = Core.TickCount;
+
+                Lift(item, item.Amount, out var rejected, out var _);
+
+                if (rejected)
+                {
+                    continue;
+                }
+
+                Drop(this, Point3D.Zero);
+                pickedUp--;
+            }
+        }
+        finally
+        {
+            if (pickedUp < 3)
+            {
+                // 5-10s
+                _nextPickup = Core.TickCount + Utility.Random(5000, 5000);
+            }
         }
     }
 

Projects/UOContent/Mobiles/Familiars/ShadowWisp.cs

@@ -41,6 +41,8 @@ public partial class ShadowWispFamiliar : BaseFamiliar
     public override string CorpseName => "a shadow wisp corpse";
     public override string DefaultName => "a shadow wisp";
 
+    public override bool AssistsMaster => false;
+
     public override void OnThink()
     {
         base.OnThink();

Projects/UOContent/Skills/AnimalTaming.cs

@@ -37,9 +37,8 @@ namespace Server.SkillHandlers
         }
 
         public static bool CheckMastery(Mobile tamer, BaseCreature creature) =>
-            SummonFamiliarSpell.Table.TryGetValue(tamer, out var bc)
-            && bc is DarkWolfFamiliar { Deleted: false }
-            && creature is DireWolf or GreyWolf or TimberWolf or WhiteWolf or BakeKitsune;
+            SummonFamiliarSpell.Table.TryGetValue(tamer, out var bc) &&
+            bc is DarkWolfFamiliar { Deleted: false } && creature is DireWolf or GreyWolf or TimberWolf or WhiteWolf;
 
         public static bool MustBeSubdued(BaseCreature bc) =>
             bc.Owners.Count <= 0 && bc.SubdueBeforeTame && bc.Hits > bc.HitsMax / 10;