External Radar CS:S

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