• Najnowsze pytania
  • Bez odpowiedzi
  • Zadaj pytanie
  • Kategorie
  • Tagi
  • Zdobyte punkty
  • Ekipa ninja
  • IRC
  • FAQ
  • Regulamin
  • Książki warte uwagi

c++ tlhelp32.h | error DWORD/HANDLE/LONG/WCHAR/CHAR does not name a type

VPS Starter Arubacloud
0 głosów
1,079 wizyt
pytanie zadane 16 czerwca 2016 w C i C++ przez Mickeygames Nowicjusz (190 p.)
edycja 16 czerwca 2016 przez Mickeygames

Tak jak w Temacie. Mam Errory w Codeblocksie:

DWORD does not name a type.

HANDLE does not name a type.

LONG does not name a type.

WCHAR does not name a type

CHAR does not name a type..

Errory znajduja sie w pliku tlhelp32.h.// Linie z errorami 35-94

main.cpp----->


#include <iostream>
#include <tlhelp32.h>
#include <windows.h>

#define BHOP_KEY 'C' //press to bunnyhop

struct module_t
{
    DWORD dwBase, dwSize;
};

//debugger class:

class CDebugger
{
private:
    DWORD dwPid;
    HANDLE hProcess;

public:
    bool attach(char* szProcess)
    {

        HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL)
                        PROCESSENTRY32 entry;
        entry.dwsSize = sizeof(entry);
        do
        {
            if (!strcmp(entry.szExeFile, szProcess))
            {
                dwPID = entry.th32ProcessID;
                CloseHandle(handle);
                hProcess = OpenProcess(PROCESS_ALL_ACCESS, false,dwPid);
                return true;
            }
        }
        while (Process32Next(handle, &entry))
            return false;

        module_t GetModule(char* szModule)
        {
            HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL)
                            MODULEENTRY32 entry;
            entry.dwsSize = sizeof(entry);
            do
            {
                if (!strcmp(entry.szModule, szProcess))
                {
                    dwPID = entry.th32ProcessID;
                    CloseHandle(handle);
                    hProcess = OpenProcess(PROCESS_ALL_ACCESS, false,dwPid);
                    return { (DWPRD)entry.hModule, entry.modBaseSize};
                }
            }
            while (Module32Next(handle, &entry))
                return false;
        }
    }
    template<typename T>
    T ReadMemory(DWORD Address)
    {
        T read;
        ReadProcessMemory(hProcess, Address, &read, sizeof(T), 0)
    }
    template<typename T>
    void WriteMemory(DWORD Address, T value)
    {
        WriteProcessMemory(hProcss, Address, &val, Sizeof(T), 0)
    }

};
//offsets:
DWORD dwLocalPlayer = 0xA9948C;
DWORD dwJump = 0x4AD0374;
DWORD dwFlags = 0x100;

CDebugger debugger;
module_t moduleClient;

//locate the client.dll in memory

module_t* GetModuleClient()
{
    if(!moduleClient.dwBase && !moduleClient.dwSize) {
        moduleClient = debugger.GetModule("client.dll");
    }
    return &moduleClient;
}

class CBunnyhop
{
public:
    static unsigned long __stdcall ThreadRoutine(void*)
    {
        while (true)
        {
            DWORD dwMe = debugger.ReadMemory<DWORD>(GetModuleClient())->dwBase + dwLocalPlayer;
            int CanJump = debugger.ReadMemory<DWORD>(dwMe + dwFlags);
            if(GetAsyncKeyState(BHOP_KEY) & 0x8000 && (CanJump & 0x1 == true)) {
                debugger.WriteMemory<int>(GetModuleClient()->dwBase + dwJump, 5); //Jump in game
            }
        }
    }

};

int main()
{
    WHILE (!debugger.attach("csgo.exe")) { //attach to csgo process
     Sleep(100;)
    }
 CreateThread(0,0, &CBunnyhop::ThreadRoutine, 0, 0,0); //create bhop thread
 while (1) {
    Sleep(100);
 }
}


tlhelp32.h---------->
 

/*
    tlhelp32.h - Include file for Tool help functions.

    Written by Mumit Khan <khan@nanotech.wisc.edu>

    This file is part of a free library for the Win32 API.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

*/
#ifndef _TLHELP32_H
#define _TLHELP32_H
#if __GNUC__ >=3
#pragma GCC system_header
#endif

