'Own~*

Ninja Injector

Compatibilidade:

Windows7 - OK!

WindowsXP - OK!

WindowsVISTA - OK!

ScreenShoot:

Tutorial :

1 - Em "Target Dll" clique em "Add" e selecione a DLL do hack.

2 - Marque a caixa "Close after injection".

3 - Em "Process" digite "Crossfire.exe" (sem as aspas"") ou selecione o Cross Firelogo abaixo em "Game's".

Créditos:

LCSVSL

Parabens , Felicidades ae . :D '

rairiariiar , Lacy Grease Sabe de tudo .

1 - Tiririca no conselho de Educação da câmara.

2 - Um homem posará na capa da playboy.

3 - Sarney e Collor na comissão de reforma política.

4 - Silvio Santos com problema financeiro.

5 - O Faustão ficou magro.

6 - Sandy é garota-propaganda da Devassa.

7 - Justin Bieber arrumou uma namorada.

8 - Angela Bismarchi vai lançar um livro.

9 - Preta Gil diz que veste manequim 42.

10 - Lázaro Ramos Galã de novela.

Se gostou Agradeçe ae .

:D '

Ola Galera , Nesse Topico Irei Ensinar Como Reportar 1 Bug NO CF PH .

Vamos la .

1 - Entre no site Do CF =

2 - Logue-se no Site .

3 - Apos Logar-se Clique em CrossFire FAQ

4 - Apos Clicar em CrossFire FAQ ,Clique em Bug Report .

5 - Depois e So Preenche os Motivos provas e etc .

Creditos :

Own

Ola , sei que o Conteudo e Existente mais So Postei , pra Organizar mais o Topico .

1. O código do One Hit Kill e No Fall Damage

0x07F8 => "AmmoDamage"

Shot Gun Spread

0x0834 => "ShotsPerAmmo"

No Weapon Weight

0x20D0 => "MoveSpeedPenalty"

0x20D4 => "ZoomInMoveSpeedPenalty"

0x20D8 => "MovePenaltyForDelayFire"

2. O código do aimbot D3D

const BYTE bMaroon[60] =

{

0x42, 0x4D, 0x3C, 0x00,0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x36, 0x00,

0x00, 0x00, 0x28, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00, 0x01,0x00,

0x00, 0x00, 0x01, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x12, 0x0B, 0x00, 0x00,

0x12, 0x0B, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x15, 0x00, 0x88, 0x00, 0x00, 0x00

};

 

const BYTE bOrange[60] =

{

0x42, 0x4D, 0x3C, 0x00,0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x36, 0x00,

0x00, 0x00, 0x28, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00, 0x01,0x00,

0x00, 0x00, 0x01, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x12, 0x0B, 0x00, 0x00,

0x12, 0x0B, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x71, 0xFF, 0x00, 0x00, 0x00

};

 

const BYTE bBlue[60] =

{

0x42, 0x4D, 0x3C, 0x00,0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x36, 0x00,

0x00, 0x00, 0x28, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00, 0x01,0x00,

0x00, 0x00, 0x01, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x12, 0x0B, 0x00, 0x00,

0x12, 0x0B, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x80, 0x00, 0x00, 0x00, 0x00, 0x00

};

 

const BYTE bLBlue[60] =

{

0x42, 0x4D, 0x3C, 0x00,0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x36, 0x00,

0x00, 0x00, 0x28, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00, 0x01,0x00,

0x00, 0x00, 0x01, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x12, 0x0B, 0x00, 0x00,

0x12, 0x0B, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0xFF, 0x80, 0x00, 0x00, 0x00, 0x00

};

 

D3DCOLOR

 

FontColor = D3DCOLOR_ARGB(150, 20, 20, 20),

ESPColor = D3DCOLOR_ARGB(150, 20, 255, 20),

XHairColor = D3DCOLOR_ARGB(150, 255, 255, 20),

ConsoleColor = D3DCOLOR_ARGB(150, 255, 255, 255),

ConsoleLineColor = D3DCOLOR_ARGB(150, 20, 20, 20),

ConsoleTitleColor = D3DCOLOR_ARGB(150, 255, 255, 255),

WhiteColor = D3DCOLOR_ARGB(255,255,255,255),

 

*pColor;

 

LPDIRECT3DSURFACE9

 

originalSurface = NULL,

originalDStencilSurface = NULL,

NewLSurface = NULL,

NewSurface = NULL;

 

D3DSURFACE_DESC

 

originalSurfaceDesc,

originalDepthSurfaceDesc;

 

LPDIRECT3DTEXTURE9

 

texMaroon = NULL,

texOrange = NULL,

texBlue = NULL,

texLBlue = NULL;

 

DWORD

 

TempX[220] = {NULL},

TempY[220] = {NULL},

color[220] = {NULL},

 

ColorArray[400000] = {0};

 

BOOL

 

TeamUSA = FALSE,

TeamMEC = FALSE,

NotInc = FALSE,

SRGBE = FALSE,

FGE = FALSE,

 

btKeyProc = FALSE;

 

UINT

 

Scale = 0,

XStride = 0,

Radius = 0;

 

BYTE

 

InitResources = 0x00,

bIngameDetector = 0x00,

btIngame = 0x00,

Aim_US_MEC = 0x01,

 

bKeyBstate[256] = {0x00},

 

btConsole = 0x00,

ConKey = 0x00,

