C# Mobile.GetType方法代码示例

		public void Target( Mobile m )
		{
			Type t = m.GetType();
			bool dispellable = false;

			if ( m is BaseCreature )
				dispellable = ((BaseCreature)m).Summoned;

			if ( !Caster.CanSee( m ) )
			{
				Caster.SendLocalizedMessage( 500237 ); // Target can not be seen.
			}
			else if ( !dispellable )
			{
				Caster.SendLocalizedMessage( 1005049 ); // That cannot be dispelled.
			}
			else if ( CheckHSequence( m ) )
			{
				SpellHelper.Turn( Caster, m );

				if ( CheckResisted( m ) )
				{
					m.FixedEffect( 0x3779, 10, 20 );
				}
				else
				{
					Effects.SendLocationParticles( EffectItem.Create( m.Location, m.Map, EffectItem.DefaultDuration ), 0x3728, 8, 20, 5042 );
					Effects.PlaySound( m, m.Map, 0x201 );

					m.Delete();
				}
			}

			FinishSequence();
		}

        public void Target( Mobile m )
        {
            Type t = m.GetType();
            bool dispellable = false;

            if ( m is BaseCreature )
                dispellable = ((BaseCreature)m).Summoned && !((BaseCreature)m).IsAnimatedDead;

            if ( !Caster.CanSee( m ) )
            {
                Caster.SendLocalizedMessage( 500237 ); // Target can not be seen.
            }
            else if ( !dispellable )
            {
                Caster.SendLocalizedMessage( 1005049 ); // That cannot be dispelled.
            }
            else if ( CheckHSequence( m ) )
            {
                SpellHelper.Turn( Caster, m );

                int diff;
                if ( m is Daemon )
                    diff = 95;
                else if ( m is EnergyVortex )
                    diff = 80;
                else if ( m is FireElemental || m is WaterElemental || m is AirElemental || m is EarthElemental )
                    diff = 75;
                else if ( m is BladeSpirit )
                    diff = 50;
                else
                    diff = 0;

                if ( Caster.Skills[SkillName.Magery].Value >= Utility.Random( 41 )-20+diff )
                {
                    Effects.SendLocationParticles( EffectItem.Create( m.Location, m.Map, EffectItem.DefaultDuration ), 0x3728, 8, 20, 5042 );
                    Effects.PlaySound( m, m.Map, 0x201 );

                    m.Delete();
                }
                else
                {
                    m.Animate( 14201, 10, 20, true, false, 0 );
                    Caster.SendAsciiMessage( "{0} resisted the attempt to dispell it!", m.Name );
                }
            }

            FinishSequence();
        }

        public void Target( Mobile m )
        {
            Type t = m.GetType();
            bool dispellable = false;

            if ( m is BaseCreature )
                dispellable = ((BaseCreature)m).Summoned && !((BaseCreature)m).IsAnimatedDead;

            if ( !Caster.CanSee( m ) )
            {
                Caster.SendAsciiMessage( "Target can not be seen." );
            }
            else if ( !dispellable )
            {
                Caster.SendAsciiMessage( "That cannot be dispelled." );
            }
            else if ( CheckHSequence( m ) )
            {
                SpellHelper.Turn( Caster, m );

                BaseCreature bc = m as BaseCreature;

                double dispelChance = 0;

                if ( bc != null )
                    dispelChance = (50.0 + ((100 * (Caster.Skills.Magery.Value - bc.DispelDifficulty)) / (bc.DispelFocus*2))) / 100;

                if ( dispelChance > Utility.RandomDouble() )
                {
                    Effects.SendLocationParticles( EffectItem.Create( m.Location, m.Map, EffectItem.DefaultDuration ), 0x3728, 8, 20, 5042 );
                    Effects.PlaySound( m, m.Map, 0x201 );

                    m.Delete();
                }
                else
                {
                    m.FixedEffect( 0x3779, 10, 20 );
                    Caster.SendAsciiMessage( "The creature resisted the attempt to dispel it!" );
                }
            }

            FinishSequence();
        }

        public int GetRankFor(Mobile m)
        {
            Type[][] types = ChampionSpawnInfo.GetInfo(this.m_Type).SpawnTypes;
            Type t = m.GetType();

            for (int i = 0; i < types.GetLength(0); i++)
            {
                Type[] individualTypes = types[i];

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

            return -1;
        }

        public virtual void OnHit( Mobile attacker, Mobile defender )
        {
            PlaySwingAnimation( attacker );
            PlayHurtAnimation( defender );

            attacker.PlaySound( GetHitAttackSound( attacker, defender ) );
            defender.PlaySound( GetHitDefendSound( attacker, defender ) );

            int damage = ComputeDamage( attacker, defender );

            CheckSlayerResult cs = CheckSlayers( attacker, defender );

            if ( cs != CheckSlayerResult.None )
            {
                if ( cs == CheckSlayerResult.Slayer )
                    defender.FixedEffect( 0x37B9, 10, 5 );

                damage *= 2;
            }

            if ( !attacker.Player )
            {
                if ( defender is PlayerMobile )
                {
                    PlayerMobile pm = (PlayerMobile)defender;

                    if ( pm.EnemyOfOneType != null && pm.EnemyOfOneType != attacker.GetType() )
                        damage *= 2;
                }
            }
            else if ( !defender.Player )
            {
                if ( attacker is PlayerMobile )
                {
                    PlayerMobile pm = (PlayerMobile)attacker;

                    if ( pm.WaitingForEnemy )
                    {
                        pm.EnemyOfOneType = defender.GetType();
                        pm.WaitingForEnemy = false;
                    }

                    if ( pm.EnemyOfOneType == defender.GetType() )
                    {
                        defender.FixedEffect( 0x37B9, 10, 5, 1160, 0 );
                        damage += AOS.Scale( damage, 50 );
                    }
                }
            }

            int packInstinctBonus = GetPackInstinctBonus( attacker, defender );

            if ( packInstinctBonus != 0 )
                damage += AOS.Scale( damage, packInstinctBonus );

            if ( m_InDoubleStrike )
                damage -= AOS.Scale( damage, 10 ); // 10% loss when attacking with double-strike

            TransformContext context = TransformationSpell.GetContext( defender );

            if ( m_Slayer == SlayerName.Silver && context != null && context.Type != typeof( HorrificBeastSpell ) )
                damage += AOS.Scale( damage, 25 ); // Every necromancer transformation other than horrific beast take an additional 25% damage

            if ( attacker is BaseCreature )
                ((BaseCreature)attacker).AlterMeleeDamageTo( defender, ref damage );

            if ( defender is BaseCreature )
                ((BaseCreature)defender).AlterMeleeDamageFrom( attacker, ref damage );

            WeaponAbility a = WeaponAbility.GetCurrentAbility( attacker );

            damage = AbsorbDamage( attacker, defender, damage );

            if ( !Core.AOS && damage < 1 )
                damage = 1;
            else if ( Core.AOS && damage == 0 ) // parried
            {
                if ( a != null && a.Validate( attacker ) /*&& a.CheckMana( attacker, true )*/ ) // Parried special moves have no mana cost
                {
                    a = null;
                    WeaponAbility.ClearCurrentAbility( attacker );

                    attacker.SendAsciiMessage( "Your attack was parried!" );
                }
            }

            AddBlood( attacker, defender, damage );

            int phys, fire, cold, pois, nrgy;

            GetDamageTypes( attacker, out phys, out fire, out cold, out pois, out nrgy );

            if ( m_Consecrated )
            {
                phys = defender.PhysicalResistance;
                fire = defender.FireResistance;
                cold = defender.ColdResistance;
                pois = defender.PoisonResistance;
                nrgy = defender.EnergyResistance;

//.........这里部分代码省略.........

		public virtual void OnHit(Mobile attacker, Mobile defender, double damageBonus)
		{
			if (MirrorImage.HasClone(defender) && (defender.Skills.Ninjitsu.Value / 150.0) > Utility.RandomDouble())
			{
				Clone bc;

				foreach (Mobile m in defender.GetMobilesInRange(4))
				{
					bc = m as Clone;

					if (bc != null && bc.Summoned && bc.SummonMaster == defender)
					{
						attacker.SendLocalizedMessage(1063141); // Your attack has been diverted to a nearby mirror image of your target!
						defender.SendLocalizedMessage(1063140); // You manage to divert the attack onto one of your nearby mirror images.

						/*
                        * TODO: What happens if the Clone parries a blow?
                        * And what about if the attacker is using Honorable Execution
                        * and kills it?
                        */

						defender = m;
						break;
					}
				}
			}

			PlaySwingAnimation(attacker);
			PlayHurtAnimation(defender);

			attacker.PlaySound(GetHitAttackSound(attacker, defender));
			defender.PlaySound(GetHitDefendSound(attacker, defender));

			int damage = ComputeDamage(attacker, defender);

			#region Damage Multipliers
			/*
            * The following damage bonuses multiply damage by a factor.
            * Capped at x3 (300%).
            */
			int percentageBonus = 0;

			WeaponAbility a = WeaponAbility.GetCurrentAbility(attacker);
			SpecialMove move = SpecialMove.GetCurrentMove(attacker);

			if (a != null)
			{
				percentageBonus += (int)(a.DamageScalar * 100) - 100;
			}

			if (move != null)
			{
				percentageBonus += (int)(move.GetDamageScalar(attacker, defender) * 100) - 100;
			}

			percentageBonus += (int)(damageBonus * 100) - 100;

			CheckSlayerResult cs = CheckSlayers(attacker, defender);

			if (cs != CheckSlayerResult.None)
			{
				if (cs == CheckSlayerResult.Slayer)
				{
					defender.FixedEffect(0x37B9, 10, 5);
				}

				percentageBonus += 100;
			}

			if (!attacker.Player)
			{
				if (defender is PlayerMobile)
				{
					PlayerMobile pm = (PlayerMobile)defender;

					if (pm.EnemyOfOneType != null && pm.EnemyOfOneType != attacker.GetType())
					{
						percentageBonus += 100;
					}
				}
			}
			else if (!defender.Player)
			{
				if (attacker is PlayerMobile)
				{
					PlayerMobile pm = (PlayerMobile)attacker;

					if (pm.WaitingForEnemy)
					{
						pm.EnemyOfOneType = defender.GetType();
						pm.WaitingForEnemy = false;
					}

					if (pm.EnemyOfOneType == defender.GetType())
					{
						defender.FixedEffect(0x37B9, 10, 5, 1160, 0);

						percentageBonus += 50;
					}
				}
//.........这里部分代码省略.........

		public bool Slays(Mobile m)
		{
			Type t = m.GetType();

			return Types.Any(t1 => t1.IsAssignableFrom(t));
		}

        public override void OnKill(Mobile killed, Mobile killer)
        {
            base.OnKill(killed, killer);

            // supports ignoring XmlPoints challenges
            if (this.m_ChallengeStatus)
            {
                this.m_ChallengeStatus = false;
                return;
            }

            if (killed == null || killer == null || killer == killed)
                return;
		    
            // check for within guild kills and ignore them
            if (this.SameGuild(killed, killer))
                return;

            // this calculates the base faction level that will be gained/lost based upon the fame of the killed mob
            double value = (double)(killed.Fame / 1000.0);
            if (value <= 0)
                value = 1;

            // calculates credits gained in a similar way
            int cval = (int)(killed.Fame * m_CreditScale);
            if (cval <= 0)
                cval = 1;

            this.Credits += cval;

            // prepare the group lists that will be checked for faction
            ArrayList glist = null;
            ArrayList dglist = null;

            // check to see whether this mob type has already been hashed into a group list
            if (GroupHash.Contains(killed.GetType()))
            {
                glist = (ArrayList)GroupHash[killed.GetType()];
            }
            else
            {
                // otherwise look it up the slow way and prepare a hash entry for it at the same time
                // unless it is using dynamic faction
                glist = new ArrayList();
                foreach (Group g in KillGroups)
                {
                    if (MatchType(g.Members, killed))
                    {
                        glist.Add(g);
                    }
                }
                GroupHash.Add(killed.GetType(), glist);
            }

            // have to look up dynamic factions the exhaustive way
            // does this mob have dynamic faction assignments?
            ArrayList list = XmlAttach.FindAttachments(XmlAttach.MobileAttachments, killed, typeof(XmlDynamicFaction));
            if (list != null && list.Count > 0)
            {
                //if(XmlAttach.FindAttachment(XmlAttach.MobileAttachments, killed, typeof(XmlDynamicFaction)) != null)
                //{
                dglist = new ArrayList();
                foreach (Group g in KillGroups)
                {
                    if (DynamicMatchType(g.Members, killed))
                    {
                        dglist.Add(g);
                    }
                }
            }

            ArrayList alist = new ArrayList();
            if (glist != null && glist.Count > 0)
                alist.Add(glist);
            if (dglist != null && dglist.Count > 0)
                alist.Add(dglist);

            //  go through this with static and dynamic factions
            foreach (ArrayList al in alist)
            {
                foreach (Group g in al)
                {
                    // tabulate the faction loss from target group allies
                    if (g.Allies != null && g.Allies.Length > 0)
                    {
                        for (int i = 0; i < g.Allies.Length; i++)
                        {
                            Group ally = g.Allies[i];

                            int facloss = 0;
                            try
                            {
                                facloss = (int)(value * g.AllyLoss[i]);
                            }
                            catch
                            {
                            }
                            if (facloss <= 0)
                                facloss = 1;
        
//.........这里部分代码省略.........

        public virtual bool IsObjective(Mobile mob)
        { 
            if (this.m_Creature == null)
                return false;
		
            if (this.m_Creature.IsAssignableFrom(mob.GetType()))
            {
                if (this.m_Region != null && !this.m_Region.Contains(mob.Location))
                    return false;
					
                return true;
            }
			
            return false;
        }

			private static void CopyMobProperties ( Mobile dest, Mobile src )
			{
				PropertyInfo[] props = src.GetType().GetProperties();

				for ( int i = 0; i < props.Length; i++ )
				{
					if ( props[i].CanRead && props[i].CanWrite )
						props[i].SetValue( dest, props[i].GetValue( src, null ), null );
				}
			}

        private static bool MatchType(ArrayList array, Mobile m)
        {
            if (array == null || m == null)
                return false;

            foreach (object o in array)
            {
                if (o is Type && ((Type)o == m.GetType() || ((Type)o).IsSubclassOf(m.GetType())))
                    return true;
            }
            return false;
        }

        public String GetPetKind(Mobile pet)
        {
            if (pet == null || pet.Deleted)
            {
                return "";
            }

            String petclass = pet.GetType().ToString();
            var rx = new Regex(@"^.*\.(?<pc>.*)$");
            Match m = rx.Match(petclass);

            return m.Groups["pc"].Value;
        }

        public override bool IgnoreYoungProtection(Mobile from)
        {
            if (this.Completed)
                return false;

            IngredientInfo info = IngredientInfo.Get(this.Ingredient);
            Type fromType = from.GetType();

            for (int i = 0; i < info.Creatures.Length; i++)
            {
                if (fromType == info.Creatures[i])
                    return true;
            }

            return false;
        }

        public Item Mutate(Mobile from, int luckChance, Item item)
        {
            if (item == null)
                return null;

            if (item is BaseWeapon)
            {
                BaseWeapon weapon = (BaseWeapon)item;

                //Taran: Below we remove the items we don't want mobs to drop
                while (weapon is BaseKnife || weapon is Pickaxe || weapon is Hatchet || weapon is BaseStaff)
                {
                    weapon.Delete();
                    weapon = BaseWeapon.CreateRandomWeapon();
                }

                if (m_WeaponModifiers != null)
                    m_WeaponModifiers.Mutate(weapon);

                //if (5 > Utility.Random(100))
                //   weapon.Slayer = SlayerName.Silver;

                //if (from != null && weapon.AccuracyLevel == 0 && weapon.DamageLevel == 0 && weapon.DurabilityLevel == 0 && weapon.Slayer == SlayerName.None && 5 > Utility.Random(100))
                //    weapon.Slayer = SlayerGroup.GetLootSlayerType(from.GetType());

                weapon.Identified = true;
            }
            else if (item is BaseArmor)
            {
                BaseArmor armor = (BaseArmor)item;

                if (m_ArmorModifiers != null)
                    m_ArmorModifiers.Mutate(armor);

                armor.Identified = true;
            }
            else if (item is BaseInstrument)
            {
                SlayerName slayer = SlayerGroup.GetLootSlayerType(from.GetType());

                if (slayer == SlayerName.None)
                {
                    item.Delete();
                    return null;
                }

                BaseInstrument instr = (BaseInstrument)item;

                instr.Quality = InstrumentQuality.Regular;
                instr.Slayer = slayer;
            }

            return item;
        }

        public static bool Slays(TalismanSlayerName name, Mobile m)
        {

            if (m.SpecialSlayerMechanics)
            {
                if (m.SlayerVulnerabilities.Contains(name.ToString()))
                    return true;
                else
                    return false;
                
            }

            if (!m_Table.ContainsKey(name))
                return false;

            Type[] types = m_Table[name];
			
            if (types == null || m == null)
                return false;

            Type type = m.GetType();

            for (int i = 0; i < types.Length; i++)
            {
                if (types[i].IsAssignableFrom(type))
                    return true;
            }

            return false;
        }