[Question] Archer Attack Calculation

[littlechris95]

As the topic title says ... I would like to know how to attack Archer is calculated. It is the same as the others? How?

[Spirited]

[CptSky]

Originally Posted by Spirited

Not all calculations are right in this source as it's another project. But it's a good start.

[abdoumatrix]

Originally Posted by Spirited

isn't this for eudemon?
aren't the calculation away different now?

good refrence anyway

 Spoiler

PHP Code:

BOOL CBattleSystem::IsTargetDodged(IRole* pAtker, IRole* pTarget)
{
    if (!pAtker || !pTarget)
        return true;    

    // بç¹ûؤ؟±ê´¦سعؤ§·¨ت©ص¹ضذ£¬°ظ·ض°ظ¶م±ـ -- zlong 2004.5.12
    if (pTarget->QueryMagic() && pTarget->QueryMagic()->IsInLaunch())
        return true;

    int nDodge    = 0;
    CUser* pTargetUser = NULL;
    if (pTarget->QueryObj(OBJ_USER, IPP_OF(pTargetUser)))
    {
        nDodge = 40;    // ±»¹¥»÷صكتابث£¬³ُت¼ةء±ـخھ40
    }
    int nHitRate = __min(100, __max(0, 100 + (int)pAtker->GetAtkHitRate() - nDodge - (int)pTarget->GetDdg()));

#ifdef _DEBUG
    CUser* pAtkerUser = NULL;
    pAtker->QueryObj(OBJ_USER, IPP_OF(pAtkerUser));
    
    if (pAtkerUser)
        pAtkerUser->SendSysMsg(_TXTATR_NORMAL, "HitRate: %d", nHitRate);

    if (pTargetUser)
        pTargetUser->SendSysMsg(_TXTATR_NORMAL, "Monster HitRate: %d", nHitRate);
#endif

    return  (::RandGet(100) >= nHitRate);
}

