Aimbot nie namierza na przeciwników

vec3_t calcAng(const vec3_t& src, const vec3_t& dst, vec3_t& angles, vec3_t& mpnch, vec3_t& myOrig)
{
    float pitchreduction;
    float yawreduction;
    pitchreduction = mpnch.x * 2.f;
    yawreduction = mpnch.y * 2.f;
    vec3_t delta = vec3_t((src.x - dst.x), (src.y - dst.y), (src.z + myOrig.z - dst.z));
    float hyp = (float)sqrt(delta[0] * delta[0] + delta[1] * delta[1]);

    angles[0] = (float)(atan(delta[2] / hyp) * (float)57.295779513082f) - pitchreduction;
    angles[1] = (float)(atan(delta[1] / delta[0]) * (float)57.295779513082f) - yawreduction;
    angles[2] = 0.f;
    if (delta[0] >= 0.0)
    {
        angles[1] += 180.0f;
        angles[2] = 0.f;
    }
    return angles;
}


void calcFov(vec3_t& src, vec3_t& dst, vec3_t& viewAngl, vec3_t& mpnch, vec3_t& myOrig)
{
    float delta[3] = { (src.x - dst.x), (src.y - dst.y), (src.z + myOrig.z - dst.z) };
    float hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);
    viewAngl.x = atanf(delta[2] / hyp) * (180 / M_PI);
    viewAngl.y = atanf(delta[1] / delta[0]) * (180 / M_PI);
    viewAngl.z = 0.0f;
    if (delta[0] >= 0.0) 
    {
        viewAngl.y += 180.0f;
    }
}

void ClampAngles(vec3_t& angles)
{
    if (angles.x > 89.0f) angles.x = 89.0f;
    else if (angles.x < -89.0f) angles.x = -89.0f;
    /*
    if (angles.yaw > 180.0f) angles.yaw = 180.0f;
    else if (angles.yaw < -180.0f) angles.yaw = -180.0f;
    */

    if (angles.y > 180)
        angles.y -= 360;
    if (angles.y < -180)
        angles.y += 360;

    angles.z = 0;
}
float calcDist(vec3_t& myPos, vec3_t& enPos)
{
    return sqrt(
        pow(double(myPos[0] - enPos[0]), 2.0) +
        pow(double(myPos[1] - enPos[1]), 2.0) +
        pow(double(myPos[2] - enPos[2]), 2.0));
}

