예제 #1
0
        public static void HandleRangedAttack(Character chr, Packet packet)
        {
            //Program.MainForm.LogAppend("Handling Ranged");
            if (!ParseAttackData(chr, packet, out AttackData ad, AttackTypes.Ranged))
            {
                return;
            }

            int    TotalDamage;
            bool   died;
            double MaxPossibleDamage = 0;
            Mob    mob;

            SendRangedAttack(chr, ad);

            if (ad.SkillID != 0 || ad.StarID != 0)
            {
                chr.Skills.UseRangedAttack(ad.SkillID, ad.StarItemSlot);
            }

            foreach (var ai in ad.Attacks)
            {
                try
                {
                    TotalDamage = 0;
                    mob         = chr.Field.GetMob(ai.MobMapId);

                    if (mob != null)
                    {
                        foreach (int amount in ai.Damages)
                        {
                            mob.GiveDamage(chr, amount);
                            TotalDamage += amount;
                        }

                        if (TotalDamage != 0)
                        {
                            died = mob.CheckDead(ai.HitPosition, ai.HitDelay, chr.PrimaryStats.BuffMesoUP.N);


                            var sld = chr.Skills.GetSkillLevelData(ad.SkillID, out byte derp);
                            if (sld != null && derp == ad.SkillLevel)
                            {
                                long buffTime = sld.BuffTime * 1000;

                                if (!died)
                                {
                                    if (ad.SkillID == Constants.Hunter.Skills.ArrowBomb && !mob.IsBoss)
                                    {
                                        short chance = RNG.Range.generate((short)0, (short)100);

                                        if (chance < sld.Property)
                                        {
                                            var stat = mob.Status.BuffStun.Set(ad.SkillID, 1,
                                                                               MasterThread.CurrentTime + buffTime);
                                            MobPacket.SendMobStatsTempSet(mob, ai.HitDelay, stat);
                                        }
                                    }
                                }

                                if (ad.SkillID == Constants.Assassin.Skills.Drain)
                                {
                                    double hp = Math.Min(ai.Damages[0] * sld.XValue * 0.01, mob.MaxHP);
                                    hp = Math.Min(hp, chr.PrimaryStats.MaxHP / 2);
                                    chr.ModifyHP((short)(hp));
                                }

                                switch (ad.SkillID)
                                {
                                case Constants.Hunter.Skills.PowerKnockback:
                                case Constants.Crossbowman.Skills.PowerKnockback:
                                    MaxPossibleDamage = DamageFormula.MaximumPowerKnockbackDamage(chr, mob, TotalDamage);
                                    break;

                                case Constants.Hunter.Skills.ArrowBomb:
                                    MaxPossibleDamage =
                                        DamageFormula.MaximumArrowBombDamage(chr, mob, ad.StarID, TotalDamage);
                                    break;

                                case Constants.Rogue.Skills.LuckySeven:
                                    MaxPossibleDamage = DamageFormula.MaximumLuckySevenDamage(chr, mob, TotalDamage);
                                    break;

                                case Constants.Assassin.Skills.Drain:
                                    MaxPossibleDamage = 99999;     //Hotfix a bug that caused legit players to get autobanned. TODO check this properly!
                                    break;

                                default:
                                    MaxPossibleDamage = DamageFormula.MaximumRangedDamage(chr, mob, ad.SkillID, ad.StarID,
                                                                                          ad.Targets, TotalDamage);
                                    break;
                                }

                                if (TotalDamage > MaxPossibleDamage)
                                {
                                    if (ReportDamagehack(chr, ad, TotalDamage, (int)MaxPossibleDamage))
                                    {
                                        return;
                                    }
                                }
                            }
                        }
                    }
                }

                catch (Exception ex)
                {
                    //Program.MainForm.LogAppendFormat(ex.ToString());
                }
            }
        }