#ifdef __cplusplus
extern "C" {
#endif
#define HF32_DEFAULT    1
#define HF32_SHARED    2
#define LF32_FIXED    0x1
#define LF32_FREE    0x2
#define LF32_MOVEABLE    0x4
#define MAX_MODULE_NAME32    255
#define TH32CS_SNAPHEAPLIST    0x1
#define TH32CS_SNAPPROCESS    0x2
#define TH32CS_SNAPTHREAD    0x4
#define TH32CS_SNAPMODULE    0x8
#define TH32CS_SNAPALL    (TH32CS_SNAPHEAPLIST|TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)
#define TH32CS_INHERIT    0x80000000
typedef struct tagHEAPLIST32 {
    DWORD dwSize;
    DWORD th32ProcessID;
    DWORD th32HeapID;
    DWORD dwFlags;
} HEAPLIST32,*PHEAPLIST32,*LPHEAPLIST32;
typedef struct tagHEAPENTRY32 {
    DWORD dwSize;
    HANDLE hHandle;
    DWORD dwAddress;
    DWORD dwBlockSize;
    DWORD dwFlags;
    DWORD dwLockCount;
    DWORD dwResvd;
    DWORD th32ProcessID;
    DWORD th32HeapID;
} HEAPENTRY32,*PHEAPENTRY32,*LPHEAPENTRY32;
typedef struct tagPROCESSENTRY32W {
    DWORD dwSize;
    DWORD cntUsage;
    DWORD th32ProcessID;
    DWORD th32DefaultHeapID;
    DWORD th32ModuleID;
    DWORD cntThreads;
    DWORD th32ParentProcessID;
    LONG pcPriClassBase;
    DWORD dwFlags;
    WCHAR szExeFile[MAX_PATH];
} PROCESSENTRY32W,*PPROCESSENTRY32W,*LPPROCESSENTRY32W;
typedef struct tagPROCESSENTRY32 {
    DWORD dwSize;
    DWORD cntUsage;
    DWORD th32ProcessID;
    DWORD th32DefaultHeapID;
    DWORD th32ModuleID;
    DWORD cntThreads;
    DWORD th32ParentProcessID;
    LONG pcPriClassBase;
    DWORD dwFlags;
    CHAR  szExeFile[MAX_PATH];
} PROCESSENTRY32,*PPROCESSENTRY32,*LPPROCESSENTRY32;
typedef struct tagTHREADENTRY32 {
    DWORD dwSize;
    DWORD cntUsage;
    DWORD th32ThreadID;
    DWORD th32OwnerProcessID;
    LONG tpBasePri;
    LONG tpDeltaPri;
    DWORD dwFlags;
} THREADENTRY32,*PTHREADENTRY32,*LPTHREADENTRY32;
typedef struct tagMODULEENTRY32W {
    DWORD dwSize;
    DWORD th32ModuleID;
    DWORD th32ProcessID;
    DWORD GlblcntUsage;
    DWORD ProccntUsage;
    BYTE *modBaseAddr;
    DWORD modBaseSize;
    HMODULE hModule;
    WCHAR szModule[MAX_MODULE_NAME32 + 1];
    WCHAR szExePath[MAX_PATH];
} MODULEENTRY32W,*PMODULEENTRY32W,*LPMODULEENTRY32W;
typedef struct tagMODULEENTRY32 {
    DWORD dwSize;
    DWORD th32ModuleID;
    DWORD th32ProcessID;
    DWORD GlblcntUsage;
    DWORD ProccntUsage;
    BYTE *modBaseAddr;
    DWORD modBaseSize;
    HMODULE hModule;
    char szModule[MAX_MODULE_NAME32 + 1];
    char szExePath[MAX_PATH];
} MODULEENTRY32,*PMODULEENTRY32,*LPMODULEENTRY32;
BOOL WINAPI Heap32First(LPHEAPENTRY32,DWORD,DWORD);
BOOL WINAPI Heap32ListFirst(HANDLE,LPHEAPLIST32);
BOOL WINAPI Heap32ListNext(HANDLE,LPHEAPLIST32);
BOOL WINAPI Heap32Next(LPHEAPENTRY32);
BOOL WINAPI Module32First(HANDLE,LPMODULEENTRY32);
BOOL WINAPI Module32FirstW(HANDLE,LPMODULEENTRY32W);
BOOL WINAPI Module32Next(HANDLE,LPMODULEENTRY32);
BOOL WINAPI Module32NextW(HANDLE,LPMODULEENTRY32W);
BOOL WINAPI Process32First(HANDLE,LPPROCESSENTRY32);
BOOL WINAPI Process32FirstW(HANDLE,LPPROCESSENTRY32W);
BOOL WINAPI Process32Next(HANDLE,LPPROCESSENTRY32);
BOOL WINAPI Process32NextW(HANDLE,LPPROCESSENTRY32W);
BOOL WINAPI Thread32First(HANDLE,LPTHREADENTRY32);
BOOL WINAPI Thread32Next(HANDLE,LPTHREADENTRY32);
BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD,LPCVOID,LPVOID,DWORD,LPDWORD);
HANDLE WINAPI CreateToolhelp32Snapshot(DWORD,DWORD);
#ifdef UNICODE
#define LPMODULEENTRY32 LPMODULEENTRY32W
#define LPPROCESSENTRY32 LPPROCESSENTRY32W
#define MODULEENTRY32 MODULEENTRY32W
#define Module32First Module32FirstW
#define Module32Next Module32NextW
#define PMODULEENTRY32 PMODULEENTRY32W
#define PPROCESSENTRY32 PPROCESSENTRY32W
#define PROCESSENTRY32 PROCESSENTRY32W
#define Process32First Process32FirstW
#define Process32Next Process32NextW
#endif /* UNICODE */
#ifdef __cplusplus
}
#endif
#endif /* _TLHELP32_H */



