[Code]Source Codes

[yaker]

kannst du vllt noch d3dbase.h code reistellen daran scheitere ich

[ArkaneMage]

ich kann C und ich glaube das ist fast das gleiche wie C++ ich versteh nur nicht was d3dbase oder so ist!

[yaker]

wäre sehr dankbar für source code für d3dbase.h

[Perience]

Omg, wen man sowas hat braucht man nicht mehr zu lernen, das
ist dan reines Billiges Copy and Past... echt arm finde ich das.
Naja wem es gefällt, wetten keiner versteht davon was?

[yaker]

ich habe aber ka wie man d3dbase.h codet

[St3r3o]

wär echt cool wenn die noch reingestellt wird, und vielleicht ein tut noch dazu

[EDIT:

Folgende Sachen fehlen da noch :

- Choke.h
- Support.h
- detours.h
- Guid.h
- bypass.h
- d3dbase.h
- StdAfx.h
- d3d8.h

Also mit den Source Codes kann man keinen Hack programmieren.
Ich denk mal *.h Dateien werden die Headerdateien sein. o.O

[St3r3o]

stdafx.h

// stdafx.h : Includedatei für Standardsystem-Includedateien
// oder häufig verwendete projektspezifische Includedateien,
// die nur in unregelmäßigen Abständen geändert werden.
#pragma once

// TODO: Hier auf zusätzliche Header, die das Programm erfordert, verweisen.

[derahlemer]

Originally Posted by St3r3o

stdafx.h

Edit-Button benutzen und keine Doppelposts machen.

[Aless™]

Also
Wer hat den Source Code fertig gekriegt?

[megalaz]

GEIL doch kann mir mla einer sagen wie man die codes bekommt ich hab schon die sufu benutz aber da kam nix

[derahlemer]

Hier sind welche:

 Spoiler

if (CH_aim)
{
if(GetAsyncKeyState(VK_RBUTTON)&1<< 0xF)
{
long t=2;
unsigned long Protection;
VirtualProtect((void*)(scope_Addie1), sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)(scope_Addie1), &t , sizeof(t));
VirtualProtect((void*)(scope_Addie1), sizeof(t), Protection, 0);
}
else
{
long t=0;
unsigned long Protection;
VirtualProtect((void*)(scope_Addie1), sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)(scope_Addie1), &t , sizeof(t));
VirtualProtect((void*)(scope_Addie1), sizeof(t), Protection, 0);
}
}


SVP
if ( CH_SVP )
{
const BYTE vantage[4] = {0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(Svp_Addie1), 4, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(Svp_Addie1), &vantage, 4);
VirtualProtect((void*)(Svp_Addie1), 4, dwProtect, NULL);
}
}
else//off below

{
const BYTE vantageoff[4] = {0x8B, 0x54, 0x24, 0x04};

{
DWORD dwProtect;
VirtualProtect((void*)(Svp_Addie1), 4, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(Svp_Addie1), &vantageoff, 4);
VirtualProtect((void*)(Svp_Addie1), 4, dwProtect, NULL);
}
}
----
void Bypass()
delete by me
----
if (SuperJump)
{
if (GetAsyncKeyState(VK_CONTROL) &1)
{
DWORD dwPlayerPtr = *(DWORD*)PLAYER;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x190) = SuperJump * 1000;
}
}
}



if (Mapname)
{
sprintf (mapnaame, "[Mapname] %s", (ADR_Mapname));
DrawMini(mapnaame, 400,10,textWhite,abc1233);
}




[2] {0xEB, 0xFE}//JUMPBYTES


//Write To Memory
DWORD OldProtection;
void WriteToMemory(DWORD Offset, DWORD Pointer, DWORD Length){
VirtualProtect((void *)Offset, Length, PAGE_EXECUTE_READWRITE, &OldProtection);
RtlMoveMemory((void *)Offset, (const void*)Pointer, Length);
VirtualProtect((void *)Offset, Length, OldProtection, &OldProtection);
}
void ModifyMemory( BYTE *Offset, BYTE *ByteArray, DWORD Length){
for(DWORD i = 0; i < Length; i++)
WriteToMemory((DWORD)Offset + i, (DWORD)ByteArray + i, 1);
}

