D3DAIMBOT 2013

Okay works I tried it on-line but it needs better model rec and
find out why there are some flying boxes...but has a vast improvement
from before. Always aim through in this version...
Can now track more objects this one has 500+.

Code

#ifndef MAIN_H
#define MAIN_H
//================================================== ============================

#define _CRT_SECURE_NO_WARNINGS
#define MAX_SHADERS 510

/************************************************** ****************************/

#define Opfor ((OpforAssualt || OpforGunnermen || OpforSniper || Opfortje))
#define OpforAssualt (Stride == 32 && (NumVertices == 3124 && PCount == 4132) \
|| (NumVertices == 1970 && PCount == 2186) || (NumVertices == 1252 && PCount == 1160) \
|| (NumVertices == 470 && PCount == 352))

#define OpforGunnermen (Stride == 32 && (NumVertices == 2715 && PCount == 3588) \
|| (NumVertices == 1620 && PCount == 1886) || (NumVertices == 943 && PCount == 908) \
|| (NumVertices == 441 && PCount == 308))

#define OpforSniper (Stride == 32 && (NumVertices == 250 && PCount == 304) \
|| (NumVertices == 2818 && PCount == 3672) || (NumVertices == 150 && PCount == 142) \
|| (NumVertices == 1715 && PCount == 1950) || (NumVertices == 1101 && PCount == 1066) \
|| (NumVertices == 481 && PCount == 350)) || (Stride == 32 && (NumVertices == 2816 && PCount == 3642) \
|| (NumVertices == 1773 && PCount == 2022) || (NumVertices == 1150 && PCount == 1086) \
|| (NumVertices == 435 && PCount == 320))

#define Opfortje (Stride == 32 && (NumVertices == 3531 && PCount == 4526) \
|| (NumVertices == 2188 && PCount == 2386) || (NumVertices == 1325 && PCount == 1194) \
|| (NumVertices == 499 && PCount == 352))

#define Marines ((MarinesAssault || MarinesGunnremen || MarinesSniper || Marines1 || Marines2))
#define MarinesAssault (Stride == 32 && (NumVertices == 2613 && PCount == 3248) \
|| (NumVertices == 1842 && PCount == 1978) || (NumVertices == 1144 && PCount == 814) \
|| (NumVertices == 1034 && PCount == 904) || (NumVertices == 447 && PCount == 312))

#define MarinesGunnremen (Stride == 32 && (NumVertices == 3597 && PCount == 4280) \
|| (NumVertices == 2301 && PCount == 2364) || (NumVertices == 1341 && PCount == 1132) \
|| (NumVertices == 580 && PCount == 380))

#define MarinesSniper (Stride == 32 && (NumVertices == 2516 && PCount == 2940) \
|| (NumVertices == 681 && PCount == 588) || (NumVertices == 106 && PCount == 114) \
|| (NumVertices == 1726 && PCount == 1760) || (NumVertices == 1020 && PCount == 872) \
|| (NumVertices == 587 && PCount == 370))

#define Marines1 (Stride == 32 && (NumVertices == 689 && PCount == 1172) \
|| (NumVertices == 367 && PCount == 298) || (NumVertices == 4050 && PCount == 4486) \
|| (NumVertices == 308 && PCount == 212) || (NumVertices == 2540 && PCount == 2444) \
|| (NumVertices == 628 && PCount == 670) || (NumVertices == 1488 && PCount == 1114) \
|| (NumVertices == 105 && PCount == 74) || (NumVertices == 592 && PCount == 374))

#define Marines2 (Stride == 32 && (NumVertices == 3790 && PCount == 4078) \
|| (NumVertices == 2784 && PCount == 2384) || (NumVertices == 1572 && PCount == 1166) \
|| (NumVertices == 634 && PCount == 372) || (NumVertices == 233 && PCount == 330))

#define Spetz ((SpetzAssualt || SpetzGunnermen || SpetzSniper || Spetz1 || Spetz2))

#define SpetzAssualt (Stride == 32 && (NumVertices == 4358 && PCount == 4864) \
|| (NumVertices == 3278 && PCount == 3188) || (NumVertices == 503 && PCount == 704) \
|| (NumVertices == 1633 && PCount == 1332) || (NumVertices == 840 && PCount == 618) \
|| (NumVertices == 783 && PCount == 1168))

#define SpetzGunnermen (Stride == 32 && (NumVertices == 4270 && PCount == 4804) \
|| (NumVertices == 2755 && PCount == 2494) || (NumVertices == 1317 && PCount == 1054) \
|| (NumVertices == 809 && PCount == 590))