void cfeatures::aimbot() 
{
    auto local = centity::getlocal();
    float bestdistance = 9999;
    int target = -1;
    bool visycheck;
    if (settings_t.vischeck == 1)
    {
        visycheck = false;
    }
    else
    {
        visycheck = true;
    }
    float psmooth = settings_t.xsmooth;
    float ysmooth = settings_t.ysmooth;
    if (psmooth < 2.f || ysmooth < 2.f)
    {
        psmooth = 2.f;
        ysmooth = 2.f;
    }
    float paura = settings_t.xfov;
    float yaura = settings_t.yfov;
    if (paura < 2.f || yaura < 2.f)
    {
        paura = 2.f;
        yaura = 2.f;
    }
    float checkx = paura;
    float checkxtwo = paura * -2.f;
    float checky = yaura;
    float checkytwo = yaura * -2.f;
    vec3_t diff;

    if (local.team() > 1 && local.team() < 4 && local.health() > 0)
    {
        DWORD dwPlayerz = mem->read<DWORD>(offys::clientdll + offys::dwLocalPlayer);
        DWORD dwEnginez = mem->read<DWORD>(offys::enginedll + offys::dwClientState);
        int localid = mem->read<int>(dwPlayerz + offys::m_Local);

        if (GetAsyncKeyState(settings_t.aim_key) & 0x8000)
        {
            vec3_t mypunch = mem->read<vec3_t>(dwPlayerz + offys::m_aimPunchAngle);
            vec3_t curangl, stableang = mem->read<vec3_t>(dwEnginez + offys::dwClientState_ViewAngles);
            vec3_t myPos = mem->read<vec3_t>(dwPlayerz + offys::m_vecOrigin);
            vec3_t myOrig = mem->read<vec3_t>(dwPlayerz + offys::m_vecViewOffset);
            for (int i = 0; i < 32; i++)
            {
                auto ent = centity::getentity(i);
                if (ent.dormant() || local.team() == ent.team() && ent.health() < 1)
                {
                    continue;
                }
                vec3_t testanga, testangb = mem->read<vec3_t>(dwEnginez + offys::dwClientState_ViewAngles);
                calcFov(myPos, ent.position, testanga, mypunch, myOrig);
                diff.x = testanga.x - testangb.x;
                diff.y = testanga.y - testangb.y;
                ClampAngles(diff);
                diff.y = fabs(diff.y);
                float idistance = calcDist(myPos, ent.position);
                ent.fovx = sin(diff.x * (float)(M_PI / 180)) * idistance;
                ent.fovy = sin(diff.y * (float)(M_PI / 180)) * idistance;
                int tempmask = mem->read<int>(ent.dwBase + offys::m_bSpottedByMask);
                int pid = localid - 1;
                if (diff.y < 90.f && ent.fovy < checky && ent.fovy > checkytwo&& ent.fovx > checkxtwo&& ent.fovx < checkx && ent.fovx != 0 && ent.fovy != 0)
                {
                    if (!ent.dormant() && local.team() != ent.team() && ent.health() > 0 && ((tempmask & (0x1 << pid)) != 0 || visycheck))
                    {
                        float vec3_tlength = sqrt(ent.fovy * ent.fovy + ent.fovx * ent.fovx);
                        if (vec3_tlength < bestdistance)
                        {
                            bestdistance = vec3_tlength;
                            target = i;
                        }
                    }
                }
            }
            auto ent_target = centity::getentity(target);
            if (ent_target.health() < 1 || ent_target.health() > 2000000 || ent_target.dormant() || target == -1 || ent_target.fovy > checky || ent_target.fovy < checkytwo || ent_target.fovx < checkxtwo || ent_target.fovx > checkx)
            {
                target = -1;
                bestdistance = 9999;
                return;
            }
            if (ent_target.weapon_ammo() == 0)
            {
                return;
            }
            calcAng(myPos, ent_target.position, curangl, mypunch, myOrig);
            vec3_t randomname;
            randomname.x = curangl.x - stableang.x;
            randomname.y = curangl.y - stableang.y;
            randomname.z = 0.f;
            ClampAngles(randomname);
            randomname.x = stableang.x + (randomname.x / 100.f) * (45.f / psmooth);
            randomname.y = stableang.y + (randomname.y / 100.f) * (45.f / ysmooth);
            randomname.z = stableang.z;
            ClampAngles(randomname);
            if (settings_t.aim_delay > 0)
            {
                Sleep(settings_t.aim_delay);
            }
            mem->write<vec3_t>(dwEnginez + offys::dwClientState_ViewAngles, randomname);
            Sleep(settings_t.aim_time);
        }
        else
        {
            bestdistance = 9999;
            target = -1;
        }
    }
}

ewentualnie takie getFOV

float calcFov(Vector& src, Vector& dst, Vector& angles, Vector& mpnch, Vector& myOrig)
    {
        Vector ang, aim, angle;
        calcAng(src, dst, angles, mpnch, myOrig);
        MakeVector(angle, aim);
        MakeVector(ang, ang);
        float fov;
        bool bDistancebased = false;
 
        float mag_s = sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2]));
        float mag_d = sqrt((aim[0] * aim[0]) + (aim[1] * aim[1]) + (aim[2] * aim[2]));
 
        float u_dot_v = aim[0] * ang[0] + aim[1] * ang[1] + aim[2] * ang[2];
 
        fov = acos(u_dot_v / (mag_s*mag_d)) * (180.f / M_PI);
 
        fov *= 1.4;
 
        if (!bDistancebased)
        {
            float xDist = abs(src[0] - dst[0]);
            float yDist = abs(src[1] - dst[1]);
            float Distance = sqrt((xDist * xDist) + (yDist * yDist));
 
            Distance /= 650.f;
 
            if (Distance < 0.7f)
                Distance = 0.7f;
 
            if (Distance > 6.5f)
                Distance = 6.5f;
 
            fov *= Distance;
        }
        return (float)fov;
    }

@Adi2071 Uzyj debuggera i zobacz czy wywala jakis blad.

Debugger nie widzi żadnego błędu.

Aimbot w ogóle nie działa czy robi dziwne rzeczy? Jak w ogóle to poustawiaj breakpointy i sprawdź na czym kończy się wykonywanie kodu, wtedy łatwiej będzie dojść do tego co jest źle.

