KardofflHook | Client.cpp

#include "Includes.h"
#include "sdk.h"

#define MakePtr( Type, dwBase, dwOffset ) ( ( Type )( DWORD( dwBase ) + (DWORD)( dwOffset ) ) )
#define M_RADPI 57.295779513082f
#define square( x ) ( x * x )
ScreenSize_t sScreenSize2;
bool bResChange = false;
int iTarget = -1;
float flDistance = 9999.0f;
QAngle qAngle;

float GetFov(QAngle angle, Vector src, Vector dst)
{
    QAngle ang, aim;
    float fov;

    Vector tmp = dst - src;
    VectorAngles(tmp, ang);
    QAngle vTempAngles = ang - angle;
    NormalizeAngles(vTempAngles);

    return vTempAngles.Length();
}

bool GetVisible(Vector& vAbsStart, Vector& vAbsEnd, IClientEntity* pEntity)
{
    trace_t tr;
    Ray_t ray;
    CTraceFilterNoPlayers filter;
    filter.pSkip = Ikaros.m_pEntity->Ent();

    ray.Init(vAbsStart, vAbsEnd);
    Ikaros.m_pEnginetrace->TraceRay(ray, 0x4600400B, &filter, &tr);

    return (tr.m_pEnt == pEntity || tr.fraction > 0.99f);
}

bool GetHitboxPosition(IClientEntity* ClientEntity, int iHitBox, Vector* vOut)
{
    matrix3x4a_t pmatrix[128];

    Vector vMin, vMax;

    const model_t* model = ClientEntity->GetModel();

    if (!model)
        return false;

    studiohdr_t *pStudioHdr = Ikaros.m_pModelinfo->GetStudiomodel(model);

    if (pStudioHdr == NULL)
        return false;

    if (!ClientEntity->SetupBones(pmatrix, 128, 0x00000100, 0))
        return false;

    mstudiohitboxset_t *set = pStudioHdr->pHitboxSet(Ikaros.m_pEntity->GetHitboxSet(ClientEntity));

    if (!set)
        return false;

    mstudiobbox_t* pbox = set->pHitbox(iHitBox);

    // center and all the points of the hitbox
    Vector points[9] = { ((pbox->bbmin + pbox->bbmax) * .5f), // center
        Vector(pbox->bbmin.x, pbox->bbmin.y, pbox->bbmin.z), // left bottom back corner
        Vector(pbox->bbmin.x, pbox->bbmax.y, pbox->bbmin.z), // left bottom front corner
        Vector(pbox->bbmax.x, pbox->bbmax.y, pbox->bbmin.z), // left top front corner
        Vector(pbox->bbmax.x, pbox->bbmin.y, pbox->bbmin.z), // left top back corner
        Vector(pbox->bbmax.x, pbox->bbmax.y, pbox->bbmax.z), // right top front corner
        Vector(pbox->bbmin.x, pbox->bbmax.y, pbox->bbmax.z), // right bottom front corner
        Vector(pbox->bbmin.x, pbox->bbmin.y, pbox->bbmax.z), // right bottom back corner
        Vector(pbox->bbmax.x, pbox->bbmin.y, pbox->bbmax.z)  // right top back corner
    };

    for (int index = 0; index <= 8; ++index)
    {
        if (index != 0)
        {
            // scale down the hitbox size
            points[index] = ((((points[index] + points[0]) * .5f) + points[index]) * .5f);
        }

        // transform the vector
        VectorTransform(points[index], pmatrix[pbox->bone], vOut[index]);
    }

    return true;
}