wall = 0x00,

NoFog = 0x00,

AimThru = 0x00,

ColorDetector = 0x00,

AIM = 0x00,

XHair = 0x00,

ESP = 0x00,

bLoad = 0x00,

bInitDX = 0x00;

 

D3DRECT

 

rConsole,

rConsoleLine,

rConsoleTitle;

 

D3DVIEWPORT9

Viewport;

 

ID3DXBuffer

*MyBuffer = NULL;

 

ID3DXFont

* pFont = NULL;

 

ID3DXLine

* pLine = NULL;

 

HHOOK

KeyHook;

 

D3DXVECTOR2

 

LineX[1024],

Line[2],

LineA[2],

LineB[2];

 

RECT

rFont;

 

HANDLE

hProc;

 

D3DLOCKED_RECT

LOCKEDRECT;

 

LPBYTE

pBits = NULL;

 

POINT

AimAt[400000] = {-1};

 

LPDIRECT3DPIXELSHADER9

 

shadecolor[220] = {NULL},

OriginalShaders = NULL;

 

char

 

MyShader [MAX_PATH],

ConBuffer [MAX_PATH],

DLL_PATH [MAX_PATH],

chConsole [MAX_PATH],

chCvars [512];

 

float

 

Step = 0.0f,

circ1 = 0.0f,

circ2 = 0.0f,

circ3 = 0.0f,

circ4 = 0.0f,

 

View = 1.0f;

 

int

 

FOV = 0,

Count = 0,

FirstPos = 0,

LastPos = 0,

NumberOfObjects = 0,

NumberOfShaders = 0,

BITSPERPIXEL = 32;

 

BOOL __stdcall Save( );

BOOL __stdcall Load( );

 

LRESULT CALLBACK KeyProc

(int code,WPARAM wParam,LPARAM lParam);

 

int __stdcall GetDistance

( long x1, long x2, long y1, long y2 );

 

//================================================== ===================================

 

BOOL WINAPI DllMain(HINSTANCE hinstModule, DWORD dwReason, LPVOID lpvReserved)

{

if(dwReason == DLL_PROCESS_ATTACH)

{

DisableThreadLibraryCalls(hinstModule);

 

GetModuleFileNameA(hinstModule, DLL_PATH, MAX_PATH);

DLL_PATH[strlen(DLL_PATH)-3] = 0;

strcat(DLL_PATH, "ini");

 

ConKey = (BYTE)VkKeyScan('`');

 

if(Direct3DCreate9_VMTable() == D3D_OK){

return TRUE;

}

}

 

return FALSE;

}

 

//================================================== ===================================

 

HRESULT WINAPI Reset_Detour(LPDIRECT3DDEVICE9 Device_Interface,

D3DPRESENT_PARAMETERS* PresentationParameters)

{

 

if( texOrange )

if(texOrange->Release() == S_OK)

texOrange = NULL;

 

if( texMaroon )

if(texMaroon->Release() == S_OK)

texMaroon = NULL;

 

if( texBlue )

if(texBlue->Release() == S_OK)

texBlue = NULL;

 

if( texLBlue )

if(texLBlue->Release() == S_OK)

texLBlue = NULL;

 

if( pFont )

if(pFont->Release() == S_OK)

pFont = NULL;

 

if( pLine )

if(pLine->Release() == S_OK)

pLine = NULL;

 

if( NewSurface )

if(NewSurface->Release() == S_OK)

NewSurface = NULL;

 

if( NewLSurface )

if(NewLSurface->Release() == S_OK)

NewLSurface = NULL;

 

if( originalSurface )

if(originalSurface->Release() == S_OK)

originalSurface = NULL;

 

if( originalDStencilSurface )

if(originalDStencilSurface->Release() == S_OK)

originalDStencilSurface = NULL;

 

if( OriginalShaders )

if(OriginalShaders->Release() == S_OK)

OriginalShaders = NULL;

 

for( int x = 0;x < NumberOfObjects;x++ )

if( shadecolor[x] )

if(shadecolor[x]->Release() == S_OK)

shadecolor[x] = NULL;

 

InitResources = 0x00;

 

return Reset_Pointer(Device_Interface, PresentationParameters);

}

 

//================================================== ===================================

 

HRESULT WINAPI BeginScene_Detour(LPDIRECT3DDEVICE9 Device_Interface)

