HHHHELPPP !!! im a noob hack-maker :(

#include <windows.h>
#include "main.h"
#include "d3d8.h"
#include "graphic_adds.h"
#include <fstream> //
#include <stdio.h> //these are for your sprintf
#include "d3dfont.h" //this is for the font
#define D3DHOOK_TEXTURES //comment this to disable texture hooking
#define ABCPlayer (m_Stride == 44 || m_Stride == 44) // we declared our Player Body

HANDLE phandle;
HANDLE Wrrk;

CD3DFont* m_pFont_new = NULL;//one for menu
CD3DFont* m_pFont_INFO = NULL;////one for other text (such as a header)
char Display_Line[256];///256 is the max text it will pass
const D3DCOLOR txtRed = D3DCOLOR_ARGB(255, 255, 0, 0);
const D3DCOLOR txtGreen = D3DCOLOR_ARGB(255, 0,255, 0);


void Write_D3Dmem( void* pxAddress, void* pxBuffer )
{
unsigned long Protection;
VirtualProtect((void*)pxAddress, sizeof( pxBuffer ), PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)pxBuffer, sizeof( pxBuffer ));
VirtualProtect((void*)pxAddress, sizeof( pxBuffer ), Protection, 0);
}

///////////////////////////////////////////////// Addies Here!
// Example : #define yourhack_Addie 0x000000
//Add your next hack like the rest
#define uammo_Addie2 0x50E1F7
#define uammo_Addie3 0x50E1FD
#define scope_Addie1 0xC3E63A
#define ADR_Quickspawn1 0xEF9B38
#define ADR_Quickspawn2 0x123D424
#define ADR_Quickspawn3 0x123D420
#define playerpointer_Addie1 0x150FFA0
#define bounds_Addie1 0xF1C10C
#define bounds_Addie2 0xF1C110
#define nospread_Addie1 0xC3E690
#define fastall_Addie1 0xC3E644
#define fastall_Addie2 0xC3E648
#define fastall_Addie3 0xC3E64C
#define fastall_Addie4 0xC3E650
#define ADR_INVIS 0x514370
#define ADR_NAMEESP 0x512F94
#define ADR_NOKICK 0x4F4205
#define ADR_AUTOMEDIC 0x51A30F
#define bone_Addie1 0x4B3D64




///////////////////////////////////////////////// End of addies


UINT m_Stride;

bool CH_Menu = true;
//-------------------------------------
//You have to add your hack like thses here!
bool CH_Scope = false;
bool CH_ADR_Quickspawn = false;
bool CH_Playerpointer = false;
bool CH_Bounds = false;
bool CH_Nospread = false;
bool CH_Fastall = false;
bool CH_ADR_INVIS = false;
bool CH_ADR_NAMEESP = false;
bool CH_ADR_NOKICK = false;
bool CH_ADR_AUTOMEDIC = false;
bool CH_Bone = false;



//-------------------------------------
// Add a +1 with every hack in the[*] now its [2] next hack = [3]
// Also add a ,0 - so were {1,0} your next hack = {1,0,0}
int highlight[19] = {1,0,0,0,0,0,0,0,0,0,0,0};
//So for next hack it would be - int highlight[3] = {1,0,0}; EASY!




// Declare a string here everytime you add a Hack
//Just add your hack like these here! keeping it at 20
char scopestring[40] = {NULL};
char ADR_Quickspawnstring[40] = {NULL};
char playerpointerstring[40] = {NULL};
char Boundsstring[40] = {NULL};
char Nospreadstring[40] = {NULL};
char Fastallstring[40] = {NULL};
char ADR_INVISstring[40] = {NULL};
char ADR_NAMEESPstring[40] = {NULL};
char ADR_NOKICKstring[40] = {NULL};
char ADR_AUTOMEDICstring[40] = {NULL};
char Bonestring[40] = {NULL};



//After you have added to here scroll down untill you find ADD HACKS HERE
//While you scroll also look at the code on way down to get use to it!

// Below for your FONT text color
const D3DCOLOR textOrange = D3DCOLOR_ARGB(255, 255, 140, 0);
const D3DCOLOR textRed = D3DCOLOR_ARGB(255, 255, 0, 0);
const D3DCOLOR textGreen = D3DCOLOR_ARGB(255,0,255,0);
const D3DCOLOR textWhite = D3DCOLOR_ARGB(255,255,255,255);
const D3DCOLOR textBlue = D3DCOLOR_ARGB(255,0,0,255);
const D3DCOLOR textYellow = D3DCOLOR_ARGB(255,255,255,0);
const D3DCOLOR textPink = D3DCOLOR_ARGB(255,255,192,203);
const D3DCOLOR textBlack = D3DCOLOR_ARGB(255,0,0,0);
const D3DCOLOR textPurple = D3DCOLOR_ARGB(255,160,32,240);