PS. Jak robisz pętle to 

for (int i = 1; i <= 32; i++)

a nie

for (int i = 0; i < 32; i++)

PS2. Wydaje mi się, że wina jest matematyka związana z calcfov i wszystkimi checkami w pętli.

Ja używam tego:

Nawet po zaktualizowaniu offsetów nawet RCS nie działa :), pokazuje x y i z :inf , znalazłem inny kod to pokazuje wartości x i y ale nie kontroluje.

Co do aimbota w ogole nie działa.

@Adi2071 To wykorzystaj debuger i breakpointy i zobacz do którego momentu kod się wykonuje, zapewne któryś z if'ów nie puszcza dalej i jest to spowodowane innymi błędami.

Jak korzystasz z mojego source jako bazy to polecam ci skorzystać z tego: https://github.com/patrykkolodziej/Abzynt-Cheat   Dużo lepiej zooptymalizowany niż to co wtedy napisałem.

Kod fajnie napisany, ale mimo zaktualizowania offsetów to działa tylko clr render :). Coś innego możesz mi polecić pod baze?

@Adi2071 jesteś pewny że dobrze zaktualizowałeś? Czit działał i nic się szczególnego w CS nie zmieniło żeby miał mieć problemy.

dobrze, bo przekopiowałem całość z hazedumpera, zmieniłem na DWORD, w offsetach. h zmieniłem też wszystko z dopiskiem extern. ale nie działa RCS. autopistola nie sprawdzałem, trigger działa bez zarzutu, bhop i glow tak samo, chociaż chciałem zrobić tak aby glow był tylko na przeciwników. aimbot moze nie działać, bo nie ma aktualizacji playersów itd co widziałem w src z aimbotem.

void UpdateLocalPlayer(const CSGOMemory& mem)
{
    g_localPlayer = {};
    Player newLocalPlayer;

    auto localPlayer = mem.Read<uint32_t>(mem.GetClientBase() + dwLocalPlayer);
    if (localPlayer != std::nullopt && localPlayer != 0x0)
    {
        newLocalPlayer.m_dwBase = localPlayer.value();
        newLocalPlayer.m_glowIndex = mem.Read<uint32_t>(newLocalPlayer.m_dwBase + m_iGlowIndex).value();
        newLocalPlayer.m_plrData = mem.Read<PlayerStruct>(newLocalPlayer.m_dwBase).value();

        g_localPlayer = newLocalPlayer;
    }
    else
    {
       std::cout << "WARN: Failed updating localPlayer!" << std::endl;
    }
}

Nie mam pojęcia co z tym kodem jest nie tak, puki nie jestem w meczu cały czas spamuje w konsoli "WARN: Failed updating localPlayer!". Kilka razy jak wyłączę i włączę haxa to już jest okey.

@Adi2071 no bo póki nie jesteś w meczu to nie ma localplayera. Co rozumiesz poprzez brak aktualizacji playersow?

2 godziny temu, uzytkownik napisał:

@Adi2071 no bo póki nie jesteś w meczu to nie ma localplayera. Co rozumiesz poprzez brak aktualizacji playersow?

struct PlayerStruct
{
    char pad_0000[244]; //0x0000
    int32_t m_iTeamNum; //0x00F4
    char pad_00F8[8]; //0x00F8
    int32_t m_iHealth; //0x0100
    char pad_0104[4]; //0x0104
    Vector m_vecViewOffset; //0x0108
    char pad_0114[36]; //0x0114
    Vector m_vecOrigin; //0x0138
};

struct Player
{
    PlayerStruct m_plrData{};
    uint32_t m_dwBase = 0;
    uint32_t m_glowIndex = 0;

    bool Update(const uint32_t index, const CSGOMemory& mem)
    {
        auto player = mem.Read<uint32_t>(mem.GetClientBase() + dwEntityList + ((index - 1) * 0x10));

        if (player != std::nullopt && player != 0x0)
        {
            m_dwBase = player.value();

            m_glowIndex = mem.Read<uint32_t>(m_dwBase + m_iGlowIndex).value();
            m_plrData = mem.Read<PlayerStruct>(m_dwBase).value();

            return true;
        }

        return false;
    }