{

Device_Interface->GetViewport( &Viewport );

 

if( !bLoad && btIngame ){

Load();

bLoad = 0x01;

}

 

if( bIngameDetector )

btIngame = 0x01;

else

btIngame = 0x00;

 

if( !InitResources ){

 

/* Create Textures */

D3DXCreateTextureFromFileInMemory(Device_Interface , (LPCVOID)&bOrange, 60, &texOrange);

D3DXCreateTextureFromFileInMemory(Device_Interface , (LPCVOID)&bMaroon, 60, &texMaroon);

D3DXCreateTextureFromFileInMemory(Device_Interface , (LPCVOID)&bBlue, 60, &texBlue);

D3DXCreateTextureFromFileInMemory(Device_Interface , (LPCVOID)&bLBlue, 60, &texLBlue);

 

/* Create font */

D3DXCreateFont(Device_Interface, 14,0, FW_BOLD, 0, FALSE,DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,

DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,TEXT("Cambria"), &pFont );

 

/* Create a line */

D3DXCreateLine( Device_Interface, &pLine );

pLine->SetAntialias( TRUE );

pLine->SetWidth( 2.0f );

 

/* Get Original Rendertarget Data */

Device_Interface->GetRenderTarget( 0,&originalSurface );

originalSurface->GetDesc( &originalSurfaceDesc );

 

if( originalSurface )

if(originalSurface->Release() == S_OK)

originalSurface = NULL;

 

/* Set The Default Radius */

Radius = Viewport.Width/8;

 

/* Screen size difference */

Scale = (UINT)(Viewport.Width/400);

 

/* Create Small RenderTarget */

Device_Interface->CreateRenderTarget( (UINT)(Viewport.Width/Scale),

(UINT)(Viewport.Height/Scale), D3DFMT_A8R8G8B8,

D3DMULTISAMPLE_NONE, 0,TRUE, &NewSurface, NULL);

 

/* Create Large RenderTarget */

Device_Interface->CreateRenderTarget((UINT)Viewport.Width,

(UINT)Viewport.Height, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE,

0, TRUE, &NewLSurface, NULL);

 

/* Create Shaders */

NumberOfShaders = 0;

for(int x = 1;x < 7;x++)

{

for(int y = 1;y < 7;y++)

{

for(int z = 1;z < 7;z++)

{

MyBuffer = NULL;

 

sprintf( MyShader, "ps.1.1\ndef c0, %f, %f, %f, %f\nmov r0,c0",

(float)((float)x*(float)40)/(float)255, (float)((float)y*(float)40)/(float)255,

(float)((float)z*(float)40)/(float)255,(float) (float)255/(float)255 );

 

D3DXAssembleShader( MyShader, sizeof( MyShader ), NULL, NULL, 0, &MyBuffer , NULL );

 

Device_Interface->CreatePixelShader((const DWORD*)MyBuffer ->GetBufferPointer(), &shadecolor[NumberOfShaders]);

 

color[NumberOfShaders] = (DWORD)D3DXCOLOR((float)((float)x*(float)40)/(float)255,

(float)((float)y*(float)40)/(float)255, (float)((float)z*(float)40)/(float)255,

(float) ((float)255/(float)255));

 

NumberOfShaders++;

}

}

}

 

/* Initialize StretchRect */

Device_Interface->StretchRect( NewLSurface, NULL,

NewSurface, NULL, D3DTEXF_NONE );

 

InitResources = 0x01;

}

 

/* Set The FOV */

FOV = GetDistance( Radius + Viewport.Width/2, Viewport.Width/2, 0, 0 );

 

/* Circle drawing */

Step = 3.14159265f * 2.0f / (float)(Radius/2);

 

Count = 0;

 

for (float index=0; index < 3.14159265 *2.0; index += Step)

{

circ1 = (float)Radius * cos(index) + (float)(Viewport.Width/2);

circ2 = (float)Radius * sin(index) + (float)(Viewport.Height/2);

circ3 = (float)Radius * cos(index+Step) + (float)(Viewport.Width/2);

circ4 = (float)Radius * sin(index+Step) + (float)(Viewport.Height/2);

LineX[Count].x = circ1;

LineX[Count].y = circ2;

LineX[Count+1].x = circ3;

LineX[Count+1].y = circ4;

Count += 2;

}

 

/* SetWindowHookEx */

if( !btKeyProc ){

DWORD ThdID = GetCurrentThreadId();

KeyHook = SetWindowsHookExA(WH_KEYBOARD,&KeyProc,0,ThdID);

btKeyProc = 0x01;

}

 

bIngameDetector = 0x00;

NumberOfObjects = 0;

 

return BeginScene_Pointer(Device_Interface);

}

 

//================================================== ===================================

 

BOOL __stdcall DrawConsole( LPDIRECT3DDEVICE9 Device_Interface )