//////////////////////////////////////////////////////////////////////
int CBattleSystem::CalcPower(int nMagic, IRole* pAtker, IRole* pTarget, int* pAdjustAtk/*=0*/, bool bCanDodge/*=false*/)
{
    int    nPower    = 0;

    // bCanDodge==falseشٍ²»؟¼آا¶م±ـ ،ھ،ھ سأسعؤ§·¨¹¥»÷µؤت±؛ٍ¼ئثمةث؛¦£¬زٍخھ²ك»®زھاَؤ§·¨¹¥»÷½ِح¨¹‎percent¼ئثمأüضذآت
    // bCanDodge==trueشٍ¼ئثم¶م±ـ ،ھ،ھ سأسعئصح¨¹¥»÷ت±¼ئثمةث؛¦
    if (!(bCanDodge && CBattleSystem::IsTargetDodged(pAtker, pTarget)))
    {
        if(nMagic == MAGICTYPE_NONE)
        {
            nPower += CBattleSystem::CalcAttackPower(pAtker, pTarget, pAdjustAtk);
        }
        else
        {
            nPower += CMagic::CalcMagicPower(pAtker, pTarget, pAdjustAtk);

            // XP¼¼ؤـ¶شحو¼زµؤةث؛¦خھ 2%
            if (nMagic == MAGICTYPE_XPSKILL)
            {
                CUser* pUser = NULL;
                if (pTarget->QueryObj(OBJ_USER, IPP_OF(pUser)))
                    nPower /= 50;
            }
        }
    }

    if (nPower > 0)
    {
        CMonster* pMonster = NULL;
        if (pAtker->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)))
        {
            nPower = pMonster->AdjustFrenzy2Dmg(nPower);
        }

        IStatus* pStatus = NULL;
        // ¹¥»÷½ل½ç£¬شِ¼سةث؛¦
        if (pStatus = pAtker->QueryStatus(STATUS_TEAMATTACK))
        {
            nPower    += nPower*pStatus->GetPower()/100;
        }
        // ؟ٌ±©×´ج¬شِ¼سةث؛¦
        if (pStatus = pAtker->QueryStatus(STATUS_FRENZY))
        {
            if (pAtker->GetLife()*100/pAtker->GetMaxLife() < 50)
                nPower = ::MulDiv(nPower, 100+pStatus->GetPower(), 100);
        }
        // ةٌء¦×´ج¬
        if (pStatus = pAtker->QueryStatus(STATUS_EXTRA_POWER))
        {
            int nMultiple    = 2;
            if (pTarget->IsMonster())
                nMultiple    = 10;
            nPower *= nMultiple;
        }
        
        // µ÷صû¹¥»÷شى³ةµؤةث؛¦
        if (pStatus = pAtker->QueryStatus(STATUS_ATKER_DAMAGE))
        {
            nPower = ::CutTrail(0, CRole::AdjustDataEx(nPower, pStatus->GetPower()));
        }

        // µ÷صû±»»÷شى³ةµؤةث؛¦
        if (pStatus = pTarget->QueryStatus(STATUS_DAMAGE))
        {
            nPower = ::CutTrail(0, CRole::AdjustDataEx(nPower, pStatus->GetPower()));
        }

        // ا±ء¦ضµµؤس°دى
        if (pAtker->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)))
        {
            // »أتقأ؟شِ/¼ُ1µما±ء¦ضµ£¬¶شµذبثةث؛¦شِ/¼ُ1%
            int nOffset = pMonster->GetPotential() - DEFAULT_EUDEMON_POTENTIAL;
            if (nOffset != 0)
                nPower = ::MulDiv(nPower, 100 + nOffset, 100);
        }
        if (pTarget->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)))
        {
            // »أتقأ؟شِ/¼ُ1µما±ء¦ضµ£¬تـµ½µذبثµؤةث؛¦¼ُ/شِ1% ،ھ،ھ ¸ص؛أسëةدأودà·´
            int nOffset = pMonster->GetPotential() - DEFAULT_EUDEMON_POTENTIAL;
            if (nOffset != 0)
                nPower = ::MulDiv(nPower, 100 - nOffset, 100);
        }
        
        // ؟ٌ±©×´ج¬¼ُةظةث؛¦
        if (pStatus = pTarget->QueryStatus(STATUS_FRENZY))
        {
            if (pTarget->GetLife()*100/pTarget->GetMaxLife() < 50)
                nPower -= __min(nPower, nPower*pStatus->GetPower()/100);
        }
        // »¤جه½ل½ç£¬¼ُةظةث؛¦
        if (pStatus = pTarget->QueryStatus(STATUS_TEAMDEFENCE))
        {
            nPower    = nPower*__max(0, 100-(int)pStatus->GetPower())/100;
        }

        // ؟ٌ±©×´ج¬»ل¸ؤ±نةث؛¦
        if (pStatus = pAtker->QueryStatus(STATUS_TRUCULENCE))
        {
            int nPercent = 150;
            nPercent -= (pAtker->GetMaxLife()-pAtker->GetLife())*100 / pAtker->GetMaxLife();
            nPower    = MulDiv(nPower, nPercent, 100);
        }

        // ½ل½çدµح³µؤةث؛¦×ھزئ
        if (pStatus = pTarget->QueryStatus(STATUS_TEAMSPIRIT))
        {
            CUser* pUser = NULL;
            if (!pTarget->QueryObj(OBJ_USER, IPP_OF(pUser)))
            {
                CMonster* pMonster = NULL;
                if (pTarget->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)))
                {
                    if (pMonster->IsEudemon())
                        pUser    = pTarget->QueryOwnerUser();
                }
            }
            
            if (pUser)
            {
                CTeam* pTeam = pUser->GetTeam();
                if (pTeam)
                {
                    nPower    = pTeam->ShareDamage(nPower, pTarget->GetID());
                }
            }
        }
    }
    

    return nPower;
}

