CSGO项目

#include <Windows.h>
#include <sstream>
#include <iostream> 
#include <math.h>  
#include "HackProcess.h"
#include <vector>
#include <algorithm>   

CHackProcess fProcess;  
using namespace std;  

#define F6_Key 0x75

#define RIGHT_MOUSE 0x02

int NumOfPlayers = 32;

const DWORD dw_PlayerCountOffs = 0x7994E0;//Engine.dll


//自己人物模块偏移
const DWORD Player_Base = 0x4C5B3B4;//client_panorama.dll

//阵营
const DWORD dw_mTeamOffset = 0xE8;//client_panorama.dll
//血量
const DWORD dw_Health = 0xF4;//client_panorama.dll

//人物坐标偏移
const DWORD dw_Pos = 0x12C;//client_panorama.dll

//敌人地址
const DWORD EntityPlayer_Base = 0x4c5b3bc;//client_panorama.dll

//敌人结构偏移
const DWORD EntityLoopDistance = 0x8;

//鼠标指针
const DWORD dw_m_angRotation = 0x461A9C;
RECT m_Rect; 

HDC HDC_Desktop;

HBRUSH EnemyBrush;
HFONT Font; 

//矩阵地址
const DWORD dw_vMatrix = 0x4C2CD04 + 0xb0;
const DWORD dw_antiFlick = 0x58C2B8;


HWND TargetWnd;
HWND Handle;
DWORD DwProcId;

COLORREF SnapLineCOLOR;
COLORREF TextCOLOR; 

typedef struct
{
    float flMatrix [4][4];
}WorldToScreenMatrix_t;

float Get3dDistance(float * myCoords, float * enemyCoords)
{
    return sqrt(
        pow(double(enemyCoords[0] - myCoords[0]), 2.0) +
        pow(double(enemyCoords[1] - myCoords[1]), 2.0) +
        pow(double(enemyCoords[2] - myCoords[2]), 2.0));

}


void SetupDrawing(HDC hDesktop, HWND handle)
{
    HDC_Desktop =hDesktop;
    Handle = handle;
    EnemyBrush = CreateSolidBrush(RGB(255, 0, 0));
    //Color
    SnapLineCOLOR = RGB(0, 0, 255);
    TextCOLOR = RGB(0, 255, 0);
}
struct MyPlayer_t  
{ 
    DWORD CLocalPlayer; 
    int Team; 
    int Health; 
    WorldToScreenMatrix_t WorldToScreenMatrix;
    float Position[3]; 
    int flickerCheck;
    void ReadInformation() 
    {
        // 读自己地址
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + Player_Base), &CLocalPlayer, sizeof(DWORD), 0);
        // 读阵营
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_mTeamOffset), &Team, sizeof(int), 0);
        // 读血量   
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_Health), &Health, sizeof(int), 0); 
        // 读坐标
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CLocalPlayer + dw_Pos), &Position, sizeof(float[3]), 0); 

        //读房间人数
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_PlayerCountOffs), &NumOfPlayers, sizeof(int), 0); 



        //anti flicker
        //ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordEngine + dw_antiFlick), &flickerCheck, sizeof(int), 0); 
        //VMATRIX
        //if(flickerCheck == 0)
        //{

        //读矩阵
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + dw_vMatrix), &WorldToScreenMatrix, sizeof(WorldToScreenMatrix), 0);
        //}
        //-1A4 = ANTI FLICKER
        //Engine.dll+0x58C45C
    }
}MyPlayer;    






//ENemy struct
struct PlayerList_t 
{
    DWORD CBaseEntity; 
    int Team; 
    int Health; 
    float Position[3]; 
    float AimbotAngle[3]; 
    char Name[39]; 

    void ReadInformation(int Player) 
    {
        // 读敌人地址
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(fProcess.__dwordClient + EntityPlayer_Base  + (Player * EntityLoopDistance)),&CBaseEntity, sizeof(DWORD), 0);
        // 读阵营 
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_mTeamOffset), &Team, sizeof(int), 0);
        // 读血量    
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_Health), &Health, sizeof(int), 0); 
        // 读坐标
        ReadProcessMemory (fProcess.__HandleProcess, (PBYTE*)(CBaseEntity + dw_Pos), &Position, sizeof(float[3]), 0); 
     }
}PlayerList[32];  


