1607 lines
37 KiB
C#
1607 lines
37 KiB
C#
#region References
|
|
using System;
|
|
|
|
using Server.Items;
|
|
using Server.SkillHandlers;
|
|
using Server.Spells;
|
|
using Server.Spells.Eighth;
|
|
using Server.Spells.Fifth;
|
|
using Server.Spells.First;
|
|
using Server.Spells.Fourth;
|
|
using Server.Spells.Mysticism;
|
|
using Server.Spells.Necromancy;
|
|
using Server.Spells.Second;
|
|
using Server.Spells.Seventh;
|
|
using Server.Spells.Sixth;
|
|
using Server.Spells.SkillMasteries;
|
|
using Server.Spells.Spellweaving;
|
|
using Server.Spells.Third;
|
|
using Server.Targeting;
|
|
#endregion
|
|
|
|
namespace Server.Mobiles
|
|
{
|
|
public class MageAI : BaseAI
|
|
{
|
|
public virtual SkillName CastSkill { get { return SkillName.Magery; } }
|
|
public virtual bool UsesMagery { get { return true; } }
|
|
public virtual double HealChance { get { return .25; } }
|
|
|
|
protected const double DispelChance = 0.75; // 75% chance to dispel at gm skill
|
|
protected double TeleportChance { get { return m_Mobile.TeleportChance; } }
|
|
|
|
private LandTarget m_RevealTarget;
|
|
|
|
public DateTime NextCastTime { get; set; }
|
|
public DateTime NextHealTime { get; set; }
|
|
public Mobile LastTarget { get; set; }
|
|
public Point3D LastTargetLoc { get; set; }
|
|
|
|
public virtual bool SmartAI
|
|
{
|
|
get { return PetTrainingHelper.GetAbilityProfile(m_Mobile, true).HasAbility(MagicalAbility.MageryMastery); }
|
|
}
|
|
|
|
public MageAI(BaseCreature m)
|
|
: base(m)
|
|
{ }
|
|
|
|
public override bool Think()
|
|
{
|
|
if (m_Mobile.Deleted)
|
|
return false;
|
|
|
|
if (ProcessTarget())
|
|
return true;
|
|
return base.Think();
|
|
}
|
|
|
|
public virtual double ScaleByCastSkill(double v)
|
|
{
|
|
return m_Mobile.Skills[CastSkill].Value * v * 0.01;
|
|
}
|
|
|
|
public virtual double ScaleBySkill(double v, SkillName skill)
|
|
{
|
|
return v * m_Mobile.Skills[skill].Value / 100;
|
|
}
|
|
|
|
protected TimeSpan GetDelay(Spell spell)
|
|
{
|
|
var del = ScaleBySkill(3.0, spell != null ? spell.CastSkill : CastSkill);
|
|
var min = 6.0 - (del * 0.75);
|
|
var max = 6.0 - (del * 1.25);
|
|
|
|
return TimeSpan.FromSeconds(min + ((max - min) * Utility.RandomDouble()));
|
|
}
|
|
|
|
protected virtual DateTime GetCastDelay(Spell spell)
|
|
{
|
|
if (UsesMagery)
|
|
{
|
|
var ts = !SmartAI && !(spell is DispelSpell)
|
|
? TimeSpan.FromSeconds(1)
|
|
: m_Combo > -1
|
|
? TimeSpan.FromSeconds(.5)
|
|
: TimeSpan.FromSeconds(1.5);
|
|
var delay = spell == null
|
|
? TimeSpan.FromSeconds(m_Mobile.ActiveSpeed * 2.0)
|
|
: spell.GetCastDelay() + spell.GetCastRecovery() + ts;
|
|
|
|
return DateTime.UtcNow + delay;
|
|
}
|
|
else
|
|
{
|
|
var delay = spell == null
|
|
? TimeSpan.FromSeconds(m_Mobile.ActiveSpeed * 2.0)
|
|
: spell.GetCastDelay() + spell.GetCastRecovery() + GetDelay(spell);
|
|
return DateTime.UtcNow + delay;
|
|
}
|
|
}
|
|
|
|
public override bool DoActionWander()
|
|
{
|
|
if (SmartAI && m_Mobile.Skills[SkillName.Meditation].Base > 0 && m_Mobile.Mana < m_Mobile.ManaMax &&
|
|
!m_Mobile.Meditating)
|
|
{
|
|
m_Mobile.DebugSay("I am going to meditate");
|
|
|
|
m_Mobile.UseSkill(SkillName.Meditation);
|
|
return true;
|
|
}
|
|
|
|
if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
|
|
{
|
|
m_Mobile.DebugSay("I am going to attack {0}", m_Mobile.FocusMob.Name);
|
|
|
|
m_Mobile.Combatant = m_Mobile.FocusMob;
|
|
Action = ActionType.Combat;
|
|
NextCastTime = DateTime.UtcNow;
|
|
}
|
|
else
|
|
{
|
|
m_Mobile.DebugSay("I am wandering");
|
|
|
|
m_Mobile.Warmode = false;
|
|
|
|
base.DoActionWander();
|
|
|
|
if (Utility.RandomDouble() < 0.05)
|
|
{
|
|
var spell = CheckCastHealingSpell();
|
|
|
|
if (spell != null)
|
|
spell.Cast();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool DoActionCombat()
|
|
{
|
|
var c = m_Mobile.Combatant;
|
|
m_Mobile.Warmode = true;
|
|
|
|
if (m_Mobile.Target != null)
|
|
ProcessTarget();
|
|
|
|
if (c == null || c.Deleted || !c.Alive || (c is Mobile && ((Mobile)c).IsDeadBondedPet) || !m_Mobile.CanSee(c) ||
|
|
!m_Mobile.CanBeHarmful(c, false) || c.Map != m_Mobile.Map)
|
|
{
|
|
// Our combatant is deleted, dead, hidden, or we cannot hurt them
|
|
// Try to find another combatant
|
|
if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
|
|
{
|
|
m_Mobile.DebugSay("Something happened to my combatant, so I am going to fight {0}", m_Mobile.FocusMob.Name);
|
|
|
|
m_Mobile.Combatant = c = m_Mobile.FocusMob;
|
|
m_Mobile.FocusMob = null;
|
|
}
|
|
else
|
|
{
|
|
m_Mobile.DebugSay("Something happened to my combatant, and nothing is around. I am on guard.");
|
|
Action = ActionType.Guard;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (!m_Mobile.InLOS(c))
|
|
{
|
|
m_Mobile.DebugSay("I can't see my target");
|
|
|
|
if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
|
|
{
|
|
m_Mobile.DebugSay("I will switch to {0}", m_Mobile.FocusMob.Name);
|
|
m_Mobile.Combatant = c = m_Mobile.FocusMob;
|
|
m_Mobile.FocusMob = null;
|
|
}
|
|
}
|
|
|
|
if (!Core.AOS && SmartAI && !m_Mobile.StunReady && m_Mobile.Skills[SkillName.Wrestling].Value >= 80.0 &&
|
|
m_Mobile.Skills[SkillName.Anatomy].Value >= 80.0)
|
|
EventSink.InvokeStunRequest(new StunRequestEventArgs(m_Mobile));
|
|
|
|
if (!m_Mobile.InRange(c, m_Mobile.RangePerception))
|
|
{
|
|
// They are somewhat far away, can we find something else?
|
|
if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
|
|
{
|
|
m_Mobile.Combatant = m_Mobile.FocusMob;
|
|
m_Mobile.FocusMob = null;
|
|
}
|
|
else if (!m_Mobile.InRange(c, m_Mobile.RangePerception * 3))
|
|
{
|
|
m_Mobile.Combatant = null;
|
|
}
|
|
|
|
c = m_Mobile.Combatant as Mobile;
|
|
|
|
if (c == null)
|
|
{
|
|
m_Mobile.DebugSay("My combatant has fled, so I am on guard");
|
|
Action = ActionType.Guard;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (!m_Mobile.Controlled && !m_Mobile.Summoned && m_Mobile.CanFlee)
|
|
{
|
|
if (m_Mobile.Hits < m_Mobile.HitsMax * 20 / 100)
|
|
{
|
|
// We are low on health, should we flee?
|
|
if (Utility.Random(100) <= Math.Max(10, 10 + c.Hits - m_Mobile.Hits))
|
|
{
|
|
m_Mobile.DebugSay("I am going to flee from {0}", c.Name);
|
|
Action = ActionType.Flee;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_Mobile.Spell == null && DateTime.UtcNow > NextCastTime && m_Mobile.InRange(c, Core.ML ? 10 : 12))
|
|
{
|
|
Spell spell = null;
|
|
|
|
if (m_Mobile.Poisoned)
|
|
{
|
|
spell = GetCureSpell();
|
|
}
|
|
|
|
if (SmartAI && spell == null && !m_Mobile.InRange(c.Location, 3) && UsesMagery && c is Mobile &&
|
|
!m_Mobile.DisallowAllMoves && CheckCanCastMagery(3) && m_Mobile.ControlOrder == OrderType.Attack &&
|
|
m_Mobile.InRange(c.Location, 10) && 0.6 > Utility.RandomDouble())
|
|
{
|
|
spell = new TeleportSpell(m_Mobile, null);
|
|
}
|
|
|
|
if (spell == null)
|
|
{
|
|
// We are ready to cast a spell
|
|
spell = ChooseSpell(c);
|
|
}
|
|
|
|
m_Mobile.DebugSay(spell != null ? "Choosen Spell" : "No spell chosen");
|
|
RunTo(c);
|
|
|
|
if (spell != null)
|
|
spell.Cast();
|
|
|
|
NextCastTime = GetCastDelay(spell);
|
|
}
|
|
else
|
|
{
|
|
RunTo(c);
|
|
}
|
|
|
|
LastTarget = c as Mobile;
|
|
LastTargetLoc = c.Location;
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool DoActionGuard()
|
|
{
|
|
if (LastTarget != null && LastTarget.Hidden)
|
|
{
|
|
var map = m_Mobile.Map;
|
|
|
|
if (map == null || !m_Mobile.InRange(LastTargetLoc, Core.ML ? 10 : 12))
|
|
{
|
|
LastTarget = null;
|
|
}
|
|
else if (m_Mobile.Spell == null && DateTime.UtcNow > NextCastTime)
|
|
{
|
|
// virutal method needs to go in BaseAI
|
|
TryReveal();
|
|
m_Mobile.DebugSay("I am going to reveal my last target");
|
|
}
|
|
}
|
|
|
|
if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
|
|
{
|
|
m_Mobile.DebugSay("I am going to attack {0}", m_Mobile.FocusMob.Name);
|
|
|
|
m_Mobile.Combatant = m_Mobile.FocusMob;
|
|
Action = ActionType.Combat;
|
|
}
|
|
else
|
|
{
|
|
ProcessTarget();
|
|
|
|
var spell = CheckCastHealingSpell();
|
|
|
|
if (spell != null)
|
|
spell.Cast();
|
|
|
|
base.DoActionGuard();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool DoActionFlee()
|
|
{
|
|
var c = m_Mobile.Combatant as Mobile;
|
|
|
|
if ((m_Mobile.Mana > 20 || m_Mobile.Mana == m_Mobile.ManaMax) && m_Mobile.Hits > (m_Mobile.HitsMax / 2))
|
|
{
|
|
// If I have a target, go back and fight them
|
|
if (c != null && m_Mobile.GetDistanceToSqrt(c) <= m_Mobile.RangePerception * 2)
|
|
{
|
|
m_Mobile.DebugSay("I am stronger now, reengaging {0}", c.Name);
|
|
Action = ActionType.Combat;
|
|
}
|
|
else
|
|
{
|
|
m_Mobile.DebugSay("I am stronger now, my guard is up");
|
|
Action = ActionType.Guard;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
base.DoActionFlee();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual void RunTo(IDamageable d)
|
|
{
|
|
if (!SmartAI)
|
|
{
|
|
if (!MoveTo(d, true, m_Mobile.RangeFight))
|
|
OnFailedMove();
|
|
|
|
return;
|
|
}
|
|
|
|
if (d is Mobile && (((Mobile)d).Paralyzed || ((Mobile)d).Frozen))
|
|
{
|
|
if (m_Mobile.InRange(d, 1))
|
|
RunFrom(d);
|
|
else if (!m_Mobile.InRange(d, m_Mobile.RangeFight > 2 ? m_Mobile.RangeFight : 2) && !MoveTo(d, true, 1))
|
|
OnFailedMove();
|
|
}
|
|
else
|
|
{
|
|
if (!m_Mobile.InRange(d, m_Mobile.RangeFight))
|
|
{
|
|
if (!MoveTo(d, true, 1))
|
|
OnFailedMove();
|
|
}
|
|
else if (m_Mobile.InRange(d, m_Mobile.RangeFight - 1))
|
|
{
|
|
RunFrom(d);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RunFrom(IDamageable d)
|
|
{
|
|
Run((Direction)((int)m_Mobile.GetDirectionTo(d) - 4) & Direction.Mask);
|
|
}
|
|
|
|
public virtual void OnFailedMove()
|
|
{
|
|
if (UsesMagery && !m_Mobile.DisallowAllMoves &&
|
|
(SmartAI ? Utility.Random(10) == 0 : ScaleByCastSkill(TeleportChance) > Utility.RandomDouble()))
|
|
{
|
|
if (m_Mobile.Target != null)
|
|
m_Mobile.Target.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
|
|
new TeleportSpell(m_Mobile, null).Cast();
|
|
|
|
m_Mobile.DebugSay("I am stuck, I'm going to try teleporting away");
|
|
}
|
|
else if (AcquireFocusMob(m_Mobile.RangePerception, m_Mobile.FightMode, false, false, true))
|
|
{
|
|
m_Mobile.DebugSay("My move is blocked, so I am going to attack {0}", m_Mobile.FocusMob.Name);
|
|
|
|
m_Mobile.Combatant = m_Mobile.FocusMob;
|
|
Action = ActionType.Combat;
|
|
}
|
|
else
|
|
{
|
|
m_Mobile.DebugSay("I am stuck");
|
|
}
|
|
}
|
|
|
|
public void Run(Direction d)
|
|
{
|
|
if ((m_Mobile.Spell != null && m_Mobile.Spell.IsCasting) || m_Mobile.Paralyzed || m_Mobile.Frozen ||
|
|
m_Mobile.DisallowAllMoves)
|
|
return;
|
|
|
|
m_Mobile.Direction = d | Direction.Running;
|
|
|
|
if (!DoMove(m_Mobile.Direction, true))
|
|
OnFailedMove();
|
|
}
|
|
|
|
public virtual Spell ChooseSpell(IDamageable c)
|
|
{
|
|
if (c == null || !c.Alive)
|
|
return null;
|
|
|
|
Spell spell = null;
|
|
|
|
if (!UsesMagery)
|
|
{
|
|
if (!(c is Mobile))
|
|
{
|
|
m_Mobile.DebugSay("Just doing damage...");
|
|
spell = GetRandomDamageSpell();
|
|
}
|
|
else
|
|
{
|
|
m_Mobile.DebugSay("Random combat spell...");
|
|
spell = RandomCombatSpell();
|
|
}
|
|
|
|
return spell;
|
|
}
|
|
|
|
if (m_Mobile.Poisoned) // Top cast priority is cure
|
|
{
|
|
m_Mobile.DebugSay("I am going to cure myself");
|
|
|
|
spell = GetCureSpell();
|
|
}
|
|
|
|
if (spell != null)
|
|
return spell;
|
|
|
|
var toDispel = FindDispelTarget(true);
|
|
|
|
if (toDispel != null) // Something dispellable is attacking us
|
|
{
|
|
m_Mobile.DebugSay("I am going to dispel {0}", toDispel);
|
|
|
|
spell = DoDispel(toDispel);
|
|
}
|
|
|
|
if (spell != null)
|
|
return spell;
|
|
|
|
if (c is Mobile && SmartAI && m_Combo != -1) // We are doing a spell combo
|
|
{
|
|
spell = DoCombo((Mobile)c);
|
|
}
|
|
else if (c is Mobile && SmartAI && (((Mobile)c).Spell is HealSpell || ((Mobile)c).Spell is GreaterHealSpell) &&
|
|
!((Mobile)c).Poisoned) // They have a heal spell out
|
|
{
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
}
|
|
else
|
|
{
|
|
spell = RandomCombatSpell();
|
|
}
|
|
|
|
return spell;
|
|
}
|
|
|
|
protected virtual Spell CheckCastHealingSpell()
|
|
{
|
|
// Summoned creatures never heal themselves.
|
|
if (m_Mobile.Summoned)
|
|
return null;
|
|
|
|
Spell spell = null;
|
|
|
|
// If I'm poisoned, always attempt to cure.
|
|
if (m_Mobile.Poisoned)
|
|
{
|
|
spell = GetCureSpell();
|
|
}
|
|
|
|
if (spell != null)
|
|
return spell;
|
|
|
|
if (m_Mobile.Controlled && DateTime.UtcNow < NextHealTime)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (m_Mobile.Hits == m_Mobile.HitsMax || (!SmartAI && ScaleByCastSkill(HealChance) < Utility.RandomDouble()))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (Utility.Random(0, 4 + (m_Mobile.Hits == 0 ? m_Mobile.HitsMax : (m_Mobile.HitsMax / m_Mobile.Hits))) < 3)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
spell = GetHealSpell();
|
|
|
|
double delay;
|
|
|
|
if (m_Mobile.Int >= 500)
|
|
delay = Utility.RandomMinMax(7, 10);
|
|
else
|
|
delay = Math.Sqrt(600 - m_Mobile.Int);
|
|
|
|
NextHealTime = DateTime.UtcNow + TimeSpan.FromSeconds(delay);
|
|
|
|
return spell;
|
|
}
|
|
|
|
public virtual Spell DoDispel(Mobile toDispel)
|
|
{
|
|
if (!SmartAI)
|
|
{
|
|
if (CheckCanCastMagery(6) && ScaleByCastSkill(DispelChance) > Utility.RandomDouble())
|
|
return new DispelSpell(m_Mobile, null);
|
|
|
|
return null;
|
|
}
|
|
|
|
var spell = CheckCastHealingSpell();
|
|
|
|
if (spell == null && CheckCanCastMagery(6))
|
|
{
|
|
spell = new DispelSpell(m_Mobile, null);
|
|
}
|
|
|
|
return spell;
|
|
}
|
|
|
|
public Mobile FindDispelTarget(bool activeOnly)
|
|
{
|
|
if (m_Mobile.Deleted || m_Mobile.Int < 95 || CanDispel(m_Mobile) || m_Mobile.AutoDispel)
|
|
return null;
|
|
|
|
if (activeOnly)
|
|
{
|
|
var aggressed = m_Mobile.Aggressed;
|
|
var aggressors = m_Mobile.Aggressors;
|
|
|
|
Mobile active = null;
|
|
var activePrio = 0.0;
|
|
|
|
var comb = m_Mobile.Combatant as Mobile;
|
|
|
|
if (comb != null && !comb.Deleted && comb.Alive && !comb.IsDeadBondedPet &&
|
|
m_Mobile.InRange(comb, Core.ML ? 10 : 12) && CanDispel(comb))
|
|
{
|
|
active = comb;
|
|
activePrio = m_Mobile.GetDistanceToSqrt(comb);
|
|
|
|
if (activePrio <= 2)
|
|
return active;
|
|
}
|
|
|
|
for (var i = 0; i < aggressed.Count; ++i)
|
|
{
|
|
var info = aggressed[i];
|
|
var m = info.Defender;
|
|
|
|
if (m != comb && m.Combatant == m_Mobile && m_Mobile.InRange(m, Core.ML ? 10 : 12) && CanDispel(m))
|
|
{
|
|
var prio = m_Mobile.GetDistanceToSqrt(m);
|
|
|
|
if (active == null || prio < activePrio)
|
|
{
|
|
active = m;
|
|
activePrio = prio;
|
|
|
|
if (activePrio <= 2)
|
|
return active;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var i = 0; i < aggressors.Count; ++i)
|
|
{
|
|
var info = aggressors[i];
|
|
var m = info.Attacker;
|
|
|
|
if (m != comb && m.Combatant == m_Mobile && m_Mobile.InRange(m, Core.ML ? 10 : 12) && CanDispel(m))
|
|
{
|
|
var prio = m_Mobile.GetDistanceToSqrt(m);
|
|
|
|
if (active == null || prio < activePrio)
|
|
{
|
|
active = m;
|
|
activePrio = prio;
|
|
|
|
if (activePrio <= 2)
|
|
return active;
|
|
}
|
|
}
|
|
}
|
|
|
|
return active;
|
|
}
|
|
var map = m_Mobile.Map;
|
|
|
|
if (map != null)
|
|
{
|
|
Mobile active = null, inactive = null;
|
|
double actPrio = 0.0, inactPrio = 0.0;
|
|
|
|
var comb = m_Mobile.Combatant as Mobile;
|
|
|
|
if (comb != null && !comb.Deleted && comb.Alive && !comb.IsDeadBondedPet && CanDispel(comb))
|
|
{
|
|
active = inactive = comb;
|
|
actPrio = inactPrio = m_Mobile.GetDistanceToSqrt(comb);
|
|
}
|
|
|
|
IPooledEnumerable eable = m_Mobile.GetMobilesInRange(Core.ML ? 10 : 12);
|
|
|
|
foreach (Mobile m in eable)
|
|
{
|
|
if (m != m_Mobile && CanDispel(m))
|
|
{
|
|
var prio = m_Mobile.GetDistanceToSqrt(m);
|
|
|
|
if (!activeOnly && (inactive == null || prio < inactPrio))
|
|
{
|
|
inactive = m;
|
|
inactPrio = prio;
|
|
}
|
|
|
|
if ((m_Mobile.Combatant == m || m.Combatant == m_Mobile) && (active == null || prio < actPrio))
|
|
{
|
|
active = m;
|
|
actPrio = prio;
|
|
}
|
|
}
|
|
}
|
|
|
|
eable.Free();
|
|
|
|
return active != null ? active : inactive;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public bool CanDispel(Mobile m)
|
|
{
|
|
return (m is BaseCreature && ((BaseCreature)m).Summoned && m_Mobile.CanBeHarmful(m, false) &&
|
|
!((BaseCreature)m).IsAnimatedDead);
|
|
}
|
|
|
|
public Spell CheckCastDispelField()
|
|
{
|
|
if (m_Mobile.Frozen || m_Mobile.Paralyzed)
|
|
return null;
|
|
|
|
var mana = m_Mobile.Mana;
|
|
|
|
if (mana < 14)
|
|
return null;
|
|
|
|
var field = GetHarmfulFieldItem();
|
|
|
|
if (field != null)
|
|
{
|
|
m_Mobile.DebugSay("Found harmful field, attempting to dispel");
|
|
return new DispelFieldSpell(m_Mobile, null);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public Item GetHarmfulFieldItem()
|
|
{
|
|
if (m_Mobile.Map == null)
|
|
return null;
|
|
|
|
IPooledEnumerable eable = m_Mobile.Map.GetItemsInRange(m_Mobile.Location, 0);
|
|
|
|
foreach (Item item in eable)
|
|
{
|
|
if (item is PoisonFieldSpell.InternalItem)
|
|
{
|
|
var field = (PoisonFieldSpell.InternalItem)item;
|
|
|
|
if (field.Visible && field.Caster != null && (!Core.AOS || m_Mobile != field.Caster) &&
|
|
SpellHelper.ValidIndirectTarget(field.Caster, m_Mobile) && field.Caster.CanBeHarmful(m_Mobile, false))
|
|
{
|
|
eable.Free();
|
|
return item;
|
|
}
|
|
}
|
|
else if (item is ParalyzeFieldSpell.InternalItem)
|
|
{
|
|
var field = (ParalyzeFieldSpell.InternalItem)item;
|
|
|
|
if (field.Visible && field.Caster != null && (!Core.AOS || m_Mobile != field.Caster) &&
|
|
SpellHelper.ValidIndirectTarget(field.Caster, m_Mobile) && field.Caster.CanBeHarmful(m_Mobile, false))
|
|
{
|
|
eable.Free();
|
|
return item;
|
|
}
|
|
}
|
|
else if (item is FireFieldSpell.FireFieldItem)
|
|
{
|
|
var field = (FireFieldSpell.FireFieldItem)item;
|
|
|
|
if (field.Visible && field.Caster != null && (!Core.AOS || m_Mobile != field.Caster) &&
|
|
SpellHelper.ValidIndirectTarget(field.Caster, m_Mobile) && field.Caster.CanBeHarmful(m_Mobile, false))
|
|
{
|
|
eable.Free();
|
|
return item;
|
|
}
|
|
}
|
|
}
|
|
|
|
eable.Free();
|
|
return null;
|
|
}
|
|
|
|
public virtual Spell RandomCombatSpell()
|
|
{
|
|
Spell spell = null;
|
|
|
|
if (!UsesMagery)
|
|
{
|
|
spell = CheckCastHealingSpell();
|
|
|
|
if (spell != null)
|
|
return spell;
|
|
|
|
switch (Utility.Random(6))
|
|
{
|
|
case 0: // Buff
|
|
{
|
|
m_Mobile.DebugSay("Cursing Thyself!");
|
|
spell = GetRandomBuffSpell();
|
|
break;
|
|
}
|
|
case 1: // Curse
|
|
{
|
|
m_Mobile.DebugSay("Cursing Thou!");
|
|
spell = GetRandomCurseSpell();
|
|
break;
|
|
}
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5: // damage
|
|
{
|
|
m_Mobile.DebugSay("Just doing damage");
|
|
spell = GetRandomDamageSpell();
|
|
}
|
|
break;
|
|
}
|
|
|
|
return spell;
|
|
}
|
|
|
|
var c = m_Mobile.Combatant as Mobile;
|
|
|
|
if (c == null || !c.Alive)
|
|
return null;
|
|
|
|
if (!SmartAI)
|
|
{
|
|
spell = CheckCastHealingSpell();
|
|
|
|
if (spell != null)
|
|
return spell;
|
|
|
|
if (spell == null && m_Mobile.RawInt >= 80)
|
|
spell = CheckCastDispelField();
|
|
|
|
switch (Utility.Random(15))
|
|
{
|
|
case 0:
|
|
case 1: // Poison them
|
|
{
|
|
if (c.Poisoned || !CheckCanCastMagery(3))
|
|
goto default;
|
|
|
|
m_Mobile.DebugSay("Attempting to poison");
|
|
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
break;
|
|
}
|
|
case 2: // Bless ourselves
|
|
{
|
|
if (!CheckCanCastMagery(3))
|
|
goto default;
|
|
|
|
m_Mobile.DebugSay("Blessing myself");
|
|
|
|
spell = GetRandomBuffSpell(); //new BlessSpell(m_Mobile, null);
|
|
break;
|
|
}
|
|
case 3:
|
|
case 4: // Curse them
|
|
{
|
|
m_Mobile.DebugSay("Attempting to curse");
|
|
|
|
spell = GetRandomCurseSpell();
|
|
|
|
if (spell == null)
|
|
goto default;
|
|
break;
|
|
}
|
|
case 5: // Paralyze them
|
|
{
|
|
m_Mobile.DebugSay("Attempting to paralyze");
|
|
|
|
if (CheckCanCastMagery(5))
|
|
spell = new ParalyzeSpell(m_Mobile, null);
|
|
else
|
|
spell = GetRandomCurseSpell();
|
|
|
|
if (spell == null)
|
|
goto default;
|
|
break;
|
|
}
|
|
case 6: // Drain mana
|
|
{
|
|
m_Mobile.DebugSay("Attempting to drain mana");
|
|
|
|
spell = GetRandomManaDrainSpell();
|
|
|
|
if (spell == null)
|
|
goto default;
|
|
break;
|
|
}
|
|
default: // Damage them
|
|
{
|
|
m_Mobile.DebugSay("Just doing damage");
|
|
|
|
spell = GetRandomDamageSpell();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_Mobile.Hidden)
|
|
return null;
|
|
|
|
spell = CheckCastDispelField();
|
|
|
|
if (spell == null)
|
|
spell = CheckCastHealingSpell();
|
|
|
|
if (spell == null && 0.05 >= Utility.RandomDouble())
|
|
spell = GetRandomBuffSpell();
|
|
|
|
else if (spell == null && m_Mobile.Followers + 1 < m_Mobile.FollowersMax && 0.05 >= Utility.RandomDouble())
|
|
spell = GetRandomSummonSpell();
|
|
|
|
else if (spell == null && 0.05 >= Utility.RandomDouble())
|
|
spell = GetRandomFieldSpell();
|
|
|
|
else if (spell == null && 0.05 >= Utility.RandomDouble())
|
|
spell = GetRandomManaDrainSpell();
|
|
|
|
if (spell != null)
|
|
return spell;
|
|
|
|
switch (Utility.Random(3))
|
|
{
|
|
case 0: // Poison them
|
|
{
|
|
if (c.Poisoned)
|
|
goto case 1;
|
|
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
break;
|
|
}
|
|
case 1: // Deal some damage
|
|
{
|
|
spell = GetRandomDamageSpell();
|
|
|
|
break;
|
|
}
|
|
default: // Set up a combo
|
|
{
|
|
if (m_Mobile.Mana > 15 && m_Mobile.Mana < 40)
|
|
{
|
|
if (c.Paralyzed && !c.Poisoned && !m_Mobile.Meditating)
|
|
{
|
|
m_Mobile.DebugSay("I am going to meditate");
|
|
|
|
m_Mobile.UseSkill(SkillName.Meditation);
|
|
}
|
|
else if (!c.Poisoned)
|
|
{
|
|
spell = new ParalyzeSpell(m_Mobile, null);
|
|
}
|
|
}
|
|
else if (m_Mobile.Mana > 60)
|
|
{
|
|
if (Utility.RandomBool() && !c.Paralyzed && !c.Frozen && !c.Poisoned)
|
|
{
|
|
m_Combo = 0;
|
|
spell = new ParalyzeSpell(m_Mobile, null);
|
|
}
|
|
else
|
|
{
|
|
m_Combo = 1;
|
|
spell = new ExplosionSpell(m_Mobile, null);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return spell;
|
|
}
|
|
|
|
//TODO: This needs to be tested on EA
|
|
/// <summary>
|
|
/// Obsolete. Creatures don't fizzle based on spell, but cast spells depending on mana pool
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public virtual int GetMaxCircle()
|
|
{
|
|
return (int)((m_Mobile.Skills[SkillName.Magery].Value + 20.0) / (100.0 / 7.0));
|
|
}
|
|
|
|
private readonly int[] m_ManaTable = {4, 6, 9, 11, 14, 20, 40, 50};
|
|
|
|
public virtual bool CheckCanCastMagery(int circle)
|
|
{
|
|
if (circle < 1)
|
|
circle = 1;
|
|
if (circle > 8)
|
|
circle = 8;
|
|
|
|
var skill = (100.0 / 7.0) * circle;
|
|
|
|
return m_Mobile.Mana >= m_ManaTable[circle - 1] &&
|
|
(Core.SA || m_Mobile.Skills[SkillName.Magery].Value >= skill - 20);
|
|
}
|
|
|
|
public virtual Spell GetRandomDamageSpell()
|
|
{
|
|
int select;
|
|
|
|
if (SmartAI)
|
|
{
|
|
if (m_Mobile.Mana > 100)
|
|
{
|
|
if (!SkillMasterySpell.HasSpell(m_Mobile, typeof(DeathRaySpell)))
|
|
select = Utility.RandomMinMax(0, 4);
|
|
else
|
|
select = Utility.RandomMinMax(1, 4);
|
|
}
|
|
else if (CheckCanCastMagery(7))
|
|
{
|
|
select = Utility.Random(5, 11);
|
|
}
|
|
else
|
|
{
|
|
select = Utility.Random(5, 8);
|
|
}
|
|
|
|
switch (select)
|
|
{
|
|
case 0:
|
|
return new DeathRaySpell(m_Mobile, null);
|
|
case 1:
|
|
return new MindBlastSpell(m_Mobile, null);
|
|
case 2:
|
|
return new EnergyBoltSpell(m_Mobile, null);
|
|
case 3:
|
|
return new ExplosionSpell(m_Mobile, null);
|
|
case 4:
|
|
return new FlameStrikeSpell(m_Mobile, null);
|
|
case 5:
|
|
return new MagicArrowSpell(m_Mobile, null);
|
|
case 6:
|
|
return new HarmSpell(m_Mobile, null);
|
|
case 7:
|
|
return new FireballSpell(m_Mobile, null);
|
|
case 8:
|
|
return new LightningSpell(m_Mobile, null);
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
return new ManaVampireSpell(m_Mobile, null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (CheckCanCastMagery(8))
|
|
select = 8;
|
|
else if (CheckCanCastMagery(6))
|
|
select = 6;
|
|
else if (CheckCanCastMagery(5))
|
|
select = 5;
|
|
else if (CheckCanCastMagery(4))
|
|
select = 4;
|
|
else if (CheckCanCastMagery(3))
|
|
select = 3;
|
|
else if (CheckCanCastMagery(2))
|
|
select = 2;
|
|
else
|
|
select = 1;
|
|
|
|
switch (Utility.Random(select))
|
|
{
|
|
default:
|
|
case 0:
|
|
return new MagicArrowSpell(m_Mobile, null);
|
|
case 1:
|
|
return new HarmSpell(m_Mobile, null);
|
|
case 2:
|
|
return new FireballSpell(m_Mobile, null);
|
|
case 3:
|
|
return new LightningSpell(m_Mobile, null);
|
|
case 4:
|
|
return new MindBlastSpell(m_Mobile, null);
|
|
case 5:
|
|
return new EnergyBoltSpell(m_Mobile, null);
|
|
case 6:
|
|
return new ExplosionSpell(m_Mobile, null);
|
|
case 7:
|
|
return new FlameStrikeSpell(m_Mobile, null);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public virtual Spell GetRandomCurseSpell()
|
|
{
|
|
if (Utility.RandomBool() && CheckCanCastMagery(5))
|
|
return new CurseSpell(m_Mobile, null);
|
|
|
|
switch (Utility.Random(3))
|
|
{
|
|
default:
|
|
case 0:
|
|
return new WeakenSpell(m_Mobile, null);
|
|
case 1:
|
|
return new ClumsySpell(m_Mobile, null);
|
|
case 2:
|
|
return new FeeblemindSpell(m_Mobile, null);
|
|
}
|
|
}
|
|
|
|
public virtual Spell GetRandomManaDrainSpell()
|
|
{
|
|
if (Utility.RandomBool() && CheckCanCastMagery(7))
|
|
return new ManaVampireSpell(m_Mobile, null);
|
|
|
|
if ((CheckCanCastMagery(4)))
|
|
return new ManaDrainSpell(m_Mobile, null);
|
|
|
|
return null;
|
|
}
|
|
|
|
public virtual Spell GetRandomSummonSpell()
|
|
{
|
|
// TODO: I left this here if anyone wants summons from magery
|
|
/*if (CheckCanCastMagery(8))
|
|
return new EnergyVortexSpell(m_Mobile, null);
|
|
|
|
if (CheckCanCastMagery(5))
|
|
return new BladeSpiritsSpell(m_Mobile, null);*/
|
|
|
|
return null;
|
|
}
|
|
|
|
public virtual Spell GetRandomFieldSpell()
|
|
{
|
|
// I left this here if someone wants field spells
|
|
/*bool pois = m_Mobile.Skills[SkillName.Poisoning].Value >= 80.0 || m_Mobile.HitPoison == Poison.Greater || m_Mobile.HitPoison == Poison.Lethal;
|
|
|
|
if (pois && CheckCanCastMagery(5))
|
|
return new PoisonFieldSpell(m_Mobile, null);
|
|
|
|
if (Utility.RandomBool() && CheckCanCastMagery(6))
|
|
return new ParalyzeFieldSpell(m_Mobile, null);
|
|
|
|
if (CheckCanCastMagery(4))
|
|
return new FireFieldSpell(m_Mobile, null);*/
|
|
|
|
return null;
|
|
}
|
|
|
|
public virtual Spell GetRandomBuffSpell()
|
|
{
|
|
if (!BlessSpell.IsBlessed(m_Mobile) && CheckCanCastMagery(3))
|
|
return new BlessSpell(m_Mobile, null);
|
|
|
|
if (!m_Mobile.Controlled && CheckCanCastMagery(6))
|
|
return new InvisibilitySpell(m_Mobile, null);
|
|
|
|
return null;
|
|
}
|
|
|
|
public virtual Spell GetHealSpell()
|
|
{
|
|
Spell spell = null;
|
|
|
|
if (m_Mobile.Hits < (m_Mobile.HitsMax - 50))
|
|
{
|
|
if (CheckCanCastMagery(4))
|
|
{
|
|
spell = new GreaterHealSpell(m_Mobile, null);
|
|
}
|
|
else
|
|
{
|
|
spell = new HealSpell(m_Mobile, null);
|
|
}
|
|
}
|
|
else if (m_Mobile.Hits < (m_Mobile.HitsMax - 10))
|
|
{
|
|
spell = new HealSpell(m_Mobile, null);
|
|
}
|
|
|
|
return spell;
|
|
}
|
|
|
|
public virtual Spell GetCureSpell()
|
|
{
|
|
if (SmartAI && m_Mobile.Poison.Level > 1 && CheckCanCastMagery(4))
|
|
{
|
|
return new ArchCureSpell(m_Mobile, null);
|
|
}
|
|
|
|
if (CheckCanCastMagery(2))
|
|
{
|
|
return new CureSpell(m_Mobile, null);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected int m_Combo = -1;
|
|
protected ComboType m_ComboType;
|
|
|
|
protected enum ComboType
|
|
{
|
|
None,
|
|
Exp_FS_Poison,
|
|
Exp_MB_Poison,
|
|
Exp_EB_Poison,
|
|
Exp_FB_MA_Poison,
|
|
Exp_FB_Poison_Light,
|
|
Exp_FB_MA_Light,
|
|
Exp_Poison_FB_Light
|
|
}
|
|
|
|
public virtual Spell DoCombo(Mobile c)
|
|
{
|
|
Spell spell = null;
|
|
|
|
if (m_ComboType == ComboType.None)
|
|
m_ComboType = (ComboType)Utility.RandomMinMax(1, 7);
|
|
|
|
if (m_Combo == 1)
|
|
{
|
|
switch (m_ComboType)
|
|
{
|
|
case ComboType.Exp_FS_Poison:
|
|
case ComboType.Exp_MB_Poison:
|
|
case ComboType.Exp_EB_Poison:
|
|
case ComboType.Exp_FB_MA_Poison:
|
|
case ComboType.Exp_FB_Poison_Light:
|
|
case ComboType.Exp_FB_MA_Light:
|
|
case ComboType.Exp_Poison_FB_Light:
|
|
spell = new ExplosionSpell(m_Mobile, null);
|
|
break;
|
|
}
|
|
}
|
|
else if (m_Combo == 2)
|
|
{
|
|
switch (m_ComboType)
|
|
{
|
|
case ComboType.Exp_FS_Poison:
|
|
spell = new FlameStrikeSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_MB_Poison:
|
|
spell = new MindBlastSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_EB_Poison:
|
|
spell = new EnergyBoltSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_FB_MA_Poison:
|
|
spell = new FireballSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_FB_Poison_Light:
|
|
spell = new FireballSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_FB_MA_Light:
|
|
spell = new FireballSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_Poison_FB_Light:
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
break;
|
|
}
|
|
}
|
|
else if (m_Combo == 3)
|
|
{
|
|
switch (m_ComboType)
|
|
{
|
|
case ComboType.Exp_FS_Poison:
|
|
case ComboType.Exp_MB_Poison:
|
|
case ComboType.Exp_EB_Poison:
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
EndCombo();
|
|
return spell;
|
|
case ComboType.Exp_FB_MA_Poison:
|
|
spell = new MagicArrowSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_FB_Poison_Light:
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_FB_MA_Light:
|
|
spell = new MagicArrowSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_Poison_FB_Light:
|
|
spell = new FireballSpell(m_Mobile, null);
|
|
break;
|
|
}
|
|
}
|
|
else if (m_Combo == 4)
|
|
{
|
|
switch (m_ComboType)
|
|
{
|
|
case ComboType.Exp_FS_Poison:
|
|
case ComboType.Exp_MB_Poison:
|
|
case ComboType.Exp_EB_Poison:
|
|
spell = new LightningSpell(m_Mobile, null);
|
|
EndCombo();
|
|
return spell;
|
|
case ComboType.Exp_FB_MA_Poison:
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
break;
|
|
case ComboType.Exp_FB_Poison_Light:
|
|
case ComboType.Exp_FB_MA_Light:
|
|
case ComboType.Exp_Poison_FB_Light:
|
|
spell = new LightningSpell(m_Mobile, null);
|
|
EndCombo();
|
|
return spell;
|
|
}
|
|
}
|
|
else if (m_Combo == 5)
|
|
{
|
|
switch (m_ComboType)
|
|
{
|
|
case ComboType.Exp_FS_Poison:
|
|
case ComboType.Exp_MB_Poison:
|
|
case ComboType.Exp_EB_Poison:
|
|
case ComboType.Exp_FB_MA_Poison:
|
|
case ComboType.Exp_FB_Poison_Light:
|
|
case ComboType.Exp_FB_MA_Light:
|
|
case ComboType.Exp_Poison_FB_Light:
|
|
spell = new LightningSpell(m_Mobile, null);
|
|
EndCombo();
|
|
return spell;
|
|
}
|
|
}
|
|
|
|
m_Combo++; // Move to next spell
|
|
|
|
if (spell == null)
|
|
spell = new PoisonSpell(m_Mobile, null);
|
|
|
|
return spell;
|
|
}
|
|
|
|
public virtual void EndCombo()
|
|
{
|
|
m_ComboType = ComboType.None;
|
|
m_Combo = -1;
|
|
}
|
|
|
|
protected virtual bool ProcessTarget()
|
|
{
|
|
var targ = m_Mobile.Target;
|
|
|
|
if (targ == null)
|
|
return false;
|
|
|
|
var harmful = (targ.Flags & TargetFlags.Harmful) != 0 || targ is HailStormSpell.InternalTarget ||
|
|
targ is WildfireSpell.InternalTarget;
|
|
var beneficial = (targ.Flags & TargetFlags.Beneficial) != 0 || targ is ArchCureSpell.InternalTarget;
|
|
|
|
if (UsesMagery)
|
|
{
|
|
var isDispel = (targ is DispelSpell.InternalTarget || targ is MassDispelSpell.InternalTarget);
|
|
var isParalyze = (targ is ParalyzeSpell.InternalTarget);
|
|
var isTeleport = (targ is TeleportSpell.InternalTarget);
|
|
var isSummon = (targ is EnergyVortexSpell.InternalTarget || targ is BladeSpiritsSpell.InternalTarget ||
|
|
targ is NatureFurySpell.InternalTarget);
|
|
var isField = (targ is FireFieldSpell.InternalTarget || targ is PoisonFieldSpell.InternalTarget ||
|
|
targ is ParalyzeFieldSpell.InternalTarget);
|
|
var isAnimate = (targ is AnimateDeadSpell.InternalTarget);
|
|
var isDispelField = (targ is DispelFieldSpell.InternalTarget);
|
|
var teleportAway = false;
|
|
|
|
if (isTeleport && m_Mobile.CanSwim)
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
|
|
IDamageable toTarget = null;
|
|
|
|
if (isDispel)
|
|
{
|
|
toTarget = FindDispelTarget(false);
|
|
|
|
if (toTarget != null)
|
|
RunTo(toTarget);
|
|
}
|
|
else if (isDispelField)
|
|
{
|
|
var field = GetHarmfulFieldItem();
|
|
|
|
if (field != null)
|
|
targ.Invoke(m_Mobile, field);
|
|
else
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
}
|
|
else if (isAnimate)
|
|
{
|
|
var corpse = FindCorpseToAnimate();
|
|
|
|
if (corpse != null)
|
|
targ.Invoke(m_Mobile, corpse);
|
|
}
|
|
else
|
|
{
|
|
toTarget = m_Mobile.Combatant;
|
|
|
|
if (toTarget != null)
|
|
RunTo(toTarget);
|
|
}
|
|
|
|
if (isSummon && toTarget != null)
|
|
{
|
|
var failSafe = 0;
|
|
var map = toTarget.Map;
|
|
|
|
while (failSafe <= 25)
|
|
{
|
|
var x = Utility.RandomMinMax(toTarget.X - 2, toTarget.X + 2);
|
|
var y = Utility.RandomMinMax(toTarget.Y - 2, toTarget.Y + 2);
|
|
var z = toTarget.Z;
|
|
|
|
var lt = new LandTarget(new Point3D(x, y, z), map);
|
|
|
|
if (map.CanSpawnMobile(x, y, z))
|
|
{
|
|
targ.Invoke(m_Mobile, lt);
|
|
break;
|
|
}
|
|
|
|
failSafe++;
|
|
}
|
|
}
|
|
else if (isField && toTarget != null)
|
|
{
|
|
var map = toTarget.Map;
|
|
|
|
var x = m_Mobile.X;
|
|
var y = m_Mobile.Y;
|
|
var z = m_Mobile.Z;
|
|
|
|
if (toTarget == null || m_Mobile.InRange(toTarget.Location, 3))
|
|
{
|
|
targ.Invoke(m_Mobile, toTarget);
|
|
return true;
|
|
}
|
|
|
|
var d = Utility.GetDirection(m_Mobile, toTarget);
|
|
var dist = (int)m_Mobile.GetDistanceToSqrt(toTarget.Location) / 2;
|
|
var p = m_Mobile.Location;
|
|
|
|
switch ((int)d)
|
|
{
|
|
case (int)Direction.Running:
|
|
case (int)Direction.North:
|
|
y = p.Y - dist;
|
|
break;
|
|
case 129:
|
|
case (int)Direction.Right:
|
|
x = p.X + dist;
|
|
y = p.Y - dist;
|
|
break;
|
|
case 130:
|
|
case (int)Direction.East:
|
|
x = p.X + dist;
|
|
break;
|
|
case 131:
|
|
case (int)Direction.Down:
|
|
x = p.X + dist;
|
|
y = p.Y + dist;
|
|
break;
|
|
case 132:
|
|
case (int)Direction.South:
|
|
y = p.Y + dist;
|
|
break;
|
|
case 133:
|
|
case (int)Direction.Left:
|
|
x = p.X - dist;
|
|
y = p.Y + dist;
|
|
break;
|
|
case 134:
|
|
case (int)Direction.West:
|
|
x = p.X - dist;
|
|
break;
|
|
case (int)Direction.ValueMask:
|
|
case (int)Direction.Up:
|
|
x = p.X - dist;
|
|
y = p.Y - dist;
|
|
break;
|
|
}
|
|
|
|
var lt = new LandTarget(new Point3D(x, y, z), map);
|
|
targ.Invoke(m_Mobile, lt);
|
|
}
|
|
|
|
if (harmful && toTarget != null)
|
|
{
|
|
if ((targ.Range == -1 || m_Mobile.InRange(toTarget, targ.Range)) && m_Mobile.CanSee(toTarget) &&
|
|
m_Mobile.InLOS(toTarget))
|
|
{
|
|
targ.Invoke(m_Mobile, toTarget);
|
|
}
|
|
else if (isDispel)
|
|
{
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
}
|
|
}
|
|
else if (beneficial)
|
|
{
|
|
targ.Invoke(m_Mobile, m_Mobile);
|
|
}
|
|
else if (isTeleport && toTarget != null)
|
|
{
|
|
var map = m_Mobile.Map;
|
|
|
|
if (map == null)
|
|
{
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
return true;
|
|
}
|
|
|
|
int px, py;
|
|
|
|
if (teleportAway)
|
|
{
|
|
var rx = m_Mobile.X - toTarget.X;
|
|
var ry = m_Mobile.Y - toTarget.Y;
|
|
|
|
var d = m_Mobile.GetDistanceToSqrt(toTarget);
|
|
|
|
px = toTarget.X + (int)(rx * (10 / d));
|
|
py = toTarget.Y + (int)(ry * (10 / d));
|
|
}
|
|
else
|
|
{
|
|
px = toTarget.X;
|
|
py = toTarget.Y;
|
|
}
|
|
|
|
for (var i = 0; i < m_Offsets.Length; i += 2)
|
|
{
|
|
int x = m_Offsets[i], y = m_Offsets[i + 1];
|
|
|
|
var p = new Point3D(px + x, py + y, 0);
|
|
|
|
var lt = new LandTarget(p, map);
|
|
|
|
if ((targ.Range == -1 || m_Mobile.InRange(p, targ.Range)) && m_Mobile.InLOS(lt) &&
|
|
map.CanSpawnMobile(px + x, py + y, lt.Z) && !SpellHelper.CheckMulti(p, map))
|
|
{
|
|
targ.Invoke(m_Mobile, lt);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
var teleRange = targ.Range;
|
|
|
|
if (teleRange < 0)
|
|
teleRange = Core.ML ? 11 : 12;
|
|
|
|
for (var i = 0; i < 10; ++i)
|
|
{
|
|
var randomPoint = new Point3D(
|
|
m_Mobile.X - teleRange + Utility.Random(teleRange * 2 + 1),
|
|
m_Mobile.Y - teleRange + Utility.Random(teleRange * 2 + 1),
|
|
0);
|
|
|
|
var lt = new LandTarget(randomPoint, map);
|
|
|
|
if (m_Mobile.InLOS(lt) && map.CanSpawnMobile(lt.X, lt.Y, lt.Z) && !SpellHelper.CheckMulti(randomPoint, map))
|
|
{
|
|
targ.Invoke(m_Mobile, new LandTarget(randomPoint, map));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
}
|
|
else
|
|
{
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
var toTarget = m_Mobile.Combatant;
|
|
|
|
if (toTarget != null)
|
|
RunTo(toTarget);
|
|
|
|
if (harmful && toTarget != null)
|
|
{
|
|
if ((targ.Range == -1 || m_Mobile.InRange(toTarget, targ.Range)) && m_Mobile.CanSee(toTarget) &&
|
|
m_Mobile.InLOS(toTarget))
|
|
{
|
|
targ.Invoke(m_Mobile, toTarget);
|
|
}
|
|
else
|
|
{
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
}
|
|
}
|
|
else if (beneficial)
|
|
{
|
|
targ.Invoke(m_Mobile, m_Mobile);
|
|
}
|
|
else
|
|
{
|
|
targ.Cancel(m_Mobile, TargetCancelType.Canceled);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public Item FindCorpseToAnimate()
|
|
{
|
|
IPooledEnumerable eable = m_Mobile.GetItemsInRange(12);
|
|
foreach (Item item in eable)
|
|
{
|
|
var c = item as Corpse;
|
|
|
|
if (c != null)
|
|
{
|
|
Type type = null;
|
|
|
|
if (c.Owner != null)
|
|
type = c.Owner.GetType();
|
|
|
|
var owner = c.Owner as BaseCreature;
|
|
|
|
if ((c.ItemID < 0xECA || c.ItemID > 0xED5) && m_Mobile.InLOS(c) && !c.Channeled && type != typeof(PlayerMobile) &&
|
|
type != null && (owner == null || (!owner.Summoned && !owner.IsBonded)))
|
|
{
|
|
eable.Free();
|
|
return item;
|
|
}
|
|
}
|
|
}
|
|
eable.Free();
|
|
return null;
|
|
}
|
|
|
|
private static readonly int[] m_Offsets =
|
|
{
|
|
-1, -1, -1, 0, -1, 1, 0, -1, 0, 1, 1, -1, 1, 0, 1, 1, -2, -2, -2, -1, -2, 0, -2, 1, -2, 2, -1, -2, -1, 2, 0, -2, 0,
|
|
2, 1, -2, 1, 2, 2, -2, 2, -1, 2, 0, 2, 1, 2, 2
|
|
};
|
|
|
|
public virtual void TryReveal()
|
|
{
|
|
if (!m_Mobile.Alive || m_Mobile.Map == null)
|
|
return;
|
|
|
|
m_RevealTarget = new LandTarget(LastTargetLoc, m_Mobile.Map);
|
|
|
|
if (UsesMagery)
|
|
{
|
|
Spell spell = new RevealSpell(m_Mobile, null);
|
|
|
|
if (spell.Cast())
|
|
LastTarget = null; // only do it once
|
|
|
|
NextCastTime = DateTime.UtcNow + GetDelay(spell);
|
|
}
|
|
else if (m_Mobile.CanDetectHidden)
|
|
{
|
|
DetectHidden.OnUse(m_Mobile);
|
|
|
|
if (m_Mobile.Target is DetectHidden.InternalTarget)
|
|
{
|
|
m_Mobile.Target.Invoke(m_Mobile, m_RevealTarget);
|
|
}
|
|
|
|
NextCastTime = DateTime.UtcNow + TimeSpan.FromSeconds(1);
|
|
}
|
|
}
|
|
}
|
|
}
|