#define SpetzSniper (Stride == 32 && (NumVertices == 726 && PCount == 556) \
|| (NumVertices == 1315 && PCount == 1170) || (NumVertices == 2140 && PCount == 2310) \
|| (NumVertices == 3326 && PCount == 4336) || (NumVertices == 2578 && PCount == 2192) \
|| (NumVertices == 482 && PCount == 476) || (NumVertices == 3254 && PCount == 4122) \
|| (NumVertices == 1730 && PCount == 1938) || (NumVertices == 398 && PCount == 410) \
|| (NumVertices == 327 && PCount == 500) || (NumVertices == 2388 && PCount == 2040) \
|| (NumVertices == 222 && PCount == 298) || (NumVertices == 1111 && PCount == 986) \
|| (NumVertices == 1186 && PCount == 1184) || (NumVertices == 339 && PCount == 248) \
|| (NumVertices == 994 && PCount == 714))

#define Spetz1 (Stride == 32 && (NumVertices == 4242 && PCount == 5028) \
|| (NumVertices == 2391 && PCount == 2488) || (NumVertices == 1689 && PCount == 1422) \
|| (NumVertices == 384 && PCount == 250) || (NumVertices == 969 && PCount == 708))

#define Spetz2 (Stride == 32 && (NumVertices == 793 && PCount == 834) \
|| (NumVertices == 3891 && PCount == 4598) || (NumVertices == 592 && PCount == 532) \
|| (NumVertices == 2510 && PCount == 2470) || (NumVertices == 171 && PCount == 114) \
|| (NumVertices == 1398 && PCount == 1176) || (NumVertices == 384 && PCount == 250) \
|| (NumVertices == 384 && PCount == 250) || (NumVertices == 994 && PCount == 714) \
|| (NumVertices == 529 && PCount == 540) || (NumVertices == 353 && PCount == 346))

#define SAS ((SASAssualt || SASGunnermen || SASSniper || SAS1 || SAS2))

#define SASAssualt (Stride == 32 && (NumVertices == 447 && PCount == 312) \
|| (NumVertices == 1034 && PCount == 904) || (NumVertices == 1842 && PCount == 1978) \
|| (NumVertices == 2613 && PCount == 3248) || (NumVertices == 1001 && PCount == 964) \
|| (NumVertices == 3935 && PCount == 5226) || (NumVertices == 960 && PCount == 1072) \
|| (NumVertices == 2640 && PCount == 3070) || (NumVertices == 212 && PCount == 288) \
|| (NumVertices == 214 && PCount == 202) || (NumVertices == 1373 && PCount == 1256) \
|| (NumVertices == 585 && PCount == 440))

#define SASGunnermen (Stride == 32 && (NumVertices == 193 && PCount == 140) \
|| (NumVertices == 580 && PCount == 380) || (NumVertices == 1341 && PCount == 1132) \
|| (NumVertices == 802 && PCount == 800) || (NumVertices == 2301 && PCount == 2364) \
|| (NumVertices == 275 && PCount == 322) || (NumVertices == 3597 && PCount == 4280) \
|| (NumVertices == 3716 && PCount == 5064) || (NumVertices == 2578 && PCount == 2994) \
|| (NumVertices == 1412 && PCount == 1330) || (NumVertices == 568 && PCount == 470))

#define SASSniper (Stride == 32 && (NumVertices == 1615 && PCount == 1706) \
|| (NumVertices == 541 && PCount == 366) || (NumVertices == 3667 && PCount == 4952) \
|| (NumVertices == 2460 && PCount == 2882) || (NumVertices == 1479 && PCount == 1402) \
|| (NumVertices == 552 && PCount == 452))

#define SAS1 (Stride == 32 && (NumVertices == 634 && PCount == 372) \
|| (NumVertices == 1572 && PCount == 1166) || (NumVertices == 2784 && PCount == 2384) \
|| (NumVertices == 3790 && PCount == 4078) || (NumVertices == 3585 && PCount == 4858) \
|| (NumVertices == 1498 && PCount == 1304) || (NumVertices == 2525 && PCount == 3022) \
|| (NumVertices == 695 && PCount == 478))

