Вопрос Получить здоровье игрока

[waht]

не получается узнать здоровье игрока, пытаюсь считать localPlayerController, выдает 0

main.cpp

#include <iostream>
#include "memory.cpp"
#include "offsets.h"

int main()
{


    HWND hwnd;

    do {
        hwnd = FindWindowA(0, "Counter-Strike 2");
        Sleep(50);
    } while (!hwnd);

    DWORD pid;
    pid = memory::PIDByName(L"cs2.exe");
    DWORD client;
    client = memory::getmoduleadres(pid, L"client.dll");
    HANDLE proc;
    proc = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
    uintptr_t localPlayerController = memory::memory_read<uintptr_t>(proc, client + 0x1823128);


    int health = memory::memory_read<int>(proc, localPlayerController + 0x344);

    std::cout << health << "\n";
}

memory.cpp

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
#include <thread>
namespace memory
{
    static DWORD getmoduleadres(DWORD pid, const WCHAR* name)
    {
        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
        MODULEENTRY32 mEntry;
        mEntry.dwSize = sizeof(MODULEENTRY32);
        do
        {
            if (mEntry.szModule == name)
            {
                std::cout << mEntry.szModule;
                CloseHandle(snapshot);
                return (DWORD)mEntry.modBaseAddr;
            }
        } while (Module32Next(snapshot, &mEntry));
    }
    static DWORD PIDByName(const WCHAR* AProcessName)
    {
        HANDLE pHandle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        PROCESSENTRY32 ProcessEntry;
        DWORD pid;
        ProcessEntry.dwSize = sizeof(ProcessEntry);
        bool Loop = Process32First(pHandle, &ProcessEntry);

        while (Loop)
        {
            if (wcsstr(ProcessEntry.szExeFile, AProcessName))
            {
                pid = ProcessEntry.th32ProcessID;
                CloseHandle(pHandle);
                return pid;
            }
            Loop = Process32Next(pHandle, &ProcessEntry);
        }
        return 0;
    }

    template <typename T>
    T memory_write(HANDLE process, DWORD address, T value)
    {
        WriteProcessMemory(process, (LPVOID)address, &value, sizeof(value), 0);
    }
    template <typename T>
    T memory_read(HANDLE process, const std::uintptr_t& address)
    {
        T value = { };
        ::ReadProcessMemory(process, (LPVOID)address, &value, sizeof(T), 0);
        return value;
    }
}

 

[waht]

не получается узнать здоровье игрока, пытаюсь считать localPlayerController, выдает 0

main.cpp

#include <iostream>
#include "memory.cpp"
#include "offsets.h"

int main()
{


    HWND hwnd;

    do {
        hwnd = FindWindowA(0, "Counter-Strike 2");
        Sleep(50);
    } while (!hwnd);

    DWORD pid;
    pid = memory::PIDByName(L"cs2.exe");
    DWORD client;
    client = memory::getmoduleadres(pid, L"client.dll");
    HANDLE proc;
    proc = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
    uintptr_t localPlayerController = memory::memory_read<uintptr_t>(proc, client + 0x1823128);


    int health = memory::memory_read<int>(proc, localPlayerController + 0x344);

    std::cout << health << "\n";
}

memory.cpp

#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
#include <thread>
namespace memory
{
    static DWORD getmoduleadres(DWORD pid, const WCHAR* name)
    {
        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid);
        MODULEENTRY32 mEntry;
        mEntry.dwSize = sizeof(MODULEENTRY32);
        do
        {
            if (mEntry.szModule == name)
            {
                std::cout << mEntry.szModule;
                CloseHandle(snapshot);
                return (DWORD)mEntry.modBaseAddr;
            }
        } while (Module32Next(snapshot, &mEntry));
    }
    static DWORD PIDByName(const WCHAR* AProcessName)
    {
        HANDLE pHandle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        PROCESSENTRY32 ProcessEntry;
        DWORD pid;
        ProcessEntry.dwSize = sizeof(ProcessEntry);
        bool Loop = Process32First(pHandle, &ProcessEntry);

        while (Loop)
        {
            if (wcsstr(ProcessEntry.szExeFile, AProcessName))
            {
                pid = ProcessEntry.th32ProcessID;
                CloseHandle(pHandle);
                return pid;
            }
            Loop = Process32Next(pHandle, &ProcessEntry);
        }
        return 0;
    }

    template <typename T>
    T memory_write(HANDLE process, DWORD address, T value)
    {
        WriteProcessMemory(process, (LPVOID)address, &value, sizeof(value), 0);
    }
    template <typename T>
    T memory_read(HANDLE process, const std::uintptr_t& address)
    {
        T value = { };
        ::ReadProcessMemory(process, (LPVOID)address, &value, sizeof(T), 0);
        return value;
    }
}