{

if( btConsole && btIngame )

{

rConsole.x1 = (Viewport.Width/2) - (Viewport.Width/4);

rConsole.y1 = (Viewport.Height/2) - (Viewport.Height/8);

rConsole.x2 = (Viewport.Width/2) + (Viewport.Width/4);

rConsole.y2 = (Viewport.Height/2) + (Viewport.Height/4);

 

rFont.left = rConsole.x1 + 10;

rFont.top = rConsole.y2 - 18;

rFont.right = rConsole.x2;

rFont.bottom = rConsole.y2;

 

rConsoleLine.x1 = rConsole.x1;

rConsoleLine.y1 = rFont.top - 6;

rConsoleLine.x2 = rConsole.x2;

rConsoleLine.y2 = rFont.top - 5;

 

rConsoleTitle.x1 = rConsole.x1;

rConsoleTitle.y1 = rConsole.y1 - 18;

rConsoleTitle.x2 = rConsole.x2;

rConsoleTitle.y2 = rConsole.y1;

 

Device_Interface->Clear( 1, &rConsole, D3DCLEAR_TARGET,

ConsoleColor, 0, 0 );

 

Device_Interface->Clear( 1, &rConsoleLine, D3DCLEAR_TARGET,

ConsoleLineColor, 0, 0 );

 

Device_Interface->Clear( 1, &rConsoleTitle, D3DCLEAR_TARGET,

ConsoleTitleColor, 0, 0 );

 

rConsoleLine.x1 = rConsole.x1;

rConsoleLine.y1 = rConsole.y1;

rConsoleLine.x2 = rConsole.x2;

rConsoleLine.y2 = rConsole.y1 + 1;

 

Device_Interface->Clear( 1, &rConsoleLine, D3DCLEAR_TARGET,

ConsoleLineColor, 0, 0 );

 

pFont->DrawTextA(NULL, (LPCSTR)chConsole, -1, &rFont, DT_LEFT, FontColor);

 

rFont.top = rConsoleTitle.y1 + 2;

rFont.bottom = rConsoleTitle.y2;

 

char chTitle[] = "CONSOLE";

 

pFont->DrawTextA(NULL, (LPCSTR)chTitle, -1, &rFont, DT_LEFT, FontColor);

 

char chUCFORUM[] = "UCFORUM D3D PROGRAMMING";

 

rFont.top = rConsole.y2 - 38;

rFont.bottom = rConsole.y2 - 24;

 

pFont->DrawTextA(NULL, (LPCSTR)chUCFORUM, -1, &rFont, DT_LEFT, FontColor);

 

char chAim_US_MEC[4];

 

if( Aim_US_MEC )

sprintf( chAim_US_MEC, "US" );

else

sprintf( chAim_US_MEC, "MEC" );

 

sprintf( chCvars, \

"CVARS 0/1\n\n" \

"WALL %i\n" \

"NOFOG %i\n" \

"FOV %i\n" \

"AIM %i\n" \

"AIMTHRU %i\n" \

"ESP %i\n" \

"AIM @ %s\n" \

"SAVE\n" \

"LOAD\n" \

,wall,NoFog,FOV,AIM,AimThru,ESP,chAim_US_MEC );

 

rFont.top = rConsole.y1 + 14;

rFont.bottom = rConsole.y2;

 

pFont->DrawTextA(NULL, (LPCSTR)chCvars, -1, &rFont, DT_LEFT, FontColor);

 

}

 

return TRUE;

 

}

//================================================== ===================================

 

int __stdcall GetDistance( long x1, long x2, long y1, long y2 )

{

long ResA = (x1 - x2) * (x1 - x2);

 

long ResB = (y1 - y2) * (y1 - y2);

 

double ResC = (double)(ResA + ResB);

 

return (int)sqrt( ResC );

}

 

//================================================== ===================================

 

HRESULT WINAPI EndScene_Detour(LPDIRECT3DDEVICE9 Device_Interface)

