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