CSS Trigger Bot

#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_TARG_OFFS_1 0x00744FF4
#define AIM_TARG_OFFS_2 0x14
#define AIM_TARG_OFFS_3 0x14
#define AIM_TARG_OFFS_4 0x470 // not needed
#define AIM_TARG_OFFS_5 0x470 // unknown

#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( 5 );

                        DWORD dwAimTargOffset_1;
                        DWORD dwAimTargOffset_2;
                        DWORD dwAimTargOffset_3;
                        DWORD dwAimTargOffset_4;

                        DWORD dwAimingAt = 0;

                        ReadProcessMemory( hProcess, clientModule.modBaseAddr + AIM_TARG_OFFS_1, &dwAimTargOffset_1, sizeof( DWORD* ), NULL );
                        ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwAimTargOffset_1 + AIM_TARG_OFFS_2 ), &dwAimTargOffset_2, sizeof( DWORD* ), NULL );
                        ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwAimTargOffset_2 + AIM_TARG_OFFS_3 ), &dwAimTargOffset_3, sizeof( DWORD* ), NULL );
                        ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwAimTargOffset_3 + AIM_TARG_OFFS_4 ), &dwAimingAt, sizeof( DWORD* ), NULL );
                        //ReadProcessMemory( hProcess, reinterpret_cast< LPVOID >( dwAimTargOffset_4 + AIM_TARG_OFFS_4 ), &dwAimingAt, sizeof( DWORD ), NULL );

                        printf( "%d\n", dwAimingAt );

                        if( dwAimingAt == 0 || dwAimingAt > 64 )
                        {
                            continue;
                        }

                        dwAimingAt--;

                        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 local player\n";
                            getchar();

                            return 1;
                        }

                        if( dwLocalHealth == 0 )
                        {
                            continue;
                        }

                        ReadProcessMemory( hProcess, reinterpret_cast< LPVOID* >( dwNewRadar + dwAimingAt * STRUCT_SIZE + HEALTH_OFFSET ), &dwPlayerHealth, sizeof( DWORD ), NULL );
                        ReadProcessMemory( hProcess, reinterpret_cast< LPVOID* >( dwNewRadar + dwAimingAt * STRUCT_SIZE + TEAM_OFFSET ), &dwPlayerTeam, sizeof( DWORD ), NULL );
                        ReadProcessMemory( hProcess, reinterpret_cast< LPVOID* >( dwNewRadar + dwAimingAt * STRUCT_SIZE + ORIGIN_OFFSET ), fPlayerOrigin, sizeof( float[3] ), NULL );

                        printf( "%d %d ", dwPlayerTeam, dwPlayerHealth );

                        if( dwPlayerTeam != dwLocalTeam )
                        {
                            if( dwPlayerHealth > 0 )
                            {
                                if( VecDist( fLocalOrigin, fPlayerOrigin ) < TRIGGERBOT_MAX_LENGTH )
                                {
                                    mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0 );
                                    Sleep( 50 );

                                    mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0 );
                                    Sleep( 25 );
                                }
                            }
                        }
                    }
                }
                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();
}