#define SAS2 (Stride == 32 && (NumVertices == 689 && PCount == 1172) \
|| (NumVertices == 367 && PCount == 298) || (NumVertices == 4050 && PCount == 4486) \
|| (NumVertices == 308 && PCount == 212) || (NumVertices == 2540 && PCount == 2444) \
|| (NumVertices == 628 && PCount == 670) || (NumVertices == 1488 && PCount == 1114) \
|| (NumVertices == 105 && PCount == 74) || (NumVertices == 592 && PCount == 374) \
|| (NumVertices == 3562 && PCount == 4784) || (NumVertices == 2509 && PCount == 2954) \
|| (NumVertices == 1402 && PCount == 1164) || (NumVertices == 628 && PCount == 450))

#define snow ( Stride == 20 )

#define Smoke ((NumVertices == 16384))

#define sky ((Stride == 44) && (NumVertices == 20 && PCount == 10) \
|| (NumVertices == 12 && PCount == 12) \
|| (PCount >= 20 && PCount <= 30 && NumVertices == 50) \
|| (PCount >= 20 && PCount <= 30 && PCount == 37) \
|| (PCount >= 20 && PCount <= 30 && PCount == 32) \
|| (PCount >= 20 && PCount <= 30 && PCount == 41))

#define D3D_RELEASE(D3D_PTR) if( D3D_PTR ){ D3D_PTR->Release(); D3D_PTR = NULL; }

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

#pragma warning(disable : 4996)

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <D3DX9Mesh.h>

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

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

HRESULT (WINAPI* pReset) (LPDIRECT3DDEVICE9, D3DPRESENT_PARAMETERS*);
HRESULT (WINAPI* pEndScene) (LPDIRECT3DDEVICE9);
HRESULT (WINAPI* pDIP) (LPDIRECT3DDEVICE9, D3DPRIMITIVETYPE, INT, UINT, UINT, UINT, UINT);
HRESULT (WINAPI* pClear) (LPDIRECT3DDEVICE9 pDevice9,DWORD Count,CONST
D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);

/************************************************** ****************************/

typedef struct _Entities {
DWORD X;
DWORD Y;
}Entities,*PEntities;

//DIP
HRESULT WINAPI DIP( LPDIRECT3DDEVICE9 pDevice9, D3DPRIMITIVETYPE Type,
INT BaseIndex, UINT MinIndex, UINT NumVertices,
UINT StartIndex, UINT PCount );

//RESET
HRESULT WINAPI RESET( LPDIRECT3DDEVICE9 pDevice9,
D3DPRESENT_PARAMETERS* PParameters );

//ENDSCENE
HRESULT WINAPI ENDSCENE
( LPDIRECT3DDEVICE9 pDevice9 );

//CLEAR
HRESULT WINAPI CLEAR( LPDIRECT3DDEVICE9 pDevice9, DWORD Count,
CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color,
float Z, DWORD Stencil );

//THREAD
VOID WINAPI THREAD
( VOID );

//DetourFunc
PVOID WINAPI DetourFunc( PBYTE src,
CONST PBYTE dst, CONST INT len );

//RetourFunc
BOOL WINAPI RetourFunc( PBYTE src,
PBYTE restore, CONST INT len );

//GenerateShader
HRESULT WINAPI GenerateShader( IDirect3DPixelShader9 **Shader_Name,
IDirect3DDevice9 *Device, int red, int green, int blue, int alpha );

//GenerateTexture
VOID WINAPI GenerateTexture( LPDIRECT3DDEVICE9 pDevice,
IDirect3DTexture9 **ppD3Dtex, DWORD colour32 );

//SCAN
VOID WINAPI SCAN( DWORD ScrnW, DWORD ScrnH,
PBYTE pBits, INT Pitch, INT Start,
LPDIRECT3DDEVICE9 pDevice9 );

//================================================== ============================
#endif
//================================================== ============================

Code2

