War Rock Cheat Programming Discussion

==========ADDYS==========
unsigned long asmCallback2  = 0x0A000;
unsigned long asmNanoScan1  = 0x3E54E;
unsigned long asmNanoScan2  = 0x3B8FF;
unsigned long asmDetection1 = 0x0A098;
unsigned long asmDetection2 = 0x2D97D;

==========SOURCE==========
pCheatTools->WriteMeMoRy((void *)( dwEhSvc + asmCallback2 ), (BYTE *)"\x74\x15",2);
pCheatTools->WriteMeMoRy((void *)( dwEhSvc + asmNanoScan1 ), (BYTE *)"\x03\xD2",2);
pCheatTools->WriteMeMoRy((void *)( dwEhSvc + asmNanoScan2 ), (BYTE *)"\xB8\x00\x00\x00\x00",5);
pCheatTools->WriteMeMoRy((void *)( dwEhSvc + asmDetection1 ), (BYTE *)"\xC2\x04\x00",3);
pCheatTools->WriteMeMoRy((void *)( dwEhSvc + asmDetection2 ), (BYTE *)"\x90\x90",2);

DWORD dwCreateRemoteThread    = (DWORD)GetProcAddress( (HMODULE)GetModuleHandleA(KERNEL32),"CreateRemoteThread");
DWORD dwCreateRemoteThreadEx  = (DWORD)GetProcAddress( (HMODULE)GetModuleHandle(KERNEL32), "CreateRemoteThreadEx");


typedef struct _PROC_THREAD_ATTRIBUTE_LIST *PPROC_THREAD_ATTRIBUTE_LIST, *LPPROC_THREAD_ATTRIBUTE_LIST;

typedef HANDLE(WINAPI* tCreateRemoteThreadEx)(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, DWORD lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, LPDWORD lpThreadId);
         tCreateRemoteThreadEx oCreateRemoteThreadEx;

typedef HANDLE(WINAPI* tCreateRemoteThread)(HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, DWORD lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId);
         tCreateRemoteThread oCreateRemoteThread;

typedef int( __cdecl* tSecureFunctionCall)(int a1, int a2, int a3);
         tSecureFunctionCall oSecureFunctionCall;


bool  bThreadTerminate  = false;
DWORD dwEhSvc,realThreadAddress,cMainStarting,cAsmThread,cThread_1,cThread_2,cThread_3,cThread_4;
BYTE ORIGINALBYTES[5];


DWORD dwAhnHS_Uninitialize_Back = NULL;
__declspec(naked) void hkAhnHS_Uninitialize()
{
	VMProtectBeginUltra("hkAhnHS_Uninitialize");
	if ( dwAhnHS_Uninitialize_Back !=0 )
	{
		__asm
		{
			push ebp
			mov ebp,esp
			push ecx
			mov dword ptr ss:[ebp-0x4],0x0
			pushad
		}

		bThreadTerminate = true;
		  
		__asm
		{
			popad
			jmp dwAhnHS_Uninitialize_Back;
		}
	}
	VMProtectEnd();
}


void FakeASMThread ( void )
{ 
	VMProtectBeginUltra("FakeASMThread");
	DWORD dwEvent = *(DWORD *)(dwEhSvc+0x12D680);
	SetEvent((HANDLE)dwEvent);
	VMProtectEnd();
	
	while(  bThreadTerminate == false )
	{
	     Sleep(1000);
	}
}

void FakeHeuristicScanThread ( void )
{
	VMProtectBeginUltra("FakeHeuristicScanThread");
	DWORD dwEvent_  = (dwEhSvc+0x12BD50);
	DWORD dwEvent__ = *(DWORD *)(dwEvent_+0xBCC);
	SetEvent((HANDLE)dwEvent__);
	VMProtectEnd();
	
	while ( bThreadTerminate == false )
	{
		Sleep(1000);
	}
}

void FakeHeuristicModulesScanThread ( void )
{
	VMProtectBeginUltra("FakeHeuristicModulesScanThread");
	DWORD dwEvent_  = *(DWORD*)(dwEhSvc+0x12E0C8);
	DWORD dwEvent__ = *(DWORD*)(dwEvent_+0xB98);
	SetEvent( (HANDLE)dwEvent__ );
	VMProtectEnd();

	while ( bThreadTerminate == false )
	{
		Sleep(1000);
	}
}


void FakeStrangeCheckScanThread ( void )
{
	VMProtectBeginUltra("FakeStrangeCheckScanThread");
	DWORD dwEvent = *(DWORD*)(dwEhSvc+0x12CE08);
	SetEvent((HANDLE)dwEvent);
	VMProtectEnd();

	while ( bThreadTerminate == false )
	{
		Sleep(1000);
	}
}

void FakeKernelTraceThread ( void )
{

}


HANDLE WINAPI hkCreateRemoteThreadEx ( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, DWORD lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList, LPDWORD lpThreadId)
{
	VMProtectBeginUltra("hkCreateRemoteThreadEx");
	if ( lpStartAddress == cMainStarting )
	{
		__asm pushad
		__asm mov esi,dword ptr ss:[esi+0x48];
		__asm mov realThreadAddress,esi;
		__asm popad

				if ( realThreadAddress == cAsmThread ) 
				{
					__asm pushad
					__asm mov edi, FakeASMThread;
					__asm mov dword ptr ss:[esi+0x48], edi;
					__asm mov dword ptr ss:[esi+0x4C], edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_1 )
				{
					__asm pushad
					__asm mov edi, FakeHeuristicScanThread;
					__asm mov dword ptr ss:[esi+0x48], edi;
					__asm mov dword ptr ss:[esi+0x4C], edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_2 )
				{
					__asm pushad
					__asm mov edi, FakeStrangeCheckScanThread;
					__asm mov dword ptr ss:[esi+0x48], edi;
					__asm mov dword ptr ss:[esi+0x4C], edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_3 )
				{
					__asm pushad
					__asm mov edi, FakeHeuristicModulesScanThread;
					__asm mov dword ptr ss:[esi+0x48], edi;
					__asm mov dword ptr ss:[esi+0x4C], edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_4 )
				{
					__asm pushad
					__asm mov edi,FakeKernelTraceThread;
					__asm mov dword ptr ss:[esi+0x48],edi;
					__asm mov dword ptr ss:[esi+0x4C], edi;
					__asm popad

					__asm pushad
					DWORD old;
					tools->VProtect((void*)(dwCreateRemoteThreadEx-0x7585),0x7590,PAGE_EXECUTE_READWRITE,&old);
					for(int i = 0; i < sizeof(ORIGINALBYTES); i++)
					{
						*(BYTE*)(dwCreateRemoteThreadEx+i) = ORIGINALBYTES[i];
					}
					tools->VProtect((void*)(dwCreateRemoteThreadEx-0x7585),0x7590,old,&old);
					__asm popad

				}
	}
    VMProtectEnd();
	return oCreateRemoteThreadEx ( hProcess, lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpAttributeList, lpThreadId);
}

HANDLE WINAPI hkCreateRemoteThread ( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, DWORD lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId)
{
	VMProtectBeginUltra("hkCreateRemoteThread");
	if ( lpStartAddress == cMainStarting )
	{
		__asm pushad
		__asm mov esi, dword ptr ss:[esi+0x48];
		__asm mov realThreadAddress,esi;
		__asm popad

				if ( realThreadAddress == cAsmThread ) 
				{
					__asm pushad
					__asm mov edi, FakeASMThread;
					__asm mov dword ptr ss:[esi+0x48],edi;
					__asm mov dword ptr ss:[esi+0x4C],edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_1 )
				{
					__asm pushad
					__asm mov edi, FakeHeuristicScanThread;
					__asm mov dword ptr ss:[esi+0x48],edi;
					__asm mov dword ptr ss:[esi+0x4C],edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_2 )
				{
					__asm pushad
					__asm mov edi, FakeStrangeCheckScanThread;
					__asm mov dword ptr ss:[esi+0x48],edi;
					__asm mov dword ptr ss:[esi+0x4C],edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_3 )
				{
					__asm pushad
					__asm mov edi, FakeHeuristicModulesScanThread;
					__asm mov dword ptr ss:[esi+0x48],edi;
					__asm mov dword ptr ss:[esi+0x4C],edi;
					__asm popad
				}

				if ( realThreadAddress == cThread_4 )
				{
					__asm pushad
					__asm mov edi,FakeKernelTraceThread;
					__asm mov dword ptr ss:[esi+0x48],edi;
					__asm mov dword ptr ss:[esi+0x4C],edi;
					__asm popad

					__asm pushad
					DWORD old;
					tools->VProtect((void*)(dwCreateRemoteThread-0x7585),0x7590,PAGE_EXECUTE_READWRITE,&old);
					for(int i = 0; i < sizeof(ORIGINALBYTES); i++)
					{
						*(BYTE*)(dwCreateRemoteThread+i) = ORIGINALBYTES[i];
					}
					tools->VProtect((void*)(dwCreateRemoteThread-0x7585),0x7590,old,&old);
					__asm popad
                }		
	}
	VMProtectEnd();
	return oCreateRemoteThread(hProcess, lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter, dwCreationFlags, lpThreadId);
}


bool InitializeHSBypass (void)
{	
	VMProtectBeginUltra("InitializeHSBypass");
	do{
	 dwEhSvc = (DWORD)GetModuleHandle(EHSVC);
	 Sleep(100);
	}while(!dwEhSvc);


	    
		cMainStarting = ((DWORD)(dwEhSvc+0xB7072));
           cAsmThread = ((DWORD)(dwEhSvc+0x2E9C0));
           cThread_1  = ((DWORD)(dwEhSvc+0x43390));
            cThread_2 = ((DWORD)(dwEhSvc+0x1A500));
			cThread_3 = ((DWORD)(dwEhSvc+0x37850));
			cThread_4 = ((DWORD)(dwEhSvc+0x19DA0));


		dwAhnHS_Uninitialize_Back = (0x7F12DA);
		tools->DetourCreate((BYTE*)0x7F12CF,(BYTE*)hkAhnHS_Uninitialize,11);

		if ( dwCreateRemoteThreadEx !=0 )
		{
			    patch->memcpy_s((void*)ORIGINALBYTES,(BYTE*)dwCreateRemoteThreadEx,5);
	            oCreateRemoteThreadEx = (tCreateRemoteThreadEx) tools->DetourCreate((BYTE*)dwCreateRemoteThreadEx,(BYTE*)hkCreateRemoteThreadEx,5);
		        return true;
		}else{
			    patch->memcpy_s((void*)ORIGINALBYTES,(BYTE*)dwCreateRemoteThread,5);
                oCreateRemoteThread = (tCreateRemoteThread)  tools->DetourCreate((BYTE*)dwCreateRemoteThread,(BYTE*)hkCreateRemoteThread,5);
				return true;
		}
}

