warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
## 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.
This commit is contained in:
Kamron Batman 2026-09-14 23:14:30 -07:00 • committed by GitHub
parent 459674ce3b
commit 1e891094fe
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 1265 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

130
Projects/UOContent.Tests/Tests/Mobiles/AI/ApproachOutcomeTests.cs Normal file
View file

@ -0,0 +1,130 @@
using System.Collections.Generic;
using Server;
using Server.Engines.Pathing.Cache;
using Server.Mobiles;
using Server.Tests;
using Server.Tests.Mobiles.AI;
using Xunit;
namespace UOContent.Tests.Mobiles.AI;
// Driven manually against live map statics; the pathfinder's buffers are not reentrant.
[Collection("Sequential Pathfinding Tests")]
public class ApproachOutcomeTests
{
private sealed class Stub : BaseCreature
{
public Stub(Serial serial) : base(serial) => Body = 0xC9;
}
private sealed class Target : Mobile
{
public Target() => Body = 0xC9;
}
private static (Stub bc, BaseAI ai) NewFollower(Map map, int x, int y)
{
map.GetAverageZ(x, y, out _, out var z, out _);
var bc = new Stub(World.NewMobile);
bc.DefaultMobileInit();
bc.MoveToWorld(new Point3D(x, y, (sbyte)z), map);
BaseAI ai = new AnimalAI(bc);
ai.AITimer?.Stop();
return (bc, ai);
}
private static Target NewTarget(Map map, int x, int y)
{
map.GetAverageZ(x, y, out _, out var z, out _);
var t = new Target();
t.MoveToWorld(new Point3D(x, y, (sbyte)z), map);
return t;
}
[SkippableFact]
public void OpenGround_ReportsDirectProgress_ThenArrived()
{
TileDataRequirement.SkipIfMissing();
var map = Map.Maps[1];
var (bc, ai) = NewFollower(map, 1500, 1600);
var target = NewTarget(map, 1497, 1600);
StepCache.Instance.Clear();
try
{
ai.NextMove = 0;
ai.MoveTo(target, 1);
Assert.Equal(ApproachOutcome.DirectProgress, ai.LastApproach);
ai.MoveTo(target, 1); // budget consumed: no step
Assert.Equal(ApproachOutcome.Waiting, ai.LastApproach);
ai.NextMove = 0;
ai.MoveTo(target, 1); // lands adjacent: still a progress step
Assert.Equal(ApproachOutcome.DirectProgress, ai.LastApproach);
ai.NextMove = 0;
ai.MoveTo(target, 1);
Assert.Equal(ApproachOutcome.Arrived, ai.LastApproach);
}
finally
{
bc.Delete();
target.Delete();
}
}
[SkippableFact]
public void WalledTarget_ReportsGaveUp()
{
TileDataRequirement.SkipIfMissing();
var map = Map.Maps[1];
var (bc, ai) = NewFollower(map, 1500, 1601);
var target = NewTarget(map, 1500, 1596);
var ring = new List<Item>();
var id = ApproachTargetTests.FirstImpassableItemId();
Assert.NotEqual<ushort>(0, id);
// Impassable ring around the target: unreachable.
for (var x = 1499; x <= 1501; x++)
{
for (var y = 1595; y <= 1597; y++)
{
if (x == 1500 && y == 1596)
{
continue;
}
map.GetAverageZ(x, y, out _, out var rz, out _);
ring.Add(new Item(World.NewItem) { ItemID = id, Map = map, Location = new Point3D(x, y, (sbyte)rz) });
}
}
StepCache.Instance.Clear();
try
{
var sawRouting = false;
for (var i = 0; i < 120; i++)
{
ai.NextMove = 0;
ai.MoveTo(target, 1);
sawRouting |= ai.LastApproach is ApproachOutcome.Routing or ApproachOutcome.Blocked;
}
Assert.True(sawRouting, "a walled target must route or block before giving up");
Assert.Equal(ApproachOutcome.GaveUp, ai.LastApproach);
}
finally
{
bc.Delete();
target.Delete();
for (var i = 0; i < ring.Count; i++)
{
ring[i].Delete();
}
}
}
}

