Example #1
0
        public SplinteringWeaponContext(Mobile from, Mobile defender, Item weapon)
            : base(from, defender, weapon, EffectsType.Splintering, TimeSpan.FromSeconds(4), TimeSpan.FromSeconds(4))
        {
            StartForceWalk(defender);

            if (Core.EJ)
            {
                if (!(defender is PlayerMobile) || !IsBleedImmune(defender))
                {
                    BleedAttack.BeginBleed(defender, from, true);
                    AddBleedImmunity(defender);
                }
            }
            else
            {
                BleedAttack.BeginBleed(defender, from, true);
            }

            defender.SendLocalizedMessage(1112486); // A shard of the brittle weapon has become lodged in you!
            from.SendLocalizedMessage(1113077);     // A shard of your blade breaks off and sticks in your opponent!

            Server.Effects.PlaySound(defender.Location, defender.Map, 0x1DF);

            BuffInfo.AddBuff(defender, new BuffInfo(BuffIcon.SplinteringEffect, 1154670, 1152144, TimeSpan.FromSeconds(10), defender));
        }
Example #2
0
        public override void OnHit(Mobile attacker, Mobile defender, int damage)
        {
            if (!Validate(attacker) || !CheckMana(attacker, true))
            {
                return;
            }

            ClearCurrentMove(attacker);

            // Necromancers under Lich or Wraith Form are immune to Bleed Attacks.
            TransformContext context = TransformationSpellHelper.GetContext(defender);

            if ((context != null && (context.Type == typeof(LichFormSpell) || context.Type == typeof(WraithFormSpell))) ||
                (defender is BaseCreature && ((BaseCreature)defender).BleedImmune))
            {
                attacker.SendLocalizedMessage(1062052);                   // Your target is not affected by the bleed attack!
                return;
            }

            attacker.SendLocalizedMessage(1060159);               // Your target is bleeding!
            defender.SendLocalizedMessage(1060160);               // You are bleeding!

            if (defender is PlayerMobile)
            {
                defender.LocalOverheadMessage(MessageType.Regular, 0x21, 1060757);                   // You are bleeding profusely
                defender.NonlocalOverheadMessage(MessageType.Regular, 0x21, 1060758, defender.Name); // ~1_NAME~ is bleeding profusely
            }

            defender.PlaySound(0x133);
            defender.FixedParticles(0x377A, 244, 25, 9950, 31, 0, EffectLayer.Waist);

            BleedAttack.BeginBleed(defender, attacker, (AosWeaponAttributes.GetValue(attacker, AosWeaponAttribute.BloodDrinker) != 0));
        }
Example #3
0
        public SplinteringWeaponContext(Mobile from, Mobile defender, Item weapon)
            : base(from, defender, weapon, EffectsType.Splintering, TimeSpan.FromSeconds(4), TimeSpan.FromSeconds(4))
        {
            StartForceWalk(defender);
            BleedAttack.BeginBleed(defender, from, true);

            defender.SendLocalizedMessage(1112486); // A shard of the brittle weapon has become lodged in you!
            Server.Effects.PlaySound(from.Location, from.Map, 0x1DF);

            BuffInfo.AddBuff(defender, new BuffInfo(BuffIcon.SplinteringEffect, 1154670, 1152144, TimeSpan.FromSeconds(10), defender));
        }
