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

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

#define STRUCT_OFFSET 0x00738098
#define CLIENT_COUNT_OFFSET 0x0039B514
#define CLIENT_COUNT_OFFSET2 0x1A0
#define STRUCT_SIZE 0x140
#define START_ID 0
#define MAX_ID 32
#define	NAME_OFFSET 0x38
#define HEALTH_OFFSET 0x5C
#define INGAME_OFFSET 0x28

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

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(MODULE_NAME), &clientModule, processEntry.th32ProcessID ) &&
				FindModuleByName( _T(ENGINE_MODULE), &engineModule, processEntry.th32ProcessID ) )
			{
				DWORD dwAddress = reinterpret_cast< DWORD >( clientModule.modBaseAddr ) + STRUCT_OFFSET;
				DWORD dw2ndAddress;

				DWORD dwEngAddress = reinterpret_cast< DWORD >( engineModule.modBaseAddr ) + CLIENT_COUNT_OFFSET;
				DWORD dw2ndEngAddress;

				if( ReadProcessMemory( hProcess, reinterpret_cast< PVOID >( dwAddress ), &dw2ndAddress, sizeof( dw2ndAddress ), NULL ) &&
					ReadProcessMemory( hProcess, reinterpret_cast< PVOID >( dwEngAddress ), &dw2ndEngAddress, sizeof( dw2ndEngAddress ), NULL ) )
				{
					char szRadBase[] = "Radar base: ";
					
					CharToOemA( szRadBase, szRadBase );

					std::cout << szRadBase << (DWORD*)dw2ndAddress << "\n";

					DWORD dwTotalPlayers = 0;

					if( !ReadProcessMemory( hProcess, reinterpret_cast< PVOID >( dw2ndEngAddress + CLIENT_COUNT_OFFSET2 ), &dwTotalPlayers, sizeof( dwTotalPlayers ), NULL ) )
					{
						std::cout << "Could not get players count. Set it to 64\n";

						dwTotalPlayers = 64;
					}
					else
					{
						if( dwTotalPlayers <= 64 )
						{
							std::cout << "Client count: " << dwTotalPlayers << "\n\n";
						}
						else
						{
							dwTotalPlayers = 64;
							std::cout << "Total players > 64. Update offsets.\n";
						}
					}

					for( DWORD i = 0; i < dwTotalPlayers; i++ )
					{
						DWORD dwNameOffset = dw2ndAddress + STRUCT_SIZE * i + NAME_OFFSET;
						DWORD dwHealthOffset = dw2ndAddress + STRUCT_SIZE * i + HEALTH_OFFSET;
						DWORD dwIngameOffset = dw2ndAddress + STRUCT_SIZE * i + INGAME_OFFSET;

						CHAR szNameBuffer[128];
						DWORD dwHealthBuff;
						DWORD dwIngame = 0;


						if( ReadProcessMemory( hProcess, reinterpret_cast< PVOID >( dwIngameOffset ), &dwIngame, sizeof( dwIngame ), NULL ) )
						{
							if( !dwIngame )
							{
								continue;
							}
						}
						else
						{
							std::cout << "Could not read ingame offset. Code: " << GetLastError( ) << "\n";
						}

						if( ReadProcessMemory( hProcess, reinterpret_cast< PVOID >( dwNameOffset ), szNameBuffer, sizeof( szNameBuffer ), NULL ) )
						{
							CharToOemA( szNameBuffer, szNameBuffer );
						}
						else
						{
							std::cout << "Could not read name buffer! Code:" << GetLastError( ) << "\n";
						}

						if( ReadProcessMemory( hProcess, reinterpret_cast< PVOID >( dwHealthOffset ), &dwHealthBuff, sizeof( dwHealthBuff ), NULL ) )
						{
							std::cout << i << ": " << szNameBuffer << "[" << dwHealthBuff << "]\n";
						}
						else
						{
							std::cout << "Could not read health state! Code:" << GetLastError( ) << "\n";
						}
					}
				}
				else
				{
					std::cout << "Could not find address! Code: " << GetLastError( ) << "\n";
				}
			}
			else
			{
				std::cout << "Could not find module! Code:" << GetLastError( ) << "\n";
			}
		}
	}
	else
	{
		std::cout << "Could not find process! Code:" << GetLastError( ) << "\n";
	}

	getchar();
}