//////////////////////////////////////////////////////////////////////
int CBattleSystem::CalcAttackPower(IRole* pAtker, IRole* pTarget, int* pAdjustAtk/*=0*/, int* pAdjustDef/*=0*/)
{
    CHECKF(pAtker && pTarget);

    // super man status
//    IStatus* pSuperMan = pAtker->QueryStatus(STATUS_SUPERMAN);

    // get user
    CUser* pUser = NULL;
    pAtker->QueryObj(OBJ_USER, IPP_OF(pUser));

    // attack
    int nMaxRand = 50 + pAtker->GetLuck();
    int nAtk = 0;
    if(::RandGet(100) < nMaxRand)
        nAtk = pAtker->GetMaxAtk() - ::RandGet((pAtker->GetMaxAtk()-pAtker->GetMinAtk()) / 2);
    else
        nAtk = pAtker->GetMinAtk() + ::RandGet((pAtker->GetMaxAtk()-pAtker->GetMinAtk()) / 2);

    if (pUser)
    {
#ifdef _DEBUG
        pUser->SendSysMsg(_TXTATR_NORMAL, "atk org value: %d", nAtk);
#endif
    }

    nAtk    = pAtker->AdjustAttack(nAtk);
    if(pAdjustAtk)
    {
        if(*pAdjustAtk)
            nAtk = ::CutTrail(0, CRole::AdjustDataEx(nAtk, *pAdjustAtk));
        
        *pAdjustAtk = nAtk;
    }

    // defence
    int nRawDef    = pTarget->GetDef();
#ifdef _DEBUG
    if (pUser)
        pUser->SendSysMsg(_TXTATR_NORMAL, "target row def: +%d", nRawDef);
#endif

    int nDef = pTarget->AdjustDefence(nRawDef);
    if(pAtker->IsBowman())
        nDef = pTarget->AdjustBowDefence(nDef);
#ifdef    PALED_DEBUG
//    if(pSuperMan && pAtker->IsPM())
//    {
//        nAtk = pTarget->GetLife();
//        pAtker->SendSysMsg("==========±طة±===========");
//    }
#endif

    if(pAdjustDef)
    {
        if(*pAdjustDef)
            nDef = ::CutTrail(0, CRole::AdjustDataEx(nDef, *pAdjustDef));
        
        *pAdjustDef    = nDef;
    }

//    if(pSuperMan)
//    {
//        nDef /= 2;
//#ifdef _DEBUG
//        if (pUser)
//            pUser->SendSysMsg(_TXTATR_NORMAL, "target def decrease to 1/2 for superman status, def=%d", nDef);
//#endif
//    }

    // damage
    int    nDamage    = nAtk - nDef;
    if (pAtker->QueryOwnerUser() && pTarget->IsMonster())
    {
        CMonster* pMonster;
        if(pTarget->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)) && !pMonster->IsEquality())
            nDamage    = CBattleSystem::CalcDamageUser2Monster(nAtk, nDef, pAtker->GetLev(), pTarget->GetLev());
        nDamage = pTarget->AdjustWeaponDamage(nDamage);
        nDamage    = CBattleSystem::AdjustMinDamageUser2Monster(nDamage, pAtker, pTarget);
    }
    else if(pAtker->IsMonster() && pTarget->QueryOwnerUser())
    {
        CMonster* pMonster;
        if(pAtker->QueryObj(OBJ_MONSTER, IPP_OF(pMonster)) && !pMonster->IsEquality())
            nDamage    = CBattleSystem::CalcDamageMonster2User(nAtk, nDef, pAtker->GetLev(), pTarget->GetLev());
        nDamage = pTarget->AdjustWeaponDamage(nDamage);
        nDamage    = CBattleSystem::AdjustMinDamageMonster2User(nDamage, pAtker, pTarget);
    }
    else
    {
        nDamage    = pTarget->AdjustWeaponDamage(nDamage);
    }

    return ::CutTrail(0, nDamage);
}

