WarRock EU - Code Snippets

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <wininet.h>
#include "xColor.h"
#include "xMenu.h"
#include "xAddys.h"
#include "xMain.h"
#include "xDetour.h"
#include "xDetour2.h"
#include "xBreakpoint.h"
#include "xStruct.h"
#include "targetever.h"
#include "VTable.h"
#include "xDumpProtection.h"
#include "xAntiRev.h"
#include "xDefines.h"
#include "xPatch.h"
#include "xLog.h"
#include "xGUIDTech.h"
#include "xCrypt.h"
#include "xWeaponBinder.h"
#include "xBypass.h"
#include <fstream>
#include <d3d9.h>
#include <d3dx9.h>
#include <time.h>
using namespace std;
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "D3DX9.LIB")
D3D9Menu *Base = NULL;
ModuleBase* Module;
ID3DXFont * _FontDevice;
LPDIRECT3DTEXTURE9 aRed,aGreen,aBlue,aYellow,aPurple,aPink,aOrange,aGrey,aCyan,aBlack,aWhite;
LPDIRECT3DVERTEXBUFFER9 Stream;
UINT OffsetInBytes;
UINT Offset = 0;
UINT m_Stride;
bool Color = true;
BYTE EndSceneOpCodes[7],DrawIndexedPrimiveOpCodes[7];
BYTE PresenOpCodes[7],ResetOpCodes[7];
BOOL AimbotInitialised = FALSE;
BOOL InitAimBot = FALSE;
D3DVIEWPORT9 viewPort;
D3DXVECTOR3 vOrthoLocation;
D3DXMATRIX projection, view, world, identity;
D3DXVECTOR3 *GetScreenCoordFromWorld( IDirect3DDevice9 *pDevice, D3DXVECTOR3 &vScreenCoord, D3DXVECTOR3 vWorldLocation )
{
if( !pDevice ) return NULL;

pDevice->GetTransform( D3DTS_VIEW, &view );
pDevice->GetTransform( D3DTS_PROJECTION, &projection );
pDevice->GetTransform( D3DTS_WORLD, &world );
pDevice->GetViewport( &viewPort );
D3DXMatrixIdentity( &identity );

D3DXVec3Project( &vScreenCoord, &vWorldLocation, &viewPort, &projection, &view, &identity );

if(vScreenCoord.z < 1)
{
return &vScreenCoord;
}   
return NULL;
}
float xMenu = 12;
float yMenu = 10;
bool Create;
bool IngameMessage = true;


		HRESULT __stdcall xRebuildMenu()
		{
			Base->AddFolder(Decrypt_text (/*Settings*/ "`rv{t€"),OpenClose,&SETTINGSFOLDER,2);
			if(SETTINGSFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Anti Party Program*/ "N{v-]n†-]|tnz"),OnOff,&AntiPartyProgram,2);
				Base->AddItem(Decrypt_text (/*Enable Bypass*/ "R{noyr-O†}n€€"),OnOff,&BypassX1,2);
				Base->AddCategory(Decrypt_text (/*Change Menu Colors*/ "Pun{tr-Zr{‚-P|y|€"),OnOff,&ChangeMenuColors,2);
				if(ChangeMenuColors)
				{
				Base->AddItem(Decrypt_text (/*BackGround Color*/ "OnpxT|‚{q-P|y|"),MColor,&MenuColor,5);
				Base->AddItem(Decrypt_text (/*Box Color*/ "O|…-P|y|"),MColor,&BoxColor,5);
				}
			}
			Base->AddFolder(Decrypt_text (/*D3D Hacks*/ "Q@Q-Unpx€"),OpenClose,&D3DFOLDER,2);
            if(D3DFOLDER)
			{
				Base->AddItem(Decrypt_text (/*D3D Hook*/ "Q@Q-U||x"),OnOff, &nEnable,2);
				Base->AddItem(Decrypt_text (/*Chams A*/ "Punz€-N"),Colors, &nColorA,10);
				Base->AddItem(Decrypt_text (/*Chams B*/ "Punz€-O"),Colors, &nColorB,10);
				Base->AddItem(Decrypt_text (/*WireFrame*/ "dvrSnzr"),OnOff,&WireFrame,2);
				Base->AddItem(Decrypt_text (/*PointMode*/ "]|v{Z|qr"),OnOff,&PointMode,2);
				Base->AddItem(Decrypt_text (/*WallHack*/ "dnyyUnpx"),OnOff, &x_WallHack,2);
				Base->AddItem(Decrypt_text (/*WallColor*/ "dnyyP|y|"),WallColor1, &WallColor,4);
				Base->AddItem(Decrypt_text (/*FullBright*/ "S‚yyOvtu"),OnOff, &x_FullBright,2);
				Base->AddItem(Decrypt_text (/*CrossHair*/ "P|€€Unv"),Colors2, &nCross,10);
				Base->AddItem(Decrypt_text (/*NoFog*/ "[|S|t"), OnOff, &x_NoFog,2);
				Base->AddItem(Decrypt_text (/*GlassWalls*/ "Tyn€€dnyy€"),OnOff,&x_GlassWall,2);
			}
			Base->AddFolder(Decrypt_text (/*AimBot Hacks*/ "NvzO|-Unpx€"),OpenClose,&AIMBOTFOLDER,2);
			if(AIMBOTFOLDER)
			{
				Base->AddItem(Decrypt_text (/*AimBot*/ "NvzO|"),OnOff,&AimBot,2);
				Base->AddItem(Decrypt_text (/*AimKey*/ "NvzXr†"),CV_AIMKEY,&AimKey,4);
				Base->AddItem(Decrypt_text (/*AimType*/ "Nvza†}r"),CV_AIMMODE,&AimType,3);
				Base->AddItem(Decrypt_text (/*Enemy Only*/ "R{rz†-\{y†"),OnOff,&AimEnemy,2);
				Base->AddItem(Decrypt_text (/*See Down*/ "`rr-Q|„{"),OnOff,&SeeDown,2);
			}
			Base->AddFolder(Decrypt_text (/*ESP/GPS Hacks*/ "R`]<T]`-Unpx€"),OpenClose,&ESPFOLDER,2);
			if(ESPFOLDER)
			{
				Base->AddItem(Decrypt_text (/*ESP - Enable*/ "R`]-:-R{noyr"),OnOff,&EspOnOff,2);
				Base->AddItem(Decrypt_text (/*ESP - Enemy Only*/ "R`]-:-R{rz†-\{y†"),OnOff,&EspEnemysOnly,2);
				Base->AddItem(Decrypt_text (/*ESP - Name*/ "R`]-:-[nzr"),OnOff,&NameEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Team*/ "R`]-:-arnz"),OnOff,&TeamEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Premium*/ "R`]-:-]rzv‚z"),OnOff,&PremiumEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Health*/ "R`]-:-Urnyu"),OnOff,&HealthEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Ping*/ "R`]-:-]v{t"),OnOff,&PingEsp,2);	
				Base->AddItem(Decrypt_text (/*ESP - Flags*/ "R`]-:-Synt€"),OnOff,&FlagsEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Kills*/ "R`]-:-Xvyy€"),OnOff,&KillsEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Deaths*/ "R`]-:-Qrnu€"),OnOff,&DeathEsp,2);
				Base->AddItem(Decrypt_text (/*ESP - Class*/ "R`]-:-Pyn€€"),OnOff,&ClassEsp,2);
			}
			Base->AddFolder(Decrypt_text (/*Player Hacks*/ "]yn†r-Unpx€"),OpenClose,&PLAYERFOLDER,2);
            if(PLAYERFOLDER)
			{
				Base->AddItem(Decrypt_text (/*PlayerOPK*/ "]yn†r\]X"), OnOff, &PlayerOPK,2);
				Base->AddItem(Decrypt_text (/*DeadSpinner*/ "Qrnq`}v{{r"), OnOff, &Deadspinner,2);
				Base->AddItem(Decrypt_text (/*Quick Ladder Up*/ "^‚vpx-Ynqqr-b}"), OnOff, &QuickLadderUp,2);
				Base->AddItem(Decrypt_text (/*Super Explosion*/ "`‚}r-R…}y|€v|{"), OnOff, &SuperExplosion,2);
				Base->AddItem(Decrypt_text (/*Moon Jump*/ "Z||{-W‚z}"),OnOff,&MoonJump,2);
				Base->AddItem(Decrypt_text (/*Super Jump*/ "`‚}r-W‚z}"), OnOff, &SuperJump,2);
				Base->AddItem(Decrypt_text (/*No Fall Damage*/ "[|-Snyy-Qnzntr"), OnOff, &NFD,2);
				Base->AddItem(Decrypt_text (/*Speed*/ "`}rrq"), setSpeed, &Speed,4);
				Base->AddItem(Decrypt_text (/*Stamina*/ "`nzv{n"),OnOff,&Stamina,2);
				Base->AddItem(Decrypt_text (/*NoBounds*/ "[|O|‚{q€"),OnOff,&NoBounds,2);
				Base->AddItem(Decrypt_text (/*NoSpawnWait*/ "[|`}n„{dnv"),OnOff,&NoSpawnWait,2);
				Base->AddItem(Decrypt_text (/*W.T.W.*/ "d;a;d;"),OnOff,&WTW,2);
				Base->AddItem(Decrypt_text (/*W.T.H.*/ "d;a;U;"),OnOff,&WTH,2);
				Base->AddItem(Decrypt_text (/*Self Kill*/ "`rys-Xvyy"),OnOff,&Selfkill,2);
				Base->AddItem(Decrypt_text (/*Dig undermap*/ "Qvt-‚{qrzn}"),OnOff,&Dig,2);
				Base->AddItem(Decrypt_text (/*LowGravity*/ "Y|„Tnƒv†"),OnOff,&LowGravity,2);
				Base->AddItem(Decrypt_text (/*D3DPlayerView*/ "Q@Q]yn†rcvr„"),OnOff,&D3DPlayerView,2);
				Base->AddItem(Decrypt_text (/*Auto Repair*/ "N‚|-_r}nv"),OnOff,&AutoRepair,2);
				Base->AddItem(Decrypt_text (/*CQCProne*/ "P^P]|{r"),OnOff,&CQCProne,2);
				Base->AddItem(Decrypt_text (/*Invisible*/ "V{ƒv€voyr"),OnOff,&Invisible,2);
			}
			Base->AddFolder(Decrypt_text (/*Weapon Hacks*/ "drn}|{-Unpx€"),OpenClose,&WEAPONFOLDER,2);
			if(WEAPONFOLDER)
			{
				Base->AddItem(Decrypt_text (/*NoReload*/ "[|_ry|nq"), OnOff, &NoReload,2);
				Base->AddItem(Decrypt_text (/*NoDelay*/ "[|Qryn†"), OnOff, &NoDelay,2);
				Base->AddItem(Decrypt_text (/*NoRecoil*/ "[|_rp|vy"), OnOff, &NoRecoil,2);
				Base->AddItem(Decrypt_text (/*SuperNoSpread*/ "`‚}r[|`}rnq"), OnOff, &SuperNoSpread,2);
				Base->AddItem(Decrypt_text (/*NoSpread*/ "[|`}rnq"), OnOff, &NoSpread,2);
				Base->AddItem(Decrypt_text (/*BoneShot*/ "O|{r`u|"), OnOff, &BoneShot,2);
				Base->AddItem(Decrypt_text (/*BreakLimit*/ "OrnxYvzv"), OnOff, &BreakLimit,2);
				Base->AddItem(Decrypt_text (/*Fast Lock On*/ "Sn€-Y|px-\{"), OnOff, &FastLockOn,2);
				Base->AddItem(Decrypt_text (/*Fast Nade Blast*/ "Sn€-[nqr-Oyn€"), OnOff, &FastNadeBlast,2);
				Base->AddItem(Decrypt_text (/*Crazy Nade*/ "Pn‡†-[nqr"),OnOff,&CrazyNade,2);
				Base->AddItem(Decrypt_text (/*S.T.W.*/ "`;a;d;"),OnOff, &STW,2);
				Base->AddItem(Decrypt_text (/*Unlimited Ammo*/ "b{yvzvrq-Nzz|"),OnOff,&UnlAmmo,2);		
			}
			Base->AddFolder(Decrypt_text (/*Weapon Binder*/ "drn}|{-Ov{qr"),OpenClose,&WBINDERFOLDER,2);
			if(WBINDERFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Choose Class*/ "Pu||€r-Pyn€€"), pClass, &var[1], 6);
				Base->AddItem(Decrypt_text (/*Slot 1*/ "`y|->"), WeaponArray, &var[2], 2003);
				Base->AddItem(Decrypt_text (/*Slot 2*/ "`y|-?"), WeaponArray, &var[3], 2003);
				Base->AddItem(Decrypt_text (/*Slot 3*/ "`y|-@"), WeaponArray, &var[4], 2003);
				Base->AddItem(Decrypt_text (/*Slot 4*/ "`y|-A"), WeaponArray, &var[5], 2003);
				Base->AddItem(Decrypt_text (/*Slot 5*/ "`y|-B"), WeaponArray, &var[6], 2003);
				Base->AddItem(Decrypt_text (/*Slot 6*/ "`y|-C"), WeaponArray, &var[7], 2003);
				Base->AddItem(Decrypt_text (/*Slot 7*/ "`y|-D"), WeaponArray, &var[8], 2003);
				Base->AddItem(Decrypt_text (/*Slot 8*/ "`y|-E"), WeaponArray, &var[9], 2003);
			}
			Base->AddFolder(Decrypt_text (/*Server Hacks*/ "`rƒr-Unpx€"),OpenClose,&SERVERFOLDER,2);
			if(SERVERFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Enable 5. Slot*/ "R{noyr-B;-`y|"), OnOff, &SLOT5,2);
				Base->AddItem(Decrypt_text (/*Enable 6. Slot*/ "R{noyr-C;-`y|"), OnOff, &SLOT6,2);
				Base->AddItem(Decrypt_text (/*Enable 7. Slot*/ "R{noyr-D;-`y|"), OnOff, &SLOT7,2);
				Base->AddItem(Decrypt_text (/*Enable 8. Slot*/ "R{noyr-E;-`y|"), OnOff, &SLOT8,2);
				Base->AddItem(Decrypt_text (/*GM Warning*/ "TZ-dn{v{t"),setGM,&GMWarning,2);
			}
			Base->AddFolder(Decrypt_text (/*Zombie Hacks*/ "g|zovr-Unpx€"),OpenClose,&ZOMBIEFOLDER,2);
			if(ZOMBIEFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Zombie OPK*/ "g|zovr-\]X"),setZOPK, &ZombieOPK,2);
			}
			Base->AddFolder(Decrypt_text (/*User Hacks*/ "b€r-Unpx€"),OpenClose,&USERFOLDER,2);
			if(USERFOLDER)
			{
				Base->AddCategory(Decrypt_text (/*Select User*/ "`ryrp-b€r"),setUser, &SelectUser,33);
				if(SelectUser)
				{
				Base->AddItem(Decrypt_text (/*Kill User*/ "Xvyy-b€r"),OnOff, &KillUser,2);
				Base->AddItem(Decrypt_text (/*Follow User*/ "S|yy|„-b€r"),OnOff, &FollowUser,2);
				}
			}
			Base->AddFolder(Decrypt_text (/*Fast Hacks*/ "Sn€-Unpx€"),OpenClose,&FASTFOLDER,2);
			if(FASTFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Fast Ammo*/ "Sn€-Nzz|"), OnOff, &FastAmmo,2);
				Base->AddItem(Decrypt_text (/*Fast Health*/ "Sn€-Urnyu"), OnOff, &FastHealth,2);
				Base->AddItem(Decrypt_text (/*Fast Flag*/ "Sn€-Synt"), OnOff, &FastFlag,2);
				Base->AddItem(Decrypt_text (/*Fast Repair*/ "Sn€-_r}nv"), OnOff, &FastRepair,2);
			}
			Base->AddFolder(Decrypt_text (/*Teleport Hacks*/ "aryr}|-Unpx€"),OpenClose,&TPFOLDER,2);
			if(TPFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Dotonbori A*/ "Q||{o|v-N"), F5, &DotonboriA,2);
				Base->AddItem(Decrypt_text (/*Dotonbori B*/ "Q||{o|v-O"), F6, &DotonboriB,2);
				Base->AddItem(Decrypt_text (/*Marien A*/ "Znvr{-N"), F5, &MarienA,2);
				Base->AddItem(Decrypt_text (/*Marien B*/ "Znvr{-O"), F6, &MarienB,2);
				Base->AddItem(Decrypt_text (/*Velruf A*/ "cry‚s-N"), F5, &VelrufA,2);
				Base->AddItem(Decrypt_text (/*Velruf B*/ "cry‚s-O"), F6, &VelrufB,2);
				Base->AddItem(Decrypt_text (/*Bloc A*/ "Oy|p-N"), F5, &BlocA,2);
				Base->AddItem(Decrypt_text (/*Bloc B*/ "Oy|p-O"), F6, &BlocB,2);
				Base->AddItem(Decrypt_text (/*Khali A*/ "Xunyv-N"), F5, &KhaliA,2);
				Base->AddItem(Decrypt_text (/*Khali B*/ "Xunyv-O"), F6, &KhaliB,2);
				Base->AddItem(Decrypt_text (/*Xauen A*/ "en‚r{-N"), F5, &XauenA,2);
				Base->AddItem(Decrypt_text (/*Xauen B*/ "en‚r{-O"), F6, &XauenB,2);
				Base->AddItem(Decrypt_text (/*Khyber A*/ "Xu†or-N"), F5, &KhyberA,2);
				Base->AddItem(Decrypt_text (/*Khyber B*/ "Xu†or-O"), F6, &KhyberB,2);
				Base->AddItem(Decrypt_text (/*Artifact A*/ "Nvsnp-N"), F5, &ArtifactA,2);
				Base->AddItem(Decrypt_text (/*Artifact B*/ "Nvsnp-O"), F6, &ArtifactB,2);
				Base->AddItem(Decrypt_text (/*Beringia A*/ "Orv{tvn-N"), F5, &BeringiaA,2);
				Base->AddItem(Decrypt_text (/*Beringia B*/ "Orv{tvn-O"), F6, &BeringiaB,2);
				Base->AddItem(Decrypt_text (/*Decay A*/ "Qrpn†-N"), F5, &DecayA,2);
				Base->AddItem(Decrypt_text (/*Decay B*/ "Qrpn†-O"), F6, &DecayB,2);
			}
			Base->AddFolder(Decrypt_text (/*Bot Hacks*/ "O|-Unpx€"),OpenClose,&BOTFOLDER,2);
			if(BOTFOLDER)
			{
				Base->AddItem(Decrypt_text (/*Auto Start / Ready*/ "N‚|-`n-<-_rnq†"),OnOff, &AutoStart,2);
				Base->AddItem(Decrypt_text (/*Quick Plant*/ "^‚vpx-]yn{"),OnOff, &QuickPlant,2);
				Base->AddItem(Decrypt_text (/*Quick Defuse*/ "^‚vpx-Qrs‚€r"), OnOff, &QuickDefuse,2);
				Base->AddItem(Decrypt_text (/*Plant Any Where*/ "]yn{-N{†-durr"), OnOff, &PAD,2);
				Base->AddItem(Decrypt_text (/*Defuse Any Where*/ "Qrs‚€r-N{†-durr"), OnOff, &DAW,2);
				Base->AddItem(Decrypt_text (/*Auto Bomb*/ "N‚|-O|zo"), OnOff, &AutoBomb,2);
				Base->AddItem(Decrypt_text (/*Auto Nipper*/ "N‚|-[v}}r"), OnOff, &AutoNipper,2);
				Base->AddItem(Decrypt_text (/*Auto Plant*/ "N‚|-]yn{"),OnOff,&AutoPlant,2);
				Base->AddItem(Decrypt_text (/*Auto Defuse*/ "N‚|-Qrs‚€r"),OnOff,&AutoDefuse,2);
				Base->AddItem(Decrypt_text (/*Anti AFK Kick*/ "N{v-NSX-Xvpx"),OnOff, &AntiAFK,2);
			}
			return TRUE;
		}

float fFps = NULL;
float fLastTickCount = NULL;
float fCurrentTickCount;
char  cFrameRate[50] = {NULL};

int xTime5;
int xTime4;
int xTime3;
int xTime2;
int xTime1;


char *GetFrameRate()
{
    fCurrentTickCount = clock() * 0.001f;
    ++fFps;
    if((fCurrentTickCount - fLastTickCount) > 1.0f)
    {
        fLastTickCount = fCurrentTickCount;
		sprintf( cFrameRate, "FPS: %d", int( fFps ) );
        fFps = 0;
    }
    return cFrameRate;

} 		void D3D9Menu::Boarders(LPDIRECT3DDEVICE9 pDevice,ID3DXFont* _FontDevice, float x, float y)
		{
			DrawBox(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,GREY);
			DrawRectangle(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,1,mBLACK);
			if(MenuColor == 0){
			DrawBox(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,GREY);}
			if(BoxColor == 0){
			DrawRectangle(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,1,mBLACK);}
			if(MenuColor == 1){
			DrawBox(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,BLUE2);}
			if(BoxColor == 1){
			DrawRectangle(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,1,BLUE);}
			if(MenuColor == 2){
			DrawBox(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,RED2);}
			if(BoxColor == 2){
			DrawRectangle(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,1,RED);}
			if(MenuColor == 3){
			DrawBox(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,CYAN2);}
			if(BoxColor == 3){
			DrawRectangle(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,1,CYAN);}
			if(MenuColor == 4){
			DrawBox(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,GREEN2);}
			if(BoxColor == 4){
			DrawRectangle(pDevice,4,10,Mxofs+25,Mmax*Mysize+40,1,GREEN);}
			//if(xTime5 == 1){DrawTextC(999,800,RED,"Trial Version - [5] - Minutes Remaining",_FontDevice);}
			/*if(xTime5 == 1){*/DrawTextC(999,800,RED,"Full Version - www.CyberCheatz.com",_FontDevice);/*}*/
			if(xTime4 == 1){DrawTextC(999,800,RED,"Trial Version - [4] - Minutes Remaining",_FontDevice);}
			if(xTime3 == 1){DrawTextC(999,800,RED,"Trial Version - [3] - Minutes Remaining",_FontDevice);}
			if(xTime2 == 1){DrawTextC(999,800,RED,"Trial Version - [2] - Minutes Remaining",_FontDevice);}
			if(xTime1 == 1){DrawTextC(999,800,RED,"Trial Version - [1] - Minute Remaining",_FontDevice);}
			if(xTime5 == 0){DrawTextC(999,800,RED,"",_FontDevice);}
			if(xTime4 == 0){DrawTextC(999,800,RED,"",_FontDevice);}
			if(xTime3 == 0){DrawTextC(999,800,RED,"",_FontDevice);}
			if(xTime2 == 0){DrawTextC(999,800,RED,"",_FontDevice);}
			if(xTime1 == 0){DrawTextC(999,800,RED,"",_FontDevice);}
			DrawTextL(x+4,Mmax*Mysize+35,WHITE,GetFrameRate(), _FontDevice);
			DrawTextL(x+74,Mmax*Mysize+35,YELLOW,Decrypt_text (/*By TradEmArk*/ "O†-anqRzNx"),_FontDevice);
			if(SelectUser){Boarders2(pDevice, _FontDevice);}

		}
	void D3D9Menu::Boarders2(LPDIRECT3DDEVICE9 pDevice,ID3DXFont* _FontDevice)
	{
	DrawBox(pDevice,200,10,170,55,GREY);
	DrawRectangle(pDevice,200,10,170,55 ,1, mBLACK);
	DrawTextC(285,10,RED,Decrypt_text (/*User Infos*/ "b€r-V{s|€"),_FontDevice);
	DrawTextC(285,30,WHITE,UserNameMenu,_FontDevice);
	DrawTextC(285,50,WHITE,UserIPMenu,_FontDevice);
	}

