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

#include <gl/GL.h>
#include <gl\GLU.h>
#include <opengl\glut.h>

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

#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 ANGLES_OFFSET 0x6C
#define ORIGIN_OFFSET 0x60
#define TEAM_OFFSET 0x58
#define	NAME_OFFSET 0x38
#define HEALTH_OFFSET 0x5C
#define INGAME_OFFSET 0x28

#define PI 3.14159265

#define WIN_W 800
#define WIN_H 600

#define UNACTIVE_TEST
#define TICKS_AFTER_DEATH 40

DWORD *dwModuleBaseAddr;
DWORD *dwRadarBaseAddr;
DWORD *dwLocalNameAddr;

HANDLE hProcess;

enum { CS_TEAM_T = 2, CS_TEAM_CT = 3 };

DWORD dwScreenWidth, dwScreenHeight;

struct Player
{
	int team;
	int health;
	float angles[3];
	float origin[3];
}; 

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;
}

void DrawPlayer( float x, float y, GLfloat width, float* angles, int team, int health )
{
	glBegin( GL_TRIANGLE_FAN );

	if( team == CS_TEAM_T )
	{
		glColor3f( 1, 0, 0 );
	}
	else if( team == CS_TEAM_CT )
	{
		glColor3f( 0, 0, 1 );
	}
	else
	{
		glColor3f( 0, 1, 0 );
	}

	glVertex2f( x, y );

	for( GLfloat i = 0; i <= PI*2; i += PI*2/18 )
	{
		glVertex2f( x + cos( i ) * width , y + sin( i ) * width );
	}

	glEnd( );
	
	glBegin( GL_LINES );

	if( team == CS_TEAM_T )
	{
		glColor3f( 1, 0, 0 );
	}
	else if( team == CS_TEAM_CT )
	{
		glColor3f( 0, 0, 1 );
	}
	else
	{
		glColor3f( 0, 1, 0 );
	}

	glVertex2f( x, y );
	
	glVertex2f( x + cos( DegToRad( angles[1] ) ) * width * 2, y + sin( DegToRad( angles[1] ) ) * width * 2 );

	glEnd( );

	glLineWidth( 3 );

	glBegin( GL_LINES );

	glColor3f( 1 - (float)health / 100, (float)health / 100, 0 );

	GLfloat fCoef = 1.2;
	GLfloat fHealthCoef = (float)health / 100 * ( width * (fCoef * 2) );
	
	glVertex2f( x - fHealthCoef / 2, y - width * 2 );
	glVertex2f( x + fHealthCoef / 2, y - width * 2 );

	glEnd( );

	glLineWidth( 1 );
}

void DrawCross( float x, float y, float size )
{
	glBegin( GL_LINES );

	glColor3f( 1, 1, 1 );

	glVertex2f( x - size, y - size );
	glVertex2f( x + size, y + size );

	glVertex2f( x + size, y - size );
	glVertex2f( x - size, y + size );

	glEnd( );
}

void RenderScene() 
{
	glClear(GL_COLOR_BUFFER_BIT);

	glMatrixMode( GL_MODELVIEW );

	char szLocalPlayerName[128];

	ReadProcessMemory( hProcess, dwLocalNameAddr, szLocalPlayerName, sizeof( szLocalPlayerName ), NULL );

	static Player playersCache[65];
	static int unaliveIteration[65];
	static int ticksOnPlayerDeath[65];

	Player localPlayer;

	DWORD* dwHealthAddr;
	DWORD* dwTeamAddr;
	DWORD* dwNameAddr;
	DWORD* dwOriginAddr;
	DWORD* dwAnglesAddr;

	DWORD dwLocalId = -1;

	char szPlayerName[128] = {0};

	for( int i = 0; i < 64; i++ )
	{
		dwHealthAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + HEALTH_OFFSET );
		dwTeamAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + TEAM_OFFSET );
		dwNameAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + NAME_OFFSET );
		dwOriginAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + ORIGIN_OFFSET );
		dwAnglesAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + ANGLES_OFFSET );

		ReadProcessMemory( hProcess, dwNameAddr, szPlayerName, sizeof( szPlayerName ), NULL );

		if( szPlayerName[0] == NULL )
		{
			continue;
		}

		if( !strcmp( szPlayerName, szLocalPlayerName ) )
		{
			dwLocalId = i;

			ReadProcessMemory( hProcess, dwTeamAddr, &localPlayer.team, sizeof( DWORD ), NULL );
			ReadProcessMemory( hProcess, dwHealthAddr, &localPlayer.health, sizeof( DWORD ), NULL );
			ReadProcessMemory( hProcess, dwOriginAddr, localPlayer.origin, sizeof( float[3] ), NULL );
			ReadProcessMemory( hProcess, dwAnglesAddr, localPlayer.angles, sizeof( float[3] ), NULL );

			break;
		}
	}

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

	for( int i = 1; i < 64; i++ )
	{
		if( i == dwLocalId )
		{
			continue;
		}

		Player curPlayer = { 0 };

		dwHealthAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + HEALTH_OFFSET );
		dwTeamAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + TEAM_OFFSET );
		dwOriginAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + ORIGIN_OFFSET );
		dwAnglesAddr = (DWORD*)( (DWORD)dwRadarBaseAddr + i * STRUCT_SIZE + ANGLES_OFFSET );

		ReadProcessMemory( hProcess, dwHealthAddr, &curPlayer.health, sizeof( int ), NULL );
		ReadProcessMemory( hProcess, dwTeamAddr, &curPlayer.team, sizeof( int ), NULL );
		ReadProcessMemory( hProcess, dwOriginAddr, curPlayer.origin, sizeof( float[3] ), NULL );
		ReadProcessMemory( hProcess, dwAnglesAddr, curPlayer.angles, sizeof( float[3] ), NULL );