---

if (Bypass)
delete by me

-----
Unlim Ammo


if( CH_Unlimammo )
{
FUNCTION NAME( ( void* )ullammo_Addie1, 3);//patched
FUNCTION NAME( ( void* )ullammo_Addie2, 3);//patched
FUNCTION NAME( ( void* )ullammo_Addie3, 3);//patched
}
{



if( CH_Boxs )
{
D3D_NOP( ( void* )boxs_Addie1, 1);//no one uses
}

if (Antiban)
{
DWORD dwProtect;

VirtualProtect((void*)(ADR_HACKSHIELD), 8, PAGE_EXECUTE_READWRITE, &dwProtect);
*(int*)(0x005F35D0)= 2415922370, 8;
VirtualProtect((void*)(ADR_HACKSHIELD), 8, dwProtect, NULL);
}



ESP
if( CH_Esp )
{
D3D_NOP( ( void* )esp_Addie1, 1);//Works
}



{

Invis
if( CH_Invisable )
{
D3D_NOP ( ( void* ) Invis_Addie1,1);//patched
}
{


if (Roommaster)
{
DWORD dwPlayerPointer = *(DWORD*)0xCD4930;
if(dwPlayerPointer != 0)
{
*(long*)(dwPlayerPointer + 0x39A00) = *(long*)(dwPlayerPointer + 0x4E324);
}
}
if (Supermaster)
{
DWORD dwPlayerPointer = *(DWORD*)0xCD4930;
if(dwPlayerPointer != 0)
{
*(long*)(dwPlayerPointer + 0x395EC) = *(long*)(dwPlayerPointer + 0x4E324);
}
}


5TH Slot
if (CH_Slot)
{
long t=5;
unsigned long Protection;
VirtualProtect((void*)slot_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)slot_Addie1, &t , sizeof(t));
VirtualProtect((void*)slot_Addie1, sizeof(t), Protection, 0);
}




Spawn
if (CH_Spawn)
{
long t=0;
unsigned long Protection;
VirtualProtect((void*)spawn_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)spawn_Addie1, &t , sizeof(t));
VirtualProtect((void*)spawn_Addie1, sizeof(t), Protection, 0);

VirtualProtect((void*)spawn_Addie2, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)spawn_Addie2, &t , sizeof(t));
VirtualProtect((void*)spawn_Addie2, sizeof(t), Protection, 0);
}



Super Jump
if (CH_Jump)
{
if(GetAsyncKeyState(VK_CONTROL) &1)
{
DWORD dwPlayerPtr = *(DWORD*)playrerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x190) = 2000;
}
}
}



Stanima
if (CH_Stamina)
{
DWORD dwPlayerPtr = *(DWORD*)playrerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x2A4) = 100;
}
}

Stanima
if (CH_Stamina)
{
DWORD dwPlayerPtr = *(DWORD*)playerpointer;
if(dwPlayerPtr != 0)
{
if(*(float*)(dwPlayerPtr+0x2A4) <= 25) {
*(float*)(dwPlayerPtr+0x2A4) = 25;
}
}


GlassWall - Add a hotkey unless its on all the time!
if (CH_Glasswalls)
{
*(int*)0xB70EF0 = 0, 4;
}

No Fall Damage
if (CH_NFD)
{
DWORD dwPlayerPtr = *(DWORD*)playrerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x27C) = -20000;
}
}

Weapons - 30 = Scorps/42=Shotgun
if (weapons)
{
if(GetAsyncKeyState(VK_F5) &1)
{
DWORD dwPlayerPtr = *(DWORD*)playerpointer;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr+0x4C) = 30;
}
}
}