//////////////////////////////////////////////////////////////////////
int    CBattleSystem::AdjustMinDamageUser2Monster(int nDamage, IRole* pAtker, IRole* pTarget)
{
    int nMinDamage = 1;
    nMinDamage += pAtker->GetLev() / 10;

    CUser* pUser;
    if(!pAtker->QueryObj(OBJ_USER, IPP_OF(pUser)))
        return ::CutTrail(nMinDamage, nDamage);

    CItem* pItem = pUser->GetWeaponR();
    if(pItem)
    {
        nMinDamage += pItem->GetQuality();
    }

    return ::CutTrail(nMinDamage, nDamage);
}

//////////////////////////////////////////////////////////////////////
int    CBattleSystem::AdjustMinDamageMonster2User(int nDamage, IRole* pAtker, IRole* pTarget)
{
    int nMinDamage = 7;

    if(nDamage >= nMinDamage || pTarget->GetLev() <= 15)
        return nDamage;

    CUser* pUser;
    if(!pTarget->QueryObj(OBJ_USER, IPP_OF(pUser)))
        return ::CutTrail(nMinDamage, nDamage);

    for(int i = ITEMPOSITION_EQUIPBEGIN; i < ITEMPOSITION_EQUIPEND; i++)
    {
        switch(i)
        {
        case    ITEMPOSITION_HELMET:
        case    ITEMPOSITION_NECKLACE:
        case    ITEMPOSITION_ARMOR:
            {
                CItem* pItem = pUser->GetEquipItemByPos(i);
                if(pItem)
                {
                    nMinDamage -= pItem->GetQuality() / 5;
                }
            }
            break;
        }
    }
    nMinDamage = ::CutTrail(1, nMinDamage);

    return ::CutTrail(nMinDamage, nDamage);
}

