ESP

#define NAMESIZE 0x21
#define OFS_NAMES 0x5D2C
#define OFS_HEALTH   0x344
#define HPSIZE   0x1C
#define MAXPLAYERS   16
#define PLAYERSIZE   0x11A8
#define OFS_BASEPLAYER  0x631A58
#define OFS_PLAYER   0x74BC
#define OFS_TEAM     0x6150
#define OFS_RDATA    0x189080


#define OFS_Grade 0x5AD1
#define GradeSIZE 0x26



CHAR FrameRate[20] = "[+]";


DWORD dwGFX  = (DWORD)GetModuleHandle("i3GfxDx.dll");
RenderContext *pRC   = (RenderContext*)(dwGFX + OFS_RDATA);



bool WorldToScreen(D3DVECTOR Player,D3DVECTOR &PlayerScaled)
{
D3DXVECTOR3 PlayerPos(Player.x,Player.y,Player.z);
D3DXMATRIX identity;
D3DXVECTOR3 vScreen;

npDevice->GetViewport(&g_ViewPort);
g_ViewPort.X = g_ViewPort.Y = 0;
g_ViewPort.MinZ = 0;
g_ViewPort.MaxZ = 1;
D3DXVec3Project(&vScreen, &PlayerPos, &g_ViewPort, &pRC->pRenderData->ProjMatrix, &pRC->pRenderData->ViewMatrix, &pRC->pRenderData->GetWorldMatrix);

if (vScreen.z < 1.0f && vScreen.x > 0.0f && vScreen.y > 0.0f && vScreen.x < g_ViewPort.Width && vScreen.y < g_ViewPort.Height)
{
PlayerScaled.x = vScreen.x;
PlayerScaled.y = vScreen.y ;
PlayerScaled.z = vScreen.z;

return true;
}
return false;
}





void FillRGB( float x, float y, float w, float h, D3DCOLOR color)
{
if( w < 0 )w = 1;
if( h < 0 )h = 1;
if( x < 0 )x = 1;
if( y < 0 )y = 1;

D3DRECT rec = { x, y, x + w, y + h };
npDevice->Clear( 1, &rec, D3DCLEAR_TARGET, color, 0, 0 );
}




void DrawBox1(float x, float y, float w, float h, D3DCOLOR color )
{
D3DRECT rec;
rec.x1 = x;
rec.x2 = x + w;
rec.y1 = y;
rec.y2 = y + h;
npDevice->Clear( 1, &rec, D3DCLEAR_TARGET, color, 0, 0 );
}





void DrawString(float x, float y , DWORD color, const char *fmt, ...)
{
RECT FontPos = { x, y, x + 20, y + 10 };
char buf[1024] = {'\0'};
va_list va_alist;
va_start(va_alist, fmt);
vsprintf(buf, fmt, va_alist);
va_end(va_alist);
g_pFont->DrawText(NULL, buf, -1, &FontPos, DT_NOCLIP, color);
}



D3DVECTOR HeadPos;
D3DVECTOR FootPos;
D3DVECTOR ScreenPos;



#define BLACK    D3DCOLOR_ARGB(150, 000, 000, 000)
#define WHITE    D3DCOLOR_ARGB(255, 255, 255, 255)
#define RED  D3DCOLOR_ARGB(255, 255, 000, 000)
#define GREEN    D3DCOLOR_ARGB(255, 000, 255, 000)
#define YELLOW   D3DCOLOR_ARGB(255, 255, 255, 000)
#define BLUE     D3DCOLOR_ARGB(255, 000, 000, 255)
#define SKYBLUE  D3DCOLOR_ARGB(255, 0, 180, 255)
#define RED2     D3DCOLOR_ARGB(100, 255, 000, 000)



void DrawBorder( float x, float y, float w, float h, int px, float Health)
{
DWORD HPcol = GREEN;
if (Health < 90 )HPcol = BLUE;
if (Health < 70 )HPcol = SKYBLUE;
if (Health < 50 )HPcol = YELLOW;
if (Health < 30) HPcol = RED;
if (Health < 10) HPcol = RED2;
if (Health = 0) HPcol = BLACK;
FillRGB( x, (y + h - px), w, px, HPcol);
FillRGB( x, y, px, h, HPcol);
FillRGB( x, y, w, px, HPcol);
FillRGB( (x + w - px), y, px, h, HPcol);
}


void FillRGB3( int x, int y, int w, int h, D3DCOLOR color, IDirect3DDevice9* pDevice )
{
if( w < 0 )w = 1;
if( h < 0 )h = 1;
if( x < 0 )x = 1;
if( y < 0 )y = 1;

D3DRECT rec = { x, y, x + w, y + h };
pDevice->Clear( 1, &rec, D3DCLEAR_TARGET, color, 0, 0 );
}



