NFD
Spoiler
if (NFD==1)
{
DWORD dwPlayerPtr = *(DWORD*)ADR_PLAYERPTR;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+OFS_NFD) = -20000; //Fall Height
}
}

SPEED
Spoiler
if(CH_Speed=0)
{
*(float*)ADR_SPEED = 89; //normal speed
}
if(CH_Speed=1)
{
*(float*)ADR_SPEED = 160; //normal speed
}

NoRecoil
Spoiler
if (CH_NoRecoil==1) ()
{
DWORD dwPlayerPtr = *(DWORD*)ADR_PLAYERPTR;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+OFS_NORECOIL1) = 0;
*(float*)(dwPlayerPtr+OFS_NORECOIL2) = 0;
*(float*)(dwPlayerPtr+OFS_NORECOIL3) = 0;
}
}

NoSpawn
Spoiler
If(CH_NoSpawn==1)
{
*(int*)ADR_NOSPAWN1 = 0;
*(int*)ADR_NOSPAWN2 = 0;
}

SCOPE
Spoiler
if(CH_Scope==1)
{
if(GetAsyncKeyState(VK_RBUTTON))
{
*(int*)(ADR_SCOPE) = (int)1;
}
else
{
*(int*)(ADR_SCOPE) = (int)0;
}
}

NoSpread
Spoiler
if (CH_NoSpread)
{
*(int*)ADR_NOSPREAD = 0;
}

NoBounds
Spoiler
if(CH_NoBounds)
{
*(int*)ADR_NOBOUNDS1 = 0;
*(int*)ADR_NOBOUNDS2 = 0;
}

NoWater
Spoiler
void NoWater ()
{
*(int*)(ADR_NOWATER) = 0;
}

NoFog
Spoiler
if(CH_NoFog==1) pDevice->SetRenderState(D3DRS_FOGENABLE, false);

SuperJump
Spoiler
if (CH_SuperJump==1)
{
if(GetAsyncKeyState(VK_CONTROL)&1) //VK_CONTROL = CTRL, cambiarlo con il tasto che si desidera =)
{
DWORD dwPlayerPtr = *(DWORD*)ADR_PLAYERPTR;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+OFS_Z) = 1000; //Height of Jump
}
}
}

FullBright
Spoiler
if (CH_FullBright==1){
pDevice->SetRenderState(D3DRS_LIGHTING, false);
pDevice->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_ARGB(255,255,255,255));
}else{
pDevice->SetRenderState(D3DRS_AMBIENT, false);}

SpeedRoll
Spoiler
if(CH_Speedroll==1)
{
DWORD dwADR_PLAYERPTR = *(DWORD*) ADR_PLAYERPOINTER;

if(dwADR_PLAYERPTR!=0)
{
switch(CH_Speedroll)
{
case 1:*(float*)ADR_SPEEDROLL = 7.0f;break;
}
}
}

Im Drunk
Spoiler
if(CH_ImDrunk==1)
{
*(DWORD*)(ADR_IMDRUNK) = 1;
}

Fast Ammo
Spoiler
if(CH_FastAmmo==1)
{
*(float*)(ADR_FASTAMMO) = 10.0f;
}

Fast Health
Spoiler
if(CH_FastHealth==1)
{
*(float*)(ADR_FASTHEALTH) = 10.0f;

}

Fast Repair
Spoiler
if(CH_FastRepair==1)
{
//*(float*)(ADR_FASTREPAIR) = 5.0f;
}

AntiAfk
Spoiler
if(CH_FastFlag==1)
{
*(float*)(ADR_FASTFLAG) = 10.0f;
}

Teleport
Spoiler
if(CH_Teleport==1){
if (GetAsyncKeyState(VK_F8))//F8 Save PosiTion
{
posiX = *(float*)(dwPlayerPointer + OFS_X);
posiY = *(float*)(dwPlayerPointer + OFS_Y);
posiZ = *(float*)(dwPlayerPointer + OFS_Z);
}
if (GetAsyncKeyState(VK_F9))//Teleport to Position
{
*(float*)(dwPlayerPointer + OFS_X) = posiX;
*(float*)(dwPlayerPointer + OFS_Y) = posiY;
*(float*)(dwPlayerPointer + OFS_Z) = posiZ;
}
}
if(CH_Teleport==2){
*(float*)(dwPlayerPointer + OFS_X) = posiX;
*(float*)(dwPlayerPointer + OFS_Y) = posiY;
*(float*)(dwPlayerPointer + OFS_Z) = posiZ;
}

Premium
Spoiler
if(CH_Premium!=0)
{

switch(CH_Premium)
{
case 1: *(int*)(dwServerPointer+OFFSET_PREM) = 1;
*(float*)(dwServerPointer+OFFSET_PREM2) = 1;break;
case 2: *(int*)(dwServerPointer+OFFSET_PREM) = 2;
*(float*)(dwServerPointer+OFFSET_PREM2) = 2;break;
case 3: *(int*)(dwServerPointer+OFFSET_PREM) = 3;
*(float*)(dwServerPointer+OFFSET_PREM2) = 3;break;
case 4: *(int*)(dwServerPointer+OFFSET_PREM) = 4;
*(float*)(dwServerPointer+OFFSET_PREM2) = 4;break;
}
}
}

