Перейти к содержанию

Рекомендуемые сообщения

Всем добрый день, собственно столкнулся с проблемой нахождения окна. Может кто дать правельный пример или ссылку на литературу/пинок в нужную сторону O_O (сам не нашел)

ну и сопсно сам код который возвращает 0х0


#include "stdafx.h"
#include <windows.h>
#include <iostream>

const int F1 = 0x70;
const int F2 = 0x71;
const int END = 0x23;
const LPCTSTR GameWindowClass = L"ghme1lvl1";
const LPCTSTR GameWindowTitle = L"GTM Level1";
int hi;
LPVOID HappyMem;
BOOL HappyMemSucceed;
HWND GameWindow;
void hotkey();
void HappyAlloc();
void AddText();
int main();

void HappyAlloc()
{
DWORD ThrID;
DWORD ProcID;
HANDLE ProcHandle;
HWND HappyWindow;
HappyWindow = FindWindow(GameWindowClass, GameWindowTitle);
if (HappyWindow != 0) {
HappyMemSucceed = FALSE;
HappyMem = NULL;
ThrID = GetWindowThreadProcessId(HappyWindow, &ProcID);
ProcHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcID);
HappyMem = VirtualAllocEx(ProcHandle, NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (HappyMem != NULL) { HappyMemSucceed = TRUE; }
CloseHandle(ProcHandle);
}
}

void hotkey()
{
hi = 5;
do {
Sleep(100);
GameWindow = FindWindow(GameWindowClass, GameWindowTitle);
if (GetAsyncKeyState (F1) != 0) { AddText(); }
if (GetAsyncKeyState (F2) != 0) { HappyAlloc(); }
if (GetAsyncKeyState (END) != 0) { break; }
}
while (hi == 5);
}
void AddText()
{
std::cout << "Адресс: " << GameWindow << std::endl;
}
int main() //main
{
setlocale(LC_ALL, "Rus");
SetConsoleTitle(L"Окно");
system("Color 1F");
printf("=================================================================\n");
printf("F1 - Текст Процесса\n");
printf("F2 - HappyAlloc();\n");
printf("=================================================================\n");
printf("END - Выход\n");
printf("=================================================================\n");
hotkey();
return 0;
}

P.S.

писать начал не С++ недавно

Ссылка на комментарий
Поделиться на другие сайты

FindWindowA(0, "Call of Duty: Modern Warfare 3");


const int F1 = 0x70;

VK_F1 уже не меинстрим? O_O

Зачем тебе printf когда ты не передаешь аргументы?


std::cout << "Адресс: " << GameWindow << std::endl;

лол, а здесь printf как-раз можно


GetAsyncKeyState(F1) != 0//зачем лишняя проверка?


GetAsyncKeyState(F1)

int main() //main

208e8a261e3647966754596a6f14ff14.png

Ссылка на комментарий
Поделиться на другие сайты

Спасибо огромное,=))

Говорю недавно начал писать на С++ =) пишу по тому материалу который нашел и освоил. Думаю со временем научусь как надо.

Вот обязательно застебывать? Ну да лишнего поналяпал в коде... с кем не бывает...

Ссылка на комментарий
Поделиться на другие сайты

От себя добавлю: Синапс, поставил тебе за каждый из стебных постов по минусу. Вспомни себя, когда ты сам начинал и относись к юзерам с уважением, даже если они задают глупые (на твой "просвященный" взгляд) вопросы. Мы на то и есть, чтобы помогать осваивать основы геймхакинга и программирования, а без таких вопросов (азов) познание невозможно.

Ссылка на комментарий
Поделиться на другие сайты

ICEBURG, хорошо бы делать проверки выполнения функций (в данном случае это поиск окна, открытие процесса) с выводом результата на консоль, если это консольное приложение и мессагами(окнами сообщений), если это консоль отсутствует;

А по FindWindow при создании трейнеров в Интернете должно быть очень много примеров. Слова для поиска "C++ Trainer FindWindow"

Ссылка на комментарий
Поделиться на другие сайты

Вот сегодня на паре немного доработал код...

P.S.

Мелкие ошибки и ненужные строки пока не уберал, но небольшое продвежение вроде есть.


#include "stdafx.h"
#include <windows.h>
#include <iostream>