void SmoothAngles(QAngle &src, QAngle &back, QAngle &flLocalAngles, float smooth)
{
    float smoothdiff[2];
    src[0] -= flLocalAngles.x;
    src[1] -= flLocalAngles.y;
    NormalizeAngles(src);
    smoothdiff[0] = src[0] / smooth;
    smoothdiff[1] = src[1] / smooth;
    back[0] = flLocalAngles.x + smoothdiff[0];
    back[1] = flLocalAngles.y + smoothdiff[1];
    back[2] = 0;
    NormalizeAngles(back);
}
C_BaseCombatWeapon* GetBaseCombatActiveWeapon()
{
    C_BaseEntity *pLocal = (C_BaseEntity*)entitylist->GetClientEntity(engine->GetLocalPlayer());

    ULONG pWeepEhandle = *(PULONG)((DWORD)pLocal + 0x12C0);
    return (C_BaseCombatWeapon*)(entitylist->GetClientEntityFromHandle(pWeepEhandle));
}
void CalcAngles(Vector src, Vector dst, QAngle &ang)
{
    double delta[3] = { src[0] - dst[0], src[1] - dst[1], src[2] - dst[2] };
    double hyp = sqrt(delta[0] * delta[0] + delta[1] * delta[1]);

    ang[0] = (float)(atan(delta[2] / hyp) * M_RADPI);
    ang[1] = (float)(atan(delta[1] / delta[0]) * M_RADPI);
    ang[2] = 0.0f;

    if (delta[0] >= 0.0) ang[1] += 180.0f;
}
void Aimbot(CUserCmd* cmd, C_BaseCombatWeapon* Weapon)
{
    iTarget = -1;
    flDistance = 9999.0f;
    qAngle.Init();
    player_info_t playerInfo;
    Vector aiming_Org[64];
    Vector vecTarget, vecEntity[9], vecEyePos = Ikaros.m_pEntity->GetEyePos(Ikaros.m_pEntity->Ent()) + (Ikaros.m_pEntity->GetVelocity(Ikaros.m_pEntity->Ent()) * Ikaros.m_pGlobals->interval_per_tick);
    QAngle qPunch = Ikaros.m_pEntity->GetPunchAngle(Ikaros.m_pEntity->Ent()) * 2;

    int WeaponID = GetBaseCombatActiveWeapon()->GetCSWpnData()->WeaponID;
    int WeaponType = GetBaseCombatActiveWeapon()->GetCSWpnData()->WeaponType;

    for (int i = Ikaros.m_pEntlist->GetHighestEntityIndex(); i > 0; --i)
    {
        if (i == Ikaros.m_pEngine->GetLocalPlayer())
            continue;

        IClientEntity* Entity = Ikaros.m_pEntlist->GetClientEntity(i);

        if (Entity == NULL
            || Entity->IsDormant()
            || !Ikaros.m_pEngine->GetPlayerInfo(i, &playerInfo)
            || !Ikaros.m_pEntity->GetLifeState(Entity)
            || Ikaros.m_pEntity->GetRenderColor(Entity).a < 255
            || Ikaros.m_pEntity->GetTeamID(Ikaros.m_pEntity->Ent()) == Ikaros.m_pEntity->GetTeamID(Entity)
            || !GetHitboxPosition(Entity, 11, vecEntity))
            continue;

        if (!GetVisible(vecEyePos, vecEntity[0], Entity))
            continue;

        float flFieldofView = GetFov(cmd->viewangles + qPunch, vecEyePos, vecEntity[0]);

        if (flFieldofView <= Ikaros.m_pConvars->flAimbotFOV && flFieldofView < flDistance)
        {
            flDistance = flFieldofView;
            iTarget = i;
            vecTarget = vecEntity[0];
        }
    }

    if (iTarget > -1)
    {
        QAngle qPreAim, qAim;
        Vector tmp = vecTarget - vecEyePos;
        VectorAngles(tmp, qPreAim);

        if (Ikaros.m_pConvars->flAimbotRCS && !Ikaros.m_pUtilities->IsPistol(Weapon) && !Ikaros.m_pUtilities->IsSniper(Weapon))
            qPreAim -= qPunch;

        NormalizeAngles(qPreAim);

        SmoothAngles(qPreAim, qAim, cmd->viewangles, Ikaros.m_pConvars->flAimbotSmooth);

        if (Ikaros.m_pConvars->flAimbotStopCrouch == 1){
            cmd->forwardmove = 0.f;
            cmd->sidemove = 0.f;
            cmd->buttons |= IN_DUCK;
        }

        if (Ikaros.m_pConvars->flAimbotSilent == 0.0f)
            Ikaros.m_pEngine->SetViewAngles(qAim);
        else if (Ikaros.m_pConvars->flAimbotSilent == 1.0f)
            cmd->viewangles = qAim;
        else if (Ikaros.m_pConvars->flAimbotSilent == 2.0f)
            qAngle = qAim;

        if (Ikaros.m_pConvars->flAimbotAutoshoot == 1.0f)
            cmd->buttons |= IN_ATTACK;

    }
}