#ifdef UNACTIVE_TEST
		if( memcmp( playersCache[i].angles, curPlayer.angles, sizeof( float[3] ) ) == 0 )
		{
			unaliveIteration[i]++;
		}
		else
		{
			unaliveIteration[i] = 0;
		}

		if( unaliveIteration[i] > 200 )
		{
			continue;
		}
#endif

		GLfloat x, y;

		x = ( curPlayer.origin[0] - localPlayer.origin[0] ) / 20;
		y = ( curPlayer.origin[1] - localPlayer.origin[1] ) / 20;

		if( x > dwScreenWidth || y > dwScreenHeight )
		{
			continue;
		}

		glPushMatrix( );

		float fLocalPitch = -localPlayer.angles[1] + 90;

		glRotatef( fLocalPitch, 0, 0, 1 );
		
		if( curPlayer.health != NULL )
		{
			DrawPlayer( x, y, 2, curPlayer.angles, curPlayer.team, curPlayer.health );
		}
		else if( playersCache[i].health > NULL && curPlayer.health <= NULL )
		{
			ticksOnPlayerDeath[i] = TICKS_AFTER_DEATH;
		}

		if( ticksOnPlayerDeath[i] > 0 )
		{
			ticksOnPlayerDeath[i]--;

			DrawCross( x, y, 4 );
		}

		memcpy( &playersCache[i], &curPlayer, sizeof( Player ) );

		glPopMatrix( );
	}

	float ang[3] = {0, 90, 0};

	DrawPlayer( 0, 0, 2, ang, -1, localPlayer.health );

	glutSwapBuffers( );
}

void TimerFunc( int )
{
	glutPostRedisplay( );
	glutTimerFunc( 50, TimerFunc, 1 );
}

void ChangeSize( int width, int height )
{
	dwScreenWidth = width, dwScreenHeight = height;

	float fRatio;

	if( !height )
	{
		height = 1;
	}

	glViewport( 0, 0, width, height );
	glMatrixMode( GL_PROJECTION );

	glLoadIdentity( );

	fRatio = (float)width / (float)height;

	if( width <= height )
	{
		glOrtho( -100, 100, -100.0 / fRatio, 100.0 / fRatio, 1, -1 );
	}
	else
	{
		glOrtho( -100 * fRatio, 100 * fRatio, -100, 100, 1, -1 );
	}

	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity( );
}

int main( int argc, char** argv )
{
	PROCESSENTRY32 processEntry;
	MODULEENTRY32 clientModule;
	MODULEENTRY32 engineModule;

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

	dwLocalNameAddr = dwRadarBaseAddr = NULL;

	if( FindProcessByName( _T( "hl2.exe" ), &processEntry ) )
	{
		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* dwLocalNameAddrPtr = reinterpret_cast< DWORD* >( engineModule.modBaseAddr + LOCAL_NAME_OFFSET );
				
				if( 
					ReadProcessMemory( hProcess, dwRadarAddr, &dwRadarBaseAddr, sizeof( DWORD* ), NULL ) &&
					ReadProcessMemory( hProcess, dwLocalNameAddrPtr, &dwLocalNameAddr, sizeof( DWORD* ), NULL )
					)
				{
					std::cout << "Addresses found! " << "Radar base: " << dwRadarBaseAddr << std::endl;
				}
				else
				{
					std::cout << "Could not find addresses.\n";
					getchar();

					return 1;
				}
			}
			else
			{
				std::cout << "Could not find modules.\n";
				getchar();

				return 1;
			}
		}
		else
		{
			std::cout << "Could not open process.\n";
			getchar();

			return 1;
		}
	}
	else
	{
		std::cout << "Could not find process.\n";
		getchar();

		return 1;
	}


	glutInit( &argc, argv );
	glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB );
	glutInitWindowSize( WIN_W, WIN_H );
	glutCreateWindow( "External Radar Hack by Push(http://steamcommunity.com/id/pushad/)" );
	glutDisplayFunc(RenderScene);
	glutReshapeFunc(ChangeSize);
	glutTimerFunc( 25, TimerFunc, 1 );
	
	glClearColor( 0, 0, 0, 1 );

	glutMainLoop();

	return 1;