void x_Player()
{
	DWORD PTR_PLAYER = *(DWORD*)PTR_PLAYERPTR;
	DWORD PTR_SERVER = *(DWORD*)PTR_SERVERPTR;
	if(PTR_PLAYER  != 0)
	{


	if(SuperNoSpread)
{
*(double*)MEM_SUPERNOSPREAD = 0;
}
else
{
*(double*)MEM_SUPERNOSPREAD = 5;
}
	
if ( AutoRepair )
		{
			if ( *(DWORD*)(PTR_PLAYER+PlayerAnimation) == *(DWORD*)(PlayerAnimationVehicle) )
			{
				*(BYTE*)(ADR_AUTOREPAIR) = 1;
				*(FLOAT*)(ADR_FASTREPAIR) = 14;
			}
		}


if( SuperExplosion )
{
*(float*)(ADR_SuperExplosion) = 400.0f;
}
else
{
*(float*)(ADR_SuperExplosion) = 3.7e-1;
}

		if(DotonboriA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 5745.638184;
   *(float*)(PTR_PLAYER + OFS_Y) = 8136.030273;
   *(float*)(PTR_PLAYER + OFS_Z) = 193.862152;
  }
 }
/////////////////////////////////////////////////////
if(DotonboriB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 4643.898926;
   *(float*)(PTR_PLAYER + OFS_Y) = 5909.547852;
   *(float*)(PTR_PLAYER + OFS_Z) = 204.022903;
  }
 }
/////////////////////////////////////////////////////
if(MarienA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 3653.894531;
   *(float*)(PTR_PLAYER + OFS_Y) = 2495.826416;
   *(float*)(PTR_PLAYER + OFS_Z) = 62.702488;
  }
 }
/////////////////////////////////////////////////////
if(MarienB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2666.574219;
   *(float*)(PTR_PLAYER + OFS_Y) = 3485.433105;
   *(float*)(PTR_PLAYER + OFS_Z) = 62.702488;
  }
 }
/////////////////////////////////////////////////////
if(CadoroA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 1957.290161;
   *(float*)(PTR_PLAYER + OFS_Y) = 2391.639648;
   *(float*)(PTR_PLAYER + OFS_Z) = 262.748016;
  }
 }
/////////////////////////////////////////////////////
if(CadoroB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2996.580566;
   *(float*)(PTR_PLAYER + OFS_Y) = 3690.143066;
   *(float*)(PTR_PLAYER + OFS_Z) = 280.124786;
  }
 }
/////////////////////////////////////////////////////
if(VelrufA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2941.710938;
   *(float*)(PTR_PLAYER + OFS_Y) = 4006.549561;
   *(float*)(PTR_PLAYER + OFS_Z) = 177.879547;
  }
 }
/////////////////////////////////////////////////////
if(VelrufB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2385.072510;
   *(float*)(PTR_PLAYER + OFS_Y) = 3492.060791;
   *(float*)(PTR_PLAYER + OFS_Z) = 200.987244;
  }
 }
/////////////////////////////////////////////////////
if(BlocA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2855.690674;
   *(float*)(PTR_PLAYER + OFS_Y) = 2596.960938;
   *(float*)(PTR_PLAYER + OFS_Z) = 287.452393;
  }
 }
/////////////////////////////////////////////////////
if(BlocB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2855.631836;
   *(float*)(PTR_PLAYER + OFS_Y) = 2841.132568;
   *(float*)(PTR_PLAYER + OFS_Z) = 622.006958;
  }
 }
/////////////////////////////////////////////////////
if(KhaliA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 3638.498291;
   *(float*)(PTR_PLAYER + OFS_Y) = 4668.644531;
   *(float*)(PTR_PLAYER + OFS_Z) = 942.701416;
  }
 }
/////////////////////////////////////////////////////
if(KhaliB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 4666.466309;
   *(float*)(PTR_PLAYER + OFS_Y) = 4580.945313;
   *(float*)(PTR_PLAYER + OFS_Z) = 913.796631;
  }
 }
/////////////////////////////////////////////////////
if(XauenA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 3542.612305;
   *(float*)(PTR_PLAYER + OFS_Y) = 3514.294434;
   *(float*)(PTR_PLAYER + OFS_Z) = 218.159256;
  }
 }
/////////////////////////////////////////////////////
if(XauenB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 4222.146973;
   *(float*)(PTR_PLAYER + OFS_Y) = 4240.328125;
   *(float*)(PTR_PLAYER + OFS_Z) = 201.859665;
  }
 }
/////////////////////////////////////////////////////
if(KhyberA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 3834.090088;
   *(float*)(PTR_PLAYER + OFS_Y) = 2687.793457;
   *(float*)(PTR_PLAYER + OFS_Z) = 36.671398;
  }
 }
/////////////////////////////////////////////////////
if(KhyberB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 4344.426758;
   *(float*)(PTR_PLAYER + OFS_Y) = 3644.459229;
   *(float*)(PTR_PLAYER + OFS_Z) = 117.970886;
  }
 }
/////////////////////////////////////////////////////
if(ArtifactA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2976.223633;
   *(float*)(PTR_PLAYER + OFS_Y) = 3182.355469;
   *(float*)(PTR_PLAYER + OFS_Z) = -3.568463;
  }
 }
/////////////////////////////////////////////////////
if(ArtifactB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2450.996338;
   *(float*)(PTR_PLAYER + OFS_Y) = 3358.174072;
   *(float*)(PTR_PLAYER + OFS_Z) = 128.944641;
  }
 }
/////////////////////////////////////////////////////
if(BeringiaA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 4065.145996;
   *(float*)(PTR_PLAYER + OFS_Y) = 3789.231201;
   *(float*)(PTR_PLAYER + OFS_Z) = 554.373230;
  }
 }
/////////////////////////////////////////////////////
if(BeringiaB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 3061.874756;
   *(float*)(PTR_PLAYER + OFS_Y) = 3644.541504;
   *(float*)(PTR_PLAYER + OFS_Z) = 410.848785;
  }
 }
/////////////////////////////////////////////////////
if(KaraqumA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2410.851074;
   *(float*)(PTR_PLAYER + OFS_Y) = 3254.205322;
   *(float*)(PTR_PLAYER + OFS_Z) = 1434.785034;
  }
 }
/////////////////////////////////////////////////////
if(KaraqumB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2956.465820;
   *(float*)(PTR_PLAYER + OFS_Y) = 4352.144043;
   *(float*)(PTR_PLAYER + OFS_Z) = 1481.444946;
  }
 }
/////////////////////////////////////////////////////
if(DecayA)
{
  if (GetAsyncKeyState(VK_F5)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 2678.036865;
   *(float*)(PTR_PLAYER + OFS_Y) = 3512.164551;
   *(float*)(PTR_PLAYER + OFS_Z) = 6.123757;
  }
 }