void DrawBorder333( int x, int y, int w, int h, int px, D3DCOLOR BorderColor, IDirect3DDevice9* pDevice )
{
FillRGB3( x, (y + h - px), w, px, BorderColor, pDevice );
FillRGB3( x, y, px, h, BorderColor, pDevice );
FillRGB3( x, y, w, px, BorderColor, pDevice );
FillRGB3( (x + w - px), y, px, h, BorderColor, pDevice );
}





void Healthbar(int x, int y, float Health)
{
DWORD HPcol = GREEN;
if (Health < 90 )HPcol = BLUE;
if (Health < 70 )HPcol = SKYBLUE;
if (Health < 50 )HPcol = YELLOW;
if (Health < 30) HPcol = RED;
if (Health < 10) HPcol = RED2;
DrawBorder333(x-1,y-1,50,6,1,BLACK,npDevice);
FillRGB3(x,y,Health/2,4,HPcol,npDevice);
}


void DrawRectangle(float x, float y, float w, int h)
{
D3DXVECTOR2 vLine1[2];
D3DXVECTOR2 vLine2[2];
D3DXVECTOR2 vLine3[2];
D3DXVECTOR2 vLine4[2];
vLine1[0].x = x;
vLine1[0].y = y;
vLine1[1].x = x;
vLine1[1].y = y+h;
vLine2[0].x = x+w;
vLine2[0].y = y;
vLine2[1].x = x+w;
vLine2[1].y = y+h;
vLine3[0].x = x;
vLine3[0].y = y;
vLine3[1].x = x+w;
vLine3[1].y = y;
vLine4[0].x = x;
vLine4[0].y = y+h;
vLine4[1].x = x+w;
vLine4[1].y = y+h;
g_pLine->SetWidth(2);
g_pLine->SetAntialias(false);
g_pLine->SetGLLines(false);
g_pLine->Begin();
g_pLine->Draw(vLine1, 2, 0xFF0000FF);
g_pLine->Draw(vLine2, 2, 0xFF0000FF);
g_pLine->Draw(vLine3, 2, 0xFF0000FF);
g_pLine->Draw(vLine4, 2, 0xFF0000FF);
g_pLine->End();

}

void DrawLine ( long Xa, long Ya, long Xb, long Yb, DWORD dwWidth, float Health)
{
DWORD HPcol = GREEN; // Deklarasi Health Protection Color
if (Health < 90 )HPcol = BLUE; // Jika HP Di Bawah 90 = Color
if (Health < 70 )HPcol = SKYBLUE; // Jika HP Di Bawah 70 = Color
if (Health < 50 )HPcol = YELLOW; // Jika HP Di Bawah 50 = Color
if (Health < 30) HPcol = RED; // Jika HP Di Bawah 30 = Color
if (Health < 10) HPcol = RED2; // Jika HP Di Bawah 10 = Color
if (Health = 0) HPcol = BLACK; // Jika HP Di Bawah 10 = Color
D3DXVECTOR2 vLine[ 2 ]; // 2 Poin
g_pLine->SetAntialias( 0 ); // Set Tepi
g_pLine->SetWidth( dwWidth ); // Lebar Dari Line
g_pLine->Begin();
vLine[ 0 ][ 0 ] = Xa; // Jadikan Point Menjadi Array
vLine[ 0 ][ 1 ] = Ya;
vLine[ 1 ][ 0 ] = Xb;
vLine[ 1 ][ 1 ] = Yb;
g_pLine->Draw( vLine, 2, HPcol ); // Draw Garis , Jumlah Garis , Warna Garis
g_pLine->End(); // Selesai
}


ID3DXLine *pLine; //Deklarasi pLine