Z góry dziękuje. Jak by co ten kod jest do AutoBH do gry CS:GO

1 odpowiedź

0 głosów
odpowiedź 16 czerwca 2016 przez maly Nałogowiec (37,190 p.)
wybrane 17 czerwca 2016 przez Mickeygames
 
Najlepsza
Daj windows.h nad tlhelp32.h
komentarz 16 czerwca 2016 przez Patryk Krajewski Nałogowiec (26,170 p.)
Po co mu pomagasz oszukiwać w grze?
komentarz 16 czerwca 2016 przez niezalogowany
Gdyby chciał oszukiwać w grze to ściągnąłby gotową binarkę a nie bawiłby się w kompilacje. Poza tym jeśli są udostępniane źródła, to cheat już pewnie dawno nie działa.
komentarz 16 czerwca 2016 przez Patryk Krajewski Nałogowiec (26,170 p.)
Może o tym nie wiedział, a akurat znalazł poradnik z kompilacją.
komentarz 17 czerwca 2016 przez Mickeygames Nowicjusz (190 p.)
W żadnym wypadku nie chce tego używać do cheatowania, tylko uczę się obsługiwać i programować z tlhelp32.h . I tak jakbym tego używał VAC to wykryje, ponieważ ten cheat nie ma żadnego zabezpieczenia

Podobne pytania

0 głosów
1 odpowiedź 1,318 wizyt
pytanie zadane 26 grudnia 2015 w C i C++ przez Pac Plus Mądrala (5,560 p.)
0 głosów
1 odpowiedź 462 wizyt
pytanie zadane 19 sierpnia 2021 w C i C++ przez Programmer01 Początkujący (490 p.)
0 głosów
1 odpowiedź 102 wizyt
pytanie zadane 8 stycznia 2017 w C i C++ przez Hubert17081997 Nowicjusz (160 p.)

92,453 zapytań

141,262 odpowiedzi

319,088 komentarzy

61,854 pasjonatów

Motyw:

Akcja Pajacyk

Pajacyk od wielu lat dożywia dzieci. Pomóż klikając w zielony brzuszek na stronie. Dziękujemy! ♡

Oto polecana książka warta uwagi.
Pełną listę książek znajdziesz tutaj.

Akademia Sekuraka

Akademia Sekuraka 2024 zapewnia dostęp do minimum 15 szkoleń online z bezpieczeństwa IT oraz dostęp także do materiałów z edycji Sekurak Academy z roku 2023!

Przy zakupie możecie skorzystać z kodu: pasja-akademia - użyjcie go w koszyku, a uzyskacie rabat -30% na bilety w wersji "Standard"! Więcej informacji na temat akademii 2024 znajdziecie tutaj. Dziękujemy ekipie Sekuraka za taką fajną zniżkę dla wszystkich Pasjonatów!

Akademia Sekuraka

Niedawno wystartował dodruk tej świetnej, rozchwytywanej książki (około 940 stron). Mamy dla Was kod: pasja (wpiszcie go w koszyku), dzięki któremu otrzymujemy 10% zniżki - dziękujemy zaprzyjaźnionej ekipie Sekuraka za taki bonus dla Pasjonatów! Książka to pierwszy tom z serii o ITsec, który łagodnie wprowadzi w świat bezpieczeństwa IT każdą osobę - warto, polecamy!

...