damage limitter c++ anti cheat

//martysama0134's 2022
#ifdef ENABLE_HIT_LIMITER
const WORD wHitLimiterBow = 2550;
const WORD wHitLimiterSWORD = 2450;
// const WORD wHitLimiterHANDED
const WORD wHitLimiterHANDED = 2450;
const WORD wHitLimiterDAGGER = 2450;
const WORD wHitLimiterBELL = 2450;
const WORD wHitLimiterFAN = 2450;
const WORD wHitLimiterCLAW = 2450;
// const WORD wHitLimiterSWORD = 2550;
const WORD wHitLimiterPoly = 2450;
const long lMaxDistanceDiff = 60;
const DWORD dwMinBlockedHitsToLog = 3500;

// race, min time (milisec) to next hit
std::map<BYTE, WORD> m_hit_limiter = {
                                            { MAIN_RACE_WARRIOR_M, 200 },
                                            { MAIN_RACE_ASSASSIN_M, 200 },
                                            { MAIN_RACE_SURA_M, 200 },
                                            { MAIN_RACE_SHAMAN_M, 200 },
                                            //
                                            { MAIN_RACE_WARRIOR_W, 200 },
                                            { MAIN_RACE_ASSASSIN_W, 200 },
                                            { MAIN_RACE_SURA_W, 200 },
                                            { MAIN_RACE_SHAMAN_W, 200 },
                                            #ifdef ENABLE_WOLFMAN_CHARACTER
                                            { MAIN_RACE_WOLFMAN_M, 200 },
                                            #endif
                                        };
#endif

//martysama0134's 2022
#ifdef ENABLE_HIT_LIMITER
extern std::map<BYTE, WORD> m_hit_limiter;
extern const WORD wHitLimiterPoly;
extern const WORD wHitLimiterBow;
extern const WORD wHitLimiterSWORD;
extern const WORD wHitLimiterHANDED;
extern const WORD wHitLimiterDAGGER;
extern const WORD wHitLimiterBELL;
extern const WORD wHitLimiterFAN;
extern const WORD wHitLimiterCLAW;
extern const long lMaxDistanceDiff;
extern const DWORD dwMinBlockedHitsToLog;
#endif

#ifdef ENABLE_HIT_LIMITER
void CHARACTER::SetLastTimeAttack(LPCHARACTER victim)
{
    if (!victim)
        return;

    DWORD dwVID = victim->GetVID();
    unsigned long long currentMillis = static_cast<unsigned long long>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());

    if (um_Enemy_VIDs.find(dwVID) == um_Enemy_VIDs.end())
        um_Enemy_VIDs.insert(std::make_pair(dwVID, currentMillis));
    else
        um_Enemy_VIDs[dwVID] = currentMillis;

    m_lLastAttackTime = currentMillis;
    SetLastPosAttack(GetXYZ());
}

unsigned long long CHARACTER::GetHitLimiterTimeLimit() const
{
    LPITEM pkBow = GetWear(WEAR_WEAPON);

    if (pkBow && pkBow->GetProto()->bSubType == WEAPON_BOW)
        return wHitLimiterBow;
 
    LPITEM pkWeapon = GetWear(WEAR_WEAPON);
 
    if (pkWeapon && pkWeapon->GetProto()->bSubType == WEAPON_SWORD)
        return wHitLimiterSWORD;
 
    if (pkWeapon && pkWeapon->GetProto()->bSubType == WEAPON_TWO_HANDED)
        return wHitLimiterHANDED;
 
    if (pkWeapon && pkWeapon->GetProto()->bSubType == WEAPON_DAGGER)
        return wHitLimiterDAGGER;
 
    if (pkWeapon && pkWeapon->GetProto()->bSubType == WEAPON_BELL)
        return wHitLimiterBELL;
 
    if (pkWeapon && pkWeapon->GetProto()->bSubType == WEAPON_FAN)
        return wHitLimiterFAN;
 
    if (pkWeapon && pkWeapon->GetProto()->bSubType == WEAPON_CLAW)
        return wHitLimiterCLAW;
 
 
    return IsPolymorphed() ? wHitLimiterPoly : m_hit_limiter[GetRaceNum()];
}

bool CHARACTER::CanAttackVID(DWORD dwVID)
{
    unsigned long long currentMillis = static_cast<unsigned long long>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
    const unsigned long long lMaxTimeDiff = GetHitLimiterTimeLimit();
 
    if (um_Enemy_VIDs.find(dwVID) != um_Enemy_VIDs.end())
    {
        if (currentMillis - um_Enemy_VIDs[dwVID] < lMaxTimeDiff)
        {
            m_dwBlockedHits++;
            return false;
        }
    }
 
    PIXEL_POSITION pos = GetXYZ();
    const long distance = DISTANCE_APPROX(m_posLastAttack.x - pos.x, m_posLastAttack.y - pos.y);
    const unsigned long long lLastAttackLimitTime = lMaxTimeDiff == wHitLimiterBow ? wHitLimiterBow : 100 || wHitLimiterSWORD ? wHitLimiterSWORD : 100 || wHitLimiterHANDED ? wHitLimiterHANDED : 100 || wHitLimiterDAGGER ? wHitLimiterDAGGER : 100 || wHitLimiterBELL ? wHitLimiterBELL : 100 || wHitLimiterFAN ? wHitLimiterFAN : 100|| wHitLimiterCLAW ? wHitLimiterCLAW : 100;
 
    if ((distance > lMaxDistanceDiff) && (currentMillis - m_lLastAttackTime <= lLastAttackLimitTime))
    {
        m_dwBlockedHits++;
        return false;
    }
 
    return true;
}
#endif