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