void Draw3DBox(float x_bottom_left, float y_bottom_left, float x_bottom_right, float y_bottom_right, float x_top_left, float y_top_left, float x_top_right, float y_top_right, float x_forward_bottom_left, float y_forward_bottom_left, float x_forward_bottom_right, float y_forward_bottom_right, float x_forward_top_left, float y_forward_top_left, float x_forward_top_right, float y_forward_top_right, int a, int r, int g, int b)
{
if(!IsBadReadPtr(pLine, sizeof(ID3DXLine)))
{
D3DXVECTOR2 vLine1[2];
D3DXVECTOR2 vLine2[2];
D3DXVECTOR2 vLine3[2];
D3DXVECTOR2 vLine4[2];
D3DXVECTOR2 vLine5[2];
D3DXVECTOR2 vLine6[2];
D3DXVECTOR2 vLine7[2];
D3DXVECTOR2 vLine8[2];
D3DXVECTOR2 vLine9[2];
D3DXVECTOR2 vLine10[2];
D3DXVECTOR2 vLine11[2];
D3DXVECTOR2 vLine12[2];

float t=1;
pLine->SetWidth( t );
pLine->SetAntialias( false );
pLine->SetGLLines( false );

//bottom left to bottom right
vLine1[0].x = x_bottom_left;
vLine1[0].y = y_bottom_left;
vLine1[1].x = x_bottom_left+(x_bottom_right-x_bottom_left);
vLine1[1].y = y_bottom_left;

//bottom left to top left
vLine2[0].x = x_top_left;
vLine2[0].y = y_top_left;
vLine2[1].x = x_top_left;
vLine2[1].y = y_top_left+(y_bottom_left-y_top_left);

//bottom right to top right
vLine3[0].x = x_top_right;
vLine3[0].y = y_top_right;
vLine3[1].x = x_top_right;
vLine3[1].y = y_top_right+(y_bottom_right-y_top_right);

//top left to top right
vLine4[0].x = x_top_left;
vLine4[0].y = y_top_left;
vLine4[1].x = x_top_left+(x_top_right-x_top_left);
vLine4[1].y = y_top_left;

//from top left to top left forward
vLine5[0].x = x_top_left;
vLine5[0].y = y_top_left;
vLine5[1].x = x_top_left+(x_forward_top_left-x_top_left);
vLine5[1].y = y_top_left+(y_forward_top_left-y_top_left);

//from bottom left to bottom left forward
vLine6[0].x = x_bottom_left;
vLine6[0].y = y_bottom_left;
vLine6[1].x = x_bottom_left+(x_forward_bottom_left-x_bottom_left);//
vLine6[1].y = y_bottom_left+(y_forward_bottom_left-y_bottom_left);//

//from bottom right to bottom right forward
vLine7[0].x = x_bottom_right;
vLine7[0].y = y_bottom_right;
vLine7[1].x = x_bottom_right+(x_forward_bottom_right-x_bottom_right);//
vLine7[1].y = y_bottom_right+(y_forward_bottom_right-y_bottom_right);//

//from top right to top right forward
vLine8[0].x = x_top_right;
vLine8[0].y = y_top_right;
vLine8[1].x = x_top_right+(x_forward_top_right-x_top_right);//
vLine8[1].y = y_top_right+(y_forward_top_right-y_top_right);//

//bottom left forward to bottom right forward
vLine9[0].x = x_forward_bottom_left;
vLine9[0].y = y_forward_bottom_left;
vLine9[1].x = x_forward_bottom_left+(x_forward_bottom_right-x_forward_bottom_left);
vLine9[1].y = y_forward_bottom_left;

//bottom left forward to top left forward
vLine10[0].x = x_forward_top_left;
vLine10[0].y = y_forward_top_left;
vLine10[1].x = x_forward_top_left;
vLine10[1].y = y_forward_top_left+(y_forward_bottom_left-y_forward_top_left);

//bottom right forward to top right forward
vLine11[0].x = x_forward_top_right;
vLine11[0].y = y_forward_top_right;
vLine11[1].x = x_forward_top_right;
vLine11[1].y = y_forward_top_right+(y_forward_bottom_right-y_forward_top_right);

//top left forward to top right forward
vLine12[0].x = x_forward_top_left;
vLine12[0].y = y_forward_top_left;
vLine12[1].x = x_forward_top_left+(x_forward_top_right-x_forward_top_left);
vLine12[1].y = y_forward_top_left;

pLine->Begin( );
pLine->Draw( vLine1, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine2, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine3, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine4, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine5, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine6, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine7, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine8, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine9, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine10, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine11, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->Draw( vLine12, 2, D3DCOLOR_ARGB(a, r, g, b ) );
pLine->End( );
}
}


/*void DrawHealthbar(int x, int y, int w, int h, D3DCOLOR barCol, D3DCOLOR borCol, int hp, int maxhp)
{
FillRGB(x, y, ( hp / (double)maxhp ) * w, h, barCol, pDevice);
DrawBorder(x, y, w, h, Green, Green);
}*/


static char FinalString[260];
#define OFS_BASEPLAYER2 0x631A24

char dis[64];


DWORD dwPointer;
D3DXMATRIX ProjMatrix, World, ViewMatrix;//Place At Top Of Your Source Code
bool DxInit = false;


float FindDistance(D3DXVECTOR3 my,D3DXVECTOR3 other,CPlayers* pPlayer,CPlayers* pLocal)
{
return sqrt((pLocal->pos.x-pPlayer->pos.x)*(pLocal->pos.x-pPlayer->pos.x) + (pLocal->pos.y-pPlayer->pos.y)*(pLocal->pos.y-pPlayer->pos.y) + (pLocal->pos.z-pPlayer->pos.z)*(pLocal->pos.z-pPlayer->pos.z));
}

void DrawESP()
{

DWORD dwI3EXEC   = (DWORD)GetModuleHandle("PointBlank.exe");
unsigned long dwBase    = *(DWORD*)(dwI3EXEC + OFS_BASEPLAYER);
unsigned long dwBase2   = *(DWORD*)(dwI3EXEC + OFS_BASEPLAYER2);
CTeam    *pTeam  = ((CTeam*)(dwBase + OFS_TEAM));

D3DVECTOR ScreenPos;


for (int i = 0; i <= 16; i++)
{
CPlayers    *pPlayer    = (CPlayers*)((dwBase + OFS_PLAYER) + i * PLAYERSIZE);
CPlayers    *pLocal  = (CPlayers*)((dwBase + OFS_PLAYER) + pTeam->iTeam * PLAYERSIZE);
CNames *PNames = (CNames*) ((dwBase + OFS_NAMES) + NAMESIZE * i);
CGrade *PGrade = (CGrade*) ((dwBase + OFS_Grade) + GradeSIZE * i);
CHealth  *pHealth   = (CHealth*) ((dwBase2+ OFS_HEALTH) + i * HPSIZE);
HeadPos.x   =   pPlayer->pos.x;
HeadPos.y   =   1.5f + pPlayer->pos.y;
HeadPos.z   =   pPlayer->pos.z;
FootPos.x   =   pPlayer->pos.x;
FootPos.y   =   pPlayer->pos.y;
FootPos.z   =   pPlayer->pos.z;
D3DXVECTOR3 xDistance   =   pPlayer->pos - pLocal->pos;
D3DXVECTOR3 MyDistance  =   pLocal->pos - pPlayer->pos;
float xaDistance    = D3DXVec3Length(&xDistance );
float MyaDistance   = D3DXVec3Length(&MyDistance );

if (WorldToScreen(pPlayer->pos,ScreenPos))
{

if(pHealth->CurHP > 1)
{

if (esphp == 1)
{
Healthbar((int)ScreenPos.x-23,(int)ScreenPos.y+15,pHealth->CurHP);
}

if (ESPHack == 1)
{
DrawBorder(ScreenPos.x-(10000/MyaDistance)/40,ScreenPos.y-(35000/MyaDistance)/40,50000/MyaDistance/6*2/40,50000/MyaDistance/3*2/40,1,pHealth->CurHP);
}

if(LineESP == 1)
{
DrawLine(ScreenCenterX,ScreenCenterY+550,ScreenPos.x-10,ScreenPos.y+20,1,pHealth->CurHP);
}

if (DrawStringESP == 1)
{
DrawString(ScreenPos.x+10,ScreenPos.y-25,WHITE,"Name : [%s]",PNames->szNames);
}


if (HealthBarDD == 1)
{
DrawString(ScreenPos.x+10,ScreenPos.y-35,YELLOW,"Clan : [%s] ",PGrade->szGrade);
}


}
}
}
}

ClassESP :
Code:

#include <windows.h>
#include <stdio.h>
#include <string>
#include <d3d9.h>
#include <d3dx9.h>
#include <tchar.h>
#include <iostream>
#include <d3dx9math.h>
#include <fstream>
#include <time.h>
#include <vector>
#include <math.h>
#include <fstream>
#include <cmath>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

class RenderContext;
class RenderData;
class CPlayers;
class CTeam;

class CPlayers
{
public:
float yaw;
float pitch;
D3DXVECTOR3 pos;
char unkno8[2704];
};

struct CNames
{
char szNames[33];//21
};


struct CGrade
{
char szGrade[33];//21
};


class RenderContext
{
public:
RenderData* pRenderData;
char unknown4[1076];
D3DXVECTOR3 bone;
D3DXVECTOR3 bone1;
D3DXVECTOR3 bone2;
};

class _Object
{
public:
char Pad[4];
D3DXVECTOR3 origin;
};


struct CHealth
{
float CurHP;
};


struct DHealth
{
char STRHP;
};


class RenderData
{
public:
char unknown0[2400];
D3DXMATRIX ViewMatrix;
D3DXMATRIX ProjMatrix;
D3DXMATRIX GetWorldMatrix;
D3DXMATRIX WorldView[80];
};

class CTeam
{
public:
BYTE iTeam;
};