{

DrawConsole( Device_Interface );

 

/* // View NewLSuface

RECT rectx;

rectx.left = Viewport.Width - (Viewport.Width/4);

rectx.top = 0;

rectx.right = Viewport.Width;

rectx.bottom = (Viewport.Height/4);

 

Device_Interface->GetRenderTarget( 0,&originalSurface );

 

Device_Interface->StretchRect( NewLSurface, NULL,

originalSurface, &rectx, D3DTEXF_NONE );

 

if( originalSurface ){

originalSurface->Release();

originalSurface = NULL;

}*/

 

int PixelCtr = 0;

POINT ClosestTarget;

ClosestTarget.x = -1;

ClosestTarget.y = -1;

 

/* Lock the small rendertarget to get 2d coords . auto edge included . */

if( NumberOfObjects > 0 && btIngame )

{

Device_Interface->StretchRect( NewLSurface, NULL,

NewSurface, NULL, D3DTEXF_NONE );

}

 

/* Draw Crosshair */

if( !btConsole && XHair && btIngame ){

 

int Len = 15;

 

Line[0].x = (float)((Viewport.Width/2));

Line[0].y = (float)((Viewport.Height/2) - Len);

Line[1].x = (float)((Viewport.Width/2));

Line[1].y = (float)((Viewport.Height/2) + Len);

pLine->Begin();

pLine->Draw(Line,2,XHairColor);

pLine->End();

 

Line[0].x = (float)((Viewport.Width/2) - Len);

Line[0].y = (float)((Viewport.Height/2));

Line[1].x = (float)((Viewport.Width/2) + Len);

Line[1].y = (float)((Viewport.Height/2));

pLine->Begin();

pLine->Draw(Line,2,XHairColor);

pLine->End();

}

 

/* Draw Circle */

if( FOV > 0 && !btConsole && btIngame ){

pLine->Begin();

pLine->Draw(LineX,Count,D3DXCOLOR(1.0, 0.0, 0.0, 1.0));

pLine->End();

}

 

if( NumberOfObjects > 0 && btIngame )

{

if( NewSurface->LockRect( &LOCKEDRECT, NULL,

D3DLOCK_READONLY ) == S_OK )

{

for( long scy = (long)1; scy <= (long)

( Viewport.Height / (int) +Scale ); scy++ )

{

for( long scx = (long)1; scx <= (long)

( Viewport.Width / (int) +Scale); scx++ )

{

AimAt[ PixelCtr ].x = -1;

AimAt[ PixelCtr ].y = -1;

ColorArray[ PixelCtr ] = -1;

pBits = ( LPBYTE ) LOCKEDRECT.pBits;

pBits += ( ( scy * LOCKEDRECT.Pitch )

+ ( scx * ( BITSPERPIXEL / 8 ) ) );

pColor = ( D3DCOLOR* ) pBits;

if( *pColor != NULL )

{

AimAt[ PixelCtr ].x = scx;

AimAt[ PixelCtr ].y = scy;

ColorArray[ PixelCtr ] = *pColor;

if( PixelCtr < 400000 )

PixelCtr++;

}

}

}

NewSurface->UnlockRect( );

}

 

/* loop through the pixel data to get colors */

int ClosestPosition = 0;

 

if( FOV )

ClosestPosition = +FOV;

else

ClosestPosition = (int)+Viewport.Width;

 

for( int i = 0; i < NumberOfObjects; i++ )

{

ColorDetector = 0x00;

TempX = -1;

TempY = -1;

for( int j = 0; j <= PixelCtr; j++ )

{

if( ColorArray[j] == color && !ColorDetector )

{

FirstPos = j;

ColorDetector = 0x01;

}

if( ColorArray[j] == color && ColorDetector )

{

LastPos = j;

}

 

}

if( ColorDetector )

{

TempX = ( DWORD )( AimAt[FirstPos].x + AimAt[LastPos].x ) / 2;

TempY = ( DWORD )( AimAt[FirstPos].y + AimAt[LastPos].y ) / 2;

 

TempX *= Scale;

TempY *= Scale;

 

if( +GetDistance( TempX, Viewport.Width/2, TempY,

Viewport.Height/2 ) < +ClosestPosition ){

ClosestTarget.x = TempX;

ClosestTarget.y = TempY;

}

}

}

}

 

if( btIngame && NumberOfObjects > 0 )

{

/* Draw esp on all objects */

for( int i = 0; i < NumberOfObjects; i++ )

{

if( TempX != -1 && TempY != -1 && !btConsole && ESP )

{

int Len = 4;

 

LineA[0].x = (float)(TempX - Len);

LineA[0].y = (float)(TempY - Len);

LineA[1].x = (float)(TempX + Len);

LineA[1].y = (float)(TempY + Len);

pLine->Begin();

pLine->Draw(LineA,2,ESPColor);

pLine->End();

 

LineB[0].x = (float)(TempX + Len);

LineB[0].y = (float)(TempY - Len);

LineB[1].x = (float)(TempX - Len);

LineB[1].y = (float)(TempY + Len);

pLine->Begin();

pLine->Draw(LineB,2,ESPColor);

pLine->End();

}

}

 

/* Aim at closest position */

if( ClosestTarget.x != -1 && ClosestTarget.y != -1 && !btConsole && AIM )

{

 

POINT Target;

if((DWORD)ClosestTarget.x > (Viewport.Width/2)){

Target.x = ClosestTarget.x - (Viewport.Width/2);

Target.x /= 4;

Target.x = +Target.x;

}

 

if((DWORD)ClosestTarget.x < (Viewport.Width/2)){

Target.x = (Viewport.Width/2) - ClosestTarget.x;

Target.x /= 4;

Target.x = -Target.x;

}

 

if((DWORD)ClosestTarget.x == (Viewport.Width/2)){

Target.x = 0;

}

 

if((DWORD)ClosestTarget.y > (Viewport.Height/2)){

Target.y = ClosestTarget.y - (Viewport.Height/2);

Target.y /= 4;

Target.y = +Target.y;

}

 

if((DWORD)ClosestTarget.y < (Viewport.Height/2)){

Target.y = (Viewport.Height/2) - ClosestTarget.y;

Target.y /= 4;

Target.y = -Target.y;

}

 

if((DWORD)ClosestTarget.y == (Viewport.Height/2)){

Target.y = 0;

}

 

// Use with ingame sensitivity below 1.4 in BF2

if( GetKeyState( VK_XBUTTON1 )<0 )

mouse_event( MOUSEEVENTF_MOVE, Target.x,

Target.y, 0, NULL );

}

 

 

/* Clear RenderTarget */

Device_Interface->GetRenderTarget( 0,&originalSurface );

Device_Interface->GetDepthStencilSurface( &originalDStencilSurface );

Device_Interface->SetRenderTarget( 0,NewLSurface );

Device_Interface->SetDepthStencilSurface( originalDStencilSurface );

Device_Interface->Clear( 0, NULL, D3DCLEAR_TARGET , WhiteColor, 0.0f, 0 );

Device_Interface->SetRenderTarget( 0,originalSurface );

Device_Interface->SetDepthStencilSurface( originalDStencilSurface );

 

if( originalSurface )

if(originalSurface->Release() == S_OK)

originalSurface = NULL;

 

if( originalDStencilSurface )

if(originalDStencilSurface->Release() == S_OK)

originalDStencilSurface = NULL;

 

}

 

return EndScene_Pointer(Device_Interface);

}

 

//================================================== ===================================

 

BOOL __stdcall Aimbot(LPDIRECT3DDEVICE9 Device_Interface, D3DPRIMITIVETYPE Type,

INT Base, UINT Min, UINT Num, UINT start, UINT prim)