2
Projects/UOContent.Tests/Tests/Mobiles/AI/ApproachTargetTests.cs
View file

@ -49,7 +49,7 @@ public class ApproachTargetTests
return false;
}
private static ushort FirstImpassableItemId()
internal static ushort FirstImpassableItemId()
{
for (ushort id = 1; id < TileData.MaxItemValue; id++)
{

557
Projects/UOContent.Tests/Tests/Mobiles/AI/FamiliarAITests.cs Normal file
View file

@ -0,0 +1,557 @@
using System;
using System.Collections.Generic;
using Server;
using Server.Items;
using Server.Mobiles;
using Server.Tests;
using Server.Tests.Mobiles.AI;
using Xunit;
namespace UOContent.Tests.Mobiles.AI;
// Timer-wheel driven (the real AITimer thinks and moves) against live Trammel statics.
[Collection("Sequential Pathfinding Tests")]
public class FamiliarAITests : IDisposable
{
// NPCSpeeds is not configured in the fixture; pin the speeds.
private sealed class Wolf : DarkWolfFamiliar
{
public override void GetSpeeds(out double a, out double p) { a = 0.1; p = 0.1; }
}
private sealed class Bat : VampireBatFamiliar
{
public override void GetSpeeds(out double a, out double p) { a = 0.1; p = 0.1; }
}
private sealed class Wisp : ShadowWispFamiliar
{
public override void GetSpeeds(out double a, out double p) { a = 0.1; p = 0.1; }
}
private sealed class Adder : DeathAdder
{
public override void GetSpeeds(out double a, out double p) { a = 0.1; p = 0.1; }
}
private sealed class Minion : HordeMinionFamiliar
{
public override void GetSpeeds(out double a, out double p) { a = 0.1; p = 0.1; }
}
private sealed class EnemyStub : Mobile
{
public EnemyStub()
{
Body = 0x190;
Str = 100;
}
}
private static readonly Map _map = Map.Maps[1];
private readonly List<IEntity> _created = new();
public FamiliarAITests()
{
TileDataRequirement.SkipIfMissing();
Core._tickCount = 0;
Timer.Init(0);
}
public void Dispose()
{
for (var i = _created.Count - 1; i >= 0; i--)
{
_created[i].Delete();
}
}
private static Point3D At(int x, int y)
{
_map.GetAverageZ(x, y, out _, out var z, out _);
return new Point3D(x, y, (sbyte)z);
}
private PlayerMobile Master(int x, int y)
{
var p = new PlayerMobile(World.NewMobile);
p.DefaultMobileInit();
p.Player = true;
p.Body = 0x190;
p.Str = p.Dex = p.Int = 100;
p.AddItem(new Backpack());
p.MoveToWorld(At(x, y), _map);
_created.Add(p);
return p;
}
private BaseFamiliar Familiar(int kind, PlayerMobile master, int x, int y)
{
BaseFamiliar f = kind switch
{
0 => new Wolf(),
1 => new Bat(),
2 => new Wisp(),
3 => new Adder(),
_ => new Minion()
};
Assert.True(BaseCreature.Summon(f, master, At(x, y), -1, TimeSpan.FromHours(1)));
_created.Add(f);
return f;
}
private EnemyStub Enemy(int x, int y)
{
var e = new EnemyStub();
e.MoveToWorld(At(x, y), _map);
_created.Add(e);
return e;
}
// 8ms lockstep keeps the wheel and Core.TickCount in sync.
private static void RunFor(long ms)
{
var deadline = Core._tickCount + ms;
while (Core._tickCount - deadline < 0)
{
Core._tickCount += 8;
Timer.Slice(Core._tickCount);
}
}
private static bool RunUntil(Func<bool> condition, long maxMs)
{
var deadline = Core._tickCount + maxMs;
while (Core._tickCount - deadline < 0)
{
if (condition())
{
return true;
}
Core._tickCount += 8;
Timer.Slice(Core._tickCount);
}
return condition();
}
[SkippableFact]
public void UsesFamiliarAI_AndStaysOnComeOrder()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1500, 1600);
Assert.IsType<FamiliarAI>(f.AIObject);
Assert.Equal(OrderType.Come, f.ControlOrder);
Assert.Equal(0.1, f.ActiveSpeed);
Assert.Equal(0.1, f.PassiveSpeed);
}
[SkippableFact]
public void Follows_WithoutBacktracking()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1500, 1600);
RunFor(400); // past the activation spread
p.MoveToWorld(At(1494, 1600), _map);
var best = f.GetDistanceToSqrt(p);
var regressed = false;
var arrived = RunUntil(
() =>
{
var d = f.GetDistanceToSqrt(p);
if (d > best + 0.01)
{
regressed = true;
}
best = Math.Min(best, d);
return f.InRange(p, 1);
},
3000
);
Assert.True(arrived, "familiar must reach range 1 of its master");
Assert.False(regressed, "familiar must never step away from the master while following");
Assert.Equal(OrderType.Come, f.ControlOrder);
Assert.Equal(Point3D.Zero, f.Home);
}
[SkippableFact]
public void Orders_AreInert()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1500, 1600);
RunFor(400);
f.IssueOrder(OrderType.Stay, p);
Assert.Equal(Point3D.Zero, f.Home);
Assert.Equal(0.1, f.CurrentSpeed);
p.MoveToWorld(At(1495, 1600), _map);
Assert.True(RunUntil(() => f.InRange(p, 1), 3000), "a familiar under a Stay order still follows");
}
[SkippableTheory]
[InlineData(0, true)] // dark wolf
[InlineData(1, true)] // vampire bat
[InlineData(2, false)] // shadow wisp
[InlineData(3, false)] // death adder
[InlineData(4, true)] // horde minion
public void AssistsMastersTarget_OnlyIfCombatCapable(int kind, bool assists)
{
var p = Master(1500, 1600);
var f = Familiar(kind, p, 1501, 1600);
var e = Enemy(1495, 1600);
RunFor(400);
p.Warmode = true;
p.Combatant = e;
if (assists)
{
Assert.True(
RunUntil(() => f.Combatant == e && f.InRange(e, f.RangeFight), 4000),
"a combat familiar must engage the caster's target"
);
Assert.True(f.Warmode);
Assert.Equal(OrderType.Come, f.ControlOrder);
}
else
{
RunFor(2000);
Assert.Null(f.Combatant);
Assert.False(f.Warmode);
Assert.True(f.InRange(p, 1), "a non-combat familiar stays with the caster");
}
}
[SkippableFact]
public void DropsTarget_WhenMasterHides()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1501, 1600);
var e = Enemy(1495, 1600);
RunFor(400);
p.Warmode = true;
p.Combatant = e;
Assert.True(RunUntil(() => f.Combatant == e, 2000));
p.Hidden = true;
Assert.True(RunUntil(() => f.Combatant == null && f.Hidden, 1000));
}
[SkippableFact]
public void Leash_NeverEngagesATargetFarFromTheMaster()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1501, 1600);
var e = Enemy(1500 - f.RangePerception - 4, 1600); // beyond the leash
RunFor(400);
p.Warmode = true;
p.Combatant = e;
RunFor(4000);
Assert.Null(f.Combatant);
Assert.True(f.InRange(p, 1), "assist must not carry the familiar past the leash");
}
[SkippableFact]
public void Retaliates_IfCombatCapable_AndStaysOnComeOrder()
{
var p = Master(1500, 1600);
var wolf = Familiar(0, p, 1501, 1600);
var wisp = Familiar(2, p, 1499, 1600);
var e = Enemy(1503, 1600);
RunFor(400);
// Combatant setter → DoHarmful → AggressiveAction with ChangingCombatant: the path that
// issues a stand-down pet an Attack order.
e.Combatant = wolf;
Assert.True(RunUntil(() => wolf.Combatant == e, 1000), "a combat familiar fights back");
Assert.Equal(OrderType.Come, wolf.ControlOrder);
e.Combatant = wisp;
RunFor(1000);
Assert.Null(wisp.Combatant);
Assert.False(wisp.Warmode);
}
[SkippableFact]
public void KeepUp_SnapsWhenFarOnOpenGround()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1500, 1600);
RunFor(400);
p.MoveToWorld(At(1500 - BaseFamiliar.KeepUpRange - 2, 1600), _map);
RunFor(300); // one think with a greedy step
Assert.True(f.InRange(p, 1), "familiar must snap adjacent to a master 12 tiles away on open ground");
}
[SkippableFact]
public void KeepUp_DoesNotSnapWhileRouting()
{
// Britain inn L-desk: master north, familiar south; ~17-step detour.
var p = Master(1494, 1605);
var f = Familiar(0, p, 1493, 1614);
p.MoveToWorld(new Point3D(1494, 1605, 21), _map);
f.MoveToWorld(new Point3D(1493, 1614, 20), _map);
Server.Engines.Pathing.Cache.StepCache.Instance.Clear();
// Observed from the first tick so an early snap cannot hide behind "arrived".
var teleported = false;
var last = f.Location;
var arrived = RunUntil(
() =>
{
if (f.Location != last && !f.InRange(last, 1))
{
teleported = true;
}
last = f.Location;
return f.InRange(p, 1);
},
8000
);
Assert.True(arrived, "familiar walks the detour");
Assert.False(teleported, "a working detour must not be short-circuited by a snap");
}
[SkippableFact]
public void KeepUp_SnapsAfterGiveUp()
{
var p = Master(1500, 1596);
var f = Familiar(0, p, 1500, 1602);
// 5x5 ring, open 3x3 interior: a landing tile exists, no route reaches it.
var id = ApproachTargetTests.FirstImpassableItemId();
Assert.NotEqual<ushort>(0, id);
for (var x = 1498; x <= 1502; x++)
{
for (var y = 1594; y <= 1598; y++)
{
if (x is > 1498 and < 1502 && y is > 1594 and < 1598)
{
continue;
}
_map.GetAverageZ(x, y, out _, out var rz, out _);
_created.Add(new Item(World.NewItem) { ItemID = id, Map = _map, Location = new Point3D(x, y, (sbyte)rz) });
}
}
Server.Engines.Pathing.Cache.StepCache.Instance.Clear();
RunFor(400);
Assert.True(
RunUntil(() => f.InRange(p, 1), 15000),
"after giving up on an unreachable master the familiar snaps to it"
);
}
[SkippableFact]
public void MirrorsHidden_EvenWhileWalking()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1500, 1600);
RunFor(400);
p.Hidden = true;
p.MoveToWorld(At(1495, 1600), _map);
Assert.True(RunUntil(() => f.Hidden, 500));
var stayedHidden = true;
var arrived = RunUntil(
() =>
{
stayedHidden &= f.Hidden;
return f.InRange(p, 1);
},
3000
);
Assert.True(arrived);
Assert.True(stayedHidden, "steps must not strip the mirror");
p.Hidden = false;
Assert.True(RunUntil(() => !f.Hidden, 500));
}
[SkippableFact]
public void Herding_TargetLocation_WinsAndClears()
{
var p = Master(1500, 1600);
var f = Familiar(4, p, 1500, 1600);
RunFor(400);
var goal = new Point2D(1500, 1594);
f.TargetLocation = goal;
Assert.True(RunUntil(() => f.TargetLocation == null, 6000), "familiar walks to the herding target");
Assert.True(f.InRange(goal, 1));
}
[SkippableFact]
public void NonCombatFamiliar_RefusesAnyCombatant()
{
var p = Master(1500, 1600);
var wisp = Familiar(2, p, 1501, 1600);
var e = Enemy(1502, 1600);
wisp.Combatant = e;
Assert.Null(wisp.Combatant);
}
[SkippableFact]
public void HiddenCaster_FamiliarRefusesRetaliation()
{
var p = Master(1500, 1600);
var wolf = Familiar(0, p, 1501, 1600);
var e = Enemy(1502, 1600);
RunFor(400);
p.Hidden = true;
Assert.True(RunUntil(() => wolf.Hidden, 500));
e.Combatant = wolf;
// Synchronous: the veto is at the setter.
Assert.Null(wolf.Combatant);
Assert.False(wolf.Warmode);
RunFor(500);
Assert.Null(wolf.Combatant);
Assert.True(wolf.Hidden);
}
[SkippableFact]
public void LeftBehind_StandsDown()
{
var p = Master(1500, 1600);
var wolf = Familiar(0, p, 1501, 1600);
var e = Enemy(1495, 1600);
RunFor(400);
p.Warmode = true;
p.Combatant = e;
Assert.True(RunUntil(() => wolf.Combatant == e, 2000));
p.MoveToWorld(new Point3D(1500, 1600, p.Z), Map.Felucca);
Assert.True(RunUntil(() => wolf.Combatant == null && !wolf.Warmode, 500));
}
[SkippableFact]
public void Herding_OutranksCombat_AndStandsDown()
{
var p = Master(1500, 1600);
var f = Familiar(4, p, 1501, 1600);
var e = Enemy(1502, 1600);
RunFor(400);
p.Warmode = true;
p.Combatant = e;
Assert.True(RunUntil(() => f.Combatant == e, 2000));
// Caster visible and fighting: only herding clears this.
var goal = new Point2D(1500, 1594);
f.TargetLocation = goal;
var distBefore = f.GetDistanceToSqrt(goal);
RunFor(300);
Assert.Null(f.Combatant);
Assert.False(f.Warmode);
Assert.NotNull(f.TargetLocation);
Assert.True(f.GetDistanceToSqrt(goal) < distBefore, "the fetch makes progress while combat is set aside");
Assert.Same(e, p.Combatant);
}
[SkippableFact]
public void AssistsAgainstWhatTheCastersPetIsFighting()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1501, 1600);
var e = Enemy(1496, 1600);
var pet = new PetTestStub();
pet.MoveToWorld(At(1497, 1600), _map);
pet.SetControlMaster(p);
_created.Add(pet);
RunFor(400);
// The pet attacks; the caster is credited indirectly without a Combatant.
pet.Combatant = e;
p.DoHarmful(e, true);
e.Combatant = pet;
Assert.Null(p.Combatant);
Assert.True(
RunUntil(() => f.Combatant == e && f.InRange(e, f.RangeFight), 4000),
"familiar joins the fight the caster's pet is in"
);
}
[SkippableFact]
public void DefendsAnAttackedCaster_WhoseOwnCombatantExpired()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1501, 1600);
var e = Enemy(1496, 1600);
RunFor(400);
e.Combatant = p;
p.Combatant = null; // expired
Assert.Null(p.Combatant);
Assert.True(
RunUntil(() => f.Combatant == e && f.InRange(e, f.RangeFight), 4000),
"familiar defends the caster from a live aggressor"
);
}
[SkippableFact]
public void DropsATarget_ThatNoLongerFightsAnyone()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1501, 1600);
var e = Enemy(1495, 1600);
RunFor(400);
p.Warmode = true;
p.Combatant = e;
Assert.True(RunUntil(() => f.Combatant == e, 2000));
// Caster stops, target disengages.
p.Combatant = null;
p.Warmode = false;
e.Combatant = null;
Assert.True(RunUntil(() => f.Combatant == null && f.InRange(p, 1), 4000), "familiar disengages and returns");
}
[SkippableFact]
public void AssistEnd_LeavesNoStaleMoveIntent()
{
var p = Master(1500, 1600);
var f = Familiar(0, p, 1501, 1600);
var e = Enemy(1495, 1600);
RunFor(400);
p.Warmode = true;
p.Combatant = e;
Assert.True(RunUntil(() => f.Combatant == e, 2000));
// Assist ends with the familiar already beside the caster (MoveTo's arrival return).
f.MoveToWorld(At(1501, 1600), _map);
p.Combatant = null;
p.Warmode = false;
e.Combatant = null;
Assert.True(RunUntil(() => f.Combatant == null, 500));
Assert.False(f.AIObject.TryGetMoveWake(out _), "no pursuit may survive the stand-down");
}
}

