Trigger Bot (Vector scanning)

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
#include <tchar.h>
#include <string>

#define CLIENT_MODULE "client.dll"
#define ENGINE_MODULE "engine.dll"

#define AIM_OFFSET 0x3EFCBC
#define LOCAL_NAME_OFFSET 0x003CE3AC

#define TRIGGERBOT_MAX_LENGTH 1700.0

#define STRUCT_OFFSET 0x007390A8
#define STRUCT_SIZE 0x140
#define MIN_ID 0
#define MAX_ID 64

#define ORIGIN_OFFSET 0x60
#define TEAM_OFFSET 0x58
#define NAME_OFFSET 0x38
#define HEALTH_OFFSET 0x5C
#define INGAME_OFFSET 0x28 //Useless but maybe needed ;)

#define PLAYER_TRUE_WIDTH 26
#define PLAYER_TRUE_HEIGHT 72

#define PLAYER_HEIGHT ( PLAYER_TRUE_HEIGHT + 5 )
#define PLAYER_WIDTH ( PLAYER_TRUE_WIDTH - 8 )

struct PlayerProfile
{

    DWORD TorseHeight;
    DWORD NeckHeight;

    DWORD HeadTop;

    DWORD TorseWidth;
    DWORD HeadWidth;

} ppStand = { PLAYER_TRUE_HEIGHT - 5, PLAYER_HEIGHT - ( PLAYER_TRUE_HEIGHT - 5 ), PLAYER_HEIGHT, 16, 8 };

BOOL FindProcessByName( TCHAR* ProcessName, PROCESSENTRY32* processEntry )
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, NULL );

    if( Process32First( hSnapshot, processEntry ) )
    {
        do
        {
            if( !_tcscmp( processEntry->szExeFile, ProcessName ) )
            {
                CloseHandle( hSnapshot );
                return TRUE;
            }
        } while ( Process32Next( hSnapshot, processEntry ) );
    }

    CloseHandle( hSnapshot );
    return FALSE;
}

BOOL FindModuleByName( TCHAR* ModuleName, MODULEENTRY32* moduleEntry, DWORD dwProcessId )
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwProcessId );

    if( hSnapshot == INVALID_HANDLE_VALUE )
    {
        std::wcout << L"Something went wrong with ToolHelp func. Code: " << GetLastError( ) << L"\n";
        return FALSE;
    }

    if( Module32First( hSnapshot, moduleEntry ) )
    {
        do
        {
            if( !_tcscmp( moduleEntry->szModule, ModuleName ) )
            {
                return TRUE;
            }
        } while( Module32Next( hSnapshot, moduleEntry ) );
    }
    else
    {
        std::wcout << L"Could not find first module. " <<  GetLastError() << "\n";
    }

    CloseHandle( hSnapshot );
    return FALSE;
}

inline float DegToRad( float fAng )
{
    return fAng * 3.14159265 / 180;
}

inline float VecDist( float* fVec1, float* fVec2 )
{
    return sqrt( pow( fVec1[0] - fVec2[0] , 2 ) + pow( fVec1[1] - fVec2[1] , 2 ) + pow( fVec1[2] - fVec2[2] , 2 ) );
}

inline bool IsInBox( float* fPoint, float* fCubeCenter, float fHeight, float fWidth )
{
    if( ( fPoint[0] < fCubeCenter[0] + fWidth / 2 ) && ( fPoint[0] > fCubeCenter[0] - fWidth / 2 ) &&
        ( fPoint[1] < fCubeCenter[1] + fWidth / 2 ) && ( fPoint[1] > fCubeCenter[1] - fWidth / 2 ) &&
        ( fPoint[2] < fCubeCenter[2] + fHeight / 2 ) && ( fPoint[2] > fCubeCenter[2] - fHeight / 2 ) )
    {
        return true;
    }

    return false;
}