{

/* Filter calls to setrenderstate that distort color (incomplete) */

 

Device_Interface->GetRenderState( D3DRS_FOGENABLE, reinterpret_cast<DWORD*>(&FGE) );

Device_Interface->GetRenderState( D3DRS_SRGBWRITEENABLE, reinterpret_cast<DWORD*>(&SRGBE) );

 

/* Switch Rendertarget */

Device_Interface->GetPixelShader( &OriginalShaders );

Device_Interface->GetRenderTarget( 0,&originalSurface );

Device_Interface->GetDepthStencilSurface( &originalDStencilSurface );

Device_Interface->SetRenderTarget( 0,NewLSurface );

Device_Interface->SetDepthStencilSurface( originalDStencilSurface );

 

Device_Interface->SetRenderState( D3DRS_FOGENABLE, FALSE );

Device_Interface->SetRenderState( D3DRS_SRGBWRITEENABLE, FALSE );

 

Device_Interface->SetPixelShader( shadecolor[NumberOfObjects] );

 

if( AimThru ){

Device_Interface->SetRenderState( D3DRS_ZENABLE,D3DZB_FALSE );

DrawIndexedPrimitive_Pointer(Device_Interface, Type, Base, Min, Num, start, prim);

}

 

Device_Interface->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );

DrawIndexedPrimitive_Pointer(Device_Interface, Type, Base, Min, Num, start, prim);

 

Device_Interface->SetRenderTarget( 0,originalSurface );

Device_Interface->SetDepthStencilSurface( originalDStencilSurface );

Device_Interface->SetPixelShader( OriginalShaders );

 

Device_Interface->SetRenderState( D3DRS_FOGENABLE, *reinterpret_cast<DWORD*>(&FGE) );

Device_Interface->SetRenderState( D3DRS_SRGBWRITEENABLE, *reinterpret_cast<DWORD*>(&SRGBE) );

 

if( originalSurface )

if(originalSurface->Release() == S_OK)

originalSurface = NULL;

 

if( originalDStencilSurface )

if(originalDStencilSurface->Release() == S_OK)

originalDStencilSurface = NULL;

 

if( OriginalShaders )

if(OriginalShaders->Release() == S_OK)

OriginalShaders = NULL;

 

if( NumberOfObjects < 216 )

NumberOfObjects++;

 

return TRUE;

}

//================================================== ===================================

 

HRESULT WINAPI DrawIndexedPrimitive_Detour(LPDIRECT3DDEVICE9 Device_Interface, D3DPRIMITIVETYPE Type,

INT Base, UINT Min, UINT Num, UINT start, UINT prim)