No Bounds
if (CH_Nobounds)
{
long t=0;
unsigned long Protection;
VirtualProtect((void*)nobounds_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)nobounds_Addie1, &t , sizeof(t));
VirtualProtect((void*)nobounds_Addie1, sizeof(t), Protection, 0);

VirtualProtect((void*)nobounds_Addie2, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)nobounds_Addie2, &t , sizeof(t));
VirtualProtect((void*)nobounds_Addie2, sizeof(t), Protection, 0);
}




Anti Kick
if (CH_Anti)
{

const BYTE anti[6] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(anti_Addie1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(anti_Addie1), &anti, 6);
VirtualProtect((void*)(anti_Addie1), 6, dwProtect, NULL);
}





0-Delay
const BYTE zero[3] = {0x90, 0x90, 0x90};

if ( Delay )
{
DWORD dwProtect;
VirtualProtect((void*)(delay_addie1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(delay_addie1), &zero, 3);
VirtualProtect((void*)(delay_addie1), 3, dwProtect, NULL);
}






FullBright
if (CH_fullbright)
{
long t=1092779973;
unsigned long Protection;
VirtualProtect((void*)bright_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)bright_Addie1, &t , sizeof(t));
VirtualProtect((void*)bright_Addie1, sizeof(t), Protection, 0);

VirtualProtect((void*)bright_Addie2, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)bright_Addie2, &t , sizeof(t));
VirtualProtect((void*)bright_Addie2, sizeof(t), Protection, 0);

VirtualProtect((void*)bright_Addie2, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)bright_Addie2, &t , sizeof(t));
VirtualProtect((void*)bright_Addie2, sizeof(t), Protection, 0);
}[/code]

Premium
if (premium)
{
DWORD dwPlayerPtr = *(DWORD*)premium_addie1;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr+0x364) = 3, 10;
}
}




if (No_Spread)
{
long t=0;
unsigned long Protection;
VirtualProtect((void*)No_Spread_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)spread_addie, &t , sizeof(t));
VirtualProtect((void*)No_Spread_Addie1, sizeof(t), Protection, 0);
}



Scope
if (scope)
{
if (GetAsyncKeyState(VK_RBUTTON)&1)
{
*(int*)0xScopeAddy = 2, 4;
}
}




No Recoil
if (Norecoil)
{
DWORD dwPlayerPtr = *(DWORD*)playerpointer;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x2F4) = 0;
*(float*)(dwPlayerPtr+0x2F8) = 0;
*(float*)(dwPlayerPtr+0x2FC) = 0;
}
}

if (Slot5==1)
{
DWORD dwPlayerPointer = *(DWORD*)ADR_SERVER;
if(dwPlayerPointer != 0)
{
*(long*)(dwPlayerPointer + 0x3EA5C) = 5;
*(long*)(dwPlayerPointer + 0x3EA5D) = 6;
*(long*)(dwPlayerPointer + 0x3EA5E) = 7;
*(long*)(dwPlayerPointer + 0x3EA5F) = 8;
}
}


BoneShot
const BYTE Nopboneshot[1] = {0x31};

if (boneshot)
{
DWORD dwProtect;
VirtualProtect((void*)(boneshot_addie1), 1, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(boneshot_addie1), &Nopboneshot, 1);
VirtualProtect((void*)(boneshot_addie1), 1, dwProtect, NULL);
}



