f8d2a2bacc
## Symptom Since #2614, on any shard with `taming.petsStandDownOnCommand` (default `Core.ML`), every wild creature hits `"I'm being attacked but my master told me not to fight."` when struck. Brigands still chase (acquisition is a separate path in the think loop) but the retaliation path is dead: no `OnAggressiveAction`, no `StopFlee`, no `ForceReacquire`, `Combatant` never set, and `Warmode` forced off on every hit. ## Root cause #2614 correctly added `OrderType.None` to `BaseAI.IsStandDownOrder` — a stopped pet rests on `None` and Publish 51 says it must not fight back. But the gate in `BaseCreature.AggressiveAction` never asked whether anybody could have given the order. The old predicate (`ct != Follow && ct != Stop && ct != Stay`) had only excluded wild creatures by accident: `None` was not in its set, so nothing ever needed to spell the check out. A wild creature's `_controlOrder` is always `None`. ## Fix Both halves of `AggressiveAction` now gate on `Controlled && ControlMaster != null && Commandable` — the same predicate every order entry point already uses (`OnSpeech`, context menu, `IsValidTarget`). Only a creature somebody can command has been told to stand down. That excludes, and lets fight back: | Creature | Why it was standing down | |---|---| | Wild creature | rests on `None` | | Energy vortex, blade spirits, animated weapon, animate dead | `Summoned` with a `SummonMaster` but never `Controlled`; rests on `None` | | Familiar, talisman summon, escortee, mirror image | `Controlled` with a master but `Commandable => false`; sits on a system-issued `Follow` | The last row is a deliberate behaviour change from #2614 for ML+ shards: a familiar or escortee on `Follow` no longer stands down when attacked. The publish speaks of commanded pets; a creature that cannot take an order was never told anything, and pre-ML it always fought back. Commandable summons (Summon Creature, elementals, daemons) are `Controlled` with `ControlMaster == SummonMaster`, so they stand down exactly as pets do. ## Also: stop after stay Found while testing: `all come` then `all stop` left the pet on `Stay`, ticking *"I have been ordered to stay"*. `come` rests into `Stay` on arrival (deliberate ModernUO divergence, kept), and #2614 had `IssueStop` keep a previous `Stay`. RunUO and ServUO never consult the previous order — `DoOrderStop` is "wander around here" (or `None` pre-ML) — and Publish 51 says a stopped pet *"may wander"*. `Stay` now joins `Follow`/`Guard` in `IssueStop`: stop cancels the standing order and the pet idles anchored where it stands. `Stop_WhileStaying_RemainsStayingAtOriginalPost` is replaced by `Stop_WhileStaying_CancelsToIdleNone` plus the `come, stop` repro. ## Tests `PetRetaliationTests` gains one case per row above: `WildCreature_`, `UncontrolledSummon_`, `UncommandableCreature_Retaliates_UnderStandDown`. Each fails on main and passes here; full `UOContent.Tests` green (1058 passed).
850 lines
27 KiB
C#
850 lines
27 KiB
C#
/*************************************************************************
|
|
* ModernUO *
|
|
* Copyright 2019-2026 - ModernUO Development Team *
|
|
* Email: hi@modernuo.com *
|
|
* File: PetOrders.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;
|
|
|
|
namespace Server.Mobiles;
|
|
|
|
public abstract partial class BaseAI
|
|
{
|
|
// Runtime-only: None after a load until PetLoginHandler derives it.
|
|
internal OrderType PersistentOrder { get; private set; } = OrderType.None;
|
|
|
|
public static bool IsRestableOrder(OrderType order) =>
|
|
order is OrderType.None or OrderType.Come or OrderType.Guard or OrderType.Attack or OrderType.Stay
|
|
or OrderType.Follow;
|
|
|
|
public static bool IsFriendOrder(OrderType order) =>
|
|
order is OrderType.Follow or OrderType.Stay or OrderType.Stop;
|
|
|
|
// Everything else stands the pet down before it runs.
|
|
private static bool KeepsCombatPosture(OrderType order) =>
|
|
order is OrderType.Attack or OrderType.Guard or OrderType.Drop or OrderType.Friend
|
|
or OrderType.Unfriend or OrderType.Rename;
|
|
|
|
// Publish 51: told any of these, a pet "will not attack anything, even if it is attacked".
|
|
// Stop resolves to None, which is its resting form ("and may wander").
|
|
public static bool IsStandDownOrder(OrderType order) =>
|
|
order is OrderType.Follow or OrderType.Come or OrderType.Stay or OrderType.None;
|
|
|
|
// Orders a dead bonded pet refuses.
|
|
public static bool IsDeadPetOrder(OrderType order) =>
|
|
order is OrderType.Guard or OrderType.Attack or OrderType.Transfer or OrderType.Drop;
|
|
|
|
// A targeted command overwrites ControlTarget; a resumed Follow restores it from here.
|
|
private Mobile _persistentTarget;
|
|
|
|
// The controlled-pet wander anchor (Home) is a pure function of the persistent command.
|
|
internal void SetPersistentOrder(OrderType order)
|
|
{
|
|
PersistentOrder = order;
|
|
_persistentTarget = order == OrderType.Follow ? Mobile.ControlTarget : null;
|
|
Mobile.Home = order is OrderType.Follow or OrderType.Guard ? Point3D.Zero : Mobile.Location;
|
|
}
|
|
|
|
// Adopt a saved standing order; Home and ControlTarget were saved with it.
|
|
internal void RestorePersistentOrder(OrderType order)
|
|
{
|
|
PersistentOrder = order;
|
|
_persistentTarget = order == OrderType.Follow ? Mobile.ControlTarget : null;
|
|
}
|
|
|
|
// The standing order is the fallback only for an interrupted order that cannot resume: a
|
|
// transient, or an attack whose target is gone.
|
|
private OrderType ResumeInterrupted(OrderType previous, Mobile interruptedTarget)
|
|
{
|
|
if (!IsRestableOrder(previous) ||
|
|
previous == OrderType.Attack && IsInvalidControlTarget(interruptedTarget))
|
|
{
|
|
return PersistentOrder;
|
|
}
|
|
|
|
Mobile.ControlTarget = interruptedTarget;
|
|
return previous;
|
|
}
|
|
|
|
// Resume the standing command without re-deriving it or re-anchoring Home.
|
|
private void ResumePersistentOrder() => Mobile.SetControlOrder(PersistentOrder, null, true);
|
|
|
|
/// <summary>
|
|
/// Issue phase. <paramref name="issuer"/> is the only mobile revealed (null = system-issued);
|
|
/// <paramref name="resuming"/> marks a fallback to the standing order. Returns the order to rest in.
|
|
/// </summary>
|
|
public virtual OrderType IssueOrder(
|
|
OrderType order, OrderType previous, Mobile issuer, bool resuming, Mobile interruptedTarget
|
|
)
|
|
{
|
|
if (Mobile.Deleted)
|
|
{
|
|
return order;
|
|
}
|
|
|
|
AITimer.Prod();
|
|
|
|
issuer?.RevealingAction();
|
|
|
|
// Dropping Warmode nulls Combatant through the Mobile setter, which would turn Attack's
|
|
// single Combatant write into a re-write (DoHarmful again) and flap Guard's war stance.
|
|
Mobile.FocusMob = null;
|
|
|
|
if (!KeepsCombatPosture(order))
|
|
{
|
|
Mobile.Warmode = false; // also nulls Combatant via the setter
|
|
Mobile.Combatant = null;
|
|
}
|
|
|
|
return order switch
|
|
{
|
|
OrderType.None => IssueNone(),
|
|
OrderType.Come => IssueCome(),
|
|
OrderType.Drop => IssueDrop(previous, interruptedTarget),
|
|
OrderType.Friend => IssueFriend(previous, interruptedTarget),
|
|
OrderType.Unfriend => IssueUnfriend(previous, interruptedTarget),
|
|
OrderType.Guard => IssueGuard(resuming),
|
|
OrderType.Attack => IssueAttack(resuming),
|
|
OrderType.Release => IssueRelease(),
|
|
OrderType.Stay => IssueStay(resuming),
|
|
OrderType.Stop => IssueStop(previous),
|
|
OrderType.Follow => IssueFollow(resuming),
|
|
OrderType.Transfer => IssueTransfer(),
|
|
OrderType.Rename => IssueRename(issuer, previous, interruptedTarget),
|
|
_ => PersistentOrder // Patrol and anything unimplemented
|
|
};
|
|
}
|
|
|
|
private OrderType IssueNone()
|
|
{
|
|
Mobile.ControlTarget = null;
|
|
Mobile.SetCurrentSpeedToPassive();
|
|
return OrderType.None;
|
|
}
|
|
|
|
private OrderType IssueCome()
|
|
{
|
|
Mobile.SetCurrentSpeedToActive();
|
|
return OrderType.Come;
|
|
}
|
|
|
|
private OrderType IssueStay(bool resuming)
|
|
{
|
|
Mobile.SetCurrentSpeedToPassive();
|
|
|
|
if (resuming)
|
|
{
|
|
Mobile.ControlTarget = null; // a transient's target does not carry over
|
|
}
|
|
else
|
|
{
|
|
SetPersistentOrder(OrderType.Stay); // anchors Home at the post
|
|
Mobile.PlaySound(Mobile.GetIdleSound());
|
|
}
|
|
|
|
return OrderType.Stay;
|
|
}
|
|
|
|
private OrderType IssueFollow(bool resuming)
|
|
{
|
|
Mobile.SetCurrentSpeedToActive();
|
|
|
|
if (resuming)
|
|
{
|
|
// the standing Follow's target, never a transient's
|
|
Mobile.ControlTarget = _persistentTarget?.Deleted == false ? _persistentTarget : Mobile.ControlMaster;
|
|
}
|
|
else
|
|
{
|
|
SetPersistentOrder(OrderType.Follow); // Home = Zero, remembers the target
|
|
Mobile.PlaySound(Mobile.GetIdleSound());
|
|
}
|
|
|
|
return OrderType.Follow;
|
|
}
|
|
|
|
private OrderType IssueGuard(bool resuming)
|
|
{
|
|
Mobile.Warmode = true; // the guard order opens in war stance
|
|
Mobile.SetCurrentSpeedToActive();
|
|
|
|
if (resuming)
|
|
{
|
|
Mobile.ControlTarget = null;
|
|
}
|
|
else
|
|
{
|
|
SetPersistentOrder(OrderType.Guard);
|
|
Mobile.PlaySound(Mobile.GetAttackSound());
|
|
Mobile.ControlMaster?.SendLocalizedMessage(1049671, Mobile.Name);
|
|
// ~1_NAME~ is now guarding you.
|
|
}
|
|
|
|
return OrderType.Guard;
|
|
}
|
|
|
|
private OrderType IssueAttack(bool resuming)
|
|
{
|
|
var target = Mobile.ControlTarget;
|
|
var valid = target?.Deleted == false && target.Alive;
|
|
|
|
Mobile.FocusMob = valid ? target : null;
|
|
Mobile.Combatant = valid ? target : null; // the one Combatant write of the Attack command
|
|
|
|
if (valid)
|
|
{
|
|
Action = ActionType.Combat;
|
|
}
|
|
|
|
Mobile.Warmode = true;
|
|
Mobile.SetCurrentSpeedToActive();
|
|
|
|
// A resumed attack is not a new command: no bark. The Combatant write above is
|
|
// idempotent (the setter early-outs unchanged), so its aggression is not repeated.
|
|
if (!resuming)
|
|
{
|
|
Mobile.PlaySound(Mobile.GetAttackSound());
|
|
}
|
|
|
|
return OrderType.Attack;
|
|
}
|
|
|
|
// Stop: Follow/Guard/Stay -> idle here; anything transient -> the standing order.
|
|
private OrderType IssueStop(OrderType previous)
|
|
{
|
|
Mobile.ControlTarget = null;
|
|
|
|
switch (previous)
|
|
{
|
|
case OrderType.Follow:
|
|
case OrderType.Guard:
|
|
case OrderType.Stay:
|
|
{
|
|
SetPersistentOrder(OrderType.None); // cancel the standing order; idle anchor = here
|
|
return OrderType.None;
|
|
}
|
|
default:
|
|
{
|
|
// No standing order: idle here, anchored (a Zero Home wanders without bounds).
|
|
if (PersistentOrder == OrderType.None)
|
|
{
|
|
SetPersistentOrder(OrderType.None);
|
|
}
|
|
|
|
return PersistentOrder;
|
|
}
|
|
}
|
|
}
|
|
|
|
private OrderType IssueDrop(OrderType previous, Mobile interruptedTarget)
|
|
{
|
|
if (!Mobile.IsDeadPet && Mobile.CanDrop)
|
|
{
|
|
this.DebugSayFormatted($"I am ordered to drop my items by {Mobile.ControlMaster?.Name ?? "Unknown"}.");
|
|
DropItems();
|
|
}
|
|
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
private void DropItems()
|
|
{
|
|
var pack = Mobile.Backpack;
|
|
|
|
if (pack == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var items = pack.Items;
|
|
|
|
for (var i = items.Count - 1; i >= 0; --i)
|
|
{
|
|
if (i < items.Count)
|
|
{
|
|
items[i].MoveToWorld(Mobile.Location, Mobile.Map);
|
|
}
|
|
}
|
|
}
|
|
|
|
private OrderType IssueFriend(OrderType previous, Mobile interruptedTarget)
|
|
{
|
|
var from = Mobile.ControlMaster;
|
|
var to = Mobile.ControlTarget;
|
|
|
|
if (from?.Deleted != false)
|
|
{
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
var youngFrom = from is PlayerMobile { Young: true };
|
|
var youngTo = to is PlayerMobile { Young: true };
|
|
|
|
if (youngFrom && !youngTo)
|
|
{
|
|
from.SendLocalizedMessage(502040);
|
|
// As a young player, you may not friend pets to older players.
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (!youngFrom && youngTo)
|
|
{
|
|
from.SendLocalizedMessage(502041);
|
|
// As an older player, you may not friend pets to young players.
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (to?.Deleted != false || from == to || !to.Player)
|
|
{
|
|
Mobile.PublicOverheadMessage(MessageType.Regular, 0x3B2, 502039);
|
|
// *looks confused*
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (!from.CanBeBeneficial(to, true))
|
|
{
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (from.HasTrade || to.HasTrade)
|
|
{
|
|
(from.HasTrade ? from : to).SendLocalizedMessage(1070947);
|
|
// You cannot friend a pet with a trade pending
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (Mobile.IsPetFriend(to))
|
|
{
|
|
from.SendLocalizedMessage(1049691);
|
|
// That person is already a friend.
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (!Mobile.AllowNewPetFriend)
|
|
{
|
|
from.SendLocalizedMessage(1005482);
|
|
// Your pet does not seem to be interested in making new friends right now.
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
from.SendLocalizedMessage(1049676, $"{Mobile.Name}\t{to.Name}");
|
|
// ~1_NAME~ will now accept movement commands from ~2_NAME~.
|
|
|
|
to.SendLocalizedMessage(1043246, $"{from.Name}\t{Mobile.Name}");
|
|
// ~1_NAME~ has granted you the ability to give orders to their pet ~2_PET_NAME~.
|
|
// This creature will now consider you as a friend.
|
|
|
|
Mobile.AddPetFriend(to);
|
|
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
private OrderType IssueUnfriend(OrderType previous, Mobile interruptedTarget)
|
|
{
|
|
var from = Mobile.ControlMaster;
|
|
var to = Mobile.ControlTarget;
|
|
|
|
if (from?.Deleted != false || to?.Deleted != false || from == to || !to.Player)
|
|
{
|
|
Mobile.PublicOverheadMessage(MessageType.Regular, 0x3B2, 502039);
|
|
// *looks confused*
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
if (!Mobile.IsPetFriend(to))
|
|
{
|
|
from.SendLocalizedMessage(1070953);
|
|
// That person is not a friend.
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
from.SendLocalizedMessage(1070951, $"{Mobile.Name}\t{to.Name}");
|
|
// ~1_NAME~ will no longer accept movement commands from ~2_NAME~.
|
|
|
|
to.SendLocalizedMessage(1070952, $"{from.Name}\t{Mobile.Name}");
|
|
// ~1_NAME~ has no longer granted you the ability to give orders to their pet ~2_PET_NAME~.
|
|
// This creature will no longer consider you as a friend.
|
|
|
|
Mobile.RemovePetFriend(to);
|
|
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
private OrderType IssueTransfer()
|
|
{
|
|
if (Mobile.IsDeadPet)
|
|
{
|
|
return PersistentOrder;
|
|
}
|
|
|
|
var from = Mobile.ControlMaster;
|
|
var to = Mobile.ControlTarget;
|
|
|
|
if (from?.Deleted != false || to?.Deleted != false || from == to || !to.Player)
|
|
{
|
|
return PersistentOrder;
|
|
}
|
|
|
|
this.DebugSayFormatted($"Beginning transfer with {to.Name}");
|
|
|
|
var youngFrom = from is PlayerMobile { Young: true };
|
|
var youngTo = to is PlayerMobile { Young: true };
|
|
|
|
if (youngFrom && !youngTo)
|
|
{
|
|
from.SendLocalizedMessage(502040);
|
|
// As a young player, you may not friend pets to older players.
|
|
return PersistentOrder;
|
|
}
|
|
|
|
if (!youngFrom && youngTo)
|
|
{
|
|
from.SendLocalizedMessage(502041);
|
|
// As an older player, you may not friend pets to young players.
|
|
return PersistentOrder;
|
|
}
|
|
|
|
if (!Mobile.CanBeControlledBy(to))
|
|
{
|
|
SendTransferRefusalMessages(from, to, 1043248, 1043249);
|
|
// 1043248: The pet refuses to be transferred because it will not obey ~1_NAME~.~3_BLANK~
|
|
// 1043249: The pet will not accept you as a master because it does not trust you.~3_BLANK~
|
|
return PersistentOrder;
|
|
}
|
|
|
|
if (!Mobile.CanBeControlledBy(from))
|
|
{
|
|
SendTransferRefusalMessages(from, to, 1043250, 1043251);
|
|
// 1043250: The pet refuses to be transferred because it will not obey you sufficiently.~3_BLANK~
|
|
// 1043251: The pet will not accept you as a master because it does not trust ~2_NAME~.~3_BLANK~
|
|
return PersistentOrder;
|
|
}
|
|
|
|
// The stand-down already cleared Combatant; the aggressor lists and the combat cooldown gate this.
|
|
if (Mobile.Aggressors.Count > 0 || Mobile.Aggressed.Count > 0 || Core.TickCount - Mobile.NextCombatTime < 0)
|
|
{
|
|
from.SendMessage("You can not transfer a pet while in combat.");
|
|
to.SendMessage("You can not transfer a pet while in combat.");
|
|
return PersistentOrder;
|
|
}
|
|
|
|
var fromState = from.NetState;
|
|
var toState = to.NetState;
|
|
|
|
if (fromState == null || toState == null)
|
|
{
|
|
return PersistentOrder;
|
|
}
|
|
|
|
if (from.HasTrade || to.HasTrade)
|
|
{
|
|
from.SendLocalizedMessage(1010507);
|
|
// You cannot transfer a pet with a trade pending
|
|
to.SendLocalizedMessage(1010507);
|
|
// You cannot transfer a pet with a trade pending
|
|
return PersistentOrder;
|
|
}
|
|
|
|
var container = fromState.AddTrade(toState);
|
|
container.DropItem(new TransferItem(Mobile));
|
|
|
|
// Hold position while the trade window is open.
|
|
Mobile.PlaySound(Mobile.GetIdleSound());
|
|
Mobile.SetCurrentSpeedToPassive();
|
|
SetPersistentOrder(OrderType.Stay);
|
|
return OrderType.Stay;
|
|
}
|
|
|
|
private static void SendTransferRefusalMessages(Mobile from, Mobile to, int fromMessage, int toMessage)
|
|
{
|
|
var args = $"{to.Name}\t{from.Name}\t ";
|
|
|
|
from.SendLocalizedMessage(fromMessage, args);
|
|
to.SendLocalizedMessage(toMessage, args);
|
|
}
|
|
|
|
// SetControlMaster(null) assigns ControlOrder = None underneath; the funnel keeps that write.
|
|
private OrderType IssueRelease()
|
|
{
|
|
if (Mobile.Summoned)
|
|
{
|
|
Mobile.Kill();
|
|
|
|
// A vetoed death leaves the summon controlled; it keeps its standing order.
|
|
return Mobile.Deleted || !Mobile.Alive ? OrderType.None : PersistentOrder;
|
|
}
|
|
|
|
DebugSay("I have been released to the wild.");
|
|
|
|
if (!string.IsNullOrEmpty(Mobile.Name))
|
|
{
|
|
Mobile.Name = null;
|
|
}
|
|
|
|
Mobile.PlaySound(Mobile.GetIdleSound());
|
|
|
|
Mobile.ControlTarget = null;
|
|
Mobile.BondingBegin = DateTime.MinValue;
|
|
Mobile.OwnerAbandonTime = DateTime.MinValue;
|
|
Mobile.IsBonded = false;
|
|
// Nothing of the old master survives a re-tame.
|
|
Mobile.ClearPetFriends();
|
|
PersistentOrder = OrderType.None;
|
|
_persistentTarget = null;
|
|
Mobile.SetControlMaster(null);
|
|
|
|
var spawner = Mobile.Spawner;
|
|
|
|
if (spawner != null)
|
|
{
|
|
Mobile.Home = spawner.GetSpawnPosition(Mobile, spawner.Map);
|
|
Mobile.RangeHome = spawner.WalkingRange;
|
|
}
|
|
else
|
|
{
|
|
// No spawner: anchor here rather than path toward a stale stay anchor.
|
|
Mobile.Home = Mobile.Location;
|
|
Action = ActionType.Wander;
|
|
}
|
|
|
|
if (Mobile.DeleteOnRelease || Mobile.IsDeadPet)
|
|
{
|
|
Mobile.Delete();
|
|
}
|
|
else
|
|
{
|
|
Mobile.BeginDeleteTimer();
|
|
|
|
if (Mobile.CanDrop)
|
|
{
|
|
Mobile.DropBackpack();
|
|
}
|
|
}
|
|
|
|
return OrderType.None;
|
|
}
|
|
|
|
protected virtual OrderType IssueRename(Mobile issuer, OrderType previous, Mobile interruptedTarget)
|
|
{
|
|
var to = issuer ?? Mobile.ControlMaster;
|
|
|
|
if (Mobile.Summoned)
|
|
{
|
|
to?.SendMessage("You cannot rename a summoned creature.");
|
|
}
|
|
else
|
|
{
|
|
to?.SendMessage("Change name on pet health bar.");
|
|
}
|
|
|
|
return ResumeInterrupted(previous, interruptedTarget);
|
|
}
|
|
|
|
// Only restable orders arrive here; anything else is a pre-refactor save and resumes the standing order.
|
|
public virtual bool Obey()
|
|
{
|
|
if (Mobile.Deleted)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (Mobile.ControlOrder)
|
|
{
|
|
case OrderType.None:
|
|
{
|
|
return DoOrderNone();
|
|
}
|
|
case OrderType.Come:
|
|
{
|
|
return DoOrderCome();
|
|
}
|
|
case OrderType.Guard:
|
|
{
|
|
return DoOrderGuard();
|
|
}
|
|
case OrderType.Attack:
|
|
{
|
|
return DoOrderAttack();
|
|
}
|
|
case OrderType.Stay:
|
|
{
|
|
return DoOrderStay();
|
|
}
|
|
case OrderType.Follow:
|
|
{
|
|
return DoOrderFollow();
|
|
}
|
|
default:
|
|
{
|
|
ResumePersistentOrder();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool DoOrderNone()
|
|
{
|
|
DebugSay("I currently have no orders.");
|
|
|
|
Mobile.Warmode = IsValidCombatant(Mobile.Combatant);
|
|
|
|
// A standing order is resumed through ResumePersistentOrder, never re-derived here.
|
|
WalkRandomIdle();
|
|
return true;
|
|
}
|
|
|
|
public virtual bool DoOrderCome()
|
|
{
|
|
if (CheckHerding())
|
|
{
|
|
this.DebugSayFormatted($"I am being herded by {Mobile.ControlTarget?.Name ?? "Unknown"}.");
|
|
return true;
|
|
}
|
|
|
|
if (Mobile.ControlMaster?.Deleted != false)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
WalkMobileRange(Mobile.ControlMaster, 1, 1, 2);
|
|
|
|
if (Mobile.GetDistanceToSqrt(Mobile.ControlMaster) <= 2)
|
|
{
|
|
Mobile.ControlOrder = OrderType.Stay;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual bool DoOrderFollow()
|
|
{
|
|
if (CheckHerding())
|
|
{
|
|
this.DebugSayFormatted($"I am being herded by {Mobile.ControlTarget?.Name ?? "Unknown"}.");
|
|
return true;
|
|
}
|
|
|
|
if (Mobile.ControlTarget?.Deleted == false && Mobile.ControlTarget != Mobile)
|
|
{
|
|
FollowTarget();
|
|
}
|
|
else
|
|
{
|
|
DebugSay("I have no one to follow.");
|
|
|
|
Mobile.ControlOrder = OrderType.None;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void FollowTarget()
|
|
{
|
|
var currentDistance = (int)Mobile.GetDistanceToSqrt(Mobile.ControlTarget);
|
|
|
|
if (currentDistance > Mobile.RangePerception)
|
|
{
|
|
this.DebugSayFormatted($"Master {Mobile.ControlMaster?.Name ?? "Unknown"} is missing. Staying put.");
|
|
return;
|
|
}
|
|
|
|
this.DebugSayFormatted($"I am ordered to follow {Mobile.ControlTarget?.Name}.");
|
|
|
|
if (currentDistance > 1)
|
|
{
|
|
WalkMobileRange(Mobile.ControlTarget, 1, 1, 2);
|
|
}
|
|
}
|
|
|
|
public virtual bool DoOrderGuard()
|
|
{
|
|
var controlMaster = Mobile.ControlMaster;
|
|
|
|
if (Mobile.IsDeadPet || controlMaster?.Deleted != false)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var combatant = FindGuardTarget();
|
|
|
|
if (combatant != null)
|
|
{
|
|
this.DebugSayFormatted($"Attacking target: {combatant.Name}");
|
|
|
|
// Engage without leaving the Guard order so tags, recall handling, and retargeting persist.
|
|
Mobile.Combatant = combatant;
|
|
Mobile.FocusMob = combatant;
|
|
Action = ActionType.Combat;
|
|
|
|
Think();
|
|
}
|
|
else
|
|
{
|
|
this.DebugSayFormatted($"Guarding my master, {controlMaster.Name}.");
|
|
|
|
// Stand down; a stale Warmode would skew the return pace.
|
|
Mobile.FocusMob = null;
|
|
Mobile.Warmode = false;
|
|
Mobile.Combatant = null;
|
|
|
|
var distance = (int)Mobile.GetDistanceToSqrt(controlMaster);
|
|
|
|
// Alert either way; FollowMoveSpeed caps the steps of the return itself.
|
|
Mobile.SetCurrentSpeedToActive();
|
|
|
|
if (distance > GuardRange)
|
|
{
|
|
WalkMobileRange(controlMaster, 1, 1, GuardRange);
|
|
}
|
|
else
|
|
{
|
|
WalkRandom(3, 1, 1);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual bool DoOrderAttack()
|
|
{
|
|
if (Mobile.IsDeadPet)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (IsInvalidControlTarget(Mobile.ControlTarget))
|
|
{
|
|
HandleInvalidControlTarget();
|
|
}
|
|
else
|
|
{
|
|
this.DebugSayFormatted($"Attacking target: {Mobile.ControlTarget?.Name}");
|
|
|
|
// OnAggressiveAction can swap Combatant; the commanded target wins.
|
|
if (Mobile.Combatant != Mobile.ControlTarget)
|
|
{
|
|
Mobile.Combatant = Mobile.ControlTarget;
|
|
}
|
|
|
|
Think();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool IsInvalidControlTarget(Mobile target) => target?.Deleted != false || target.Map != Mobile.Map
|
|
|| !target.Alive || target.IsDeadBondedPet || target.Hidden;
|
|
|
|
private void HandleInvalidControlTarget()
|
|
{
|
|
DebugSay("Target is either dead, hidden, or out of range.");
|
|
|
|
ResumePersistentOrder();
|
|
|
|
// A resumed Guard engages through its own scan; other fallbacks chain an explicit Attack.
|
|
if (Mobile.ControlOrder == OrderType.Guard ||
|
|
Mobile.FightMode is not (FightMode.Closest or FightMode.Aggressor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var next = FindGuardTarget();
|
|
|
|
if (next != null)
|
|
{
|
|
Mobile.IssueOrder(OrderType.Attack, null, next);
|
|
|
|
this.DebugSayFormatted($"{next.Name} is still hostile! Engaging...");
|
|
|
|
Think();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects the aggressor closest to the master. The current combatant is kept
|
|
/// unless a strictly closer one exists. Never mutates order state.
|
|
/// </summary>
|
|
private Mobile FindGuardTarget()
|
|
{
|
|
var controlMaster = Mobile.ControlMaster;
|
|
var anchor = controlMaster ?? Mobile;
|
|
|
|
var current = Mobile.Combatant;
|
|
var best = current != controlMaster && IsValidCombatant(current) ? current : null;
|
|
var bestDist = best?.GetDistanceToSqrt(anchor) ?? double.MaxValue;
|
|
|
|
foreach (var aggr in Mobile.GetMobilesInRange(Mobile.RangePerception))
|
|
{
|
|
if (aggr == best || aggr == Mobile || aggr == controlMaster ||
|
|
aggr.IsDeadBondedPet || !aggr.Alive ||
|
|
aggr.Combatant != Mobile && (controlMaster == null || aggr.Combatant != controlMaster))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var dist = aggr.GetDistanceToSqrt(anchor);
|
|
|
|
if (dist < bestDist && Mobile.CanSee(aggr) && Mobile.InLOS(aggr))
|
|
{
|
|
best = aggr;
|
|
bestDist = dist;
|
|
}
|
|
}
|
|
|
|
var aggressors = controlMaster?.Aggressors;
|
|
|
|
if (aggressors != null)
|
|
{
|
|
for (var i = 0; i < aggressors.Count; i++)
|
|
{
|
|
var aggressor = aggressors[i].Attacker;
|
|
|
|
if (aggressor == best || aggressor?.Deleted != false || !aggressor.Alive ||
|
|
aggressor.IsDeadBondedPet || !Mobile.InRange(aggressor, Mobile.RangePerception))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var dist = aggressor.GetDistanceToSqrt(anchor);
|
|
|
|
if (dist < bestDist && Mobile.CanSee(aggressor) && Mobile.InLOS(aggressor))
|
|
{
|
|
best = aggressor;
|
|
bestDist = dist;
|
|
}
|
|
}
|
|
}
|
|
|
|
return best;
|
|
}
|
|
|
|
public virtual bool DoOrderStay()
|
|
{
|
|
if (CheckHerding())
|
|
{
|
|
this.DebugSayFormatted($"I am being herded by {Mobile.ControlTarget?.Name ?? "Unknown"}.");
|
|
}
|
|
else
|
|
{
|
|
this.DebugSayFormatted($"I have been ordered to stay by {Mobile.ControlMaster?.Name ?? "Unknown"}.");
|
|
}
|
|
|
|
// Hold position at the post (Home). Stand still when there; only walk back if displaced
|
|
// (e.g. after chasing a kill). No idle shuffle.
|
|
if (Mobile.Home != Point3D.Zero && Mobile.Location != Mobile.Home)
|
|
{
|
|
DoMove(Mobile.GetDirectionTo(Mobile.Home));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|