void __stdcall CL_FixMove(CUserCmd* cmd, QAngle viewangles)
{
    Vector move, movenorm, dir, set;
    QAngle movenormang, adjusted;

    float len;

    move.Init(cmd->forwardmove, cmd->sidemove, cmd->upmove);

    movenorm = move;

    VectorNormalize(movenorm);

    len = move.Length();

    VectorAngles(movenorm, movenormang);

    if ((cmd->viewangles.x >= 89.0f) || (cmd->viewangles.x <= -89.0f))
    {
        if (viewangles.x >= 0.0f && viewangles.x <= 89.0f)
        {
            viewangles.x = cmd->viewangles.x + 180.0f;
        }
        if (viewangles.x <= 0.0f && viewangles.x >= -89.0f)
        {
            viewangles.x = cmd->viewangles.x - 180.0f;
        }
    }

    adjusted = movenormang + (cmd->viewangles - viewangles);

    AngleVectors(adjusted, &dir);

    set = dir * len;

    if ((cmd->viewangles.x > 89.0f) || (cmd->viewangles.x < -89.0f))
        cmd->forwardmove = set.x;
    else if ((cmd->viewangles.x == 89.0f || cmd->viewangles.x == -89.0f))
        cmd->forwardmove = -set.x;
    else
        cmd->forwardmove = set.x;

    if ((cmd->viewangles.x >= 89.0f) || (cmd->viewangles.x <= -89.0f))
        cmd->sidemove = -set.y;
    else
        cmd->sidemove = set.y;

    if (cmd->sidemove < -450)
        cmd->sidemove = -450;

    if (cmd->sidemove > 450)
        cmd->sidemove = 450;

    if (cmd->forwardmove < -450)
        cmd->forwardmove = -450;

    if (cmd->forwardmove > 450)
        cmd->forwardmove = 450;
}

void AntiAntiAimXProxy(const CRecvProxyData *pData, void *pStruct, void *pOut)
{
    float flPitch = pData->m_Value.m_Float;

    if (flPitch > 180.0)
        flPitch -= 360.0;
    else if (flPitch < -180.0)
        flPitch += 360.0;

    //Fakedown autofix
    if (flPitch < -179.648438f || flPitch > 179.648438f)
    {
        flPitch = -10.0f;
    }

    if (flPitch <= -88.945313f && flPitch >= -179.648438f)
    {
        flPitch = -89.0f;
    }

    if (flPitch >= 88.945313f && flPitch <= 179.648438f)
    {
        flPitch = 89.0f;
    }

    *(float*)pOut = flPitch;
}

