Skip to content

GTLIbCpp is library to make game trainer in C++ it provide all the necessary methods to make simple game trainer with Cheat-Engine support

License

Notifications You must be signed in to change notification settings

Jones-HM/GTLibCpp

Repository files navigation

cover_logo

GTLibCpp - Game Trainer Library

GTLibc is a library designed to facilitate the creation of game trainers in C++ with latest C++17 features. It offers a comprehensive set of methods that enable developers to develop simple game trainers for the Windows operating system using the Win32 API with ease.
Notably, GTLibc exclusively employs Win32 API methods and eschews CRT methods as its primary aim is to operate exclusively on Windows systems and not to be portable to other operating systems such as Linux or Mac OS.
It provides all the requisite methods necessary for game trainer development from the inception of the project to its completion. It streamlines the development process, making it less cumbersome for developers.

ONLINE_USAGE

This library is intended to be used only for offline games. You agree not to use the Library for any online games. for more information, see ONLINE_USAGE.md

Demo and Usages

  • Generic Trainer - [GTLibc-Generator] used to generate the trainer example GenericTrainer.cpp file is generated from Cheat Engine table file.
  • Simple Trainer - [SimpleTrainer] is a simple trainer example using GTLibc library. Example IGITrainer.cpp

Usage and Installation

  • To use GTLibc just include the GTLibc.h header file in your project.
  • To use the [GTLibc-Generator], you need to install [Cheat Engine] and include the GTLibc.h header file in your project.
    1. Read the Cheat Engine table file using this gtlibc.ReadCheatTable("CheatTableFile.ct"); method.
    2. Activate the Cheat Entries you want to use in the trainer using this gtlibc.ActivateCheatTableEntries({0, 1, 2}); method.
    3. Execute and Generate the trainer using this gtlibc.ExecuteCheatTable(); method.
  • To compile and run the file use CppRunner.bat file_name.cpp.
  • Or to run manually use this command g++ -std=c++17 -w -DGT_USE_CE_PARSER -o GenericTrainer.exe GenericTrainer.cpp GTLibc.cpp CEParser.cpp note the flag GT_USE_CE_PARSER is important to use if compiling for CheatEngine. You need to have C++ 17 Compiler installed on your machine.

Features and Usages

  • Game Process and Window Detection.
  • Memory Reading and Writing with advanced pointer support.
  • Hotkey Detection with advanced support for multiple hotkeys.
  • Using latest C++ 17 features for ease of use and readability.
  • No external dependencies - only the Win32 API and Standard C++ Library.
  • Generate Generic trainer using the [GTLibc-Generator].
  • Advanced support for famous Cheat Engine.

Methods information and usages