{

LPDIRECT3DVERTEXBUFFER9 Stream_Data;

UINT Offset = 0;

UINT XStride = 0;

 

if(Device_Interface->GetStreamSource(0, &Stream_Data, &Offset, &XStride) == D3D_OK)

Stream_Data->Release();

 

/* Disable ingame fog */

if( NoFog && btIngame ) Device_Interface->SetRenderState( D3DRS_FOGENABLE, FALSE );

 

/* Detect when ingame */

if( XStride == 52 ) bIngameDetector = 0x01;

 

/* Monkey BF2 Model Rec */

if( XStride == 52 && btIngame )

{

if( Num == 68|| Num == 70|| Num == 75|| Num == 341|| Num == 361|| Num == 398|| Num == 456|| Num == 480

|| Num == 495|| Num == 549|| Num == 662|| Num == 782|| Num == 1073|| Num == 1270|| Num == 1322|| Num == 1518

|| Num == 2148|| Num == 2240|| Num == 2303|| Num == 2414|| Num == 2675 || Num == 724|| Num == 787|| Num == 842

|| Num == 1158|| Num == 1176|| Num == 1282)

{NotInc = TRUE;}else{NotInc = FALSE;}

 

if(XStride == 52 && NotInc == FALSE && (Num != 154) && (Num != 1082) && (Num != 1301)

&& (Num != 1046) && (Num != 1321) && (Num != 2523) && (Num != 120) && (Num != 1279)

&& (Num != 1407) && (Num != 248) && (Num != 90) && (Num != 251)

&&(!(XStride==52 && (Num == 1643 && prim == 861) || (Num == 3313 && prim == 2065) || (Num == 306 && prim == 128)

|| (Num == 403 && prim == 153) || (Num == 2910 && prim == 1696) || (Num == 1095 && prim == 631)

|| (Num == 6613 && prim == 4987) || (Num == 953 && prim == 912) || (Num == 2624 && prim == 1682)

|| (Num == 1402 && prim == 721) || (Num == 422 && prim == 160) || (Num == 3480 && prim == 1810)

|| (Num == 1880 && prim == 824) || (Num == 563 && prim == 213) || (Num == 6745 && prim == 4595)

|| (Num == 6602 && prim == 5004)))&&(!(XStride==52 && (Num == 10 && prim == 8)))

&&(!(XStride == 52 && (Num == 1322 || Num == 1112 || Num == 1045 || Num == 1578 || (Num == 1073 && prim == 1384)

|| (Num == 1409 && prim == 1581) || (Num == 341 && prim == 200) || (Num == 1321 && prim == 1439)

|| (Num == 1407 && prim == 1568))))&&(!(XStride==52 && Num == 68))

&&(!(XStride==52 && (Num == 1073 && prim == 1384) || Num == 1112 || Num == 1045 || Num == 1578))

&&(!(XStride==52 && Num == 2302))&&(!(XStride==52 &&(Num==251 && prim==248)||(Num==248 && prim==248)))

&&(!(XStride == 52 && (Num == 1322 || Num == 1112 || Num == 1045 || Num == 1578 || (Num == 1073 && prim == 1384)

|| (Num == 1409 && prim == 1581) || (Num == 341 && prim == 200) || (Num == 1321 && prim == 1439) || (Num == 1407 && prim == 1568)))))

{TeamMEC = TRUE;}else{TeamMEC = FALSE;}

 

if(XStride == 52 && TeamMEC == FALSE && (Num == 68|| Num == 70|| Num == 75|| Num == 341|| Num == 361|| Num == 398|| Num == 456|| Num == 480

|| Num == 495|| Num == 549|| Num == 662|| Num == 782|| Num == 1073|| Num == 1270|| Num == 1322|| Num == 1518

|| Num == 2148|| Num == 2240|| Num == 2303|| Num == 2414|| Num == 2675 || Num == 724|| Num == 787|| Num == 842

|| Num == 1158|| Num == 1176|| Num == 1282) &&

(!(XStride==52 && (Num == 1643 && prim == 861) || (Num == 3313 && prim == 2065) || (Num == 306 && prim == 128)

|| (Num == 403 && prim == 153) || (Num == 2910 && prim == 1696) || (Num == 1095 && prim == 631)

|| (Num == 6613 && prim == 4987) || (Num == 953 && prim == 912) || (Num == 2624 && prim == 1682)

|| (Num == 1402 && prim == 721) || (Num == 422 && prim == 160) || (Num == 3480 && prim == 1810)

|| (Num == 1880 && prim == 824) || (Num == 563 && prim == 213) || (Num == 6745 && prim == 4595)

|| (Num == 6602 && prim == 5004)))&&(!(XStride==52 && (Num == 10 && prim == 8)))

&&(!(XStride == 52 && (Num == 1322 || Num == 1112 || Num == 1045 || Num == 1578 || (Num == 1073 && prim == 1384)

|| (Num == 1409 && prim == 1581) || (Num == 341 && prim == 200) || (Num == 1321 && prim == 1439)

|| (Num == 1407 && prim == 1568))))&&(!(XStride==52 && Num == 68))

&&(!(XStride==52 && (Num == 1073 && prim == 1384) || Num == 1112 || Num == 1045 || Num == 1578))

&&(!(XStride==52 && Num == 2302))&&(!(XStride==52 &&(Num==251 && prim==248)||(Num==248 && prim==248)))

&&(!(XStride == 52 && (Num == 1322 || Num == 1112 || Num == 1045 || Num == 1578 || (Num == 1073 && prim == 1384)

|| (Num == 1409 && prim == 1581) || (Num == 341 && prim == 200) || (Num == 1321 && prim == 1439) || (Num == 1407 && prim == 1568)))))

{TeamUSA = TRUE;}else{TeamUSA = FALSE;}

 

/* Draw wallhack and texture chams */

if( ( TeamUSA || TeamMEC ) && wall )

{

if( TeamUSA ){

Device_Interface->SetTexture( 0, texBlue );

Device_Interface->SetTexture( 2, texBlue );

}

 

if( !TeamUSA ){

Device_Interface->SetTexture( 0, texMaroon );

Device_Interface->SetTexture( 2, texMaroon );

}

 

Device_Interface->SetRenderState( D3DRS_ZENABLE, D3DZB_FALSE );

DrawIndexedPrimitive_Pointer(Device_Interface, Type, Base, Min, Num, start, prim);

Device_Interface->SetRenderState( D3DRS_ZENABLE, D3DZB_TRUE );

 

if( TeamUSA ){

Device_Interface->SetTexture( 0, texLBlue );

Device_Interface->SetTexture( 2, texLBlue );

}

 

if( !TeamUSA ){

Device_Interface->SetTexture( 0, texOrange );

Device_Interface->SetTexture( 2, texOrange );

}

}

 

DrawIndexedPrimitive_Pointer(Device_Interface, Type, Base, Min, Num, start, prim);

 

/* Call the aimbot function */

if( btIngame )

if(( Aim_US_MEC && TeamUSA ) || ( !Aim_US_MEC && TeamMEC ))

Aimbot( Device_Interface, Type, Base, Min, Num, start, prim );

 

return S_OK;

}

 

return DrawIndexedPrimitive_Pointer(Device_Interface, Type, Base, Min, Num, start, prim);

}

 

//================================================== ===================================

 

DWORD WINAPI VirtualMethodTableRepatchingLoopToCounterExtension Repatching(LPVOID Param)

{

UNREFERENCED_PARAMETER(Param);

 

while(1)

{

Sleep(100);

 

*(PDWORD)&Direct3D_VMTable[16] = (DWORD)Reset_Detour;

*(PDWORD)&Direct3D_VMTable[41] = (DWORD)BeginScene_Detour;

*(PDWORD)&Direct3D_VMTable[42] = (DWORD)EndScene_Detour;

*(PDWORD)&Direct3D_VMTable[82] = (DWORD)DrawIndexedPrimitive_Detour;

}

 

return 1;

}

 

//================================================== ===================================

 

LRESULT CALLBACK KeyProc(int code,WPARAM wParam,LPARAM lParam)

