[RELEASE] MOH Campaign/Tier1 Mode - Head Chams + Triggerbot

[Birdshit]

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.

[IMG]https://lh6.ggph*****m/_1Wo4KO-ZjwU/TNNtUTcl8SI/AAAAAAAAACU/YKQtrnD_FMk/s1024/moh%202010-11-04%2021-17-38-60.jpg[/IMG]

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)

/*	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);
}

btw to those who say this is a virus/trojan

https://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.

[Zithium]

Nice job man.

[Birdshit]

I wouldnt mind a thanks button or two if you do infact like them

[misiek709]

works in multiplayer

[Birdshit]

works in multiplayer

no? is that a question?

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.

[Julma Henri]

Not gonna download .
VirusTotal 13%

[Koen]

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.

[xbeatsszzx]

nice man GJ!

[justerr71]

Hello everyone

you can be banned for this?

[slizza]

Ich habe den Hack getestet und kann sagen ... er geht nicht und es ist ein trojaner.

[Dakota]

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.

[ropsu678]

Looks good!

[blablablaido]

i really needed this hack
thank you so much

[Birdshit]

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

[smokey49203]

i cant seem to get his to work..................does it work on windows 7 64 bit?