/////////////////////////////////////////////////////
if(DecayB)
{
  if (GetAsyncKeyState(VK_F6)&1)
  {
   *(float*)(PTR_PLAYER + OFS_X) = 3654.477051;
   *(float*)(PTR_PLAYER + OFS_Y) = 2941.200195;
   *(float*)(PTR_PLAYER + OFS_Z) = 129.354630;
  }
 }
/////////////////////////////////////////////////////

if( GMWarning == 1 )
{
char *gmname=(char *) (MEM_GMWARNING);
if (strlen(gmname)>2) {
char gmwarn[333];
sprintf(gmwarn, "Warning: %s » is in this Room.", MEM_GMWARNING);
}
}

if (g_pBase->pLocal) 
{
if ( ZombieOPK ) /*Light House*/
{
for(int i = 4; i < 32; i++)
{
CPlayer* pPlayer = g_pBase->pGlobal[i];
pPlayer->PosX=3318.81;
pPlayer->PosY=16.93;
pPlayer->PosZ=3148.48;
}
}
}

if ( PlayerOPK ) 
{
if (PTR_PLAYER != 0 && PTR_SERVER != 0)
for(int i = 0; i < 32; i++)
{
*(float*)(PTR_PLAYER + OFS_X) =0 ;
*(float*)(PTR_PLAYER+ OFS_Y) =0 ;
*(float*)ADR_NOBOUNDS1 = 0;
*(float*)ADR_NOBOUNDS2 = 0;
*(float*)ADR_NOBOUNDS3 = 0;
*(int*)(PTR_PLAYER + OFS_NFD) = -99999999;
CPlayer* pPlayerA = p_Player->pGlobal[i];    
pPlayerA->PosX=0;
pPlayerA->PosY=0;
pPlayerA->PosZ=0;
}
}

if( NoRecoil )
{
if(PTR_PLAYER != 0)
{
*(float*)(PTR_PLAYER + OFS_NORECOIL1) = 0;
*(float*)(PTR_PLAYER + OFS_NORECOIL2) = 0;
*(float*)(PTR_PLAYER + OFS_NORECOIL3) = 0;
}
}

if( NoSpread )
{
*(float*)(PTR_PLAYER+OFS_NOSPREAD) = 1;
}
else
{
*(float*)(PTR_PLAYER+OFS_NOSPREAD) = 0;
}

if ( NoReload )
{
if ( *(INT*)(PTR_PLAYER+OFS_WEAPONSTATE) == *(INT*)(ADR_WEAPONSTATERELOAD) )
{
*(FLOAT*)(PTR_PLAYER+OFS_NORELOAD) = 1.0F;
}
}

if ( NoDelay )
{
if(GetAsyncKeyState(VK_LBUTTON))
{
*(DWORD*)(PTR_PLAYER+OFS_NODELAY) = -1;
}
}

if ( Deadspinner )
{
*(float*)(MEM_DEADSPINNER) = 400.0f;
}
else
{
*(float*)(MEM_DEADSPINNER) = 2.0e-2;
}

if ( QuickLadderUp )
{
*(double*)(ADR_LADDERQUICKLY) = 300;
}
else
{
*(double*)(ADR_LADDERQUICKLY) = 40;
}

if( NFD )
{
*(int*)(PTR_PLAYER + OFS_NFD) = -99999999;
}

if ( SuperJump )
{
if(GetAsyncKeyState(VK_CONTROL) &1)
{
if(PTR_PLAYER != 0)
{
*(float*)(PTR_PLAYER+OFS_Z) +=175; 
}
}
}

if( NoBounds )
{
*(float*)ADR_NOBOUNDS1 = 0;
*(float*)ADR_NOBOUNDS2 = 0;
*(float*)ADR_NOBOUNDS3 = 0;
}

if( NoSpawnWait )
{
*(float*)ADR_NOSPAWNWAIT1 = 0;
*(float*)ADR_NOSPAWNWAIT2 = 0;
}

if( Stamina )
{
*(float*)ADR_STAMINA1=1000;
*(float*)ADR_STAMINA2=0;
*(float*)ADR_STAMINA3=0;
*(float*)ADR_STAMINA4=0;
*(float*)ADR_STAMINA5=1000;
}

if( WTW )
{
*(float*)(MEM_WTW) = -999;
}
else
{
*(float*)(MEM_WTW) = 6;
}

if( GlassWalls )
{
*(int*)ADR_GLASSWALLS = 4;
}
else
{
*(int*)ADR_GLASSWALLS = 0;
}

if( BoneShot )
{
if(IsShooting())
{
*(double*)(MEM_BONESHOT) = 1235;
}
else
{
*(double*)(MEM_BONESHOT) = 1.237e3;
}
}

if( STW )
{
if(IsShooting())
{
*(float*)(MEM_STW) = 999;
}
else
{
*(float*)(MEM_STW) = 6;
}
}

if( WTH )
{
if(IsShooting())
{
*(float*)(ADR_WTH) = 10;
}
else
{
*(float*)(ADR_WTH) = 0.1;
}
}

if( AntiAFK )
{
*(float*)(ADR_ANTIAFK)=1;
}

bool bChangedValue = true;
int  oldValue;

if( CQCProne )
{
int *pProne = (int *)ADR_CQCPRONE;
if( GetAsyncKeyState('C')&1 )
{
if( bChangedValue )
{
oldValue = *pProne;
bChangedValue = false;
}
*pProne = 3;
}
else{if( !bChangedValue )
{
*pProne = oldValue;
bChangedValue = true;
}
}
}

if( UnlAmmo )
{
if(IsShooting())
{
UnlAmmoP.Patch();
}
else
{
UnlAmmoP.Restore();
}
}

if( FastLockOn )
{
*(int*) ADR_FASTLOCKON = 1;
}

if( LowGravity )
{
if(PTR_PLAYER != 0)
{
*(float*)(PTR_PLAYER+OFS_LOWGRAVITY) = 100.0f;
}
}

if( Dig )
{
if (GetAsyncKeyState(VK_MENU))
{
*(float*)(PTR_PLAYER+OFS_Z) = -2000;
}
}

if( Selfkill )
{
*(int*)(PTR_PLAYER+OFS_NFD) +=999999;
}

switch( Speed )
{
case 0:*(double*)ADR_SPEED = 97;break;
case 1:*(double*)ADR_SPEED = 145.0f;break;
case 2:*(double*)ADR_SPEED = 350.0f;break;
case 3:*(double*)ADR_SPEED = 600.0f;break;
}

if( BreakLimit )
{
*(double*)ADR_BREAKLIMIT +=8000;
}
else
{
*(double*)ADR_BREAKLIMIT =100;
}

if( FastFlag )
{
*(float*)(ADR_FASTFLAG) = 14;
}

if( FastRepair )
{
*(float*)(ADR_FASTREPAIR) = 14;
}

if( FastAmmo )
{
*(float*)(ADR_FASTAMMO) = 99;
}

if( FastHealth )
{
*(float*)(ADR_FASTHEALTH) = 99;
}

if ( FastNadeBlast )
{
p_Player->pLocal->FastNadeBlast = -9.99e2;
}

if ( CrazyNade )
{
p_Player->pLocal->FastNadeBlast = 15.99e2;
}

if ( D3DPlayerView )
{
p_Player->pLocal->PlayerView3D = 1;
}

if ( MoonJump )
{
if ( GetAsyncKeyState ( VK_SPACE ) )
{
p_Player->pLocal->GravityY = 350.0F;
}
}

}
}
void x_Server()
{
	DWORD PTR_SERVER = *(DWORD*)PTR_SERVERPTR;
	if(PTR_SERVER != 0)
	{

if(AntiPartyProgram)
{
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY1) = 0;
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY2) = 0;
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY3) = 0;
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY4) = 0;
}

	find_weapons( );
if (var[2] > 0){ WPNget( var[1]-1,0); WPNput( var[1]-1 ,0, var[2]-1);}
if (var[3] > 0){ WPNget( var[1]-1,1); WPNput( var[1]-1,1, var[3]-1);}
if (var[4] > 0){ WPNget( var[1]-1,2); WPNput( var[1]-1,2, var[4]-1);}
if (var[5] > 0){ WPNget( var[1]-1,3); WPNput( var[1]-1,3, var[5]-1);}
if (var[6] > 0){ WPNget( var[1]-1,4); WPNput( var[1]-1,4, var[6]-1);}
if (var[7] > 0){ WPNget( var[1]-1,5); WPNput( var[1]-1,5, var[7]-1);}
if (var[8] > 0){ WPNget( var[1]-1,6); WPNput( var[1]-1,6, var[8]-1);}
if (var[9] > 0){ WPNget( var[1]-1,7); WPNput( var[1]-1,7, var[9]-1);}

if( AutoStart )
{
SetCursorPos(452,84);
Sleep(300);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
Sleep(300);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
Sleep(300);
}

static bool InviciblePatch;

if ( Invisible )
{
if (!InviciblePatch)
{
*(long*)(PTR_SERVER+OFS_INVISIBLE) -= 2;
InviciblePatch = true;
}
}
else
{
if (InviciblePatch)
{
*(long*)(PTR_SERVER+OFS_INVISIBLE) += 2;
InviciblePatch = false;
}
}

if(SLOT5)
{
*(int*)(PTR_SERVER + OFS_SLOT5) = 0x1;
}

if(SLOT6)
{
*(int*)(PTR_SERVER + OFS_SLOT6) = 0x1;
}

if(SLOT7)
{
*(int*)(PTR_SERVER + OFS_SLOT7) = 0x1;
}

if(SLOT8)
{
*(int*)(PTR_SERVER + OFS_SLOT8) = 0x1;
}

if( SelectUser ) 
{
int i;
DWORD UserName = NULL;
DWORD UserIP = NULL;
i = (SelectUser-1);
UserName = (0xA45804 + (0x1CF8 * i));
UserIP  = (0xA45518       + (0x1CF8 * i));
sprintf(UserNameMenu,"Name: %s",(void*)UserName);
sprintf(UserIPMenu,"IP: %s",(void*)UserIP);
}
else
{
sprintf(UserNameMenu, "User Name"); 
sprintf(UserIPMenu,   "User IP");
}
if(KillUser)
{
if(SelectUser)
{
if(g_pBase->pLocal && g_pBase->pGlobal)
{
CPlayer* pPlayer = g_pBase->pGlobal[SelectUser - 1]; 
if(pPlayer)
{
pPlayer->PosX = g_pBase->pLocal->PosX;
pPlayer->PosY = g_pBase->pLocal->PosY;
pPlayer->PosZ = g_pBase->pLocal->PosZ;
}
}
}
}