int main( )
{
    PROCESSENTRY32 processEntry;
    MODULEENTRY32 clientModule;
    MODULEENTRY32 engineModule;

    processEntry.dwSize = sizeof( PROCESSENTRY32 );
    clientModule.dwSize = sizeof( MODULEENTRY32 );
    engineModule.dwSize = sizeof( MODULEENTRY32 );

    if( FindProcessByName( _T( "hl2.exe" ), &processEntry ) )
    {
        HANDLE hProcess = OpenProcess( PROCESS_VM_READ, FALSE, processEntry.th32ProcessID );

        if( hProcess != INVALID_HANDLE_VALUE )
        {
            if( FindModuleByName( _T( CLIENT_MODULE ), &clientModule, processEntry.th32ProcessID ) &&
                FindModuleByName( _T( ENGINE_MODULE ), &engineModule, processEntry.th32ProcessID ) )
            {
                DWORD* dwRadarAddr = reinterpret_cast< DWORD* >( clientModule.modBaseAddr + STRUCT_OFFSET );
                DWORD* dwAimAddr = reinterpret_cast< DWORD* >( engineModule.modBaseAddr + AIM_OFFSET );
                DWORD* dwLocalNameAddrPtr = reinterpret_cast< DWORD* >( engineModule.modBaseAddr + LOCAL_NAME_OFFSET );

                DWORD dwLocalNameAddr;
                DWORD dwNewRadar;

                if( ReadProcessMemory( hProcess, dwRadarAddr, &dwNewRadar, sizeof( DWORD ), NULL ) )
                {
                    CHAR szLocalName[127];

                    if( ReadProcessMemory( hProcess, dwLocalNameAddrPtr, &dwLocalNameAddr, sizeof( DWORD ), NULL ) )
                    {
                        if( !ReadProcessMemory( hProcess, reinterpret_cast< DWORD* >( dwLocalNameAddr ), szLocalName, sizeof( szLocalName ), NULL ) )
                        {
                            std::cout << "Could not read local player name. " << GetLastError( ) << "\n";
                            std::cout << (DWORD*)engineModule.modBaseAddr << " " << dwLocalNameAddr << "\n";

                            getchar();
                            return 1;
                        }
                        else
                        {
                            std::cout << szLocalName << "\n";
                        }
                    }

                    CHAR szNameBuffer[127];

                    DWORD dwHealthAddr;
                    DWORD dwTeamAddr;
                    DWORD dwNameAddr;
                    DWORD dwOriginAddr;

                    DWORD dwLocalTeam;
                    DWORD dwLocalHealth;
                    DWORD dwLocalId = -1;

                    DWORD dwPlayerTeam;
                    DWORD dwPlayerHealth;

                    float fPlayerOrigin[3];

                    float fLocalOrigin[3];
                    float fLocalAimAngles[3];

                    while( true )
                    {
                        Sleep( 1 );

                        if( !ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwAimAddr ), fLocalAimAngles, sizeof( float[3] ), NULL ) )
                        {
                            std::cout << "Could not read local aim angles.\n";

                            getchar();
                            return 1;
                        }

                        for( int i = 0; i < 32; i++ )
                        {
                            dwHealthAddr = dwNewRadar + i * STRUCT_SIZE + HEALTH_OFFSET;
                            dwTeamAddr = dwNewRadar + i * STRUCT_SIZE + TEAM_OFFSET;
                            dwNameAddr = dwNewRadar + i * STRUCT_SIZE + NAME_OFFSET;
                            dwOriginAddr = dwNewRadar + i * STRUCT_SIZE + ORIGIN_OFFSET;

                            if( ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwNameAddr ), szNameBuffer, sizeof( szNameBuffer ), NULL ) )
                            {
                                if( !strcmp( szLocalName, szNameBuffer ) )
                                {
                                    dwLocalId = i;

                                    ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwTeamAddr ), &dwLocalTeam, sizeof( DWORD ), NULL );
                                    ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwHealthAddr ), &dwLocalHealth, sizeof( DWORD ), NULL );
                                    ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwOriginAddr ), fLocalOrigin, sizeof( float[3] ), NULL );

                                    break;
                                }
                            }
                        }

                        if( dwLocalId == -1 )
                        {
                            std::cout << "Could not find player\n";
                            getchar();

                            return 1;
                        }

                        if( dwLocalHealth == 0 )
                        {
                            continue;
                        }

                        for( int i = 1; i < 32; i++ )
                        {
                            bool bBreakCycle = false;
                            float fPoint[3] = { 0 };

                            if( i == dwLocalId )
                            {
                                continue;
                            }

                            dwHealthAddr = dwNewRadar + i * STRUCT_SIZE + HEALTH_OFFSET;
                            dwTeamAddr = dwNewRadar + i * STRUCT_SIZE + TEAM_OFFSET;
                            dwOriginAddr = dwNewRadar + i * STRUCT_SIZE + ORIGIN_OFFSET;

                            ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwTeamAddr ), &dwPlayerTeam, sizeof( DWORD ), NULL );

                            if( dwPlayerTeam != dwLocalTeam )
                            {
                                ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwHealthAddr ), &dwPlayerHealth, sizeof( DWORD ), NULL );

                                if( dwPlayerHealth != 0 )
                                {
                                    ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwOriginAddr ), fPlayerOrigin, sizeof( float[3] ), NULL );

                                    fPlayerOrigin[2] -= PLAYER_TRUE_HEIGHT;
                                    //fPlayerOrigin[2] += PLAYER_HEIGHT;

                                    if( VecDist( fLocalOrigin, fPlayerOrigin ) < TRIGGERBOT_MAX_LENGTH )
                                    {
                                        for( float f = 1; f < TRIGGERBOT_MAX_LENGTH; f++ )
                                        {
                                            fPoint[0] = fLocalOrigin[0] + cos( DegToRad( fLocalAimAngles[1] ) ) * f;
                                            fPoint[1] = fLocalOrigin[1] + sin( DegToRad( fLocalAimAngles[1] ) ) * f;
                                            fPoint[2] = fLocalOrigin[2] + sin( DegToRad( fLocalAimAngles[0] * -1 ) ) * f;

                                            float fHeadPos[3] = { fPlayerOrigin[0], fPlayerOrigin[1], fPlayerOrigin[2] + ppStand.TorseHeight + (float)( ppStand.NeckHeight ) / 2 };
                                            float fTorsePos[3] = { fPlayerOrigin[0], fPlayerOrigin[1], fPlayerOrigin[2] + (float)ppStand.TorseHeight / 2 };

                                            if( IsInBox( fPoint, fHeadPos, ppStand.NeckHeight, ppStand.HeadWidth ) ||
                                                IsInBox( fPoint, fTorsePos, ppStand.TorseHeight, ppStand.TorseWidth ) )
                                            {
                                                mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 );
                                                Sleep( 50 );

                                                mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 );
                                                Sleep( 25 );

                                                bBreakCycle = true;

                                                break;
                                            }

                                            /*if( IsInBox( fPoint, fPlayerOrigin, PLAYER_HEIGHT, PLAYER_WIDTH ) )
                                            {
                                                mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 );
                                                Sleep( 2 );
                                                mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 );

                                                bBreakCycle = true;

                                                break;
                                            }*/
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    std::cout << "Could not find radar addr.\n";
                }
            }
            else
            {
                std::cout << "Could not find both modules.\n";
            }
        }
        else
        {
            std::cout << "Could not open process.\n";
        }
    }
    else
    {
        std::cout << "Could not find process.\n";
    }

    getchar();
}