C# ISpell.GetType方法代码示例

        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;
        }

        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 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 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 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;
        }

 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 void CastSpell(Player player, ISpell spell)
 {
     player.CastSpell(spell);
     if (spell.GetType() == typeof (Shield))
     {
         player.IsShielded = true;
     }
     if (!spell.Target.IsShielded)
     {
         spell.Target.Health -= spell.Damage;
     }
     
 }

		public static int GetRegistryNumber( ISpell s )
		{
			return GetRegistryNumber( s.GetType() );
		}

		public static int GetRegistryNumber( ISpell s ) {
			Type[] t = SpellRegistry.Types;

			for( int i = 0; i < t.Length; i++ ) {
				if( s.GetType() == t[i] )
					return i;
			}

			return -1;
		}

		public virtual bool CheckSpellCast(Mobile caster, ISpell spell)
		{
			if (caster == null || caster.Deleted || spell == null)
			{
				return false;
			}

			if (!DebugMode && caster.AccessLevel >= AccessLevel.Counselor)
			{
				return true;
			}

			if (!(spell is Spell))
			{
				return true;
			}

			if (!Options.Rules.CanFly)
			{
				var t = spell.GetType();

				if (t.Name.ContainsAny("FlySpell", "FlightSpell"))
				{
					return false;
				}
			}

			return !Options.Restrictions.Spells.IsRestricted((Spell)spell);
		}

		protected override void OnSpellCastDeny(Mobile caster, ISpell spell)
		{
			if (Crystal != null && !Crystal.Deleted && Crystal.Carrier == caster && spell != null)
			{
				Type st = spell.GetType();

				if (_NoCarrySpellCasts.Contains(st))
				{
					string name = spell is Spell ? ((Spell)spell).Name : st.Name.Replace("Spell", String.Empty).SpaceWords();

					caster.SendMessage(33, "You cannot cast {0} while holding the Crystal of Power!", name);
					return;
				}
			}

			base.OnSpellCastDeny(caster, spell);
		}

		public override bool CheckSpellCast(Mobile caster, ISpell spell)
		{
			if (!base.CheckSpellCast(caster, spell))
			{
				return false;
			}

			if (Crystal != null && !Crystal.Deleted && Crystal.Carrier == caster && spell != null && _NoCarrySpellCasts.Contains(spell.GetType()))
			{
				return false;
			}

			return true;
		}

		public static SpellInfo GetSpellInfo(ISpell s)
		{
			return s != null ? GetSpellInfo(s.GetType()) : null;
		}

		public static int GetRegistryNumber(ISpell s)
		{
			return s != null ? GetRegistryNumber(s.GetType()) : -1;
		}