void __stdcall new_PaintTraverse(vgui::VPANEL vguiPanel, bool forceRepaint, bool allowForce)
{
    Ikaros.m_pPanelVMT->Function<PaintTraverse_t>(41)(vguiPanel, forceRepaint, allowForce);

    const char* pszPanelName = Ikaros.m_pPanel->GetName(vguiPanel);
    bool isValidPanel = false;

    if (pszPanelName && pszPanelName[0] == 'F' && pszPanelName[5] == 'O')
        isValidPanel = true;

    if (isValidPanel)
    {
        Ikaros.m_pEngine->GetScreenSize(sScreenSize2.iWidth, sScreenSize2.iHeight);

        if (!bResChange && (sScreenSize2.iWidth != sScreenSize.iWidth || sScreenSize2.iHeight != sScreenSize.iHeight))
        {
            sScreenSize.iWidth = sScreenSize2.iWidth;
            sScreenSize.iHeight = sScreenSize2.iHeight;
            bResChange = true;
        }

        if (bResChange)
        {
            Ikaros.m_pDraw->FontInit(Ikaros.m_pFont, "Tahoma", 13, FONTFLAG_OUTLINE);
            bResChange = false;
        }

        if (Ikaros.m_pConvars->flMiscAntiUntrust > 0)
            Ikaros.m_pConvars->flRemovalsSpread = 0;

        if (Ikaros.m_pEngine->IsTakingScreenshot())
            return;

        if (Ikaros.m_pEngine->IsInGame())
        {
            if (Ikaros.m_pConvars->flESPActive)
                Ikaros.m_pESP->DrawESP();

            if (Ikaros.m_pConvars->flMiscCrosshair)
            {
                Ikaros.m_pDraw->FillRGBA((sScreenSize.iWidth / 2) - 5, (sScreenSize.iHeight / 2) - 1, 11, 3, 0, 0, 0, 255);
                Ikaros.m_pDraw->FillRGBA((sScreenSize.iWidth / 2) - 1, (sScreenSize.iHeight / 2) - 5, 3, 11, 0, 0, 0, 255);
                Ikaros.m_pDraw->FillRGBA((sScreenSize.iWidth / 2) - 4, (sScreenSize.iHeight / 2), 9, 1, 255, 255, 255, 255);
                Ikaros.m_pDraw->FillRGBA((sScreenSize.iWidth / 2), (sScreenSize.iHeight / 2) - 4, 1, 9, 255, 255, 255, 255);
            }
        }

        Ikaros.m_pDraw->Text(5, 5, 255, 255, 255, 255, 0, Ikaros.m_pFont, "Kardofflhook");


        Ikaros.m_pMenu->InitializeMenu();
        Ikaros.m_pMenu->MenuDrawing();
    }
}


#define WEAPON_SPREAD_OFFSET 0x778