// D3D
LPDIRECT3DPIXELSHADER9 pShaders[MAX_SHADERS] = {0}; // 44 bytes each = 11,176 BYTES total.
LPDIRECT3DPIXELSHADER9 oShade = NULL;
LPDIRECT3DSURFACE9 pRenderSurfA = NULL;
LPDIRECT3DSURFACE9 pRenderSurfB = NULL;
LPDIRECT3DSURFACE9 pOffSurf = NULL;
LPDIRECT3DSURFACE9 pStencilSurf = NULL;
LPDIRECT3DSURFACE9 oDStencilSurface = NULL;
LPDIRECT3DSURFACE9 oSurface = NULL;
LPDIRECT3DTEXTURE9 TEX_OPFOR_A = NULL;
LPDIRECT3DTEXTURE9 TEX_OPFOR_B = NULL;
LPDIRECT3DTEXTURE9 TEX_MARINE_A = NULL;
LPDIRECT3DTEXTURE9 TEX_MARINE_B = NULL;
LPDIRECT3DTEXTURE9 TEX_SPETZ_A = NULL;
LPDIRECT3DTEXTURE9 TEX_SPETZ_B = NULL;
LPDIRECT3DTEXTURE9 TEX_SAS_A = NULL;
LPDIRECT3DTEXTURE9 TEX_SAS_B = NULL;
LPDIRECT3DDEVICE9 pDevice9 = NULL;
LPDIRECT3D9 Direct3D9 = NULL;
D3DPRESENT_PARAMETERS D3D_PP = {0};
LPDIRECT3DPIXELSHADER9 pShader = NULL;
D3DVIEWPORT9 Viewport = {0};
D3DSURFACE_DESC pDesc;
D3DRECT RectA = {0};
D3DRECT RectB = {0};
D3DLOCKED_RECT lRect;
PBYTE pBits = NULL;
INT BITSPERPIXEL = 32;
PBYTE Pixel;
HRESULT hRes = NULL;
PDWORD pVTable;
HWND hWND = NULL;
LPDIRECT3DDEVICE9 pDevice = NULL;
DWORD dwCreateDevice = NULL;

// COMMON
DWORD ScrnW;
DWORD ScrnH;
DWORD AspectRatioX;
DWORD AspectRatioY;
INT iColors = 0;
Entities Ents[512] = {0};
DWORD Box_Size = 10;
PDWORD IsInGame =
(PDWORD)0x0074E35C;
DWORD TargetX = NULL;
DWORD TargetY = NULL;

BYTE OPFOR = 0x0;
BYTE SPETZ = 0x0;
BYTE MARINE = 0x0;
BYTE Sas = 0x0;

INT Posx = 0;
INT Posy = 0;
INT TotalPixels = 0;

//INIT
BOOL InitShaders = FALSE;

//================================================== ============================
__declspec( naked )
VOID WINAPI CREATEDEVICE( VOID )
{
__asm
{
PUSH EBP
MOV EBP,ESP
PUSH [EBP+0x20]
PUSH [EBP+0x1C]
PUSH [EBP+0x18]
PUSH [EBP+0x14]
PUSH [EBP+0x10]
PUSH [EBP+0xC]
PUSH [EBP+0x8]
CALL [dwCreateDevice]
MOV EDX,[EBP+0x20]
MOV EDX,[EDX]
MOV [pDevice],EDX
POP EBP
RETN 0x1C
}
}

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

VOID WINAPI THREAD( VOID )
{
while( pDevice == NULL )
Sleep( 100 );

RetourFunc( (PBYTE)pVTable[16],
(PBYTE)dwCreateDevice, 5 );

pVTable = (PDWORD)*(PDWORD)pDevice;

*(PDWORD)&pClear = (DWORD)DetourFunc
( (PBYTE)pVTable[43], (PBYTE)CLEAR, 5 );

*(PDWORD)&pEndScene = (DWORD)DetourFunc
( (PBYTE)pVTable[42], (PBYTE)ENDSCENE, 5 );

*(PDWORD)&pReset = (DWORD)DetourFunc
( (PBYTE)pVTable[16], (PBYTE)RESET, 5 );

*(PDWORD)&pDIP = (DWORD)DetourFunc
( (PBYTE)pVTable[82], (PBYTE)DIP, 5 );
}

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

BOOL WINAPI DllMain( HMODULE hMod, DWORD dwReason, LPVOID lpvReserved )
{
if( dwReason == DLL_PROCESS_ATTACH )
{
DisableThreadLibraryCalls( hMod );

LPDIRECT3D9 LPD3D9 = Direct3DCreate9
( D3D_SDK_VERSION );

if( LPD3D9 != NULL )
{
pVTable = (PDWORD)*(PDWORD)LPD3D9;
LPD3D9->Release();

dwCreateDevice = (DWORD)DetourFunc
( (PBYTE)pVTable[16], (PBYTE)
CREATEDEVICE, 5 );

CreateThread( NULL ,NULL,
(LPTHREAD_START_ROUTINE)THREAD,
NULL, NULL,NULL );
}
}
else if( dwReason == DLL_PROCESS_DETACH )
{

}

return TRUE;
}

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

