public SummonEffectHandler(SpellCast cast, SpellEffect effect)
			: base(cast, effect)
		{
			// MiscValueB:
			// 41 -> NonCombat Companion
			// 
		}

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
 {
     if (!(target is Character))
     {
         failReason = SpellFailedReason.TargetNotPlayer;
     }
 }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			if (target.MaxPower == 0 || target.PowerType != (PowerType)m_spellEffect.MiscValue)
			{
				failReason = SpellFailedReason.BadTargets;
			}
		}

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
 {
     var caster = creatingCast.CasterReference.Object as Unit;
     if (caster == null)
     {
         failReason = SpellFailedReason.BadTargets;
     }
     else
     {
         if (caster.Charm != null)
         {
             failReason = SpellFailedReason.AlreadyHaveCharm;
         }
         else if (target.HasMaster)
         {
             failReason = SpellFailedReason.CantDoThatRightNow;
         }
         else if (caster.HasMaster)
         {
             failReason = SpellFailedReason.Possessed;
         }
         else if (caster is Character)
         {
             if (((Character)caster).ActivePet != null)
             {
                 failReason = SpellFailedReason.AlreadyHaveSummon;
             }
         }
     }
 }

        protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
        {
            if (!(target is NPC))
            {
                failReason = SpellFailedReason.BadTargets;
            }

            if (casterRef != null && casterRef.Object is Unit)
            {
                var caster = (Unit)casterRef.Object;
                //if (target.Target == caster)
                //{
                //    failReason = SpellFailedReason.NoValidTargets;
                //}
                //else
                {
                    var spell = m_aura.Spell;
                    var hasSingleFriendTarget = spell.HasBeneficialEffects && !spell.IsAreaSpell && spell.HasTargets;
                    if (hasSingleFriendTarget && caster.Target != null && caster.IsFriendlyWith(caster.Target))
                    {
                        // taunting a friend, means we want to taunt his attackers
                        // needed for Righteous defense, amongst others
                        if (target.Target != caster.Target)
                        {
                            failReason = SpellFailedReason.NoValidTargets;
                        }
                    }
                }
            }
        }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			Caster = casterReference.Object as Unit;
			if (Caster == null || Caster is Vehicle)
			{
				log.Warn("Invalid SpellCaster \"{0}\" for Spell: {1}", Caster, SpellEffect.Spell);
				failReason = SpellFailedReason.Error;
				return;
			}

			Vehicle = target as Vehicle;
			if (Vehicle == null)
			{
				failReason = SpellFailedReason.BadTargets;
			}
			else
			{
				Seat = Vehicle.GetSeatFor(Caster);
				if (Seat == null)
				{
					// must never happen since Vehicle is unclickable when full
					failReason = SpellFailedReason.BadTargets;
				}
			}
		}

    // Use this for initialization
    void Start()
    {
        longc = GameObject.Find ("LongCast");
        spellcast1 = longc.GetComponent<SpellCast> ();

        _sih = GameObject.Find ("Sihir");
        mc = _sih.GetComponent<Encolhimento> ();
    }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			if (m_spellEffect.TriggerSpell == null)
			{
				failReason = SpellFailedReason.Error;
				log.Warn("Tried to cast Spell \"{0}\" which has invalid TriggerSpellId {1}", m_spellEffect.Spell, m_spellEffect.TriggerSpellId);
			}
		}

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			if (target.Class != ClassId.Hunter)
			{
				failReason = SpellFailedReason.BadTargets;
				return;
			}
		}

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
 {
     if (!(target is Character)) return;
     var chr = (Character)target;
     if (chr.Class != ClassId.Hunter)
     {
         failReason = SpellFailedReason.BadTargets;
     }
 }

		public NotImplementedEffect(SpellCast cast, SpellEffect effect)
			: base(cast, effect)
		{
			if (cast.Caster is Character)
			{
				(cast.Caster as Character).SendSystemMessage(
					"Spell {0} ({1}) has not implemented Effect {2}. Please report this to the developers",
					cast.Spell.Name, cast.Spell.Id, effect.EffectType);
			}
		}

    // Use this for initialization
    void Start()
    {
        //Os gameobjects a seguir sao inicializados para conseguir componentes de outros scripts utilizando
        //as variaveis ja declaradas.
         longc = GameObject.Find ("SpellCast");
        spellcast1 = longc.GetComponent<SpellCast> ();

        GameObject u = GameObject.Find ("UnObj");
        un = u.GetComponent<Unlockeds> ();
    }

 protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
 {
     if (target is Character)
     {
         var chr = (Character)target;
         if (!chr.CanFly)
         {
             failReason = SpellFailedReason.NotHere;
         }
     }
 }

 public SpellCast Cast(double crit_chance, double haste, int spell_power, double hit_chance = 0.99, double mana_cost_modifier = 1, double casting_time_modifier = 0)
 {
     SpellCast result = new SpellCast();
     result.IsResisted = r.NextDouble() < hit_chance ? false : true;
     result.IsCrit = can_crit && !result.IsResisted && r.NextDouble() < crit_chance ? true : false;
     int min = (int)Math.Floor((min_base_dmg + spell_power * spell_power_coeff) * (1 + (result.IsCrit ? crit_bonus_dmg : 0)) * dmg_multiplier);
     int max = (int)Math.Ceiling((max_base_dmg + spell_power * spell_power_coeff) * (1 + (result.IsCrit ? crit_bonus_dmg : 0)) * dmg_multiplier);
     result.Damage = r.Next(min, max + 1);
     result.ManaUsed = result.IsResisted ? 0 : (int)Math.Round(mana_cost * mana_cost_modifier);
     result.CastTime = (casting_time - casting_time_modifier) / (1 + haste);
     return result;
 }

    void Start()
    {
        //Os gameobjects a seguir sao inicializados para conseguir componentes de outros scripts utilizando
        //as variaveis ja declaradas.
        GameObject s = GameObject.Find ("SpellCast");
        castspell = s.GetComponent<SpellCast> ();
        DesoxField = GameObject.Find ("desoxfield");
        GameObject h = GameObject.Find ("Sihir");
        hp = h.GetComponent<Hpsih> ();
        trsihir = GameObject.Find ("Sihir");

        GameObject a = GameObject.Find ("Sihir");
        SihirSounds = a.GetComponent <SihirSounds> ();
    }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
		{
			form = (ShapeshiftForm)SpellEffect.MiscValue;
			if (target.ShapeshiftForm == form)
			{
				// stances can't be undone:
				if (form != ShapeshiftForm.BattleStance &&
					form != ShapeshiftForm.BerserkerStance &&
					form != ShapeshiftForm.DefensiveStance)
				{
					target.Auras.RemoveWhere(aura => aura.Spell.Id == m_aura.Spell.Id);
					failReason = SpellFailedReason.DontReport;
				}
			}
		}

    // Use this for initialization
    void Start()
    {
        //Os gameobjects a seguir sao inicializados para conseguir componentes de outros scripts utilizando
        //as variaveis ja declaradas.
        GameObject s = GameObject.Find ("SpellCast");
        castspell = s.GetComponent<SpellCast> ();

        esferar = GameObject.Find ("boladear2");

        GameObject t = GameObject.Find ("Sihir");
        tr = t.GetComponent<TrueSihir> ();

        GameObject h = GameObject.Find ("Sihir");
        hp = h.GetComponent<Hpsih> ();

        trsih = GameObject.Find ("Sihir");

        GameObject a = GameObject.Find ("Sihir");
        SihirSounds = a.GetComponent <SihirSounds> ();
    }

    void Update()
    {
        float a;//teste
        bool ativo = false;//controle, o objeto esta inativo.

        /*Caso a variavel da classe SpellCast chamada selo receba esses parametros, ele ira criar o objeto
         *e adicionara uma força para que o mesmo va para frente. Ao ser instanciado, o mesmo solta um som. Ele
         *reseta a variavel da classe SpellCast, reduz 1/8 da vida maxima da personagem, e manda a mensagem
         *para a classe TrueSihir, executando o metodo "Attack" que aciona a animaçao dos dados, bursts e etc.
         *Depois de tres segundos o gameobject desse script e destruido*/
        if (castspell.selo == "01" || castspell.selo == "D R ") {

            GameObject s = GameObject.Find ("SpellCast");
            castspell = s.GetComponent<SpellCast> ();
            target = GameObject.Find ("Sihir/SpellCast").transform;

            GameObject obj = Instantiate (DesoxField, target.position, target.rotation) as GameObject;
            obj.rigidbody.AddForce(target.forward * 50);

            #region Atack Sound Switch
            if (AtackSound)
            {
                SihirSounds.PlaySound (0);
                AtackSound = false;
            }
            else
            {
                SihirSounds.PlaySound (1);
                AtackSound = true;
            }
            #endregion

            castspell.selo = "";
            hp.curHealth -= hp.maxHealth/8;
            trsihir.SendMessage("Attack", SendMessageOptions.DontRequireReceiver);
            Destroy(obj, 3);

        }
    }

		protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
		{
			var caster = creatingCast.CasterReference.Object as Unit;
			if (caster == null)
			{
				failReason = SpellFailedReason.BadTargets;
			}
			else
			{
				if (!(target is NPC))
				{
					LogManager.GetCurrentClassLogger().Warn("{0} tried to Charm {1} which is not an NPC, but Player charming is not yet supported.", caster, target);
					failReason = SpellFailedReason.BadTargets;
				}
				if (caster.Charm != null)
				{
					failReason = SpellFailedReason.AlreadyHaveCharm;
				}
				else if (target.HasMaster)
				{
					failReason = SpellFailedReason.CantBeCharmed;
				}
				//else if (caster.Level < EffectValue)
				//{
				//    failReason = SpellFailedReason.Highlevel;
				//}
				else if (caster.HasMaster)
				{
					failReason = SpellFailedReason.Charmed;
				}
				else if (caster is Character)
				{
					if (((Character)caster).ActivePet != null)
					{
						failReason = SpellFailedReason.AlreadyHaveSummon;
					}
				}
			}
		}

		protected internal override void Apply()
		{
			if (spell == null)
			{
				var channel = m_aura.Controller as SpellChannel;
				if (channel != null)
				{
					origCast = channel.Cast;
				}
				else
				{
					origCast = m_aura.Auras.Owner.SpellCast;
				}

				if (origCast == null)
				{
					return;
					//throw new Exception("Cannot apply a Periodic Trigger Spell Aura on anyone but the Caster");
				}

				spell = m_spellEffect.TriggerSpell;
				if (spell == null)
				{
					LogManager.GetCurrentClassLogger().Warn("Found invalid periodic TriggerSpell in Spell {0} ({1}) ",
						m_spellEffect.Spell, 
						(uint)m_spellEffect.TriggerSpellId);
					return;
				}
			}

			cast = SpellCast.ObtainPooledCast(origCast.Caster);
			cast.TargetLoc = origCast.TargetLoc;
			cast.Selected = origCast.Selected;
			//cast.Start(spell, m_spellEffect, true);
			cast.Start(spell, true);
		}