QAngle GetSpreadAngle(UINT iSeed, CUserCmd* cmd, C_BaseCombatWeapon* Weapon)
{
    typedef float(__thiscall *getfloat)(void*);
    typedef void(__thiscall *funcvoid)(void*);
    ((funcvoid)((*(DWORD*)(*(DWORD*)(Weapon)+WEAPON_SPREAD_OFFSET + 0x8))))(Weapon);
    const float constInaccuracy = ((getfloat)((*(DWORD*)(*(DWORD*)(Weapon)+WEAPON_SPREAD_OFFSET))))(Weapon);
    const float constSpread = ((getfloat)((*(DWORD*)(*(DWORD*)(Weapon)+WEAPON_SPREAD_OFFSET + 0x4))))(Weapon);
    QAngle view(cmd->viewangles);
    Vector direction, right, up;
    AngleVectors(view, &direction, &right, &up);
    iSeed &= 0xFF;
    RandomSeed(iSeed + 1);
    float pi_1 = RandomFloat(0.f, 2.0f * M_PI_F);
    float inaccuracy = RandomFloat(0.f, constInaccuracy);
    Vector2D leftSpread((cos(pi_1) * inaccuracy), (sin(pi_1) * inaccuracy));
    Vector2D rightSpread[0xFF];
    for (int bullet = 0; bullet < 1; ++bullet)
    {
        float pi_2 = RandomFloat(0.f, 2.0f * M_PI_F);
        float spread = RandomFloat(0.f, constSpread);
        rightSpread[bullet] = Vector2D((cos(pi_2) * spread), (sin(pi_2) * spread));
    }
    for (int bullet = 0; bullet < 1; ++bullet)
    {
        Vector2D totalSpread = (leftSpread + rightSpread[bullet]);
        totalSpread = -totalSpread;
        Vector shot = (direction + (right * totalSpread.x) + (up * totalSpread.y));
        VectorNormalize(shot);
        float flIdentity[3][3];
        flIdentity[2][0] = 1.0f;
        flIdentity[2][1] = -totalSpread[0];
        flIdentity[2][2] = totalSpread[1];
        VectorNormalize(flIdentity[2]);
        flIdentity[0][0] = 0.0f;
        flIdentity[0][1] = -totalSpread[0];
        flIdentity[0][2] = (1.0f / totalSpread[1]) + (1.0f / flIdentity[2][2]) + totalSpread[1];
        if (totalSpread[0] > 0.0f && totalSpread[1] < 0.0f)
        {
            if (flIdentity[0][1] < 0.0f)
                flIdentity[0][1] = -flIdentity[0][1];
        }
        else if (totalSpread[0] < 0.0f && totalSpread[1] < 0.0f)
        {
            if (flIdentity[0][1] > 0.0f)
                flIdentity[0][1] = -flIdentity[0][1];
        }
        if (flIdentity[0][2] < 0.0f)
            flIdentity[0][2] = -flIdentity[0][2];
        VectorNormalize(flIdentity[0]);
        CrossProduct(flIdentity[0], flIdentity[2], flIdentity[1]);
        VectorNormalize(flIdentity[1]);
        float flCross = (flIdentity[1][1] * flIdentity[2][0]) - (flIdentity[1][0] * flIdentity[2][1]);
        float flRoll;
        if (view[0] > 84.0f || view[0] < -84.0f)
            flRoll = RAD2DEG(atan2(flIdentity[1][2], sqrt(flCross)));
        else
            flRoll = RAD2DEG(atan2(flIdentity[1][2], flCross));
        if (flRoll < 0.0f)
            flRoll += 360.0f;
        QAngle angles;
        VectorAngles(shot, up, angles);
        angles[2] += flRoll;
        angles -= view;
        NormalizeAngles(angles);
        return angles;
    }
    return QAngle(0, 0, 0);
}

