#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 )
{
static bool bLastState = false;
static bool bToggle = false; // Turned off by default
Sleep( 5 );
bool bState = GetAsyncKeyState( 'Q' );
if( !bLastState && bState )
{
bToggle = !bToggle;
}
bLastState = bState;
if( !bToggle )
{
Sleep( 250 );
continue;
}
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 );
if( dwAimingAt == 0 || dwAimingAt > 64 )
{
continue;
}
dwAimingAt--;
for( int i = 0; i < 64; 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 );
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();
}
Comments