732 lines
No EOL
19 KiB
C#
732 lines
No EOL
19 KiB
C#
using System;
|
|
using Server.Items;
|
|
using Server.Misc;
|
|
using Server.Network;
|
|
using Server.Targeting;
|
|
using Server.Mobiles;
|
|
using Server.Spells.Second;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Server.Spells
|
|
{
|
|
public abstract class Spell : ISpell
|
|
{
|
|
private Mobile m_Caster;
|
|
private Item m_Scroll;
|
|
private SpellInfo m_Info;
|
|
private SpellState m_State;
|
|
private DateTime m_StartCastTime;
|
|
|
|
public SpellState State{ get{ return m_State; } set{ m_State = value; } }
|
|
public Mobile Caster{ get{ return m_Caster; } }
|
|
public SpellInfo Info{ get{ return m_Info; } }
|
|
public string Name{ get{ return m_Info.Name; } }
|
|
public string Mantra{ get{ return m_Info.Mantra; } }
|
|
public Type[] Reagents{ get{ return m_Info.Reagents; } }
|
|
public Item Scroll{ get{ return m_Scroll; } }
|
|
public DateTime StartCastTime { get { return m_StartCastTime; } }
|
|
|
|
private static TimeSpan NextSpellDelay = TimeSpan.FromSeconds( 0.75 );
|
|
private static TimeSpan AnimateDelay = TimeSpan.FromSeconds( 1.5 );
|
|
|
|
public virtual SkillName CastSkill{ get{ return SkillName.Magery; } }
|
|
public virtual SkillName DamageSkill{ get{ return SkillName.Concentration; } }
|
|
|
|
public virtual bool RevealOnCast{ get{ return true; } }
|
|
public virtual bool ClearHandsOnCast{ get{ return Server.Misc.Settings.CastSpellsHoldingThings(); } }
|
|
public virtual bool ShowHandMovement{ get{ return true; } }
|
|
|
|
public virtual bool DelayedDamage{ get{ return false; } }
|
|
|
|
public virtual bool DelayedDamageStacking { get { return true; } }
|
|
//In reality, it's ANY delayed Damage spell that can't stack, but, only
|
|
//Expo & Magic Arrow have enough delay and a short enough cast time to bring up
|
|
//the possibility of stacking 'em. Note that a MA & an Explosion will stack, but
|
|
//of course, two MA's won't.
|
|
|
|
private static Dictionary<Type, DelayedDamageContextWrapper> m_ContextTable = new Dictionary<Type, DelayedDamageContextWrapper>();
|
|
|
|
private class DelayedDamageContextWrapper
|
|
{
|
|
private Dictionary<Mobile, Timer> m_Contexts = new Dictionary<Mobile, Timer>();
|
|
|
|
public void Add( Mobile m, Timer t )
|
|
{
|
|
Timer oldTimer;
|
|
if( m_Contexts.TryGetValue( m, out oldTimer ) )
|
|
{
|
|
oldTimer.Stop();
|
|
m_Contexts.Remove( m );
|
|
}
|
|
|
|
m_Contexts.Add( m, t );
|
|
}
|
|
|
|
public void Remove( Mobile m )
|
|
{
|
|
m_Contexts.Remove( m );
|
|
}
|
|
}
|
|
|
|
public void StartDelayedDamageContext( Mobile m, Timer t )
|
|
{
|
|
if( DelayedDamageStacking )
|
|
return; //Sanity
|
|
|
|
DelayedDamageContextWrapper contexts;
|
|
|
|
if( !m_ContextTable.TryGetValue( GetType(), out contexts ) )
|
|
{
|
|
contexts = new DelayedDamageContextWrapper();
|
|
m_ContextTable.Add( GetType(), contexts );
|
|
}
|
|
|
|
contexts.Add( m, t );
|
|
}
|
|
|
|
public void RemoveDelayedDamageContext( Mobile m )
|
|
{
|
|
DelayedDamageContextWrapper contexts;
|
|
|
|
if( !m_ContextTable.TryGetValue( GetType(), out contexts ) )
|
|
return;
|
|
|
|
contexts.Remove( m );
|
|
}
|
|
|
|
public void HarmfulSpell( Mobile m )
|
|
{
|
|
if ( m is BaseCreature )
|
|
((BaseCreature)m).OnHarmfulSpell( m_Caster );
|
|
}
|
|
|
|
public Spell( Mobile caster, Item scroll, SpellInfo info )
|
|
{
|
|
m_Caster = caster;
|
|
m_Scroll = scroll;
|
|
m_Info = info;
|
|
}
|
|
|
|
public virtual bool IsCasting{ get{ return m_State == SpellState.Casting; } }
|
|
|
|
public virtual void OnCasterHurt()
|
|
{
|
|
//Confirm: Monsters and pets cannot be disturbed.
|
|
if ( !Caster.Player )
|
|
return;
|
|
|
|
if ( CheckHandToHand( Caster ) )
|
|
return;
|
|
|
|
if ( IsCasting )
|
|
{
|
|
object o = ProtectionSpell.Registry[m_Caster];
|
|
bool disturb = true;
|
|
|
|
if ( o != null && o is double )
|
|
{
|
|
if ( ((double)o) > Utility.RandomDouble()*100.0 )
|
|
disturb = false;
|
|
}
|
|
|
|
if ( disturb )
|
|
Disturb( DisturbType.Hurt, false, true );
|
|
}
|
|
}
|
|
|
|
public virtual void OnCasterKilled()
|
|
{
|
|
Disturb( DisturbType.Kill );
|
|
}
|
|
|
|
public virtual void OnConnectionChanged()
|
|
{
|
|
FinishSequence();
|
|
}
|
|
|
|
public virtual bool OnCasterMoving( Direction d )
|
|
{
|
|
if ( IsCasting && BlocksMovement )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 500111 ); // You are frozen and can not move.
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual bool OnCasterEquiping( Item item )
|
|
{
|
|
if ( IsCasting )
|
|
Disturb( DisturbType.EquipRequest );
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual bool OnCasterUsingObject( object o )
|
|
{
|
|
if ( m_State == SpellState.Sequencing )
|
|
Disturb( DisturbType.UseRequest );
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual bool OnCastInTown( Region r )
|
|
{
|
|
return m_Info.AllowTown;
|
|
}
|
|
|
|
public virtual bool ConsumeReagents()
|
|
{
|
|
if ( m_Scroll != null || !m_Caster.Player )
|
|
return true;
|
|
|
|
Container pack = m_Caster.Backpack;
|
|
|
|
if ( pack == null )
|
|
return false;
|
|
|
|
if ( pack.ConsumeTotal( m_Info.Reagents, m_Info.Amounts ) == -1 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public virtual int GetDamageFixed( Mobile m )
|
|
{
|
|
return m.Skills[DamageSkill].Fixed;
|
|
}
|
|
|
|
public virtual double GetDamageSkill( Mobile m )
|
|
{
|
|
return m.Skills[DamageSkill].Value;
|
|
}
|
|
|
|
public virtual double GetResistSkill( Mobile m )
|
|
{
|
|
return m.Skills[SkillName.MagicResist].Value;
|
|
}
|
|
|
|
public virtual bool CheckHandToHand( Mobile m )
|
|
{
|
|
return m.CheckSkill( SkillName.HandToHand, 0.0, 100.0 );
|
|
}
|
|
|
|
public virtual double GetDamageScalar( Mobile target )
|
|
{
|
|
double scalar = 1.0;
|
|
|
|
double casterEI = m_Caster.Skills[DamageSkill].Value;
|
|
double targetRS = target.Skills[SkillName.MagicResist].Value;
|
|
|
|
if( casterEI > targetRS )
|
|
scalar = (1.0 + ((casterEI - targetRS) / 500.0));
|
|
else
|
|
scalar = (1.0 + ((casterEI - targetRS) / 200.0));
|
|
|
|
// magery damage bonus, -25% at 0 skill, +0% at 100 skill, +5% at 120 skill
|
|
scalar += (m_Caster.Skills[CastSkill].Value - 100.0) / 400.0;
|
|
|
|
if ( m_Caster.CheckSkill( SkillName.Concentration, 0.0, 100.0 ) )
|
|
scalar *= ( m_Caster.Skills[SkillName.Concentration].Value / 50 );
|
|
|
|
if ( target is BaseCreature )
|
|
((BaseCreature)target).AlterDamageScalarFrom( m_Caster, ref scalar );
|
|
|
|
if ( m_Caster is BaseCreature )
|
|
((BaseCreature)m_Caster).AlterDamageScalarTo( target, ref scalar );
|
|
|
|
target.Region.SpellDamageScalar( m_Caster, target, ref scalar );
|
|
|
|
return scalar;
|
|
}
|
|
|
|
public virtual double GetSlayerDamageScalar( Mobile defender )
|
|
{
|
|
Spellbook atkBook = Spellbook.FindEquippedSpellbook( m_Caster );
|
|
|
|
double scalar = 1.0;
|
|
if( atkBook != null )
|
|
{
|
|
SlayerEntry atkSlayer = SlayerGroup.GetEntryByName( atkBook.Slayer );
|
|
SlayerEntry atkSlayer2 = SlayerGroup.GetEntryByName( atkBook.Slayer2 );
|
|
|
|
if( atkSlayer != null && atkSlayer.Slays( defender ) || atkSlayer2 != null && atkSlayer2.Slays( defender ) )
|
|
{
|
|
defender.FixedEffect( 0x37B9, 10, 5 ); //TODO: Confirm this displays on OSIs
|
|
scalar = 2.0;
|
|
}
|
|
|
|
if( scalar != 1.0 )
|
|
return scalar;
|
|
}
|
|
|
|
return scalar;
|
|
}
|
|
|
|
public virtual void DoFizzle()
|
|
{
|
|
m_Caster.LocalOverheadMessage( MessageType.Regular, 0x3B2, 502632 ); // The spell fizzles.
|
|
|
|
if ( m_Caster.Player )
|
|
{
|
|
m_Caster.FixedEffect( 0x3735, 6, 30 );
|
|
|
|
m_Caster.PlaySound( 0x5C );
|
|
}
|
|
}
|
|
|
|
private CastTimer m_CastTimer;
|
|
private AnimTimer m_AnimTimer;
|
|
|
|
public void Disturb( DisturbType type )
|
|
{
|
|
Disturb( type, true, false );
|
|
}
|
|
|
|
public virtual bool CheckDisturb( DisturbType type, bool firstCircle, bool resistable )
|
|
{
|
|
if ( resistable && m_Scroll is BaseWand )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public void Disturb( DisturbType type, bool firstCircle, bool resistable )
|
|
{
|
|
if ( !CheckDisturb( type, firstCircle, resistable ) )
|
|
return;
|
|
|
|
if ( m_State == SpellState.Casting )
|
|
{
|
|
if( !firstCircle && this is MagerySpell && ((MagerySpell)this).Circle == SpellCircle.First )
|
|
return;
|
|
|
|
if ( CheckHandToHand( m_Caster ) )
|
|
return;
|
|
|
|
m_State = SpellState.None;
|
|
m_Caster.Spell = null;
|
|
|
|
OnDisturb( type, true );
|
|
|
|
if ( m_CastTimer != null )
|
|
m_CastTimer.Stop();
|
|
|
|
if ( m_AnimTimer != null )
|
|
m_AnimTimer.Stop();
|
|
|
|
m_Caster.NextSpellTime = DateTime.Now + GetDisturbRecovery();
|
|
}
|
|
else if ( m_State == SpellState.Sequencing )
|
|
{
|
|
if( !firstCircle && this is MagerySpell && ((MagerySpell)this).Circle == SpellCircle.First )
|
|
return;
|
|
|
|
if ( CheckHandToHand( m_Caster ) )
|
|
return;
|
|
|
|
m_State = SpellState.None;
|
|
m_Caster.Spell = null;
|
|
|
|
OnDisturb( type, false );
|
|
|
|
Targeting.Target.Cancel( m_Caster );
|
|
}
|
|
}
|
|
|
|
public virtual void DoHurtFizzle()
|
|
{
|
|
m_Caster.FixedEffect( 0x3735, 6, 30 );
|
|
m_Caster.PlaySound( 0x5C );
|
|
}
|
|
|
|
public virtual void OnDisturb( DisturbType type, bool message )
|
|
{
|
|
if ( message )
|
|
m_Caster.SendLocalizedMessage( 500641 ); // Your concentration is disturbed, thus ruining thy spell.
|
|
}
|
|
|
|
public virtual bool CheckCast()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public virtual void SayMantra()
|
|
{
|
|
if ( m_Scroll is BaseWand )
|
|
return;
|
|
|
|
if ( m_Info.Mantra != null && m_Info.Mantra.Length > 0 && m_Caster.Player )
|
|
m_Caster.PublicOverheadMessage( MessageType.Spell, m_Caster.SpeechHue, true, m_Info.Mantra, false );
|
|
}
|
|
|
|
public virtual bool BlocksMovement{ get{ return true; } }
|
|
|
|
public virtual bool CheckNextSpellTime{ get{ return !(m_Scroll is BaseWand); } }
|
|
|
|
public bool Cast()
|
|
{
|
|
m_StartCastTime = DateTime.Now;
|
|
|
|
if ( !m_Caster.CheckAlive() )
|
|
{
|
|
return false;
|
|
}
|
|
else if ( m_Caster.Spell != null && m_Caster.Spell.IsCasting )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 502642 ); // You are already casting a spell.
|
|
}
|
|
else if ( !(m_Scroll is BaseWand) && (m_Caster.Paralyzed || m_Caster.Frozen) )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 502643 ); // You can not cast a spell while frozen.
|
|
}
|
|
else if ( CheckNextSpellTime && DateTime.Now < m_Caster.NextSpellTime )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 502644 ); // You have not yet recovered from casting a spell.
|
|
}
|
|
else if ( m_Caster is PlayerMobile && ( (PlayerMobile) m_Caster ).PeacedUntil > DateTime.Now )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 1072060 ); // You cannot cast a spell while calmed.
|
|
}
|
|
else if ( m_Caster.Mana >= ScaleMana( GetMana() ) )
|
|
{
|
|
if ( m_Caster.Spell == null && m_Caster.CheckSpellCast( this ) && CheckCast() && m_Caster.Region.OnBeginSpellCast( m_Caster, this ) )
|
|
{
|
|
m_State = SpellState.Casting;
|
|
m_Caster.Spell = this;
|
|
|
|
if ( RevealOnCast )
|
|
m_Caster.RevealingAction();
|
|
|
|
SayMantra();
|
|
|
|
TimeSpan castDelay = this.GetCastDelay();
|
|
|
|
if ( ShowHandMovement && m_Caster.Body.IsHuman )
|
|
{
|
|
int count = (int)Math.Ceiling( castDelay.TotalSeconds / AnimateDelay.TotalSeconds );
|
|
|
|
if ( count != 0 )
|
|
{
|
|
m_AnimTimer = new AnimTimer( this, count );
|
|
m_AnimTimer.Start();
|
|
}
|
|
|
|
if ( m_Info.LeftHandEffect > 0 )
|
|
Caster.FixedParticles( 0, 10, 5, m_Info.LeftHandEffect, EffectLayer.LeftHand );
|
|
|
|
if ( m_Info.RightHandEffect > 0 )
|
|
Caster.FixedParticles( 0, 10, 5, m_Info.RightHandEffect, EffectLayer.RightHand );
|
|
}
|
|
|
|
if ( ClearHandsOnCast )
|
|
m_Caster.ClearHands();
|
|
|
|
m_CastTimer = new CastTimer( this, castDelay );
|
|
m_CastTimer.Start();
|
|
|
|
OnBeginCast();
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Caster.LocalOverheadMessage( MessageType.Regular, 0x22, 502625 ); // Insufficient mana
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public abstract void OnCast();
|
|
|
|
public virtual void OnBeginCast()
|
|
{
|
|
}
|
|
|
|
public virtual void GetCastSkills( out double min, out double max )
|
|
{
|
|
min = max = 0; //Intended but not required for overriding.
|
|
}
|
|
|
|
public virtual bool CheckFizzle()
|
|
{
|
|
if ( m_Scroll is BaseWand )
|
|
return true;
|
|
|
|
double minSkill, maxSkill;
|
|
|
|
GetCastSkills( out minSkill, out maxSkill );
|
|
|
|
if ( DamageSkill != CastSkill )
|
|
Caster.CheckSkill( DamageSkill, 0.0, Caster.Skills[ DamageSkill ].Cap );
|
|
|
|
return Caster.CheckSkill( CastSkill, minSkill, maxSkill );
|
|
}
|
|
|
|
public abstract int GetMana();
|
|
|
|
public virtual int ScaleMana( int mana )
|
|
{
|
|
double scalar = 1.0;
|
|
|
|
// Lower Mana Needed for Concentration is capped at 50%
|
|
int lmc = (int)(m_Caster.Skills[SkillName.Concentration].Value/2);
|
|
if ( lmc > 50 )
|
|
lmc = 50;
|
|
|
|
scalar -= (double)lmc / 100;
|
|
|
|
return (int)(mana * scalar);
|
|
}
|
|
|
|
public virtual TimeSpan GetDisturbRecovery()
|
|
{
|
|
double delay = 1.0 - Math.Sqrt( (DateTime.Now - m_StartCastTime).TotalSeconds / GetCastDelay().TotalSeconds );
|
|
|
|
if ( delay < 0.2 )
|
|
delay = 0.2;
|
|
|
|
return TimeSpan.FromSeconds( delay );
|
|
}
|
|
|
|
public virtual int CastRecoveryBase{ get{ return 6; } }
|
|
public virtual int CastRecoveryFastScalar{ get{ return 1; } }
|
|
public virtual int CastRecoveryPerSecond{ get{ return 4; } }
|
|
public virtual int CastRecoveryMinimum{ get{ return 0; } }
|
|
|
|
public virtual TimeSpan GetCastRecovery()
|
|
{
|
|
int fcr = 0;
|
|
|
|
if ( m_Caster.CheckSkill( SkillName.HandToHand, 0.0, 100.0 ) )
|
|
{
|
|
fcr = (int)(m_Caster.Skills[SkillName.HandToHand].Value / 20);
|
|
}
|
|
|
|
int fcrDelay = -(CastRecoveryFastScalar * fcr);
|
|
|
|
int delay = CastRecoveryBase + fcrDelay;
|
|
|
|
if ( delay < CastRecoveryMinimum )
|
|
delay = CastRecoveryMinimum;
|
|
|
|
return TimeSpan.FromSeconds( (double)delay / CastRecoveryPerSecond );
|
|
}
|
|
|
|
public abstract TimeSpan CastDelayBase { get; }
|
|
|
|
public virtual double CastDelayFastScalar { get { return 1; } }
|
|
public virtual double CastDelaySecondsPerTick { get { return 0.25; } }
|
|
public virtual TimeSpan CastDelayMinimum { get { return TimeSpan.FromSeconds( 0.25 ); } }
|
|
|
|
public virtual TimeSpan GetCastDelay()
|
|
{
|
|
if ( m_Scroll is BaseWand )
|
|
return TimeSpan.Zero;
|
|
|
|
// Faster casting cap of 2 (if not using the protection spell)
|
|
// Faster casting cap of 0 (if using the protection spell)
|
|
int fc = 0;
|
|
|
|
if ( m_Caster.CheckSkill( SkillName.HandToHand, 0.0, 100.0 ) )
|
|
{
|
|
if ( m_Caster.Skills[SkillName.HandToHand].Value > 50.0 )
|
|
fc = 1;
|
|
else
|
|
fc = 2;
|
|
}
|
|
|
|
if ( ProtectionSpell.Registry.Contains( m_Caster ) )
|
|
fc -= 2;
|
|
|
|
TimeSpan baseDelay = CastDelayBase;
|
|
|
|
TimeSpan fcDelay = TimeSpan.FromSeconds( -(CastDelayFastScalar * fc * CastDelaySecondsPerTick) );
|
|
|
|
//int delay = CastDelayBase + circleDelay + fcDelay;
|
|
TimeSpan delay = baseDelay + fcDelay;
|
|
|
|
if ( delay < CastDelayMinimum )
|
|
delay = CastDelayMinimum;
|
|
|
|
//return TimeSpan.FromSeconds( (double)delay / CastDelayPerSecond );
|
|
return delay;
|
|
}
|
|
|
|
public virtual void FinishSequence()
|
|
{
|
|
m_State = SpellState.None;
|
|
|
|
if ( m_Caster.Spell == this )
|
|
m_Caster.Spell = null;
|
|
}
|
|
|
|
public virtual bool CheckSequence()
|
|
{
|
|
int mana = ScaleMana( GetMana() );
|
|
|
|
if ( m_Caster.Deleted || !m_Caster.Alive || m_Caster.Spell != this || m_State != SpellState.Sequencing )
|
|
{
|
|
DoFizzle();
|
|
}
|
|
else if ( m_Scroll != null && (m_Scroll.Amount <= 0 || m_Scroll.Deleted || m_Scroll.RootParent != m_Caster || (m_Scroll is BaseWand && (((BaseWand)m_Scroll).Uses <= 0 || m_Scroll.Parent != m_Caster))) )
|
|
{
|
|
DoFizzle();
|
|
}
|
|
else if ( !ConsumeReagents() )
|
|
{
|
|
m_Caster.LocalOverheadMessage( MessageType.Regular, 0x22, 502630 ); // More reagents are needed for this spell.
|
|
}
|
|
else if ( m_Caster.Mana < mana )
|
|
{
|
|
m_Caster.LocalOverheadMessage( MessageType.Regular, 0x22, 502625 ); // Insufficient mana for this spell.
|
|
}
|
|
else if ( m_Caster is PlayerMobile && ((PlayerMobile) m_Caster).PeacedUntil > DateTime.Now )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 1072060 ); // You cannot cast a spell while calmed.
|
|
DoFizzle();
|
|
}
|
|
else if ( CheckFizzle() )
|
|
{
|
|
m_Caster.Mana -= mana;
|
|
|
|
if ( m_Scroll is SpellScroll )
|
|
m_Scroll.Consume();
|
|
else if ( m_Scroll is BaseWand )
|
|
((BaseWand)m_Scroll).ConsumeCharge( m_Caster );
|
|
|
|
if ( m_Scroll is BaseWand )
|
|
{
|
|
bool m = m_Scroll.Movable;
|
|
|
|
m_Scroll.Movable = false;
|
|
|
|
if ( ClearHandsOnCast )
|
|
m_Caster.ClearHands();
|
|
|
|
m_Scroll.Movable = m;
|
|
}
|
|
else
|
|
{
|
|
if ( ClearHandsOnCast )
|
|
m_Caster.ClearHands();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
DoFizzle();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool CheckBSequence( Mobile target )
|
|
{
|
|
return CheckBSequence( target, false );
|
|
}
|
|
|
|
public bool CheckBSequence( Mobile target, bool allowDead )
|
|
{
|
|
if ( !target.Alive && !allowDead )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 501857 ); // This spell won't work on that!
|
|
return false;
|
|
}
|
|
else if ( Caster.CanBeBeneficial( target, true, allowDead ) && CheckSequence() )
|
|
{
|
|
Caster.DoBeneficial( target );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool CheckHSequence( Mobile target )
|
|
{
|
|
if ( !target.Alive )
|
|
{
|
|
m_Caster.SendLocalizedMessage( 501857 ); // This spell won't work on that!
|
|
return false;
|
|
}
|
|
else if ( Caster.CanBeHarmful( target ) && CheckSequence() )
|
|
{
|
|
Caster.DoHarmful( target );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private class AnimTimer : Timer
|
|
{
|
|
private Spell m_Spell;
|
|
|
|
public AnimTimer( Spell spell, int count ) : base( TimeSpan.Zero, AnimateDelay, count )
|
|
{
|
|
m_Spell = spell;
|
|
|
|
Priority = TimerPriority.FiftyMS;
|
|
}
|
|
|
|
protected override void OnTick()
|
|
{
|
|
if ( m_Spell.State != SpellState.Casting || m_Spell.m_Caster.Spell != m_Spell )
|
|
{
|
|
Stop();
|
|
return;
|
|
}
|
|
|
|
if ( !m_Spell.Caster.Mounted && m_Spell.Caster.Body.IsHuman && m_Spell.m_Info.Action >= 0 )
|
|
m_Spell.Caster.Animate( m_Spell.m_Info.Action, 7, 1, true, false, 0 );
|
|
|
|
if ( !Running )
|
|
m_Spell.m_AnimTimer = null;
|
|
}
|
|
}
|
|
|
|
private class CastTimer : Timer
|
|
{
|
|
private Spell m_Spell;
|
|
|
|
public CastTimer( Spell spell, TimeSpan castDelay ) : base( castDelay )
|
|
{
|
|
m_Spell = spell;
|
|
|
|
Priority = TimerPriority.TwentyFiveMS;
|
|
}
|
|
|
|
protected override void OnTick()
|
|
{
|
|
if ( m_Spell.m_State == SpellState.Casting && m_Spell.m_Caster.Spell == m_Spell )
|
|
{
|
|
m_Spell.m_State = SpellState.Sequencing;
|
|
m_Spell.m_CastTimer = null;
|
|
m_Spell.m_Caster.OnSpellCast( m_Spell );
|
|
m_Spell.m_Caster.Region.OnSpellCast( m_Spell.m_Caster, m_Spell );
|
|
m_Spell.m_Caster.NextSpellTime = DateTime.Now + m_Spell.GetCastRecovery();// Spell.NextSpellDelay;
|
|
|
|
Target originalTarget = m_Spell.m_Caster.Target;
|
|
|
|
m_Spell.OnCast();
|
|
|
|
if ( m_Spell.m_Caster.Player && m_Spell.m_Caster.Target != originalTarget && m_Spell.Caster.Target != null )
|
|
m_Spell.m_Caster.Target.BeginTimeout( m_Spell.m_Caster, TimeSpan.FromSeconds( 30.0 ) );
|
|
|
|
m_Spell.m_CastTimer = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |