COMPARTILHADO CONHECIMENTO


Você não está conectado. Conecte-se ou registre-se

Conquer Ataque TQ 99%

Ver o tópico anterior Ver o tópico seguinte Ir em baixo  Mensagem [Página 1 de 1]

1 Conquer Ataque TQ 99% em Ter Mar 14, 2017 6:09 pm

Diegox

avatar
ADMINISTRADOR
ADMINISTRADOR
Achei no teamxor e tai pra vocês
Assassino - 100%
Monk - 100%
toist - 100%
warrier - 100%
Trojan - 100%
EpicWeapon - 99.5%
Pirate - 100%
Skill Boom - 98%
ninja - 100%



Guia -
Só está faltando o atack de epic ninja.

Abra a Handle.Cs e delete todo o código que tem nela e cole o código que coloquei para [Você precisa estar registrado e conectado para ver este link.]


_________________
[Você precisa estar registrado e conectado para ver esta imagem.]
Ver perfil do usuário http://4funbrasil.forumfacil.net

2 Re: Conquer Ataque TQ 99% em Sab Abr 01, 2017 4:28 pm

Essas sources são escrotas pq tem um cálculo pra cada coisa...
Quando o certo é que só há 2 tipos de ataque: físico e mágico.
Código:
public int CalcAttackPower(IRole attacker, IRole attacked, ref InteractionEffect pSpecial)
        {
            if (attacked is Character)
            {
                Character pUser = attacked as Character;
                if (pUser.QueryTransformation != null && pUser.QueryTransformation.Lookface == 223)
                    return 1;
            }

            if (attacked.QueryStatus(FlagInt.VORTEX) != null)
            {
                return 1;
            }

            int nAttack = 0;

            if (Calculations.ChanceCalc(50))
                nAttack = attacker.MaxAttack - ThreadSafeRandom.RandGet(1, Math.Max(1, attacker.MaxAttack - attacker.MinAttack) / 2 + 1);
            else
                nAttack = attacker.MinAttack + ThreadSafeRandom.RandGet(1, Math.Max(1, attacker.MaxAttack - attacker.MinAttack) / 2 + 1);

            if (attacker is Character && attacked is Character && (attacker as Character).IsBowman())
                nAttack = (int)(nAttack / 1.5f);

            // handle physical status
            if (attacker.QueryStatus(FlagInt.STIG) != null)
            {
                float tPower = attacker.QueryStatus(FlagInt.STIG).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            int nRawDefense = attacked.Defense;
            int nDef = attacked.AdjustDefense(nRawDefense);

            if (attacker.QueryStatus(FlagInt.OBLIVION) != null
                && !(attacked is Character)
                && ((attacked is Monster) && !(attacked as Monster).IsBoss))
            {
                nAttack *= 2;
            }

            if (attacker.QueryStatus(FlagInt.FATAL_STRIKE) != null
                && ((!attacked.IsDynaNpc() && !(attacked is Character))))
            {
                float tPower = attacker.QueryStatus(FlagInt.FATAL_STRIKE).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;

                if (attacked is Monster)
                {
                    Monster pMob = attacked as Monster;
                    if (pMob.IsGuard())
                        nAttack /= 10;
                }
            }

            if (attacker.QueryStatus(FlagInt.VORTEX) != null && !attacked.IsDynaNpc() && !(attacked is Character))
            {
                float tPower = attacker.QueryStatus(FlagInt.VORTEX).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            if (attacker.QueryStatus(FlagInt.SUPERMAN) != null
                && (!attacked.IsDynaNpc() && !(attacked is Character)))
            {
                float tPower = attacker.QueryStatus(FlagInt.SUPERMAN).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            if (attacked.QueryStatus(FlagInt.SHIELD) != null)
            {
                float tPower = attacked.QueryStatus(FlagInt.SHIELD).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nDef = (int)(nDef * tPower);
                }
                else
                    nDef += (short)tPower;
            }

            if (attacked.QueryStatus(FlagInt.DEFENSIVE_INSTANCE) != null)
            {
                nDef *= 4;
            }

            if (attacker.Magics.QueryMagic() != null)
            {
                float tPower = attacker.Magics.QueryMagic().QueryPower();
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            //float reduction = attacked.GetReduceDamage();
            int nDamage = (int)((nAttack - nDef) * (1f - (attacked.GetReduceDamage() / 100f)));
            float tort = (attacked.GetTortoiseGemEffect() / 100f);
            nDamage = (int)(nDamage * (1f - tort));

            if (nDamage <= 0) nDamage = 7;

            if (attacker is Character && attacked.IsMonster())
            {
                nDamage = CalcDamageUser2Monster(nAttack, nDef, attacker.Level, attacked.Level);
                nDamage = attacked.AdjustWeaponDamage(nDamage);
                nDamage = AdjustMinDamageUser2Monster(nDamage, attacker, attacked);
            }
            else if (attacker.IsMonster() && attacked is Character)
            {
                nDamage = CalcDamageMonster2User(nAttack, nDef, attacker.Level, attacked.Level);
                nDamage = attacked.AdjustWeaponDamage(nDamage);
                nDamage = AdjustMinDamageMonster2User(nDamage, attacker, attacked);
            }
            else
            {
                nDamage = attacked.AdjustWeaponDamage(nDamage);
            }

            //if (attacker is Character && attacked is Character && attacker.BattlePower < attacked.BattlePower)
            //{
            //    nDamage /= 2;
            //}

            #region Block, Critical, Break
            if (attacker.BattlePower < attacked.BattlePower)
            {
                if (attacked is Character)
                {
                    // Break (Pene is on the magic code)
                    // Break through the battle power cap...
                    // If the break fails, the damage is reduced by half.
                    if (attacked.Counteraction < attacker.Breakthrough)
                    {
                        if (!Calculations.ChanceCalc((float)(attacker.Breakthrough - attacked.Counteraction) / 10))
                            nDamage /= 2;
                        else
                            pSpecial |= InteractionEffect.BREAKTHROUGH;
                        //Owner.SendMessage(string.Format("Break: {0} Counter: {1} Difference: {2}%", GetBreakthrough(), pTarget.GetCounteraction(), (float)(GetBreakthrough() - pTarget.GetCounteraction()) / 10));
                    }
                    else
                    {
                        nDamage /= 2;
                    }
                }
            }

            // Critical is enabled on every monster.
            // Multiply the damage by 1.5
            if (attacker.CriticalStrike > attacked.Immunity)
            {
                if (Calculations.ChanceCalc((float)(attacker.CriticalStrike - attacked.Immunity) / 100))
                {
                    nDamage = (int)(nDamage * 1.5f);
                    pSpecial |= InteractionEffect.CRITICAL_STRIKE;
                }
            }

            if (attacked.Block > 0 && Calculations.ChanceCalc((float)attacked.Block / 100))
            {
                nDamage /= 10;
                pSpecial |= InteractionEffect.BLOCK;
            }

            if (QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                switch (QueryMagic().GetElement())
                {
                    case ElementType.WATER:
                        pSpecial |= InteractionEffect.WATER_RESIST;
                        break;
                    case ElementType.FIRE:
                        pSpecial |= InteractionEffect.FIRE_RESIST;
                        break;
                    case ElementType.WOOD:
                        pSpecial |= InteractionEffect.WOOD_RESIST;
                        break;
                    case ElementType.METAL:
                        pSpecial |= InteractionEffect.METAL_RESIST;
                        break;
                    case ElementType.EARTH:
                        pSpecial |= InteractionEffect.EARTH_RESIST;
                        break;
                }
            }
            #endregion

            if (attacker is Monster && QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                switch (QueryMagic().GetElement())
                {
                    case ElementType.WATER:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.WaterResistance/100f)));
                        break;
                    }
                    case ElementType.FIRE:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.FireResistance/100f)));
                        break;
                    }
                    case ElementType.EARTH:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.EarthResistance/100f)));
                        break;
                    }
                    case ElementType.WOOD:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.WoodResistance/100f)));
                        break;
                    }
                    case ElementType.METAL:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.MetalResistance/100f)));
                        break;
                    }
                }
            }

            if (attacker is Character)
            {
                nDamage += attacker.AddFinalAttack;
            }

            if (attacked is Character)
                nDamage -= attacked.AddFinalDefense;

            if (attacked is Monster)
            {
                nDamage = (int) Math.Min(nDamage, attacked.MaxLife*700);
            }

            if (nDamage <= 0)
                nDamage = 1;

            return nDamage;
        }

        public int CalcMagicPower(IRole pAtker, IRole pTarget, int pAdjustAtk, ref InteractionEffect pSpecial) // /*=0*/, ref InteractionEffect special)
        {
            if (pTarget is Character)
            {
                Character pUser = pTarget as Character;
                if (pUser.QueryTransformation != null && pUser.QueryTransformation.Lookface == 223)
                    return 1;
            }

            if (pTarget.QueryStatus(FlagInt.VORTEX) != null)
            {
                return 1;
            }

            if (pTarget.QueryStatus(FlagInt.MAGIC_DEFENDER) != null)
            {
                return 1;
            }

            int nAtk = pAtker.MagicAttack;

            if (pAtker.Magics.QueryMagic() != null)
            {
                float tPower = pAtker.Magics.QueryMagic().QueryPower();
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAtk = (int)(nAtk * tPower);
                }
                else
                    nAtk += (short)tPower;
            }

            int nDef = pTarget.MagicDefense; // * (1 + (pTarget.Magic / 100));

            if (pTarget is Character)
            {
                int nCounter = (int) (pTarget.Counteraction / 10f);
                int nPene = (int) (pAtker.Penetration / 100f);
                if (nCounter < nPene)
                {
                    if (!Calculations.ChanceCalc((nPene - nCounter)))
                    {
                        Character pUser = pTarget as Character;
                        nDef = (int) (nDef*(1 + (pUser.MagicDefenseBonus/100f)));
                    }
                    else
                    {
                        nAtk = (int) (nAtk*1.25f);
                        pSpecial |= InteractionEffect.BREAKTHROUGH;
                    }
                }
                else
                {
                    Character pUser = pTarget as Character;
                    nDef = (int)(nDef * (1 + (pUser.MagicDefenseBonus / 100f)));
                }
            }

            int nDamage = (int)((nAtk - nDef) * (1f - (pTarget.GetReduceDamage() / 100f)));
            nDamage = (int)(nDamage * (1f - (pTarget.GetTortoiseGemEffect() / 100f)));

            if (pAtker is Character && pTarget.IsMonster())
            {
                nDamage = CalcDamageUser2Monster(nDamage, nDef, pAtker.Level, pTarget.Level);
                nDamage = pTarget.AdjustMagicDamage(nDamage);
                nDamage = AdjustMinDamageUser2Monster(nDamage, pAtker, pTarget);
            }
            else if (pAtker.IsMonster() && pTarget is Character)
            {
                nDamage = CalcDamageMonster2User(nDamage, nDef, pAtker.Level, pTarget.Level);
                nDamage = pTarget.AdjustMagicDamage(nDamage);
                nDamage = AdjustMinDamageMonster2User(nDamage, pAtker, pTarget);
            }
            else
            {
                nDamage = pAtker.AdjustMagicDamage(nDamage);
            }

            if (pAtker.BattlePower < pTarget.BattlePower)
            {
                if (pTarget is Character)
                {
                    int levelDiff = pTarget.BattlePower - pAtker.BattlePower;
                    float disccount = 0;
                    if (levelDiff > 50)
                        disccount = 50;
                    else
                        disccount = 100 - levelDiff;

                    nDamage = (int)(nDamage * (disccount / 100));
                }
            }

            if (pAtker.SkillCriticalStrike > pTarget.Immunity)
            {
                if (Calculations.ChanceCalc((float)(pAtker.SkillCriticalStrike - pTarget.Immunity) / 100))
                {
                    nDamage = (int)(nDamage * 2f);
                    pSpecial |= InteractionEffect.CRITICAL_STRIKE;
                }
            }

            if (QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                switch (QueryMagic().GetElement())
                {
                    case ElementType.WATER:
                        pSpecial |= InteractionEffect.WATER_RESIST;
                        break;
                    case ElementType.FIRE:
                        pSpecial |= InteractionEffect.FIRE_RESIST;
                        break;
                    case ElementType.WOOD:
                        pSpecial |= InteractionEffect.WOOD_RESIST;
                        break;
                    case ElementType.METAL:
                        pSpecial |= InteractionEffect.METAL_RESIST;
                        break;
                    case ElementType.EARTH:
                        pSpecial |= InteractionEffect.EARTH_RESIST;
                        break;
                }
            }

            if (pAtker is Monster && QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                nDamage += pAtker.Magics.GetElementPower(pTarget);
                //switch (QueryMagic().GetElement())
                //{
                //    case ElementType.WATER:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.WaterResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.FIRE:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.FireResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.EARTH:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.EarthResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.WOOD:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.WoodResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.METAL:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.MetalResistance / 100f)));
                //            break;
                //        }
                //}
            }

            if (pAtker is Character)
                nDamage += pAtker.AddFinalMagicAttack;
            if (pTarget is Character)
                nDamage -= pTarget.AddFinalMagicDefense;

            // Adjust synflag damage
            if (pTarget is DynamicNpc)
            {
                //var npc = pTarget as DynamicNpc;
                //if (npc.IsSynFlag()
                //    && npc.IsSynMoneyEmpty())
                nDamage = nDamage * Character.SYNWAR_NOMONEY_DAMAGETIMES;
            }

            return Calculations.CutTrail(1, nDamage);
        }
E esse é o código de esquiva
Código:
public bool IsTargetDodged(IRole attacker, IRole attacked)
        {
            if (attacker == null || attacked == null) return true;

            //if (attacked.BattleSystem.QueryMagic() != null && attacked.BattleSystem.QueryMagic().IsInLaunch()) return true;

            int nDodge = 0;
            if (attacked is Character || attacked is DynamicNpc || (attacked is Monster && (attacked as Monster).IsBoss))
                nDodge = 40;

            int atkHit = attacker.AttackHitRate;
            if (attacker.QueryStatus(FlagInt.STAR_OF_ACCURACY) != null)
                atkHit = Calculations.AdjustData(atkHit, attacker.QueryStatus(FlagInt.STAR_OF_ACCURACY).Power);

            int atkdDodge = attacked.Dodge;
            if (attacked.QueryStatus(FlagInt.DODGE) != null)
                atkHit = Calculations.AdjustData(atkHit, attacker.QueryStatus(FlagInt.DODGE).Power);

            int hitRate = Math.Min(100, Math.Max(40, 100 + atkHit - nDodge - atkdDodge));

            if (hitRate < 40)
                hitRate = 40;

            if (attacker is Character)
                if ((attacker as Character).IsPm)
                    (attacker as Character).Send("HitRate: " + hitRate);

            if (attacked is Character)
                if ((attacked as Character).IsPm)
                    (attacked as Character).Send("Attacker HitRate: " + hitRate);

            //if (attacker.Profession / 10 != 4 && hitRate > 90)
            //    hitRate = 90;

            return !Calculations.ChanceCalc(hitRate);
        }

Ver perfil do usuário http://ftwmasters.com/

3 Re: Conquer Ataque TQ 99% em Sex Abr 14, 2017 10:54 pm

iRoshan

avatar
Membro
Membro
FelipeVieira escreveu:Essas sources são escrotas pq tem um cálculo pra cada coisa...
Quando o certo é que só há 2 tipos de ataque: físico e mágico.
Código:
public int CalcAttackPower(IRole attacker, IRole attacked, ref InteractionEffect pSpecial)
        {
            if (attacked is Character)
            {
                Character pUser = attacked as Character;
                if (pUser.QueryTransformation != null && pUser.QueryTransformation.Lookface == 223)
                    return 1;
            }

            if (attacked.QueryStatus(FlagInt.VORTEX) != null)
            {
                return 1;
            }

            int nAttack = 0;

            if (Calculations.ChanceCalc(50))
                nAttack = attacker.MaxAttack - ThreadSafeRandom.RandGet(1, Math.Max(1, attacker.MaxAttack - attacker.MinAttack) / 2 + 1);
            else
                nAttack = attacker.MinAttack + ThreadSafeRandom.RandGet(1, Math.Max(1, attacker.MaxAttack - attacker.MinAttack) / 2 + 1);

            if (attacker is Character && attacked is Character && (attacker as Character).IsBowman())
                nAttack = (int)(nAttack / 1.5f);

            // handle physical status
            if (attacker.QueryStatus(FlagInt.STIG) != null)
            {
                float tPower = attacker.QueryStatus(FlagInt.STIG).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            int nRawDefense = attacked.Defense;
            int nDef = attacked.AdjustDefense(nRawDefense);

            if (attacker.QueryStatus(FlagInt.OBLIVION) != null
                && !(attacked is Character)
                && ((attacked is Monster) && !(attacked as Monster).IsBoss))
            {
                nAttack *= 2;
            }

            if (attacker.QueryStatus(FlagInt.FATAL_STRIKE) != null
                && ((!attacked.IsDynaNpc() && !(attacked is Character))))
            {
                float tPower = attacker.QueryStatus(FlagInt.FATAL_STRIKE).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;

                if (attacked is Monster)
                {
                    Monster pMob = attacked as Monster;
                    if (pMob.IsGuard())
                        nAttack /= 10;
                }
            }

            if (attacker.QueryStatus(FlagInt.VORTEX) != null && !attacked.IsDynaNpc() && !(attacked is Character))
            {
                float tPower = attacker.QueryStatus(FlagInt.VORTEX).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            if (attacker.QueryStatus(FlagInt.SUPERMAN) != null
                && (!attacked.IsDynaNpc() && !(attacked is Character)))
            {
                float tPower = attacker.QueryStatus(FlagInt.SUPERMAN).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            if (attacked.QueryStatus(FlagInt.SHIELD) != null)
            {
                float tPower = attacked.QueryStatus(FlagInt.SHIELD).Power;
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nDef = (int)(nDef * tPower);
                }
                else
                    nDef += (short)tPower;
            }

            if (attacked.QueryStatus(FlagInt.DEFENSIVE_INSTANCE) != null)
            {
                nDef *= 4;
            }

            if (attacker.Magics.QueryMagic() != null)
            {
                float tPower = attacker.Magics.QueryMagic().QueryPower();
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAttack = (int)(nAttack * tPower);
                }
                else
                    nAttack += (short)tPower;
            }

            //float reduction = attacked.GetReduceDamage();
            int nDamage = (int)((nAttack - nDef) * (1f - (attacked.GetReduceDamage() / 100f)));
            float tort = (attacked.GetTortoiseGemEffect() / 100f);
            nDamage = (int)(nDamage * (1f - tort));

            if (nDamage <= 0) nDamage = 7;

            if (attacker is Character && attacked.IsMonster())
            {
                nDamage = CalcDamageUser2Monster(nAttack, nDef, attacker.Level, attacked.Level);
                nDamage = attacked.AdjustWeaponDamage(nDamage);
                nDamage = AdjustMinDamageUser2Monster(nDamage, attacker, attacked);
            }
            else if (attacker.IsMonster() && attacked is Character)
            {
                nDamage = CalcDamageMonster2User(nAttack, nDef, attacker.Level, attacked.Level);
                nDamage = attacked.AdjustWeaponDamage(nDamage);
                nDamage = AdjustMinDamageMonster2User(nDamage, attacker, attacked);
            }
            else
            {
                nDamage = attacked.AdjustWeaponDamage(nDamage);
            }

            //if (attacker is Character && attacked is Character && attacker.BattlePower < attacked.BattlePower)
            //{
            //    nDamage /= 2;
            //}

            #region Block, Critical, Break
            if (attacker.BattlePower < attacked.BattlePower)
            {
                if (attacked is Character)
                {
                    // Break (Pene is on the magic code)
                    // Break through the battle power cap...
                    // If the break fails, the damage is reduced by half.
                    if (attacked.Counteraction < attacker.Breakthrough)
                    {
                        if (!Calculations.ChanceCalc((float)(attacker.Breakthrough - attacked.Counteraction) / 10))
                            nDamage /= 2;
                        else
                            pSpecial |= InteractionEffect.BREAKTHROUGH;
                        //Owner.SendMessage(string.Format("Break: {0} Counter: {1} Difference: {2}%", GetBreakthrough(), pTarget.GetCounteraction(), (float)(GetBreakthrough() - pTarget.GetCounteraction()) / 10));
                    }
                    else
                    {
                        nDamage /= 2;
                    }
                }
            }

            // Critical is enabled on every monster.
            // Multiply the damage by 1.5
            if (attacker.CriticalStrike > attacked.Immunity)
            {
                if (Calculations.ChanceCalc((float)(attacker.CriticalStrike - attacked.Immunity) / 100))
                {
                    nDamage = (int)(nDamage * 1.5f);
                    pSpecial |= InteractionEffect.CRITICAL_STRIKE;
                }
            }

            if (attacked.Block > 0 && Calculations.ChanceCalc((float)attacked.Block / 100))
            {
                nDamage /= 10;
                pSpecial |= InteractionEffect.BLOCK;
            }

            if (QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                switch (QueryMagic().GetElement())
                {
                    case ElementType.WATER:
                        pSpecial |= InteractionEffect.WATER_RESIST;
                        break;
                    case ElementType.FIRE:
                        pSpecial |= InteractionEffect.FIRE_RESIST;
                        break;
                    case ElementType.WOOD:
                        pSpecial |= InteractionEffect.WOOD_RESIST;
                        break;
                    case ElementType.METAL:
                        pSpecial |= InteractionEffect.METAL_RESIST;
                        break;
                    case ElementType.EARTH:
                        pSpecial |= InteractionEffect.EARTH_RESIST;
                        break;
                }
            }
            #endregion

            if (attacker is Monster && QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                switch (QueryMagic().GetElement())
                {
                    case ElementType.WATER:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.WaterResistance/100f)));
                        break;
                    }
                    case ElementType.FIRE:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.FireResistance/100f)));
                        break;
                    }
                    case ElementType.EARTH:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.EarthResistance/100f)));
                        break;
                    }
                    case ElementType.WOOD:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.WoodResistance/100f)));
                        break;
                    }
                    case ElementType.METAL:
                    {
                        nDamage = (int) (nDamage*(1 - (attacked.MetalResistance/100f)));
                        break;
                    }
                }
            }

            if (attacker is Character)
            {
                nDamage += attacker.AddFinalAttack;
            }

            if (attacked is Character)
                nDamage -= attacked.AddFinalDefense;

            if (attacked is Monster)
            {
                nDamage = (int) Math.Min(nDamage, attacked.MaxLife*700);
            }

            if (nDamage <= 0)
                nDamage = 1;

            return nDamage;
        }

        public int CalcMagicPower(IRole pAtker, IRole pTarget, int pAdjustAtk, ref InteractionEffect pSpecial) // /*=0*/, ref InteractionEffect special)
        {
            if (pTarget is Character)
            {
                Character pUser = pTarget as Character;
                if (pUser.QueryTransformation != null && pUser.QueryTransformation.Lookface == 223)
                    return 1;
            }

            if (pTarget.QueryStatus(FlagInt.VORTEX) != null)
            {
                return 1;
            }

            if (pTarget.QueryStatus(FlagInt.MAGIC_DEFENDER) != null)
            {
                return 1;
            }

            int nAtk = pAtker.MagicAttack;

            if (pAtker.Magics.QueryMagic() != null)
            {
                float tPower = pAtker.Magics.QueryMagic().QueryPower();
                if (tPower > 30000)
                {
                    tPower = (tPower - 30000) / 100f;
                    nAtk = (int)(nAtk * tPower);
                }
                else
                    nAtk += (short)tPower;
            }

            int nDef = pTarget.MagicDefense; // * (1 + (pTarget.Magic / 100));

            if (pTarget is Character)
            {
                int nCounter = (int) (pTarget.Counteraction / 10f);
                int nPene = (int) (pAtker.Penetration / 100f);
                if (nCounter < nPene)
                {
                    if (!Calculations.ChanceCalc((nPene - nCounter)))
                    {
                        Character pUser = pTarget as Character;
                        nDef = (int) (nDef*(1 + (pUser.MagicDefenseBonus/100f)));
                    }
                    else
                    {
                        nAtk = (int) (nAtk*1.25f);
                        pSpecial |= InteractionEffect.BREAKTHROUGH;
                    }
                }
                else
                {
                    Character pUser = pTarget as Character;
                    nDef = (int)(nDef * (1 + (pUser.MagicDefenseBonus / 100f)));
                }
            }

            int nDamage = (int)((nAtk - nDef) * (1f - (pTarget.GetReduceDamage() / 100f)));
            nDamage = (int)(nDamage * (1f - (pTarget.GetTortoiseGemEffect() / 100f)));

            if (pAtker is Character && pTarget.IsMonster())
            {
                nDamage = CalcDamageUser2Monster(nDamage, nDef, pAtker.Level, pTarget.Level);
                nDamage = pTarget.AdjustMagicDamage(nDamage);
                nDamage = AdjustMinDamageUser2Monster(nDamage, pAtker, pTarget);
            }
            else if (pAtker.IsMonster() && pTarget is Character)
            {
                nDamage = CalcDamageMonster2User(nDamage, nDef, pAtker.Level, pTarget.Level);
                nDamage = pTarget.AdjustMagicDamage(nDamage);
                nDamage = AdjustMinDamageMonster2User(nDamage, pAtker, pTarget);
            }
            else
            {
                nDamage = pAtker.AdjustMagicDamage(nDamage);
            }

            if (pAtker.BattlePower < pTarget.BattlePower)
            {
                if (pTarget is Character)
                {
                    int levelDiff = pTarget.BattlePower - pAtker.BattlePower;
                    float disccount = 0;
                    if (levelDiff > 50)
                        disccount = 50;
                    else
                        disccount = 100 - levelDiff;

                    nDamage = (int)(nDamage * (disccount / 100));
                }
            }

            if (pAtker.SkillCriticalStrike > pTarget.Immunity)
            {
                if (Calculations.ChanceCalc((float)(pAtker.SkillCriticalStrike - pTarget.Immunity) / 100))
                {
                    nDamage = (int)(nDamage * 2f);
                    pSpecial |= InteractionEffect.CRITICAL_STRIKE;
                }
            }

            if (QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                switch (QueryMagic().GetElement())
                {
                    case ElementType.WATER:
                        pSpecial |= InteractionEffect.WATER_RESIST;
                        break;
                    case ElementType.FIRE:
                        pSpecial |= InteractionEffect.FIRE_RESIST;
                        break;
                    case ElementType.WOOD:
                        pSpecial |= InteractionEffect.WOOD_RESIST;
                        break;
                    case ElementType.METAL:
                        pSpecial |= InteractionEffect.METAL_RESIST;
                        break;
                    case ElementType.EARTH:
                        pSpecial |= InteractionEffect.EARTH_RESIST;
                        break;
                }
            }

            if (pAtker is Monster && QueryMagic() != null && QueryMagic().GetElement() > ElementType.NONE)
            {
                nDamage += pAtker.Magics.GetElementPower(pTarget);
                //switch (QueryMagic().GetElement())
                //{
                //    case ElementType.WATER:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.WaterResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.FIRE:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.FireResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.EARTH:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.EarthResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.WOOD:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.WoodResistance / 100f)));
                //            break;
                //        }
                //    case ElementType.METAL:
                //        {
                //            nDamage = (int)(nDamage * (1 - (pTarget.MetalResistance / 100f)));
                //            break;
                //        }
                //}
            }

            if (pAtker is Character)
                nDamage += pAtker.AddFinalMagicAttack;
            if (pTarget is Character)
                nDamage -= pTarget.AddFinalMagicDefense;

            // Adjust synflag damage
            if (pTarget is DynamicNpc)
            {
                //var npc = pTarget as DynamicNpc;
                //if (npc.IsSynFlag()
                //    && npc.IsSynMoneyEmpty())
                nDamage = nDamage * Character.SYNWAR_NOMONEY_DAMAGETIMES;
            }

            return Calculations.CutTrail(1, nDamage);
        }
E esse é o código de esquiva
Código:
public bool IsTargetDodged(IRole attacker, IRole attacked)
        {
            if (attacker == null || attacked == null) return true;

            //if (attacked.BattleSystem.QueryMagic() != null && attacked.BattleSystem.QueryMagic().IsInLaunch()) return true;

            int nDodge = 0;
            if (attacked is Character || attacked is DynamicNpc || (attacked is Monster && (attacked as Monster).IsBoss))
                nDodge = 40;

            int atkHit = attacker.AttackHitRate;
            if (attacker.QueryStatus(FlagInt.STAR_OF_ACCURACY) != null)
                atkHit = Calculations.AdjustData(atkHit, attacker.QueryStatus(FlagInt.STAR_OF_ACCURACY).Power);

            int atkdDodge = attacked.Dodge;
            if (attacked.QueryStatus(FlagInt.DODGE) != null)
                atkHit = Calculations.AdjustData(atkHit, attacker.QueryStatus(FlagInt.DODGE).Power);

            int hitRate = Math.Min(100, Math.Max(40, 100 + atkHit - nDodge - atkdDodge));

            if (hitRate < 40)
                hitRate = 40;

            if (attacker is Character)
                if ((attacker as Character).IsPm)
                    (attacker as Character).Send("HitRate: " + hitRate);

            if (attacked is Character)
                if ((attacked as Character).IsPm)
                    (attacked as Character).Send("Attacker HitRate: " + hitRate);

            //if (attacker.Profession / 10 != 4 && hitRate > 90)
            //    hitRate = 90;

            return !Calculations.ChanceCalc(hitRate);
        }


Obrigado mano


_________________
"A pior coisa que eu posso ser é igual a todo mundo. Eu odeio isso."

Arnold Schwarzenegger
Ver perfil do usuário

Conteúdo patrocinado


Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo  Mensagem [Página 1 de 1]

Permissão deste fórum:
Você não pode responder aos tópicos neste fórum