예제 #2
0
        public static void HandleMagicAttack(Character chr, Packet packet)
        {
            //Program.MainForm.LogAppend("Handling Magic");
            if (!ParseAttackData(chr, packet, out AttackData ad, AttackTypes.Magic))
            {
                return;
            }

            int    TotalDamage;
            double MaxSpellDamage;
            bool   died;
            Mob    mob;

            SendMagicAttack(chr, ad);


            if (ad.SkillID != 0)
            {
                chr.Skills.UseMeleeAttack(ad.SkillID, ad);
            }

            int StolenMP       = 0;
            int MpStealSkillID = chr.Skills.GetMpStealSkillData(2, out int MpStealProp, out int MpStealPercent, out byte MpStealLevel);

            foreach (var ai in ad.Attacks)
            {
                try
                {
                    TotalDamage = 0;
                    mob         = chr.Field.GetMob(ai.MobMapId);

                    if (mob == null)
                    {
                        continue;
                    }

                    foreach (int amount in ai.Damages)
                    {
                        mob.GiveDamage(chr, amount);
                        TotalDamage += amount;
                    }

                    if (MpStealPercent > 0)
                    {
                        StolenMP += mob.OnMobMPSteal(MpStealProp, MpStealPercent / ad.Targets);
                    }

                    if (TotalDamage == 0)
                    {
                        continue;
                    }

                    died = mob.CheckDead(ai.HitPosition, ai.HitDelay, chr.PrimaryStats.BuffMesoUP.N);

                    if (!died)
                    {
                        var  sld      = DataProvider.Skills[ad.SkillID].Levels[ad.SkillLevel];
                        long buffTime = sld.BuffTime * 1000;

                        //TODO refactor element code when we get the proper element loading with calcdamage branch
                        if ((sld.ElementFlags == SkillElement.Ice || ad.SkillID == Constants.ILMage.Skills.ElementComposition) && !mob.IsBoss)
                        {
                            var stat = mob.Status.BuffFreeze.Set(ad.SkillID, 1, MasterThread.CurrentTime + buffTime);
                            MobPacket.SendMobStatsTempSet(mob, ai.HitDelay, stat);
                        }

                        if (ad.SkillID == Constants.FPMage.Skills.ElementComposition && !mob.IsBoss)
                        {
                            if (Rand32.NextBetween(0, 100) < sld.Property)
                            {
                                mob.DoPoison(chr.ID, chr.Skills.GetSkillLevel(ad.SkillID), buffTime, ad.SkillID, sld.MagicAttack, ai.HitDelay);
                            }
                        }

                        if (ad.SkillID == Constants.FPWizard.Skills.PoisonBreath)
                        {
                            if (Rand32.NextBetween(0, 100) < sld.Property)
                            {
                                mob.DoPoison(chr.ID, chr.Skills.GetSkillLevel(ad.SkillID), buffTime, ad.SkillID, sld.MagicAttack, ai.HitDelay);
                            }
                        }

                        if (StolenMP > 0)
                        {
                            chr.ModifyMP((short)StolenMP);
                            MapPacket.SendPlayerSkillAnimSelf(chr, MpStealSkillID, MpStealLevel);
                            MapPacket.SendPlayerSkillAnim(chr, MpStealSkillID, MpStealLevel);
                        }
                    }

                    switch (ad.SkillID)
                    {
                    case Constants.Magician.Skills.MagicClaw:     // If the Spell is Magic Claw (since it registers two hits)
                        MaxSpellDamage = DamageFormula.MaximumSpellDamage(chr, mob, ad.SkillID) * 2;
                        break;

                    case Constants.Cleric.Skills.Heal:     // If the Spell is Heal (since it has a special snowflake calculation for it)
                        if (mob.Data.Undead == false)
                        {
                            chr.PermaBan("Heal damaging regular mobs exploit");
                            return;
                        }
                        MaxSpellDamage = DamageFormula.MaximumHealDamage(chr, mob, ad.Targets);
                        break;

                    default:
                        MaxSpellDamage = DamageFormula.MaximumSpellDamage(chr, mob, ad.SkillID);
                        break;
                    }

                    if (TotalDamage > MaxSpellDamage)
                    {
                        if (ReportDamagehack(chr, ad, TotalDamage, (int)MaxSpellDamage))
                        {
                            return;
                        }
                    }
                }

                catch (Exception ex)
                {
                    Program.MainForm.LogAppend(ex.ToString());
                }
            }
        }