Method Description Example Signature
FindGameProcess Finds the game process by its name. HANDLE handle = FindGameProcess("GameName"); HANDLE FindGameProcess(const std::string &gameName);
FindGameWindow Finds the game window by its name. HWND gameWindow = FindGameWindow("GameWindowName"); HWND FindGameWindow(const std::string &windowName);
ReadAddress Reads the value at the address. Int value = ReadAddress<int>(0x12345678); T ReadAddress(DWORD address);
WriteAddress Writes the value at the address. Bool result = WriteAddress<int>(0x12345678, 100); Bool WriteAddress(DWORD address, const T &value);
ReadAddressOffset Reads the value at the address with the offset. Int value = ReadAddressOffset<int>(0x12345678, 0x10); T ReadAddressOffset(DWORD address, const DWORD offset);
WriteAddressOffset Writes the value at the address with the offset. Bool result = WriteAddressOffset<int>(0x12345678, 0x10, 100); Bool WriteAddressOffset(DWORD address, DWORD offset, const T &value);
ReadAddressOffsets Reads the value at the address with the offsets. Int value = ReadAddressOffsets<int>(0x12345678, {0x10, 0x20}); T ReadAddressOffsets(DWORD address, const std::vector &offsets);
WriteAddressOffsets Writes the value at the address with the offsets. Bool result = WriteAddressOffsets<int>(0x12345678, {0x10, 0x20}, 100); Bool WriteAddressOffsets(DWORD address, const std::vector &offsets, const T &value);
ReadPointer Reads the value at the address. Int value = ReadPointer<int>(0x12345678); T ReadPointer(DWORD address);
WritePointer Writes the value at the address with the pointer offset. Bool result = WritePointer<int>(0x12345678, 0x10, 100); Bool WritePointer(DWORD address, DWORD pointerOffset, const T &value);
ReadPointerOffset Reads the value at the address with the pointer offset. Int value = ReadPointerOffset<int>(0x12345678, 0x10); T ReadPointerOffset(DWORD address, const DWORD offset);
WritePointerOffset Writes the value at the address with the pointer and offset. Bool result = WritePointerOffset<int>(0x12345678, 0x10, 0x20, 100); Bool WritePointerOffset(DWORD address, DWORD pointerOffset, DWORD offset, const T &value);
ReadPointerOffsets Reads the value at the address with the pointer offsets. Int value = ReadPointerOffsets<int>(0x12345678, {0x10, 0x20}); T ReadPointerOffsets(DWORD address, const std::vector &offsets);
WritePointerOffsets Writes the value at the address with the pointer and offsets. Bool result = WritePointerOffsets<int>(0x12345678, 0x10, {0x20, 0x30}, 100); Bool WritePointerOffsets(DWORD address, DWORD pointerOffset, const std::vector &offsets, const T &value);
ReadString Reads the string at the address with the size. Std::string value = ReadString(0x12345678, 20); Std::string ReadString(DWORD address, size_t size);
WriteString Writes the string at the address. Bool result = WriteString(0x12345678, "Hello World"); Bool WriteString(DWORD address, const std::string &str);
HotKeysDown Checks if all the keys are pressed. Bool isPressed = HotKeysDown({VK_A, VK_B, VK_C}); Bool HotKeysDown(const std::vector &keys);
IsKeyPressed Checks if the key is pressed. Bool isPressed = IsKeyPressed(VK_A); Bool IsKeyPressed(int keycode);
IsKeyToggled Checks if the key is toggled. Bool isToggled = IsKeyToggled(VK_CAPITAL); Bool IsKeyToggled(int keycode);
GetGameName Returns the name of the game. Std::string gameName = GetGameName(); Std::string GetGameName();
GetProcessId Returns the process id of the game. DWORD processId = GetProcessId(); DWORD GetProcessId();
GetGameHandle4mHWND Returns the game handle from the window handle. HANDLE gameHandle = GetGameHandle4mHWND(gameWindow); HANDLE GetGameHandle4mHWND(HWND hwnd);
GetProcessID4mHWND Returns the process id from the window handle. DWORD processId = GetProcessID4mHWND(gameWindow); DWORD GetProcessID4mHWND(HWND hwnd);
GetGameHandle Returns the game handle. HANDLE gameHandle = GetGameHandle(); HANDLE GetGameHandle();
GetGameBaseAddress Returns the base address of the game. DWORD baseAddress = GetGameBaseAddress(); DWORD GetGameBaseAddress();
EnableLogs Enables or disables the logs. EnableLogs(true); Void EnableLogs(bool status);
ReadCheatTable Reads the cheat table file and returns the cheat table. CheatTable ct = ReadCheatTable("cheatTableFile.ct"); CheatTable ReadCheatTable(const std::string &cheatTableFile, int entries = -1);
AddCheatTableEntry Adds the cheat entry to the cheat table. AddCheatTableEntry("Armor", CheatTypes.Integer, 0x07290BC8, {}, {VK_CONTROL, 'M'}, CheatActions.SetValue, "150"); Void AddCheatTableEntry(const std::string &description, const std::string &dataType, const DWORD address, const std::vector &offsets, const std::vector &hotkeys, const std::string &hotkeyAction, const std::string hotkeyValue);
DisplayCheatTable Displays the cheat table. DisplayCheatTable(); Void DisplayCheatTable(bool showMenuIndex = true, bool showMenuDescription = true, bool showMenuAction = false, bool showMenuHotkeys = true, bool showMenuValue = false);
ReadCheatTableEntries Reads the cheat table entries and print their values. ReadCheatTableEntries(); Void ReadCheatTableEntries();
ActivateCheatTableEntries Activates the cheat table entries. ActivateCheatTableEntries({1, 2, 3}); Void ActivateCheatTableEntries(const std::vector &cheatEntryIndex);
ExecuteCheatTable Executes the cheat table and generate trainer. ExecuteCheatTable(true, VK_ESCAPE, true, true, false, true); Void ExecuteCheatTable(bool showTrainerOutput = false, int exitTrainerKey = EXIT_TRAINER_KEY, bool showMenuIndex = true, bool showMenuDescription = true, bool showMenuAction = false, bool showMenuHotkeys = true);

Written and maintained by: HeavenHM@2023. cover_logo

About

GTLIbCpp is library to make game trainer in C++ it provide all the necessary methods to make simple game trainer with Cheat-Engine support

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published