if (FollowUser)									
{
if (SelectUser)
{
if(g_pBase->pLocal && g_pBase->pGlobal)
{
CPlayer* pPlayer = g_pBase->pGlobal[SelectUser - 1];

if (pPlayer)
{
g_pBase->pLocal->PosX = pPlayer->PosX;
g_pBase->pLocal->PosY = pPlayer->PosY;
g_pBase->pLocal->PosZ = pPlayer->PosZ;
}
}
}
}

	}
}


VOID BotHacks()
{
if ( QuickPlant )
		{
			if ( WeaponTest(91) )
			{
				if ( IsShooting() )
				{
					*(float*)(QuickPlantDefuse) = 100;
				}
			}
		}
		if ( QuickDefuse )
		{
			if (WeaponTest(118) )
			{
				if (IsShooting() )
				{
					*(float*)(QuickPlantDefuse) = 100;
				}
			}
		}
		if ( PAD )
		{
			if (WeaponTest(91) )
			{
				*(BYTE*)(PlantAnyWhere) = 0x1;
			}
		}
		if ( DAW )
		{
			if(WeaponTest(118))
			{
				{
				*(BYTE*)(PlantAnyWhere) = 0x1;
				*(WORD*)(DefuseAnyWhere) = 1;
				}
			}
					if ( AutoBomb )
		{
			    p_Player->pLocal->Weapon1 = 91;
			    p_Player->pLocal->Weapon2 = 91;
				p_Player->pLocal->Weapon3 = 91;
			}
		if ( AutoNipper )
		{
				p_Player->pLocal->Weapon1 = 118;
			    p_Player->pLocal->Weapon2 = 118;
				p_Player->pLocal->Weapon3 = 118;
			}
		if ( AutoPlant )
		{
				p_Player->pLocal->WeaponState = *(INT*)(WeaponShot);
				p_Player->pLocal->AutoPlant = 1;
		}
		if ( AutoDefuse )
		{
				p_Player->pLocal->WeaponState = *(INT*)(WeaponShot);
				p_Player->pLocal->AutoDefuse = 1;
				}
		}
}

VOID AimbotHacks()
{
 DWORD PTR_PLAYER = *(DWORD*)Player;
 if ( PTR_PLAYER != 0 )
 {
 if( SeeDown ) 
{ 
p_Local->Pitch += 150; 
} 
  if ( AimBot )
  {
   NoRecoil = 1;
   if ( AimDistance )
   {
    if ( AimKey == 0 ) 
    {
     if ( AimType == 1 )
     {
      p_Local->Pitch = CalculatePitch(GetNearestPlayer());
      p_Local->Yaw = CalculateYaw(GetNearestPlayer());
     }
     if ( AimType == 2 )
     {
      p_Local->Pitch = CalculatePitch(GetCrossHairPlayer());
      p_Local->Yaw = CalculateYaw(GetCrossHairPlayer());
     }
    }
    if ( AimKey == 1 ) 
    {
     if ( GetAsyncKeyState ( VK_RBUTTON ) )
     {
      if ( AimType == 1 )
      {
       p_Local->Pitch = CalculatePitch(GetNearestPlayer());
       p_Local->Yaw = CalculateYaw(GetNearestPlayer());
      }
      if ( AimType == 2 )
      {
       p_Local->Pitch = CalculatePitch(GetCrossHairPlayer());
       p_Local->Yaw = CalculateYaw(GetCrossHairPlayer());
      }
     }
    }
	    if ( AimKey == 2 ) 
    {
     if ( GetAsyncKeyState ( VK_LBUTTON ) )
     {
      if ( AimType == 1 )
      {
       p_Local->Pitch = CalculatePitch(GetNearestPlayer());
       p_Local->Yaw = CalculateYaw(GetNearestPlayer());
      }
      if ( AimType == 2 )
      {
       p_Local->Pitch = CalculatePitch(GetCrossHairPlayer());
       p_Local->Yaw = CalculateYaw(GetCrossHairPlayer());
      }
     }
    }
    if ( AimKey == 3 ) 
    {
     if ( GetAsyncKeyState ( VK_MENU ) )
     {
      if ( AimType == 1 )
      {
       p_Local->Pitch = CalculatePitch(GetNearestPlayer());
       p_Local->Yaw = CalculateYaw(GetNearestPlayer());
      }
      if ( AimType == 2 )
      {
       p_Local->Pitch = CalculatePitch(GetCrossHairPlayer());
       p_Local->Yaw = CalculateYaw(GetCrossHairPlayer());
      }
     }
    }
   }
  }
 }
}

HRESULT WINAPI myReset (LPDIRECT3DDEVICE9 pDevice, D3DPRESENT_PARAMETERS* pPresentationParameters )
{
	_FontDevice->OnLostDevice();
	HRESULT hRet = pReset(pDevice, pPresentationParameters);
	_FontDevice->OnResetDevice();

    return hRet;
}