Example #4
0
        public override void OnHit(Mobile attacker, Mobile defender, double damageBonus)
        {
            base.OnHit(attacker, defender, damageBonus);

            if (attacker != null && defender != null)
            {
                // No special effects 90% of the time for players
                if (attacker.Player && attacker.AccessLevel == AccessLevel.Player && Utility.RandomDouble() < 0.90)
                {
                    return;
                }

                // Always bleed.
                if (!BleedAttack.IsBleeding(defender))
                {
                    // Necromancers under Lich or Wraith Form are immune to Bleed Attacks.
                    TransformContext context = TransformationSpellHelper.GetContext(defender);

                    if ((context != null && (context.Type == typeof(LichFormSpell) || context.Type == typeof(WraithFormSpell))) ||
                        (defender is BaseCreature && ((BaseCreature)defender).BleedImmune))
                    {
                        return;
                    }
                    else if (defender is PlayerMobile)
                    {
                        defender.LocalOverheadMessage(MessageType.Regular, 0x21, 1060757);                           // You are bleeding profusely
                        defender.NonlocalOverheadMessage(MessageType.Regular, 0x21, 1060758, defender.Name);         // ~1_NAME~ is bleeding profusely
                    }

                    defender.PlaySound(0x133);
                    defender.FixedParticles(0x377A, 244, 25, 9950, 31, 0, EffectLayer.Waist);

                    BleedAttack.BeginBleed(defender, attacker, true);
                }

                // 20% chance of Mortal Strike, costs 10 stam each use but cannot be used if you have < 80 stam.
                if (Utility.RandomDouble() > 0.80 && attacker.Stam > 79 && !MortalStrike.IsWounded(defender))
                {
                    MortalStrike.BeginWound(defender, TimeSpan.FromSeconds(6.0));

                    attacker.SendLocalizedMessage(1060086);                       // You deliver a mortal wound!
                    defender.SendLocalizedMessage(1060087);                       // You have been mortally wounded!

                    defender.PlaySound(0x1E1);
                    defender.FixedParticles(0x37B9, 244, 25, 9944, 31, 0, EffectLayer.Waist);

                    attacker.Stam -= 15;
                }
            }
        }
        public static void ApplyDamageEffect(Mobile defender, Mobile attacker, AmmoTypes typeAmmo)
        {
            double luck = attacker.Luck * .02;

            int physicaldamage = (int)((100 - defender.GetResistance(ResistanceType.Physical)) * .07 + luck);
            int colddamage     = (int)((100 - defender.GetResistance(ResistanceType.Cold)) * .07 + luck);
            int firedamage     = (int)((100 - defender.GetResistance(ResistanceType.Fire)) * .07 + luck);
            int poisondamage   = (int)((100 - defender.GetResistance(ResistanceType.Poison)) * .07 + luck);
            int energydamage   = (int)((100 - defender.GetResistance(ResistanceType.Energy)) * .07 + luck);

            if (physicaldamage < 1)
            {
                physicaldamage = 1;
            }
            if (colddamage < 1)
            {
                colddamage = 1;
            }
            if (firedamage < 1)
            {
                firedamage = 1;
            }
            if (poisondamage < 1)
            {
                poisondamage = 1;
            }
            if (energydamage < 1)
            {
                energydamage = 1;
            }

            switch (typeAmmo)
            {
            case AmmoTypes.Oak:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage, attacker);
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(1, 5), 100, 0, 0, 0, 0);
                }

                break;
            }

            case AmmoTypes.Yew:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage + 3, attacker);
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(3, 6), 100, 0, 0, 0, 0);
                }

                break;
            }

            case AmmoTypes.Ash:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    SpellHelper.Damage(new FireballSpell(attacker, null), defender, Utility.RandomMinMax(10, 30), 0, 100, 0, 0, 0);
                    attacker.MovingParticles(defender, 0x36D4, 7, 0, false, true, 9502, 4019, 0x160);
                    attacker.PlaySound(Core.AOS ? 0x15E : 0x44B);
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(1, 5), 0, 100, 0, 0, 0);
                }

                break;
            }

            case AmmoTypes.Bloodwood:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.PlaySound(0x133);
                    defender.FixedParticles(0x377A, 244, 25, 9950, 31, 0, EffectLayer.Waist);
                    BleedAttack.BeginBleed(defender, attacker);
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(1, 5), 100, 0, 0, 0, 0);
                }

                break;
            }

            case AmmoTypes.Heartwood:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.PlaySound(0xDD);
                    defender.FixedParticles(0x3728, 244, 25, 9941, 1266, 0, EffectLayer.Waist);

                    if (attacker.Skills[SkillName.Poisoning].Value > Utility.RandomMinMax(50, 250))
                    {
                        defender.ApplyPoison(attacker, Poison.Deadly);
                    }
                    else
                    {
                        defender.ApplyPoison(attacker, Poison.Regular);
                    }
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(1, 5), 0, 0, 0, 100, 0);
                }

                break;
            }

            case AmmoTypes.Frostwood:
            {
                if ((0.15 + luck) > Utility.RandomDouble())
                {
                    TimeSpan duration = defender.Player ? TimeSpan.FromSeconds(4) : TimeSpan.FromSeconds(8);
                    defender.Paralyze(duration);
                    ParalyzingBlow.BeginImmunity(defender, duration + TimeSpan.FromSeconds(4));
                    defender.FixedEffect(0x376A, 9, 32);
                    defender.PlaySound(0x204);
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(1, 5), 0, 100, 15, 0, 0);
                }

                break;
            }

            case AmmoTypes.DullCopper:
            {
                if ((0.3 + luck) > Utility.RandomDouble())
                {
                    AOS.Damage(defender, Utility.RandomMinMax(8, 18), true, 100, 0, 0, 0, 0);
                    defender.FixedParticles(0x3728, 1, 26, 0x26D6, 0, 0, EffectLayer.Waist);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, Utility.Random(1, 8), 100, 0, 0, 0, 0);
                }

                break;
            }

            case AmmoTypes.ShadowIron:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(energydamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 0, 0, 0, 0, 40);
                }
                break;
            }

            case AmmoTypes.Copper:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(energydamage, attacker);
                    defender.Damage(poisondamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 0, 0, 0, 30, 30);
                }
                break;
            }

            case AmmoTypes.Bronze:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage, attacker);
                    defender.Damage(firedamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 15, 40, 0, 0, 0);
                }
                break;
            }

            case AmmoTypes.Gold:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage, attacker);
                    defender.Damage(firedamage, attacker);
                    defender.Damage(colddamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 20, 15, 15, 0, 0);
                }
                break;
            }

            case AmmoTypes.Agapite:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage, attacker);
                    defender.Damage(firedamage, attacker);
                    defender.Damage(energydamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 25, 30, 0, 0, 20);
                }
                break;
            }

            case AmmoTypes.Verite:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage, attacker);
                    defender.Damage(poisondamage, attacker);
                    defender.Damage(energydamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 30, 0, 0, 40, 20);
                }
                break;
            }

            case AmmoTypes.Valorite:
            {
                if ((0.1 + luck) > Utility.RandomDouble())
                {
                    defender.Damage(physicaldamage, attacker);
                    defender.Damage(firedamage, attacker);
                    defender.Damage(colddamage, attacker);
                    defender.Damage(poisondamage, attacker);
                    defender.Damage(energydamage, attacker);
                    defender.PlaySound(0x56);
                }
                else
                {
                    AOS.Damage(defender, 5, 50, 10, 20, 10, 20);
                }
                break;
            }

            default: break;
            }
        }