выяснил что
getmoduleadres всегда выдает 0, хотя вроде рабочая помогите пожалуйста

 

[waht]

заменил getmoduleadress, теперь выдает большие числа
140729830146048

код:

uintptr_t GetBaseModule(HANDLE handle, std::string moduleName)
{
    HMODULE modules[1024];
    DWORD neededmodule;

    if (EnumProcessModules(handle, modules, sizeof(modules), &neededmodule))
    {
        int moduleCount = neededmodule / sizeof(HMODULE);

        for (int i = 0; i < moduleCount; ++i)
        {
            char buffer[MAX_PATH];

            if (GetModuleBaseNameA(handle, modules[i], buffer, sizeof(buffer)))
            {
                if (!moduleName.compare(buffer)) {
                    return reinterpret_cast<uintptr_t>(modules[i]);

                }
            }
        }
    }
}

 

[SQL]

    uintptr_t GetLibAddres(const char* Name, DWORD ProcessID) {
        HANDLE Shapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, ProcessID);

        if (Shapshot != INVALID_HANDLE_VALUE) {
            MODULEENTRY32 ModuleEntry;
            ModuleEntry.dwSize = sizeof(ModuleEntry);

            if (Module32First(Shapshot, &ModuleEntry)) {
                do {
                    if (!strcmp(ModuleEntry.szModule, Name)) {
                        CloseHandle(Shapshot);
                            return (uintptr_t)ModuleEntry.modBaseAddr;
                    }
                }

                while (Module32Next(Shapshot, &ModuleEntry));
            }
        }

        CloseHandle(Shapshot);
        return 0;
    }


    uintptr_t GetProcessID(const char* ProcessName) {
        HANDLE Shanshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

        PROCESSENTRY32 ProcessInfo = { 0 };
        ProcessInfo.dwSize = sizeof(PROCESSENTRY32);

        while (Process32Next(Shanshot, &ProcessInfo)) {
            if (_stricmp(ProcessName, ProcessInfo.szExeFile) == 0) {
                CloseHandle(Shanshot);
                return ProcessInfo.th32ProcessID;
            }
        }

        CloseHandle(Shanshot);
        return 0;
    }


    void GetProcess(const char* ProcessName, const char* ProcessWindowName) {
        Process::ID = GetProcessID(ProcessName);

        if (Process::ID) {
            Process::Handle = FindWindowA(0, ProcessWindowName);

            Process::Client = GetLibAddres("client.dll", Process::ID);
            Process::Server = GetLibAddres("server.dll", Process::ID);

            Process::Process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Process::ID);
        }

        else {
            MessageBox(0, "Could not find process.", ProcessName, 0);
            exit(0);
        }
    }

uintptr_t getPawn(uintptr_t EntityList, int Index) {
            uintptr_t ListEntity = Memory::Read<uintptr_t>(EntityList + (8 * (Index & 0x7FFF) >> 9) + 16);
            if (!ListEntity) return 0;

            uintptr_t EntityController = Memory::Read<uintptr_t>(ListEntity + 120 * (Index & 0x1FF));
            if (!EntityController) return 0;

            uintptr_t EntityControllerPawn = Memory::Read<uintptr_t>(EntityController + NetVar::m_hPawn);
            if (!EntityControllerPawn) return 0;

            uintptr_t ListEntity2 = Memory::Read<uintptr_t>(EntityList + 0x8 * ((EntityControllerPawn & 0x7FFF) >> 9) + 16);

            uintptr_t EntityPawn = Memory::Read<uintptr_t>(ListEntity2 + 120 * (EntityControllerPawn & 0x1FF));
            if (!EntityPawn) return 0;

            return EntityPawn;
        }

int Health() {
            return Memory::Read<int>(Entity + NetVar::m_iHealth);
        }