WarRock EU - Code Snippets

Page 471 of 500 « First 371421461469470 471 472473481 Last »
05/12/2012 18:32 Raz9r#7051
Quote:
Originally Posted by Crytec' View Post
2d radar source bitte

habe die source aber mein possition stimmen nicht :(
Zeig uns doch mal deine Versuche.
05/12/2012 18:48 Crytec'#7052
void rad(LPDIRECT3DDEVICE9 pDevice)
{
if(Radar2D==1)
{
DrawBox(700,50,150,150,GREEN,pDevice);

DrawRectangle(776,126,255,255,255,GREY,pDevice);
for(int i = 0; i < 32; i++)
{
if(!p_Player->pGlobal || !p_Player->pLocal) break;
CPlayer* pPlayer = p_Player->pGlobal[i];
CPlayerInfo *pInfo = GetGlobalInfo(i);

if(pInfo && pPlayer)
{
CPlayerInfo *pLocalInfo = GetGlobalInfo(p_Player->pLocal->index);
D3DXVECTOR3 g_pPlayer(pPlayer->PosX, pPlayer->PosY, pPlayer->PosZ),g_vView;
if( GetScreenCoordFromWorld(pDevice, g_vView, g_pPlayer) )
{
DWORD colr;
DWORD colg;
DWORD colb;
if( pLocalInfo->team == pInfo->team )
{
colr = 0;
colg = 255;
colb = 0;
}
else
{
colr = 255;
colg = 0;
colb = 0;
}
DWORD enemyposx = g_vView.x;
DWORD enemyposy = g_vView.y;
DWORD endenemyposx = (776+(enemyposx/10));
DWORD endenemyposy = (126+(enemyposy/10));
DrawRectangle(endenemyposx,endenemyposy,colr,colg, colb,GREY,pDevice);
}
}
}
}

}



so sieht im spiel aus sehe nix :(



[Only registered and activated users can see links. Click Here To Register...]

























brauche opk, auto ready, auto 9wins, votekick sources

und 2d radar fixx :(
05/12/2012 19:09 Raz9r#7053
Wie wäre es damit, nicht nur zu kopieren?
05/12/2012 19:10 Crytec'#7054
ja man sieht auf screen habe versucht postion einzustellen aber immer probleme :(
05/12/2012 21:38 xxfabbelxx#7055
Quote:
Originally Posted by __underScore View Post
Code:
int *const spawnwait = 0x00;
// ...
*spawnwait = 0;
[Only registered and activated users can see links. Click Here To Register...]

dafuq...
05/12/2012 22:37 Raz9r#7056
Quote:
Originally Posted by xxfabbelxx View Post
[Only registered and activated users can see links. Click Here To Register...]

dafuq...
[Only registered and activated users can see links. Click Here To Register...]

Type-Safety...
05/14/2012 15:14 Domik2#7057
Bräuchte einen code für Sprites da meine nur buggig funktionieren also kein text da ist :/
[Only registered and activated users can see links. Click Here To Register...]
jap die sind hässlich aber das ist nur ein test :)
05/14/2012 16:13 AdrenalinaPL#7058
@request

- ESP struct
- OPK struct
05/14/2012 16:18 nicki240#7059
hi leute ,

Ich bin am basteln meines guidtech systems ...

Ich bekomme immer
PHP Code:
Notice: Undefined index: password in C:\xampp\htdocs\vbulletin\guid\login.php on line 5 
Code:
while($rows=mysql_fetch_array($result)){
        $checkpass=$rows['password'];
	$salt=$rows['salt'];
	}
$password_hash = md5(md5($salt) . md5($password));
Code:
$password=mysql_real_escape_string($password);
05/14/2012 17:48 Domik2#7060
Quote:
Originally Posted by nicki240 View Post
hi leute ,

Ich bin am basteln meines guidtech systems ...

Ich bekomme immer
PHP Code:
Notice: Undefined index: password in C:\xampp\htdocs\vbulletin\guid\login.php on line 5 
Code:
while($rows=mysql_fetch_array($result)){
        $checkpass=$rows['password'];
	$salt=$rows['salt'];
	}
$password_hash = md5(md5($salt) . md5($password));
Code:
$password=mysql_real_escape_string($password);
Du musst password erst einmal definiren :P
05/14/2012 20:16 nicki240#7061
Quote:
Originally Posted by nicki240 View Post
hi leute ,

Ich bin am basteln meines guidtech systems ...

Ich bekomme immer
PHP Code:
Notice: Undefined index: password in C:\xampp\htdocs\vbulletin\guid\login.php on line 5 
Code:
while($rows=mysql_fetch_array($result)){
        $checkpass=$rows['password'];
	$salt=$rows['salt'];
	}
$password_hash = md5(md5($salt) . md5($password));
Code:
$password=mysql_real_escape_string($password);
line 5 :
Code:
$password=$_POST['password'];
Kann mir jemand sagen was hier ran falsch ist ? :
PHP Code:
$result=mysql_query("SELECT * FROM ".$pf."user WHERE password='" . $password. "'")or die('fout'. mysql_error());
while($rows=mysql_fetch_array($result)){
    $password=$rows['password'];
}
echo "test md5 : $password"; 
Die spalte heißt password ...

thx 4 help :confused:
05/14/2012 23:37 . χaωe#7062
Quote:
Originally Posted by nicki240 View Post
line 5 :
Code:
$password=$_POST['password'];
Kann mir jemand sagen was hier ran falsch ist ? :
PHP Code:
$result=mysql_query("SELECT * FROM ".$pf."user WHERE password='" . $password. "'")or die('fout'. mysql_error());
while($rows=mysql_fetch_array($result)){
    $password=$rows['password'];
}
echo "test md5 : $password"; 
Die spalte heißt password ...

thx 4 help :confused:
Bei der abfrage musst du zwischen ".$pf."user ein Leerzeichen machen, sonst kann SQL die Abfrage ja nicht richtig verarbeiten ;)
(Also einfach einfügen:
PHP Code:
$result=mysql_query("SELECT * FROM ".$pf." user WHERE password='" . $password. "'")or die('fout'. mysql_error()); 
05/15/2012 19:01 nicki240#7063
Danke für eure hilfe ...jetzt brauche ich sie auch noch mal ..;)
Ich habe es ja hiermit versucht :
PHP Code:
$result=mysql_query("SELECT * FROM ".$pf."user WHERE password='" . $password. "'")or die('fout'. mysql_error());
while($rows=mysql_fetch_array($result)){
    $password=$rows['password'];
    } 
Dabei ist mir jetzt aufgefallen , dass die abfrage ja garnicht "wissen" kann von welchem user das passswort benötigt wird :rolleyes:

Also kann mir jemand sagen wie der code dann aussehen müsste

die variable für den usernamen ist : $user2

Wenn ihr versteht was ich meine :P
05/15/2012 19:17 Phantom.#7064
Code:
// ============================================
// ==       WarRock HackShield ByPass        ==
// ==    Made by King7 && VirtualProtect     ==
// == Keep a credit if you are gona use this ==
// ============================================


BOOL MemoryEdit ( VOID *lpMem, VOID *lpSrc, DWORD len )
{
  DWORD lpflOldProtect, flNewProtect = PAGE_READWRITE;
  unsigned char *pDst = (unsigned char *)lpMem, 
  *pSrc = (unsigned char *)lpSrc;
  if (VirtualProtect(lpMem,len,flNewProtect,&lpflOldProtect))
  {
              while(len-- >0) *pDst++ = *pSrc++;
                          VirtualProtect(lpMem,len, lpflOldProtect,&lpflOldProtect);
                          FlushInstructionCache(GetCurrentProcess(), lpMem, len);
              return 1;
  }
  return 0;
}


void HackShieldBP (void)
{
        DWORD hEhSvc = 0;
        do{
        hEhSvc = (DWORD)GetModuleHandle("EhSvc.dll");
        Sleep(300); // Waiting EhSvc.dll Module
        }while(!hEhSvc);

        // == EhSvc.dll
        MemoryEdit((LPVOID)(hEhSvc+0x09F10),(LPVOID)"\xC2\x04\x00",3);
        MemoryEdit((LPVOID)(hEhSvc+0x786DC),(LPVOID)"\xC2\x04\x00",3);
        MemoryEdit((LPVOID)(hEhSvc+0x3BC3E),(LPVOID)"\x31",1);
        MemoryEdit((LPVOID)(hEhSvc+0x3906F),(LPVOID)"\x31",1);
        // == WarRock.exe 
        MemoryEdit((LPVOID)(0x4E5FB5),(LPVOID)"\xC2\x0C\x00",3);
        MemoryEdit((LPVOID)(0x4E6699),(LPVOID)"\xEB",1);
        MemoryEdit((LPVOID)(0x59B908),(LPVOID)"\xC3",1); 
}

 CreateThread(0,0,(LPTHREAD_START_ROUTINE)HackShieldBP,0,0,0);
05/15/2012 21:56 animus7#7065
Code:
//------------------------ Make the hack working ------------------------//
                
                //-- Premium --//
        if(CH_Premium == 1)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {
                *(int*)(dwServerBase + Address_Premium_Offset) = 0;
            }
        }
        if(CH_Premium == 2)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {
                *(int*)(dwServerBase + Address_Premium_Offset) = 1;
            }
        }
        if(CH_Premium == 3)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {
                *(int*)(dwServerBase + Address_Premium_Offset) = 2;
            }
        }
        if(CH_Premium == 4)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {
                *(int*)(dwServerBase + Address_Premium_Offset) = 3;
            }
        }

        //-- Stamina --//
        if(CH_Stamina)
        {
            DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
            if(dwPlayerPtr != 0)
            {
                *(float*)(dwPlayerPtr + Address_Stamina_Offset) = 100;
            }
        }

        //-- No Spread --//
        if(CH_No_Spread)
        {
            long value = 0;
            DWORD Protection;
            
            VirtualProtect((void*)Address_No_Spread, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Spread, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Spread, sizeof(value), Protection, 0);
        }

        //-- No Recoil --//
        if(CH_No_Recoil)
        {
            DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
            if(dwPlayerPtr != 0)
            {
                *(float*)(dwPlayerPtr + Address_No_Recoil_Offset_1) = 0;
                *(float*)(dwPlayerPtr + Address_No_Recoil_Offset_2) = 0;
                *(float*)(dwPlayerPtr + Address_No_Recoil_Offset_3) = 0;
            }
        }

        //-- Super Jump --//
        if(CH_Super_Jump == 2)
        {
            CH_NFD_Player = true;

            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
                if(dwPlayerPtr != 0)
                {
                    *(float*)(dwPlayerPtr + Address_Super_Jump_Offset) = 500;
                }
            }
        }
        if(CH_Super_Jump == 3)
        {
            CH_NFD_Player = true;

            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
                if(dwPlayerPtr != 0)
                {
                    *(float*)(dwPlayerPtr + Address_Super_Jump_Offset) = 1000;
                }
            }
        }
        if(CH_Super_Jump == 4)
        {
            CH_NFD_Player = true;

            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
                if(dwPlayerPtr != 0)
                {
                    *(float*)(dwPlayerPtr + Address_Super_Jump_Offset) = 1500;
                }
            }
        }
        if(CH_Super_Jump == 5)
        {
            CH_NFD_Player = true;

            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
                if(dwPlayerPtr != 0)
                {
                    *(float*)(dwPlayerPtr + Address_Super_Jump_Offset) = 2000;
                }
            }
        }
        if(CH_Super_Jump == 6)
        {
            CH_NFD_Player = true;

            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
                if(dwPlayerPtr != 0)
                {
                    *(float*)(dwPlayerPtr + Address_Super_Jump_Offset) = 2500;
                }
            }
        }
        if(CH_Super_Jump == 7)
        {
            CH_NFD_Player = true;

            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
                if(dwPlayerPtr != 0)
                {
                    *(float*)(dwPlayerPtr + Address_Gravity_Offset) = 500;
                }
            }
        }
        
        //-- No Fall Damage --//
        if(CH_NFD_Player)
        {
            DWORD dwPlayerPtr = *(DWORD*)Address_Player_Base;
            if(dwPlayerPtr != 0)
            {
                *(float*)(dwPlayerPtr + Address_No_Fall_Damage_Offset) = -2500;
            }
        }

        /    //-- Scope --//
        if(CH_Scope)
        {
            if(GetAsyncKeyState(VK_RBUTTON))
            {
                long value = 1;
                DWORD Protection;
                
                VirtualProtect((void*)Address_Scope, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Scope, &value , sizeof(value));
                VirtualProtect((void*)Address_Scope, sizeof(value), Protection, 0);
            }
            else
            {
                long value = 0;
                DWORD Protection;
            
                VirtualProtect((void*)Address_Scope, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Scope, &value , sizeof(value));
                VirtualProtect((void*)Address_Scope, sizeof(value), Protection, 0);
            }
        }
        
        //-- 5º Slot --//
        if(CH_Slot)
        {
            long value = 4;
            DWORD Protection;
            
            VirtualProtect((void*)Address_Slot, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_Slot, &value , sizeof(value));
            VirtualProtect((void*)Address_Slot, sizeof(value), Protection, 0);
        }

        //-- No Water --//
        if(CH_No_Water)
        {
            long value = 0;
            DWORD Protection;
        
            VirtualProtect((void*)Address_No_Water, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Water, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Water, sizeof(value), Protection, 0);
        }

        //-- No Bounds --//
        if(CH_No_Bounds)
        {
            long value = 0;
            DWORD Protection;

            VirtualProtect((void*)Address_No_Bounds_1, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Bounds_1, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Bounds_1, sizeof(value), Protection, 0);

            VirtualProtect((void*)Address_No_Bounds_2, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Bounds_2, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Bounds_2, sizeof(value), Protection, 0);
        }

        //-- Fast Ammo --//
        if(CH_Fast_Ammo)
        {
            long value = 1092779973;
            DWORD Protection;
            
            VirtualProtect((void*)Address_Fast_Ammo, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_Fast_Ammo, &value , sizeof(value));
            VirtualProtect((void*)Address_Fast_Ammo, sizeof(value), Protection, 0);
        }

        //-- Fast Health --//
        if(CH_Fast_Health)
        {
            long value = 1092779973;
            DWORD Protection;
    
            VirtualProtect((void*)Address_Fast_Health, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_Fast_Health, &value , sizeof(value));
            VirtualProtect((void*)Address_Fast_Health, sizeof(value), Protection, 0);
        }

        //-- Fast Repair --//
        if(CH_Fast_Repair)
        {
            long value = 1092779973;
            DWORD Protection;
    
            VirtualProtect((void*)Address_Fast_Repair, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_Fast_Repair, &value , sizeof(value));
            VirtualProtect((void*)Address_Fast_Repair, sizeof(value), Protection, 0);
        }

        //-- Fast Flag --//
        if(CH_Fast_Flag)
        {
            long value = 1092779973;
            DWORD Protection;
        
            VirtualProtect((void*)Address_Fast_Flag, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_Fast_Flag, &value , sizeof(value));
            VirtualProtect((void*)Address_Fast_Flag, sizeof(value), Protection, 0);
        }
        
        //-- No Spawn --//
        if(CH_No_Spawn)
        {
            long value = 0;
            DWORD Protection;
    
            VirtualProtect((void*)Address_No_Spawn_1, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Spawn_1, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Spawn_1, sizeof(value), Protection, 0);
      
            VirtualProtect((void*)Address_No_Spawn_2, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Spawn_2, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Spawn_2, sizeof(value), Protection, 0);

            VirtualProtect((void*)Address_No_Spawn_3, sizeof(value), PAGE_READWRITE, &Protection);
            memcpy((void*)Address_No_Spawn_3, &value , sizeof(value));
            VirtualProtect((void*)Address_No_Spawn_3, sizeof(value), Protection, 0);
        }

        //-- Speed Hack --//
        if(CH_Speed_Hack == 1)
        {
            {
                float value = 100;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
        }
        if(CH_Speed_Hack == 2)
        {
            if(GetAsyncKeyState(VK_LCONTROL))
            {
                float value = 200;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
            else
            {
                float value = 100;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
        }
        if(CH_Speed_Hack == 3)
        {
            if(GetAsyncKeyState(VK_LCONTROL))
            {
                float value = 300;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
            else
            {
                float value = 100;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
        }
        if(CH_Speed_Hack == 4)
        {
            if(GetAsyncKeyState(VK_LCONTROL))
            {
                float value = 400;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
            else
            {
                float value = 100;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
        }
        if(CH_Speed_Hack == 5)
        {
            if(GetAsyncKeyState(VK_LCONTROL))
            {
                float value = 500;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
            else
            {
                float value = 100;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Speed_Hack, &value , sizeof(value));
                VirtualProtect((void*)Address_Speed_Hack, sizeof(value), Protection, 0);
            }
        }
        
        //-- Glass Walls Memory --//
        if(CH_Glass_Walls_Memory)
        {
            if((GetAsyncKeyState(VK_MBUTTON)) || (GetAsyncKeyState(VK_MENU)))
            {
                long value = 0;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Far_Fog__Glass_Walls, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Far_Fog__Glass_Walls, &value , sizeof(value));
                VirtualProtect((void*)Address_Far_Fog__Glass_Walls, sizeof(value), Protection, 0);
            }
            else
            {
                long value = 1181376512;
                DWORD Protection;
        
                VirtualProtect((void*)Address_Far_Fog__Glass_Walls, sizeof(value), PAGE_READWRITE, &Protection);
                memcpy((void*)Address_Far_Fog__Glass_Walls, &value , sizeof(value));
                VirtualProtect((void*)Address_Far_Fog__Glass_Walls, sizeof(value), Protection, 0);
            }
        }

        //-- Super Master --//
        if(CH_Super_Master)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {        
                *(int*)(dwServerBase + Address_Super_Master_Offset) = 1;
            }
        }
        if(!CH_Super_Master)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {        
                *(int*)(dwServerBase + Address_Super_Master_Offset) = 0;
            }
        }
        
        //-- All Slots --//
        if(CH_All_Slots)
        {
            DWORD dwServerBase = *(DWORD*)Address_Server_Base;
            if(dwServerBase != 0)
            {        
                *(int*)(dwServerBase + Address_All_Slots_Offset_1) = 1;
                *(int*)(dwServerBase + Address_All_Slots_Offset_2) = 1;
                *(int*)(dwServerBase + Address_All_Slots_Offset_3) = 1;
                *(int*)(dwServerBase + Address_All_Slots_Offset_4) = 1;
            }
        }

        //-- Zero Delay --//
        if(CH_Zero_Delay)
        {
            const BYTE zero_delay_on[3] = { 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Zero_Delay), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Zero_Delay), &zero_delay_on, 3);
                VirtualProtect((void*)(Address_Zero_Delay), 3, dwProtect, NULL);
            }
        }
        if(!CH_Zero_Delay)
        {
            const BYTE zero_delay_off[3] = { 0xF6, 0xC6, 0x04 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Zero_Delay), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Zero_Delay), &zero_delay_off, 3);
                VirtualProtect((void*)(Address_Zero_Delay), 3, dwProtect, NULL);
            }
        }

        //-- Anti Kick --//
        if(CH_Anti_Kick)
        {
            const BYTE anti_kick_on[6] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Anti_Kick), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Anti_Kick), &anti_kick_on, 6);
                VirtualProtect((void*)(Address_Anti_Kick), 6, dwProtect, NULL);
            }
        }
        if(!CH_Anti_Kick)
        {
            const BYTE anti_kick_off[6] = { 0x8B, 0x85, 0x24, 0xE3, 0x04, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Anti_Kick), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Anti_Kick), &anti_kick_off, 6);
                VirtualProtect((void*)(Address_Anti_Kick), 6, dwProtect, NULL);
            }
        }

        //-- Invisible --//
        if(CH_Invisible)
        {
            const BYTE invisible_on[2] = { 0x1C, 0x8B };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Invisible), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Invisible), &invisible_on, 2);
                VirtualProtect((void*)(Address_Invisible), 2, dwProtect, NULL);
            }
        }
        if(!CH_Invisible)
        {
            const BYTE invisible_off[2] = { 0x2C, 0x8B };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Invisible), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Invisible), &invisible_off, 2);
                VirtualProtect((void*)(Address_Invisible), 2, dwProtect, NULL);
            }
        }