#ifndef ADDRESS
#define ADDRESS

#pragma once


#define ADR_GAMENOTICE       0x0040EECD//***
#define ADR_GAMETEXT         0x00522CC0//***
#define ADR_DEVICEPOINTER    0xAE2B74//***
#define OFS_DEVICEPOINTER    0x2B930  
#define ADR_PLAYERPTR        0xAE92FC//*** 
#define ADR_SERVERPTR        0xAE3AC4//*** 
#define ADR_BASEPTR          0xB1BCF0//***
#define ADR_VIEWANGELS       0xAE2B70//***
#define ADR_GMALERTIP        0xB16928 + 0x10//***
#define ADR_GMALERTNAMEBASE  (ADR_GMALERTIP - 0x400)
#define ADR_GMALERTNAME      (ADR_GMALERTNAMEBASE + 0x10)
#define ADR_BACKINLOBBY      0x004E11EF
#define OFS_NOFALLDAMAGE     0x102E8  
#define OFS_PREMIUM          0x3CC    
#define OFS_PLAYERSTARE      0xC4CC   
#define OFS_SLOTS            0x9F1E4 
#define OFS_SUPERJUMP        0x10308 
#define OFS_ROOMMASTER       0x9C7E8
#define OFS_SUPERMASTER      0x9C750
#define OFS_PLAYERSLOT       0xB8368//***** 
#define ADR_SPEED            0x8C9E10//***** 
#define ADR_SPEEDROLLING     0x8C9C38//*****
#define ADR_SCOPE            0x934460//*****
#define ADR_GETBASE         ( 0xB6AC98 -  ADR_PLAYERPTR ) //******
#define ADR_NEWCBASE        ( ADR_GETBASE - 0x4  )
#define ADR_UNLOCKSWIM       0x00509C10//*****
#define ADR_SWIM1            0xADA95C //*****
#define ADR_SWIM2            0xAE933C //*****
#define ADR_INVEHICLE        0xAE9340 //*****
#define ADR_NOWATER_1        0xAF011C //*****
#define ADR_NOWATER_2        0xAF0120 //*****
#define ADR_WEAPONBASE       0xB07CE8 //******
#define ADR_SLOTBASE         0x9E040
#define ADR_PLAYERID         0xA40
#define ADR_DAMAGEAS         0x005105B0
#define ADR_UNLOXYGEN        0x00509CD2
#define ADR_PRONE            0x004F7D44
#define ADR_NOSPREAD         0x0051042C
#define ADR_NORECOIL         0x00500B8E
#define ADR_NORELOAD         0x0051C02A
#define ADR_BULLETS          0x00510696
#define ADR_BULLETSJMP       0x005106A2
#define ADR_STAMINA1         0x004575F8
#define ADR_STAMINA2         0x004F800B
#define ADR_STAMINA3         0x0050819A
#define ADR_VEHNODAMAGE      0x0042A91F
#define ADR_VEHINVISIBLE     0x0042AC8E
#define ADR_VEHSUPERFIRE1    0x004273C0
#define ADR_VEHSUPERFIRE2    0x004273EB
#define ADR_VEHSUPERFIRE3    0x0042742B
#define ADR_UNLAMMO          0x00513A0A
#define ADR_WALKTHRU         0x0076FB70
#define ADR_ANTIAFK          0x00592D17
#define ADR_QUICKSPAWN1      0x005E3249
#define ADR_QUICKSPAWN2      0x005E3263
#define ADR_FASTRELOAD1      0x0051C216
#define ADR_FASTRELOAD2      0x0059882E
#define ADR_STAMINAUP1       0x0040938E
#define ADR_STAMINAUP2       0x004093D5
#define ADR_CLIPA            0x00456646
#define ADR_CLIPS            0x0045665F
#define ADR_SNIPERPX         0x0045666D
#define ADR_COMPBANDAGE      0x004566C8
#define ADR_DEATHCAM         0x004566FA
#define ADR_ANTIFLASH        0x005A9818
#define ADR_ANTIM14          0x005A9744
#define ADR_MINEINFO1        0x00448404
#define ADR_MINEINFO2        0x00448482
#define ADR_MINEINFOFFA1     0x004483EB
#define ADR_MINEINFOFFA2     0x00448469
#define ADR_INVISIBLE        0x0050CFBC
#define ADR_RADARGPS         0x0059C874
#define ADR_RADARFFA1        0x0059C892
#define ADR_RADARFFA2        0x0059EAE6
#define ADR_NORESTRICTION    0x004F6C4F
#define ADR_AUTOSHOT         0x004F6C44
#define ADR_QUICKPLANT       0x00512E29
#define ADR_QUICKDEFUSE      0x0050EF26
#define ADR_PLANTANYWHERE    0x0057F8F8
#define ADR_BONESHOT         0x0044A575
#define ADR_AUTOHEAL1        0x00507D93
#define ADR_AUTOHEAL2        0x00508000
#define ADR_AUTOAMMO1        0x00507C8A
#define ADR_AUTOAMMO2        0x00507CCA
#define ADR_AUTOREPAIR1      0x00427446
#define ADR_AUTOREPAIR2      0x00427475
#define ADR_AUTOREPAIR3      0x004274F2
#define ADR_ANTIOVERHEART    0x00724B46
#define ADR_SHOTTHRU1        0x006041D0
#define ADR_SHOTTHRU2        0x006041D6
#define ADR_PREMCROSSCALL1   0x0057702A
#define ADR_PREMCROSSCALL2   0x00407F34
#define ADR_PREMCROSSCHANGE  0x00577050
#define ADR_PREMIUMCROSS1    0x00577172
#define ADR_PREMIUMCROSS2    0x0057717A
#define ADR_UNLOCKCROSS      0x00577385
#define ADR_OPK1             0x00408103
#define ADR_OPK2             0x0040810C
#define ADR_OPK3             0x00408118
#define ADR_ZERODELAY        0x0051BD25
#define ADR_SPAMBOT          0x0051F1F1
#define ADR_FAKEKICK         0x0058EB9B
#define ADR_USERKILL         0x00416CFC
#define ADR_ARTILLERY0       0x004F82E0
#define ADR_ARTILLERY1       0x004F8555
#define ADR_ARTILLERY2       0x00594F1E
#define ADR_ARTILLERY3       0x00594FB1
#define ADR_ARTILLERY4       0x00594CF9
#define ADR_ARTILLERY5       0x00577A01
#define ADR_ARTILLERY6       0x00594E98
#define ADR_ARTILLERY7       0x0059502E
#define ADR_VEHJUMP1         0x0045E153
#define ADR_VEHJUMP2         0x0045E15C
#define ADR_VEHJUMP3         0x8C9AA4
#define ADR_AUTOREADYSTART   0x005469B8
#define ADR_WEAPONGRAVITY    0x8C9A38
#define ADR_PLAYERSIZE       0x0B18   
#define ADR_USERNAME         0xB1C334
#define ADR_USERIP          (0xB1C1E8+0x10)
#define ADR_CHECKREADYSTART  0xB1C738
#define ADR_CLASSROOMPOINTER 0xAE9554
#define ADR_WEAPONGLOBAL1    0xB07CA8
#define ADR_WEAPONGLOBAL2    0xB5C5E8
#define ADR_FASTAMMO         0xAED90C
#define ADR_FASTMEDIC        0xAED914
#define ADR_FASTFLAG         0xAED924
#define ADR_NOBOUNDS1        0xB7AB24
#define ADR_NOBOUNDS2        0xB7AB28
#define ADR_NOBOUNDS3        0xB7AB36



#define IsReady ((ADR_CHECKREADYSTART)+(ADR_PLAYERSIZE*(*(int*)(*(DWORD*)(ADR_SERVERPTR)+OFS_PLAYERSLOT)) ))	


class CVehicle;

struct  vectorB
{
	float x,a,z,b,y,d,m,g,s;
};

struct  vectorA
{
	float x,z,y;
};


struct CPlayer
{
		char unknown0[50328]; //0x0000
	BYTE index; //0xC498  
		char unknown50329[43]; //0xC499
	CVehicle* wVehicle; //0xC4C4  
		char unknown50376[15588]; //0xC4C8
	float pitch; //0x101AC  
		char unknown65968[24]; //0x101B0
	float yaw; //0x101C8  
		char unknown65996[8]; //0x101CC
	vectorA pos;  //0x101D4  
		char unknown66008[14]; //0x101D8
	WORD weapon; //0x101EE  
		char unknown66032[92]; //0x101F0
	__int32 status; //0x1024C  
		char unknown66128[164]; //0x10250
	vectorB pos1; //0x102F4  
		char unknown66296[172]; //0x102F8
	BYTE shotting; //0x103A4  
};

struct CLocal
{
	char unknown51[32];		    //0x0000
	vectorA pos;				//0x0020
	char unknown52[36];		    //0x002C
	float pitch;				//0x0050
	float yaw;					//0x0054
	char unknown53[16];		    //0x0058
	float view_down;			//0x0068
	float view_up;				//0x006C
	float fovx;					//0x0070
	float fovy;					//0x0074
};

struct CPlayerInfo
{

		char unknown0[1288]; //0x0000
	char ip[16]; //0x0508  
		char unknown1304[300]; //0x0518
	char name[20]; //0x0644  
		char unknown1624[836]; //0x0658
	__int32 health; //0x099C  
		char unknown2464[340]; //0x09A0
	BYTE team; //0x0AF4  
		char unknown2805[13671]; //0x0AF5

};


struct  CBase
{
        CPlayer* local;           
    char unknown0[ADR_NEWCBASE];  
        CPlayer** player;        
};       

struct CWeaponInformations
{
	char _0x0000[20]; 
	char Name[25]; //0x0014 
	char _0x002D[39];
		char ShortName[4]; //0x0054 
	char _0x0058[1];
		char Animation[4]; //0x0059 
	char _0x005D[5219];
		DWORD dwDamage; //0x14C0 
	DWORD dwDefence; //0x14C4 
	DWORD dwRange; //0x14C8 
	DWORD dwAmmoNum; //0x14CC 
	DWORD dwMagazineNum; //0x14D0 
	DWORD dwEffectRange; //0x14D4
	DWORD dwParabola; //0x14D8 ?
	float ReactAmount; //0x14DC 
	float ReactRecovery; //0x14E0 
	float Accurate; //0x14E4 
	DWORD dwShotSpeed; //0x14E8 
	DWORD dwWeight; //0x14EC 
};

struct CWeaponGlobalPtr
{
	CWeaponInformations* WeaponInformations[340]; //0x0000
};

struct CWeaponGlobal
{
	char _0x0000[64];
	   CWeaponGlobalPtr* WeaponPtr; 
};

#endif

#include "cFunction.h"
#include "cAimbot.h"