bool WorldToScreen(float * from, float * to)
{
    float w = 0.0f;

    to[0] = MyPlayer.WorldToScreenMatrix.flMatrix[0][0] * from[0] + MyPlayer.WorldToScreenMatrix.flMatrix[0][1] * from[1] + MyPlayer.WorldToScreenMatrix.flMatrix[0][2] * from[2] + MyPlayer.WorldToScreenMatrix.flMatrix[0][3];
    to[1] = MyPlayer.WorldToScreenMatrix.flMatrix[1][0] * from[0] + MyPlayer.WorldToScreenMatrix.flMatrix[1][1] * from[1] + MyPlayer.WorldToScreenMatrix.flMatrix[1][2] * from[2] + MyPlayer.WorldToScreenMatrix.flMatrix[1][3];
    w = MyPlayer.WorldToScreenMatrix.flMatrix[3][0] * from[0] + MyPlayer.WorldToScreenMatrix.flMatrix[3][1] * from[1] + MyPlayer.WorldToScreenMatrix.flMatrix[3][2] * from[2] + MyPlayer.WorldToScreenMatrix.flMatrix[3][3];

    if(w < 0.01f)
        return false;

    float invw = 1.0f / w;
    to[0] *= invw;
    to[1] *= invw;

    int width = (int)(m_Rect.right - m_Rect.left);
    int height = (int)(m_Rect.bottom - m_Rect.top);

    float x = width/2;
    float y = height/2;

    x += 0.5 * to[0] * width + 0.5;
    y -= 0.5 * to[1] * height + 0.5;

    to[0] = x+ m_Rect.left;
    to[1] = y+ m_Rect.top ;

    return true;
}









void DrawFilledRect(int x, int y, int w, int h)
{

    RECT rect = { x, y, x + w, y + h }; 

    FillRect(HDC_Desktop, &rect, EnemyBrush);
}


void DrawBorderBox(int x, int y, int w, int h, int thickness)
{
    //Top horiz line
    DrawFilledRect(x, y, w, thickness);
    //Left vertical line
    DrawFilledRect( x, y, thickness, h);
    //right vertical line
    DrawFilledRect((x + w), y, thickness, h);
    //bottom horiz line
    DrawFilledRect(x, y + h, w+thickness, thickness);
}



void DrawLine(float StartX, float StartY, float EndX, float EndY, COLORREF Pen)
{
    int a,b=0;
    HPEN hOPen;
    HPEN hNPen = CreatePen(PS_SOLID, 2, Pen);
    hOPen = (HPEN)SelectObject(HDC_Desktop, hNPen);
    MoveToEx(HDC_Desktop, StartX, StartY, NULL);
    a = LineTo(HDC_Desktop, EndX, EndY);
    DeleteObject(SelectObject(HDC_Desktop, hOPen));
}

void DrawString(int x, int y, COLORREF color, const char* text)
{    
    SetTextAlign(HDC_Desktop,TA_CENTER|TA_NOUPDATECP);

    SetBkColor(HDC_Desktop,RGB(0,0,0));
    SetBkMode(HDC_Desktop,TRANSPARENT);

    SetTextColor(HDC_Desktop,color);

    SelectObject(HDC_Desktop,Font);

    TextOutA(HDC_Desktop,x,y,text,strlen(text));

    DeleteObject(Font);
}


void DrawESP(int x, int y, float distance)
{
    int width = 18100/distance;
    int height = 36000/distance;
    DrawBorderBox(x-(width/2), y-height, width, height, 1);

    DrawLine((m_Rect.right - m_Rect.left)/2,
            m_Rect.bottom - m_Rect.top, x, y, 
            SnapLineCOLOR);


    std::stringstream ss;
    ss << (int)distance;

    char * distanceInfo = new char[ss.str().size()+1];
    strcpy(distanceInfo, ss.str().c_str());

    DrawString(x, y, TextCOLOR, distanceInfo);

    delete [] distanceInfo;
}

void ESP()
{
    GetWindowRect(FindWindow(NULL, "Counter-Strike: Global Offensive"), &m_Rect);

    for(int i = 0; i < NumOfPlayers; i ++)
    {
        PlayerList[i].ReadInformation(i);

        if(PlayerList[i].Health < 2)
            continue;

        if(PlayerList[i].Team == MyPlayer.Team)
            continue;

        float EnemyXY[3];
        if(WorldToScreen(PlayerList[i].Position, EnemyXY))
        {
            DrawESP(EnemyXY[0] - m_Rect.left, EnemyXY[1] - m_Rect.top, Get3dDistance(MyPlayer.Position, PlayerList[i].Position));
        }

    }




}


int main()
{
    fProcess.RunProcess(); 

    ShowWindow(FindWindowA("ConsoleWindowClass", NULL), false);
    TargetWnd = FindWindow(0, "Counter-Strike: Global Offensive");
    HDC HDC_Desktop = GetDC(TargetWnd);
    SetupDrawing(HDC_Desktop, TargetWnd);

    for(;;)
    {
        MyPlayer.ReadInformation();

        ESP();

    }


    return 0;
}