59
Projects/UOContent.Tests/Tests/Mobiles/AI/ForcedAITests.cs Normal file
View file

@ -0,0 +1,59 @@
using Server;
using Server.Mobiles;
using Xunit;
namespace UOContent.Tests.Mobiles.AI;
[Collection("Sequential UOContent Tests")]
public class ForcedAITests
{
private sealed class CountingAI : BaseAI
{
public CountingAI(BaseCreature m) : base(m)
{
}
}
private sealed class ForcedStub : BaseCreature
{
public int Constructions;
public ForcedStub() : base(AIType.AI_Melee)
{
}
public override void GetSpeeds(out double activeSpeed, out double passiveSpeed)
{
activeSpeed = 0.2;
passiveSpeed = 0.4;
}
// Not sector-gated: a BaseAI ctor starts its timer immediately.
public override bool PlayerRangeSensitive => false;
protected override BaseAI ForcedAI
{
get
{
Constructions++;
return new CountingAI(this);
}
}
}
[Fact]
public void ChangeAIType_ConstructsForcedAIOnce()
{
var bc = new ForcedStub();
try
{
Assert.Equal(1, bc.Constructions);
Assert.IsType<CountingAI>(bc.AIObject);
}
finally
{
bc.Delete();
}
}
}

51
Projects/UOContent.Tests/Tests/Mobiles/AI/HerdingTests.cs Normal file
View file