{

if( code < 0 )

goto EXIT;

 

if ( (lParam & 0x40000000) && btIngame )

{

switch (wParam)

{

// Reset the console

case VK_DELETE:

btConsole = 0x00;

break;

case VK_INSERT:

case VK_NUMPAD0:

case VK_NUMPAD1:

case VK_NUMPAD2:

default:

break;

}

// Same as Game console key ( ` / ~ ) to prevent input and sync them .

if( wParam == ConKey ){

btConsole = !btConsole;

for( UINT i = 0;i < MAX_PATH;i++)

chConsole = NULL;

return E_FAIL;

}

if( btConsole )

{

if ((wParam==VK_SPACE)||(wParam==VK_RETURN)||(wParam= =VK_BACK)||(wParam>=0x2f ) &&(wParam<=0x100))

{

if (wParam==VK_RETURN)

{

if( !strcmp( "WALL 1", chConsole ) ) wall = 0x01;

if( !strcmp( "NOFOG 1", chConsole ) ) NoFog = 0x01;

 

if( StrStrA( chConsole, "FOV" ) ) {

char chfov[5] =

{ chConsole[4],chConsole[5],chConsole[6],chConsole[7],0x00 };

int fov = atoi( chfov );

if( fov >= 0 && fov < (int)(+Viewport.Height/2) ) Radius = (UINT)fov;

}

if( !strcmp( "AIM 1", chConsole ) ) AIM = 0x01;

if( !strcmp( "AIMTHRU 1", chConsole ) ) AimThru = 0x01;

if( !strcmp( "XHAIR 1", chConsole ) ) XHair = 0x01;

if( !strcmp( "ESP 1", chConsole ) ) ESP = 0x01;

if( !strcmp( "AIM @ US", chConsole ) ) Aim_US_MEC = 0x01;

 

if( !strcmp( "SAVE", chConsole ) ) Save( );

if( !strcmp( "LOAD", chConsole ) ) Load( );

 

if( !strcmp( "WALL 0", chConsole ) ) wall = 0x00;

if( !strcmp( "NOFOG 0", chConsole ) ) NoFog = 0x00;

if( !strcmp( "AIM 0", chConsole ) ) AIM = 0x00;

if( !strcmp( "AIMTHRU 0", chConsole ) ) AimThru = 0x00;

if( !strcmp( "XHAIR 0", chConsole ) ) XHair = 0x00;

if( !strcmp( "ESP 0", chConsole ) ) ESP = 0x00;

if( !strcmp( "AIM @ MEC", chConsole ) ) Aim_US_MEC = 0x00;

 

for( UINT i = 0;i < MAX_PATH;i++)

chConsole = NULL;

 

}

else

{

GetKeyboardState( bKeyBstate );

WORD wCharacter;

ToAscii( wParam, NULL, bKeyBstate, &wCharacter, NULL );

 

UINT Len;

 

for(Len = 0;Len < MAX_PATH;Len++){

if( chConsole[Len] == NULL )

break;

}

 

if( Len < MAX_PATH ){

chConsole[Len] = (char)wCharacter;

chConsole[Len+1] = 0x00;

}

 

}

if (wParam==VK_BACK)

{

UINT Len;

 

for(Len = 0;Len < MAX_PATH;Len++){

if( chConsole[Len] == NULL )

break;

}

 

if( Len < MAX_PATH && Len > 0 ){

chConsole[Len] = 0x00;

chConsole[Len-1] = 0x00;

chConsole[Len-2] = 0x00;

}

}

}

}

}

 

EXIT:

 

return CallNextHookEx(KeyHook,code,wParam,lParam);

}

 

//================================================== ===================================

 

BOOL __stdcall Save( )

{

HANDLE hFile = CreateFileA( DLL_PATH, GENERIC_READ|GENERIC_WRITE,

FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,

FILE_ATTRIBUTE_NORMAL, NULL );

 

char chCvars[] = "CVARS";

char Buff[2] = {0x00};

char Buffer[5] = {0x00};

 

_itoa( Radius,Buffer, 10 );

 

if( wall ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"WALL", (LPCSTR)&Buff, DLL_PATH );

 

if( NoFog ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"NOFOG", (LPCSTR)&Buff, DLL_PATH );

 

if( AIM ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"AIM", (LPCSTR)&Buff, DLL_PATH );

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"FOV", (LPCSTR)&Buffer, DLL_PATH );

 

if( AimThru ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"AIMTHRU", (LPCSTR)&Buff, DLL_PATH );

 

if( XHair ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"XHAIR", (LPCSTR)&Buff, DLL_PATH );

 

if( ESP ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"ESP", (LPCSTR)&Buff, DLL_PATH );

 

if( Aim_US_MEC ) Buff[0] = '1';

else Buff[0] = '0';

 

WritePrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"AIM @", (LPCSTR)&Buff, DLL_PATH );

 

return TRUE;

}

 

//================================================== ===================================

 

BOOL __stdcall Load( )

{

char chCvars[] = "CVARS";

char Buff[2] = {0x00};

char Buffer[5] = {0x00};

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"WALL", "0", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

wall = atoi(Buff);

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"NOFOG", "0", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

NoFog = atoi(Buff);

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"AIM", "0", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

AIM = atoi(Buff);

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"FOV", "144", (LPSTR)&Buffer, 5, DLL_PATH ) < 5){

int fov = atoi(Buffer);

if( fov >= 0 && fov < 10000 ) Radius = fov;

}

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"AIMTHRU", "0", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

AimThru = atoi(Buff);

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"XHAIR", "0", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

XHair = atoi(Buff);

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"ESP", "0", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

ESP = atoi(Buff);

 

if( GetPrivateProfileStringA( (LPCSTR)chCvars,

(LPCSTR)"AIMTEAM", "1", (LPSTR)&Buff, 2, DLL_PATH ) == 1)

Aim_US_MEC = atoi(Buff);