HRESULT WINAPI RESET( LPDIRECT3DDEVICE9 pDevice9,
D3DPRESENT_PARAMETERS* PParameters )
{
if( InitShaders == TRUE )
{
// 44 bytes each = 11,176 BYTES total.
for( int i = 0;i < MAX_SHADERS;i++ )
D3D_RELEASE( pShaders[i] );

D3D_RELEASE( TEX_OPFOR_A );
D3D_RELEASE( TEX_OPFOR_B );
D3D_RELEASE( TEX_MARINE_A );
D3D_RELEASE( TEX_MARINE_B );
D3D_RELEASE( TEX_SPETZ_A );
D3D_RELEASE( TEX_SPETZ_B );
D3D_RELEASE( TEX_SAS_A );
D3D_RELEASE( TEX_SAS_B );

D3D_RELEASE( pOffSurf );
D3D_RELEASE( pRenderSurfA );
D3D_RELEASE( pRenderSurfB );
D3D_RELEASE( pStencilSurf );

InitShaders = FALSE;
}

return pReset( pDevice9, PParameters );
}

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

HRESULT WINAPI ENDSCENE( LPDIRECT3DDEVICE9 pDevice9 )
{
pDevice9->GetViewport( &Viewport );

TargetX = 0;
TargetY = 0;

if( InitShaders == FALSE )
{
for( int i = 0;i < MAX_SHADERS;i++ )
{
// 44 bytes each = 11,176 BYTES total.
GenerateShader( &pShaders[i], pDevice9,
20, 20, 255, i + 1 );
}

GenerateTexture( pDevice9, &TEX_OPFOR_A,
D3DCOLOR_ARGB( 255, 255, 255, 20 ) ); // YELLOW
GenerateTexture( pDevice9, &TEX_OPFOR_B,
D3DCOLOR_ARGB( 255, 255, 20, 20 ) ); // RED

GenerateTexture( pDevice9, &TEX_MARINE_A,
D3DCOLOR_ARGB( 255, 128, 20, 255 ) ); // VIOLET
GenerateTexture( pDevice9, &TEX_MARINE_B,
D3DCOLOR_ARGB( 255, 20, 20, 255 ) ); // BLUE

GenerateTexture( pDevice9, &TEX_SPETZ_A,
D3DCOLOR_ARGB( 255, 20, 255, 20 ) ); // GREEN
GenerateTexture( pDevice9, &TEX_SPETZ_B,
D3DCOLOR_ARGB( 255, 185, 122, 87 ) ); // BROWN

GenerateTexture( pDevice9, &TEX_SAS_A,
D3DCOLOR_ARGB( 255, 255, 20, 255 ) ); // PINK
GenerateTexture( pDevice9, &TEX_SAS_B,
D3DCOLOR_ARGB( 255, 127, 122, 127 ) ); // GREY

AspectRatioX = Viewport.Width/240; // 240 x 180 | 4:3
AspectRatioY = Viewport.Height/180;

ScrnW = Viewport.Width/AspectRatioX;
ScrnH = Viewport.Height/AspectRatioY;

pDevice9->CreateOffscreenPlainSurface( ScrnW, ScrnH,
D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &pOffSurf, NULL );

pDevice9->CreateRenderTarget( ScrnW, ScrnH,
D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE,
&pRenderSurfA, NULL );

pDevice9->CreateRenderTarget( ScrnW, ScrnH,
D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE,
&pRenderSurfB, NULL );

pDevice9->CreateDepthStencilSurface( ScrnW, ScrnH,
D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0,
FALSE, &pStencilSurf, NULL );

InitShaders = TRUE;
}

if( *IsInGame && iColors
&& InitShaders == TRUE )
{
pDevice->GetRenderTargetData
( pRenderSurfA, pOffSurf );

if( pOffSurf->LockRect( &lRect, NULL,
D3DLOCK_NOSYSLOCK | D3DLOCK_DONOTWAIT ) == S_OK )
{

SCAN( ScrnW, ScrnH, (PBYTE)
lRect.pBits, lRect.Pitch,
0, pDevice9);

pOffSurf->UnlockRect( );
}

if( iColors > 254 )
{
pDevice->GetRenderTargetData
( pRenderSurfB, pOffSurf );

if( pOffSurf->LockRect( &lRect, NULL,
D3DLOCK_NOSYSLOCK | D3DLOCK_DONOTWAIT ) == S_OK )
{

SCAN( ScrnW, ScrnH, (PBYTE)
lRect.pBits, lRect.Pitch,
255, pDevice9 );

pOffSurf->UnlockRect( );
}
}

for( int j = 0; j < iColors; j++ )
{
DWORD Exp_x = Ents[j].X;
DWORD Exp_y = Ents[j].Y;
D3DRECT HBOX;

if( Exp_x && Exp_y )
{
HBOX.x1 = Exp_x - Box_Size;
HBOX.y1 = Exp_y - Box_Size;
HBOX.x2 = Exp_x + Box_Size;
HBOX.y2 = Exp_y - (Box_Size - 1);

pClear( pDevice9, 1, &HBOX, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 255, 20, 128, 255 ), 0, 0 );

HBOX.x1 = Exp_x - Box_Size;
HBOX.y1 = Exp_y + (Box_Size - 1);
HBOX.x2 = Exp_x + Box_Size;
HBOX.y2 = Exp_y + Box_Size;

pClear( pDevice9, 1, &HBOX, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 255, 20, 128, 255 ), 0, 0 );

HBOX.x1 = Exp_x - Box_Size;
HBOX.y1 = Exp_y - Box_Size;
HBOX.x2 = Exp_x - (Box_Size - 1);
HBOX.y2 = Exp_y + Box_Size;

pClear( pDevice9, 1, &HBOX, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 255, 20, 128, 255 ), 0, 0 );

HBOX.x1 = Exp_x + (Box_Size - 1);
HBOX.y1 = Exp_y - Box_Size;
HBOX.x2 = Exp_x + Box_Size;
HBOX.y2 = Exp_y + Box_Size;

pClear( pDevice9, 1, &HBOX, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 255, 20, 128, 255 ), 0, 0 );