HRESULT WINAPI myPresent (LPDIRECT3DDEVICE9 pDevice, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
{
	if( !Create )
	{
		D3DXCreateFont(pDevice, 14,0, FW_BOLD, 1, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Arial", &_FontDevice);
	Create = true;
	}

	if( _FontDevice == NULL ) {
		_FontDevice->OnLostDevice();
	} else {

	if(Base == NULL)
	{
		Base = new D3D9Menu(Decrypt_text (/*TradEmArk VIP*/ "anqRzNx-cV]"));
	} else {
		if(Base->Mmax ==0)xRebuildMenu();
		Base->MenuShow(xMenu,yMenu,_FontDevice,pDevice);
		Base->MenuNav();
	}
  	if(EspOnOff)
   {
  DWORD PTR_PLAYER = *(DWORD*)Player;
 if ( PTR_PLAYER != 0 )
 {
  for (INT MaxPlayer = 0; MaxPlayer < 32; MaxPlayer++)
        {
   D3DXVECTOR3 PlayerView(p_Player->pGlobal[MaxPlayer]->ViewX,p_Player->pGlobal[MaxPlayer]->ViewY,p_Player->pGlobal[MaxPlayer]->ViewZ),EspView; 
         if(GetScreenCoordFromWorld(pDevice,EspView,PlayerView))
         {
    if ( GetGlobalInfo(MaxPlayer)->Health > 0 )
                {
     if( EspEnemysOnly )
     {
if ( p_Player->pGlobal[MaxPlayer]->ViewX != 0 && p_Player->pGlobal[MaxPlayer]->ViewZ != 0 )
     {
      if(IsAnEnemy(MaxPlayer))
      {
      if ( NameEsp )
      {
       char chTeam[100];
       sprintf(chTeam,"Name: %s",GetGlobalInfo(MaxPlayer)->Name);
       if(GetGlobalInfo(GetLocalInfo())->Team != GetGlobalInfo(MaxPlayer)->Team)
       Base->DrawTextR(EspView.x,(EspView.y-100),RED,chTeam,_FontDevice);
       else
       Base->DrawTextR(EspView.x,(EspView.y-100),GREEN,chTeam,_FontDevice);
       EspView.y += 12;
      }
      if ( TeamEsp )
      {
       char chTeam[100];
       if ( GetGlobalInfo(MaxPlayer)->Team == 1 ) 
        sprintf(chTeam,"Team: NIU");
       else if ( GetGlobalInfo(MaxPlayer)->Team == 0 ) 
        sprintf(chTeam,"Team: DERBERAN");
       Base->DrawTextR(EspView.x,(EspView.y-100),YELLOW,chTeam,_FontDevice);
               
       EspView.y += 12;
      }
      if ( PremiumEsp )
      {
       char chPremium[100];
       if ( GetGlobalInfo(MaxPlayer)->Premium == 0 )
        sprintf(chPremium,"Premium: Free2Play");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 1 )
        sprintf(chPremium,"Premium: Bronce");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 2 )
        sprintf(chPremium,"Premium: Silver");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 3 )
        sprintf(chPremium,"Premium: Gold");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 4 )
        sprintf(chPremium,"Premium: Platinum");
         Base->DrawTextR(EspView.x,(EspView.y-100),BLUE,chPremium,_FontDevice);
       EspView.y += 12;
      }
      if ( HealthEsp )
      {
       char chHealth[100];
       sprintf(chHealth,"Health: %d ",GetGlobalInfo(MaxPlayer)->Health/10);
         Base->DrawTextR(EspView.x,(EspView.y-100),RED,chHealth,_FontDevice);
       EspView.y += 12;
      }
      if ( PingEsp )
      {
       char chPing[100];
	   sprintf(chPing,"Ping: %i",GetGlobalInfo(MaxPlayer)->Ping);
        Base->DrawTextR(EspView.x,(EspView.y-100),WHITE,chPing,_FontDevice);
       EspView.y += 12;
      }
      if ( IpEsp )
      {
       char chIp[100];
	   sprintf(chIp,"IP: %s",GetGlobalInfo(MaxPlayer)->Ip);
        Base->DrawTextR(EspView.x,(EspView.y-100),CYAN,chIp,_FontDevice);
       EspView.y += 12;
      }
      
      if ( FlagsEsp )
      {
       char chFlags[100];
	   sprintf(chFlags,"Flag: %i",GetGlobalInfo(MaxPlayer)->Flags);
         Base->DrawTextR(EspView.x,(EspView.y-100),ORANGE,chFlags,_FontDevice);
       EspView.y += 12;
      }
      if ( KillsEsp )
      {
       char chKills[100];
	   sprintf(chKills,"Kills: %i",GetGlobalInfo(MaxPlayer)->Kills);
       Base->DrawTextR(EspView.x,(EspView.y-100),PURPLE,chKills,_FontDevice);
       EspView.y += 12;
      }
      if ( DeathEsp )
      {
       char chDeaths[100];
       sprintf(chDeaths,"Deaths: %i",GetGlobalInfo(MaxPlayer)->Deaths);
       Base->DrawTextR(EspView.x,(EspView.y-100),PURPLE,chDeaths,_FontDevice);
       EspView.y += 12;
      }
      if ( ClassEsp )
      {
       char chClass[100];
       switch ( GetGlobalInfo(MaxPlayer)->Class )
       {
       case 0: sprintf(chClass,"Class: Enginer"); break;
        case 1: sprintf(chClass,"Class: Medic"); break;
        case 2: sprintf(chClass,"Class: Sniper"); break;
        case 3: sprintf(chClass,"Class: Assault"); break;
        case 4: sprintf(chClass,"Class: Heavy Trooper"); break;
       }
       Base->DrawTextR(EspView.x,(EspView.y-100),PINK,chClass,_FontDevice);
       EspView.y += 12;
      }
     }
}}
     else
     {

     if ( p_Player->pGlobal[MaxPlayer]->ViewX != 0 && p_Player->pGlobal[MaxPlayer]->ViewZ != 0 )
     {
      if ( NameEsp )
      {
       char chTeam[100];
       sprintf(chTeam,"Name: %s",GetGlobalInfo(MaxPlayer)->Name);
       if(GetGlobalInfo(GetLocalInfo())->Team != GetGlobalInfo(MaxPlayer)->Team)
       Base->DrawTextR(EspView.x,(EspView.y-100),RED,chTeam,_FontDevice);
       else
       Base->DrawTextR(EspView.x,(EspView.y-100),GREEN,chTeam,_FontDevice);
       EspView.y += 12;
      }
      if ( TeamEsp )
      {
       char chTeam[100];
       if ( GetGlobalInfo(MaxPlayer)->Team == 1 ) 
        sprintf(chTeam,"Team: NIU");
       else if ( GetGlobalInfo(MaxPlayer)->Team == 0 ) 
        sprintf(chTeam,"Team: DERBERAN");
       Base->DrawTextR(EspView.x,(EspView.y-100),YELLOW,chTeam,_FontDevice);
               
       EspView.y += 12;
      }
      if ( PremiumEsp )
      {
       char chPremium[100];
       if ( GetGlobalInfo(MaxPlayer)->Premium == 0 )
		sprintf(chPremium,"Premium: Free2Play");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 1 )
        sprintf(chPremium,"Premium: Bronce");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 2 )
        sprintf(chPremium,"Premium: Silver");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 3 )
        sprintf(chPremium,"Premium: Gold");
       else if ( GetGlobalInfo(MaxPlayer)->Premium == 4 )
        sprintf(chPremium,"Premium: Platinum");
         Base->DrawTextR(EspView.x,(EspView.y-100),BLUE,chPremium,_FontDevice);
       EspView.y += 12;
      }
      if ( HealthEsp )
      {
       char chHealth[100];
	   sprintf(chHealth,"Health: %d ",GetGlobalInfo(MaxPlayer)->Health/10);
         Base->DrawTextR(EspView.x,(EspView.y-100),RED,chHealth,_FontDevice);
       EspView.y += 12;
      }
      if ( PingEsp )
      {
       char chPing[100];
	   sprintf(chPing,"Ping: %i",GetGlobalInfo(MaxPlayer)->Ping);
        Base->DrawTextR(EspView.x,(EspView.y-100),WHITE,chPing,_FontDevice);
       EspView.y += 12;
      }
      if ( IpEsp )
      {
       char chIp[100];
       sprintf(chIp,"IP: %s",GetGlobalInfo(MaxPlayer)->Ip);
        Base->DrawTextR(EspView.x,(EspView.y-100),CYAN,chIp,_FontDevice);
       EspView.y += 12;
      }

      if ( FlagsEsp )
      {
       char chFlags[100];
       sprintf(chFlags,"Flag: %i",GetGlobalInfo(MaxPlayer)->Flags);
         Base->DrawTextR(EspView.x,(EspView.y-100),ORANGE,chFlags,_FontDevice);
       EspView.y += 12;
      }
      if ( KillsEsp )
      {
       char chKills[100];
       sprintf(chKills,"Kills: %i",GetGlobalInfo(MaxPlayer)->Kills);
       Base->DrawTextR(EspView.x,(EspView.y-100),PURPLE,chKills,_FontDevice);
       EspView.y += 12;
      }
      if ( DeathEsp )
      {
       char chDeaths[100];
       sprintf(chDeaths,"Deaths: %i",GetGlobalInfo(MaxPlayer)->Deaths);
       Base->DrawTextR(EspView.x,(EspView.y-100),PURPLE,chDeaths,_FontDevice);
       EspView.y += 12;
      }
      if ( ClassEsp )
      {
       char chClass[100];
       switch ( GetGlobalInfo(MaxPlayer)->Class )
       {
       case 0: sprintf(chClass,"Class: Enginer"); break;
        case 1: sprintf(chClass,"Class: Medic"); break;
        case 2: sprintf(chClass,"Class: Sniper"); break;
        case 3: sprintf(chClass,"Class: Assault"); break;
        case 4: sprintf(chClass,"Class: Heavy Trooper"); break;
       }
       Base->DrawTextR(EspView.x,(EspView.y-100),PINK,chClass,_FontDevice);
       EspView.y += 12;
	DWORD dwDrawIndexedPrimitive = GetAddressPtr(82);
if(memcmp((void*)dwDrawIndexedPrimitive,(void*)(PBYTE)"\x8B\xFF",2)== 0){
	{
pDrawIndexedPrimitive = (oDrawIndexedPrimitive)BADetour((DWORD)myDrawIndexedPrimitive,(DWORD),5);	
	}
}   
      }
     }
    } 
   }
  }
  }
  }
  }
  }

return pPresent(pDevice,pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion);
}

HRESULT GenerateTexture(IDirect3DDevice9 *pD3Ddev, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
{
	if(FAILED(pD3Ddev->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, ppD3Dtex, NULL)))
	return E_FAIL;

	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;    
	(*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
	WORD *pDst16 = (WORD*)d3dlr.pBits;
	for(int xy=0; xy < 8*8; xy++)
	*pDst16++ = colour16;
	(*ppD3Dtex)->UnlockRect(0);
	return S_OK;
}

#define Whites         D3DCOLOR_ARGB(255,200,200,200) 
#define Reds            D3DCOLOR_ARGB(255,255,0,0) 
#define Redss      D3DCOLOR_ARGB(255,200,0,0) 
#define Greens          D3DCOLOR_ARGB(255,0,255,0)
#define Blues           D3DCOLOR_ARGB(255,0,0,255)
#define MediumBlues     D3DCOLOR_ARGB(255,55,100,250)
#define Blacks         D3DCOLOR_ARGB(255,0,0,0)
#define Purples         D3DCOLOR_ARGB(255,125,0,255)
#define Greys           D3DCOLOR_ARGB(255,128,128,128)
#define Grey2s          D3DCOLOR_ARGB(255,230,230,230)
#define Yellows         D3DCOLOR_ARGB(255,255,255,0)
#define Oranges         D3DCOLOR_ARGB(255,255,140,0)
#define Cyans           D3DCOLOR_ARGB(255,0,139,200)
#define Cyan2s           D3DCOLOR_ARGB(255,0,130,230)
#define Pinks           D3DCOLOR_ARGB(255,255,192,203)
#define LightBlues      D3DCOLOR_ARGB(255, 66, 180, 210)
#define Transparents    D3DCOLOR_ARGB(115, 128, 128, 128)

HRESULT WINAPI myDrawIndexedPrimitive(LPDIRECT3DDEVICE9 pDevice, D3DPRIMITIVETYPE Type, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount)
{
	_asm pushad;
	if(pDevice->GetStreamSource(0, &Stream, &Offset, &m_Stride) == D3D_OK)
	{
		Stream->Release();
	}

		if(Color)
	{
		GenerateTexture(pDevice, &aRed,		Reds);
		GenerateTexture(pDevice, &aYellow,	Yellows);
		GenerateTexture(pDevice, &aGreen,	Greens);
		GenerateTexture(pDevice, &aBlue,	Blues);
		GenerateTexture(pDevice, &aPurple,	Purples);
		GenerateTexture(pDevice, &aPink,	Pinks);
		GenerateTexture(pDevice, &aOrange,	Oranges);
		GenerateTexture(pDevice, &aBlack,	Blacks);
		GenerateTexture(pDevice, &aWhite,	Whites);
		GenerateTexture(pDevice, &aGrey, 	Greys);
		GenerateTexture(pDevice, &aCyan , 	Cyans);
		Color = false;
	}
		if ( InitAimBot == FALSE )
  {
    p_Local = (CLocal*)*(DWORD*)(Angels);
    InitAimBot = TRUE;
  }
  else if ( InitAimBot == TRUE )
  {
   if ( AimBot || AimDistance || AimEnemy || AimKey || AimType )
   {
    AimDistance =3;
    AimbotHacks();
   }
  }

	//char *Colors[]= {"[OFF]","Red","Yellow","Orange","Green","Blue","Purple","Pink","Black","Grey","Cyan"};

	if(nEnable==1)
	{
				if(x_NoFog)
		{
		pDevice->SetRenderState(D3DRS_FOGENABLE, false);
		}
		if(nColorA)
		{
			if(m_Stride==36 || m_Stride==32)
			{
				if(nColorA) pDevice->SetRenderState(D3DRS_LIGHTING,false);
				if(nColorA) pDevice->SetRenderState(D3DRS_ZENABLE,false);
				if(nColorA) pDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
				if(nColorA==1){pDevice->SetTexture(0, aRed);}
				if(nColorA==2){pDevice->SetTexture(0, aYellow);}
				if(nColorA==3){pDevice->SetTexture(0, aOrange);}
				if(nColorA==4){pDevice->SetTexture(0, aGreen);}
				if(nColorA==5){pDevice->SetTexture(0, aBlue);}
				if(nColorA==6){pDevice->SetTexture(0, aPurple);}
				if(nColorA==7){pDevice->SetTexture(0, aPink);}
				if(nColorA==8){pDevice->SetTexture(0, aBlack);}
				if(nColorA==9){pDevice->SetTexture(0, aCyan);}

				pDrawIndexedPrimitive(pDevice, Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
			}
		}

		if(nColorB)
		{
				if(m_Stride==36 || m_Stride==32)
				{
				if(nColorB) pDevice->SetRenderState(D3DRS_LIGHTING, false);
				if(nColorB) pDevice->SetRenderState(D3DRS_ZENABLE, true);
				if(nColorB) pDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
				if(nColorB==1){pDevice->SetTexture(0, aRed);}
				if(nColorB==2){pDevice->SetTexture(0, aYellow);}
				if(nColorB==3){pDevice->SetTexture(0, aOrange);}
				if(nColorB==4){pDevice->SetTexture(0, aGreen);}
				if(nColorB==5){pDevice->SetTexture(0, aBlue);}
				if(nColorB==6){pDevice->SetTexture(0, aPurple);}
				if(nColorB==7){pDevice->SetTexture(0, aPink);}
				if(nColorB==8){pDevice->SetTexture(0, aBlack);}
				if(nColorB==9){pDevice->SetTexture(0, aCyan);}
				}
		}

		 if( WireFrame )
 {
  if(m_Stride == 36)
  {
 pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
  }
 }

		    if( PointMode )
{
if(m_Stride == 36) 
{
pDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_POINT); 
}
}

if(WallColor==1)
{
if(m_Stride == 40) 
{
pDevice->SetRenderState(D3DRS_ZENABLE,true);
pDevice->SetTexture( 0, aRed);
}
}

if(WallColor==2)
{
if(m_Stride == 40) 
{
pDevice->SetRenderState(D3DRS_ZENABLE,true);
pDevice->SetTexture( 0, aBlue);
}
}


if( WallColor == 3)
{
if(m_Stride == 40) 
{
pDevice->SetRenderState(D3DRS_ZENABLE,true);
pDevice->SetTexture( 0, aGreen);
}
}
		//char *Colors[]= {"[OFF]","Red","Yellow","Orange","Green","Blue","Purple","Pink","Black","Grey","Cyan"};

		if (nCross==1)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, RED, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, RED, 0, 0); 
        }

        if (nCross==2)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, YELLOW, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, YELLOW, 0, 0); 
        }

        if (nCross==3)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, ORANGE, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, ORANGE, 0, 0); 
        }
		if (nCross==3)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, GREEN, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, GREEN, 0, 0); 
        }
		if (nCross==4)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, BLUE, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, BLUE, 0, 0); 
        }
		if (nCross==5)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, PURPLE, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, PURPLE, 0, 0); 
        }
		if (nCross==6)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, PINK, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, PINK, 0, 0); 
        }
		if (nCross==7)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, BLACK, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, BLACK, 0, 0); 
        }
		if (nCross==8)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, GREY, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, GREY, 0, 0); 
        }
		if (nCross==9)
        {
                int x = ( GetSystemMetrics( 0 ) / 2);
                int y = ( GetSystemMetrics( 1 ) / 2);
                D3DRECT rec = { x - 10, y, x + 10, y + 1};
                D3DRECT rec2 = { x, y - 10, x + 1, y + 10};
                pDevice->Clear(1, &rec, D3DCLEAR_TARGET, CYAN, 0, 0); 
                pDevice->Clear(1, &rec2, D3DCLEAR_TARGET, CYAN, 0, 0); 
        }

	   if(x_GlassWall)
       {
			#define Stride5 40
			if(m_Stride==Stride5)
			{
				pDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE); 
			}
		}

		if (x_FullBright==1)
		{
			pDevice->SetRenderState(D3DRS_LIGHTING, false);
			pDevice->SetRenderState(D3DRS_AMBIENT,D3DCOLOR_ARGB(255, 255,255,255));
		}

		if (x_WallHack==1)
		{
			if(m_Stride == 36)
			{
			pDevice->SetRenderState(D3DRS_ZENABLE,false);
			}
		}
	}

	_asm popad;
	return pDrawIndexedPrimitive(pDevice, Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}