Shoot Through Walls
{
if (stw)
{

const BYTE stw[6] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(stw_addie1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(stw_addie1), &stw, 6);
VirtualProtect((void*)(stw_addie1), 6, dwProtect, NULL);
}
}
else
{

const BYTE STWoff[3] = {0x8b, 0x51, 0x38};
{

DWORD dwProtect;
VirtualProtect((void*)(STW_Addie1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(STW_Addie1), &STWoff, 3);
VirtualProtect((void*)(STW_Addie1), 3, dwProtect, NULL);
}



ChrossHaires
if (xcrosshairone)
{
romeotomojboy( ( void* )crosshair1_addie1, 6);
romeotomojboy( ( void* )crosshair1_addie2, 6);
}

if (crosshairrtwo)
{
romeotomojboy( ( void* )crosshair2_addie1, 6);
romeotomojboy( ( void* )crosshair2_addie2, 6);
}

if (crosshairrthree)
{
romeotomojboy( ( void* )crosshair3_addie1, 6);
romeotomojboy( ( void* )crosshair3_addie2, 6);
}[/code]



no fog
if (fog)
{
*(float*)0xB70EF0 = 1166127104;//far fog address
*(float*)0xB70EEC = 0; //nerfog addres
}



No Water
if (nowater)
{
long t=0;
unsigned long Protection;
VirtualProtect((void*)nowater_addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)nowater_addie1, &t , sizeof(t));
VirtualProtect((void*)nowater_addie1, sizeof(t), Protection, 0);
}



Fast All
if (fastall)
{
long t=1092779973;
unsigned long Protection;
VirtualProtect((void*)fast_addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)fast_addie1, &t , sizeof(t));
VirtualProtect((void*)fast_addie1, sizeof(t), Protection, 0);

VirtualProtect((void*)fast_addie2, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)fast_addie2, &t , sizeof(t));
VirtualProtect((void*)fast_addie2, sizeof(t), Protection, 0);

VirtualProtect((void*)fast_addie3, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)fast_addie3, &t , sizeof(t));
VirtualProtect((void*)fast_addie3, sizeof(t), Protection, 0);

VirtualProtect((void*)fast_addie4, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)fast_addie4, &t , sizeof(t));
VirtualProtect((void*)fast_addie4, sizeof(t), Protection, 0);
}

Vechicle Invisible
if (vechicleinvisible)
{

const BYTE vechicleinvisible[3] = {0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(vechinvis_addie1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(vechinvis_addie1), &vechicleinvisible, 3);
VirtualProtect((void*)(vechinvis_addie1), 3, dwProtect, NULL);
}
}



Vechile GPS
if (vechicleradar)
{
long t=1;
unsigned long Protection;
VirtualProtect((void*)vechicleradar_addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)vechicleradar_addie1, &t , sizeof(t));
VirtualProtect((void*)vechicleradar_addie1, sizeof(t), Protection, 0);
}



Medic , Repair , Ammo
if (medic)
{

const BYTE medic[6] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(medic_addie1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(medic_addie1), &medic, 6);
VirtualProtect((void*)(medic_addie1), 6, dwProtect, NULL);
}
}

if (ammo)
{

const BYTE ammo[6] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(ammo_addie1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(ammo_addie1), &ammo, 6);
VirtualProtect((void*)(ammo_addie1), 6, dwProtect, NULL);
}
}


if (repair)
{

const BYTE repair[6] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(repair_addie1), 6, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(repair_addie1), &repair, 6);
VirtualProtect((void*)(repair_addie1), 6, dwProtect, NULL);
}
}

Binocs
if (CH_Binoculars)
{
if(GetAsyncKeyState(VK_F8) &1)
{
DWORD dwPlayerPtr = *(DWORD*)Playerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr+0x4C) = 69;
}
}
}


vechicleradar
if (vechicleradar)
{
long t=1;
unsigned long Protection;
VirtualProtect((void*)vechicleradar_addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)vechicleradar_addie1, &t , sizeof(t));
VirtualProtect((void*)vechicleradar_addie1, sizeof(t), Protection, 0);
}

CrossHaires
if (xcrosshairone)
{
D3D_NOPING( ( void* )crosshair1_addie1, 6);
D3D_NOPING( ( void* )crosshair1_addie2, 6);
}

if (crosshairrtwo)
{D3D_NOPING( ( void* )crosshair2_addie1, 6);
D3D_NOPING( ( void* )crosshair2_addie2, 6);
}

if (crosshairrthree)
{
D3D_NOPING( ( void* )crosshair3_addie1, 6);
D3D_NOPING( ( void* )crosshair3_addie2, 6);
}