Ents[j].X = 0;
Ents[j].Y = 0;
}
}

if( GetAsyncKeyState( VK_XBUTTON2 ) < 0 )
{
if( TargetX && TargetY )
{
POINT Target;
DWORD ScrX = Viewport.Width/2;
DWORD ScrY = Viewport.Height/2;

if(TargetX > (ScrX)){
Target.x = TargetX - (ScrX);
Target.x /= 4;
Target.x = +Target.x;
}

if(TargetX < (ScrX)){
Target.x = (ScrX) - TargetX;
Target.x /= 4;
Target.x = -Target.x;
}

if(TargetX == (ScrX)){
Target.x = 0;
}

if(TargetY > (ScrY)){
Target.y = TargetY - (ScrY);
Target.y /= 4;
Target.y = +Target.y;
}

if(TargetY < (ScrY)){
Target.y = (ScrY) - TargetY;
Target.y /= 4;
Target.y = -Target.y;
}

if(TargetY == (ScrY)){
Target.y = 0;
}

mouse_event( MOUSEEVENTF_MOVE,
Target.x, Target.y, NULL, NULL );
}
}
iColors = 0;
}

if( GetAsyncKeyState( VK_NUMPAD1 ) &1 )
D3DXSaveSurfaceToFileA( "c:\\Image.jpg",
D3DXIFF_JPG,pOffSurf,NULL,NULL);

DWORD ScrX = Viewport.Width / 2;
DWORD ScrY = Viewport.Height / 2;

RectA.x1 = ScrX - 4;
RectA.y1 = ScrY - 1;
RectA.x2 = ScrX + 3;
RectA.y2 = ScrY;

RectB.x1 = ScrX - 1;
RectB.y1 = ScrY - 4;
RectB.x2 = ScrX;
RectB.y2 = ScrY + 3;

pClear( pDevice9, 1, &RectA, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 255, 255, 20, 20 ), 0, 0 );

pClear( pDevice9, 1, &RectB, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 255, 255, 20, 20 ), 0, 0 );

return pEndScene( pDevice9 );
}

//================================================== ============================
// MoonBase Chaser343
float WINAPI GetDistance( float * LocationA, float * LocationB )
{
float DistanceX = LocationA[0] - LocationB[0];
float DistanceY = LocationA[1] - LocationB[1];
float DistanceZ = LocationA[2] - LocationB[2];

return (float)sqrt( ( DistanceX * DistanceX ) +
( DistanceY * DistanceY ) + ( DistanceZ * DistanceZ ) );
}

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

