CS:S Players dump

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