/////////////// Colors ///////////////
LPDIRECT3DTEXTURE8 texRed;
LPDIRECT3DTEXTURE8 texBlue;
LPDIRECT3DTEXTURE8 texGreen;
LPDIRECT3DTEXTURE8 texYellow;
LPDIRECT3DTEXTURE8 texPink;
LPDIRECT3DTEXTURE8 texTur;
LPDIRECT3DTEXTURE8 texOrange;
LPDIRECT3DTEXTURE8 texWhite;
LPDIRECT3DTEXTURE8 texGrenade;
LPDIRECT3DTEXTURE8 texBlack;

//////////////////////////////////////////

void DrawRect(IDirect3DDevice8* Unidade, int baseX, int baseY, int baseW, int baseH, D3DCOLOR Cor)
{
D3DRECT BarRect = { baseX, baseY, baseX + baseW, baseY + baseH };
Unidade->Clear(1, &BarRect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, Cor, 0, 0);
}


HRESULT CD3DManager::Initialize()
{
/*
initialize Resources such as textures
(managed and unmanaged [D3DPOOL]),
vertex buffers, and other D3D rendering resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bRed, 60, &texRed);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bBlue, 60, &texBlue);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bGreen, 60, &texGreen);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bYellow, 60, &texYellow);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bPink, 60, &texPink);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bTur, 60, &texTur);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bOrange, 60, &texOrange);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bWhite, 60, &texWhite);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bYellow, 60, &texGrenade); //bGrenade
///////////these are for creating cham colors(incase you didnt know)

// Fonts to show text
m_pFont_new = new CD3DFont("Arial", 13, D3DFONT_BOLD);
m_pFont_new->InitDeviceObjects(m_pD3Ddev);
m_pFont_new->RestoreDeviceObjects();
m_pFont_INFO = new CD3DFont("Arial", 8, D3DFONT_BOLD);
m_pFont_INFO->InitDeviceObjects(m_pD3Ddev);
m_pFont_INFO->RestoreDeviceObjects();

//CH_Chams = true;
phandle = NULL;
Wrrk = GetCurrentProcess();

return S_OK;
}


HRESULT CD3DManager::PreReset()
{
/*
release all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other
volitile resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
m_pFont_new->InvalidateDeviceObjects();
m_pFont_new->DeleteDeviceObjects();
m_pFont_new = NULL;
m_pFont_INFO->InvalidateDeviceObjects();
m_pFont_INFO->DeleteDeviceObjects();
m_pFont_INFO = NULL;

return S_OK;
}



HRESULT CD3DManager::PostReset()
{
/*
re-initialize all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other volitile
resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
m_pFont_new = new CD3DFont("Arial", 13, D3DFONT_BOLD);
m_pFont_new->InitDeviceObjects(m_pD3Ddev);
m_pFont_new->RestoreDeviceObjects();
m_pFont_INFO = new CD3DFont("Arial", 8, D3DFONT_BOLD);
m_pFont_INFO->InitDeviceObjects(m_pD3Ddev);
m_pFont_INFO->RestoreDeviceObjects();

return S_OK;
}

//-------------functions-----------------------------------
void D3D_NOPING( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}

void D3D_NOP( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x1C};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}

void D3D_NOPINGS( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}
//----------------------------------------------------------------

HRESULT CD3DManager::Release()
{
/*
Release all textures, vertex buffers, and
other resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
m_pFont_new->InvalidateDeviceObjects();
m_pFont_new->DeleteDeviceObjects();
m_pFont_new = NULL;
m_pFont_INFO->InvalidateDeviceObjects();
m_pFont_INFO->DeleteDeviceObjects();
m_pFont_INFO = NULL;

CloseHandle(phandle);
phandle = NULL;

return S_OK;
}



//-----------------------------------------------------------------------------SteeL
//ok watch now everything under this is waht u were missing...
//-----------------------------------------------------------------------------

HRESULT APIENTRY hkIDirect3DDevice8::QueryInterface(REFIID riid, void** ppvObj)
{
return m_pD3Ddev->QueryInterface(riid, ppvObj);
}

ULONG APIENTRY hkIDirect3DDevice8::AddRef(void)
{
m_refCount++;
return m_pD3Ddev->AddRef();
}

ULONG APIENTRY hkIDirect3DDevice8::Release(void)
{
if( --m_refCount == 0 )
m_pManager->Release();

return m_pD3Ddev->Release();
}

HRESULT APIENTRY hkIDirect3DDevice8::TestCooperativeLevel(void)
{
return m_pD3Ddev->TestCooperativeLevel();
}

UINT APIENTRY hkIDirect3DDevice8::GetAvailableTextureMem(void)
{
return m_pD3Ddev->GetAvailableTextureMem();
}

HRESULT APIENTRY hkIDirect3DDevice8::ResourceManagerDiscardBytes(DW ORD Bytes)
{
return m_pD3Ddev->ResourceManagerDiscardBytes(Bytes);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDirect3D(IDirect3D8** ppD3D8)
{
HRESULT hRet = m_pD3Ddev->GetDirect3D(ppD3D8);
if( SUCCEEDED(hRet) )
*ppD3D8 = m_pD3Dint;
return hRet;
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDeviceCaps(D3DCAPS8* pCaps)
{
return m_pD3Ddev->GetDeviceCaps(pCaps);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDisplayMode(D3DDISPLAYMODE* pMode)
{
return m_pD3Ddev->GetDisplayMode(pMode);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetCreationParameters(D3DDEVIC E_CREATION_PARAMETERS *pParameters)
{
return m_pD3Ddev->GetCreationParameters(pParameters);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface8* pCursorBitmap)
{
return m_pD3Ddev->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap);
}

void APIENTRY hkIDirect3DDevice8::SetCursorPosition(int X,int Y,DWORD Flags)
{
m_pD3Ddev->SetCursorPosition(X, Y, Flags);
}

BOOL APIENTRY hkIDirect3DDevice8::ShowCursor(BOOL bShow)
{
return m_pD3Ddev->ShowCursor(bShow);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateAdditionalSwapChain(D3DP RESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain8** pSwapChain)
{
return m_pD3Ddev->CreateAdditionalSwapChain(pPresentationParamete rs , pSwapChain);
}

HRESULT APIENTRY hkIDirect3DDevice8::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 hkIDirect3DDevice8::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
{
return m_pD3Ddev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetBackBuffer(UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer)
{
return m_pD3Ddev->GetBackBuffer(BackBuffer, Type, ppBackBuffer);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetRasterStatus(D3DRASTER_STAT US* pRasterStatus)
{
return m_pD3Ddev->GetRasterStatus(pRasterStatus);
}

void APIENTRY hkIDirect3DDevice8::SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->SetGammaRamp(Flags, pRamp);
}

void APIENTRY hkIDirect3DDevice8::GetGammaRamp(D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->GetGammaRamp(pRamp);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture)
{
HRESULT hRet = m_pD3Ddev->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture);

#ifdef D3DHOOK_TEXTURES
if(hRet == D3D_OK) { *ppTexture = new hkIDirect3DTexture8(ppTexture, this, Width, Height, Format); }
#endif

return hRet;
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture)
{
return m_pD3Ddev->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture)
{
return m_pD3Ddev->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer)
{
return m_pD3Ddev->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer)
{
return m_pD3Ddev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface)
{
return m_pD3Ddev->CreateRenderTarget(Width, Height, Format, MultiSample, Lockable, ppSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface)
{
return m_pD3Ddev->CreateDepthStencilSurface(Width, Height, Format, MultiSample, ppSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateImageSurface(UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface)
{
return m_pD3Ddev->CreateImageSurface(Width, Height, Format, ppSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::CopyRects(IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray)
{
return m_pD3Ddev->CopyRects(pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray);
}

HRESULT APIENTRY hkIDirect3DDevice8::UpdateTexture(IDirect3DBaseTex ture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture)
{
return m_pD3Ddev->UpdateTexture(pSourceTexture, pDestinationTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetFrontBuffer(IDirect3DSurfac e8* pDestSurface)
{
return m_pD3Ddev->GetFrontBuffer(pDestSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetRenderTarget(IDirect3DSurfa ce8* pRenderTarget,IDirect3DSurface8* pNewZStencil)
{
return m_pD3Ddev->SetRenderTarget(pRenderTarget, pNewZStencil);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetRenderTarget(IDirect3DSurfa ce8** ppRenderTarget)
{
return m_pD3Ddev->GetRenderTarget(ppRenderTarget);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDepthStencilSurface(IDirect 3DSurface8** ppZStencilSurface)
{
return m_pD3Ddev->GetDepthStencilSurface(ppZStencilSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::BeginScene(void)
//----------------------------------------------
//-----------ADD HACKS HERE---------------------
{
if( CH_Scope )//Scope
{
if (GetAsyncKeyState(VK_RBUTTON)&1)
{
*(int*)0xC3E63A = 2,4
;}

}
}


{

if( CH_Quickspawn )//quickspawn

{
D3D_NOPING( ( void* )ADR_Quickspawn1, 3);
D3D_NOPING( ( void* )ADR_Quickspawn2, 3);
D3D_NOPING( ( void* )ADR_Quickspawn3, 3);
}
}

{
if( CH_Playerpointer )//player pointer
{
D3D_NOPING( ( void* )playerpointer_Addie1, 3);

}
}

{
if( CH_Bounds )//no bounds
{
D3D_NOPING( ( void* )bounds_Addie1, 3);
D3D_NOPING( ( void* )bounds_Addie2, 3);
}
}



{
if( CH_Nospread )//no spread
{
D3D_NOPING( ( void* )nospread_Addie1, 3);
}
}


{
if( CH_Fastall )//fast all
{
D3D_NOPING( ( void* )fastall_Addie1, 3);
D3D_NOPING( ( void* )fastall_Addie2, 3);
D3D_NOPING( ( void* )fastall_Addie3, 3);
D3D_NOPING( ( void* )fastall_Addie4, 3);
}
}

{
if( CH_ADR_INVIS )//invisible
{
D3D_NOPING( ( void* )ADR_INVIS, 3);
}
}

{
if( CH_ADR_NAMEESP )//esp
{
D3D_NOPING( ( void* )ADR_NAMEESP, 3);
}
}

{
if( CH_ADR_NOKICK )//antikick
{
D3D_NOPING( ( void* )ADR_NOKICK, 3);
}
}

{
if( CH_ADR_AUTOMEDIC )//automedic
{
D3D_NOPING( ( void* )ADR_AUTOMEDIC, 3);
}
}

{
if( CH_Bone )//boneshot
{
D3D_NOPING( ( void* )bone_Addie1, 3);
}
}


//Add hack above here
{
return m_pD3Ddev->BeginScene();
}
}
}
}
}
}
}
}
}
}
}
}

//Add anouther } with every hack!

HRESULT APIENTRY hkIDirect3DDevice8::EndScene(void)

; {
if (GetAsyncKeyState(VK_INSERT)&1)

if (m_pFont_new)
m_pFont_new->DrawText(15.0f, 100.0f, txtRed, "Muzymuzy's D3D");//Rename Your Hack

if (m_pFont_INFO)
{
if (CH_Menu)
{
//-----------------------
//-------OK below here just copy ONE of the lines and change to the hack your adding!
sprintf(unlimammostring, "%s", (CH_Unlimammo ? "Unlim ammo ON" : "Unlim ammo OFF"));
sprintf(scopestring, "%s", (CH_Scope ? "Scope ON" : "Scope OFF"));
sprintf(ADR_Quickspawnstring, "%s", (CH_ADR_Quickspawn ? "CH_ADR_Quickspawn ON" : "CH_ADR_Quickspawn OFF"));
sprintf(playerpointerstring, "%s", (CH_playerpointer ? "CH_playerpointer ON" : "CH_playerpointer OFF"));
sprintf(Boundsstring, "%s", (CH_Bounds ? "CH_Bounds ON" : "CH_Bounds OFF"));
sprintf(Nospreadstring, "%s", (CH_Nospread ? "CH_Nospread ON" : "CH_Nospread OFF"));
sprintf(Fastallstring, "%s", (CH_Fastall ? "CH_Fastall ON" : "CH_Fastall OFF"));
sprintf(ADR_INVISstring, "%s", (CH_ADR_INVIS ? "CH_ADR_INVIS ON" : "CH_ADR_INVIS OFF"));
sprintf(ADR_NAMEESPstring, "%s", (CH_ADR_NAMEESP ? "CH_ADR_NAMEESP ON" : "CH_ADR_NAMEESP OFF"));
sprintf(ADR_NOKICKstring, "%s", (CH_ADR_NOKICK ? "CH_ADR_NOKICK ON" : "CH_ADR_NOKICK OFF"));
sprintf(ADR_AUTOMEDICstring, "%s", (CH_ADR_AUTOMEDIC ? "CH_ADR_AUTOMEDIC ON" : "CH_ADR_AUTOMEDIC OFF"));
sprintf(Bonestring, "%s", (CH_Bone ? "CH_Bone ON" : "CH_Bone OFF"));

////--------------------------- this determines if the hack is highlighted -------------//
///--Same again Copy ONE of these and paste under the last one and change to your hack!
if(highlight[1]==1)
m_pFont_INFO->DrawText(15.0f, 120.0f, txtRed, unlimammostring);
else
m_pFont_INFO->DrawText(15.0f,120.0f, txtGreen, unlimammostring);

if(highlight[2]==1)
m_pFont_INFO->DrawText(15.0f, 130.0f, txtRed, scopestring);
else
m_pFont_INFO->DrawText(15.0f,130.0f, txtGreen, scopestring);

if(highlight[3]==1)
m_pFont_INFO->DrawText(15.0f, 140.0f, txtRed, ADR_Quickspawnstring);
else
m_pFont_INFO->DrawText(15.0f,140.0f, txtGreen, ADR_Quickspawnstring);

if(highlight[4]==1)
m_pFont_INFO->DrawText(15.0f, 150.0f, txtRed, playerpointerstring);
else
m_pFont_INFO->DrawText(15.0f,150.0f, txtGreen, playerpointerstring);

if(highlight[5]==1)
m_pFont_INFO->DrawText(15.0f, 160.0f, txtRed, Boundsstring);
else
m_pFont_INFO->DrawText(15.0f,160.0f, txtGreen, Boundsstring);

if(highlight[6]==1)
m_pFont_INFO->DrawText(15.0f, 170.0f, txtRed, Nospreadstring);
else
m_pFont_INFO->DrawText(15.0f,170.0f, txtGreen, Nospreadstring);

if(highlight[7]==1)
m_pFont_INFO->DrawText(15.0f, 180.0f, txtRed, Fastallstring);
else
m_pFont_INFO->DrawText(15.0f,180.0f, txtGreen, Fastallstring);

if(highlight[8]==1)
m_pFont_INFO->DrawText(15.0f, 190.0f, txtRed, ADR_INVISstring);
else
m_pFont_INFO->DrawText(15.0f,190.0f, txtGreen, ADR_INVISstring);

if(highlight[9]==1)
m_pFont_INFO->DrawText(15.0f, 200.0f, txtRed, ADR_NAMEESPstring);
else
m_pFont_INFO->DrawText(15.0f,200.0f, txtGreen, ADR_NAMEESPstring);

if(highlight[10]==1)
m_pFont_INFO->DrawText(15.0f, 210.0f, txtRed, ADR_NOKICKstring);
else
m_pFont_INFO->DrawText(15.0f,210.0f, txtGreen, ADR_NOKICKstring);

if(highlight[11]==1)
m_pFont_INFO->DrawText(15.0f, 220.0f, txtRed, ADR_AUTOMEDICstring);
else
m_pFont_INFO->DrawText(15.0f,220.0f, txtGreen, ADR_AUTOMEDICstring);

if(highlight[12]==1)
m_pFont_INFO->DrawText(15.0f, 230.0f, txtRed, Bonestring);
else
m_pFont_INFO->DrawText(15.0f,230.0f, txtGreen, Bonestring);






////-------------------------------------------------------------------------------------------------//


////------------------------This is how to use our menu ----------------------------------//

if(GetAsyncKeyState(VK_UP)&1)
{
//ADD +1 to were the 3 is so if its a new hack the 3 will be 4
for(int i=0; i < 12; i++)
{
if (highlight[i] == 1)
{
int a = i-1;

if(a < 1)
break;

else
{
highlight[a]=1;
highlight[i]=0;
break;
}
}
}
}

if(GetAsyncKeyState(VK_DOWN)&1)
{
for(int i=0; i < 12; i++) //Same again with the 3 add +1 with every hack!
{
if (highlight[i] == 1)
{
int a = i+1;

if(a > 12) //Same with the 2 add +1 with every hack
break;

else
{
highlight[a]=1;
highlight[i]=0;
break;
}
}
}
}

////------------------------ Activate hacks on/off here ------------------------------------//

if (GetAsyncKeyState(VK_INSERT)&1)
CH_Menu = !CH_Menu;
//--------------------------------------------------
//---Copy ONE of these and paste under the last!
//When adding a hack were the numbers are in the[*] Change it each time going in 1,2,3,4 and so on

if(highlight[1] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Unlimammo = !CH_Unlimammo;

if(highlight[2] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Scope = !CH_Scope;

if(highlight[3] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Quickspawn = !CH_Quickspawn;

if(highlight[4] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Playerpointer = !CH_Playerpointer;

if(highlight[5] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Bounds = !CH_Bounds;

if(highlight[6] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Nospread = !CH_Nospread;

if(highlight[7] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Fastall = !CH_Fastall;

if(highlight[8] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_ADR_INVIS = !CH_ADR_INVIS;

if(highlight[9] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_ADR_NAMEESP = !CH_ADR_NAMEESP;

if(highlight[10] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_ADR_NOKICK = !CH_ADR_NOKICK;

if(highlight[11] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_ADR_AUTOMEDIC = !CH_ADR_AUTOMEDIC;

if(highlight[12] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Bone = !CH_Bone;

//---------Paste above me!
//Once done hit Build then Rebuild to test for erros!
//Then build again and then Batch then rebuld all!
//Any errors then goto www.wr.ruworth.com
//Try to work them out b4 you do!
;}
}


return m_pD3Ddev->EndScene();
}

HRESULT APIENTRY hkIDirect3DDevice8::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 hkIDirect3DDevice8::SetTransform(D3DTRANSFORMSTATE TYPE State,CONST D3DMATRIX* pMatrix)
{
return m_pD3Ddev->SetTransform(State, pMatrix);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetTransform(D3DTRANSFORMSTATE TYPE State,D3DMATRIX* pMatrix)
{
return m_pD3Ddev->GetTransform(State, pMatrix);
}

HRESULT APIENTRY hkIDirect3DDevice8::MultiplyTransform( D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
{
return m_pD3Ddev->MultiplyTransform(State,pMatrix);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetViewport( CONST D3DVIEWPORT8* pViewport)
{
return m_pD3Ddev->SetViewport(pViewport);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetViewport( D3DVIEWPORT8* pViewport)
{
return m_pD3Ddev->GetViewport(pViewport);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetMaterial( CONST D3DMATERIAL8* pMaterial)
{
return m_pD3Ddev->SetMaterial(pMaterial);
}


HRESULT APIENTRY hkIDirect3DDevice8::GetMaterial( D3DMATERIAL8* pMaterial)
{
return m_pD3Ddev->GetMaterial(pMaterial);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetLight( DWORD Index,CONST D3DLIGHT8* pLight)
{
return m_pD3Ddev->SetLight(Index,pLight);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetLight( DWORD Index,D3DLIGHT8* pLight)
{
return m_pD3Ddev->GetLight(Index,pLight);
}

HRESULT APIENTRY hkIDirect3DDevice8::LightEnable( DWORD Index,BOOL Enable)
{
return m_pD3Ddev->LightEnable(Index,Enable);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetLightEnable( DWORD Index,BOOL* pEnable)
{
return m_pD3Ddev->GetLightEnable(Index,pEnable);
}

HRESULT APIENTRY hkIDirect3DDevice8::Se***ipPlane( DWORD Index,CONST float* pPlane)
{
return m_pD3Ddev->Se***ipPlane(Index,pPlane);
}

HRESULT APIENTRY hkIDirect3DDevice8::Ge***ipPlane( DWORD Index,float* pPlane)
{
return m_pD3Ddev->Ge***ipPlane(Index,pPlane);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetRenderState( D3DRENDERSTATETYPE State,DWORD Value)
{
return m_pD3Ddev->SetRenderState(State,Value);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetRenderState( D3DRENDERSTATETYPE State,DWORD* pValue)
{
return m_pD3Ddev->GetRenderState(State,pValue);
}

HRESULT APIENTRY hkIDirect3DDevice8::BeginStateBlock(void)
{
return m_pD3Ddev->BeginStateBlock();
}

HRESULT APIENTRY hkIDirect3DDevice8::EndStateBlock( DWORD* pToken)
{
return m_pD3Ddev->EndStateBlock(pToken);
}

HRESULT APIENTRY hkIDirect3DDevice8::ApplyStateBlock( DWORD Token)
{
return m_pD3Ddev->ApplyStateBlock(Token);
}

HRESULT APIENTRY hkIDirect3DDevice8::CaptureStateBlock( DWORD Token)
{
return m_pD3Ddev->CaptureStateBlock(Token);
}

HRESULT APIENTRY hkIDirect3DDevice8:eleteStateBlock( DWORD Token)
{
return m_pD3Ddev->DeleteStateBlock(Token);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateStateBlock( D3DSTATEBLOCKTYPE Type,DWORD* pToken)
{
return m_pD3Ddev->CreateStateBlock(Type,pToken);
}

HRESULT APIENTRY hkIDirect3DDevice8::Se***ipStatus( CONST D3DCLIPSTATUS8* pClipStatus)
{
return m_pD3Ddev->Se***ipStatus(pClipStatus);
}

HRESULT APIENTRY hkIDirect3DDevice8::Ge***ipStatus( D3DCLIPSTATUS8* pClipStatus)
{
return m_pD3Ddev->Ge***ipStatus(pClipStatus);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetTexture( DWORD Stage,IDirect3DBaseTexture8** ppTexture)
{
return m_pD3Ddev->GetTexture(Stage,ppTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetTexture(DWORD Stage,IDirect3DBaseTexture8* pTexture)
{
#ifdef D3DHOOK_TEXTURES
IDirect3DDevice8 *dev = NULL;
if(pTexture != NULL && ((hkIDirect3DTexture8*)(pTexture))->GetDevice(&dev) == D3D_OK)
{
if(dev == this)
return m_pD3Ddev->SetTexture(Stage, ((hkIDirect3DTexture8*)(pTexture))->m_D3Dtex);
}
#endif

return m_pD3Ddev->SetTexture(Stage,pTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetTextureStageState( DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue)
{
return m_pD3Ddev->GetTextureStageState(Stage,Type,pValue);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetTextureStageState( DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value)
{
return m_pD3Ddev->SetTextureStageState(Stage,Type,Value);
}

HRESULT APIENTRY hkIDirect3DDevice8::ValidateDevice( DWORD* pNumPasses)
{
return m_pD3Ddev->ValidateDevice(pNumPasses);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetInfo( DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize)
{
return m_pD3Ddev->GetInfo(DevInfoID,pDevInfoStruct,DevInfoStructS iz e);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetPaletteEntries( UINT PaletteNumber,CONST PALETTEENTRY* pEntries)
{
return m_pD3Ddev->SetPaletteEntries(PaletteNumber,pEntries);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries)
{
return m_pD3Ddev->GetPaletteEntries(PaletteNumber, pEntries);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetCurrentTexturePalette(UINT PaletteNumber)
{
return m_pD3Ddev->SetCurrentTexturePalette(PaletteNumber);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetCurrentTexturePalette(UINT *PaletteNumber)
{
return m_pD3Ddev->GetCurrentTexturePalette(PaletteNumber);
}

HRESULT APIENTRY hkIDirect3DDevice8:rawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount)
{
return m_pD3Ddev->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount);
}

HRESULT APIENTRY hkIDirect3DDevice8:rawIndexedPrimitive(D3DPRIMIT IVETYPE PrimitiveType,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
return m_pD3Ddev->DrawIndexedPrimitive(PrimitiveType, minIndex, NumVertices, startIndex, primCount);
}

HRESULT APIENTRY hkIDirect3DDevice8:rawPrimitiveUP(D3DPRIMITIVETY PE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
}

HRESULT APIENTRY hkIDirect3DDevice8:rawIndexedPrimitiveUP(D3DPRIM ITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
}

HRESULT APIENTRY hkIDirect3DDevice8::ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags)
{
return m_pD3Ddev->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer, Flags);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateVertexShader(CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage)
{
return m_pD3Ddev->CreateVertexShader(pDeclaration, pFunction, pHandle, Usage);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetVertexShader(DWORD Handle)
{
return m_pD3Ddev->SetVertexShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShader(DWORD* pHandle)
{
return m_pD3Ddev->GetVertexShader(pHandle);
}

HRESULT APIENTRY hkIDirect3DDevice8:eleteVertexShader(DWORD Handle)
{
return m_pD3Ddev->DeleteVertexShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetVertexShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->SetVertexShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->GetVertexShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShaderDeclaration(DWO RD Handle,void* pData,DWORD* pSizeOfData)
{
return m_pD3Ddev->GetVertexShaderDeclaration(Handle, pData, pSizeOfData);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData)
{
return m_pD3Ddev->GetVertexShaderFunction(Handle, pData, pSizeOfData);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride)
{
return m_pD3Ddev->SetStreamSource(StreamNumber, pStreamData, Stride);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride)
{
return m_pD3Ddev->GetStreamSource(StreamNumber, ppStreamData, pStride);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetIndices(IDirect3DIndexBuffe r8* pIndexData,UINT BaseVertexIndex)
{
return m_pD3Ddev->SetIndices(pIndexData, BaseVertexIndex);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetIndices(IDirect3DIndexBuffe r8** ppIndexData,UINT* pBaseVertexIndex)
{
return m_pD3Ddev->GetIndices(ppIndexData, pBaseVertexIndex);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreatePixelShader(CONST DWORD* pFunction,DWORD* pHandle)
{
return m_pD3Ddev->CreatePixelShader(pFunction, pHandle);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetPixelShader(DWORD Handle)
{
return m_pD3Ddev->SetPixelShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPixelShader(DWORD* pHandle)
{
return m_pD3Ddev->GetPixelShader(pHandle);
}

HRESULT APIENTRY hkIDirect3DDevice8:eletePixelShader(DWORD Handle)
{
return m_pD3Ddev->DeletePixelShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetPixelShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->SetPixelShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPixelShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->GetPixelShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPixelShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData)
{
return m_pD3Ddev->GetPixelShaderFunction(Handle, pData, pSizeOfData);
}

HRESULT APIENTRY hkIDirect3DDevice8:rawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo)
{
return m_pD3Ddev->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo);
}

HRESULT APIENTRY hkIDirect3DDevice8:rawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo)
{
return m_pD3Ddev->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo);
}

HRESULT APIENTRY hkIDirect3DDevice8:eletePatch(UINT Handle)
{
return m_pD3Ddev->DeletePatch(Handle);
}

(477) : error C2447: missing function header (old-style formal list?)
(488) : error C2447: missing function header (old-style formal list?)
(496) : error C2447: missing function header (old-style formal list?)
(506) : error C2447: missing function header (old-style formal list?)
(514) : error C2447: missing function header (old-style formal list?)
(524) : error C2447: missing function header (old-style formal list?)
(531) : error C2447: missing function header (old-style formal list?)
(538) : error C2447: missing function header (old-style formal list?)
(545) : error C2447: missing function header (old-style formal list?)
(552) : error C2447: missing function header (old-style formal list?)
(561) : error C2447: missing function header (old-style formal list?)
(564) : error C2143: syntax error : missing ';' before '}'
(564) : error C2143: syntax error : missing ';' before '}'
(564) : error C2143: syntax error : missing ';' before '}'
(565) : error C2143: syntax error : missing ';' before '}'
(565) : error C2143: syntax error : missing ';' before '}'
(566) : error C2143: syntax error : missing ';' before '}'
(566) : error C2143: syntax error : missing ';' before '}'
(567) : error C2143: syntax error : missing ';' before '}'
(567) : error C2143: syntax error : missing ';' before '}'
(568) : error C2143: syntax error : missing ';' before '}'
(568) : error C2143: syntax error : missing ';' before '}'
(569) : error C2143: syntax error : missing ';' before '}'
(569) : error C2143: syntax error : missing ';' before '}'
(570) : error C2143: syntax error : missing ';' before '}'
(570) : error C2143: syntax error : missing ';' before '}'
(571) : error C2143: syntax error : missing ';' before '}'
(571) : error C2143: syntax error : missing ';' before '}'
(572) : error C2143: syntax error : missing ';' before '}'
(572) : error C2143: syntax error : missing ';' before '}'
(573) : error C2143: syntax error : missing ';' before '}'
(573) : error C2143: syntax error : missing ';' before '}'
(574) : error C2143: syntax error : missing ';' before '}'
(574) : error C2143: syntax error : missing ';' before '}'
(580) : error C2447: missing function header (old-style formal list?)

Error executing cl.exe.

TatniumD3D.dll - 35 error(s), 0 warning(s)

(477) : error C2447: missing function header (old-style formal list?)
(488) : error C2447: missing function header (old-style formal list?)
(496) : error C2447: missing function header (old-style formal list?)
(506) : error C2447: missing function header (old-style formal list?)
(514) : error C2447: missing function header (old-style formal list?)
(524) : error C2447: missing function header (old-style formal list?)
(531) : error C2447: missing function header (old-style formal list?)
(538) : error C2447: missing function header (old-style formal list?)
(545) : error C2447: missing function header (old-style formal list?)
(552) : error C2447: missing function header (old-style formal list?)
(561) : error C2447: missing function header (old-style formal list?)
(564) : error C2143: syntax error : missing ';' before '}'
(564) : error C2143: syntax error : missing ';' before '}'
(564) : error C2143: syntax error : missing ';' before '}'
(565) : error C2143: syntax error : missing ';' before '}'
(565) : error C2143: syntax error : missing ';' before '}'
(566) : error C2143: syntax error : missing ';' before '}'
(566) : error C2143: syntax error : missing ';' before '}'
(567) : error C2143: syntax error : missing ';' before '}'
(567) : error C2143: syntax error : missing ';' before '}'
(568) : error C2143: syntax error : missing ';' before '}'
(568) : error C2143: syntax error : missing ';' before '}'
(569) : error C2143: syntax error : missing ';' before '}'
(569) : error C2143: syntax error : missing ';' before '}'
(570) : error C2143: syntax error : missing ';' before '}'
(570) : error C2143: syntax error : missing ';' before '}'
(571) : error C2143: syntax error : missing ';' before '}'
(571) : error C2143: syntax error : missing ';' before '}'
(572) : error C2143: syntax error : missing ';' before '}'
(572) : error C2143: syntax error : missing ';' before '}'
(573) : error C2143: syntax error : missing ';' before '}'
(573) : error C2143: syntax error : missing ';' before '}'
(574) : error C2143: syntax error : missing ';' before '}'
(574) : error C2143: syntax error : missing ';' before '}'
(580) : error C2447: missing function header (old-style formal list?)

1>------ Build started: Project: TatniumD3D, Configuration: Debug Win32 ------
1>Compiling...
1>d3d8tex.cpp
1>c:documents and settingsthe guydesktopd3d-emptyd3d8.h(7) : fatal error C1083: Cannot open include file: 'd3d8.h': No such file or directory
1>d3d8int.cpp
1>c:documents and settingsthe guydesktopd3d-emptyd3d8.h(7) : fatal error C1083: Cannot open include file: 'd3d8.h': No such file or directory
1>d3d8dev.cpp
1>c:documents and settingsthe guydesktopd3d-emptyd3d8.h(7) : fatal error C1083: Cannot open include file: 'd3d8.h': No such file or directory
1>main.cpp
1>c:documents and settingsthe guydesktopd3d-emptyd3d8.h(7) : fatal error C1083: Cannot open include file: 'd3d8.h': No such file or directory
1>d3d8.cpp
1>c:documents and settingsthe guydesktopd3d-emptyd3d8.h(7) : fatal error C1083: Cannot open include file: 'd3d8.h': No such file or directory