WarRock EU - Code Snippets

[xCyberRazzer]

struct CPlayer
{
	CHAR xJumpToAdress0[0x10194];//0x00
	FLOAT Pitch;//0x10194
	CHAR xJumpToAdress1[0x18];//0x10198
	FLOAT Yaw;//0x101B0
	CHAR xJumpToAdress2[0xC];//0x101B4
	FLOAT ViewX;//0x101C0
	FLOAT ViewY;//0x101C4
	FLOAT ViewZ;//0x101C8
	CHAR xJumpToAdress3[0x6C];//0x101CC
	BYTE PlayerState;//0x10238
	CHAR xJumpToAdress4[0xA7];//0x10239
	FLOAT PosX;//0x102E0
	CHAR xJumpToAdress5[0x4];//0x102E4
	FLOAT PosY;//0x102E8
	CHAR xJumpToAdress6[0x4];//0x102EC
	FLOAT PosZ;//0x102F0
};

struct CBase
{
    CPlayer* pLocal;
    char xJumpToAdress1[0x11E190];
    CPlayer** pGlobal;
};

if ( cPlayer.CH_PlayerOPK )
{
	for ( INT MaxPlayer = 0; MaxPlayer < 32; MaxPlayer++ )
	{
		p_Player->pGlobal[MaxPlayer]->PosX = 0.0F;
		p_Player->pGlobal[MaxPlayer]->PosY = 0.0F;
		p_Player->pGlobal[MaxPlayer]->PosZ = 0.0F;
	}
}

By CyberRazzer

[_supreme_]

Also.. Theoretisch ist die tBase size ja eigentlich
( tPlayer * 32 ) + tPlayer + 72 + 48
= 0x339318

Peace....

[UnknownData]

Originally Posted by xCyberRazzer

struct CPlayer
{
	CHAR xJumpToAdress0[0x10194];//0x00
	FLOAT Pitch;//0x10194
	CHAR xJumpToAdress1[0x18];//0x10198
	FLOAT Yaw;//0x101B0
	CHAR xJumpToAdress2[0xC];//0x101B4
	FLOAT ViewX;//0x101C0
	FLOAT ViewY;//0x101C4
	FLOAT ViewZ;//0x101C8
	CHAR xJumpToAdress3[0x6C];//0x101CC
	BYTE PlayerState;//0x10238
	CHAR xJumpToAdress4[0xA7];//0x10239
	FLOAT PosX;//0x102E0
	CHAR xJumpToAdress5[0x4];//0x102E4
	FLOAT PosY;//0x102E8
	CHAR xJumpToAdress6[0x4];//0x102EC
	FLOAT PosZ;//0x102F0
};

struct CBase
{
    CPlayer* pLocal;
    char xJumpToAdress1[0x11E190];
    CPlayer** pGlobal;
};

if ( cPlayer.CH_PlayerOPK )
{
	for ( INT MaxPlayer = 0; MaxPlayer < 32; MaxPlayer++ )
	{
		p_Player->pGlobal[MaxPlayer]->PosX = 0.0F;
		p_Player->pGlobal[MaxPlayer]->PosY = 0.0F;
		p_Player->pGlobal[MaxPlayer]->PosZ = 0.0F;
	}
}

By CyberRazzer

Dont Work Bro =)

[xCyberRazzer]

Originally Posted by UnknownData

Dont Work Bro =)

Tell them no ****, it works perfectly well =) =) =) N0ôb.

[UnknownData]

xD Nein Kommt Software Exeption (0x0000005)

[KniifezzZ]

Code For No Recoil Pls

[UnknownData]

DWORD PlayerPTR = *(DWORD*)ADR_Playerpointer;
if(PlayerPTR != 0)
{
*(float*)(PlayerPTR + OFS_NoRecoil1) = 0.0F;
*(float*)(PlayerPTR + OFS_NoRecoil2) = 0.0F;
*(float*)(PlayerPTR + OFS_NoRecoil3) = 0.0F;
}

Viel Spaß

[KniifezzZ]

Thanks

[lujaluja]