5th Slot
Spoiler
if(CH_Slot5==1)
{
*(long*)(dwServerPointer+OFS_5SLOT) = 1;
}

SuperMaster
Spoiler
if(CH_SuperMaster==1)
{
DWORD dwServerPtr = *(DWORD*)ADR_SERVERPTR;
if(dwServerPtr != 0)
{
*(int*)(dwServerPtr+OFS_SUPERMASTER) = 1;
}
}

Dinar
Spoiler
if(CH_Dinar==1)
{
DWORD dwPlayerPtr = *(DWORD*)ADR_SERVERPTR;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr + OFS_DINAR) = 999999999;
}
}

Liv. 100

Spoiler
if(CH_Level==1)
{
DWORD dwPlayerPtr = *(DWORD*)ADR_SERVERPTR;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr + OFS_LEVEL) = 999999999;
}
}

Sp 5-10%
Spoiler
if(CH_SP==1)
{
*(int*)(ADR_SP_5) = 1;
}
if(CH_SP2==1)
{
*(int*)(ADR_SP_10) = 1;
}

ExtraAmmo 1
Spoiler
if(CH_ExtraAmmo1==1)
{
*(int*)(ADR_EXTRAAMMO1) = 1;
}

ExtraAmmo 2
Spoiler
if(CH_ExtraAmmo2==1)
{
*(int*)(ADR_EXTRAAMMO2) = 1;
}

NoRoom Restriction
Spoiler
if(CH_NoRoomRestriction==1)
{
WriteMEM((void *)ADR_NOROOMRESTRICTION,(void*)(PBYTE)"\xEB\x68",2 );
}
if(CH_NoRoomRestriction==0)
{
WriteMEM((void *)ADR_NOROOMRESTRICTION,(void*)(PBYTE)"\x75\x68",2 );
}

Sniper 2X
Spoiler
if(CH_Sniper2X==1)
{
*(int*)(ADR_SNIPER2X) = 1;
}

Bandage
Spoiler
if(CH_Bandage==1)
{
*(int*)(ADR_BANDAGE) = 1;
}

Walk Under Water
Spoiler
if(CH_WUW==1)
{
WriteMEM((void *)ADR_WUW,(void*)(PBYTE)"\x90\x90",2);
}
if(CH_WUW==0)
{
WriteMEM((void *)ADR_WUW,(void*)(PBYTE)"\x74\x13",2);
}

Walk Trought Wall

Spoiler
if(CH_WTW==1)
{
WriteMEM((void *)ADR_WTW,(void*)(PBYTE)"\x90\x90\x90",3);
}
if(CH_WTW==0)
{
WriteMEM((void *)ADR_WTW,(void*)(PBYTE)"\8\x4A\x08",3);
}

Shoot Trought Wall

Spoiler
if(CH_STW==1)
{
WriteMEM((void *)ADR_STW,(void*)(PBYTE)"\x90\x90\x90",3);
}
if(CH_STW==0)
{
WriteMEM((void *)ADR_STW,(void*)(PBYTE)"\x8B\x51\x34",3);
}

CQC Prone

Spoiler
if(CH_Cqcprone==1)
{
WriteMEM((void *)ADR_PRONE,(void*)(PBYTE)"\x90\x90",2);
}
if(CH_Cqcprone==0)
{
WriteMEM((void *)ADR_PRONE,(void*)(PBYTE)"\x74\x0C",2);
}

AutoMedic
Spoiler
if(CH_AutoMedic==1)
{
WriteMEM((void *)ADR_AUTOMEDIC,(void*)(PBYTE)"\x90\x90\x90\x90\x9 0\x90",6);
}
if(CH_AutoMedic==0)
{
WriteMEM((void *)ADR_AUTOMEDIC,(void*)(PBYTE)"\x0F\x85\xA6\x00\x0 0\x00",6);
}

AutoAmmo
Spoiler
if(CH_AutoAmmo==1)
{
WriteMEM((void *)ADR_AUTOAMMO,(void*)(PBYTE)"\x90\x90\x90\x90\x90 \x90",6);
}
if(CH_AutoAmmo==0)
{
WriteMEM((void *)ADR_AUTOAMMO,(void*)(PBYTE)"\x0F\x85\xA2\x00\x00 \x00",6);
}

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

Glass Walls Memory
Spoiler
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);
}
}

All Sloth
Spoiler
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;
}
}

0 Delay
Spoiler
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 Kik
Spoiler
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);
}
}

Invisibile
Spoiler
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);;
}

Ragar GPS Enemy
Spoiler
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
Spoiler
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
Spoiler
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 Name
Spoiler
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 Health --//
Spoiler
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 --//

Auto Repair
Spoiler
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 --//
Spoiler
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);
}
}

OPK

Spoiler
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);
}
}

Artillery
Spoiler
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);
}
}

By Marekiarox

Metti tutto nella TAG code e questo il uno spoiler

Copiato e incollato da un mio vecchio post in uebarena
Cordiali Saluti,
Pippo2040

Aggiustato Scusa Del Ritardo non ho avuto Tempo... @[Solo gli utenti registrati possono vedere i link. Clicca qui per registrarti..]

Sposto in "Address"

Ricordo che sono da aggiornare i PBYTE

Originariamente Scritto da SanMarinus

Ricordo che sono da aggiornare i PBYTE

Normale Aggiornateli!!!