cHackvar hacks;
mYcAimbot * cAimBot;

CPlayerInfo* GetPlayerInfo(int index)
{
	if ( index > 32 ) return 0;
	DWORD dwBasePointer = ADR_BASEPTR;
	DWORD dwSize        = ADR_PLAYERSIZE;
	return (CPlayerInfo*) (dwBasePointer + (index*dwSize));
}; 
    CBase *g_pBase = (CBase*)ADR_PLAYERPTR;




bool bValueStored = false;
bool oncea = false;
//  ==
D3DCOLOR UrbaESP;
D3DCOLOR UrbaDistance;
char szhealth[100];
char szDistance[100];
//  ===
DWORD OldProtection;
//  ===
bool  cSwim        = true;
//  ===
BYTE Slot5,Slot6,Slot7,Slot8;
bool  cSlot        = true;
//  ===
bool cPlayerKill   = true;
//  ===
int cWater1,cWater2;
bool cWaterB       = true;
//  ===
bool  cWepGrav     = true;
//  ===
bool cVehJump      = true;
//  ===
bool  cSpeedRoll   = true;
bool  cSpeed       = true;
//  ===
bool  cSuperMaster = true;
long  SuperMaster;
// ====
bool  cCrossHairs1 = true;
bool  cCrossHairs2 = true;
bool  cCrossHairs3 = true;
bool  cCrossHairs4 = true;
bool  cCrossHairs5 = true;
bool  cCrossHairs9 = true;
// ==
DWORD dwGame   = 0;
DWORD dwServer = 0;
// ==

DWORD *serverptr = (DWORD*)ADR_SERVERPTR;


#define MAX_WEAPONS 350

struct sWeaponsOriginalValues
{
     DWORD dwWeight;
	 DWORD dwShotSpeed;
};

sWeaponsOriginalValues weaponsOriginalValues[MAX_WEAPONS]; 

struct t_weap
{
	char unknown[12];
	int  id;
	char lname[32];
	char sname1[32];
	char sname2[32];
	char sname3[32];
	char data[5336];
};
 
struct t_slot
{
	BYTE  enab;     
	BYTE  type;   
    BYTE  id;        
	BYTE  novaule;
    char  dum1[33]; 
    char  sname[16];
    char  dum2[19]; 
    DWORD adr_weap; 
    DWORD adr_inv;   
};

struct t_invslot
{
    BYTE  enab; 
    BYTE  type;     
    BYTE  id;    
	BYTE  novaule;
    char  dum1[33];  
    char  sname[16];
    char  dum2[19];  
    DWORD adr_weap;
    DWORD adr_inv; 
};

DWORD dwADR_WEAPONBASE                    =     ADR_WEAPONBASE;
DWORD dwOFS_SLOTBASE                      =		ADR_SLOTBASE;
DWORD dwOFS_PLAYERID                      =     ADR_PLAYERID;


t_weap          *pweap[342]; 
t_slot          *pslot[8];     
t_invslot       *pinvoslot[8];
 
t_invslot *WPNinvslotadr(int pclass, int slot)
{
    return (t_invslot *)(*serverptr+dwOFS_SLOTBASE+(pclass*0x50)+(slot*0x50));
}

t_slot *WPNslotadr(int pclass, int slot)
{
    return (t_slot *)(*serverptr+dwOFS_SLOTBASE+(pclass*0x280)+(slot*0x50));
}

void WPNput(int pclass, int slot, int weappon)
{
    t_slot   *pslot;
    if (weappon<0 || pweap[weappon] == 0) return;
 
    pslot=WPNslotadr(pclass,slot);
    pslot->adr_weap=(DWORD)pweap[weappon];
    strcpy(pslot->sname, pweap[weappon]->lname);
    pslot->id = weappon;   
    pslot->type = 0x44;
    pslot->enab = 1;  
}


void find_weapons(void)
{
    DWORD *p_weapbase, *baseadr;
    t_weap *weap;
 
    for (int i=0; i<342; i++)pweap[i]=0;
    p_weapbase=(DWORD *)dwADR_WEAPONBASE;
    baseadr=(DWORD*)(*p_weapbase);
 
    for (int b=0;b<342;b++)
    {
        weap=(t_weap *)(*baseadr);
        if (weap)pweap[b]=weap;
        baseadr++;
    }
}

int WPNget(int pclass, int slot)
{
    t_slot  *pslot;
    pslot=WPNslotadr(pclass,slot);
    return pslot->id;
}



