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

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();
}
}
}

6
Projects/UOContent/Items/Weapons/BaseWeapon.cs
View file

@ -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)

48
Projects/UOContent/Mobiles/AI/BaseAI/AIMovement.cs
View file

@ -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;
}

30
Projects/UOContent/Mobiles/AI/BaseAI/ApproachOutcome.cs Normal file
View file

@ -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
}

4
Projects/UOContent/Mobiles/AI/BaseAI/BaseAI.cs
View file

@ -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;
}

268
Projects/UOContent/Mobiles/AI/FamiliarAI.cs Normal file
View file

@ -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;
}
}

20
Projects/UOContent/Mobiles/BaseCreature.cs
View file

@ -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)

100
Projects/UOContent/Mobiles/Familiars/BaseFamiliar.cs
View file

@ -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();
}
}

2
Projects/UOContent/Mobiles/Familiars/DeathAdder.cs
View file

@ -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;
}

71
Projects/UOContent/Mobiles/Familiars/HordeMinion.cs
View file

@ -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);
}
}
}

2
Projects/UOContent/Mobiles/Familiars/ShadowWisp.cs
View file

@ -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();

5
Projects/UOContent/Skills/AnimalTaming.cs
View file

@ -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;