PointBlank Hook

[spononoy]

Does anyone here playing PointBlank PH?
or Coding Cheats?

Can I request for the Source Code of your Hook?? Or the Full D3D Menu Hack(Outdated)?
I already Search from the GOOGLE, but it Needs to be Updated. And I Don't Know how to Updated it.

I have This Codes

#include "Headers.h"


#define Detour_Type_0xE9 1 
#define Detour_Type_0xB8 2 
#define Detour_Type_0x68 3 
#define Detour_Type_0xE8 4 

DWORD CreateDetour(DWORD dwThread,DWORD dwAdress,DWORD dwType,DWORD dwSize)
{
        DWORD dwDetour,dwProtect,i;
        if (dwAdress&&dwThread&&dwSize>= dwSize)
        {
                dwDetour = (DWORD)VirtualAlloc(0,dwSize+dwSize,0x1000,0x40);
                if (dwDetour&&VirtualProtect((VOID*)dwAdress,dwSize,0x40,&dwProtect))
                {
                        for (i=0;i<dwSize;i++)
                        {
                                *(BYTE*)(dwDetour+i)=*(BYTE*)(dwAdress+i);
                        }
                        switch (dwType)
                        {
                            case Detour_Type_0xE9:
                                {
                                    *(BYTE*)(dwDetour+dwSize+0)=0xE9;
                                    *(DWORD*)(dwDetour+dwSize+1)=(dwAdress-dwDetour-dwSize);
                                    *(BYTE*)(dwAdress+0)=0xE9;
                                    *(DWORD*)(dwAdress+1)=(dwThread-dwAdress-dwSize);
                                }
                                break;
                                case Detour_Type_0xB8:
                                {
                                    *(BYTE*)(dwDetour+dwSize+0)=0xB8;
                                    *(DWORD*)(dwDetour+dwSize+1)=(dwAdress+dwSize);
                                    *(WORD*)(dwDetour+dwSize+5)=0xE0FF;
                                    *(BYTE*)(dwAdress+0)=0xB8;            
                                    *(DWORD*)(dwAdress+1)=(dwThread);
                                    *(WORD*)(dwAdress+5)=0xE0FF;
                                }
                                break;
                                case Detour_Type_0x68:
                                {
                                    *(BYTE*)(dwDetour+dwSize+0)=0x68;
                                    *(DWORD*)(dwDetour+dwSize+1)=(dwAdress+dwSize);
                                    *(WORD*)(dwDetour+dwSize+5)=0xC3;
                                    *(BYTE*)(dwAdress+0)=0x68;            
                                    *(DWORD*)(dwAdress+1)=(dwThread);
                                    *(WORD*)(dwAdress+5)=0xC3;
                                }
                                break;
                        }
                        VirtualProtect((VOID*)dwAdress,dwSize,dwProtect,&dwProtect);
                        VirtualProtect((VOID*)dwDetour,dwSize+dwSize,0x20,&dwProtect);
                        return dwDetour;
                }
        }
        Sleep(10);
        return (0);
}

void *DetourFunc(BYTE *src, const BYTE *dst, const int len)
{
	BYTE *jmp = (BYTE*)malloc(len+5);
	DWORD dwback;

	VirtualProtect(src, len, PAGE_READWRITE, &dwback);

	memcpy(jmp, src, len);	jmp += len;
	
	jmp[0] = 0xE9;
	*(DWORD*)(jmp+1) = (DWORD)(src+len - jmp) - 5;

	src[0] = 0xE9;
	*(DWORD*)(src+1) = (DWORD)(dst - src) - 5;

	VirtualProtect(src, len, dwback, &dwback);

	return (jmp-len);
}

BOOL bCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
	for (; *szMask; ++szMask, ++pData, ++bMask)
		if (*szMask == 'x' && *pData != *bMask)
			return false;
	return (*szMask) == NULL;
}
DWORD FindPattern(DWORD dwAddress, DWORD dwLen, BYTE *bMask, char * szMask)
{
	for (DWORD i = 0; i < dwLen; i++)
		if (bCompare((BYTE*)(dwAddress + i), bMask, szMask))
			return (DWORD)(dwAddress + i);

	return 0;
}

DWORD* GetVTable()
{
     D3DPRESENT_PARAMETERS D3D_Present_Param={0,0,D3DFMT_UNKNOWN,0,D3DMULTISAMPLE_NONE,0,D3DSWAPEFFECT_DISCARD,0,1,0,D3DFMT_UNKNOWN,0,0,0};
     IDirect3DDevice9* pDummy;
	 LPDIRECT3DDEVICE9 pDevice;
     Direct3DCreate9(D3D_SDK_VERSION)->CreateDevice(0,D3DDEVTYPE_HAL,GetForegroundWindow(),D3DCREATE_SOFTWARE_VERTEXPROCESSING,&D3D_Present_Param,&pDummy);
     return (DWORD*)((DWORD*)pDevice)[0];
}

unsigned __stdcall Hook(LPVOID param) //<----- I Need to Update This
{
	DWORD* pVTable=GetVTable();
	pReset=(oReset)DetourFunc((PBYTE)pVTable[17],(PBYTE)hkReset, 6);
	pEndScene=(oEndScene)DetourFunc((PBYTE)pVTable[17],(PBYTE)hkEndScene, 6);
	pDrawIndexedPrimitive=(oDrawIndexedPrimitive)DetourFunc((PBYTE)pVTable[17],(PBYTE)hkDrawIndexedPrimitive, 6);
	return true;
}