Chams
if (CH_Chams) ///calls Chams On/Off
{
if (Playerbody) //we defined our playerbody already as stride 44
{
m_pD3Ddev->SetRenderState(D3DRS_ZENABLE,false);
m_pD3Ddev->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
m_pD3Ddev->SetTexture( 0, texYellow); ///heres are colors
m_pD3Ddev->DrawIndexedPrimitive(PrimitiveType, minIndex, NumVertices, startIndex, primCount);
m_pD3Ddev->SetRenderState(D3DRS_ZENABLE, true);
m_pD3Ddev->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
m_pD3Ddev->SetTexture( 0, texGreen); //colors
}

}


Fog
if (fog)
{
*(float*)0xB70EF0 = 1166127104;//far fog address
*(float*)0xB70EEC = 0; //nerfog addres
}

GlassWalls Redone!
if ( CH_Glasswalls )
{
if(GetAsyncKeyState(VK_DELETE) &1)
{
*(int*)0xB7D0D0 = 0, 4;
}
}

BoneShot
const BYTE Nopboneshot[1] = {0x31};

if ( CH_Boneshot )
{
DWORD dwProtect;
VirtualProtect((void*)(Boneshot_Addie1), 1, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(Boneshot_Addie1), &Nopboneshot, 1);
VirtualProtect((void*)(Boneshot_Addie1), 1, dwProtect, NULL);
}

WTW
if ( CH_WTW )
{
const BYTE wtw[6] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(WTW_Addie1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(WTW_Addie1), &wtw, 3);
VirtualProtect((void*)(WTW_Addie1), 3, dwProtect, NULL);
}
}
else
{
const BYTE wtwoff[3] = {0xD8, 0x4A, 0x08};
{
DWORD dwProtect;
VirtualProtect((void*)(WTW_Addie1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(WTW_Addie1), &wtwoff, 3);
VirtualProtect((void*)(WTW_Addie1), 3, dwProtect, NULL);
}
}

SVP
if ( CH_SVP )
{
const BYTE vantage[4] = {0x90, 0x90, 0x90, 0x90};

{
DWORD dwProtect;
VirtualProtect((void*)(Svp_Addie1), 4, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(Svp_Addie1), &vantage, 4);
VirtualProtect((void*)(Svp_Addie1), 4, dwProtect, NULL);
}
}
else//off below

{
const BYTE vantageoff[4] = {0x8B, 0x54, 0x24, 0x04};

{
DWORD dwProtect;
VirtualProtect((void*)(Svp_Addie1), 4, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(Svp_Addie1), &vantageoff, 4);
VirtualProtect((void*)(Svp_Addie1), 4, dwProtect, NULL);
}
}

SkyStorm
if (storm)
{
DWORD dwPlayerPtr = *(DWORD*)Playerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x190) = 2000;
}


Silent Walk
const BYTE Walk[2] = {0x90, 0x90};
if (CH_Silentwalk)
{
DWORD dwProtect;
VirtualProtect((void*)(Silentwalk_Addie1), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(Silentwalk_Addie1), &Walk, 2);
VirtualProtect((void*)(Silentwalk_Addie1), 2, dwProtect, NULL);
}

DIG
if ( CH_Dig )
{
if(GetAsyncKeyState(VK_F3) &1)
{
DWORD dwPlayerPtr = *(DWORD*)Playerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x190) = -2000;
}
}
}

All Slots
if ( CH_Allslots )
{
for (long t=5;t < 9; t++){
unsigned long Protection;
VirtualProtect((void*)Allslots_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)Allslots_Addie1, &t , sizeof(t));
VirtualProtect((void*)Allslots_Addie1, sizeof(t), Protection, 0);
}
}

Scorps
if (CH_Scorps)
{
if(GetAsyncKeyState(VK_F6) &1)
{
DWORD dwPlayerPtr = *(DWORD*)Playerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr+0x4C) = 30;
}
}
}

