public DynamicObject(SpellCast cast, float radius)
			: this(cast.CasterUnit,
			cast.Spell.SpellId, radius,
			cast.Caster.Region,
			cast.TargetLoc)
		{
		}

		public virtual NPC Summon(SpellCast cast, ref Vector3 targetLoc, NPCEntry entry)
		{
			var caster = cast.CasterUnit;
			var duration = cast.Spell.GetDuration(cast.CasterReference);

			NPC minion;
			if (caster != null)
			{
				minion = caster.SpawnMinion(entry, ref targetLoc, duration);
			}
			else
			{
				minion = entry.Create(cast.TargetMap.DifficultyIndex);

				minion.Position = targetLoc;
				minion.Brain.IsRunning = true;
				minion.Phase = cast.Phase;
				cast.Map.AddObject(minion);
			}

			if (caster is Character)
			{
				minion.Level = caster.Level;
			}
			minion.Summoner = caster;
			minion.Creator = cast.CasterReference.EntityId;

			return minion;
		}

 internal void NotifyCasted(SpellCast cast)
 {
     var evt = Casted;
     if (evt != null)
     {
         evt(cast);
     }
 }

		public virtual NPC Summon(SpellCast cast, ref Vector3 targetLoc, NPCEntry entry)
		{
			var caster = cast.CasterUnit;
			var pet = caster.SpawnMinion(entry, ref targetLoc, cast.Spell.GetDuration(caster.CasterInfo));
			pet.Summoner = caster;
			pet.Creator = caster.EntityId;
			return pet;
		}

		internal void NotifyCancelled(SpellCast cast, SpellFailedReason reason)
		{
			var evt = Cancelling;
			if (evt != null)
			{
				evt(cast, reason);
			}
		}

		/// <summary>
		/// Called when this Unit got the given debuff by the given SpellCast
		/// </summary>
		/// <param name="cast"></param>
		internal void OnDebuff(SpellCast cast, Aura debuff)
		{
			// force combat mode
			IsInCombat = true;

			var evt = Debuff;
			if (evt != null)
			{
				evt(this, cast, debuff);
			}
		}

		public override NPC Summon(SpellCast cast, ref Vector3 targetLoc, NPCEntry entry)
		{
			var caster = cast.CasterUnit;
			if (caster is Character)
			{
				return ((Character)caster).SpawnPet(entry, ref targetLoc, cast.Spell.GetDuration(caster.SharedReference));
			}
			else
			{
				return base.Summon(cast, ref targetLoc, entry);
			}
		}

		/// <summary>
		/// Triggers the Casting event
		/// </summary>
		internal SpellFailedReason NotifyCasting(SpellCast cast)
		{
			var evt = Casting;
			if (evt != null)
			{
				var err = evt(cast);
				if (err != SpellFailedReason.Ok)
				{
					cast.Cancel(err);
					return err;
				}
			}
			return SpellFailedReason.Ok;
		}

        /// <summary>
        /// Ensure that the constraints are correct for the Flag aura to be applied
        /// </summary>
        protected override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
        {
			if (!(target is Character))
			{
				failReason = SpellFailedReason.BadTargets;
			}
			else
			{
				Instance = target.Region as WarsongGulch;
				if (Instance == null)
				{
					failReason = SpellFailedReason.IncorrectArea;
				}
			}
        }

 /// <summary>
 /// Correct 3.0.9
 /// </summary>
 public static void SendSpellMiss(SpellCast cast, bool display, ICollection<MissedTarget> missedTargets)
 {
     using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_SPELLLOGMISS, 34))
     {
         packet.Write(cast.Spell.Id);
         packet.Write(cast.CasterReference.EntityId);
         packet.Write(display);// TODO: test this value. Its a bool that seems to determine whether to display this packet in the combat log
         packet.Write(missedTargets.Count);
         foreach (var miss in missedTargets)
         {
             packet.Write(miss.Target.EntityId);
             packet.Write((byte)miss.Reason);
         }
         cast.SendPacketToArea(packet);
     }
 }

			protected override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
			{
				if (target is Character)
				{
					var chr = (Character)target;
					var ap = target.TotalMeleeAP;
					var sp = chr.GetDamageDoneMod(DamageSchool.Holy);
					if (ap > sp)
					{
						totalBonus = ap;
					}
					else
					{
						totalBonus = sp;
					}
				}
			}

		/// <summary>
		/// Find valid targets for AI cast during preparation
		/// </summary>
		SpellFailedReason PrepareAI(SpellCast cast)
		{
			var caster = cast.CasterUnit;
			cast.SourceLoc = caster.Position;

			if (caster.Target != null)
			{
				caster.SpellCast.TargetLoc = caster.Target.Position;
			}


			// TODO: Init handlers
			//var targets = FindValidTargetsForCaster(caster);
			//if (targets == null)
			//{
			//    return SpellFailedReason.NoValidTargets;
			//}

			return SpellFailedReason.NoValidTargets;
		}

		public FerociousBiteHandler(SpellCast cast, SpellEffect effect)
			: base(cast, effect)
		{
		}

		internal static void SendSpellFailedOther(SpellCast spellCast, SpellFailedReason reason)
		{
			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_SPELL_FAILED_OTHER, 15))
			{
				spellCast.Caster.EntityId.WritePacked(packet);
				packet.Write(spellCast.Id);
				packet.Write(spellCast.Spell.Id);
				packet.Write((byte)reason);

				spellCast.Caster.SendPacketToArea(packet);
			}
		}

 public ReadinessHandler(SpellCast cast, SpellEffect effect)
     : base(cast, effect)
 {
 }

		private static void WriteCaster(SpellCast cast, RealmPacketOut packet)
		{
			if (cast.Caster == null) return;

			if (cast.UsedItem != null)
			{
				//packet.Write(cast.UsedItem.EntityId);
				cast.UsedItem.EntityId.WritePacked(packet);
			}
			else
			{
				//cast.UsedItem.EntityId.WritePacked(packet);
				cast.Caster.EntityId.WritePacked(packet);
			}

			//packet.Write(cast.Caster.EntityId);
			cast.Caster.EntityId.WritePacked(packet);
		}

		/// <summary>
		/// Spell went wrong or got cancelled
		/// </summary>
		internal static void SendCastFailPackets(SpellCast spellCast, SpellFailedReason reason)
		{
			if (spellCast.Client == null)
			{
				return;
			}
			SendCastFailed(spellCast.Client, spellCast.Id, spellCast.Spell, reason);

			SendSpellFailure(spellCast, reason);
			SendSpellFailedOther(spellCast, reason);
		}

		/// <summary>
		/// Sent after spell start. Triggers the casting animation
		/// </summary>
		public static void SendSpellGo(ObjectBase caster2, SpellCast cast,
			ICollection<WorldObject> hitTargets, ICollection<CastMiss> missedTargets)
		{
			// TODO: Dynamic packet length?
			if (!cast.IsCasting)
			{
				return;
			}

			//int len = 200;
			int len = 24 + (hitTargets != null ? hitTargets.Count * 8 : 0) + (missedTargets != null ? missedTargets.Count * 10 : 0);

			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_SPELL_GO, len))
			{
				//caster1.EntityId.WritePacked(packet);
				cast.Caster.EntityId.WritePacked(packet);
				caster2.EntityId.WritePacked(packet);
				packet.Write(cast.Id);
				packet.Write(cast.Spell.Id);

				var castGoFlags = cast.GoFlags;
				packet.Write((int)castGoFlags);

				//packet.Write(Util.Utility.GetEpochTime());
				packet.Write(Utility.GetEpochTime());
				//packet.Write(cast.CastDelay);

				packet.WriteByte(hitTargets != null ? hitTargets.Count : 0);

				if (hitTargets != null)
				{
					foreach (var target in hitTargets)
					{
						packet.Write(target.EntityId);

						if (target is Character)
						{
							SendCastSuccess(cast.Caster, cast.Spell.Id, target as Character);
						}
					}
				}

				packet.WriteByte(missedTargets != null ? missedTargets.Count : 0);

				if (missedTargets != null)
				{
					foreach (var miss in missedTargets)
					{
						packet.Write(miss.Target.EntityId);
						packet.Write((byte)miss.Reason);
						if (miss.Reason == CastMissReason.Reflect)
						{
							packet.Write((byte)0);// relfectreason
						}
					}
				}

				WriteTargets(packet, cast);

				if ((castGoFlags & CastFlags.Flag_0x800) != 0)
				{
					packet.Write(0);
				}

				if ((castGoFlags & CastFlags.Flag_0x200000) != 0)
				{
					byte b1 = 0;
					byte b2 = 0;
					packet.Write(b1);
					packet.Write(b2);
					for (int i = 0; i < 6; i++)
					{
						byte mask = (byte)(1 << i);
						if ((mask & b1) != 0)
						{
							if (!((mask & b2) != 0))
							{
								packet.WriteByte(0);
							}
						}
					}
				}

				if ((castGoFlags & CastFlags.Flag_0x20000) != 0)
				{
					packet.WriteFloat(0);
					packet.Write(0);
				}

				if ((cast.StartFlags & CastFlags.Ranged) != 0)
				{
					WriteAmmoInfo(cast, packet);
				}

				if ((castGoFlags & CastFlags.Flag_0x80000) != 0)
				{
					packet.Write(0);
//.........这里部分代码省略.........

		public AddBleedWeaponDamageHandler(SpellCast cast, SpellEffect effect)
			: base(cast, effect)
		{
		}

			public BurnoutHandler(SpellCast cast, SpellEffect effect)
				: base(cast, effect)
			{
			}