public override bool OnBeginSpellCast( Mobile m, ISpell s )
        {
            if (!CTFGame.Running)
            {
                m.SendMessage( CTFGame.HuePerson, "You cannot cast spells until the game has started." );
                return false;
            }
            else if( CTFGame.GetFlag( m ) != null && s is InvisibilitySpell)
            {
                m.SendMessage( CTFGame.HuePerson, "You cannot use invisibility spell while carrying a flag." );
                return false;
            }
            else if ( m.AccessLevel == AccessLevel.Player &&
                ( s is MarkSpell || s is RecallSpell || s is GateTravelSpell || s is PolymorphSpell ||
                s is SummonDaemonSpell || s is AirElementalSpell || s is EarthElementalSpell || s is EnergyVortexSpell ||
                s is FireElementalSpell || s is WaterElementalSpell || s is BladeSpiritsSpell || s is SummonCreatureSpell ||
                s is EnergyFieldSpell || s is ResurrectionSpell || s is LichFormSpell || s is HorrificBeastSpell || s is WraithFormSpell ||
                s is VengefulSpiritSpell || s is SummonFamiliarSpell || s is SacredJourneySpell
                ) )
            {
                m.SendMessage( CTFGame.HuePerson, "That spell is not allowed here." );
                return false;
            }

            else if (((Spell)s).Info.Name == "Ethereal Mount")
            {
                m.SendMessage("You cannot mount your ethereal here.");
                return false;
            }

            return base.OnBeginSpellCast( m, s );
        }

        public override bool OnBeginSpellCast( Mobile from, ISpell s )
        {
            if ( from.AccessLevel == AccessLevel.Player )
                from.SendLocalizedMessage( 502629 ); // You cannot cast spells here.

            return ( from.AccessLevel > AccessLevel.Player );
        }

        public bool SpellAllowed(ISpell s)
        {
            Type stype = s.GetType();

            foreach (Type type in m_BeneficialTypes)
                if (type == stype)
                {
                    m_Spell = s.GetType();
                    return true;
                }

            if (s.GetType() == m_Spell)
                m_CastCount++;

            else
            {
                m_Spell = s.GetType();
                m_CastCount = 1;
            }

            if (m_CastCount > 3)
            {
                m_Part.SendMessage("You have already tried to cast that spell three times in a row!");
                return false;
            }

            return true;
        }

        public override bool OnBeginSpellCast(Mobile from, ISpell s)
        {
            if (from.IsPlayer())
                from.SendLocalizedMessage(502629); // You cannot cast spells here.

            return (from.IsStaff());
        }

        public override bool OnBeginSpellCast(Mobile from, ISpell s)
        {
            if (s is GateTravelSpell || s is RecallSpell || s is MarkSpell || s is InvisibilitySpell)
                return false;

            return true;
        }

        protected void ValidateAttack(ISpell spellToCast)
        {
            if (this.Unit.EnergyPoints < spellToCast.EnergyCost)
                throw new NotEnoughEnergyException(string.Format("{0} does not have enough energy to cast {1}", unit.Name, spellToCast.GetType().Name));

            unit.EnergyPoints -= spellToCast.EnergyCost;
        }

 public void ValidateEnergy(ISpell attack)
 {
     if (this.Unit.EnergyPoints - attack.EnergyCost < 0)
        {
        throw new NotEnoughEnergyException(String.Format(GlobalMessages.NotEnoughEnergy, this.Unit.Name,
            attack.GetType().Name));
        }
 }

 public override bool OnBeginSpellCast( Mobile from, ISpell s )
 {
     if( from.AccessLevel > AccessLevel.Player )
     {
         return false;
     }
     return _BoardGameControlItem.CanCastSpells;
 }

 public bool CastSpell(ISpell spell, Point target)
 {
     m_engine.BeforePlayerAction();
     bool didAnything = m_engine.CastSpell(m_engine.Player, (Spell)spell, target);
     if (didAnything)
         m_engine.AfterPlayerAction();
     return didAnything;
 }

 public void ValidateEnergyPoints(IUnit unit, ISpell spell)
 {
     if (unit.EnergyPoints < spell.EnergyCost)
     {
         throw new NotEnoughEnergyException(
             string.Format("{0} does not have enough energy to cast {1}", unit.Name, spell.GetType().Name));
     }
 }

 public override bool OnBeginSpellCast(Mobile m, ISpell s)
 {
     if (m.Player && m.AccessLevel < AccessLevel.GameMaster)
     {
         FizzleStrangely(m);
         return false;
     }
     return base.OnBeginSpellCast(m, s);
 }

 public override bool OnBeginSpellCast(Mobile from, ISpell s)
 {
     if (from.AccessLevel == AccessLevel.Player)
     {
         from.SendMessage("You cannot cast spells on a race track.");
         return false;
     }
     return base.OnBeginSpellCast(from, s);
 }

 public override bool OnBeginSpellCast(Mobile m, ISpell s)
 {
     if (s is MarkSpell || s is GateTravelSpell)
     {
         m.SendMessage("You can not cast that here");
         return false;
     }
     return base.OnBeginSpellCast(m, s);
 }

 public override bool OnBeginSpellCast(Mobile m, ISpell s)
 {
     if ((s is GateTravelSpell || s is RecallSpell || s is MarkSpell || s is SacredJourneySpell) && m.AccessLevel == AccessLevel.Player)
     {
         m.SendMessage("You cannot cast that spell here.");
         return false;
     }
     return base.OnBeginSpellCast(m, s);
 }

 protected void IsThereEnoughEnergy(ISpell attack)
 {
     if (this.Unit.EnergyPoints < attack.EnergyCost)
     {
         throw new NotEnoughEnergyException(string.Format(
             GlobalMessages.NotEnoughEnergy,
             this.Unit.Name,
             attack.GetType().Name));
     }
 }

		public override bool OnBeginSpellCast( Mobile from, ISpell s )
		{
			Console.WriteLine( "Checking spellcast!" );
			if( from.AccessLevel > AccessLevel.Player )
			{
				return true;
			}
			return _BoardGameControlItem.CanCastSpells;
			
		}

        public static bool HasEnoughEnergy(IUnit unit, ISpell spell)
        {
            if (unit.EnergyPoints - spell.EnergyCost < 0)
            {
                var message = string.Format(GlobalMessages.NotEnoughEnergy, unit.Name, spell.GetType().Name);
                throw new NotEnoughEnergyException(message);
            }

            return true;
        }

		public override bool OnBeginSpellCast( Mobile m, ISpell s )
		{
			if ( s is MarkSpell && m.AccessLevel == AccessLevel.Player )
			{
				m.SendLocalizedMessage( 501800 ); // You cannot mark an object at that location.
				return false;
			}

			return base.OnBeginSpellCast( m, s );
		}

        public override bool OnBeginSpellCast(Mobile m, ISpell s)
        {
            if (s is Server.Spells.Sixth.MarkSpell)
            {
                m.SendMessage("Voce nao pode marcar runa aqui!");
                return false;
            }

            return base.OnBeginSpellCast(m, s);
        }

		public override bool OnBeginSpellCast( Mobile m, ISpell s )
		{
			if ( s is RecallSpell || s is SacredJourneySpell )
			{
				m.SendLocalizedMessage( 501802 ); // Thy spell doth not appear to work...
				return false;
			}

			return base.OnBeginSpellCast( m, s );
		}