Shotty
if (CH_Winchester)
{
if(GetAsyncKeyState(VK_F5) &1)
{
DWORD dwPlayerPtr = *(DWORD*)Playerpointer_Addie1;
if(dwPlayerPtr != 0)
{
*(long*)(dwPlayerPtr+0x4C) = 42;// ok i c lemme send me my code ok
}//this should worl allready... it doest do you wanna see no whereis this ? EndScene? this is begin scene
}
}

Radar
if ( CH_Radar )
{
long t=1;
unsigned long Protection;
VirtualProtect((void*)Radar_Addie1, sizeof(t), PAGE_READWRITE, &Protection);
memcpy((void*)Radar_Addie1, &t , sizeof(t));
VirtualProtect((void*)Radar_Addie1, sizeof(t), Protection, 0);
}


if (CH_Weapon==1)
{
if(GetAsyncKeyState(F1))
{
Wrrk = GetCurrentProcess();
int addy=0x013FD1F8;
int offset=0x04c;
int value = 42;
long maddy;
long saddy;
ReadProcessMemory(Wrrk, (LPVOID*)(DWORD) addy, &maddy, sizeof(maddy), NULL);
saddy = maddy + offset;
WriteProcessMemory(Wrrk, (LPVOID*)(DWORD) saddy, &value, sizeof(value), NULL);
}
}



if (CH_Auto_Medic)
{
D3D_NOPINGS((void* )Auto_Medic_Addie1, 6);
}

if (CH_Auto_Ammo)
{
D3D_NOPINGS((void* )Auto_Medic_Addie1, 6);
}

void D3D_NOP( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x1C};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}





if(Speed)
{
*(float*) speed_add1 = 100;
}
else
{
*(float*) speed_add1 = 9.6;
}





{
if (CH_No_Recoil)
{
Wrrk = GetCurrentProcess();
int addy=0x13FC1B0;
int offset1=0x2F4;
int offset2=0x2F8;
int offset3=0x2FC;
int value = 0;
long maddy;
long saddy;

ReadProcessMemory(Wrrk, (LPVOID*)(DWORD) addy, &maddy, sizeof(maddy), NULL);

saddy = maddy + offset1 + offset2 + offset3;

WriteProcessMemory(Wrrk, (LPVOID*)(DWORD) saddy, &value, sizeof(value), NULL);
}

could it be case sensiti v no thats how mine is like u have them now


if (CH_GMSpectate==1){
DWORD dwPlayerPtr = *(DWORD*)ADR_SERVERBASE;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x35c) = 5.0f;
}
}


if (CH_GMSpectate==0){
DWORD dwPlayerPtr = *(DWORD*)ADR_SERVERBASE;
if(dwPlayerPtr != 0)
{
*(float*)(dwPlayerPtr+0x35c) = 0.0f;
}
}


//////////////////0 DELAY///////////////////////////
const BYTE zero[3] = {0x90, 0x90, 0x90};

if ( CH_delay )
{
DWORD dwProtect;
VirtualProtect((void*)(delay_Addie1), 3, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(delay_Addie1), &zero, 3);
VirtualProtect((void*)(delay_Addie1), 3, dwProtect, NULL);
}
else//off below
{
const BYTE zerooff[2] = {0x74, 0x43};

if ( CH_delay )
{
DWORD dwProtect;
VirtualProtect((void*)(delay_Addie1), 2, PAGE_EXECUTE_READWRITE, &dwProtect);
memcpy((void*)(delay_Addie1), &zerooff, 2);
VirtualProtect((void*)(delay_Addie1), 2, dwProtect, NULL);
}
}



void D3D_NOPING( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}

void Automedic()
{
D3D_NOPING((void* )Automedic_Addie1, 6);
}

[yaker]

hat jmd ne source von d3dbase.h pls need it

[V.I.P.H.a.c.k.e.r]

Naja leider is er Banned ich fand trotz seiner Verasche wie ich mitbekommen hab is er ganz ok...Ich denke jeder hat mal eine macke lol

[juhaownn]

Jo hätte dass auch ma gerne erklärt ^^

[Fuchseibua123]

why ist HOT eigentlich banned ??