void __stdcall new_CreateMove(int sequence_number)
{
    if (Ikaros.m_pInput)
    {
        CUserCmd* cmd = Ikaros.m_pInput->GetUserCmd(-1, sequence_number);
        CVerifiedUserCmd* vcmd = *(CVerifiedUserCmd**)((DWORD)Ikaros.m_pInput + 0xF0) + (sequence_number % 150);

        bSendPacket = 1;

        if (!cmd || !vcmd || !Ikaros.m_pEntity->Ent())
            return;

        C_BaseCombatWeapon* pWeapon = Ikaros.m_pEntity->GetBaseCombatWeapon(Ikaros.m_pEntity->Ent());

        QAngle qOldView(cmd->viewangles);


        if (Ikaros.m_pConvars->flMiscAntiAim == 1){
            cmd->viewangles.y = cmd->viewangles.y + 90.f + (float)(rand() % 55);
        }

        if (Ikaros.m_pConvars->flMiscAntiAim == 2){
            cmd->viewangles.y = cmd->viewangles.y - (90.f + (float)(rand() % 55));
        }

        if (Ikaros.m_pConvars->flMiscAntiAim == 3){
            cmd->viewangles.y = cmd->viewangles.y + 90.f + (float)(rand() % 360);
        }

        if (Ikaros.m_pConvars->flMiscAntiAim == 4){
            cmd->viewangles.y = cmd->viewangles.y + 90.0f + (float)(rand() % 360);
            cmd->viewangles.y = cmd->viewangles.y + 150.0f + (float)(rand() % 360);
            cmd->viewangles.y = cmd->viewangles.y - 43.0f + (float)(rand() % 360);
            cmd->viewangles.y = cmd->viewangles.y - 44.0f + (float)(rand() % 360);
            cmd->viewangles.x = 89;

        }

        if (Ikaros.m_pConvars->flMiscFakeLag == 1){
            int iChoke = 15;
            static int iFakeLag = 0;

            if (iFakeLag < iChoke)
                bSendPacket = false;

            if (iFakeLag > iChoke + 3)
                iFakeLag = 0;

            iFakeLag++;

        }

        if (pWeapon)
        {
            float flCurTime = float(*(int*)((DWORD)Ikaros.m_pEntity->Ent() + Ikaros.m_pOffsets->TickBase) * Ikaros.m_pGlobals->interval_per_tick);
            float flNextAttack = *(float*)((DWORD)pWeapon + Ikaros.m_pOffsets->NextPrimaryAttack);
            static int iChokedPackets = 0;

            if ((Ikaros.m_pConvars->flAimbotActive == 1.0f || (Ikaros.m_pConvars->flAimbotActive == 2.0f && GetAsyncKeyState(VK_LBUTTON))) && !Ikaros.m_pUtilities->IsKnife(pWeapon) && !Ikaros.m_pUtilities->IsMisc(pWeapon))
            {
                Aimbot(cmd, pWeapon);

                if (cmd->buttons & IN_ATTACK)
                {
                    if (Ikaros.m_pConvars->flAimbotSilent == 2.0f)
                    {
                        if ((flNextAttack <= flCurTime))
                        {
                            if (iChokedPackets <= 10)
                            {
                                ++iChokedPackets;
                                bSendPacket = false;

                                if (iTarget > -1)
                                    cmd->viewangles = qAngle;

                                if (Ikaros.m_pConvars->flRemovalsSpread && !Ikaros.m_pConvars->flMiscAntiUntrust)
                                    cmd->viewangles += GetSpreadAngle(cmd->random_seed, cmd, pWeapon);

                                if (Ikaros.m_pConvars->flRemovalsRecoil)
                                    cmd->viewangles -= Ikaros.m_pEntity->GetPunchAngle(Ikaros.m_pEntity->Ent()) * 2;
                            }
                            else
                            {
                                iChokedPackets = 0;
                                cmd->buttons &= ~IN_ATTACK;
                                bSendPacket = 1;
                            }
                        }
                        else
                        {
                            if (Ikaros.m_pConvars->flMiscAutoPistol)
                                cmd->buttons &= ~IN_ATTACK;
                        }
                    }
                    else
                    {
                        if (Ikaros.m_pConvars->flRemovalsSpread && !Ikaros.m_pConvars->flMiscAntiUntrust)
                            cmd->viewangles += GetSpreadAngle(cmd->random_seed, cmd, pWeapon);

                        if (Ikaros.m_pConvars->flRemovalsRecoil)
                            cmd->viewangles -= Ikaros.m_pEntity->GetPunchAngle(Ikaros.m_pEntity->Ent()) * 2;

                        if (Ikaros.m_pConvars->flMiscAutoPistol)
                        {
                            if (flNextAttack > flCurTime)
                            {
                                cmd->buttons &= ~IN_ATTACK;
                            }
                        }
                    }
                }
                else
                {
                    if (Ikaros.m_pConvars->flAimbotSilent == 2.0f)
                    {
                        iChokedPackets = 0;
                        bSendPacket = true;
                        cmd->viewangles = qOldView;
                    }
                }
            }

            if (Ikaros.m_pConvars->flMiscBunnyhop)
            {
                if (cmd->buttons & IN_JUMP && !(Ikaros.m_pEntity->GetFlags(Ikaros.m_pEntity->Ent()) & FL_ONGROUND))
                    cmd->buttons &= ~IN_JUMP;
            }
        }

        CL_FixMove(cmd, qOldView);
        ClampAngles(cmd->viewangles);

        vcmd->m_cmd = *cmd;
        vcmd->m_crc = cmd->GetChecksum();
    }
}