@ -0,0 +1,51 @@
using Server;
using Server.Engines.Pathing.Cache;
using Server.Mobiles;
using Server.Tests;
using Xunit;
namespace UOContent.Tests.Mobiles.AI;
// Driven manually against live map statics; the pathfinder's buffers are not reentrant.
[Collection("Sequential Pathfinding Tests")]
public class HerdingTests
{
private sealed class Stub : BaseCreature
{
public Stub(Serial serial) : base(serial) => Body = 0xC9;
}
[SkippableFact]
public void HerdedCreature_ReachesTheTile_AndClearsTargetLocation()
{
TileDataRequirement.SkipIfMissing();
var map = Map.Maps[1];
map.GetAverageZ(1500, 1600, out _, out var z, out _);
var bc = new Stub(World.NewMobile);
bc.DefaultMobileInit();
bc.MoveToWorld(new Point3D(1500, 1600, (sbyte)z), map);
BaseAI ai = new AnimalAI(bc);
ai.AITimer?.Stop();
StepCache.Instance.Clear();
try
{
var goal = new Point2D(1500, 1595);
bc.TargetLocation = goal;
for (var i = 0; i < 40 && bc.TargetLocation != null; i++)
{
ai.NextMove = 0;
ai.CheckHerding();
}
Assert.Null(bc.TargetLocation);
Assert.Equal(goal, new Point2D(bc.X, bc.Y));
}
finally
{
bc.Delete();
}
}
}