const int F1 = 0x70;
const int F2 = 0x71;
const int F3 = 0x72;
const int F4 = 0x72;
const int END = 0x23;
LPCSTR GameWindowTitle = "GTM Level1";
int hi;
LPVOID HappyMem;
BOOL HappyMemSucceed;
HWND GameWindow;
void hotkey();
void HappyAlloc();
void AddText();
void AddPointLife();
int main();

void HappyAlloc()
{
DWORD ThrID;
DWORD ProcID;
HANDLE ProcHandle;
HWND HappyWindow;
HappyWindow = FindWindowA(0, GameWindowTitle);
if (HappyWindow != 0) {
HappyMemSucceed = FALSE;
HappyMem = NULL;
ThrID = GetWindowThreadProcessId(HappyWindow, &ProcID);
ProcHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcID);
HappyMem = VirtualAllocEx(ProcHandle, NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (HappyMem != NULL) { HappyMemSucceed = TRUE; }
CloseHandle(ProcHandle);
}
}
void hotkey()
{
hi = 5;
do {
Sleep(100);
GameWindow = FindWindowA(0, GameWindowTitle);
if (GetAsyncKeyState (F1) != 0) { AddText(); }
if (GetAsyncKeyState (F2) != 0) { AddPointLife(); }
if (GetAsyncKeyState (END) != 0) { break; }
}
while (hi == 5);
}
void AddPointLife()
{
DWORD ThrID; DWORD ProcID; DWORD myRead; DWORD myWrite;
HANDLE ProcHandle;
LPVOID FinalAddress;
DWORD ValueOld;
DWORD ValueNew;
DWORD MYBASE;
DWORD MYBASE2;
if (GameWindow != 0) {
ThrID = GetWindowThreadProcessId(GameWindow, &ProcID);
ProcHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcID);
ReadProcessMemory(ProcHandle, (void*)0x00403138, &MYBASE, 0x04, &myRead);
MYBASE2 = MYBASE+0x4;
FinalAddress = (void*)MYBASE2;
ReadProcessMemory(ProcHandle, FinalAddress, &ValueOld, 0x04, &myRead);
ValueNew = ValueOld+100;
WriteProcessMemory(ProcHandle, FinalAddress, &ValueNew, 0x04, &myWrite);
std::cout << "---------\n" <<"Старое значение: " << ValueOld << "\nНовое значение: " << ValueNew << "\n---------\n" <<std::endl;
CloseHandle(ProcHandle);
}
}
void AddText()
{
std::cout << "Адрес окна: " << GameWindow << std::endl;
}

int main()
{
setlocale(LC_ALL, "Rus");
SetConsoleTitle(L"Тестовый трейнер");
system("Color 1F");
printf("=================================================================\n");
printf("F1 - Адрес Процесса\n");
printf("F2 - Прибавление денег +100\n");
printf("F3 - Нет бинда\n");
printf("F4 - Нет бинда\n");
printf("=================================================================\n");
printf("END - Выход\n");
printf("=================================================================\n");
hotkey();
return 0;
}

Трейнер теперь умеет работать с указателями.

Программа с которой он работает: Тык

ICEBURG, хорошо бы делать проверки выполнения функций (в данном случае это поиск окна, открытие процесса) с выводом результата на консоль, если это консольное приложение и мессагами(окнами сообщений), если это консоль отсутствует;

А по FindWindow при создании трейнеров в Интернете должно быть очень много примеров. Слова для поиска "C++ Trainer FindWindow"

Пока это тестовый вариант, учусь, пробую что то новое. Главное что вроде как работает нормально.

Спасибо за подсказку, я материал в основном беру с сайта msdn. Позже попробую доработать уже с внедрением в инструкцию.

Ссылка на комментарий
Поделиться на другие сайты

>> Есть методы лучше и вернее, о них читай статьи и темы на форуме и сайте.

Например, это может быть поиск процесса из списка процессов по его имени. Ещё каких-либо методов поиска процесса кроме "как по окну" или "по его имени" я не припоминаю.

Ссылка на комментарий
Поделиться на другие сайты

  • 2 недели спустя...

Работает отлично, но советую при выходе из трейнера возвращать игру в норму (отключать все опции трейнера, что были включены во время его работы).

Ссылка на комментарий
Поделиться на другие сайты

ICEBURG клавиша F1 что т о задержкой работает после 6_го раза срабатывает чит.

хм... я поставил тик таймера на 100мс. должно нормально быть, там суть в чем, если держать клавишу, то он прогоняет код на вкл\вкл пока зажата клавиша

бесконечно.

У меня вообще не работает.

всмысле вобще не включается? подробнее опиши

Работает отлично, но советую при выходе из трейнера возвращать игру в норму (отключать все опции трейнера, что были включены во время его работы).

Спасибо за совет, в будущем это буду учитывать. =)

Ссылка на комментарий
Поделиться на другие сайты

Небольшой шаблончик, может кому нужно будет.

cMemory.h


{
public:
cMemory();
~cMemory();
HRESULT OpenProc (TCHAR *tszProcName);
HRESULT OpenProc (DWORD dwProcId);
HRESULT CloseProc ();
HRESULT GetModBase (TCHAR *tszModName, BYTE** pStorage);
BOOL CalcPtr (BYTE *pBaseAddress, DWORD iPtrOffset, DWORD* pStorage);
BOOL ReadPtr (BYTE *pBaseAddress, DWORD iPtrOffset, DWORD* pStorage);
BOOL ReadMem (BYTE* pAddress, LPVOID pStorage, DWORD dwSize);
BOOL WriteMem (BYTE* pAddress, LPVOID pBuffer, DWORD dwSize);
BOOL WriteNops (BYTE* pAddress, int iNopsToWrite);
DWORD MakeCave (LPVOID pCaveBytes, DWORD dwCaveSize);
BOOL DeleteCave (BYTE* pCaveAddr, DWORD dwCaveSize);
DWORD MakeJump (BYTE* pOrigAddress, int iNopsNeeded, LPVOID pCaveBytes, DWORD dwCaveSize);
HANDLE GetOpenHandle (){ return m_hProc; }
DWORD GetOpenProcId (){ return m_dwProcId; }
protected:
PROCESSENTRY32 ProcessInfo (TCHAR *tszProcName);
MODULEENTRY32 ModuleInfo (TCHAR *tszModName);
private:
HANDLE m_hProc;
DWORD m_dwProcId;
};
class cMemory

cMemory.cpp


{
m_hProc = NULL;
m_dwProcId = NULL;
}
cMemory::~cMemory()
{
if( m_hProc != INVALID_HANDLE_VALUE )
CloseHandle( m_hProc );
m_hProc = NULL;
m_dwProcId = NULL;
}