if (CH_Invisi==1)
{
long t=273648428;
unsigned long Protection;
VirtualProtect((void*)INVIS, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)INVIS, &t , sizeof(t));
VirtualProtect((void*)INVIS, sizeof(t), Protection, 0);
}

if (!INVIS)
{
long t=471604252;
unsigned long Protection;
VirtualProtect((void*)INVIS, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)INVIS, &t , sizeof(t));
VirtualProtect((void*)INVIS, sizeof(t), Protection, 0);;
}

        //-- Unlimited Ammo --//
        if(CH_Unlimited_Ammo) //-- Hack Patched - Work Granades and RPG --//
        {
            const BYTE unlimited_ammo_1_on[3] = { 0x90, 0x90, 0x90 };
            const BYTE unlimited_ammo_2_on[3] = { 0x90, 0x90, 0x90 };
            const BYTE unlimited_ammo_3_on[3] = { 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Unlimited_Ammo_1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Unlimited_Ammo_1), &unlimited_ammo_1_on, 3);
                VirtualProtect((void*)(Address_Unlimited_Ammo_1), 3, dwProtect, NULL);

                VirtualProtect((void*)(Address_Unlimited_Ammo_2), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Unlimited_Ammo_2), &unlimited_ammo_2_on, 3);
                VirtualProtect((void*)(Address_Unlimited_Ammo_2), 3, dwProtect, NULL);

                VirtualProtect((void*)(Address_Unlimited_Ammo_3), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Unlimited_Ammo_3), &unlimited_ammo_3_on, 3);
                VirtualProtect((void*)(Address_Unlimited_Ammo_3), 3, dwProtect, NULL);
            }
        }
        if(!CH_Unlimited_Ammo)
        {
            const BYTE unlimited_ammo_1_off[3] = { 0x89, 0x7E, 0x24 };
            const BYTE unlimited_ammo_2_off[3] = { 0x89, 0x46, 0x20 };
            const BYTE unlimited_ammo_3_off[3] = { 0x89, 0x46, 0x24 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Unlimited_Ammo_1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Unlimited_Ammo_1), &unlimited_ammo_1_off, 3);
                VirtualProtect((void*)(Address_Unlimited_Ammo_1), 3, dwProtect, NULL);

                VirtualProtect((void*)(Address_Unlimited_Ammo_2), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Unlimited_Ammo_2), &unlimited_ammo_2_off, 3);
                VirtualProtect((void*)(Address_Unlimited_Ammo_2), 3, dwProtect, NULL);

                VirtualProtect((void*)(Address_Unlimited_Ammo_3), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Unlimited_Ammo_3), &unlimited_ammo_3_off, 3);
                VirtualProtect((void*)(Address_Unlimited_Ammo_3), 3, dwProtect, NULL);
            }
        }
        
        //-- Radar GPS Enemy--//
        if(CH_Radar_GPS_Enemy)
        {
            const BYTE radar_gps_enemy_on[6] = { 0x0F, 0x84, 0xB1, 0x00, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Radar_GPS_Enemy), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Radar_GPS_Enemy), &radar_gps_enemy_on, 6);
                VirtualProtect((void*)(Address_Radar_GPS_Enemy), 6, dwProtect, NULL);
            }
        }
        if(!CH_Radar_GPS_Enemy)
        {
            const BYTE radar_gps_enemy_off[6] = { 0x0F, 0x85, 0xB1, 0x00, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Radar_GPS_Enemy), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Radar_GPS_Enemy), &radar_gps_enemy_off, 6);
                VirtualProtect((void*)(Address_Radar_GPS_Enemy), 6, dwProtect, NULL);
            }
        }

        //-- Map GPS --//
        if(CH_Map_GPS)
        {
            const BYTE map_gps_on[2] = { 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Map_GPS), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Map_GPS), &map_gps_on, 2);
                VirtualProtect((void*)(Address_Map_GPS), 2, dwProtect, NULL);
            }
        }
        if(!CH_Map_GPS)
        {
            const BYTE map_gps_off[2] = { 0x75, 0x1E };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Map_GPS), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Map_GPS), &map_gps_off, 2);
                VirtualProtect((void*)(Address_Map_GPS), 2, dwProtect, NULL);
            }
        }

        //-- Map FFA GPS --//
        if(CH_Map_FFA_GPS)
        {
            const BYTE map_ffa_gps_on[2] = { 0x74, 0x12 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Map_FFA_GPS), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Map_FFA_GPS), &map_ffa_gps_on, 2);
                VirtualProtect((void*)(Address_Map_FFA_GPS), 2, dwProtect, NULL);
            }
        }
        if(!CH_Map_FFA_GPS)
        {
            const BYTE map_ffa_gps_off[2] = { 0x75, 0x12 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Map_FFA_GPS), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Map_FFA_GPS), &map_ffa_gps_off, 2);
                VirtualProtect((void*)(Address_Map_FFA_GPS), 2, dwProtect, NULL);
            }
        }

        //-- ESP Names --//
        if(CH_ESP_Names)
        {
            const BYTE esp_names_on[2] = { 0x76, 0x22 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_ESP_Names), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_ESP_Names), esp_names_on, 2);
                VirtualProtect((void*)(Address_ESP_Names), 2, dwProtect, NULL);
            }
        }
        if(!CH_ESP_Names)
        {
            const BYTE esp_names_off[2] = { 0x75, 0x22 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_ESP_Names), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_ESP_Names), &esp_names_off, 2);
                VirtualProtect((void*)(Address_ESP_Names), 2, dwProtect, NULL);
            }
        }

        //-- Auto Ammo --//
        if(CH_Auto_Ammo)
        {
            const BYTE auto_ammo_on[6] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Auto_Ammo), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Auto_Ammo), auto_ammo_on, 6);
                VirtualProtect((void*)(Address_Auto_Ammo), 6, dwProtect, NULL);
            }
        }
        if(!CH_Auto_Ammo)
        {
            const BYTE auto_ammo_off[6] = { 0x0F, 0x85, 0xA2, 0x00, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Auto_Ammo), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Auto_Ammo), &auto_ammo_off, 6);
                VirtualProtect((void*)(Address_Auto_Ammo), 6, dwProtect, NULL);
            }
        }

        //-- Auto Health --//
        if(CH_Auto_Health)
        {
            const BYTE auto_health_on[6] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Auto_Health), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Auto_Health), &auto_health_on, 6);
                VirtualProtect((void*)(Address_Auto_Health), 6, dwProtect, NULL);
            }
        }
        if(!CH_Auto_Health)
        {
            const BYTE auto_health_off[6] = { 0x0F, 0x85, 0xA6, 0x00, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Auto_Health), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Auto_Health), &auto_health_off, 6);
                VirtualProtect((void*)(Address_Auto_Health), 6, dwProtect, NULL);
            }
        }

        //-- Auto Repair --//
        if(CH_Auto_Repair)
        {
            const BYTE auto_repair_on[6] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Auto_Repair), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Auto_Repair), &auto_repair_on, 6);
                VirtualProtect((void*)(Address_Auto_Repair), 6, dwProtect, NULL);
            }
        }
        if(!CH_Auto_Repair)
        {
            const BYTE auto_repair_off[6] = { 0x0F, 0x85, 0xB9, 0x00, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Auto_Repair), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Auto_Repair), &auto_repair_off, 6);
                VirtualProtect((void*)(Address_Auto_Repair), 6, dwProtect, NULL);
            }
        }

        //-- Headshot --//
        if(CH_Headshot)
        {
            const BYTE headshot_on[2] = { 0x31, 0xC0 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Headshot), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Headshot), &headshot_on, 2);
                VirtualProtect((void*)(Address_Headshot), 2, dwProtect, NULL);
            }
        }
        if(!CH_Headshot)
        {
            const BYTE headshot_off[2] = { 0x85, 0xC0 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Headshot), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Headshot), &headshot_off, 2);
                VirtualProtect((void*)(Address_Headshot), 2, dwProtect, NULL);
            }
        }
        
        //-- STW --//
        if(CH_STW)
        {
            const BYTE stw_on[3] = { 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_STW), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_STW), &stw_on, 3);
                VirtualProtect((void*)(Address_STW), 3, dwProtect, NULL);
            }
        }
        if(!CH_STW)
        {
            const BYTE stw_off[3] = { 0x8B, 0x51, 0x38 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_STW), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_STW), &stw_off, 3);
                VirtualProtect((void*)(Address_STW), 3, dwProtect, NULL);
            }
        }

        //-- Escalator --//
        if(CH_Escalator)
        {
            if((GetAsyncKeyState(VK_LCONTROL)) && (GetAsyncKeyState(VK_SPACE)))
            {
                const BYTE escalator_on_1[3] = { 0x90, 0x90, 0x90 };
                const BYTE escalator_on_2[3] = { 0x90, 0x90, 0x90 };
                {
                    DWORD dwProtect;
                    
                    VirtualProtect((void*)(Address_Escalator_1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                    memcpy((void*)(Address_Escalator_1), &escalator_on_1, 3);
                    VirtualProtect((void*)(Address_Escalator_1), 3, dwProtect, NULL);

                    VirtualProtect((void*)(Address_Escalator_2), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                    memcpy((void*)(Address_Escalator_2), &escalator_on_2, 3);
                    VirtualProtect((void*)(Address_Escalator_2), 3, dwProtect, NULL);
                }  
            }      
        }
        if(!CH_Escalator)
        {
            const BYTE escalator_off_1[3] = { 0x89, 0x5D, 0x34 };
            const BYTE escalator_off_2[3] = { 0x89, 0x45, 0x34 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Escalator_1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Escalator_1), &escalator_off_1, 3);
                VirtualProtect((void*)(Address_Escalator_1), 3, dwProtect, NULL);

                VirtualProtect((void*)(Address_Escalator_2), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Escalator_2), &escalator_off_2, 3);
                VirtualProtect((void*)(Address_Escalator_2), 3, dwProtect, NULL);
            }
        }

        //-- SVP --//
        if(CH_SVP)
        {
            const BYTE svp_on[4] = { 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_SVP), 4, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_SVP), &svp_on, 4);
                VirtualProtect((void*)(Address_SVP), 4, dwProtect, NULL);
            }
        }
        if(!CH_SVP)
        {
            const BYTE svp_off[4] = { 0x8B, 0x54, 0x24, 0x04 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_SVP), 4, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_SVP), &svp_off, 4);
                VirtualProtect((void*)(Address_SVP), 4, dwProtect, NULL);
            }
        }

        //-- OPK --//
        if(CH_OPK)
        {
            const BYTE opk_on_1[6] = { 0x89, 0xA1, 0x8C, 0x01, 0x00, 0x00 };
            const BYTE opk_on_2[6] = { 0x89, 0xA1, 0x90, 0x01, 0x00, 0x00 };
            const BYTE opk_on_3[6] = { 0x89, 0xA1, 0x94, 0x01, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_OPK_1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_OPK_1), &opk_on_1, 6);
                VirtualProtect((void*)(Address_OPK_1), 6, dwProtect, NULL);

                VirtualProtect((void*)(Address_OPK_2), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_OPK_2), &opk_on_2, 6);
                VirtualProtect((void*)(Address_OPK_2), 6, dwProtect, NULL);

                VirtualProtect((void*)(Address_OPK_3), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_OPK_3), &opk_on_3, 6);
                VirtualProtect((void*)(Address_OPK_3), 6, dwProtect, NULL);
            }
        }
        if(!CH_OPK)
        {
            const BYTE opk_off_1[6] = { 0x89, 0x91, 0x8C, 0x01, 0x00, 0x00 };
            const BYTE opk_off_2[6] = { 0x89, 0x81, 0x90, 0x01, 0x00, 0x00 };
            const BYTE opk_off_3[6] = { 0x89, 0x91, 0x94, 0x01, 0x00, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_OPK_1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_OPK_1), &opk_off_1, 6);
                VirtualProtect((void*)(Address_OPK_1), 6, dwProtect, NULL);

                VirtualProtect((void*)(Address_OPK_2), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_OPK_2), &opk_off_2, 6);
                VirtualProtect((void*)(Address_OPK_2), 6, dwProtect, NULL);

                VirtualProtect((void*)(Address_OPK_3), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_OPK_3), &opk_off_3, 6);
                VirtualProtect((void*)(Address_OPK_3), 6, dwProtect, NULL);
            }
        }

        //-- Invisible Vehicle --//
        if(CH_Invisible_Vehicle)
        {
            const BYTE invisible_vehicle_on[2] = { 0x1C, 0x8B };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Invisible_Vehicle), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Invisible_Vehicle), &invisible_vehicle_on, 2);
                VirtualProtect((void*)(Address_Invisible_Vehicle), 2, dwProtect, NULL);
            }
        }
        if(!CH_Invisible_Vehicle)
        {
            const BYTE invisible_vehicle_off[2] = { 0x0C, 0x8B };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Invisible_Vehicle), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Invisible_Vehicle), &invisible_vehicle_off, 2);
                VirtualProtect((void*)(Address_Invisible_Vehicle), 2, dwProtect, NULL);
            }
        }

        //-- Prone --//
        if(CH_Prone_CQC)
        {
            const BYTE prone_cqc_on[2] = { 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Prone_CQC), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Prone_CQC), &prone_cqc_on, 2);
                VirtualProtect((void*)(Address_Prone_CQC), 2, dwProtect, NULL);
            }
        }
        if(!CH_Prone_CQC)
        {
            const BYTE prone_cqc_off[2] = { 0x74, 0x0C };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Prone_CQC), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Prone_CQC), &prone_cqc_off, 2);
                VirtualProtect((void*)(Address_Prone_CQC), 2, dwProtect, NULL);
            }
        }

        //-- Artillery --//
        if(CH_Artillery)
        {
            const BYTE artillery_1_on[1] = { 0xEB };
            const BYTE artillery_2_on[2] = { 0x90, 0x90 };
            const BYTE artillery_3_on[2] = { 0xEB, 0x31 };
            const BYTE artillery_4_on[2] = { 0x90, 0x90 };
            const BYTE artillery_5_on[2] = { 0x90, 0x90 };
            const BYTE artillery_6_on[2] = { 0xEB, 0x25 };
            const BYTE artillery_7_on[2] = { 0xEB, 0x2C };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Artillery_1), 1, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_1), &artillery_1_on, 1);
                VirtualProtect((void*)(Address_Artillery_1), 1, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_2), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_2), &artillery_2_on, 2);
                VirtualProtect((void*)(Address_Artillery_2), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_3), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_3), &artillery_3_on, 2);
                VirtualProtect((void*)(Address_Artillery_3), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_4), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_4), &artillery_4_on, 2);
                VirtualProtect((void*)(Address_Artillery_4), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_5), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_5), &artillery_5_on, 2);
                VirtualProtect((void*)(Address_Artillery_5), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_6), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_6), &artillery_6_on, 2);
                VirtualProtect((void*)(Address_Artillery_6), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_7), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_7), &artillery_7_on, 2);
                VirtualProtect((void*)(Address_Artillery_7), 2, dwProtect, NULL);
            }
        }
        if(!CH_Artillery)
        {
            const BYTE artillery_1_off[1] = { 0x7D };
            const BYTE artillery_2_off[2] = { 0x75, 0x5E };
            const BYTE artillery_3_off[2] = { 0x74, 0x31 };
            const BYTE artillery_4_off[2] = { 0x75, 0x33 };
            const BYTE artillery_5_off[2] = { 0x75, 0x25 };
            const BYTE artillery_6_off[2] = { 0x7A, 0x25 };
            const BYTE artillery_7_off[2] = { 0x75, 0x2C };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Artillery_1), 1, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_1), &artillery_1_off, 1);
                VirtualProtect((void*)(Address_Artillery_1), 1, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_2), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_2), &artillery_2_off, 2);
                VirtualProtect((void*)(Address_Artillery_2), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_3), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_3), &artillery_3_off, 2);
                VirtualProtect((void*)(Address_Artillery_3), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_4), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_4), &artillery_4_off, 2);
                VirtualProtect((void*)(Address_Artillery_4), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_5), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_5), &artillery_5_off, 2);
                VirtualProtect((void*)(Address_Artillery_5), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_6), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_6), &artillery_6_off, 2);
                VirtualProtect((void*)(Address_Artillery_6), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Artillery_7), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Artillery_7), &artillery_7_off, 2);
                VirtualProtect((void*)(Address_Artillery_7), 2, dwProtect, NULL);
            }
        }

        //-- Crazy Vehicle --//
        if(CH_Crazy_Vehicle)
        {
            const BYTE crazy_vehicle_1_on[2] = { 0x90, 0x90 };
            const BYTE crazy_vehicle_2_on[6] = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;
                        
                VirtualProtect((void*)(Address_Crazy_Vehicle_1), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Crazy_Vehicle_1), &crazy_vehicle_1_on, 2);
                VirtualProtect((void*)(Address_Crazy_Vehicle_1), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Crazy_Vehicle_2), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Crazy_Vehicle_2), &crazy_vehicle_2_on, 6);
                VirtualProtect((void*)(Address_Crazy_Vehicle_2), 6, dwProtect, NULL);
            }                    
        }
        if(!CH_Crazy_Vehicle)
        {
            {
                const BYTE crazy_vehicle_1_off[2] = { 0x74, 0x14 };
                const BYTE crazy_vehicle_2_off[6] = { 0x0F, 0x85, 0x7F, 0xF9, 0xFF, 0xFF };
                {
                    DWORD dwProtect;
                            
                    VirtualProtect((void*)(Address_Crazy_Vehicle_1), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                    memcpy((void*)(Address_Crazy_Vehicle_1), &crazy_vehicle_1_off, 2);
                    VirtualProtect((void*)(Address_Crazy_Vehicle_1), 2, dwProtect, NULL);

                    VirtualProtect((void*)(Address_Crazy_Vehicle_2), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
                    memcpy((void*)(Address_Crazy_Vehicle_2), &crazy_vehicle_2_off, 6);
                    VirtualProtect((void*)(Address_Crazy_Vehicle_2), 6, dwProtect, NULL);
                }
            }                        
        }

        //-- NFD_Vehicle --//
        if(CH_NFD_Vehicle)
        {
            const BYTE nfd_vehicle_on[2] = { 0x0F, 0x85 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_NFD_Vehicle), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_NFD_Vehicle), &nfd_vehicle_on, 2);
                VirtualProtect((void*)(Address_NFD_Vehicle), 2, dwProtect, NULL);
            }
        }
        if(!CH_NFD_Vehicle)
        {
            const BYTE nfd_vehicle_off[2] = { 0x0F, 0x84 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_NFD_Vehicle), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_NFD_Vehicle), &nfd_vehicle_off, 2);
                VirtualProtect((void*)(Address_NFD_Vehicle), 2, dwProtect, NULL);
            }
        }

        //-- No Bounds Static --//
        if(CH_No_Bounds_Static)
        {
            const BYTE no_bounds_static_on[2] = { 0x0F, 0x89 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_No_Bounds_Static), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_No_Bounds_Static), &no_bounds_static_on, 2);
                VirtualProtect((void*)(Address_No_Bounds_Static), 2, dwProtect, NULL);
            }
        }
        if(!CH_No_Bounds_Static)
        {
            const BYTE no_bounds_static_off[2] = { 0x0F, 0x85 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_No_Bounds_Static), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_No_Bounds_Static), &no_bounds_static_off, 2);
                VirtualProtect((void*)(Address_No_Bounds_Static), 2, dwProtect, NULL);
            }
        }

        //-- Super Vehicle --//
        if(CH_Super_Vehicle)
        {
            const BYTE super_vehicle_1_on[2] = { 0x90, 0x90 };
            const BYTE super_vehicle_2_on[6] = { 0xEB, 0x1E, 0x90, 0x90, 0x90, 0x90 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Super_Vehicle_1), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Super_Vehicle_1), &super_vehicle_1_on, 2);
                VirtualProtect((void*)(Address_Super_Vehicle_1), 2, dwProtect, NULL);

                VirtualProtect((void*)(Address_Super_Vehicle_2), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Super_Vehicle_2), &super_vehicle_2_on, 2);
                VirtualProtect((void*)(Address_Super_Vehicle_2), 2, dwProtect, NULL);
            }
        }
        if(!CH_Super_Vehicle)
        {
            const BYTE super_vehicle_1_off[2] = { 0x75, 0x31 };
            const BYTE super_vehicle_2_off[6] = { 0x8B, 0x0D, 0x60, 0x80, 0xB7, 0x00 };
            {
                DWORD dwProtect;

                VirtualProtect((void*)(Address_Super_Vehicle_1), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Super_Vehicle_1), &super_vehicle_1_off, 2);
                VirtualProtect((void*)(Address_Super_Vehicle_1), 2, dwProtect, NULL);
                
                VirtualProtect((void*)(Address_Super_Vehicle_2), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
                memcpy((void*)(Address_Super_Vehicle_2), &super_vehicle_2_off, 2);
                VirtualProtect((void*)(Address_Super_Vehicle_2), 2, dwProtect, NULL);
            }
        }
Credits: Matzex3
Page 471 of 500 « First 371421461469470 471 472473481 Last »