    Vector BonePos(const int boneId, const CSGOMemory& mem) const
    {
        const auto boneBase = mem.Read<uint32_t>(m_dwBase + m_dwBoneMatrix);
        if (boneBase == std::nullopt || boneBase == 0x0)
            throw std::exception("'boneBase' not found!");

        const uint32_t base = boneBase.value() + (0x30 * boneId);
        const BoneStruct boneVector = *mem.Read<BoneStruct>(base);

        Vector vBone;
        vBone.x = boneVector.x;
        vBone.y = boneVector.y;
        vBone.z = boneVector.z;

        return vBone;
    }

    int GetWeapon(const CSGOMemory& mem) const
    {
        const uint32_t weapon = *mem.Read<uint32_t>(m_dwBase + m_hActiveWeapon);
        const uint32_t duck = weapon & 0xFFF;
        const uint32_t horse = *mem.Read<uint32_t>(mem.GetClientBase() + dwEntityList + (duck - 1) * 0x10);

        return mem.Read<int>(horse + m_iItemDefinitionIndex).value_or(0);
    }

    void Glow(const float r, const float g, const float b, const CSGOMemory& mem) const
    {
        const uint32_t glowStructBase = mem.GetGlowBase() + (m_glowIndex * 0x38) + 0x4;

        g_glowStr = *mem.Read<GlowStruct>(glowStructBase);

        g_glowStr.R = 0;
        g_glowStr.G = 255;
        g_glowStr.B = 0;
        g_glowStr.m_flGlowAlpha = 0.7f;
        g_glowStr.m_bRenderWhenOccluded = true;
        g_glowStr.m_bRenderWhenUnoccluded = false;

        (void)mem.Write<GlowStruct>(glowStructBase, g_glowStr);
    }
}g_localPlayer; // TODO: tidy up global variables across the project
std::vector<Player> g_playerList;
#pragma endregion

void UpdatePlayerList(const CSGOMemory& mem)
{
    g_playerList.clear();
    g_playerList.resize(0);

    // localplayer is always first in the list vs bots, but in real games we have to separately update
    UpdateLocalPlayer(mem);

    // TODO: find a way to loop through max players
    // TODO: iterate through the list correctly -> it is a linked list -> https://github.com/ValveSoftware/source-sdk-2013/blob/master/mp/src/game/shared/entitylist_base.h#L20
    // update players start from 1 since world is at 0
    // the loop will stop when we stop reading players
    for (size_t i = 1; i < 32; i++)
    {
        Player player;
        // TODO: sometimes we fail reading an entity even though it should be a player???
        // we reached an entity that is not a player
        if (!player.Update(i, mem))
            continue;

        g_playerList.push_back(player);
    }
}

Coś takiego. W twoim kodzie nie widziałem czegoś takiego / podobnego. 

Z tym Aimbotem da się zrobić coś lepszego?

#pragma region AimBot

Vector GetLocalEye()
{
    return g_localPlayer.m_plrData.m_vecOrigin + g_localPlayer.m_plrData.m_vecViewOffset;
}

Vector CalculateAngle(const Vector& delta)
{
    Vector returnVec;

    returnVec.x = static_cast<float>(asinf(delta.z / GetMagnitude(delta)) * g_radPi); //yaw
    returnVec.y = static_cast<float>(atanf(delta.y / delta.x) * g_radPi);	             //pitch
    returnVec.z = 0.0f;

    if (delta.x >= 0.0)
    {
        returnVec.y += 180.0f;
    }

    return returnVec;
}

void NormalizeAngles(Vector& angles)
{
    while (angles.x < -180.0f) angles.x += 360.0f;
    while (angles.x > 180.0f) angles.x -= 360.0f;

    while (angles.y < -180.0f) angles.y += 360.0f;
    while (angles.y > 180.0f) angles.y -= 360.0f;
}

void ClampAngles(Vector& angles)
{
    angles.x = std::clamp(angles.x, -89.0f, 89.0f);
    angles.y = std::clamp(angles.y, -180.0f, 180.0f);
    angles.z = 0.0f;
}

