- Сообщения
- 903
- Реакции
- 671
Код:
#include <vector>
#include <windows.h>
#include <detours.h>
#include <iostream>
#include <d3d9.h>
#include <d3dx9.h>
#include "intrin.h"
#include "MenuColors.h"
#include <time.h>
#pragma comment(lib, "winmm.lib")
#pragma intrinsic(_ReturnAddress)
#pragma comment(lib, "detours.lib")
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#pragma warning( disable: 4244 )
#pragma warning( disable: 4996 )
#pragma warning( disable: 4838 )
/////////////////////////////////////////
#define WarfacePlayer 0x68EBA1
#define WarfaceSmoke 0x68AC64
DWORD frametime = timeGetTime();
int Espr;
int Espg;
int Espb;
int Menu;
int Menux = 25;
int Menuy = 100;
int Menuw = 190;
int Menuh = 160;
bool dCounter;
int aMenuSelection;
bool Chams;
bool Glow;
bool LTrippin;
bool Frontcolor;
bool Backcolor;
bool Trippin;
bool NoSmoke;
bool Wireframe;
int Crosshair;
bool WallHack;
#define ItemOffset 25
#define ValueOffset Menuw - 10
#define ItemOffsetB 20
#define ValueOffsetB Menuw - 10
LPD3DXFONT XFont = NULL;
LPD3DXFONT ZFont = NULL;
LPD3DXLINE pLine = NULL;
LPDIRECT3DDEVICE9 pDevice;
typedef HRESULT(WINAPI *Prototype_Present)(LPDIRECT3DDEVICE9, CONST RECT*, CONST RECT*, HWND, CONST RGNDATA*);
typedef HRESULT(WINAPI *Prototype_Reset)(LPDIRECT3DDEVICE9, D3DPRESENT_PARAMETERS*);
typedef HRESULT(WINAPI* Prototype_DrawIndexedPrimitive)(LPDIRECT3DDEVICE9, D3DPRIMITIVETYPE, INT, UINT, UINT, UINT, UINT);
Prototype_Present xPresent;
Prototype_Reset xReset;
Prototype_DrawIndexedPrimitive xDrawIndexedPrimitive;
HRESULT WINAPI zPresent(LPDIRECT3DDEVICE9 Device, CONST RECT *pSrcRect, CONST RECT *pDestRect, HWND hDestWindow, CONST RGNDATA *pDirtyRegion);
HRESULT WINAPI zReset(LPDIRECT3DDEVICE9 Device, D3DPRESENT_PARAMETERS *pp);
HRESULT WINAPI zDrawIndexedPrimitive(LPDIRECT3DDEVICE9 Device, D3DPRIMITIVETYPE PrimType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount);
bool XInit = false;
int g_Index = -1;
HMODULE g_HModule = 0;
std::vector<void*> g_Vector;
char g_Text[128] = { '\0' };
void* g_SelectedAddress = NULL;
LPDIRECT3DTEXTURE9 Pink, Black, Blue, Green, Red, Orange, White, Tur, Yellow, cFront, cBack;
DWORD cColorBack[3], CurrentColorBack;
DWORD cColorFront[3], CurrentColorFront;
#define d3dColorESP D3DCOLOR_ARGB( 0, Espr, Espg, Espb )
POINT Pos;
RECT rMyRect;
#define PI 3.14159265//Defining what PI is. PI is a Circle
LPDIRECT3DDEVICE9 Device;
IDirect3DPixelShader9* pShader;
UINT pSizeOfData;
////////////////////////
void CaseFunction();
void DrawRect(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR color);
void Button(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR Outline);
void AddInt(int Pos, const char *text, int controller);
void AddBool(int Pos, const char *text, bool controller);
void SetIntLimits(int bcontroller, int bmax, int bmin);
void SetIntLoop(int controller, int max, int min);
void AddIntItem(int Pos, const char *test, int controller, int max, int min);
void LBox(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR Outline);
void DrawRectangle(int x, int y, int w, int h, int r, int g, int b, int a);
void DrawFilledBox(int x, int y, int w, int h, D3DCOLOR color);
void FillRGB(int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* Device);
void DrawShadowText(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...);
void DrawLine(float x, float y, float x2, float y2, float width, DWORD color);
void zTitle(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...);
void ZLine(LPDIRECT3DDEVICE9 pDevice, int x, int y, int w, int h, D3DCOLOR Color);
void Circle(int X, int Y, int radius, int numSides, DWORD Color);
///////////////////////////
void DrawShadowText(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...) // How I draw my font.
{
RECT Font;
Font.bottom = 0;
Font.left = x;
Font.top = y;
Font.right = 0;
RECT Fonts; // It's all part.
Fonts.bottom = 0;
Fonts.left = x + 1;
Fonts.top = y + 1;
Fonts.right = 0; // Shadow is pretty stuff.
XFont->DrawTextA(0, String, strlen(String), &Fonts, DT_NOCLIP, 0xFF010101);
XFont->DrawTextA(0, String, strlen(String), &Font, DT_NOCLIP, color);
}
void eDrawShadowText(int x, int y, D3DCOLOR color, char* String, float) // How I draw my font.
{
RECT Font;
Font.bottom = 0;
Font.left = x;
Font.top = y;
Font.right = 0;
RECT Fonts; // It's all part.
Fonts.bottom = 0;
Fonts.left = x + 1;
Fonts.top = y + 1;
Fonts.right = 0; // Shadow is pretty stuff.
XFont->DrawTextA(0, String, strlen(String), &Fonts, DT_NOCLIP, 0xFF010101);
XFont->DrawTextA(0, String, strlen(String), &Font, DT_NOCLIP, color);
}
void FillRGB(int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* Device)
{
D3DRECT rec = { x, y, x + w, y + h };
Device->Clear(1, &rec, D3DCLEAR_TARGET, color, 0, 0);
}
void zTitle(int x, int y, D3DCOLOR color, char* String, const char * cFmt, ...) // How I draw my font.
{
RECT Font;
Font.bottom = 0;
Font.left = x;
Font.top = y;
Font.right = 0;
RECT Fonts; // It's all part.
Fonts.bottom = 0;
Fonts.left = x + 1;
Fonts.top = y + 1;
Fonts.right = 0; // Shadow is pretty stuff.
ZFont->DrawTextA(0, String, strlen(String), &Fonts, DT_NOCLIP, 0xFF010101);
ZFont->DrawTextA(0, String, strlen(String), &Font, DT_NOCLIP, color);
}
void DrawPoint(LPDIRECT3DDEVICE9 Device, int baseX, int baseY, int baseW, int baseH, D3DCOLOR Cor)
{
D3DRECT BarRect = { baseX, baseY, baseX + baseW, baseY + baseH };
Device->Clear(1, &BarRect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, Cor, 0, 0);
}
void DrawFilledBox(int x, int y, int w, int h, D3DCOLOR color)
{
D3DXVECTOR2 vLine[2];
pLine->SetWidth(w);
pLine->SetAntialias(false);
pLine->SetGLLines(true);
vLine[0].x = x + w / 2;
vLine[0].y = y;
vLine[1].x = x + w / 2;
vLine[1].y = y + h;
pLine->Begin();
pLine->Draw(vLine, 2, color);
pLine->End();
}
void DrawLine(float x, float y, float x2, float y2, float width, DWORD color)
{
D3DXVECTOR2 vLine[2];
pLine->SetWidth(width);
pLine->SetAntialias(true);
pLine->SetGLLines(true);
vLine[0].x = x;
vLine[0].y = y;
vLine[1].x = x2;
vLine[1].y = y2;
pLine->Begin();
pLine->Draw(vLine, 2, color);
pLine->End();
}
void SetINTCVar(const char* szString, int iVal)
{
_asm
{
mov ecx, dword ptr ds : [0x175F3E8]
mov ecx, dword ptr ds : [ecx + 0x50]
mov edx, dword ptr ds : [ecx]
mov eax, dword ptr ds : [edx + 0xD0]
push szString
call eax
mov edx, dword ptr ds : [eax + 0x18]
mov eax, iVal
mov dword ptr ds : [edx], eax
}
}
void PrintText(LPD3DXFONT Font, long x, long y, D3DCOLOR fontColor, char *text, ...)
{
RECT rct;
rct.left = x - 1;
rct.right = x + 1;
rct.top = y - 1;
rct.bottom = y + 1;
if (!text) { return; }
va_list va_alist;
char logbuf[256] = { 0 };
va_start(va_alist, text);
_vsnprintf(logbuf + strlen(logbuf), sizeof(logbuf) - strlen(logbuf), text, va_alist);
va_end(va_alist);
RECT FontRect = { x, y, x, y };
XFont->DrawText(NULL, logbuf, -1, &rct, DT_NOCLIP, fontColor);
}
void DrawRect(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR color)
{
D3DRECT BarRect = { x, y, x + w, y + h };
dev->Clear(1, &BarRect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, color, 0, 0);
}
void LBox(IDirect3DDevice9* Device, int x, int y, int w, int h, D3DCOLOR Outline)
{
DrawRect(Device, x, y, w, 1, Outline);
DrawRect(Device, x, y, 1, h, Outline);
DrawRect(Device, x + w, y, 1, h, Outline);
DrawRect(Device, x, y + h, w, 1, Outline);
}
void ZLine(LPDIRECT3DDEVICE9 Device, int x, int y, int w, int h, D3DCOLOR Color)
{
struct D3DVERTEX
{
float x, y, z, rhw;
D3DCOLOR color;
};
D3DVERTEX vertices[] =
{
{ x, y, 0.5f, 1.0f, Color },
{ x + w, y + h, 0.5f, 1.0f, Color, }
};
Device->SetTexture(0, NULL);
Device->SetPixelShader(NULL);
Device->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
Device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
Device->SetRenderState(D3DRS_ZENABLE, FALSE);
Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
Device->DrawPrimitiveUP(D3DPT_LINELIST, 1, vertices, sizeof(D3DVERTEX));
}
void DrawRectangle(int x, int y, int w, int h, int r, int g, int b, int a) {
if (!IsBadReadPtr(pLine, sizeof(ID3DXLine))) {
D3DXVECTOR2 vLine1[2];
D3DXVECTOR2 vLine2[2];
D3DXVECTOR2 vLine3[2];
D3DXVECTOR2 vLine4[2];
pLine->SetAntialias(false);
pLine->SetGLLines(true);
vLine1[0].x = x;
vLine1[0].y = y;
vLine1[1].x = x;
vLine1[1].y = y + h;
vLine2[0].x = x + w;
vLine2[0].y = y;
vLine2[1].x = x + w;
vLine2[1].y = y + h;
vLine3[0].x = x;
vLine3[0].y = y;
vLine3[1].x = x + w;
vLine3[1].y = y;
vLine4[0].x = x;
vLine4[0].y = y + h;
vLine4[1].x = x + w;
vLine4[1].y = y + h;
pLine->Begin();
pLine->Draw(vLine1, 2, D3DCOLOR_RGBA(r, g, b, a));
pLine->Draw(vLine2, 2, D3DCOLOR_RGBA(r, g, b, a));
pLine->Draw(vLine3, 2, D3DCOLOR_RGBA(r, g, b, a));
pLine->Draw(vLine4, 2, D3DCOLOR_RGBA(r, g, b, a));
pLine->End();
}
}
void cDirectClass::DrawString(ID3DXFont * XFont, int nPosX, int nPosY, D3DCOLOR dColor, const char * cFmt, ...)
{
va_list mvalist;
char cBuffer[256] = { 0 };
RECT rFontRect = { nPosX, nPosY, nPosX + 16, nPosY + 120 };
va_start(mvalist, cFmt);
vsnprintf_s(cBuffer, sizeof(cBuffer), cFmt, mvalist);
va_end(mvalist);
XFont->DrawTextA(NULL, cBuffer, -1, &rFontRect, DT_LEFT | DT_NOCLIP, dColor);
}
void DrawMyText(int x, int y, D3DCOLOR color, const char * cFmt, ...) // How I draw my font.
{
CHAR buf[512] = { NULL };
va_list ArgumentList;
va_start(ArgumentList, cFmt);
_vsnprintf_s(buf, sizeof(buf), sizeof(buf) - strlen(buf), cFmt, ArgumentList);
va_end(ArgumentList);
RECT Font;
Font.bottom = 0;
Font.left = x;
Font.top = y;
Font.right = 0;
XFont->DrawTextA(0, buf, strlen(buf), &Font, DT_NOCLIP, color);
}
void Circle(int X, int Y, int radius, int numSides, DWORD Color)
{
D3DXVECTOR2 Line[128];
float Step = PI * 2.0 / numSides;
int Count = 0;
for (float a = 0; a < PI*2.0; a += Step)
{
float X1 = radius * cos(a) + X;
float Y1 = radius * sin(a) + Y;
float X2 = radius * cos(a + Step) + X;
float Y2 = radius * sin(a + Step) + Y;
Line[Count].x = X1;
Line[Count].y = Y1;
Line[Count + 1].x = X2;
Line[Count + 1].y = Y2;
Count += 2;
}
pLine->Begin();
pLine->Draw(Line, Count, Color);
pLine->End();
}
DWORD FindDevice(DWORD Len)
{
DWORD dwObjBase = 0;
dwObjBase = (DWORD)LoadLibrary("d3d9.dll");
while (dwObjBase++ < dwObjBase + Len)
{
if ((*(WORD*)(dwObjBase + 0x00)) == 0x06C7
&& (*(WORD*)(dwObjBase + 0x06)) == 0x8689
&& (*(WORD*)(dwObjBase + 0x0C)) == 0x8689
) {
dwObjBase += 2; break;
}
}
return(dwObjBase);
}
DWORD GetDeviceAddress(int VTableIndex)
{
PDWORD VTable;
*(DWORD*)&VTable = *(DWORD*)FindDevice(0x128000);
return VTable[VTableIndex];
}
void zThread()
{
xPresent = (Prototype_Present)DetourFunction((PBYTE)GetDeviceAddress(17),
(PBYTE)zPresent);
xReset = (Prototype_Reset)DetourFunction((PBYTE)GetDeviceAddress(16),
(PBYTE)zReset);
xDrawIndexedPrimitive = (Prototype_DrawIndexedPrimitive)DetourFunction((PBYTE)GetDeviceAddress(82),
(PBYTE)zDrawIndexedPrimitive);
}
BOOL WINAPI DllMain(HINSTANCE hInsatnce, DWORD dwReason, LPVOID lpReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
g_HModule = hInsatnce;
CreateThread(0, 0, (LPTHREAD_START_ROUTINE)zThread, 0, 0, 0);
//MessageBox(0, "You Must Close this box - Injection Successful.", " Trippy Warface V3.2", 0);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
if (XFont != NULL)
{
XFont->OnLostDevice();
XFont->OnResetDevice();
XFont->Release();
XFont = NULL;
}
DetourRemove((PBYTE)zPresent, (PBYTE)zPresent);
DetourRemove((PBYTE)zReset, (PBYTE)zReset);
DetourRemove((PBYTE)zDrawIndexedPrimitive, (PBYTE)zDrawIndexedPrimitive);
}
return TRUE;
}
HRESULT cGenTex(LPDIRECT3DDEVICE9 Device, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
{
if (FAILED(Device->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, ppD3Dtex, NULL)))
return E_FAIL;
WORD colour16 = ((WORD)((colour32 >> 28) & 0xF) << 12)
| (WORD)(((colour32 >> 20) & 0xF) << 8)
| (WORD)(((colour32 >> 12) & 0xF) << 4)
| (WORD)(((colour32 >> 4) & 0xF) << 0);
D3DLOCKED_RECT d3dlr;
(*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
WORD *pDst16 = (WORD*)d3dlr.pBits;
for (int xy = 0; xy < 8 * 8; xy++)
*pDst16++ = colour16;
(*ppD3Dtex)->UnlockRect(0);
return S_OK;
}
HRESULT WINAPI zPresent(LPDIRECT3DDEVICE9 Device, CONST RECT *pSrcRect, CONST RECT *pDestRect, HWND hDestWindow, CONST RGNDATA *pDirtyRegion)
{
D3DVIEWPORT9 VP;
memset(&VP, 0, sizeof(D3DVIEWPORT9));
Device->GetViewport(&VP);
float ScreenCenterX = (float)VP.Width / 2;
float ScreenCenterY = (float)VP.Height / 2;
LPDIRECT3DDEVICE9 pDevice;
pDevice = Device;
if (Crosshair > 0)
if (Crosshair == 1)
{
D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
Device->Clear(1, &rec1, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255, 0, 0), 0, 0);
Device->Clear(1, &rec2, D3DCLEAR_TARGET, D3DCOLOR_XRGB(255, 0, 0), 0, 0);
}
if (Crosshair > 0)
if (Crosshair == 2)
{
D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
Device->Clear(1, &rec1, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 255, 0), 0, 0);
Device->Clear(1, &rec2, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 255, 0), 0, 0);
}
if (Crosshair > 0 && Crosshair == 3)
{
D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
Device->Clear(1, &rec1, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 255), 0, 0);
Device->Clear(1, &rec2, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 255), 0, 0);
}
if (Crosshair > 0 && Crosshair == 4)
{
D3DRECT rec1 = { ScreenCenterX - 5, ScreenCenterY, ScreenCenterX + 5, ScreenCenterY + 1 };
D3DRECT rec2 = { ScreenCenterX, ScreenCenterY - 5, ScreenCenterX + 1,ScreenCenterY + 5 };
LBox(Device, ScreenCenterX - 5, ScreenCenterY - 5, 10, 10, d3dColorWhite); // Outline vpx and y = Viewpoint. "Center"
}
if (Crosshair > 0 && Crosshair == 5)
{
FillRGB(ScreenCenterX - 20, ScreenCenterY, 40, 1, d3dColorBlack, Device);//Purple
FillRGB(ScreenCenterX, ScreenCenterY - 20, 1, 40, d3dColorBlack, Device);
FillRGB(ScreenCenterX - 17, ScreenCenterY, 34, 1, d3dColorBlue, Device);//Blue
FillRGB(ScreenCenterX, ScreenCenterY - 17, 1, 34, d3dColorBlue, Device);
FillRGB(ScreenCenterX - 14, ScreenCenterY, 28, 1, d3dColorWhite, Device);//Cyan
FillRGB(ScreenCenterX, ScreenCenterY - 14, 1, 28, d3dColorWhite, Device);
FillRGB(ScreenCenterX - 11, ScreenCenterY, 22, 1, d3dColorGreen, Device);//Green
FillRGB(ScreenCenterX, ScreenCenterY - 11, 1, 22, d3dColorGreen, Device);
FillRGB(ScreenCenterX - 9, ScreenCenterY, 18, 1, d3dColorYellow, Device);//Yellow
FillRGB(ScreenCenterX, ScreenCenterY - 9, 1, 18, d3dColorYellow, Device);
FillRGB(ScreenCenterX - 6, ScreenCenterY, 12, 1, d3dColorLightBlue, Device);//Orange
FillRGB(ScreenCenterX, ScreenCenterY - 6, 1, 12, d3dColorLightBlue, Device);
FillRGB(ScreenCenterX - 3, ScreenCenterY, 6, 1, d3dColorRed, Device);//Red
FillRGB(ScreenCenterX, ScreenCenterY - 3, 1, 6, d3dColorRed, Device);
}
if (Crosshair > 0 && Crosshair == 6)
{
FillRGB(ScreenCenterX - 13, ScreenCenterY, 10, 1, d3dColorRed, Device);//Left line
FillRGB(ScreenCenterX + 4, ScreenCenterY, 10, 1, d3dColorRed, Device);//Right line
FillRGB(ScreenCenterX, ScreenCenterY - 13, 1, 10, d3dColorRed, Device);//Top line
FillRGB(ScreenCenterX, ScreenCenterY + 4, 1, 10, d3dColorRed, Device);//Bottom line
}
if (Crosshair > 0 && Crosshair == 7)
{
FillRGB(ScreenCenterX - 13, ScreenCenterY, 10, 1, d3dColorBlue, Device);//Left line
FillRGB(ScreenCenterX + 4, ScreenCenterY, 10, 1, d3dColorBlue, Device);//Right line
FillRGB(ScreenCenterX, ScreenCenterY - 13, 1, 10, d3dColorBlue, Device);//Top line
FillRGB(ScreenCenterX, ScreenCenterY + 4, 1, 10, d3dColorBlue, Device);//Bottom line
}
cDirectX.InitObjects(Device);
if (!XInit)
{
if (XFont == NULL)
D3DXCreateFont(Device, 14, 0, FW_NORMAL, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "red", &XFont);
if (ZFont == NULL)
D3DXCreateFont(Device, 14, 0, FW_EXTRABOLD, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "red", &ZFont);
if (pLine == NULL) D3DXCreateLine(Device, &pLine);
cColorFront[CurrentColorFront] = 255;
cColorBack[CurrentColorBack] = 255;
XInit = true;
}
if (GetAsyncKeyState(VK_INSERT) & 1) { Menu = !Menu; }
CaseFunction();
int x = 1;
for (int x = 0; x < 20; x++) {
if (Menu && aMenuSelection == x) {
LBox(Device, Menux, Menuy - 20, Menuw + 25, Menuh + 20, d3dColorWhite); // Outline
DrawFilledBox(Menux, Menuy, Menuw + 25, Menuh + 20, D3DCOLOR_ARGB(0, 150, 255, 155)); //Overall Background
DrawFilledBox(Menux, Menuy - 20, Menuw + 25, Menuh + 20, D3DCOLOR_ARGB(155, 25, 56, 100)); //Title Background
LBox(Device, Menux, Menuy + (15 * x), Menuw + 25, 15, d3dColorWhite); // Selection
DrawFilledBox(Menux, Menuy + (15 * x), Menuw + 25, 15, D3DCOLOR_ARGB(255, 100, 0, 155));// Selection
zTitle(Menux + 18, Menuy - 20, d3dColorWhite, "DirectEx", 0);
AddBool(1, "Chams", Chams);
AddBool(2, "Translucent Chams", Glow);
AddBool(3, "Front Chams Color", Frontcolor);
AddBool(4, "Back Chams Color", Backcolor);
AddBool(5, "No-Smoke", NoSmoke);
AddBool(6, "Wire-Frame", Wireframe);
AddIntItem(7, "Cross-Hair", Crosshair, 1, 0);
AddBool(8, "Wall-Hack", WallHack);
AddBool(9, "Rage Quit", LTrippin);
LBox(Device, Menux, Menuy - 20, Menuw + 25, Menuh, d3dColorWhite); // Outline
zTitle(Menux + 20, Menuh + 80, d3dColorWhite, "Warface DirectEx V1.0", 0);
/////////////////////////////////////////////////////////////////////////////////////////////////////////
if (LTrippin) {
system("taskkill /F /T /IM Game.exe");
}
if (Frontcolor)
if (!Backcolor)
{
cGenTex(Device, &cFront, D3DCOLOR_ARGB(255, cColorFront[0], cColorFront[1], cColorFront[2]));
DrawShadowText(Menux + 5, Menuy + 245, d3dColorRed, "Choose Color : 1/2/3 : +/-", 0);
if (GetAsyncKeyState(VK_ADD) && cColorFront[CurrentColorFront] < 250)
cColorFront[CurrentColorFront] += 10; //On pressing "+" Slider will increase value on current color
if (GetAsyncKeyState(VK_SUBTRACT) && cColorFront[CurrentColorFront] > 5)
cColorFront[CurrentColorFront] -= 10; //On pressing "-" Slider will decrease value on current color
if (GetAsyncKeyState(0x31) & 1) //On pressing "1" only the Red slider will increase/decrease
CurrentColorFront = 0;
else if (GetAsyncKeyState(0x32) & 1) //On pressing "2" only the Green slider will increase/decrease
CurrentColorFront = 1;
else if (GetAsyncKeyState(0x33) & 1) //On pressing "3" only the Blue slider will increase/decrease
CurrentColorFront = 2;
FillRGB(325, 135 + 3, 255, 8, D3DCOLOR_ARGB(255, 255, 0, 0), Device);//Red Slider Bar
FillRGB(325 + cColorFront[0], 136, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Red Slider
FillRGB(325, 150 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 255, 0), Device);//Green Slider Bar
FillRGB(325 + cColorFront[1], 150 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Green Slider
FillRGB(325, 165 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 0, 255), Device);//Blue Slider Bar
FillRGB(325 + cColorFront[2], 165 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Blue Slider
}
if (Backcolor)
if (!Frontcolor)
{
cGenTex(Device, &cBack, D3DCOLOR_ARGB(255, cColorBack[0], cColorBack[1], cColorBack[2]));
FillRGB(325, 135 + 3, 255, 8, D3DCOLOR_ARGB(255, 255, 0, 0), Device);//Red Slider Bar
FillRGB(325 + cColorBack[0], 135 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Red Slider
FillRGB(325, 150 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 255, 0), Device);//Green Slider Bar
FillRGB(325 + cColorBack[1], 150 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Green Slider
FillRGB(325, 165 + 3, 255, 8, D3DCOLOR_ARGB(255, 0, 0, 255), Device);//Blue Slider Bar
FillRGB(325 + cColorBack[2], 165 + 1, 2, 11, D3DCOLOR_ARGB(255, 255, 255, 255), Device);//Blue Slider
DrawShadowText(Menux + 5, Menuy + 245, d3dColorRed, "Choose Color : 1/2/3 : +/-", 0);
if (GetAsyncKeyState(VK_ADD) && cColorBack[CurrentColorBack] < 250)
cColorBack[CurrentColorBack] += 10; //On pressing "+" Slider will increase value on current color
if (GetAsyncKeyState(VK_SUBTRACT) && cColorBack[CurrentColorBack] > 5)
cColorBack[CurrentColorBack] -= 10; //On pressing "-" Slider will decrease value on current color
if (GetAsyncKeyState(0x31) & 1) //On pressing "1" only the Red slider will increase/decrease
CurrentColorBack = 0;
else if (GetAsyncKeyState(0x32) & 1) //On pressing "2" only the Green slider will increase/decrease
CurrentColorBack = 1;
else if (GetAsyncKeyState(0x33) & 1) //On pressing "3" only the Blue slider will increase/decrease
CurrentColorBack = 2;
}
}
}
zTitle(ScreenCenterX, ScreenCenterY - 360, d3dColorRed, "DirectEx - UnknownCheats", 0);
if (!Menu)
{
zTitle(ScreenCenterX, ScreenCenterY - 340, d3dColorGreen, "Toggle Menu: Insert", 0);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
return xPresent(Device, pSrcRect, pDestRect, hDestWindow, pDirtyRegion);
}
HRESULT WINAPI zReset(LPDIRECT3DDEVICE9 Device, D3DPRESENT_PARAMETERS *pp)
{
if (XFont)
XFont->OnResetDevice();
XFont->OnResetDevice();
if (pLine)
pLine->OnResetDevice();
pLine->OnResetDevice();
return xReset(Device, pp);
}
HRESULT WINAPI zDrawIndexedPrimitive(LPDIRECT3DDEVICE9 Device, D3DPRIMITIVETYPE PrimType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount)
{
void* ReturnAddress = _ReturnAddress();
IDirect3DVertexBuffer9* pStreamData = NULL;
UINT xOffset, Stride;
if (Device->GetStreamSource(0, &pStreamData, &xOffset, &Stride) == D3D_OK)
pStreamData->Release();
if (SUCCEEDED(Device->GetPixelShader(&pShader)))
if (pShader != NULL)
if (SUCCEEDED(pShader->GetFunction(NULL, &pSizeOfData)))
if (pShader != NULL) { pShader->Release(); pShader = NULL; }
if (Chams)
if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
{
Device->SetTexture(0, cBack);
Device->SetRenderState(D3DRS_ZENABLE, false);
Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
Device->SetRenderState(D3DRS_ZENABLE, true);
Device->SetTexture(0, cFront);
}
if (Glow)
if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
{
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
Device->SetTexture(0, cBack);
Device->SetRenderState(D3DRS_ZENABLE, false);
Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
Device->SetTexture(0, cFront);
Device->SetRenderState(D3DRS_ZENABLE, true);
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
Device->SetTexture(0, cFront);
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
}
if (WallHack)
if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
{
Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
Device->SetRenderState(D3DRS_ZENABLE, false);
Device->DrawIndexedPrimitive(PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
Device->SetRenderState(D3DRS_ZENABLE, true);
Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
}
if (Trippin && ReturnAddress != NULL && ReturnAddress == (void *)0xA4CBB7) {
Device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCCOLOR);
Device->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
}
if (Wireframe)
if (ReturnAddress != NULL && ReturnAddress == (void *)WarfacePlayer)
{
Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
}
else {
Device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
}
if (NoSmoke && ReturnAddress != NULL && ReturnAddress == (void *)WarfaceSmoke)
{
return D3D_OK;
}
return xDrawIndexedPrimitive(Device, PrimType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}
void cDirectClass::InitObjects(IDirect3DDevice9 * Device)
{
}
void cDirectClass::DrawLine(float StartX, float StartY, float EndX, float EndY, D3DCOLOR dColor)
{
pLine->SetWidth(1);
pLine->SetGLLines(0);
pLine->SetAntialias(1);
D3DXVECTOR2 v2Line[2];
v2Line[0].x = StartX;
v2Line[0].y = StartY;
v2Line[1].x = EndX;
v2Line[1].y = EndY;
pLine->Begin();
pLine->Draw(v2Line, 2, dColor);
pLine->End();
}
cDirectClass cDirectX;
void Button(IDirect3DDevice9* dev, int x, int y, int w, int h, D3DCOLOR Outline)
{
DrawRect(dev, x, y, w, 1, Outline);
DrawRect(dev, x, y, 1, h, Outline);
DrawRect(dev, x + w, y, 1, h, Outline);
DrawRect(dev, x, y + h, w, 1, Outline);
}
void AddInt(int Pos, const char *text, int controller)
{
DWORD OnColor = d3dColorGreen;
DWORD OffColor = d3dColorWhite;
if (controller)
{
cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OnColor, text);
cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OnColor, "%i.00", controller);
}
else if (!controller)
{
cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OffColor, text);
cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OffColor, "0.00");
}
}
void AddBool(int Pos, const char *text, bool controller)
{
DWORD OnColor = d3dColorGreen;
DWORD OffColor = d3dColorWhite;
if (controller)
{
cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OnColor, text);
cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OnColor, "On");
}
else if (!controller)
{
cDirectX.DrawString(XFont, Menux + ItemOffset, (Menuy)+((Pos - 1) * 15), OffColor, text);
cDirectX.DrawString(XFont, Menux + ValueOffset, (Menuy)+((Pos - 1) * 15), OffColor, "Off");
}
}
int Menu_Max = 8;
void SetIntLimits(int controller, int max, int min)
{
if (controller == max + 1)
{
controller = max;
}
if (controller == min - 1)
{
controller = min;
}
}
void SetIntLoop(int controller, int max, int min)
{
if (controller == max + 1)
{
controller = min;
}
if (controller == min - 1)
{
controller = max;
}
}
void AddIntItem(int Pos, const char *test, int controller, int max, int min) {
AddInt(Pos, test, controller);
SetIntLimits(controller, max, min);
}
void CaseFunction()
{
if (Menu && ((GetAsyncKeyState(VK_UP) & 1)))
{
if (aMenuSelection > 0)
aMenuSelection--;
}
if (Menu && ((GetAsyncKeyState(VK_DOWN) & 1)))
{
if (aMenuSelection < Menu_Max)
aMenuSelection++;
}
if (Menu && ((GetAsyncKeyState(VK_RIGHT) & 1)))
{
{
switch (aMenuSelection)
{
case 0:
Chams = !Chams;
break;
case 1:
Glow = !Glow;
break;
case 2:
Frontcolor = !Frontcolor && !Backcolor;
break;
case 3:
Backcolor = !Backcolor && !Frontcolor;
break;
case 4:
NoSmoke = !NoSmoke;
break;
case 5:
Wireframe = !Wireframe;
break;
case 6:
Crosshair++;
if (Crosshair > 7)
Crosshair--;
break;
case 7:
WallHack = !WallHack;
break;
case 8:
LTrippin = !LTrippin;
break;
}
}
}
if (Menu && ((GetAsyncKeyState(VK_LEFT) & 1)))
{
if (Menu)
{
switch (aMenuSelection)
{
case 0:
Chams = !Chams;
break;
case 1:
Glow = !Glow;
break;
case 2:
Frontcolor = !Frontcolor && !Backcolor;
break;
case 3:
Backcolor = !Backcolor && !Frontcolor;
break;
case 4:
NoSmoke = !NoSmoke;
break;
case 5:
Wireframe = !Wireframe;
break;
case 6:
Crosshair--;
if (Crosshair < 0)
Crosshair++;
break;
case 7:
WallHack = !WallHack;
break;
case 8:
LTrippin = !LTrippin;
break;
}
}
}
}
Код:
#pragma once
#include < Windows.h>
#include < Iostream>
#include < Stdio.h>
#include < Fstream>
#include < D3dx9.h>
#include < D3d9.h>
#include < psapi.h>
static ID3DXFont * m_pFont1 = NULL;
static ID3DXLine * XLine = NULL;
#define d3dColorRed D3DCOLOR_XRGB( 255, 0, 0 )
#define d3dColorBlue D3DCOLOR_XRGB( 0, 0, 255 )
#define d3dColorYellow D3DCOLOR_XRGB( 255, 255, 0 )
#define d3dColorGreen D3DCOLOR_XRGB(0, 255, 0 )
#define d3dColorLightBlue D3DCOLOR_XRGB(0, 191, 255 )
#define d3dColorBlack D3DCOLOR_XRGB(0, 0, 0 )
#define d3dColorWhite D3DCOLOR_XRGB( 255, 255, 255 )
#define d3dColorGrey D3DCOLOR_ARGB( 160 ,160, 160, 160 )
const BYTE red[58] = { //
0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00
};
const BYTE orange[58] = { //
0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA5, 0xFF, 0x00
};
const BYTE bGreen[60] = //
{
0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x20, 0xA0, 0x00, 0x00, 0xFF, 0xFF
};
const BYTE bBlue[60] = //
{
0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00
};
const BYTE bWhite[58] = //
{
0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0x00
};
const BYTE bYellow[60] = //
{
0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00
};
const BYTE bPink[58] = //
{
0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x00, 0xFF, 0x00
};
const BYTE bTur[60] = //
{
0x42, 0x4D, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x12, 0x0B, 0x00, 0x00, 0x12, 0x0B, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00
};
const BYTE bBlack[58] = { //
0x42, 0x4D, 0x3A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x28, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00,
0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
class cDirectClass
{
public:
cDirectClass(void)
{
}
~cDirectClass(void)
{
}
void InitObjects(IDirect3DDevice9 * pDevice);
void DrawLine(float StartX, float StartY, float EndX, float EndY, D3DCOLOR dColor);
void FillRGBA(float fPosX, float fPosY, float fWidth, float fHeight, D3DCOLOR dColor);
void DrawString(ID3DXFont * pFont, int nPosX, int nPosY, D3DCOLOR dColor, const char * cFmt, ...);
};
extern cDirectClass cDirectX;