Hey in meinem Hack hab ich Boneshot greade hinzugefügt, aber es Crasht nach 30 sek.
Die Scource sieht so aus:
*(double*) MEM_BONESHOT = 1235;
Gibt es einen Bestimmten Bypass für diese Scource, oder eine Möglichkeit sie Crashfrei zu machen`? ^^

PS: Ja, die Scource ist C&P undzwar

[Raz9r]

Originally Posted by _supreme_

Also.. Theoretisch ist die tBase size ja eigentlich
( tPlayer * 32 ) + tPlayer + 72 + 48
= 0x339318

Peace....

typedef struct
{
player_t *m_pCurrentPlayer;
char __reserved0[1171856];
player_t** m_a_pPlayer;
} playerbase_t;

daraus folgt:
sizeof(playerbase_t) = sizeof(player_t *) + sizeof((char &)[1171856]) + sizeof(player_t **)
also:
sizeof(playerbase_t) = 4 + 1171856 + 4 = 1171864

[__BuRn3R]

Hey Leute ich wollte mal fragen ob mir jemand erklären kann wie man Structs ausrechnet ?

[NikM]

Und um das hier zu verstehen sollte man zwischen Dezimal- und Hexerdezimalzahlen hin und her rechnen können.
Also Dezimal zu Hex und umgekehrt. Oder einfach den Rechner von Windoofs benutzen ...
In einer Struktur kann man Variablen speichern und dann mit z.B. mit einem Punktoperator aufrufen, wenn man eine Instanz darauf erstellt hat.
In jeder Struktur hat die erste Variable den Wert 0x00.

struct Struktur
{
    int iVariable1; //0x00
};

Hier hat die Variable iVariable1 den Wert 0x00.
Wenn wir jetzt eine weitere Variable dazufügen hat diese den Wert 0x04.
Einige von euch fragen sich sicherlich "Warum zum Teufel hat die nächste den Wert 0x04 o.O" !
Ganz einfach :P: Ein Integer hat eine Größe von 4 Byte. Dieser Wert wird zu den 0x00 dazu addiert.

struct Struktur
{
    int iVariable1; //0x00
    double dKommazahl1; //0x04
    char chBuchstabe1; //0x0C
}

Ein double hat eine Größe von 8 Byte.
Also rechnen wir für den nächsten Wert 8 dazu (4 + 8 = C)

Um damit auch mehr machen zu können schreibe ich euch hier mal die Größe einiger Datentypen auf:

char  : 1 Byte
bool  : 1 Byte
short : 2 Bytes
int   : 4 Bytes
long  : 4 Bytes
float : 4 Bytes
double: 8 Bytes
BYTE  : 1 Byte
WORD  : 2 Bytes
DWORD : 4 Bytes

Wenn ihr das soweit verstanden habt machen wir mal mit einer Struktur weiter die man zum Hacken von WarRock benutzen kann, indem wir in
ihnen Offsets darstellen:

Als erstes sollten wir uns überlegen welches Offset am kleinsten ist !
Wir addieren schließlich immer !
In unserem Fall haben wir "NoRecoil1".
Das Offset hat den Wert 0x0C43C .
Um zu diesem Wert zu kommen wäre es sehr unsinnig 12559 Integer zu nehmen.
Wir nehmen einfach einen char-Array.
Für die Recoil - Offsets nehmen wir float, weil diese eine Fließkommazahl darstellen.

struct SPlayer
{
    char chMyChar1 [50236]; //0x00
    float Recoil1; //0xC43C
};

50236 = C43C
Auf die Werte von Recoil 2 & 3 zu kommen muss man jetz nicht mehr allzuviel machen da sie jeweils 0x4 vom vorherigen entfernt sind.

struct SPlayer
{
    char chMyChar1 [50236]; //0x00
    float fRecoil1; //0xC43C
    float fRecoil2; //0xC440
    float fRecoil3; //0xC444
    char chMyChar2 [und nun ?]; //0xC448
};

Jetzt haben wir die drei Offsets abgehackt wir müssen uns jetzt das nächstgrößte ist.
Kp ob ihr grade wirklich nachguckt oder nur weiterlest das nächstgroße ist jedenfalls das Offset der Schwerkraft für die X-Achse
Gravity_X 0xC4A4 .
Also wieder mal einfach ausrechnen: C4A4 - C448 = 5C
In Dezimalschreibweise sind das 92.
Also:

struct SPlayer
{
    char chMyChar1 [50236]; //0x00
    float fRecoil1; //0xC43C
    float fRecoil2; //0xC440
    float fRecoil3; //0xC444
    char chMyChar2 [92]; //0xC448
    float fGravity_X; //0xC4A4
    float fGravity_Y; //0xC4A8
    float fGravity_Z; //0xC4AC
};

Wenn ich irgendwo Fehler eingebaut habe, weißt mich bitte darauf hin ^^

[__BuRn3R]

vielen dank für die schöne erklärung

[xxxBarcAxxx]

Originally Posted by UnknownData

Structs:

struct tPlayer
{
		char unknown0[50308]; //0x0000
	BYTE index; //0xC484  
		char unknown50309[39]; //0xC485
	BYTE status; //0xC4AC  
		char unknown50349[15651]; //0xC4AD
	WORD weapon; //0x101D0  
		char unknown66002[258]; //0x101D2
	float pos1; //0x102D4  
	float pos2; //0x102D8  
	float pos3; //0x102DC  
};//Size=0x102E0(66272)

struct tBase
{
    tPlayer* local; //0x0000  
        char unknown4[72]; //0x0004
    tPlayer** globPlayer; //0x004C  
        char unknown80[48]; //0x0050
};//Size=0x0080(128)

Usage:

tBase b_Player = *(tBase*)0x009F1B48;

if(POPK == 1)
{
DWORD dwPlayerPointer = *(DWORD*)0x009F1B48;
		if(dwPlayerPointer != 0) 
		{
                  for(int i = 0; i < 32; i++)
                  {
                   b_Player->globPlayer[i]->pos1 = 0;
                   b_Player->globPlayer[i]->pos2 = 0;
                   b_Player->globPlayer[i]->pos3 = 0;
                  }
                 }
}

Credits: UnknownData ( Structs )
xBioKingz ( Source )

How to add??

Please help

Thanks.

[Raz9r]

Some helpers from my mem.inl file.
If (dwSize % 4 == 0) is a valid expression, use those with the suffix "_dw" for 4x speed of execution (using dwSize / 4),
if (dwSize % 4 == 2) is a valid expression, use those with the suffix "_w" for 2x speed of execution (using dwSize / 2),
else use those with suffix "_b" which are also defined in macros at the beginning.

#define _memcpy(lpDestination, lpSource, dwSize) _memcpy_b((uintptr_t)(lpDestination), (uintptr_t)(lpSource), (DWORD)(dwSize))
#define _memzero(lpDestination, dwSize) _memzero_b((uintptr_t)(lpDestination), (DWORD)(dwSize))
#define _memset(lpDestination, bValue, dwSize) _memset_b((uintptr_t)(lpDestination), (BYTE)(bValue), (DWORD)(dwSize))
#define _strlen(szString) _strlen_b((const char *)(szString))
#define _strcmp(szString1, szString2) _strcmp_b((const char *)(szString1), (const char *)(szString2))

__forceinline DWORD _strlen_b(const char *szString)
{
	__asm
	{
		cld
		mov ecx, -1
		mov eax, 0
		mov edi, szString
		repne scasb
		inc ecx
		neg ecx
		mov eax, ecx
	}
}

__forceinline int _strcmp_b(const char *szString1, const char *szString2)
{
	__asm
	{
		cld
		mov ecx, -1
		mov esi, szString1
		mov edi, szString2
		repne cmpsb
		dec esi
		dec edi
		mov eax, esi
		sub eax, edi
	}
}

__forceinline void _memcpy_b(uintptr_t lpDestination, uintptr_t lpSource, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		mov esi, lpSource
		mov edi, lpDestination
		rep stosb
	}
}

__forceinline void _memcpy_w(uintptr_t lpDestination, uintptr_t lpSource, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		mov esi, lpSource
		mov edi, lpDestination
		rep stosw
	}
}

__forceinline void _memcpy_dw(uintptr_t lpDestination, uintptr_t lpSource, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		mov esi, lpSource
		mov edi, lpDestination
		rep stosd
	}
}

__forceinline void _memzero_b(uintptr_t lpDestination, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		xor eax, eax
		mov edi, lpDestination
		rep stosb
	}
}

__forceinline void _memzero_w(uintptr_t lpDestination, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		xor eax, eax
		mov edi, lpDestination
		rep stosw
	}
}

__forceinline void _memzero_dw(uintptr_t lpDestination, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		xor eax, eax
		mov edi, lpDestination
		rep stosd
	}
}

__forceinline void _memset_b(uintptr_t lpDestination, BYTE bValue, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		mov al, bValue
		mov edi, lpDestination
		rep stosb
	}
}

__forceinline void _memset_w(uintptr_t lpDestination, WORD wValue, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		mov ax, wValue
		mov edi, lpDestination
		rep stosw
	}
}

__forceinline void _memset_dw(uintptr_t lpDestination, DWORD dwValue, DWORD dwSize)
{
	__asm
	{
		mov ecx, dwSize
		mov eax, dwValue
		mov edi, lpDestination
		rep stosd
	}
}