//HRESULT __stdcall InstallHook()
//{
//	HMODULE D3D9;
//	do
//	{
//		D3D9 = GetModuleHandle("d3d9.dll");
//	}
//	
//	while(!D3D9);
//
//	DWORD dwPresent = GetAddressPtr(17);
//	DWORD dwReset = GetAddressPtr(16);
//
//	pPresent	   =		(oPresent)	DetourCreateE9((DWORD)dwPresent,(DWORD)myPresent,SIZEOF_MOVEAX_JMPEAX);
//	pReset		   =		(oReset)    DetourCreateE9((DWORD)dwReset,(DWORD)myReset,SIZEOF_MOVEAX_JMPEAX);
//
//	while(1)
//	{
//	DWORD dwDrawIndexedPrimitive = GetAddressPtr(82);
//
//	if( memcmp((void*)dwDrawIndexedPrimitive,(void*)"\x8B\xFF",2)==0 )
//	{
//		pDrawIndexedPrimitive = (oDrawIndexedPrimitive) B8Detours(dwDrawIndexedPrimitive, (DWORD)myDrawIndexedPrimitive, 7); /*12*/
//	}
//	Sleep(100);
//	}
//
//	return TRUE;
//
//}
void WriteMemory(PVOID dwAdd, void *val, int bytes)
{
    DWORD d, ds;  
    VirtualProtect(dwAdd, bytes, PAGE_EXECUTE_READWRITE, &d);
    memcpy(dwAdd, val, bytes);   
    VirtualProtect(dwAdd,bytes,d,&ds);
}
DWORD MEMhotpatch(DWORD dwAddress, DWORD dwFunction)
{
    BYTE OriginalBytes[] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x8b, 0xff};
    BYTE NewBytes[] = { 0xe9, 0x00, 0x00, 0x00, 0x00, 0xeb, 0xf9};
    dwAddress -= 5;
    if (memcmp((void *)dwAddress,(void *)OriginalBytes, 7) != 0)
    {
        return 0;
    }
    *(DWORD*)(&NewBytes[1]) = (dwFunction - dwAddress) - 5;
    WriteMemory((void *)dwAddress, (void *)NewBytes, 7);
    return (dwAddress + 7);
}
VOID WINAPI Direct3DHook( ){
	HMODULE CBBase = NULL;
	for (;CBBase == NULL;Sleep(100))
	CBBase = LoadLibrary("d3d9.dll");
	DWORD* VTableS = 0;                  
	DWORD hD3D8 = (DWORD)GetModuleHandle("d3d9.dll");
	DWORD table = FindPattern(hD3D8, 0x128000, (PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86", "xx????xx????xx");
	memcpy(&VTableS, (void*)(table+2), 4);
	memcpy((void *)PresenOpCodes, (void*)VTableS[17], 7);
	memcpy((void *)ResetOpCodes, (void*)VTableS[16], 7);

	while( 1 )
	{
		if(memcmp((void*)VTableS[17],(void*)PresenOpCodes,7)==0){
			pPresent = (oPresent)	MEMhotpatch((DWORD)VTableS[17], (DWORD)myPresent);
		}
		if(memcmp((void*)VTableS[16],(void*)ResetOpCodes,7)==0){
			pReset = (oReset)	MEMhotpatch((DWORD)VTableS[16], (DWORD)myReset);
		}	
		Sleep( 1 );
	}
}

DWORD GUIDTECH()
{
	vipcheck("");


	if (GUIDstat!=0 || GUIDstat ==95)
	{

                Writelog("[TradEmArk™] >> Welcome to my VIP Hack v4");
				Writelog("[TradEmArk™] >> Your Guid is: %s",szGuid);
				Writelog("[TradEmArk™] >> Failed to Find your GUID in Database");
			    Writelog("");
				ExitProcess(0);
				MessageBoxA(NULL,"Your GUID is not Activated! More in .txt File!","GUID Error",MB_ICONSTOP);
				
	}
	else {
	
				Writelog("[TradEmArk™] >> Your Guid is: %s",szGuid);
				Writelog("[TradEmArk™] >> Your GUID is found in Database!");
				Writelog("[TradEmArk™] >> GUID got Verified");
				Writelog("[TradEmArk™] >> Have FUN with this Hack, TradEmArk™!");
				Writelog("");
	}
return 0;
}
void TimeLimit()
{
	DWORD PTR_SERVER = *(DWORD*)PTR_SERVERPTR;
	if(PTR_SERVER != 0)
	{
		if(ETimeLimit)
		{
		//xTime5 = 1;
		//Sleep(60000);
		//xTime5 = 0;
		//xTime4 = 1;
		//Sleep(60000);
		//xTime4 = 0;
		//xTime3 = 1;
		//Sleep(60000);
		//xTime3 = 0;
		//xTime2 = 1;
		//Sleep(60000);
		//xTime2 = 0;
		//xTime1 = 1;
		//Sleep(60000);
		//xTime1 = 0;
		//ShellExecute( NULL, NULL, "http://cybercheatz.com", NULL, NULL, SW_HIDE );
		//ExitProcess(0);
		}
	}
}

HRESULT APIENTRY TimeThread()
{
	for( ; ; )
	{
		TimeLimit();
		Sleep(1);
	}
	return TRUE;
}

HRESULT APIENTRY HackThread()
{
	for( ; ; )
	{
		x_Player();
		x_Server();
		AimbotHacks();
		BotHacks();
		Sleep(2);
	}
	return TRUE;
}


VOID SecurityMain()
{
	for ( ; ; )
	{
		Module->AntiDumping();
		Module->AntiOllyDbg();
		Sleep(2);
	}
}
//
//DWORD WriteMemory(PVOID dwAdress,VOID* dwValue,INT dwBytes)
//{
//DWORD dwProtect,dwProtected; 
//VirtualProtect(dwAdress,dwBytes,PAGE_EXECUTE_READWRITE,&dwProtect);
//memcpy(dwAdress,dwValue,dwBytes); 
//VirtualProtect(dwAdress,dwBytes,dwProtect,&dwProtected);
//return ( FALSE );
//}
//
//INT BypassMain()
//{
//DWORD dwEhSvc;
//do
//{
//dwEhSvc = (DWORD)GetModuleHandleA("EhSvc.dll");
//}
//while(!dwEhSvc);
//WriteMemory((VOID*)(dwEhSvc+HS_NANO_CHECK1),(PBYTE)"\xB8\x01\x00\x00\x00\xC3",6); //EHSVC NANO CHECK
//WriteMemory((VOID*)(dwEhSvc+HS_NANO_CHECK2),(PBYTE)"\xB8\x01\x00\x00\x00\xC3",6); //EHSVC NANO CHECK
//WriteMemory((VOID*)(dwEhSvc+HS_NANO_CHECK3),(PBYTE)"\xB8\x01\x00\x00\x00\xC3",6); //EHSVC NANO CHECK
//WriteMemory((VOID*)(dwEhSvc+HS_EHSVC_CRC),(PBYTE)"\xC2\x04\x00",3); // CRC CHECK
//WriteMemory((VOID*)(dwEhSvc+HS_ASM_DETECTION1),(PBYTE)"\x90\x90",2); // ASM DETECTION CHECK
//WriteMemory((VOID*)(dwEhSvc+HS_ASM_DETECTION2),(PBYTE)"\x90\x90",2); // ASM DETECTION CHECK
//WriteMemory((VOID*)(dwEhSvc+HS_EHSVC_CRASH),(PBYTE)"\x90\x90",2); // ANTI CRASH
//return ( 0 );
//}


//BOOL WINAPI DllMain( HMODULE hDll, unsigned long Reason , LPVOID LPReserved )
//{
//switch (Reason)
//{
//case DLL_PROCESS_ATTACH : 
//			HideModule(hDll);
//			logging(hDll);
//			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)InstallHook, NULL, NULL, NULL);
//			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)TimeThread, NULL, NULL, NULL);
//			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SecurityMain, NULL, NULL, NULL);
//			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)HackThread, NULL, NULL, NULL);
//			CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)GUIDTECH, NULL, NULL, NULL);
//			ShellExecute( NULL, NULL, "http://cybercheatz.com", NULL, NULL, SW_HIDE );
//	}
//	return TRUE;
//}

bool DllMain ( HMODULE hDll, unsigned long Reason , LPVOID LPReserved )
{
switch (Reason)
{
case DLL_PROCESS_ATTACH : 

			HideModule(hDll);
			logging(hDll);

			_START(InstallHook);
			_START(TimeThread);
			_START(SecurityMain);
			_START(HackThread);
			_START(GUIDTECH);


ReadProcessMemory(GetCurrentProcess(),(LPVOID)GetProcAddress(GetModuleHandle("Kernel32"),"GetTickCount"),&opcodes,5,0);
DetourFunction((PBYTE)GetTickCount,(PBYTE)GetTickCount_Detour);
DetourFunctionWithTrampoline((PBYTE)GetThreadContext_Trampoline,(PBYTE)GetThreadContext_Detour);

break; 

case DLL_PROCESS_DETACH :

DetourRemove((PBYTE) GetThreadContext_Trampoline,(PBYTE) GetThreadContext_Detour);
WriteProcessMemory(GetCurrentProcess(),(LPVOID)GetProcAddress(GetModuleHandle("Kernel32"),"GetTickCount"),&opcodes,5,0);
if (oldHandler) SetUnhandledExceptionFilter (oldHandler);
if (oldHandler2) SetUnhandledExceptionFilter (oldHandler2);
break;
}
return (1);
}
typedef int ( *PFN_AhnEH_Callback)( long lCode, long lParamSize, void* pParam );
PFN_AhnEH_Callback pAhnEH_Callback;

HMODULE Ehsvc = GetModuleHandleA("Ehsvc.dll");
int BypassX1 = 1;
int _CallBackThread()
{
#define ADR_CallBack            0x4DFBAD
if(BypassX1)
{
	DWORD dwCode = 0;
	int myReturn = pAhnEH_Callback(dwCode, 0, NULL);
	return myReturn;
}
}
if(AntiPartyProgram)
{
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY1) = 0;
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY2) = 0;
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY3) = 0;
*(BYTE*)(PTR_SERVER+OFS_ANTIABNORMALGAMEPLAY4) = 0;
}

		if(pMenuItems.menu.bots.start)
		{
			if ( *(int*)(Serverx+LocalIndex) == *(int*)(Serverx+ImMaster) )
			{
				DWORD dwStartPtr = *(DWORD*)Room;
				if(dwStartPtr)
            	{
					dwStartPtr = *(DWORD*)(dwStartPtr+StartSize);
               		if(dwStartPtr)
                	{
						Sleep(700);
						DWORD dwStartRoom = AutoStart;
						__asm
						{
							PUSH dwStartPtr;
							CALL [dwStartRoom];
						}
					}
				}
			}
		}

			if(pMenuItems.menu.bots.ready)
			{
				GetReady();
			}