VOID WINAPI SCAN( DWORD ScrnW, DWORD ScrnH,
PBYTE pBits, INT Pitch, INT Start,
LPDIRECT3DDEVICE9 pDevice9 )
{
float MainDistance = 999999.0f;

for( int i = Start; i < iColors; i++ )
{
Posx = 0;
Posy = 0;

Ents[i].X = 0;
Ents[i].Y = 0;

TotalPixels = 0;

for( DWORD scy = 1L; scy <= ScrnH; scy++ )
{
for( DWORD scx = 1L; scx <= ScrnW; scx++ )
{
Pixel = ( PBYTE ) pBits;
Pixel += ( ( scy * Pitch )
+ ( scx * ( BITSPERPIXEL / 8 ) ) );

if( *(PDWORD)Pixel != NULL )
{
if( Pixel[3] == (i + 1) )
{
Posx += scx;
Posy += scy;

TotalPixels++;
}
}
}
}
if( Posx && Posy && TotalPixels )
{
Posx /= TotalPixels;
Posy /= TotalPixels;
Ents[i].X = Posx * AspectRatioX;
Ents[i].Y = Posy * AspectRatioY;

FLOAT vIn1[3];
FLOAT vIn2[3];

vIn1[0] = (float)Ents[i].X;
vIn1[1] = (float)Ents[i].Y;
vIn1[2] = 0.0f;

vIn2[0] = (float)Viewport.Width/2;
vIn2[1] = (float)Viewport.Height/2;
vIn2[2] = 0.0f;

float Distance = GetDistance
( vIn1, vIn2 );

if( Distance < MainDistance )
{
MainDistance = Distance;
TargetX = Ents[i].X;
TargetY = Ents[i].Y;
}
}
}
}

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

HRESULT WINAPI DIP( LPDIRECT3DDEVICE9 pDevice9, D3DPRIMITIVETYPE Type,
INT BaseIndex, UINT MinIndex, UINT NumVertices,
UINT StartIndex, UINT PCount )
{
LPDIRECT3DVERTEXBUFFER9 Stream_Data;
UINT Offset = 0;
UINT Stride = 0;

if( pDevice9->GetStreamSource(0, &Stream_Data,
&Offset, &Stride) == D3D_OK )
Stream_Data->Release();

if( Opfor ) OPFOR = 0x1;
else
OPFOR = 0x0;

if( Spetz ) SPETZ = 0x1;
else
SPETZ = 0x0;

if( Marines ) MARINE = 0x1;
else
MARINE = 0x0;

if( SAS ) Sas = 0x1;
else
Sas = 0x0;

// Get
pDevice9->GetRenderTarget
( 0, &oSurface );

pDevice9->GetDepthStencilSurface
( &oDStencilSurface );

pDevice9->GetPixelShader
( &oShade );

oSurface->GetDesc
( &pDesc );

if( OPFOR || SPETZ || MARINE || Sas )
if( !Smoke )
if( pDesc.Width == Viewport.Width &&
pDesc.Height == Viewport.Height &&
InitShaders == TRUE )
{
// Switch
if( iColors < 255 )
pDevice9->SetRenderTarget
( 0, pRenderSurfA );
else
pDevice9->SetRenderTarget
( 0, pRenderSurfB );

pDevice9->SetDepthStencilSurface
( pStencilSurf );

pDevice9->SetRenderState
( D3DRS_ZENABLE, FALSE );

if( iColors < 255 )
pDevice9->SetPixelShader
( pShaders[iColors] );
else
pDevice9->SetPixelShader
( pShaders[iColors - 255] );

// Draw
pDIP( pDevice9, Type, BaseIndex, MinIndex,
NumVertices, StartIndex, PCount );

pDevice9->SetRenderState
( D3DRS_ZENABLE, TRUE );

// Draw
pDIP( pDevice9, Type, BaseIndex, MinIndex,
NumVertices, StartIndex, PCount );

// Switch
pDevice9->SetRenderTarget
( 0, oSurface );

pDevice9->SetDepthStencilSurface
( oDStencilSurface );

pDevice9->SetPixelShader
( oShade );

if( OPFOR )
pDevice9->SetTexture( 0, TEX_OPFOR_B );
else if( SPETZ )
pDevice9->SetTexture( 0, TEX_SPETZ_B );
else if( MARINE )
pDevice9->SetTexture( 0, TEX_MARINE_B );
else if( Sas )
pDevice9->SetTexture( 0, TEX_SAS_B );

pDevice9->SetRenderState
( D3DRS_ZENABLE, FALSE );

// Draw
pDIP( pDevice9, Type, BaseIndex, MinIndex,
NumVertices, StartIndex, PCount );

if( OPFOR )
pDevice9->SetTexture( 0, TEX_OPFOR_A );
else if( SPETZ )
pDevice9->SetTexture( 0, TEX_SPETZ_A );
else if( MARINE )
pDevice9->SetTexture( 0, TEX_MARINE_A );
else if( Sas )
pDevice9->SetTexture( 0, TEX_SAS_A );

pDevice9->SetRenderState
( D3DRS_ZENABLE, TRUE );

if( iColors < 510 )
iColors++;
}

// Release
D3D_RELEASE( oSurface );
D3D_RELEASE( oDStencilSurface );
D3D_RELEASE( oShade );

// Draw
return pDIP( pDevice9, Type, BaseIndex, MinIndex,
NumVertices, StartIndex, PCount );
}

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