//////////////////////////////////////////////////////////////////////
int CBattleSystem::CalcDamageUser2Monster(int nAtk, int nDef, int nAtkLev, int nDefLev)
{
    if(nAtkLev > 120)
        nAtkLev = 120;

    int nDamage = nAtk-nDef;
    
    if (CMonster::GetNameType(nAtkLev, nDefLev) != NAME_GREEN)
        return ::CutTrail(0, nDamage);

    int nDeltaLev = nAtkLev - nDefLev;
    if (nDeltaLev >= 3 && nDeltaLev <= 5)
        nAtk *= 1.5;
    else if (nDeltaLev > 5 && nDeltaLev <= 10)
        nAtk *= 2;
    else if (nDeltaLev > 10 && nDeltaLev <= 20)
        nAtk *= 2.5;
    else if (nDeltaLev > 20)
        nAtk *= 3;

    return ::CutTrail(0, nAtk-nDef);


//    if(nAtkLev - nDefLev > 0)
//    {
//        int nDeltaLev = nAtkLev - nDefLev;
//        if(1<nAtkLev && nAtkLev<=19)
//        {
//            if(nDeltaLev<3)
//                nDamage=nAtk-nDef;
//            else if(3 <= nDeltaLev && nDeltaLev < 6)
//                nDamage=nAtk*1.2-nDef;
//            else
//                nDamage=nAtk*1.5-nDef;
//        }
//        else if(19<nAtkLev && nAtkLev<=49)
//        {
//            if(nDeltaLev<5)
//                nDamage=nAtk-nDef;
//            else if(5 <= nDeltaLev && nDeltaLev < 10)
//                nDamage=nAtk*1.2-nDef;
//            else
//                nDamage=nAtk*1.5-nDef;
//        }
//        else if(49<nAtkLev && nAtkLev<=85)
//        {
//            if(nDeltaLev<4)
//                nDamage=nAtk-nDef;
//            else if(4 <= nDeltaLev && nDeltaLev < 8)
//                nDamage=nAtk*1.2-nDef;
//            else
//                nDamage=nAtk*1.5-nDef;
//        }
//        else if(85<nAtkLev && nAtkLev<=112)
//        {
//            if(nDeltaLev<3)
//                nDamage=nAtk-nDef;
//            else if(3 <= nDeltaLev && nDeltaLev < 6)
//                nDamage=nAtk*1.2-nDef;
//            else
//                nDamage=nAtk*1.5-nDef;
//        }
//        else if(112<nAtkLev && nAtkLev<=120)
//        {
//            if(nDeltaLev<2)
//                nDamage=nAtk-nDef;
//            else if(2 <= nDeltaLev && nDeltaLev < 4)
//                nDamage=nAtk*1.2-nDef;
//            else
//                nDamage=nAtk*1.5-nDef;
//        }
//    }
//    else
//    {
//        nDamage=nAtk-nDef;
//    }
//
//    return ::CutTrail(0, nDamage);
}
//////////////////////////////////////////////////////////////////////
int CBattleSystem::CalcDamageMonster2User(int nAtk, int nDef, int nAtkLev, int nDefLev)
{
    if(nAtkLev > 120)
        nAtkLev = 120;

    int nDamage = nAtk-nDef;

    int nNameType = CMonster::GetNameType(nDefLev, nAtkLev);
    if (nNameType == NAME_RED)
    {
        nDamage = nAtk*1.5 - nDef;
    }
    else if (nNameType == NAME_BLACK)
    {
        int nDeltaLev = nDefLev - nAtkLev;
        if (nDeltaLev >= -10 && nDeltaLev <= -5)
            nAtk *= 2;
        else if (nDeltaLev >= -20 && nDeltaLev < -10)
            nAtk *= 3.5;
        else if (nDeltaLev < -20)
            nAtk *= 5;
        nDamage = nAtk - nDef;
    }

//    if(nAtkLev - nDefLev > 0)
//    {
//        int nDeltaLev = nDefLev-nAtkLev;
//        if(1<nAtkLev && nAtkLev<=19)
//        {
//            if(nDeltaLev<3)
//                nDamage=nAtk-nDef;
//            else if(3 <= nDeltaLev && nDeltaLev < 6)
//                nDamage=nAtk+14-nDef;
//            else
//                nDamage=nAtk+14*2-nDef;
//        }
//        else if(19<nAtkLev && nAtkLev<=49)
//        {
//            if(nDeltaLev<5)
//                nDamage=nAtk-nDef;
//            else if(5 <= nDeltaLev && nDeltaLev < 10)
//                nDamage=nAtk+50-nDef;
//            else
//                nDamage=nAtk+50*2-nDef;
//        }
//        else if(49<nAtkLev && nAtkLev<=85)
//        {
//            if(nDeltaLev<4)
//                nDamage=nAtk-nDef;
//            else if(4 <= nDeltaLev && nDeltaLev < 8)
//                nDamage=nAtk+96-nDef;
//            else
//                nDamage=nAtk+96*2-nDef;
//        }
//        else if(85<nAtkLev && nAtkLev<=112)
//        {
//            if(nDeltaLev<3)
//                nDamage=nAtk-nDef;
//            else if(3 <= nDeltaLev && nDeltaLev < 6)
//                nDamage=nAtk+140-nDef;
//            else
//                nDamage=nAtk+140*2-nDef;
//        }
//        else if(112<nAtkLev && nAtkLev<=120)
//        {
//            if(nDeltaLev<2)
//                nDamage=nAtk-nDef;
//            else if(2 <= nDeltaLev && nDeltaLev < 4)
//                nDamage=nAtk+165-nDef;
//            else
//                nDamage=nAtk+165*2-nDef;
//        }
//    }
//    else
//    {
//        nDamage=nAtk-nDef;
//    }

    return ::CutTrail(0, nDamage);
} 


[nTL3fTy]

CSV3's attack system is based on TQs if I recall: