[RELEASE] MOH Campaign/Tier1 Mode - Head Chams + Triggerbot
alright so same story as the last time, except I added a triggerbot and changed the white circle to a red dot (the triggerbot scans the two pixels directly diagonal to the corners of that dot, meaning the upper left and upper right pixel)
Press INSERT to toggle head chams
Press HOME to toggle red dot
Press DEL to auto-shoot (triggerbot) visible chams
Press END to autoshoot (triggerbot) through walls
with the default brightness/contrast this should work on all levels, however I do notice a hesitation of the triggerbot to shoot at someone behind a wall while you are in some sniper scopes
and because it is a GetPixel triggerbot, the higher your resolution, the greater the accuracy.
VirusTotal
Virscan
(AND THEY *SHOULD* MATCH - I changed the injector and got different false positves /
)
video is uploading.
VIDEO:
full source code for
d3d9dev.cpp (Azorbix StarterKit)
btw to those who say this is a virus/trojan
http://www.f-secure.com/v-descs/troj...isyn_cav.shtml
not ONE of the behaviors of the "real thing" that these scans give false positives for is on my PC and Ive been using it repeatedly on a daily basis.
Press INSERT to toggle head chams
Press HOME to toggle red dot
Press DEL to auto-shoot (triggerbot) visible chams
Press END to autoshoot (triggerbot) through walls
with the default brightness/contrast this should work on all levels, however I do notice a hesitation of the triggerbot to shoot at someone behind a wall while you are in some sniper scopes
and because it is a GetPixel triggerbot, the higher your resolution, the greater the accuracy.
VirusTotal
Virscan
(AND THEY *SHOULD* MATCH - I changed the injector and got different false positves /
)video is uploading.
VIDEO:
full source code for
d3d9dev.cpp (Azorbix StarterKit)
Code:
/* Direct3D9 Device */
#include <windows.h>
#include "main.h"
#include "d3d9.h"
#include "stdio.h"
#define D3DHOOK_TEXTURES //comment this to disable texture hooking
#define PI 3.14159265
bool shoot;
bool shootwall;
bool xhair;
bool Chams;
UINT m_Stride;
UINT modelrec;
ID3DXLine *pLine;
LPD3DXFONT pFont;
LPDIRECT3DDEVICE9 pDevice;
IDirect3DPixelShader9* shaderRed;
IDirect3DPixelShader9* shaderBlue;
D3DVIEWPORT9 Viewport;
D3DCOLOR dCIRCLE = D3DCOLOR_ARGB( 255, 0, 255, 0);//green
D3DCOLOR dCIRCLE2 = D3DCOLOR_ARGB( 255, 255, 0, 0);//red
void TriggerBotWall()
{
COLORREF cPixelb;
COLORREF cPixelb2;
HWND d3dhwnd2;
HDC d3ddc2;
d3dhwnd2 = GetForegroundWindow();
d3ddc2 = GetDC(d3dhwnd2);
{
cPixelb = GetPixel( d3ddc2, (Viewport.Width/2)-3, (Viewport.Height/2)-2);
cPixelb2 = GetPixel( d3ddc2, (Viewport.Width/2)+3, (Viewport.Height/2)-2);
// shootAT BLUE Chams (thru walls)
if(GetRValue(cPixelb)<= 100
&& GetGValue(cPixelb)<= 100
&& GetBValue(cPixelb)>= 200
&& GetRValue(cPixelb2)<= 100
&& GetGValue(cPixelb2)<= 100
&& GetBValue(cPixelb2)>= 200)
{
// QUICKSCOPE METHOD - SORT of works
// keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | 0,0);// assign Right CTRL to scope and toggle aim off
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, NULL, NULL); // Simulate click
mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, NULL, NULL);
// keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,0);
//mouse_event(MOUSEEVENTF_ABSOLUTE,((Viewport.Width/2)* (65535/Viewport.Width)),((Viewport.Height/2)-4* (65535/Viewport.Height)), NULL, NULL);
}
} // End X loop
ReleaseDC(d3dhwnd2,d3ddc2);
}
void TriggerBot()
{
COLORREF cPixelr;
COLORREF cPixelr2;
HWND d3dhwnd;
HDC d3ddc;
d3dhwnd = GetForegroundWindow();
d3ddc = GetDC(d3dhwnd);
{
cPixelr = GetPixel( d3ddc, (Viewport.Width/2)-3, (Viewport.Height/2)-2);
cPixelr2 = GetPixel( d3ddc, (Viewport.Width/2)+3, (Viewport.Height/2)-2);
// AIM AT BLUE Chams
//if(GetRValue(cPixel)<= 74
//&& GetGValue(cPixel)<= 74
//&& GetBValue(cPixel)>= 250)
// AIM AT RED Chams
if(GetRValue(cPixelr)>= 220
&& GetGValue(cPixelr)<= 100
&& GetBValue(cPixelr)<= 100
&& GetRValue(cPixelr2)>= 220
&& GetGValue(cPixelr2)<= 100
&& GetBValue(cPixelr2)<= 100)
{
//keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | 0,0);// bad quickscope attempt assign Right CTRL to scope and toggle aim off
//keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,0);mouse_event(MOUSEEVENTF_LEFTDOW N, 0, 0, NULL, NULL); // Simulate click
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, NULL, NULL); // Simulate click
mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,((Viewport.Width/2)* (65535/Viewport.Width)),((Viewport.Height/2)* (65535/Viewport.Height)), NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,((Viewport.Width/2)* (65535/Viewport.Width)),((Viewport.Height/2+2)* (65535/Viewport.Height)), NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,(Viewport.Width/2)+4,(Viewport.Height/2)-4, NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,(Viewport.Width/2)-4,(Viewport.Height/2)+4, NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,(Viewport.Width/2),(Viewport.Height/2)-4, NULL, NULL);
//mouse_event(MOUSEEVENTF_MOVE,0,20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,20,-20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,-20,20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,-20,-20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,20,20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,0,-20,0,0)
}
}
ReleaseDC(d3dhwnd,d3ddc);
} // End X loop
//void DrawCircle(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();
// pLine->Release();
//}
HRESULT GenerateShader(IDirect3DDevice9 *pD3Ddev, IDirect3DPixelShader9 **pShader, float r, float g, float b, float a)
{
char szShader[256];
ID3DXBuffer *pShaderBuf = NULL;
sprintf_s (szShader, "ps_2_0\ndef c0, %f, %f, %f, %f\nmov oC0, c0", r, g, b, a);
D3DXAssembleShader(szShader, sizeof(szShader), NULL, NULL, 0, &pShaderBuf, NULL);
if(FAILED(pD3Ddev->CreatePixelShader((const DWORD*)pShaderBuf->GetBufferPointer(), pShader)))
return E_FAIL;
return S_OK;
}
HRESULT CD3DManager::Initialize()
{
/*
initialize Resources such as textures
(managed and unmanaged [D3DPOOL]),
vertex buffers, and other D3D rendering resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
GenerateShader(m_pD3Ddev, &shaderRed, 255, 0, 0, 255);
GenerateShader(m_pD3Ddev, &shaderBlue, 0, 0, 255, 255);
return S_OK;
}
HRESULT CD3DManager::PreReset()
{
/*
release all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other
volitile resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
return S_OK;
}
HRESULT CD3DManager::PostReset()
{
/*
re-initialize all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other volitile
resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
return S_OK;
}
HRESULT CD3DManager::Release()
{
/*
Release all textures, vertex buffers, and
other resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
return S_OK;
}
//-----------------------------------------------------------------------------
HRESULT APIENTRY hkIDirect3DDevice9::QueryInterface(REFIID riid, LPVOID *ppvObj)
{
return m_pD3Ddev->QueryInterface(riid, ppvObj);
}
ULONG APIENTRY hkIDirect3DDevice9::AddRef()
{
m_refCount++;
return m_pD3Ddev->AddRef();
}
HRESULT APIENTRY hkIDirect3DDevice9::BeginScene()
{
m_pD3Ddev->GetViewport(&Viewport);
if (GetAsyncKeyState(VK_INSERT)&1)
{
Chams = !Chams;
}
if (GetAsyncKeyState(VK_HOME)&1)
{
xhair = !xhair;
}
if (GetAsyncKeyState(VK_DELETE)&1)
{
shoot = !shoot;
}
if (GetAsyncKeyState(VK_END)&1)
{
shootwall = !shootwall;
}
return m_pD3Ddev->BeginScene();
}
HRESULT APIENTRY hkIDirect3DDevice9::BeginStateBlock()
{
return m_pD3Ddev->BeginStateBlock();
}
HRESULT APIENTRY hkIDirect3DDevice9::Clear(DWORD Count, CONST D3DRECT *pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil)
{
return m_pD3Ddev->Clear(Count, pRects, Flags, Color, Z, Stencil);
}
HRESULT APIENTRY hkIDirect3DDevice9::ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect, D3DCOLOR color)
{
return m_pD3Ddev->ColorFill(pSurface,pRect,color);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateAdditionalSwapChain(D3DP RESENT_PARAMETERS *pPresentationParameters, IDirect3DSwapChain9 **ppSwapChain)
{
return m_pD3Ddev->CreateAdditionalSwapChain(pPresentationParameters, ppSwapChain);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateDepthStencilSurface(Width, Height, Format, MultiSample, MultisampleQuality,Discard,ppSurface, pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateOffscreenPlainSurface(UI NT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateOffscreenPlainSurface(Width,Height,Format,Po ol,ppSurface,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader)
{
return m_pD3Ddev->CreatePixelShader(pFunction, ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery)
{
if (m_Stride = 32)
{
if( Type == D3DQUERYTYPE_OCCLUSION )
{
Type = D3DQUERYTYPE_EVENT;
}
}
return m_pD3Ddev->CreateQuery(Type,ppQuery);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateRenderTarget(Width, Height, Format, MultiSample,MultisampleQuality, Lockable, ppSurface,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateStateBlock(D3DSTATEBLOCK TYPE Type,IDirect3DStateBlock9** ppSB)
{
return m_pD3Ddev->CreateStateBlock(Type, ppSB);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle)
{
HRESULT ret = m_pD3Ddev->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
#ifdef D3DHOOK_TEXTURES
if(ret == D3D_OK) { new hkIDirect3DTexture9(ppTexture, this, Width, Height, Format); }
#endif
return ret;
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl)
{
return m_pD3Ddev->CreateVertexDeclaration(pVertexElements,ppDecl);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader)
{
return m_pD3Ddev->CreateVertexShader(pFunction, ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::DeletePatch(UINT Handle)
{
return m_pD3Ddev->DeletePatch(Handle);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawIndexedPrimitive(D3DPRIMIT IVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
UINT modelrec;
modelrec = ((m_Stride == 32 && ((primCount != 0)||(primCount <= 18) ||(primCount == 25) || (primCount == 53)|| (primCount == 76)|| (primCount == 80)|| (primCount == 104)|| (primCount == 107)|| (primCount == 125)|| (primCount == 131)|| (primCount == 145)|| (primCount == 166)|| (primCount == 190)|| (primCount == 292)|| (primCount == 361)|| (primCount == 389)|| (primCount == 417)|| (primCount == 436)|| (primCount == 452)|| (primCount == 471)|| (primCount == 597)|| (primCount == 874)|| (primCount == 1101)|| (primCount == 1333)|| (primCount == 1446)|| (primCount == 2836))));
if (Chams)
{
//EXTRA FAR LOD HEADS (primCount): TO DO
// FAR LOD HEADS (primCount): 25, 36(ALSOREDDOT), 125(skimask), 131(towel),145,166(towel2),190,292
// MEDIUM LOD HEADS (primCount): 76, 104,107,361(skimask),389(towel2),436(towel),597,87 4,1446
// CLOSE LOD HEADS (primCount): 417,452,471,1101(skimask),1333,1376(towel),1437(to wel2),2836
if ((m_Stride == 32 && ((primCount <= 25) || (primCount == 53)|| (primCount == 76)|| (primCount == 80)|| (primCount == 104)|| (primCount == 107)|| (primCount == 125)|| (primCount == 131)|| (primCount == 145)|| (primCount == 166)|| (primCount == 190)|| (primCount == 292)|| (primCount == 361)|| (primCount == 389)|| (primCount == 417)|| (primCount == 436)|| (primCount == 452)|| (primCount == 471)|| (primCount == 597)|| (primCount == 874)|| (primCount == 1101)|| (primCount == 1333)|| (primCount == 1446)|| (primCount == 2836))))//FIX THIS
{
DWORD dwOldZEnable = D3DZB_TRUE;
m_pD3Ddev->GetRenderState(D3DRS_ZENABLE, &dwOldZEnable);
m_pD3Ddev->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
m_pD3Ddev->SetTexture(0, NULL );
m_pD3Ddev->SetPixelShader( NULL );
m_pD3Ddev->SetPixelShader( shaderBlue );
m_pD3Ddev->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
m_pD3Ddev->DrawIndexedPrimitive(Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
m_pD3Ddev->SetRenderState(D3DRS_ZENABLE, dwOldZEnable);
m_pD3Ddev->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
m_pD3Ddev->SetTexture(0, NULL );
m_pD3Ddev->SetPixelShader( NULL );
m_pD3Ddev->SetPixelShader( shaderRed );
}
}
if (xhair)
{
if ((m_Stride == 32 && ((primCount == 34 )||(primCount == 36))))// CULL RED DOT FROM ACOG (SO COLOR TRIGGERBOTS WORK BETTER) NO FIX FOR SNIPERSCOPES
{
DWORD dwOldZEnable = D3DZB_TRUE;
m_pD3Ddev->SetTexture(0, NULL );
m_pD3Ddev->DrawIndexedPrimitive(Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
m_pD3Ddev->SetTexture(0, NULL );
}
}
return m_pD3Ddev->DrawIndexedPrimitive(Type,BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIM ITIVETYPE PrimitiveType, UINT MinIndex, UINT NumVertices, UINT PrimitiveCount, CONST void *pIndexData, D3DFORMAT IndexDataFormat, CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawIndexedPrimitiveUP(PrimitiveType, MinIndex, NumVertices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount)
{
return m_pD3Ddev->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETY PE PrimitiveType, UINT PrimitiveCount, CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawRectPatch(UINT Handle, CONST float *pNumSegs, CONST D3DRECTPATCH_INFO *pRectPatchInfo)
{
return m_pD3Ddev->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawTriPatch(UINT Handle, CONST float *pNumSegs, CONST D3DTRIPATCH_INFO *pTriPatchInfo)
{
return m_pD3Ddev->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo);
}
HRESULT APIENTRY hkIDirect3DDevice9::EndScene()
{
if (shoot)
{
TriggerBot();
}
if (shootwall)
{
TriggerBotWall();
}
if(xhair)
{
D3DRECT aimdot3 = {(Viewport.Width/2)-1,(Viewport.Height/2)-2, (Viewport.Width/2)+1,(Viewport.Height/2)};
m_pD3Ddev->Clear(1, &aimdot3, D3DCLEAR_TARGET,dCIRCLE2, 0, 0);
}
return m_pD3Ddev->EndScene();
}
HRESULT APIENTRY hkIDirect3DDevice9::EndStateBlock(IDirect3DStateBl ock9** ppSB)
{
return m_pD3Ddev->EndStateBlock(ppSB);
}
HRESULT APIENTRY hkIDirect3DDevice9::EvictManagedResources()
{
return m_pD3Ddev->EvictManagedResources();
}
UINT APIENTRY hkIDirect3DDevice9::GetAvailableTextureMem()
{
return m_pD3Ddev->GetAvailableTextureMem();
}
HRESULT APIENTRY hkIDirect3DDevice9::GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer)
{
return m_pD3Ddev->GetBackBuffer(iSwapChain,iBackBuffer, Type, ppBackBuffer);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetClipPlane(DWORD Index, float *pPlane)
{
return m_pD3Ddev->GetClipPlane(Index, pPlane);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetClipStatus(D3DCLIPSTATUS9 *pClipStatus)
{
return m_pD3Ddev->GetClipStatus(pClipStatus);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetCreationParameters(D3DDEVIC E_CREATION_PARAMETERS *pParameters)
{
return m_pD3Ddev->GetCreationParameters(pParameters);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetCurrentTexturePalette(UINT *pPaletteNumber)
{
return m_pD3Ddev->GetCurrentTexturePalette(pPaletteNumber);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDepthStencilSurface(IDirect 3DSurface9 **ppZStencilSurface)
{
return m_pD3Ddev->GetDepthStencilSurface(ppZStencilSurface);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDeviceCaps(D3DCAPS9 *pCaps)
{
return m_pD3Ddev->GetDeviceCaps(pCaps);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDirect3D(IDirect3D9 **ppD3D9)
{
HRESULT hRet = m_pD3Ddev->GetDirect3D(ppD3D9);
if( SUCCEEDED(hRet) )
*ppD3D9 = m_pD3Dint;
return hRet;
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode)
{
return m_pD3Ddev->GetDisplayMode(iSwapChain,pMode);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface)
{
return m_pD3Ddev->GetFrontBufferData(iSwapChain,pDestSurface);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetFVF(DWORD* pFVF)
{
return m_pD3Ddev->GetFVF(pFVF);
}
void APIENTRY hkIDirect3DDevice9::GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->GetGammaRamp(iSwapChain,pRamp);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetIndices(IDirect3DIndexBuffe r9** ppIndexData)
{
return m_pD3Ddev->GetIndices(ppIndexData);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetLight(DWORD Index, D3DLIGHT9 *pLight)
{
return m_pD3Ddev->GetLight(Index, pLight);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetLightEnable(DWORD Index, BOOL *pEnable)
{
return m_pD3Ddev->GetLightEnable(Index, pEnable);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetMaterial(D3DMATERIAL9 *pMaterial)
{
return m_pD3Ddev->GetMaterial(pMaterial);
}
float APIENTRY hkIDirect3DDevice9::GetNPatchMode()
{
return m_pD3Ddev->GetNPatchMode();
}
unsigned int APIENTRY hkIDirect3DDevice9::GetNumberOfSwapChains()
{
return m_pD3Ddev->GetNumberOfSwapChains();
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY *pEntries)
{
return m_pD3Ddev->GetPaletteEntries(PaletteNumber, pEntries);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShader(IDirect3DPixelS hader9** ppShader)
{
return m_pD3Ddev->GetPixelShader(ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->GetPixelShaderConstantB(StartRegister,pConstantDat a,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->GetPixelShaderConstantF(StartRegister,pConstantDat a,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->GetPixelShaderConstantI(StartRegister,pConstantDat a,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus)
{
return m_pD3Ddev->GetRasterStatus(iSwapChain,pRasterStatus);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRenderState(D3DRENDERSTATET YPE State, DWORD *pValue)
{
return m_pD3Ddev->GetRenderState(State, pValue);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget)
{
return m_pD3Ddev->GetRenderTarget(RenderTargetIndex,ppRenderTarget);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRenderTargetData(IDirect3DS urface9* pRenderTarget,IDirect3DSurface9* pDestSurface)
{
return m_pD3Ddev->GetRenderTargetData(pRenderTarget,pDestSurface);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue)
{
return m_pD3Ddev->GetSamplerState(Sampler,Type,pValue);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetScissorRect(RECT* pRect)
{
return m_pD3Ddev->GetScissorRect(pRect);
}
BOOL APIENTRY hkIDirect3DDevice9::GetSoftwareVertexProcessing()
{
return m_pD3Ddev->GetSoftwareVertexProcessing();
}
HRESULT APIENTRY hkIDirect3DDevice9::GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride)
{
return m_pD3Ddev->GetStreamSource(StreamNumber, ppStreamData,OffsetInBytes, pStride);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetStreamSourceFreq(UINT StreamNumber,UINT* Divider)
{
return m_pD3Ddev->GetStreamSourceFreq(StreamNumber,Divider);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9** pSwapChain)
{
return m_pD3Ddev->GetSwapChain(iSwapChain,pSwapChain);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetTexture(DWORD Stage, IDirect3DBaseTexture9 **ppTexture)
{
return m_pD3Ddev->GetTexture(Stage, ppTexture);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD *pValue)
{
return m_pD3Ddev->GetTextureStageState(Stage, Type, pValue);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetTransform(D3DTRANSFORMSTATE TYPE State, D3DMATRIX *pMatrix)
{
return m_pD3Ddev->GetTransform(State, pMatrix);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexDeclaration(IDirect3D VertexDeclaration9** ppDecl)
{
return m_pD3Ddev->GetVertexDeclaration(ppDecl);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShader(IDirect3DVerte xShader9** ppShader)
{
return m_pD3Ddev->GetVertexShader(ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->GetVertexShaderConstantB(StartRegister,pConstantDa ta,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->GetVertexShaderConstantF(StartRegister,pConstantDa ta,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->GetVertexShaderConstantI(StartRegister,pConstantDa ta,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetViewport(D3DVIEWPORT9 *pViewport)
{
return m_pD3Ddev->GetViewport(pViewport);
}
HRESULT APIENTRY hkIDirect3DDevice9::LightEnable(DWORD LightIndex, BOOL bEnable)
{
return m_pD3Ddev->LightEnable(LightIndex, bEnable);
}
HRESULT APIENTRY hkIDirect3DDevice9::MultiplyTransform(D3DTRANSFORM STATETYPE State, CONST D3DMATRIX *pMatrix)
{
return m_pD3Ddev->MultiplyTransform(State, pMatrix);
}
HRESULT APIENTRY hkIDirect3DDevice9::Present(CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion)
{
return m_pD3Ddev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
}
HRESULT APIENTRY hkIDirect3DDevice9::ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags)
{
return m_pD3Ddev->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer,pVertexDecl, Flags);
}
ULONG APIENTRY hkIDirect3DDevice9::Release()
{
if( --m_refCount == 0 )
m_pManager->Release();
return m_pD3Ddev->Release();
}
HRESULT APIENTRY hkIDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS *pPresentationParameters)
{
m_pManager->PreReset();
HRESULT hRet = m_pD3Ddev->Reset(pPresentationParameters);
if( SUCCEEDED(hRet) )
{
m_PresentParam = *pPresentationParameters;
m_pManager->PostReset();
}
return hRet;
}
HRESULT APIENTRY hkIDirect3DDevice9::SetClipPlane(DWORD Index, CONST float *pPlane)
{
return m_pD3Ddev->SetClipPlane(Index, pPlane);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetClipStatus(CONST D3DCLIPSTATUS9 *pClipStatus)
{
return m_pD3Ddev->SetClipStatus(pClipStatus);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetCurrentTexturePalette(UINT PaletteNumber)
{
return m_pD3Ddev->SetCurrentTexturePalette(PaletteNumber);
}
void APIENTRY hkIDirect3DDevice9::SetCursorPosition(int X, int Y, DWORD Flags)
{
m_pD3Ddev->SetCursorPosition(X, Y, Flags);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9 *pCursorBitmap)
{
return m_pD3Ddev->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetDepthStencilSurface(IDirect 3DSurface9* pNewZStencil)
{
return m_pD3Ddev->SetDepthStencilSurface(pNewZStencil);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetDialogBoxMode(BOOL bEnableDialogs)
{
return m_pD3Ddev->SetDialogBoxMode(bEnableDialogs);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetFVF(DWORD FVF)
{
return m_pD3Ddev->SetFVF(FVF);
}
void APIENTRY hkIDirect3DDevice9::SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->SetGammaRamp(iSwapChain,Flags, pRamp);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetIndices(IDirect3DIndexBuffe r9* pIndexData)
{
return m_pD3Ddev->SetIndices(pIndexData);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetLight(DWORD Index, CONST D3DLIGHT9 *pLight)
{
return m_pD3Ddev->SetLight(Index, pLight);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetMaterial(CONST D3DMATERIAL9 *pMaterial)
{
return m_pD3Ddev->SetMaterial(pMaterial);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetNPatchMode(float nSegments)
{
return m_pD3Ddev->SetNPatchMode(nSegments);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPaletteEntries(UINT PaletteNumber, CONST PALETTEENTRY *pEntries)
{
return m_pD3Ddev->SetPaletteEntries(PaletteNumber, pEntries);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShader(IDirect3DPixelS hader9* pShader)
{
return m_pD3Ddev->SetPixelShader(pShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->SetPixelShaderConstantB(StartRegister,pConstantDat a,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->SetPixelShaderConstantF(StartRegister,pConstantDat a,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->SetPixelShaderConstantI(StartRegister,pConstantDat a,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetRenderState(D3DRENDERSTATET YPE State, DWORD Value)
{
return m_pD3Ddev->SetRenderState(State, Value);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget)
{
return m_pD3Ddev->SetRenderTarget(RenderTargetIndex,pRenderTarget);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value)
{
return m_pD3Ddev->SetSamplerState(Sampler,Type,Value);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetScissorRect(CONST RECT* pRect)
{
return m_pD3Ddev->SetScissorRect(pRect);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetSoftwareVertexProcessing(BO OL bSoftware)
{
return m_pD3Ddev->SetSoftwareVertexProcessing(bSoftware);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
{
if( StreamNumber == 0 ){m_Stride = Stride;}
return m_pD3Ddev->SetStreamSource(StreamNumber, pStreamData,OffsetInBytes, Stride);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetStreamSourceFreq(UINT StreamNumber,UINT Divider)
{
return m_pD3Ddev->SetStreamSourceFreq(StreamNumber,Divider);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetTexture(DWORD Stage, IDirect3DBaseTexture9 *pTexture)
{
#ifdef D3DHOOK_TEXTURES
IDirect3DDevice9 *dev = NULL;
if(pTexture != NULL && ((hkIDirect3DTexture9*)(pTexture))->GetDevice(&dev) == D3D_OK)
{
if(dev == this)
return m_pD3Ddev->SetTexture(Stage, ((hkIDirect3DTexture9*)(pTexture))->m_D3Dtex);
}
#endif
return m_pD3Ddev->SetTexture(Stage, pTexture);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value)
{
return m_pD3Ddev->SetTextureStageState(Stage, Type, Value);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetTransform(D3DTRANSFORMSTATE TYPE State, CONST D3DMATRIX *pMatrix)
{
return m_pD3Ddev->SetTransform(State, pMatrix);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexDeclaration(IDirect3D VertexDeclaration9* pDecl)
{
return m_pD3Ddev->SetVertexDeclaration(pDecl);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShader(IDirect3DVerte xShader9* pShader)
{
return m_pD3Ddev->SetVertexShader(pShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->SetVertexShaderConstantB(StartRegister,pConstantDa ta,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->SetVertexShaderConstantF(StartRegister,pConstantDa ta,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->SetVertexShaderConstantI(StartRegister,pConstantDa ta,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetViewport(CONST D3DVIEWPORT9 *pViewport)
{
return m_pD3Ddev->SetViewport(pViewport);
}
BOOL APIENTRY hkIDirect3DDevice9::ShowCursor(BOOL bShow)
{
return m_pD3Ddev->ShowCursor(bShow);
}
HRESULT APIENTRY hkIDirect3DDevice9::StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter)
{
return m_pD3Ddev->StretchRect(pSourceSurface,pSourceRect,pDestSurfac e,pDestRect,Filter);
}
HRESULT APIENTRY hkIDirect3DDevice9::TestCooperativeLevel()
{
return m_pD3Ddev->TestCooperativeLevel();
}
HRESULT APIENTRY hkIDirect3DDevice9::UpdateSurface(IDirect3DSurface 9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint)
{
return m_pD3Ddev->UpdateSurface(pSourceSurface,pSourceRect,pDestinat ionSurface,pDestPoint);
}
HRESULT APIENTRY hkIDirect3DDevice9::UpdateTexture(IDirect3DBaseTex ture9 *pSourceTexture, IDirect3DBaseTexture9 *pDestinationTexture)
{
return m_pD3Ddev->UpdateTexture(pSourceTexture, pDestinationTexture);
}
HRESULT APIENTRY hkIDirect3DDevice9::ValidateDevice(DWORD *pNumPasses)
{
return m_pD3Ddev->ValidateDevice(pNumPasses);
}
http://www.f-secure.com/v-descs/troj...isyn_cav.shtml
not ONE of the behaviors of the "real thing" that these scans give false positives for is on my PC and Ive been using it repeatedly on a daily basis.
MOH_campaign_chams-REDBLUEHEADS.rar
Nice job man.
I wouldnt mind a thanks button or two 
if you do infact like them
if you do infact like them works in multiplayer
Originally Posted by misiek709
works in multiplayer
CAMPAIGN = UNREAL 3 ENGINE
MULTIPLAYER = FROSTBITE ENGINE
I pretty much did this as a test to see how far I could go with copy and paste... and from what Ive learned so far, this is about it lol
all of the best hacks for all the multiplayer games out there dont use any of these methods at all, and use memory offsets to find pointers for certain things such as player locations and names, etc none of which I can even begin to do (although I did run cheat engine once
) if you are serious about making hacks I think the best place to start isnt with copy and pasting C++ code, its in learning "assembly" to be able to directly read and understand the data that exists in memory... to me it looks like a bunch of hex memory addresses that could be how much ammo is in your clip to what gun the buddy next to you has, I couldnt tell the difference, these guys can.Not gonna download .
VirusTotal 13%
VirusTotal 13%
great work, and dude above me, it appears you don't know much about hacking, well i don't blame you for being around so short but it's more creepy to have a hack without any virus showing than having some. Great work, tip, ad godmode and it'll be god.
nice man GJ!
Hello everyone
you can be banned for this?
you can be banned for this?
Ich habe den Hack getestet und kann sagen ... er geht nicht und es ist ein trojaner.
Nice release mate keep up the good work I have seen much improvement the whole time I have been on the sections your getting to be pretty good.
Looks good!
i really needed this hack
thank you so much
thank you so much
Im thinking the easiest way to get god mode AND aimbot would be unrealscript but Im pretty sure they locked out that part of the engine... there are lots of Uscript aimbots I still cant figure out how to get them to work for this game...
And as to the people who say this is a virus, its not, its the method in which the injector adds the DLL to the memory of the executable, and having all the virscan's come back with the same one is a GOOD thing. like Koen says, be more scared of hacks that dont have false positives heh and to the other question
YOU CANNOT BE BANNED BECAUSE SINGLEPLAYER HAS NO ANTICHEAT... lol none, not even the unreal engine built in one
And as to the people who say this is a virus, its not, its the method in which the injector adds the DLL to the memory of the executable, and having all the virscan's come back with the same one is a GOOD thing. like Koen says, be more scared of hacks that dont have false positives heh
and to the other questionYOU CANNOT BE BANNED BECAUSE SINGLEPLAYER HAS NO ANTICHEAT... lol none, not even the unreal engine built in one
i cant seem to get his to work..................does it work on windows 7 64 bit?
This thread is closed for replies.