float calcFov(const Vector& src, const Vector& dst)
{
    Vector viewAngl;
    Vector delta = { (src.x - dst.x), (src.y - dst.y), (src.z - dst.z) };
    double hyp = sqrt(delta.x * delta.x + delta.y * delta.y);
    NormalizeAngles(delta);
    viewAngl.x = atanf(delta.z / hyp) * g_radPi;
    viewAngl.y = atanf(delta.y / delta.x) * g_radPi;
    viewAngl.z = 0.0f;
    if (delta.x >= 0.0) 
    {
        viewAngl.y += 180.0f;
    }
    return sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z);
}

float GetFOV(const Vector& src, const Vector& dest)
{
    Vector delta = { src.x - dest.x, src.y - dest.y, src.z - dest.z };
    NormalizeAngles(delta);
    return sqrt(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z);
}

void GetClosestEnt(const Vector& currentAng, int& index, const CSGOMemory& mem)
{
    UpdateLocalPlayer(mem);
   
    for (size_t i = 0; i < g_playerList.size(); i++)
    {
        if (!g_playerList.at(i).Update(i + 1, mem))
            continue;

        if (g_playerList.at(i).m_plrData.m_iTeamNum == g_localPlayer.m_plrData.m_iTeamNum)
            continue;
        if (g_playerList.at(i).m_plrData.m_iHealth < 1)
            continue;

        Vector enemyHeadPos = g_playerList.at(i).BonePos(8, mem);

        Vector localEye = GetLocalEye();

        const Vector delta = localEye - enemyHeadPos;

        Vector finalAng = CalculateAngle(delta);

        const float fov = calcFov(currentAng, finalAng);

        if (fov < g_minFov)
        {
            index = i;
        }
    }
}

void AimLoop(const CSGOMemory& mem)
{
    if (!GetAsyncKeyState(0x01)) return;

    auto localPlayer = *mem.Read<uint32_t>(mem.GetClientBase() + dwLocalPlayer);
    const uint32_t clientState = *mem.Read<uint32_t>(mem.GetEngineBase() + dwClientState);
    Vector currentAng = *mem.Read<Vector>(clientState + dwClientState_ViewAngles);
    Vector punchAng = *mem.Read<Vector>(localPlayer + m_aimPunchAngle);

    int index = -1;
    GetClosestEnt(currentAng, index, mem);

    if (index == -1)
        return;

    const Vector enemyHeadPos = g_playerList.at(index).BonePos(g_boneId, mem);
    Vector delta = GetLocalEye() - enemyHeadPos;
    const Vector finalAng = CalculateAngle(delta);


    float deltaX = finalAng.x - (currentAng.x + punchAng.x * 2.f);
    float deltaY = finalAng.y - (currentAng.y + punchAng.y * 2.f);

    if (deltaX < -180.0f) deltaX += 360.0f;
    if (deltaX > 180.0f) deltaX -= 360.0f;

    if (deltaY < -180.0f) deltaY += 360.0f;
    if (deltaY > 180.0f) deltaY -= 360.0f;


    Vector smoothedAngle;
    smoothedAngle.x = deltaX  / g_smooth;
    smoothedAngle.y = deltaY  / g_smooth;

    int loop = 0;
    while (loop < 10)
    {
        NormalizeAngles(currentAng);
        ClampAngles(currentAng);
        (void)mem.Write<Vector>(clientState + dwClientState_ViewAngles, currentAng);

        loop++;

        currentAng.x += smoothedAngle.x;
        currentAng.y += smoothedAngle.y;
    }
}

#pragma endregion

@Adi2071 Jeżeli w moim kodzie nie było by czegoś takiego to nic by nie działało xD https://github.com/patrykkolodziej/Abzynt-Cheat/blob/master/Abzynt/Abzynt/sdk/entities/player/player.cpp

PS. Nie działały ci funkcje wszystkie bo nie zaaktualizowałeś wszystkiego po prostu.

Co do aimbota to na pewno się da coś poprawić.

4 godziny temu, uzytkownik napisał:

@Adi2071 Jeżeli w moim kodzie nie było by czegoś takiego to nic by nie działało xD https://github.com/patrykkolodziej/Abzynt-Cheat/blob/master/Abzynt/Abzynt/sdk/entities/player/player.cpp

PS. Nie działały ci funkcje wszystkie bo nie zaaktualizowałeś wszystkiego po prostu.

 

Co do aimbota to na pewno się da coś poprawić.

W tym Abzynt po zaktualizowaniu działa mi clr render, zmiana fov, radar, noflash

nie działa autopistol, trigger i glow, twój kod jest dużo lepszy