BYTE NOP           [8] = {0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
BYTE JMP           [1] = {0xEB};
BYTE RETN          [1] = {0xC3};
BYTE RETNC         [3] = {0xC2,0x0C,0x00};
BYTE ANTIM14ON     [6] = {0xE9,0xAA,0x00,0x00,0x00,0x90};
BYTE INVISIBLEON   [3] = {0x8D,0x47,0x0C};
BYTE QPLANTON      [2] = {0xEB,0x3F};
BYTE QDEFUSEON     [2] = {0xEB,0x42};
BYTE VEHFIREON     [2] = {0xEB,0x0A};
BYTE REPAIRJMP     [2] = {0xEB,0x24};
BYTE HEADON        [5] = {0xB9,0x64,0xC1,0x54,0xA5};
BYTE NEKCON        [5] = {0xB9,0x1D,0xFD,0x87,0x9F};
BYTE EXTRACLIPON   [3] = {0xB0,0x01,0x90};
BYTE STWON         [2] = {0xD9,0x40};
BYTE AUTOHEALON    [6] = {0xE9,0x3F,0x02,0x00,0x00,0x90};
BYTE CROSSSELECT1  [5] = {0xB8,0x01,0x00,0x00,0x00};
BYTE CROSSSELECT2  [5] = {0xB8,0x02,0x00,0x00,0x00};
BYTE CROSSSELECT3  [5] = {0xB8,0x03,0x00,0x00,0x00};
BYTE CROSSSELECT4  [5] = {0xB8,0x04,0x00,0x00,0x00};
BYTE CROSSSELECT5  [5] = {0xB8,0x05,0x00,0x00,0x00};
BYTE CROSSSELECT9  [5] = {0xB8,0x09,0x00,0x00,0x00};
BYTE STAMINAUPON   [3] = {0xB1,0x01,0x90};
BYTE SNIPERXON     [2] = {0xB3,0x01};
BYTE PLANTDEFON    [3] = {0xB3,0x01,0x88};
BYTE DAMAGEASPUNCH [7] = {0xB8,0x01,0x00,0x00,0x00,0x90,0x90};
BYTE DAMAGEASCOLT  [7] = {0xB8,0x07,0x00,0x00,0x00,0x90,0x90};


BYTE BULLETOFF     [6] = {0xFF,0x85,0x14,0xFF,0xFF,0xFF};
BYTE KICKASOFF     [6] = {0x8D,0x8F,0xB0,0x96,0x09,0x00};
BYTE USERKILLOFF   [6] = {0xD9,0x58,0x50,0xDB,0x45,0x28};




CPatch cProne         (ADR_PRONE,NOP,2);
CPatch cNoRecoil      (ADR_NORECOIL,RETNC,3);
CPatch cNoReload      (ADR_NORELOAD,NOP,6);
CPatch cNoSpread      (ADR_NOSPREAD,NOP,6);
CPatch cStamina1      (ADR_STAMINA1,JMP,1);
CPatch cStamina2      (ADR_STAMINA2,JMP,1);
CPatch cStamina3      (ADR_STAMINA3,JMP,1);
CPatch cVehNoDamage   (ADR_VEHNODAMAGE,RETN,1);
CPatch cVehInvisible  (ADR_VEHINVISIBLE,NOP,3);
CPatch cVehSuperFire1 (ADR_VEHSUPERFIRE1,NOP,2);
CPatch cVehSuperFire2 (ADR_VEHSUPERFIRE2,NOP,2);
CPatch cVehSuperFire3 (ADR_VEHSUPERFIRE3,VEHFIREON,2);
CPatch cVehOverHeart  (ADR_ANTIOVERHEART,NOP,4);
CPatch cUnlAmmo       (ADR_UNLAMMO,RETN,1);
CPatch cWalkThru      (ADR_WALKTHRU,NOP,3);
CPatch cAntiAfk       (ADR_ANTIAFK,JMP,1);
CPatch cQuickSpawn1   (ADR_QUICKSPAWN1,JMP,1);
CPatch cQuickSpawn2   (ADR_QUICKSPAWN2,NOP,6);
CPatch cFastReload1   (ADR_FASTRELOAD1,NOP,2);
CPatch cFastReload2   (ADR_FASTRELOAD2,NOP,2);
CPatch cMineInfo1     (ADR_MINEINFO1,NOP,6);
CPatch cMineInfo2     (ADR_MINEINFO2,NOP,6);
CPatch cMineInfoFFA1  (ADR_MINEINFOFFA1,NOP,2);
CPatch cMineInfoFFA2  (ADR_MINEINFOFFA2,NOP,2);
CPatch cAntiFlash     (ADR_ANTIFLASH,JMP,1);
CPatch cAntiM14       (ADR_ANTIM14,ANTIM14ON,6);
CPatch cInvisible     (ADR_INVISIBLE,INVISIBLEON,3);
CPatch cRadarGPS      (ADR_RADARGPS,JMP,1);
CPatch cRadarFFA1     (ADR_RADARFFA1,JMP,1);
CPatch cRadarFFA2     (ADR_RADARFFA2,JMP,1);
CPatch cNoRestriction (ADR_NORESTRICTION,NOP,6);
CPatch cQuickPlant    (ADR_QUICKPLANT,QPLANTON,2);
CPatch cQuickDefuse   (ADR_QUICKDEFUSE,QDEFUSEON,2);
CPatch cHeadShot      (ADR_BONESHOT,HEADON,5);
CPatch cNeckShot      (ADR_BONESHOT,NEKCON,5);
CPatch cAutoHeal1     (ADR_AUTOHEAL1,AUTOHEALON,6);
CPatch cAutoHeal2     (ADR_AUTOHEAL2,NOP,6);
CPatch cAutoAmmo1     (ADR_AUTOAMMO1,JMP,1);
CPatch cAutoAmmo2     (ADR_AUTOAMMO2,NOP,6);
CPatch cAutoRepair1   (ADR_AUTOREPAIR1,NOP,6);
CPatch cAutoRepair2   (ADR_AUTOREPAIR2,NOP,6);
CPatch cAutoRepair3   (ADR_AUTOREPAIR3,REPAIRJMP,2);
CPatch cExtraClipA    (ADR_CLIPA,EXTRACLIPON,3);
CPatch cExtraClipS    (ADR_CLIPS,EXTRACLIPON,3);
CPatch cPXStamina1    (ADR_STAMINAUP1,STAMINAUPON,3);
CPatch cPXStamina2    (ADR_STAMINAUP2,STAMINAUPON,3);
CPatch cDeathCam      (ADR_DEATHCAM,NOP,2);
CPatch cSnierPX       (ADR_SNIPERPX,SNIPERXON,2);
CPatch cCompBandage   (ADR_COMPBANDAGE,EXTRACLIPON,3);
CPatch cShotThru1     (ADR_SHOTTHRU1,STWON,2);
CPatch cShotThru2     (ADR_SHOTTHRU2,STWON,2);
CPatch cOPK1          (ADR_OPK1,NOP,3);
CPatch cOPK2          (ADR_OPK2,NOP,3);
CPatch cOPK3          (ADR_OPK3,NOP,2);
CPatch cZeroDelay     (ADR_ZERODELAY,NOP,2);
CPatch UnLockSwim     (ADR_UNLOCKSWIM,NOP,2);
CPatch cCrossChange   (ADR_PREMCROSSCHANGE,NOP,2);
CPatch cPremCross1    (ADR_PREMIUMCROSS1,NOP,6);
CPatch cPremCrossSel1 (ADR_PREMIUMCROSS2,CROSSSELECT1,5);
CPatch cPremCrossSel2 (ADR_PREMIUMCROSS2,CROSSSELECT2,5);
CPatch cPremCrossSel3 (ADR_PREMIUMCROSS2,CROSSSELECT3,5);
CPatch cPremCrossSel4 (ADR_PREMIUMCROSS2,CROSSSELECT4,5);
CPatch cPremCrossSel5 (ADR_PREMIUMCROSS2,CROSSSELECT5,5);
CPatch cPremCrossSel9 (ADR_PREMIUMCROSS2,CROSSSELECT9,5);
CPatch cUnLockCross   (ADR_UNLOCKCROSS,NOP,2);
CPatch cAutoShot      (ADR_AUTOSHOT,NOP,6);
CPatch cUnlOxygen     (ADR_UNLOXYGEN,NOP,2);
CPatch cPlantDef      (ADR_PLANTANYWHERE,PLANTDEFON,3);
CPatch cPunchDamage   (ADR_DAMAGEAS,DAMAGEASPUNCH,7);
CPatch cColtDamage    (ADR_DAMAGEAS,DAMAGEASCOLT,7);
CPatch cArtillery0    (ADR_ARTILLERY0,NOP,2);
CPatch cArtillery1    (ADR_ARTILLERY1,NOP,2);
CPatch cArtillery2    (ADR_ARTILLERY2,JMP,1);
CPatch cArtillery3    (ADR_ARTILLERY3,JMP,1);
CPatch cArtillery4    (ADR_ARTILLERY4,JMP,1);
CPatch cArtillery5    (ADR_ARTILLERY5,NOP,5);
CPatch cArtillery6    (ADR_ARTILLERY6,JMP,1);
CPatch cArtillery7    (ADR_ARTILLERY7,NOP,6);
CPatch cVehJump1      (ADR_VEHJUMP1,NOP,2);
CPatch cVehJump2      (ADR_VEHJUMP2,NOP,2);

void GETBACKLOBBY (void)
{  
   dwServer  =  *(DWORD*)ADR_SERVERPTR;
   if (dwServer !=0 )
   {
	   DWORD dwKickMeNow    =  *(DWORD*)(dwServer+0x996B0);
	   DWORD GetMeInLobby   =   ADR_BACKINLOBBY;

		__asm 
		{	
			  mov  eax,dwKickMeNow
			  call [GetMeInLobby]
		}
   }
}

void cHackvar :: SpamBot ( char *SpamTexting  )
{
	DWORD dwWriteChat = ADR_SPAMBOT;
    Sleep(2500);
	__asm
	{
		mov  ecx,SpamTexting 
		call dwWriteChat
	}
}


void CallCrosshair (void)
{
//	VMProtectBeginMutation("CallCrosshair");
    dwGame   = *(DWORD*)ADR_PLAYERPTR;
	if ( dwGame !=0 )
	{
		DWORD CrosshairsCall1 = ADR_PREMCROSSCALL1;
		DWORD CrosshairsCall2 = ADR_PREMCROSSCALL2;

	    cCrossChange.Patch();	

		__asm
		{
			call [CrosshairsCall2]
			mov  eax,dword ptr ds:[eax+0x30]
			call [CrosshairsCall1]
		}

		cCrossChange.Restore();
	}
//	VMProtectEnd();
}

DWORD dwBulletsJMP = NULL;
__declspec (naked) void new_bullets (void)
{
   // VMProtectBeginMutation("new_bullets");
	if ( hacks.BULLETS !=0 )
	{
		__asm
		{
			mov ecx,hacks.BULLETS
			mov dword ptr ss :[ebp-0x124],ecx
			jmp dword ptr [dwBulletsJMP]
		}
	}
  //VMProtectEnd();
}


DWORD IDKick = NULL;
DWORD fakeKickJmp = NULL;
__declspec (naked) void new_fakekick()
{
	//VMProtectBeginMutation("new_fakekick");
	if ( hacks.KICKAS !=0 )
	{
        __asm
		{ 
			    lea  ecx, dword ptr [edi+0x996B0]
		        mov  eax,IDKick
				jmp  dword ptr [fakeKickJmp] 
		}
	}
	//VMProtectEnd();
}


DWORD UserKillKJmp = NULL;
DWORD UserID = NULL;
__declspec (naked) void new_userkill(void)
{
	//VMProtectBeginMutation("new_userkill");
	if ( hacks.USERKILL !=0 && hacks.PLAYERFIND !=0 )
	{
		__asm
		{
			mov ecx,UserID
			mov dword ptr [eax+0x1C],ecx
			jmp dword ptr [UserKillKJmp]
		}
	}
	//VMProtectEnd();
}


void __cdecl GetGameNotice ( char* Text )
{
    DWORD dwGameNotice = ADR_GAMENOTICE;
	__asm
	{
		push Text
		call [dwGameNotice]
		pop  ecx
	}
}

void __cdecl PrintText ( int * UpGames , int * InChat, char *szName, BYTE *Red, BYTE *Green, BYTE *Blue )
{  
	__asm
	{
		 push    UpGames
		 push    InChat
		 push    Red
		 pop     edi
		 push    Green
		 push    Blue
		 push    szName
		 mov     esi,ADR_GAMETEXT
		 call    esi
	}
}


void cHackvar :: cAsmFunction (void)
{
        //VMProtectBeginMutation("cAsmFunction");
		// == USER KILL 
		 if ( hacks.USERKILL !=0 && hacks.PLAYERFIND !=0 )
		 {
			cPlayerKill = false;
			dwGame   = *(DWORD*)ADR_PLAYERPTR;
			if ( dwGame !=0 )
			{
				UserID = ( hacks.PLAYERFIND-1);
				CPlayerInfo *pInfo      = GetPlayerInfo (UserID);
				CPlayerInfo *pLocalInfo = GetPlayerInfo( g_pBase->local->index );
				if ( (pLocalInfo->health > 0) && ( pInfo->team != pLocalInfo->team ) && (pInfo->health > 0) && strcmp(hacks.SNAME,"Empty Slot")!=0 )
				{	
					UserKillKJmp = (ADR_USERKILL+0x6);
					tools->DetourCreate((BYTE*)ADR_USERKILL,(BYTE*)new_userkill,6);
				}else{
					patch->memcpy_s((void*)ADR_USERKILL,(BYTE*)USERKILLOFF,6);
				}
			}else{
		          patch->memcpy_s((void*)ADR_USERKILL,(BYTE*)USERKILLOFF,6);
				}
		 }else{
				if ( cPlayerKill == false )
				{
					patch->memcpy_s((void*)ADR_USERKILL,(BYTE*)USERKILLOFF,6);
					cPlayerKill = true;
				}
		 }
		// == KICK AS
		if ( hacks.KICKAS !=0  )
		{
				switch (  hacks.KICKAS )
				{
					case 1 : ( IDKick = 0x25 ); break;
					case 2 : ( IDKick = (hacks.PLAYERFIND-1)  ); break;
				}
				if (hacks.BGHOSTKICKER)
				{
					fakeKickJmp  = (ADR_FAKEKICK+0x6);
					tools->DetourCreate((BYTE*)ADR_FAKEKICK,(BYTE*)new_fakekick,6);
					hacks.BGHOSTKICKER=false;
				}
		}else{
				if (!hacks.BGHOSTKICKER)
				{  
				    patch->memcpy_s((void*)ADR_FAKEKICK,(BYTE*)KICKASOFF,6);
					hacks.BGHOSTKICKER=true;
				}
		}
		// == Artillery
		if ( hacks.ARTILLERY == 1 )
		{
				cArtillery0.Patch();
				cArtillery1.Patch();
				cArtillery2.Patch();
				cArtillery3.Patch();
				cArtillery4.Patch();
				cArtillery5.Patch();
				cArtillery6.Patch();
				cArtillery7.Patch();
		}else{
				cArtillery0.Restore();
				cArtillery1.Restore();
				cArtillery2.Restore();
				cArtillery3.Restore();
				cArtillery4.Restore();
				cArtillery5.Restore();
				cArtillery6.Restore();
				cArtillery7.Restore();
		}
	    // == WEAPON DAMAGE
		if ( hacks.WEAPONDAMAGE == 1 )
		{
			cPunchDamage.Patch();
		}
		if ( hacks.WEAPONDAMAGE == 2 )
		{
			cPunchDamage.Restore();
			cColtDamage.Patch();
		}
		if ( hacks.WEAPONDAMAGE == 0 )
		{
			cPunchDamage.Restore();
			cColtDamage.Restore();
		}
	    // == CROSSHAIR
		if ( hacks.CROSSHAIR !=0 )
		{
			cPremCross1.Patch();
			cUnLockCross.Patch();

            if ( hacks.CROSSHAIR == 1 )
			{
					if ( cCrossHairs1 == true )
					{
						cPremCrossSel1.Patch();
						CallCrosshair();
						cCrossHairs1 = false;
						cCrossHairs2 = true;
						cCrossHairs3 = true;
						cCrossHairs4 = true;
						cCrossHairs5 = true;
					}
		    }
            if ( hacks.CROSSHAIR == 2 )
			{	
					if ( cCrossHairs2 == true )
					{
						cPremCrossSel1.Restore();
						cPremCrossSel2.Patch();
						CallCrosshair();
						cCrossHairs2 = false;
						cCrossHairs5 = true;
						cCrossHairs4 = true;
						cCrossHairs3 = true;
						cCrossHairs1 = true;
					}
			}
            if ( hacks.CROSSHAIR == 3 )
			{
				if ( cCrossHairs3 == true )
				{
						cPremCrossSel2.Restore();
						cPremCrossSel3.Patch();
						CallCrosshair();
						cCrossHairs3 = false;
						cCrossHairs5 = true;
						cCrossHairs4 = true;
						cCrossHairs2 = true;
						cCrossHairs1 = true;
				}
			}
            if ( hacks.CROSSHAIR == 4 )
			{
				if ( cCrossHairs4 == true )
				{
						cPremCrossSel3.Restore();
						cPremCrossSel4.Patch();
						CallCrosshair();
						cCrossHairs4 = false;
						cCrossHairs5 = true;
						cCrossHairs3 = true;
						cCrossHairs2 = true;
						cCrossHairs1 = true;
				}
			}
            if ( hacks.CROSSHAIR == 5 )
			{
				if ( cCrossHairs5 == true )
				{
						cPremCrossSel4.Restore();
						cPremCrossSel5.Patch();
						CallCrosshair();
						cCrossHairs5 = false;
						cCrossHairs4 = true;
						cCrossHairs3 = true;
						cCrossHairs2 = true;
						cCrossHairs1 = true;
				}
			}
            if ( hacks.CROSSHAIR == 6 )
			{
				if ( cCrossHairs9 == true )
				{
						cPremCrossSel5.Restore();
						cPremCrossSel9.Patch();
						CallCrosshair();
                        cCrossHairs9 = false;
						cCrossHairs5 = true;
						cCrossHairs4 = true;
						cCrossHairs3 = true;
						cCrossHairs2 = true;
						cCrossHairs1 = true;
				}
			}

	   }else{
				if ( cCrossHairs1 == false || cCrossHairs2 == false || cCrossHairs3 == false || cCrossHairs4 == false || cCrossHairs5 == false || cCrossHairs9 == false )
				{
						cPremCross1.Restore();
						cPremCrossSel1.Restore();
						cPremCrossSel2.Restore();
						cPremCrossSel3.Restore();
						cPremCrossSel4.Restore();
						cPremCrossSel5.Restore();
						cPremCrossSel9.Restore();
						cUnLockCross.Restore();
						CallCrosshair();
						cCrossHairs1 = true;
						cCrossHairs2 = true;
						cCrossHairs3 = true;
						cCrossHairs4 = true;
						cCrossHairs5 = true;
						cCrossHairs9 = true;
				}
	    }

		if(!bValueStored)
		{
			CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
			CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

			if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
			{
					for(int i = 0; i < MAX_WEAPONS; i++)
					{
							weaponsOriginalValues[i].dwWeight = weaponPtr_1->WeaponPtr->WeaponInformations[i]->dwWeight;
							weaponsOriginalValues[i].dwWeight = weaponPtr_2->WeaponPtr->WeaponInformations[i]->dwWeight;
							weaponsOriginalValues[i].dwShotSpeed = weaponPtr_1->WeaponPtr->WeaponInformations[i]->dwShotSpeed;
weaponsOriginalValues[i].dwShotSpeed = weaponPtr_2->WeaponPtr->WeaponInformations[i]->dwShotSpeed;
							bValueStored = true;
					}
			}
		}
	    // NO WEAPON RANGE
	    if ( hacks.WEAPONRANGE == 1 )
		{
			if ( g_pBase->local )
			{ 
				CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
				CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

				if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
				{
							weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwRange = 1000000;
							weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwRange = 1000000;
				}
			}
		}
	    // EXTRA RANGE
		if ( hacks.EXTRARANGE !=0 )
		{
			if ( g_pBase->local )
			{ 
				CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
				CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

				if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
				{
					switch ( hacks.EXTRARANGE )
					{
						case 1 : 
								weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 10000;
								weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 10000;
						break;
						case 2 :
								weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 20000;
								weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 20000;
						break;
						case 3 :
					    		weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 30000;
								weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 30000;
						break;
						case 4 :
								weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 40000;
								weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 40000;
						break;
						case 5 :
								weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 1000000;
								weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwEffectRange = 1000000;
						break;
					}
				}
			}
		}
	    // == Super Weapons
		if ( hacks.WEAPONPLUS == 1 )
		{
			if ( g_pBase->local )
			{ 
				CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
				CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

				if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
				{
						weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwShotSpeed = 50000;
						weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwShotSpeed = 50000;
				}
			}
		}else{
				if ( bValueStored )
				{
					CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
					CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

					if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
					{
						for(int i = 0; i < MAX_WEAPONS; i++)
						{
							weaponPtr_1->WeaponPtr->WeaponInformations[i]->dwShotSpeed = weaponsOriginalValues[i].dwShotSpeed;
							weaponPtr_2->WeaponPtr->WeaponInformations[i]->dwShotSpeed = weaponsOriginalValues[i].dwShotSpeed;
						}
					}
				}
		}
	    // == No Weapon weight
	    if ( hacks.NOWEAPONWEIGHT == 1 )
		{
					if ( g_pBase->local )
					{ 
						CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
						CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

						if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
						{
								weaponPtr_1->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwWeight = 0;
								weaponPtr_2->WeaponPtr->WeaponInformations[g_pBase->local->weapon]->dwWeight = 0;
						}
					}
		}else{
					if ( bValueStored )
					{
						CWeaponGlobal* weaponPtr_1 = (CWeaponGlobal*)ADR_WEAPONGLOBAL1;
						CWeaponGlobal* weaponPtr_2 = (CWeaponGlobal*)ADR_WEAPONGLOBAL2;

						if ( weaponPtr_1 !=0 && weaponPtr_2 !=0 )
						{
							for(int i = 0; i < MAX_WEAPONS; i++)
							{
								weaponPtr_1->WeaponPtr->WeaponInformations[i]->dwWeight = weaponsOriginalValues[i].dwWeight;
								weaponPtr_2->WeaponPtr->WeaponInformations[i]->dwWeight = weaponsOriginalValues[i].dwWeight;
							}
						}
					}
		}
	    // == UNLIMITED OXYGEN
		if ( hacks.UNLOXYGEN == 1 )
		{
			cUnlOxygen.Patch();
		}else{
			cUnlOxygen.Restore();
		}
	    // == COMP BANDAGE 
	    if ( hacks.COMPBANDAGE == 1 )
		{
			 cCompBandage.Patch();
		}else{
			 cCompBandage.Restore();
		}
	    // == SNIPER ZOOM x2
	    if ( hacks.SZOOM == 1 )
		{
			cSnierPX.Patch();
		}else{

			cSnierPX.Restore();
		}
	    // == DEATH CAM
        if ( hacks.DTCAM == 1 )
		{
           cDeathCam.Patch();
		}else{
	      cDeathCam.Restore();
		}
	    // == SP UP
		if ( hacks.SPUP == 1 )
		{
			cPXStamina1.Patch();
			cPXStamina2.Patch();
		}else{
			cPXStamina1.Restore();
			cPXStamina2.Restore();
		}
		/*
	    // == CLAN WAR
	    if ( hacks.CLANTAG == 1 )
		{
			*(int*)(ADR_CLANTAG_1) = 1;
			*(int*)(ADR_CLANTAG_2) = 1;
			*(int*)(ADR_CLANTAG_3) = 1;
			*(int*)(ADR_CLANTAG_4) = 1;
			*(int*)(ADR_ENBLCLANCHAT) = 1;
		*/
		//	memcpy((void*)ADR_CLANNAME,/*NexonArmy*/XorStr<0x3B,10,0xBF748C35>("\x75\x59\x45\x51\x51\x01\x33\x2F\x3A"+0xBF748C35).s,9);
		//}
		
	    // == BULLETS
		if ( hacks.BULLETS !=0 )
		{
			if ( hacks.BBULLET )
			{
				dwBulletsJMP = ADR_BULLETSJMP;
				tools->DetourCreate((BYTE*)ADR_BULLETS,(BYTE*)new_bullets,6);
				hacks.BBULLET = false;
			}
		}else{
			if (!hacks.BBULLET)
			{  
				patch->memcpy_s((void*)ADR_BULLETS,BULLETOFF,6);
				hacks.BBULLET = true;
			}
		}
	    // == ZERO DELAY
	    if ( hacks.ZERODELAY == 1 )
		{
                cZeroDelay.Patch();
		}else{
			    cZeroDelay.Restore();
		}
	    // == OPK
	    if ( hacks.OPK == 1 )
		{
				cOPK1.Patch();
				cOPK2.Patch();
				cOPK3.Patch();
		}else{
				cOPK1.Restore();
				cOPK2.Restore();
				cOPK3.Restore();
		}
	    // == PRONE
		if ( hacks.PRONE == 1 )
		{
				cProne.Patch();
		}else{
				cProne.Restore();
		     }
	    // == SHOTTHRU
		if ( hacks.SHOTTHRU == 1 )
		{
			dwGame   = *(DWORD*)ADR_PLAYERPTR;
			if ( dwGame !=0 )
			{
					cShotThru1.Patch();
					cShotThru2.Patch();
			}else{
					cShotThru1.Restore();
					cShotThru2.Restore();
			}
		}else{
					cShotThru1.Restore();
					cShotThru2.Restore();
		     }
	    // == EXTRA CLIP S
		if ( hacks.EXTRACLIPS == 1 )
		{
				cExtraClipS.Patch();
		}else{
			    cExtraClipS.Restore();
		     }
	    // == EXTRA CLIP A
		if ( hacks.EXTRACLIPA == 1 )
		{
				cExtraClipA.Patch();
		}else{
			    cExtraClipA.Restore();
		     }
		// == VEH NO OVER HEART
		if ( hacks.VEHOVERHEART == 1 )
		{
			cVehOverHeart.Patch();
		}else{
            cVehOverHeart.Restore();
		}
	    // == AUTO REPAIR
		if ( hacks.AUTOREPAIR == 1 )
		{
				cAutoRepair1.Patch();
				cAutoRepair2.Patch();
				cAutoRepair3.Patch();
		}else{
			    cAutoRepair1.Restore();
			    cAutoRepair2.Restore();
			    cAutoRepair3.Restore();
		     }
	    // == AUTO AMMO
		if ( hacks.AUTOAMMO == 1 )
		{
				cAutoAmmo1.Patch();
				cAutoAmmo2.Patch();
		}else{
			    cAutoAmmo1.Restore();
			    cAutoAmmo2.Restore();
		     }
	    // == AUTO HEAL
		if ( hacks.AUTOHEAL == 1 )
		{
				cAutoHeal1.Patch();
				cAutoHeal2.Patch();
		}else{
			    cAutoHeal1.Restore();
			    cAutoHeal2.Restore();
		     }
	    // == BONE SHOT
		if ( hacks.BONESHOT == 1 )
		{
			cHeadShot.Patch();
		}
		if ( hacks.BONESHOT == 2 )
		{
            cHeadShot.Restore();
 			cNeckShot.Patch();
		}
		if ( hacks.BONESHOT == 0 )
		{
			cHeadShot.Restore();
			cNeckShot.Restore();
		}
	    // == QUICK PLANT/DEFUSE
		if ( hacks.QUICKPLANTDEFUSE == 1 )
		{
				cQuickDefuse.Patch();
				cQuickPlant.Patch();
		}else{
				cQuickDefuse.Restore();
				cQuickPlant.Restore();
		     }
		// == Plant Def Anywhere
		if ( hacks.QUICKPLANTDEFUSE == 1 && hacks.PLANTDEFUSEANYWHERE == 1 )
		{
			cPlantDef.Patch();

		}else{

			cPlantDef.Restore();
		}

		// == AUTO SHOT
		if ( hacks.AUTOSHOT == 1 )
		{
			cAutoShot.Patch();
		}else{
			cAutoShot.Restore();
		}
	    // == NO RESTRICTION
		if ( hacks.NORESTRICTION == 1 )
		{
				cNoRestriction.Patch();
		}else{
				cNoRestriction.Restore();
		     }
	    // == RADARGPS
		if ( hacks.RADAR == 1 )
		{
			dwServer = *(DWORD*)ADR_SERVERPTR;
			if ( dwServer !=0 )
			{
				DWORD dwFFA = *(DWORD*)(dwServer+0x9C5C0);
				if ( dwFFA  == 1 )
				{ 
					cRadarFFA1.Patch();
					cRadarFFA2.Patch();
				}else{
					cRadarFFA1.Restore();
					cRadarFFA2.Restore();
				}
			}
				    cRadarGPS.Patch();
		}else{
				cRadarGPS.Restore();
                cRadarFFA1.Restore();
                cRadarFFA2.Restore();
		     }
	    // == INVISIBLE
		if ( hacks.INVISIBLE == 1 )
		{
				cInvisible.Patch();
		}else{
				cInvisible.Restore();
		     }
	    // == ANTI M14
		if ( hacks.ANTIM14 == 1 )
		{
				cAntiM14.Patch();
		}else{
				cAntiM14.Restore();
		     }
	    // == ANTI FLASH
		if ( hacks.ANTIFLASH == 1 )
		{
				cAntiFlash.Patch();
		}else{
				cAntiFlash.Restore();
		     }
	    // == MINEINFO
		if ( hacks.MINEINFO == 1 )
		{
				cMineInfo1.Patch();
				cMineInfo2.Patch();
				cMineInfoFFA1.Patch();
				cMineInfoFFA2.Patch();
		}else{
				cMineInfo1.Restore();
				cMineInfo2.Restore();
				cMineInfoFFA1.Restore();
				cMineInfoFFA2.Restore();
		     }
	    // == Fast Reload
		if ( hacks.FASTRELOAD == 1 )
		{
				cFastReload1.Patch();
				cFastReload2.Patch();
		}else{
				cFastReload1.Restore();
				cFastReload2.Restore();
		     }
	    // == Quick Spawn
		if ( hacks.QUICKSPAWN == 1 )
		{
				cQuickSpawn1.Patch();
				cQuickSpawn2.Patch();
		}else{
				cQuickSpawn1.Restore();
				cQuickSpawn2.Restore();
		     }
	    // == Walk Thru
		if ( hacks.WALKTHRU == 1 )
		{
				cWalkThru.Patch();
		}else{
				cWalkThru.Restore();
		     }
	    // == ANTIAFK
		if ( hacks.ANTIAFK == 1 )
		{
				cAntiAfk.Patch();
		}else{
				cAntiAfk.Restore();
		     }
	    // == UNL AMMO
		if ( hacks.UNLAMMO == 1 )
		{
				cUnlAmmo.Patch();
		}else{
				cUnlAmmo.Restore();
		     }
	    // == VEH SUPERJUMP
		if ( hacks.VEHJUMP == 1 )
		{
				cVehJump1.Patch();
			    cVehJump2.Patch();

				if ( cVehJump == true )
				{
		     		tools->VProtect((void*)(ADR_VEHJUMP3),0x4,PAGE_EXECUTE_READWRITE,&OldProtection);
					cVehJump = false;
				}
					if ( *(DWORD*)(dwGame+OFS_PLAYERSTARE) == *(DWORD*)ADR_INVEHICLE ) 
					{
						   *(float*) (ADR_VEHJUMP3) = 0;
					}else{
						   *(float*) (ADR_VEHJUMP3) = 40;
					}
		}else{
					cVehJump1.Restore();
					cVehJump2.Restore();
				if ( cVehJump == false )
				{    
					*(float*) (ADR_VEHJUMP3) = 40;
                    tools->VProtect((void*)(ADR_VEHJUMP3),0x4,OldProtection,0);
					cVehJump = true;
				}
		}
	    // == VEH NO DAMAGE
		if ( hacks.VEHNODAMAGE == 1 )
		{
				cVehNoDamage.Patch();
		}else{
				cVehNoDamage.Restore();
		     }
	    // == VEH INVISIBLE
		if ( hacks.VEHINVISIBLE == 1 )
		{
				cVehInvisible.Patch();
		}else{
				cVehInvisible.Restore();
		     }
	    // == VEH SUPER FIRE
		if ( hacks.VEHSUPERFIRE == 1 )
		{
				cVehSuperFire1.Patch();
				cVehSuperFire2.Patch();
				cVehSuperFire3.Patch();
		}else{
				cVehSuperFire1.Restore();
				cVehSuperFire2.Restore();
				cVehSuperFire3.Restore();
		     }
	    // == STAMINA
		if ( hacks.FULLSTAMINA == 1 )
		{
				cStamina1.Patch();
				cStamina2.Patch();
				cStamina3.Patch();
		}else{
				cStamina1.Restore();
				cStamina2.Restore();
				cStamina3.Restore();
		     }
		// == NO RECOIL
		if ( hacks.NORECOIL == 1 )
		{	
				cNoRecoil.Patch();
		}else{
				cNoRecoil.Restore();
		     }
		// == NO SPREAD
		if ( hacks.NOSPREAD == 1 )
		{
				cNoSpread.Patch();
		}else{
				cNoSpread.Restore();
		     }
		// == NO RELOAD
		if ( hacks.NORELOAD == 1 )
		{
				cNoReload.Patch();
		}else{
				cNoReload.Restore();
		     }

	   // VMProtectEnd();
}

void cHackvar :: cInGameFunction (void)
{
    dwGame   = *(DWORD*)ADR_PLAYERPTR;
	if ( dwGame !=0 )
	{

		// == FOLLOW PLAYER
		if ( hacks.USERTELEPORT == 1 && hacks.PLAYERFIND !=0 )
		{ 
			CPlayerInfo * spInfo   = GetPlayerInfo(hacks.PLAYERFIND-1);
			CPlayer     * spPlayer = g_pBase->player[hacks.PLAYERFIND-1];
			if ( spInfo && spPlayer)
			{
				if ( tools->IsValidPlayer(spPlayer,spInfo) )
				{
					if ( spInfo->health > 0 )
					{
						g_pBase->local->pos1 = spPlayer->pos1;
					}
				}
			}
		}

		// == User Invisible
		if ( hacks.USERINVISIBLE == 1 && hacks.PLAYERFIND !=0 )
		{ 
			CPlayerInfo * spInfo   = GetPlayerInfo(hacks.PLAYERFIND-1);
			CPlayer     * spPlayer = g_pBase->player[hacks.PLAYERFIND-1];
			if ( spInfo && spPlayer )
			{
				if ( tools->IsValidPlayer(spPlayer,spInfo) )
			    {
					if ( spInfo->health > 0 )
					{
						spPlayer->pos1.b = 0;
						spPlayer->pos1.y = 0;
						spPlayer->pos1.d = 0;
						spPlayer->pos1.m = 0;
						spPlayer->pos1.g = 0;
						spPlayer->pos1.s = 0;
					}
				}
			}
		}
		// == TELEKILL
		if ( hacks.TELEKILL == 1 )
		{
			if (GetAsyncKeyState(VK_RBUTTON)&0x8000)
			{
				for ( int i = 0; i < 32; i++ )
				{ 
					CPlayerInfo *pInfo = GetPlayerInfo(i);
					CPlayer     *spPlayer = g_pBase->player[i];

					if ( pInfo && spPlayer )
					{
					  if ( tools->IsValidPlayer(spPlayer,pInfo) )
			          {
							CPlayerInfo *pLocalInfo = GetPlayerInfo(g_pBase->local->index);
							if( pInfo->team != pLocalInfo->team )
							{
								if( pInfo->health !=0 )
								{
									g_pBase->local->pos1 = spPlayer->pos1;
									break;
								}     
							}
					  }
					}
				}
			}
		}
		// == Zombie OPK
		if ( hacks.ZOMBIEOPK == 1 )
		{
			dwServer = *(DWORD*)ADR_SERVERPTR;
			if ( dwServer !=0 )
			{
				DWORD dwZombie = *(DWORD*)(dwServer+0x9C5C0);
				if ( dwZombie == 9 )
				{ 
					for(int i = 0; i < 32; i++)
					{
						CPlayer * pPlayer = g_pBase->player[i];
						if ( pPlayer )
						{
							g_pBase->local->pos1.b =0.0f;   //ME
							g_pBase->local->pos1.d =0.0f;   //ME
							g_pBase->local->pos1.g =0.0f;   //ME
							/*<--------------->*/
							pPlayer->pos1.b = 80.0f;        //Zombie
							pPlayer->pos1.d = 80.0f;        //Zombie
							pPlayer->pos1.g = 80.0f;        //Zombie
						}
					}
				}
			}
		}
		// == SPEED HACK
		if ( hacks.SPEED != 0 )
		{
				if ( cSpeed == true )
				{
		     		tools->VProtect((void*)(ADR_SPEED),0x8,PAGE_EXECUTE_READWRITE,&OldProtection);
					cSpeed = false;
				}
						switch ( hacks.SPEED )
						{
								case 1 :*(double*)(ADR_SPEED) = 96+10;   break;
								case 2 :*(double*)(ADR_SPEED) = 96+20;   break;
								case 3 :*(double*)(ADR_SPEED) = 96+200;  break;
								case 4 :*(double*)(ADR_SPEED) = 96+500;  break;
								case 5 :*(double*)(ADR_SPEED) = 96+1000; break;
						}
		}else{
				if ( cSpeed == false )
				{
					*(double*)(ADR_SPEED) = 96; 
					tools->VProtect((void*)(ADR_SPEED),0x8,OldProtection,0);
					cSpeed = true;
				}
		}

		// == SPEED ROLLING
		if ( hacks.SPEEDROLL != 0 )
		{
				if ( cSpeedRoll == true )
				{
		     		tools->VProtect((void*)(ADR_SPEEDROLLING),0x4,PAGE_EXECUTE_READWRITE,&OldProtection);
					cSpeedRoll = false;
				}
						switch ( hacks.SPEEDROLL )
						{
								case 1 :*(float*)(ADR_SPEEDROLLING) = 2.75;  break;
								case 2 :*(float*)(ADR_SPEEDROLLING) = 3.75;  break;
								case 3 :*(float*)(ADR_SPEEDROLLING) = 4.75;  break;
								case 4 :*(float*)(ADR_SPEEDROLLING) = 5.75;  break;
								case 5 :*(float*)(ADR_SPEEDROLLING) = 6.75;  break;
						}
		}else{
				if ( cSpeedRoll == false )
				{
					*(float*)(ADR_SPEEDROLLING) = 1.75f; 
					tools->VProtect((void*)ADR_SPEEDROLLING,0x4,OldProtection,0);
					cSpeedRoll = true;
				}
		}
	    // == QUICK ALL
		if ( hacks.FASTALL == 1 )
		{
			*(float*)(ADR_FASTFLAG)  = 20.0f;
			*(float*)(ADR_FASTMEDIC) = 15.0f;
			*(float*)(ADR_FASTAMMO)  = 15.0f;
		}

	    // ==  Weapon Gravity
		if ( hacks.WEAPNOGRAVITY == 1 )
		{
				if ( cWepGrav == true )
				{
					tools->VProtect((void*)(ADR_WEAPONGRAVITY),0x8,PAGE_EXECUTE_READWRITE,&OldProtection);
					*(double*)(ADR_WEAPONGRAVITY) = 9999; 
                    cWepGrav = false;
				}
		}else{
				if ( cWepGrav == false )
				{
					*(double*)(ADR_WEAPONGRAVITY) = 1000;
		   			tools->VProtect((void*)ADR_WEAPONGRAVITY,0x8,OldProtection,0);
					cWepGrav = true;
				}
		}
		// == SWIM
		if ( hacks.SWIM == 1 )
		{ 
				if ( *(DWORD*)(dwGame+OFS_PLAYERSTARE) != *(DWORD*)ADR_INVEHICLE ) 
				{
			 			*(DWORD*)(dwGame+OFS_PLAYERSTARE) = *(DWORD*)ADR_SWIM1;
						UnLockSwim.Patch();
						cSwim = false;

				}else{
					    cSwim = false;
				     }
		}else{
				if ( cSwim == false  )
				{
						*(DWORD*)(dwGame+OFS_PLAYERSTARE) = *(DWORD*)ADR_SWIM2;
						*(DWORD*)(dwGame+OFS_PLAYERSTARE) = *(DWORD*)(dwGame+OFS_PLAYERSTARE);
						 UnLockSwim.Restore();
						 cSwim = true;
				}
		}
		// == SUPER JUMP
		if ( hacks.SUPERJUMP == 1 )
		{
			if (GetAsyncKeyState(0x20))
			{
			   *(float*)(dwGame+OFS_SUPERJUMP) = *(float*)(dwGame+OFS_SUPERJUMP) + 35;
			}
		}
		// == NO FALL DAMAGE
		if ( hacks.NOFALL == 1 )
		{
			*(float*)(dwGame+OFS_NOFALLDAMAGE) = -9999999;
		}
		// == SCOPE		
		if ( hacks.NOSCOPE == 1 )
		{
			if (GetAsyncKeyState(0x02))
			{
                *(DWORD*)(ADR_SCOPE) = 8;

			}else{

                *(DWORD*)(ADR_SCOPE) = 5;
			}
		}
		// == NO BOUNDS
		if ( hacks.NOBOUNDS == 1 )
		{
			*(DWORD*)(ADR_NOBOUNDS1) = 0;
			*(DWORD*)(ADR_NOBOUNDS2) = 0;
			*(DWORD*)(ADR_NOBOUNDS3) = 0;

		}
		// == NO WATER
		if ( hacks.NOWATER == 1 )
		{
			if ( cWaterB == true )
			{
				cWater1 =  *(int*)(ADR_NOWATER_1);
				cWater2 =  *(int*)(ADR_NOWATER_2);
				*(int*)(ADR_NOWATER_1) = 0;
		 		*(int*)(ADR_NOWATER_2) = 0;
				cWaterB = false;
			}
		}else{
			if ( cWaterB == false )
			{
			  *(int*)(ADR_NOWATER_1) = cWater1;
		 	  *(int*)(ADR_NOWATER_2) = cWater2;
			   cWaterB = true;
			}
		}
	

	}
}

void cHackvar :: cInServerFunction (void)
{
    dwServer = *(DWORD*)ADR_SERVERPTR;
	if ( dwServer !=0 )
	{
 
		// == PREMIUM
		switch ( hacks.PREMIUM )
				{
		case 1:
				*(long*)( dwServer+OFS_PREMIUM) = 1; 
				*(long*)( dwServer+OFS_PREMIUM + 0x4 ) = 2592000;
		break;
		case 2: 
				*(long*)( dwServer+OFS_PREMIUM ) = 2; 
				*(long*)( dwServer+OFS_PREMIUM  + 0x4 ) = 2592000;
		break;
		case 3: 
				*(long*)( dwServer+OFS_PREMIUM  ) = 3; 
				*(long*)( dwServer+OFS_PREMIUM + 0x4 ) = 2592000;	
		break;
		case 4: 
				*(long*)( dwServer+OFS_PREMIUM  ) = 4; 
				*(long*)( dwServer+OFS_PREMIUM  + 0x4 ) = 2592000;	
		break;
				}
        // == GM ALERT MESSAGE
		if ( hacks.GMALERT  == 1 )
		{
			char *GMName = (char*)(ADR_GMALERTNAME);	
			char *GMIP   = (char*)(ADR_GMALERTIP);	
			if ( strlen(GMName) > 2 || strlen(GMIP) > 2  ) 
			{
					char GMWarnMex[333];
					sprintf(GMWarnMex,/*ATTENTION >> %s is spectating room!*/XorStr<0x2C,36,0x4B99FFE8>("\x6D\x79\x7A\x6A\x7E\x65\x7B\x7C\x7A\x15\x08\x09\x18\x1C\x49\x1B\x55\x4E\x1E\x4C\x30\x24\x21\x37\x25\x31\x2F\x29\x2F\x69\x38\x24\x23\x20\x6F"+0x4B99FFE8).s,ADR_GMALERTNAME,ADR_GMALERTIP);
                    PrintText((int*)0x0,(int*)0x1,GMWarnMex,(BYTE*)0xFF,(BYTE*)0x00,(BYTE*)0x00);//Red
			}
		}
        // == GM ALERT LOBBY
		if ( hacks.GMALERT  == 2 )
		{
			char *GMName = (char*)(ADR_GMALERTNAME);	
			if ( strlen(GMName) > 2   ) 
			{
				 GETBACKLOBBY();
			}
		}
        // == GM ALERT CRASH
		if ( hacks.GMALERT  == 3 )
		{
			char *GMName = (char*)(ADR_GMALERTNAME);		
			if ( strlen(GMName) > 2  ) 
			{
				 ExitProcess(TRUE);
			}
		}
		// == Room Master
		if ( hacks.ROOMMASTER == 1 )
		{
			DWORD  *PLSLOT; 
			DWORD  *RMSLOT; 
			PLSLOT =(DWORD *)((dwServer)+ OFS_PLAYERSLOT); 
			RMSLOT =(DWORD *)((dwServer)+ OFS_ROOMMASTER); 
			*RMSLOT = *PLSLOT;
		} 
		// == SUPER MASTER
		if ( hacks.SUPERMASTER == 1 )
		{
			if ( cSuperMaster == true )
			{
				 SuperMaster =  *(long*)(dwServer+OFS_SUPERMASTER);
			    *(long*)(dwServer+OFS_SUPERMASTER) = 1;
			    cSuperMaster = false;
			}
		}else{

			if ( cSuperMaster == false )
			{
                *(long*)(dwServer+OFS_SUPERMASTER) = SuperMaster;
				 cSuperMaster = true;
			}


		}
		// == ALL SLOT
		if ( hacks.SLOTS == 1  )
		{ 
				if ( cSlot == true )
				{
					Slot5 = *(BYTE*)(dwServer+OFS_SLOTS); 
					Slot6 = *(BYTE*)(dwServer+OFS_SLOTS+0x1); 
					Slot7 = *(BYTE*)(dwServer+OFS_SLOTS+0x2);  
					Slot8 = *(BYTE*)(dwServer+OFS_SLOTS+0x3); 
					// ==========================================
					*(BYTE*)(dwServer+OFS_SLOTS)     = 1; 
					*(BYTE*)(dwServer+OFS_SLOTS+0x1) = 1;  
					*(BYTE*)(dwServer+OFS_SLOTS+0x2) = 1;  
					*(BYTE*)(dwServer+OFS_SLOTS+0x3) = 1;
					cSlot = false;
				}
		}else{
				if ( cSlot == false )
				{
					*(BYTE*)(dwServer+OFS_SLOTS)     = Slot5; 
					*(BYTE*)(dwServer+OFS_SLOTS+0x1) = Slot6; 
					*(BYTE*)(dwServer+OFS_SLOTS+0x2) = Slot7;   
					*(BYTE*)(dwServer+OFS_SLOTS+0x3) = Slot8; 
					cSlot = true;	
				}
		}		
		// == WEAPON BINDER
		if ( hacks.CLASS > 0 )
		{
			find_weapons();
			if (hacks.WEAPONSLOT1 >0)
			WPNput(hacks.CLASS - 1, 0, hacks.WEAPONSLOT1-1);
			if (hacks.WEAPONSLOT2 > 0)
			WPNput(hacks.CLASS - 1, 1, hacks.WEAPONSLOT2-1);
			if ( hacks.WEAPONSLOT3 > 0)
			WPNput(hacks.CLASS- 1, 2,  hacks.WEAPONSLOT3-1);
			if ( hacks.WEAPONSLOT4 > 0) 
			WPNput(hacks.CLASS - 1, 3,  hacks.WEAPONSLOT4-1);
			if ( hacks.WEAPONSLOT5 > 0)
			WPNput(hacks.CLASS - 1, 4 , hacks.WEAPONSLOT5-1);
			if ( hacks.WEAPONSLOT6 > 0)
			WPNput(hacks.CLASS - 1, 5,  hacks.WEAPONSLOT6-1);
			if ( hacks.WEAPONSLOT7 > 0) 
			WPNput(hacks.CLASS- 1, 6,  hacks.WEAPONSLOT7-1);
			if ( hacks.WEAPONSLOT8 > 0)
			WPNput(hacks.CLASS - 1, 7,  hacks.WEAPONSLOT8-1);
		}
	}
		// == PLAYER FINDER
		if  ( hacks.PLAYERFIND )
		{
				DWORD Name = NULL;
				DWORD Ip   = NULL;
				int  i = (hacks.PLAYERFIND-1);
				Name       = (ADR_USERNAME      + (ADR_PLAYERSIZE * i));
				Ip         = (ADR_USERIP        + (ADR_PLAYERSIZE * i));
				if ( strlen((char*)Name) >0 )
				{
						sprintf(SNAME,/*%s*/XorStr<0xDE,3,0x8CBF9E26>("\xFB\xAC"+0x8CBF9E26).s,(void*)Name);
						sprintf(SIP,/*%s*/XorStr<0xDE,3,0x8CBF9E26>("\xFB\xAC"+0x8CBF9E26).s,(void*)Ip);	
				}else{
						sprintf(SNAME,/*Empty Slot*/XorStr<0x07,11,0x75D18515>("\x42\x65\x79\x7E\x72\x2C\x5E\x62\x60\x64"+0x75D18515).s);
						sprintf(SIP,/*Empty Slot*/XorStr<0x07,11,0x75D18515>("\x42\x65\x79\x7E\x72\x2C\x5E\x62\x60\x64"+0x75D18515).s);
				}
		}
}


void   cHackvar :: StartAimbot ( void )
{
	DWORD dwPlayerPointer = *(DWORD*)ADR_PLAYERPTR;

	if ( hacks.AIMBOT !=0 && dwPlayerPointer!=0 && IsValid==479 )
	{
		hacks.NORECOIL=1;
		D3DXVECTOR3 wLocal,wPlayer,wTarget,WarAngle;
		float SetDist,PlrDist;
		float SetAngle=9999999;
		int botkey;
		int PLRID = -1;
		CPlayer* MyInfo = g_pBase->local;
					
		switch(hacks.AIMRANGE)
		{
			case 0:SetDist=999999;	break;
			case 1:SetDist=10;		break;
			case 2:SetDist=20;		break;
			case 3:SetDist=30;		break;
			case 4:SetDist=40;		break;
			case 5:SetDist=60;		break;
			case 6:SetDist=80;		break;
			case 7:SetDist=100;		break;
			case 8:SetDist=200;		break;
			case 9:SetDist=300;		break;
			case 10:SetDist=400;	break;
			case 11:SetDist=600;	break;
			case 12:SetDist=1000;	break;
		}
		switch(hacks.AIMKEY)
		{
		    case 0:botkey=02;		break;
			case 1:botkey=02;		break;
			case 2:botkey=01;		break;
			case 3:botkey=04;		break;
			case 4:botkey=160;		break;
			case 5:botkey=162;		break;
		}


		for ( int slot=0 ; slot<32 ; slot++ )	
		{

			CPlayer     *pPlayer    = g_pBase->player[slot];
			CPlayerInfo *pInfo      = GetPlayerInfo(slot);
			CPlayerInfo *pLocalInfo = GetPlayerInfo(g_pBase->local->index);

			if ( MyInfo && pInfo && pPlayer )
			{
               if ( tools->IsValidPlayer(pPlayer,pInfo) )
			   {
					wLocal.x  =  MyInfo->pos.x;
					wLocal.y  =  MyInfo->pos.y;
					wLocal.z  =  MyInfo->pos.z;

					wPlayer.x =  pPlayer->pos.x;
					wPlayer.y =  pPlayer->pos.y;
					wPlayer.z =  pPlayer->pos.z;

					PlrDist = (float)sqrt(pow((wPlayer.x-wLocal.x),2)+pow((wPlayer.y-wLocal.y),2)+pow((wPlayer.z-wLocal.z),2))/10;
					if ( PlrDist < SetDist && pInfo->team != pLocalInfo->team && pInfo->health > 0 && pInfo->name > 0  )
					{
						SetDist = PlrDist;
						PLRID   = slot;
						cAimBot->AimCorrection(hacks.AIMAT,pPlayer,wPlayer,wTarget);
					}
			   }
			}
				if ( PLRID != -1 )
				{
					if ( hacks.AIMBOT==2 )
					{
						cAimBot->TargetAngle(wTarget,wLocal,WarAngle);
						cAimBot->AimToPoint(WarAngle[0],WarAngle[2]);
					}
					if ( hacks.AIMBOT==1 )
					{
						if(GetAsyncKeyState(botkey))
						{
							cAimBot->TargetAngle(wTarget,wLocal,WarAngle);
							cAimBot->AimToPoint(WarAngle[0],WarAngle[2]);
						}
					}
				}
		}

	}
}



void  cHackvar :: D3DESP ( LPDIRECT3DDEVICE9 pDevice )
{
  for ( int i = 0; i < 32; i++ )
  {
		if ( !g_pBase->player || !g_pBase->local)break; 
		CPlayer		*spPlayer;
		CPlayerInfo *spInfo;
		spPlayer    = g_pBase->player[i];
		spInfo	    = GetPlayerInfo(i);


	if ( spInfo && spPlayer )
	{
		CPlayerInfo *spLocalInfo = GetPlayerInfo(g_pBase->local->index);
		if (hacks.NAMEESP || hacks.HEALTESP || hacks.IPESP || hacks.TEAMESP || hacks.DISTANCEESP )
		{
				D3DXVECTOR3 g_pPlayer(spPlayer->pos.x, spPlayer->pos.z, spPlayer->pos.y), g_vView; 
				if ( tools->IsValidPlayer(spPlayer, spInfo) && d3d->GetScreenCoordFromWorld ( pDevice, g_vView, g_pPlayer) )
				{
                          float foffset =  g_vView.y-30;

							// == Enemy Only
									if  (hacks.ENEMYONLY == 1 && spInfo->team != spLocalInfo->team && spInfo->health > 0 && spInfo->name > 0 )
									{

										if (hacks.NAMEESP == 1 )
										{  
											font->DrawText( g_vView.x, foffset,TextRed, spInfo->name,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										if( hacks.HEALTESP == 1  )
										{	
											d3d->ShowHealt(pDevice, g_vView.x+18,foffset+10,spInfo->health);
											foffset += 10;
										}
										if( hacks.HEALTESP == 2 )
										{
											int  Red1,Green1;
											Red1   =	255-((spInfo->health/10)*2.55);
											Green1 =	(spInfo->health/10)*2.55;
											sprintf(szhealth,/*%d %*/XorStr<0x63,5,0x678090F9>("\x46\x00\x45\x43"+0x678090F9).s,(int)spInfo->health/10);
											font->DrawText( g_vView.x,foffset,D3DCOLOR_ARGB( 255, Red1, Green1, 0), szhealth, D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										/*
										if ( hacks.WEAPONESP == 1 )
										{
											font->DrawText( g_vView.x,foffset,UrbaESP,EspWeapons[(int)spPlayer->weapon], D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										*/
										if ( hacks.IPESP == 1 )
										{   
											font->DrawText( g_vView.x,foffset,TextRed, spInfo->ip,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										
										if(hacks.TEAMESP )
										{
											if ( GetPlayerInfo(i)->team == 1 )
											{
													font->DrawText(g_vView.x,foffset,D3DCOLOR_ARGB(255,0,255,0),/*N.I.U*/XorStr<0x20,6,0x4A8A24B3>("\x6E\x0F\x6B\x0D\x71"+0x4A8A24B3).s,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
													foffset += 10;
											}else{
													font->DrawText( g_vView.x,foffset,D3DCOLOR_ARGB(255,255,255,0),/*Derberan*/XorStr<0x5D,9,0x5AE559A3>("\x19\x3B\x2D\x02\x04\x10\x02\x0A"+0x5AE559A3).s,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
													foffset += 10;
											}
										}
										if( hacks.DISTANCEESP == 1 )
										{
											sprintf(szDistance,/*%.2f m*/XorStr<0x27,7,0xC1C454F0>("\x02\x06\x1B\x4C\x0B\x41"+0xC1C454F0).s,tools->GetDistance(g_pBase->local, spPlayer)/60);
											font->DrawText( g_vView.x,foffset, TextOrange, szDistance,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC); 
											foffset += 10;
										}
								}
								if (  hacks.ENEMYONLY == 2 && spInfo->health > 0 )
								{
										if ( spLocalInfo->team == spInfo->team )
										{
											UrbaESP =  D3DCOLOR_ARGB(255,235,235,235);
											}else{
											UrbaESP = D3DCOLOR_ARGB(255,255,000,000);
										}
										if ( hacks.NAMEESP == 1 )
										{    	
											font->DrawText( g_vView.x,foffset,UrbaESP, spInfo->name,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										if( hacks.HEALTESP == 1  )
										{		
											d3d->ShowHealt (pDevice, g_vView.x+18,foffset+10, spInfo->health);
											foffset += 10;
										}
										if ( hacks.HEALTESP == 2 )
										{
											int Red1,Green1;
											Red1   =	255-((spInfo->health/10)*2.55);
											Green1 =	(spInfo->health/10)*2.55;
											sprintf(szhealth,/*%d %*/XorStr<0x63,5,0x678090F9>("\x46\x00\x45\x43"+0x678090F9).s,(int)spInfo->health/10);
											font->DrawText( g_vView.x,foffset,D3DCOLOR_ARGB( 255, Red1, Green1, 0), szhealth, D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										
										/*
										if ( hacks.WEAPONESP == 1 )
										{
											font->DrawText( g_vView.x,foffset,UrbaESP,EspWeapons[(int)spPlayer->weapon], D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										*/
										if (hacks.IPESP == 1 )
										{    	
											font->DrawText( g_vView.x,foffset,UrbaESP, spInfo->ip,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
										if (hacks.TEAMESP )
										{
											if ( GetPlayerInfo(i)->team == 1 )
											{
												font->DrawText(g_vView.x,foffset,D3DCOLOR_ARGB(255,0,255,0),/*N.I.U*/XorStr<0x20,6,0x4A8A24B3>("\x6E\x0F\x6B\x0D\x71"+0x4A8A24B3).s,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
												foffset += 10;
											}else{
												font->DrawText( g_vView.x,foffset,D3DCOLOR_ARGB(255,255,255,0),/*Derberan*/XorStr<0xD5,9,0x20273C3C>("\x91\xB3\xA5\xBA\xBC\xA8\xBA\xB2"+0x20273C3C).s,D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
												foffset += 10;
											}
										}
										if(hacks.DISTANCEESP == 1 )
										{
											sprintf(szDistance,/*%.2f m*/XorStr<0x27,7,0xC1C454F0>("\x02\x06\x1B\x4C\x0B\x41"+0xC1C454F0).s,tools->GetDistance(g_pBase->local, spPlayer)/60);
											font->DrawText( g_vView.x,foffset,TextOrange, szDistance, D3DFONT_CENTERED || D3DFONT_ZENABLE || D3DFONT_ITALIC);
											foffset += 10;
										}
								}

				 }
			  }
		}
	}
}