Results 1 to 1 of 1
  1. #1
    Viibez's Avatar
    Join Date
    May 2009
    Gender
    male
    Posts
    5,828
    Reputation
    801
    Thanks
    2,778
    My Mood
    Amused

    BF:P4F ESP [NO MENU - CODE]

    May you can fix it

    Code:
    /**********************Battlefield Play4Free************************/
    /*************************Working Base******************************/
    /**************************12/14/2010*******************************/
    /*Credits to: zoomgod, Strife, Winslow, GetModuleHandle, Freaky123**/
    /***Patrick, R4z8r, learn_more, doobie, KozmoK, Sparten, smoochy,***/
    /**********************Jugga, Vossy, Viibez************************/
    
    /****************Creator of this base: 5$andimyours*****************/
    
    /*   This is a MPGH-ONLY public release.
    /*   Please do not discuss or share this outside of the MPGH forum.
    /*
    /*   This information is distributed in the hope that it will be useful,
    /*   but WITHOUT ANY WARRANTY, without even the implied warranty of
    /*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */
    
    
    #include "BFP4F_Classes.h"
    #include "Functions.h"
    #include <Tlhelp32.h>
    bool lon = false;
    HMODULE hmRendDx9Base = NULL;
    DWORD    dwInitDllBase    = NULL;
    #define IsPlayerValid(p) ( (p) && (p->Alive) && (p->Soldier) && (p->Soldier->soldier_ptr) /*&& (p->SoldierObj->soldier_ptr->Matrix)*/ )
    bool Initialized = false;
    LPDIRECT3DDEVICE9 pDevice;
    D3DVIEWPORT9 Viewport;
    bool Fire = false;
    void SetMyCursorPos(FLOAT PosX, FLOAT PosY) 
    { 
        //Credits: Razor
        FLOAT ScreenX = (float)Viewport.Width/2;
        FLOAT ScreenY = (float)Viewport.Height/2;
        //PosX -= ScreenX;
        //PosY -= ScreenY;
    
        mouse_event( 0x1, PosX, PosY, NULL, NULL ); 
    }
    ID3DXFont *pFont;
    #define dWhite    D3DCOLOR_RGBA(255, 255, 255, 255)
    #define dRed    D3DCOLOR_RGBA(255, 000, 000, 255)
    #define dGreen    D3DCOLOR_RGBA(000, 255, 000, 255)
    #define dBlue    D3DCOLOR_RGBA(000, 000, 255, 255)
    #define dBlack    D3DCOLOR_RGBA(128, 128, 128, 255)
    #define dPurple    D3DCOLOR_RGBA(125, 000, 255, 255)
    #define dGrey    D3DCOLOR_RGBA(128, 128, 128, 255)
    #define dYellow    D3DCOLOR_RGBA(255, 255, 000, 255)
    #define dOrange    D3DCOLOR_RGBA(255, 125, 000, 255)
    CClassManager*            pClassManager;
    CRenderer*                pRenderer;
    CPlayerManager*            pPlayerManager;
    CPlayer*                pLocalPlayer;  
    CInputManager*            pInputManager;
    CActionBuffer*            pActionBuffer;
    DWORD                    oActionBuffer = 0;
    CObjectManager*            pObjectManager;
    CDebugTextWriter*        pDebugTextWriter;
    DWORD                    dwWorldToScreen;
    #define PATT_CLASSMANAGER    "\x89\x35\x99\x99\x99\x99\xFF\x15\x99\x99\x99\x99\x8B\x0D\x99\x99\x99\x99\x8B\x01"
    #define MASK_CLASSMANAGER    "xx????xx????xx????xx"
    float actionBuffer[64] = {0};
    void wtoc(CHAR*, const WCHAR*);
    DWORD GetModuleSize(LPSTR strModuleName)
    {
        MODULEENTRY32    lpme= {0};
        DWORD            dwSize=0;
        DWORD            PID=GetCurrentProcessId();
        BOOL            isMod=0;
        char            chModName[256];
    
        strcpy(chModName,strModuleName);
        _strlwr(chModName);
    
        HANDLE hSnapshotModule=CreateToolhelp32Snapshot(TH32CS_SNAPMODULE ,PID);
        if (hSnapshotModule) 
        {
            lpme.dwSize=sizeof(lpme);
            isMod=Module32First(hSnapshotModule,&lpme);
            while(isMod) 
            {
                char wtocI[256] = {0};
                wtoc(wtocI,lpme.szExePath);
                if (strcmp(_strlwr(wtocI),chModName)) 
                {
                    dwSize=(DWORD)lpme.modBaseSize;
                    CloseHandle(hSnapshotModule);
                    return dwSize;
                }
                isMod=Module32Next(hSnapshotModule,&lpme);
            }
        }
        CloseHandle(hSnapshotModule);
    
        return 0;
    }
    
    __declspec( naked ) bool WINAPI bWorldToScreen( D3DXVECTOR3* pVecInOut )
    {
        _asm mov ecx, pDebugTextWriter;
        _asm jmp [ dwWorldToScreen ];
    }
    
    #define SmoPat  "\x81\xEC\x00\x00\x00\x00\xD9\xEE\x8B\x0D\x00\x00\x00\x00\x8B\x01\xD9\x54\x24\x04\x8B\x50\x6C\xD9\x54\x24\x08\x56"
    #define SmoMask "xx????xxxx????xxxxxxxxxxxxxx"
    
    DWORD FindPattern(DWORD, DWORD, BYTE*, char*);
    
    bool FindMyWorldToScreen()
    {
        DWORD dwRendererBase = (DWORD)GetModuleHandle( L"RendDx9.dll" );
        //MessageBox(0,L"Before.",L"Victory",0);
        DWORD dwRendererSize = GetModuleSize("RendDx9.dll");
        //MessageBox(0,L"After.",L"Victory",0);
        dwWorldToScreen = FindPattern( dwRendererBase,dwRendererSize,(PBYTE)SmoPat, SmoMask );
    
        if(!dwWorldToScreen)
            return false;
    
        return true;
    }
    
    DWORD FindPattern(DWORD start_offset, DWORD size, BYTE* pattern, char mask[] )
    {
        DWORD pos = 0;
        int searchLen = strlen(mask) - 1;
    
        for( DWORD retAddress = start_offset; retAddress < start_offset + size; retAddress++ )
        {
            if( *(BYTE*)retAddress == pattern[pos] || mask[pos] == '?' ){
                if( mask[pos+1] == '\0' )
                    return (retAddress - searchLen);
                pos++;
            } 
            else 
                pos = 0;
        }
        return NULL;
    }
    /*CActionBuffer* _stdcall hkActionBuffer()
    {
    //MessageBox(0,L"F***PB",0,0);
    _asm call oActionBuffer;
    _asm mov pActionBuffer, eax;
    
    _asm pushad;
    
    if( pActionBuffer )
    {
    for ( int i = 0; i < 64; i++ ) 
    {
    pActionBuffer->inputKeys[ i ] += actionBuffer[ i ];
    
    //actionBuffer[ i ] = 0.0f;
    if (GetAsyncKeyState(VK_UP) || (GetAsyncKeyState(VK_UP) && GetAsyncKeyState(0x41)) || (GetAsyncKeyState(VK_UP) && GetAsyncKeyState(0x53)))
    {
    pActionBuffer->inputKeys[3] = 99999.0f;
    }
    }
    } 
    _asm popad;
    return pActionBuffer;
    }//*/
    
    CActionBuffer* hkActionBuffer()
    {
        __asm call oActionBuffer;
        __asm mov pActionBuffer, eax;
        __asm pushad;
    
        if(pActionBuffer)
        {
            for(int i = 0; i < 255; i ++)
            {
                pActionBuffer->inputKeys[i] += actionBuffer[i];
                actionBuffer[i] = 0.0f;
            }
        }
    
        __asm popad;
        return pActionBuffer;
    }
    int zoomhack = 1;
    void HackRoutine()
    {
        //if (GetAsyncKeyState(VK_NUMPAD1))
        //    lon = !lon;
        //if (Fire)
        ///{
        //    mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
        //    Sleep(25);
        //    mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
        //    Fire = false;
        //}
        if (GetAsyncKeyState(VK_ADD)&1)
        {
            zoomhack += 1;
        }
        else if (GetAsyncKeyState(VK_SUBTRACT)&1)
        {
            zoomhack -= 1;
        }
    }
    
    DWORD WINAPI HookFunctions(LPVOID)
    {
        while (hmRendDx9Base==NULL)
        {
            hmRendDx9Base = GetModuleHandle(L"RendDx9.dll");
            if (hmRendDx9Base == NULL) Sleep(200);
        }
    
        while(dwInitDllBase == NULL)
        {
            dwInitDllBase = (DWORD)GetProcAddress(hmRendDx9Base, "initDll");
            if (dwInitDllBase == NULL) Sleep(200);
        }
        CloseHandle(hmRendDx9Base);
    
        DWORD dwPointerOffset = FindPattern(dwInitDllBase, dwInitDllBase + 512, (BYTE*)PATT_CLASSMANAGER, MASK_CLASSMANAGER);
    
        DWORD* dwPointerOffset2 = (DWORD*)(dwPointerOffset + 2);
    
        pClassManager = *((CClassManager**)((DWORD)*dwPointerOffset2));
    
        while(pRenderer == NULL)
            pRenderer = (CRenderer *)pClassManager->GetClassPointerByName(&string("Renderer"));
    
        while(!pPlayerManager)
            pPlayerManager = (CPlayerManager*)pClassManager->GetClassPointerByName( &string("PlayerManager") );
        //MessageBoxW(0,L"Woot!",L"Victory",0);
        while(!pInputManager)
            pInputManager = (CInputManager*)pClassManager->GetClassPointerByName( &string("InputManager") );
        while(!pObjectManager)
            pObjectManager = (CObjectManager*)pClassManager->GetClassPointerByName( &string("ObjectManager") );
        while(!pDebugTextWriter)
            pDebugTextWriter    = (CDebugTextWriter*)    pClassManager->GetClassPointerByName( &string("DebugTextWriter") );
        while(!FindMyWorldToScreen())
            Sleep(100);
        //MessageBoxW(0,L"Woot2!",L"Victory",0);
        //oActionBuffer = (DWORD)HookVTableFunction((DWORD**)pInputManager,(PBYTE)&hkActionBuffer,13);
        MessageBoxW(0,L"Woot!",L"Victory",0);
        //MessageBoxW(0,L"Woot23!",L"Victory",0);
        while(1)
        {
            HackRoutine();
            Sleep(2);
        }
    
        return 0;
    }
    
    
    typedef HRESULT (WINAPI* tEndScene)(LPDIRECT3DDEVICE9 pDevice);
    tEndScene oEndScene;
    
    void Initialize(LPDIRECT3DDEVICE9 pDevice)
    {
        D3DXCreateFont( pDevice, 10, 0, FW_THIN, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, ANTIALIASED_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Lucida Console", &pFont);
        Initialized = true;
    }
    int GetTextLength ( char *szString, ... )
    {
        char szText[512];
        memset(szText,0,512);
        strcpy(szText,szString);
        unsigned int i = 0, iStrLen = 0;
        while (i < strlen(szText))
        {
            switch(szText[i])
            {
            case ' ':
                iStrLen += 4;
                break;
            case 'e':
                iStrLen += 6;
                break;
            case 'i':
                iStrLen += 2;
                break;
            case 'j':
                iStrLen += 3;
                break;
            case 'k':
                iStrLen += 6;
                break;
            case 'l':
                iStrLen += 2;
                break;
            case 'm':
                iStrLen += 10;
                break;
            case 'r':
                iStrLen += 4;
            case 'v':
                iStrLen += 7;
                break;
            case 'w':
                iStrLen += 9;
                break;
            case 'y':
                iStrLen += 7;
                break;
            case 'A':
                iStrLen += 7;
                break;
            case 'C':
                iStrLen += 7;
                break;
            case 'H':
                iStrLen += 7;
                break;
            case 'I':
                iStrLen += 2;
                break;
            case 'K':
                iStrLen += 7;
                break;
            case 'M':
                iStrLen += 9;
                break;
            case 'O':
                iStrLen += 7;
                break;
            case 'P':
                iStrLen += 7;
                break;
            case 'Q':
                iStrLen += 7;
                break;
            case 'R':
                iStrLen += 6;
                break;
            case 'V':
                iStrLen += 7;
                break;
            case 'W':
                iStrLen += 11;
                break;
            case 'X':
                iStrLen += 8;
                break;
            case 'Y':
                iStrLen += 7;
                break;
            default:
                iStrLen += 5;
                break;
            }
            i++;
        }
        return iStrLen;
    }
    void wtoc(CHAR* Dest, const WCHAR* Source)
    {
        int i = 0;
    
        while(Source[i] != '\0')
        {
            Dest[i] = (CHAR)Source[i];
            ++i;
        }
    }
    
    //=====================================================================================
    /*
    || ::DESCRIPTION::
    || This function will convert a CHAR string to a WCHAR string.
    ||
    || Param 1 :: Pointer to a buffer that will contain the converted string. Ensure this
    || buffer is large enough; if not, buffer overrun errors will occur.
    || Param 2 :: Constant pointer to a source CHAR string to be converted to WCHAR
    */
    void ctow(WCHAR* Dest, const CHAR* Source)
    {
        int i = 0;
    
        while(Source[i] != '\0')
        {
            Dest[i] = (WCHAR)Source[i];
            ++i;
        }
    }
    void fillrgba( int x, int y, int w, int h, int r, int g,int b,int a)
    {
    
        D3DRECT rec = { x, y, x + w, y + h };
        pDevice->Clear( 1, &rec, D3DCLEAR_TARGET, D3DCOLOR_ARGB(a,r,g,b), 0, 0 );
    }
    void Drawopx(int x, int y, int width, int height, int r, int g, int b, int a, int line)
    {
        fillrgba(x,y+height,width,line,r,g,b,a);
        fillrgba(x,y,line,height,r,g,b,a);
        fillrgba(x,y,width,line,r,g,b,a);
        fillrgba(x+width,y,line,height,r,g,b,a);
    }
    __inline float GetDistance( const D3DXVECTOR3& From,  const D3DXVECTOR3& To )
    {
        float Angle[3] = {0,0,0};
        Angle[0] = To.x-From.x;
        Angle[1] = To.y-From.y;
        Angle[2] = To.z-From.z;
        return sqrtf( Angle[0] * Angle[0] + Angle[1] * Angle[1] + Angle[2] * Angle[2] );
    }
    CPlayer* GetClosestByCrosshair()
    {
        FLOAT ScreenX = (FLOAT)Viewport.Width  / 2.0f;
        FLOAT ScreenY = (FLOAT)Viewport.Height / 2.0f; 
        FLOAT Nearest = (FLOAT)INT_MAX;
        FLOAT PosX = 0.0f, PosY = 0.0f;
    
        CPlayer* saved_target = NULL;
        bool AimingAtEnemy = false;
    
        CPlayer* pRet = NULL;
    
        if(!pLocalPlayer)
            return 0;
    
        CObject* pLocalInfo = pLocalPlayer->Soldier ? pLocalPlayer->Soldier->soldier_ptr : NULL;
    
        if(!pLocalInfo)
            return 0;
    
        for(int i = 0; i < 255; i++)
        {
            CPlayer* pPlayer = pPlayerManager->GetPlayerByIndex(i); 
    
            if (!IsPlayerValid(pPlayer))
                continue;
    
            if (pPlayer == pLocalPlayer)
                continue;
    
    
            CObject* pInfo = pPlayer->SoldierObj ? pPlayer->Soldier->soldier_ptr : NULL;
    
            CArmor* pHealth = pInfo->Health;
    
    
            if(pHealth->fHealth <= 0.0f || !pPlayer->Alive)
                continue;
    
            D3DXVECTOR3 vOut;
            GET_ORIGIN_FROMMATRIX( &vOut, &pInfo->Matrix );
            if( bWorldToScreen(&vOut) )
                continue;
    
            PosX = vOut.x > ScreenX ? vOut.x - ScreenX : ScreenX - vOut.x;
            PosY = vOut.y > ScreenY ? vOut.y - ScreenY : ScreenY - vOut.y; 
    
            FLOAT Temp = sqrt( PosX*PosX + PosY*PosY );
    
            if(Temp > Nearest)
                continue;
    
            pRet = pPlayer;
            Nearest = Temp;
        }
    
        return pRet;
    }
    float oldzoom;
    inline void ZoomHack(float value)
    {
        pPlayerManager->LocalPlayer->zoom2 = value;
    }
    HRESULT WINAPI hkEndScene(LPDIRECT3DDEVICE9 pDevice)
    {
        pDevice->GetViewport(&Viewport);
        if(!Initialized)Initialize(pDevice);
        pDevice->SetRenderState(D3DRS_FOGENABLE,FALSE);
    
        /*static bool done = false;
        if (!done)
        {    
        MessageBox(0,L"One Time On Endscene",0,0);
        done = true;
        }//*/
        //if (IsBadReadPtr(pPlayerManager->LocalPlayer,4)) return oEndScene(pDevice);
        if (IsPlayerValid(pPlayerManager->LocalPlayer))
        {
            //char pLocalInfo[33];
            //char Buf1[33];
            //itoa(pPlayerManager->LocalPlayer->Soldier->soldier_ptr->Health->fHealth,Buf1,10);
            //sprintf(pLocalInfo,"%s [Health: %s]",pPlayerManager->LocalPlayer->Name,Buf1);
            //pDebugTextWriter->OutlinedText(10,10,dWhite,&string(pLocalInfo));
    
            for ( int i = 0; i < 255; i++ )
            {
                //if (IsBadReadPtr(pPlayerManager->GetPlayerByIndex( i ),4)) continue;
                //if (!IsPlayerValid(pPlayerManager->GetPlayerByIndex( i ))) continue;
                if (IsPlayerValid(pPlayerManager->GetPlayerByIndex( i )))
                {
    
                    if( pPlayerManager->GetPlayerByIndex( i ) == pPlayerManager->LocalPlayer )
                        continue;
                        static float oldzoom = pPlayerManager->LocalPlayer->zoom2;
    #ifdef __ZOOMHACK__
                        ZoomHack((float)zoomhack);
                    char zh[16];
                    sprintf(zh,"Zoomhack is %d",zoomhack);
                    pDebugTextWriter->OutlinedText(10,10,dWhite,&string(zh));
    #endif
                    D3DXVECTOR3 lpOrigin, tpOrigin;
    
                    GET_ORIGIN_FROMMATRIX(&lpOrigin, &pPlayerManager->LocalPlayer->Soldier->soldier_ptr->Matrix);
                    GET_ORIGIN_FROMMATRIX(&tpOrigin, &pPlayerManager->GetPlayerByIndex( i )->Soldier->soldier_ptr->Matrix);
    
                    if(!tpOrigin || !lpOrigin || !pPlayerManager->GetPlayerByIndex( i )->Name || !pPlayerManager->GetPlayerByIndex( i )->Soldier->soldier_ptr->Health)
                        continue;
    
                    float flDistance = GetDistance(tpOrigin, lpOrigin);
    
                    char PlayerInfo[512];
                    char Buf[33];
                    itoa(pPlayerManager->GetPlayerByIndex( i )->Soldier->soldier_ptr->Health->fHealth,Buf,10);
                    sprintf( PlayerInfo, "[%.0f m] %s [Health: %s]", flDistance, pPlayerManager->GetPlayerByIndex( i )->Name,Buf);
                    if(pPlayerManager->GetPlayerByIndex( i )->Soldier->soldier_ptr->Health->fHealth <= 0.0f)
                        continue;
    
                    if( tpOrigin )
                    {
                        if(bWorldToScreen(&tpOrigin))
                        {
                            if(pPlayerManager->GetPlayerByIndex( i )->Team != pPlayerManager->LocalPlayer->Team)
                            {
                                pDebugTextWriter->OutlinedText( tpOrigin.x - ( GetTextLength(PlayerInfo) ) / 2, tpOrigin.y - 20, dRed, &string(PlayerInfo));
                                RECT rect;
                                rect.left = tpOrigin.x - ( GetTextLength(PlayerInfo) ) / 2;
                                rect.top = tpOrigin.y - 20;
    
                                Drawopx( tpOrigin.x - 250/flDistance, tpOrigin.y - (450/flDistance), 450/flDistance, 1050/flDistance,255 , 000,000, 255, 1);
    
                            }
                            /*if (GetAsyncKeyState(VK_RBUTTON)&1)
                            {
                                POINT vecc;
                                GetCursorPos(&vecc);
                                FLOAT PosX = 0.0f, PosY = 0.0f;
                                FLOAT GPosX = 0.0f, GPosY = 0.0f;
                                int modex = 0;
                                int modey = 0;
                                D3DXVECTOR3 tpOrigi;
                                for (int g = 0; g < 255; g++)
                                {
                                    if (IsPlayerValid(pPlayerManager->GetPlayerByIndex(g)))
                                    {
                                        if (pPlayerManager->GetPlayerByIndex(g) != pPlayerManager->LocalPlayer)
                                        {
                                            if(( pPlayerManager->GetPlayerByIndex( i )->Name || pPlayerManager->GetPlayerByIndex( i )->Soldier->soldier_ptr->Health  ) &&   (pPlayerManager->GetPlayerByIndex( i )->Soldier->soldier_ptr->Health->fHealth > 0.0f))
                                            {
                                                GET_ORIGIN_FROMMATRIX(&tpOrigi,&pPlayerManager->GetPlayerByIndex(g)->Soldier->soldier_ptr->Matrix);
                                                FLOAT ScreenX = (FLOAT)Viewport.Width  / 2.0f;
                                                FLOAT ScreenY = (FLOAT)Viewport.Height / 2.0f;
    
                                                FLOAT Nearest = (FLOAT)INT_MAX;
                                                if (tpOrigi)
                                                {
                                                    if ( bWorldToScreen(&tpOrigi))
                                                    {
                                                        PosX = tpOrigi.x > ScreenX ? tpOrigi.x - ScreenX : ScreenX - tpOrigi.x;
                                                        PosY = tpOrigi.y > ScreenY ? tpOrigi.y - ScreenY : ScreenY - tpOrigi.y;
                                                        modex = tpOrigi.x > ScreenX ? 2 : 1;
                                                        modey = tpOrigi.y > ScreenY ? 2 : 1;
                                                        FLOAT Temp = sqrt( PosX*PosX + PosY*PosY );
                                                        if (Temp <= Nearest)
                                                        {
                                                            Nearest = Temp;
                                                            GPosX = PosX;
                                                            GPosY = PosY;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                if (PosX && PosY)
                                {
                                    if (GPosX != 0 && GPosY != 0)
                                    {
                                        if (modex == 1)
                                        {
                                            GPosX += vecc.x;
                                        }
                                        if (modex == 2)
                                        {
                                            GPosX -= vecc.x;
                                        }
                                        if (modey == 1)
                                        {
                                            GPosY += vecc.y;
                                        }
                                        if (modey == 2)
                                        {
                                            GPosY -= vecc.y;
                                        }
                                        SetMyCursorPos(GPosX,GPosY);
                                    }
                                }
                            }//*/
                            /*if (lon == true)
                            {
                            pDebugTextWriter->OutlinedText(10,10,dWhite,&string("Triggerbot = on"));
                            FLOAT vX, vY;
                            vX = Viewport.Width/2;
                            vY = Viewport.Height/2;
                            FLOAT PosX = tpOrigin.x > vX ? tpOrigin.x - vX : vX - tpOrigin.x;
                            FLOAT PosY = tpOrigin.y > vY ? tpOrigin.y - vY : vY - tpOrigin.y;
                            #ifdef __O__
                            if ((tpOrigin.x - 250/flDistance < PosX || tpOrigin.y + 450/flDistance > PosY) && (tpOrigin.x - (450/flDistance-1050/flDistance) < PosX || tpOrigin.y + (1050/flDistance-250/flDistance) > PosY))
                            #else
                            if ((tpOrigin.x - 250/flDistance < vX || tpOrigin.y + 450/flDistance > vY) && (tpOrigin.x - (450/flDistance-1050/flDistance) < vX || tpOrigin.y + (1050/flDistance-250/flDistance) > vY))
                            #endif
                            {
                            Fire = true;
                            }
                            }
                            else
                            {
                                pDebugTextWriter->OutlinedText(10,10,dWhite,&string("Triggerbot = off"));
                            }//*/
                            if(pPlayerManager->GetPlayerByIndex( i )->Team == pPlayerManager->LocalPlayer->Team)
                            {    
                                pDebugTextWriter->OutlinedText( tpOrigin.x - ( GetTextLength(PlayerInfo) ) / 2, tpOrigin.y - 20, dBlue, &string(PlayerInfo));
                                RECT rect;
                                rect.left = tpOrigin.x - ( GetTextLength(PlayerInfo) ) / 2;
                                rect.top = tpOrigin.y - 20;
    
                                Drawopx( tpOrigin.x - 250/flDistance, tpOrigin.y - (450/flDistance), 450/flDistance, 1050/flDistance, 000, 000, 255,255, 1);
                            }
                        }
                    }
                }
            }
        }
    
        return oEndScene(pDevice);
    }
    
    DWORD WINAPI D3DHook(LPVOID)
    {
        while(hmRendDx9Base == NULL){hmRendDx9Base = GetModuleHandleA("RendDX9.dll");Sleep(250);}
        CloseHandle(hmRendDx9Base);
    
        while(pDevice == NULL)
            pDevice = (LPDIRECT3DDEVICE9)pRenderer->pDirect3Ddev;
    
        DWORD* GameDevice = (DWORD*)pDevice;
        GameDevice = (DWORD*)GameDevice[0];
        //MessageBox(0,L"Hooking Endscene",0,0);
        while (!oEndScene)
            oEndScene    = (tEndScene)    DetourFunction( (PBYTE)GameDevice[42],    (PBYTE)&hkEndScene );
        return 0;
    }
    
    BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ulReason, LPVOID lpReserved )
    {
        switch (ulReason)
        {
        case DLL_PROCESS_ATTACH:
            {
                CreateThread( 0, 0, D3DHook,        0, 0, 0 );
                CreateThread( 0, 0, HookFunctions,    0, 0, 0 );
            }
            break;
        case DLL_THREAD_DETACH:
            break;
        }
        return TRUE;
    }
    /edit: Fixed version here:

    http://www.mpgh.net/forum/360-battle...ml#post3885775
    Last edited by Viibez; 04-20-2011 at 08:37 PM.