HRESULT WINAPI CLEAR( LPDIRECT3DDEVICE9 pDevice9, DWORD Count,
CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color,
float Z, DWORD Stencil )
{
pDevice9->GetDepthStencilSurface
( &oDStencilSurface );

pDevice9->GetRenderTarget
( 0, &oSurface );

oSurface->GetDesc
( &pDesc );

if( pDesc.Width == Viewport.Width &&
pDesc.Height == Viewport.Height &&
InitShaders == TRUE )
{
pDevice9->SetRenderTarget
( 0, pRenderSurfA );

pClear( pDevice9, 0, NULL, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 0, 0, 0, 0 ), 0, 0 );

pDevice9->SetRenderTarget
( 0, pRenderSurfB );

pClear( pDevice9, 0, NULL, D3DCLEAR_TARGET,
D3DCOLOR_ARGB( 0, 0, 0, 0 ), 0, 0 );

pDevice9->SetRenderTarget
( 0, oSurface );

pDevice9->SetDepthStencilSurface
( pStencilSurf );

pClear( pDevice9, Count, pRects, Flags,
Color, Z, Stencil );

pDevice9->SetDepthStencilSurface
( oDStencilSurface );
}

D3D_RELEASE( oSurface );
D3D_RELEASE( oDStencilSurface );

return pClear( pDevice9, Count, pRects, Flags,
Color, Z, Stencil );
}

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

PVOID WINAPI DetourFunc( PBYTE src, CONST PBYTE 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 WINAPI RetourFunc( PBYTE src, PBYTE restore, CONST INT len )
{
DWORD dwback;

if(!VirtualProtect(src, len, PAGE_READWRITE, &dwback)) { return FALSE; }
if(!memcpy(src, restore, len)) { return FALSE; }

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

if(!VirtualProtect(src, len, dwback, &dwback)) { return FALSE; }

return TRUE;
}

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

HRESULT WINAPI GenerateShader( IDirect3DPixelShader9 **Shader_Name,
IDirect3DDevice9 *Device, int red, int green, int blue, int alpha )
{
ID3DXBuffer *MyBuffer = NULL;
char MyShader[ 256 ];

sprintf( MyShader, "ps_3_0\ndef c0, %f, %f, %f, %f\nmov oC0, c0",
(float)red/(float)255, (float)green/(float)255, (float)blue/(float)255,
(float)alpha/(float)255 );

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

if( FAILED( Device->CreatePixelShader((const DWORD*)
MyBuffer->GetBufferPointer(), Shader_Name)) )
return E_FAIL;

return S_OK;
}

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

VOID WINAPI GenerateTexture( LPDIRECT3DDEVICE9 pDevice,
IDirect3DTexture9 **ppD3Dtex, DWORD colour32 )
{
IDirect3DTexture9 * Temp_tex;

if( SUCCEEDED(pDevice->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4,
D3DPOOL_DEFAULT, ppD3Dtex, NULL)) )
{
if( SUCCEEDED(pDevice->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4,
D3DPOOL_SYSTEMMEM, &Temp_tex, NULL)) )
{
WORD colour16 =
((WORD)((colour32>>28)&0xF)<<12)
|(WORD)(((colour32>>20)&0xF)<<8)
|(WORD)(((colour32>>12)&0xF)<<4)
|(WORD)(((colour32>>4)&0xF)<<0);

D3DLOCKED_RECT d3dlr;

if( Temp_tex->LockRect( 0, &d3dlr, 0,
D3DLOCK_DONOTWAIT | D3DLOCK_NOSYSLOCK
| D3DLOCK_DISCARD ) == S_OK )
{
WORD *pDst16 = (WORD*)d3dlr.pBits;

for(int xy=0; xy < 8*8; xy++)
*pDst16++ = colour16;

Temp_tex->UnlockRect( 0 );
}

if( Temp_tex != NULL )
{
pDevice->UpdateTexture( Temp_tex, *ppD3Dtex );
Temp_tex->Release();
}
}
}
}

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

D3DAIMBOT 2013

Post a Reply

Similar Threads

Tags for this Thread