예제 #3
0
        public static void HandleMeleeAttack(Character chr, Packet packet)
        {
            //Program.MainForm.LogAppend("Handling Melee");
            if (!ParseAttackData(chr, packet, out AttackData ad, AttackTypes.Melee))
            {
                return;
            }

            SendMeleeAttack(chr, ad);
            Mob    mob;
            bool   died;
            int    TotalDamage = 0;
            double MaxPossibleDamage;

            if (ad.SkillID != 0)
            {
                chr.Skills.UseMeleeAttack(ad.SkillID, ad);
            }

            bool pickPocketActivated = chr.PrimaryStats.HasBuff(Constants.ChiefBandit.Skills.Pickpocket);
            var  pickPocketSLD       = chr.Skills.GetSkillLevelData(Constants.ChiefBandit.Skills.Pickpocket, out byte pickPocketSkillLevel);
            bool pickOk = !ad.IsMesoExplosion && pickPocketActivated && pickPocketSkillLevel > 0 && pickPocketSLD != null;

            int StolenMP       = 0;
            int MpStealSkillID = chr.Skills.GetMpStealSkillData(2, out int MpStealProp, out int MpStealPercent, out byte MpStealLevel);

            List <Drop> dropsToPop = null;
            short       delayForMesoExplosionKill = 0;

            if (ad.SkillID == Constants.ChiefBandit.Skills.MesoExplosion)
            {
                byte items = packet.ReadByte();
                dropsToPop = new List <Drop>(items);
                byte i;
                for (i = 0; i < items; i++)
                {
                    int objectID = packet.ReadInt();
                    packet.Skip(1);

                    if (chr.Field.DropPool.Drops.TryGetValue(objectID, out var drop) &&
                        drop.Reward.Mesos)
                    {
                        dropsToPop.Add(drop);
                    }
                }

                delayForMesoExplosionKill = packet.ReadShort();
            }


            var  sld            = ad.SkillID == 0 ? null : DataProvider.Skills[ad.SkillID].Levels[ad.SkillLevel];
            long buffTime       = sld?.BuffTime * 1000 ?? 0;
            long buffExpireTime = MasterThread.CurrentTime + buffTime;

            bool IsSuccessRoll() => sld != null && (Rand32.Next() % 100) < sld.Property;


            foreach (var ai in ad.Attacks)
            {
                try
                {
                    TotalDamage = 0;
                    mob         = chr.Field.GetMob(ai.MobMapId);

                    if (mob == null)
                    {
                        continue;
                    }

                    bool boss = mob.Data.Boss;

                    if (MpStealPercent > 0)
                    {
                        StolenMP += mob.OnMobMPSteal(MpStealProp, MpStealPercent / ad.Targets);
                    }
                    if (pickOk)
                    {
                        mob.GiveMoney(chr, ai, ad.Hits);
                    }

                    foreach (var amount in ai.Damages)
                    {
                        mob.GiveDamage(chr, amount);
                        TotalDamage += amount;
                    }

                    if (TotalDamage == 0)
                    {
                        continue;
                    }

                    var maxDamage = 5 + (chr.Level * 6);
                    if (ad.SkillID == 0 && chr.Level < 10 && TotalDamage > maxDamage)
                    {
                        chr.PermaBan("Melee damage hack (low level), hit " + TotalDamage + " (max: " + maxDamage + ")");
                        return;
                    }

                    died = mob.CheckDead(ai.HitPosition, ad.IsMesoExplosion ? delayForMesoExplosionKill : ai.HitDelay, chr.PrimaryStats.BuffMesoUP.N);

                    //TODO sometimes when attacking without using a skill this gets triggered and throws a exception?
                    if (died || ad.SkillID <= 0)
                    {
                        continue;
                    }

                    if (ad.SkillID != 0)
                    {
                        MobStatus.MobStatValue addedStats = 0;

                        switch (ad.SkillID)
                        {
                        case Constants.DragonKnight.Skills.Sacrifice:
                        {
                            double percentSacrificed = sld.XValue / 100.0;
                            short  amountSacrificed  = (short)(TotalDamage * percentSacrificed);
                            chr.DamageHP(amountSacrificed);
                            break;
                        }

                        case Constants.Bandit.Skills.Steal:
                            if (!boss && IsSuccessRoll())
                            {
                                mob.GiveReward(chr.ID, 0, DropType.Normal, ai.HitPosition, ai.HitDelay, 0, true);
                            }
                            break;

                        // Debuffs

                        case Constants.Rogue.Skills.Disorder:

                            addedStats  = mob.Status.BuffPhysicalDamage.Set(ad.SkillID, (short)sld.XValue, buffExpireTime);
                            addedStats |= mob.Status.BuffPhysicalDefense.Set(ad.SkillID, (short)sld.XValue, buffExpireTime);
                            break;

                        case Constants.WhiteKnight.Skills.ChargeBlow:     // Not sure if this should add the stun
                        case Constants.Crusader.Skills.AxeComa:
                        case Constants.Crusader.Skills.SwordComa:
                        case Constants.Crusader.Skills.Shout:
                            if (!boss && IsSuccessRoll())
                            {
                                addedStats = mob.Status.BuffStun.Set(ad.SkillID, (short)-sld.BuffTime, buffExpireTime);
                            }
                            //is charge blow supposed to end the elemental charge buff?
                            break;

                        case Constants.Crusader.Skills.AxePanic:
                        case Constants.Crusader.Skills.SwordPanic:
                            if (!boss && IsSuccessRoll())
                            {
                                addedStats = mob.Status.BuffDarkness.Set(ad.SkillID, (short)1, buffExpireTime);
                                //darkness animation doesnt show in this ver?
                            }
                            break;
                        }

                        if (addedStats != 0)
                        {
                            MobPacket.SendMobStatsTempSet(mob, ai.HitDelay, addedStats);
                        }
                    }


                    if (StolenMP > 0)
                    {
                        chr.ModifyMP((short)StolenMP);
                        MapPacket.SendPlayerSkillAnimSelf(chr, MpStealSkillID, MpStealLevel);
                        MapPacket.SendPlayerSkillAnim(chr, MpStealSkillID, MpStealLevel);
                    }

                    if (ad.SkillID != 0)
                    {
                        MaxPossibleDamage = DamageFormula.MaximumMeleeDamage(chr, mob, ad.Targets, ad.SkillID);
                    }
                    else
                    {
                        MaxPossibleDamage = DamageFormula.MaximumMeleeDamage(chr, mob, ad.Targets);
                    }

                    if (TotalDamage > MaxPossibleDamage)
                    {
                        if (ReportDamagehack(chr, ad, TotalDamage, (int)MaxPossibleDamage))
                        {
                            return;
                        }
                    }
                }

                catch (Exception ex)
                {
                    Program.MainForm.LogAppend(ex.ToString());
                }
            }

            if (chr.PrimaryStats.BuffComboAttack.IsSet() && TotalDamage > 0)
            {
                if (ad.SkillID == Constants.Crusader.Skills.AxeComa ||
                    ad.SkillID == Constants.Crusader.Skills.SwordComa ||
                    ad.SkillID == Constants.Crusader.Skills.AxePanic ||
                    ad.SkillID == Constants.Crusader.Skills.SwordPanic)
                {
                    chr.PrimaryStats.BuffComboAttack.N = 1;
                    BuffPacket.SetTempStats(chr, BuffValueTypes.ComboAttack);
                    MapPacket.SendPlayerBuffed(chr, BuffValueTypes.ComboAttack);
                }
                else if (ad.SkillID != Constants.Crusader.Skills.Shout)
                {
                    if (chr.PrimaryStats.BuffComboAttack.N <= chr.PrimaryStats.BuffComboAttack.MaxOrbs)
                    {
                        chr.PrimaryStats.BuffComboAttack.N++;
                        BuffPacket.SetTempStats(chr, BuffValueTypes.ComboAttack);
                        MapPacket.SendPlayerBuffed(chr, BuffValueTypes.ComboAttack);
                    }
                }
            }


            switch (ad.SkillID)
            {
            case 0:                                                                                           // Normal wep
            {
                if (chr.Inventory.GetEquippedItemId((short)Constants.EquipSlots.Slots.Helm, true) == 1002258) // Blue Diamondy Bandana
                {
                    var mobs = chr.Field.GetMobsInRange(chr.Position, new Pos(-10000, -10000), new Pos(10000, 10000));

                    foreach (var m in mobs)
                    {
                        MobPacket.SendMobDamageOrHeal(chr.Field, m, 1337, false, false);

                        if (m.GiveDamage(chr, 1337))
                        {
                            m.CheckDead();
                        }
                    }
                }
                break;
            }

            case Constants.ChiefBandit.Skills.MesoExplosion:
            {
                byte i = 0;
                foreach (var drop in dropsToPop)
                {
                    var delay = (short)Math.Min(1000, delayForMesoExplosionKill + (100 * (i % 5)));
                    chr.Field.DropPool.RemoveDrop(drop, RewardLeaveType.Explode, delay);
                    i++;
                }
                break;
            }

            case Constants.WhiteKnight.Skills.ChargeBlow:
                if (IsSuccessRoll())
                {
                    // RIP. It cancels your charge
                    var removedBuffs = chr.PrimaryStats.RemoveByReference(chr.PrimaryStats.BuffCharges.R);
                    BuffPacket.SetTempStats(chr, removedBuffs);
                    MapPacket.SendPlayerBuffed(chr, removedBuffs);
                }
                break;

            case Constants.WhiteKnight.Skills.BwFireCharge:
            case Constants.WhiteKnight.Skills.BwIceCharge:
            case Constants.WhiteKnight.Skills.BwLitCharge:
            case Constants.WhiteKnight.Skills.SwordFireCharge:
            case Constants.WhiteKnight.Skills.SwordIceCharge:
            case Constants.WhiteKnight.Skills.SwordLitCharge:
            {
                var buff = chr.PrimaryStats.BuffCharges.Set(
                    ad.SkillID,
                    sld.XValue,
                    BuffStat.GetTimeForBuff(1000 * sld.BuffTime)
                    );
                BuffPacket.SetTempStats(chr, buff);
                MapPacket.SendPlayerBuffed(chr, buff);
                break;
            }

            case Constants.DragonKnight.Skills.DragonRoar:
            {
                // Apply stun
                var buff = chr.PrimaryStats.BuffStun.Set(
                    ad.SkillID,
                    1,
                    BuffStat.GetTimeForBuff(1000 * sld.YValue)
                    );
                BuffPacket.SetTempStats(chr, buff);
                MapPacket.SendPlayerBuffed(chr, buff);
                break;
            }
            }
        }