///////////////////////////////////////////////////////////////////////////
//cMemory::ProcessInfo
///////////////////////////////////////////////////////////////////////////
PROCESSENTRY32 cMemory::ProcessInfo(TCHAR *tszProcName)
{
PROCESSENTRY32 pe32 = {0};
HANDLE hSnapshot = NULL;
pe32.dwSize = sizeof(PROCESSENTRY32);
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if( Process32First(hSnapshot, &pe32) )
{
do{
if( _tcsicmp(pe32.szExeFile, tszProcName) == 0 ){
CloseHandle( hSnapshot );
return pe32;
}
}while( Process32Next(hSnapshot, &pe32) );
}
if( hSnapshot != INVALID_HANDLE_VALUE )
CloseHandle( hSnapshot );
memset( &pe32, -1, sizeof(PROCESSENTRY32) );
return pe32;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::ModuleInfo
///////////////////////////////////////////////////////////////////////////
MODULEENTRY32 cMemory::ModuleInfo(TCHAR *tszModName)
{
MODULEENTRY32 me32 = {0};
HANDLE hSnapshot = NULL;
me32.dwSize = sizeof(MODULEENTRY32);
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_dwProcId);
if( Module32First(hSnapshot, &me32) )
{
do{
if( _tcsicmp(me32.szModule, tszModName) == 0 ){
CloseHandle( hSnapshot );
return me32;
}
}while( Module32Next(hSnapshot, &me32) );
}
if( hSnapshot != INVALID_HANDLE_VALUE )
CloseHandle( hSnapshot );
memset( &me32, -1, sizeof(MODULEENTRY32) );
return me32;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::OpenProc
///////////////////////////////////////////////////////////////////////////
HRESULT cMemory::OpenProc(TCHAR *tszProcName)
{
PROCESSENTRY32 pe32 = ProcessInfo(tszProcName);
if( pe32.th32ProcessID != -1 )
return OpenProc( pe32.th32ProcessID );
return E_FAIL;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::OpenProc
///////////////////////////////////////////////////////////////////////////
HRESULT cMemory::OpenProc(DWORD dwProcId)
{
if( (dwProcId == 0) || (dwProcId == -1) )
return E_FAIL;
m_hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcId);
if( m_hProc == INVALID_HANDLE_VALUE )
return E_FAIL;
m_dwProcId = dwProcId;
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::CloseProc
///////////////////////////////////////////////////////////////////////////
HRESULT cMemory::CloseProc()
{
if( m_hProc == INVALID_HANDLE_VALUE ){
return E_FAIL;
}else{
CloseHandle( m_hProc );
m_hProc = INVALID_HANDLE_VALUE;
}
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::GetModBase
///////////////////////////////////////////////////////////////////////////
HRESULT cMemory::GetModBase(TCHAR *tszModName, BYTE** pStorage)
{
MODULEENTRY32 me32 = ModuleInfo(tszModName);
if( _tcsicmp(me32.szModule, tszModName) != 0 )
return E_FAIL;
*pStorage = me32.modBaseAddr;
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::CalcPtr
///////////////////////////////////////////////////////////////////////////
BOOL cMemory::CalcPtr(BYTE *pBaseAddress, DWORD iPtrOffset, DWORD* pStorage)
{
BOOL bRead = FALSE;
DWORD dwPointer = NULL;
bRead = ReadProcessMemory( m_hProc, pBaseAddress, &dwPointer, sizeof(DWORD), NULL );
if( !bRead ){
*pStorage = -1;
return FALSE;
}
if( IsBadReadPtr( &dwPointer, 4 ) ){
*pStorage = -1;
return FALSE;
}
*pStorage = (dwPointer+iPtrOffset);
return bRead;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::ReadPtr
///////////////////////////////////////////////////////////////////////////
BOOL cMemory::ReadPtr(BYTE *pBaseAddress, DWORD iPtrOffset, DWORD* pStorage)
{
BOOL bRead = FALSE;
DWORD dwPointer = NULL;
DWORD dwValue = NULL;
bRead = ReadProcessMemory( m_hProc, pBaseAddress, &dwPointer, sizeof(DWORD), NULL );
if( !bRead )
return FALSE;
if( IsBadReadPtr( &dwPointer, 4 ) )
return FALSE;
bRead = ReadProcessMemory( m_hProc, (LPCVOID)(DWORD_PTR)(dwPointer+iPtrOffset), &dwValue, sizeof(DWORD), NULL );
if( !bRead )
return FALSE;
*pStorage = dwValue;
return bRead;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::ReadMem
///////////////////////////////////////////////////////////////////////////
BOOL cMemory::ReadMem(BYTE* pAddress, LPVOID pStorage, DWORD dwSize)
{
if( m_hProc == INVALID_HANDLE_VALUE )
return E_FAIL;
DWORD dwOldProtect = NULL;
VirtualProtectEx( m_hProc, pAddress, dwSize, PAGE_EXECUTE_READWRITE, &dwOldProtect );
BOOL bRead = ReadProcessMemory( m_hProc, pAddress, pStorage, dwSize, NULL );
VirtualProtectEx( m_hProc, pAddress, dwSize, dwOldProtect, &dwOldProtect );
return bRead;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::WriteMem
///////////////////////////////////////////////////////////////////////////
BOOL cMemory::WriteMem(BYTE *pAddress, LPVOID pBuffer, DWORD dwSize)
{
if( m_hProc == INVALID_HANDLE_VALUE )
return FALSE;
DWORD dwOldProtect = NULL;
BOOL bProt = VirtualProtectEx( m_hProc, pAddress, dwSize, PAGE_EXECUTE_READWRITE, &dwOldProtect );
BOOL bWrite = WriteProcessMemory( m_hProc, pAddress, pBuffer, dwSize, NULL );
VirtualProtectEx( m_hProc, pAddress, dwSize, dwOldProtect, &dwOldProtect );
return bWrite;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::WriteNops
///////////////////////////////////////////////////////////////////////////
BOOL cMemory::WriteNops(BYTE* pAddress, int iNopsToWrite)
{
if( m_hProc == INVALID_HANDLE_VALUE )
return FALSE;
DWORD dwOldProtect = NULL;
VirtualProtectEx( m_hProc, pAddress, iNopsToWrite, PAGE_EXECUTE_READWRITE, &dwOldProtect );
BYTE bNOP[] = { 0x90 };
for( int x = 0; x < iNopsToWrite; x++ )
if( !WriteProcessMemory( m_hProc, pAddress+x, &bNOP, 1, NULL ) )
return FALSE;
VirtualProtectEx( m_hProc, pAddress, iNopsToWrite, dwOldProtect, &dwOldProtect );
return TRUE;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::MakeCave
///////////////////////////////////////////////////////////////////////////
DWORD cMemory::MakeCave(LPVOID pCaveBytes, DWORD dwCaveSize)
{
if( m_hProc == INVALID_HANDLE_VALUE )
return NULL;
DWORD dwCaveAddress = NULL;
dwCaveAddress = (DWORD)VirtualAllocEx( m_hProc, NULL, dwCaveSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
if( pCaveBytes != NULL )
WriteMem( (BYTE*)dwCaveAddress, pCaveBytes, dwCaveSize );
return dwCaveAddress;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::DeleteCave
///////////////////////////////////////////////////////////////////////////
BOOL cMemory::DeleteCave(BYTE* pCaveAddr, DWORD dwCaveSize)
{
if( m_hProc == INVALID_HANDLE_VALUE )
return FALSE;
BOOL bRet = VirtualFreeEx( m_hProc, pCaveAddr, dwCaveSize, MEM_DECOMMIT );
return bRet;
}
///////////////////////////////////////////////////////////////////////////
//cMemory::MakeJump
///////////////////////////////////////////////////////////////////////////
DWORD cMemory::MakeJump(BYTE* pOrigAddress, int iNopsNeeded, LPVOID pCaveBytes, DWORD dwCaveSize)
{
//
if( m_hProc == INVALID_HANDLE_VALUE )
return NULL;
//
DWORD dwCaveAddress = NULL;
dwCaveAddress = MakeCave( pCaveBytes, (dwCaveSize+5) );
//
BYTE* dwReturnJmp = (PBYTE)(((DWORD)pOrigAddress+5)+iNopsNeeded);
dwReturnJmp = dwReturnJmp - (dwCaveAddress+(dwCaveSize+5));
//
BYTE bJmp[] = {0xE9};
WriteMem( (BYTE*)((dwCaveAddress+dwCaveSize)), &bJmp, 1 );
WriteMem( (BYTE*)((dwCaveAddress+dwCaveSize)+1), &dwReturnJmp, 4 );
//
DWORD dwJmpAddr = dwCaveAddress - ((DWORD)pOrigAddress+5);
if( iNopsNeeded != 0 )
WriteNops((pOrigAddress+5), iNopsNeeded);
WriteMem( pOrigAddress, &bJmp, 1 );
WriteMem( (pOrigAddress+1), &dwJmpAddr, 4 );
//
return dwCaveAddress;
}
cMemory::cMemory()

Кусок кода из main.cpp


BOOL bMoney = FALSE;
DWORD dwMoneyCave = NULL;
BYTE btMoneyCave[] = {0xB8, 0x50, 0xC3, 0x00, 0x00, 0xC7, 0x46, 0x04, 0x50, 0xC3, 0x00, 0x00};
BYTE btMoneyOrig[] = {0xB8, 0x05, 0x00, 0x00, 0x00, 0x29, 0x46, 0x04};
//===================
//===Жизни===========
BOOL bLife = FALSE;
DWORD dwLifeCave = NULL;
BYTE btLifeCave[] = {0xB8, 0x64, 0x00, 0x00, 0x00, 0xC7, 0x46, 0x08, 0x64, 0x00, 0x00, 0x00};
BYTE btLifeOrig[] = {0xB8, 0x05, 0x00, 0x00, 0x00, 0x29, 0x46, 0x08};
//===================
//===Жизни значение==
BOOL bLifePoints = FALSE;
DWORD dwLifePointsCave = NULL;
BYTE btLifePointsCave1[] = {0xEB, 0x02};
BYTE btLifePointsCave2[] = {0xB8, 0x0A, 0x00, 0x00, 0x00, 0xC7, 0x46, 0x0C, 0x0A, 0x00, 0x00, 0x00};
BYTE btLifePointsOrig1[] = {0x0B, 0xC0};
BYTE btLifePointsOrig2[] = {0xB8, 0x01, 0x00, 0x00, 0x00, 0x29, 0x46, 0x0C};
//===================
//===Полоска=========
BOOL bStrip = FALSE;
DWORD dwStripCave = NULL;
BYTE btStripCave[] = {0xB8, 0x64, 0x00, 0x00, 0x00, 0xC7, 0x46, 0x10, 0x64, 0x00, 0x00, 0x00};
BYTE btStripOrig[] = {0xB8, 0x01, 0x00, 0x00, 0x00, 0x29, 0x46, 0x10};
//===================

cMemory Mem;

BOOL CheckIfAttached()
{
if( Mem.OpenProc( _T("Process.exe") ) == S_OK )
{
return TRUE;
}
else
{
return FALSE;
}

}

//====Cheats===
void Money()
{
if( !CheckIfAttached() )
return;
if( !bMoney ){
dwMoneyCave = Mem.MakeJump( (BYTE*)0x4011D6, 3, &btMoneyCave, sizeof(btMoneyCave) );
bMoney = !bMoney;
}else{
Mem.WriteMem( (BYTE*)0x4011D6, &btMoneyOrig, sizeof(btMoneyOrig) );
Mem.DeleteCave( (BYTE*)dwMoneyCave, sizeof(btMoneyOrig)+5 );
bMoney = !bMoney;
}
}
void Life()
{
if( !CheckIfAttached() )
return;
if( !bLife ){
dwLifeCave = Mem.MakeJump( (BYTE*)0x4011DE, 3, &btLifeCave, sizeof(btLifeCave) );
bLife = !bLife;
}else{
Mem.WriteMem( (BYTE*)0x4011DE, &btLifeOrig, sizeof(btLifeOrig) );
Mem.DeleteCave( (BYTE*)dwLifeCave, sizeof(btLifeOrig)+5 );
bLife = !bLife;
}
}
void LifePoints()
{
if( !CheckIfAttached() )
return;
if( !bLifePoints ){
Mem.WriteMem( (BYTE*)0x4011E9, &btLifePointsCave1, sizeof(btLifePointsCave1) );
dwLifeCave = Mem.MakeJump( (BYTE*)0x401217, 3, &btLifePointsCave2, sizeof(btLifePointsCave2) );
bLifePoints = !bLifePoints;
}else{
Mem.WriteMem( (BYTE*)0x4011E9, &btLifePointsOrig1, sizeof(btLifePointsOrig1) );
Mem.WriteMem( (BYTE*)0x401217, &btLifePointsOrig2, sizeof(btLifePointsOrig2) );
Mem.DeleteCave( (BYTE*)dwLifePointsCave, sizeof(btLifePointsOrig2)+5 );
bLifePoints = !bLifePoints;
}
}
void Strip()
{
if( !CheckIfAttached() )
return;
if( !bStrip ){
dwLifeCave = Mem.MakeJump( (BYTE*)0x40121f, 3, &btStripCave, sizeof(btStripCave) );
bStrip = !bStrip;
}else{
Mem.WriteMem( (BYTE*)0x40121f, &btStripOrig, sizeof(btStripOrig) );
Mem.DeleteCave( (BYTE*)dwStripCave, sizeof(btStripOrig)+5 );
bStrip = !bStrip;
}
}
//===End Cheats===
//===ДЕНЬГИ==========

P.S.

Ну а я пока пытаюсь сделать нормальное окно на WinApi. Может кто подсказать нормальные учебники/мануалы для изучения?

Ссылка на комментарий
Поделиться на другие сайты

  • 3 недели спустя...

Столкнулся с проблемой, при создании трейнера картинка загружается в приложение только до тех пор пока верно указан к ней путь. Может кто кинуть рабочий пример загрузки картинки в главное окно из ресурсов на WinApi?

Вопрос снят. Проблема решена.

Сделал трейнер на WinAPI, просьба его проверить.

Тык

Правая кнопка мышки по окну - инфо

NUMPAD1 - патчить трейнми

END - Выход

Ссылка на комментарий
Поделиться на другие сайты

×
×
  • Создать...

Важная информация

Находясь на нашем сайте, Вы автоматически соглашаетесь соблюдать наши Условия использования.