void __stdcall GetReady()
{
  DWORD PlayerPointer = *(DWORD*)ADR_PLAYERPOINTER;
  DWORD ServerPointer = *(DWORD*)ADR_SERVERPOINTER;
  if(ServerPointer != 0)
  {  

	  if(*(int*)(ServerPointer+MySize) == *(int*)(ServerPointer+ImMaster) || *(int*)((ImReady)+(GlobalIndex*(*(int*)(ServerPointer+MySize))))!=1)
    { 
	 DWORD StartRoomClassPointer = *(DWORD*)(Room);
	 DWORD GameStart = 0x50A666;
     if(StartRoomClassPointer)
     {
      StartRoomClassPointer = *(DWORD*)(StartRoomClassPointer+StartSize);
      if(StartRoomClassPointer)//
      {
		  StartRoomClassPointer = *(DWORD*)(StartRoomClassPointer+ReadySize);
       if(StartRoomClassPointer)//
       {
        Sleep(700);
		if(*(int*)(ServerPointer+MySize) == *(int*)(ServerPointer+ImMaster) ||  *(int*)((ImReady)+(GlobalIndex*(*(int*)(ServerPointer+MySize))))!=1)
        { 
         __asm
         {
          push StartRoomClassPointer;
          call [GameStart];
         }
        }
       }
      }
     }
    }
   }
  }

struct CPlayer
{
char Nano0[50236];//0x0
float NoRecoil1;//0xC43C
float NoRecoil2;//0xC440
float NoRecoil3;//0xC444
char Nano1[92];
float GravityX;//0xC4A4
float GravityY;//0xC4A8
float GravityZ;//0xC4AC
char Nano2[15658];
WORD Weapon1;//0x101DA
WORD Weapon2;//0x101DE
WORD Weapon3;//0x101E2
char Nano3[228];
float FallDamage;//0x102C8
char Nano4[20];
float PosX;//0x102E0
char Nano5[4];
float PosY;//0x102E8
char Nano6[4];
float PosZ;//0x102F0
char Nano7[228];
int m134idle;//0x103D8
char Nano8[53];
float NoReload;//0x103DD
};

if(CH_chams)

{

        pDevice->SetRenderState(D3DRS_ZENABLE,false);

        pDevice->SetRenderState(D3DRS_LIGHTING, true);

        pDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);

        pDevice->SetRenderState(D3DRS_AMBIENT, COLOR1);

        pDrawIndexedPrimitive(pDevice, pType, nMinIndex, nNumVertices, nStartIndex, nPrimitiveCount);

        pDevice->SetRenderState(D3DRS_ZENABLE,true);

        pDevice->SetRenderState(D3DRS_LIGHTING, true);

        pDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);

        pDevice->SetRenderState(D3DRS_FOGENABLE, false);

        pDevice->SetRenderState(D3DRS_AMBIENT, COLOR2);

}

  void D3D9Menu::Boarders(LPDIRECT3DDEVICE9 pDevice,ID3DXFont* pFont, float x, float y)

  {

   //Menu

   DrawBox      (pDevice,8,7, 171,21,MENUCOLOR_INSIDEBOX);

   DrawBox      (pDevice,8,28,159,Mmax*Mysize+33,MENUCOLOR_INSIDEBOX);

   DrawRectangle(pDevice,8,7, 171,21,1,MENUCOLOR_OUTSIDEBOX);

   DrawRectangle(pDevice,8,28,158,Mmax*Mysize+33,1,MENUCOLOR_OUTSIDEBOX);

            //ScrollBar

   DrawBox      (pDevice,166,28,13,Mmax*Mysize+33,MENUCOLOR_INSIDEBOX);

   DrawRectangle(pDevice,166,28,13,Mmax*Mysize+33,1,MENUCOLOR_OUTSIDEBOX);

   //Bottom

   DrawBox      (pDevice,8,Mmax*Mysize+62,171,20,MENUCOLOR_INSIDEBOX);

   DrawRectangle(pDevice,8,Mmax*Mysize+62,171,20,1,MENUCOLOR_OUTSIDEBOX);

   DrawTextC(83,Mmax*Mysize+65,Cyans,"Coded by UnknownData!",pFont);

  

  }

void D3D9Menu::MenuShow(float x, float y, ID3DXFont*  pFont1, LPDIRECT3DDEVICE9 pDevice)

{

   int i, val;

   DWORD color;

   char text[100];

   if (!Mvisible) return;

   if (Mtitle[0]) {

Boarders(pDevice,pFont1, x, y);

DrawTextC((x + 72) + 7, y + 2, MENUCOLOR_TITLE, "  Wr-Sys D3D Engine ", pFont1);

  y+=(Mysize+8);

   }

   for (i=0; i<Mmax; i++) {

     val=(MENU[i]->var)?(*MENU[i]->var):0;

     sprintf(text,  "%s", MENU[i]->txt);

     if (i==Mpos){

      color=MCOLOR_CURRENT;

      sprintf(text, "%s", MENU[i]->txt);

       DrawBox(pDevice,x+155,y,13,15,Cyans);

     }

  

     else if (MENU[i]->typ==MENUFOLDER)

      color=MCOLOR_FOLDER;

     else if (MENU[i]->typ==MENUTEXT)

      color=MCOLOR_TEXT;

     else

      color=(val)?MCOLOR_ACTIVE:MCOLOR_INACTIVE;

   //FillARGB(x-9, y, 155, 14, D3DCOLOR_ARGB( 180 , 51, 51, 51 ), pDevice );

     if (MENU[i]->opt)

     {

      if (MENU[i]->typ==MENUFOLDER){

     DrawTextL(x+3, y, color,text, pFont1);

     //y = y + 2;

      }else{

     DrawTextL(x+3, y, color,text, pFont1);

      }

     }

    

      

     if (MENU[i]->opt) {

      if (MENU[i]->typ==MENUTEXT)

       DrawTextR((x+Mxofs), y, color,(char *)MENU[i]->opt, pFont1);

      else

       DrawTextR((x+Mxofs), y, color,(char *)MENU[i]->opt[val], pFont1);

     }

     y+=Mysize;

   }

   YPOS=y;

}

HRESULT IDirect3DDevice9::GetStreamSource(
  [in]       UINT StreamNumber,
  [in, out]  IDirect3DVertexBuffer9 **ppStreamData,
  [out]      UINT *pOffsetInBytes,
  [out]      UINT *pStride
);