auto
weaponWallHack
(
const
bool
bStatus
)
const
->
void
{
void
*
pRenderWeapon
{
reinterpret_cast

(
0x732F3F
+
0x1
)
}
;
if
(
bStatus
)
{
std
::
memset
(
pRenderWeapon
,
0x0
,
0x1
)
;
}
else
{
std
::
memcpy
(
pRenderWeapon
,
"\x01"
,
0x1
)
;
}
return
;
}

inline
void
weaponWallHack
(
bool
bStatus
)
{
*
reinterpret_cast

(
0x732F3F
+
0x1
)
=
!
bStatus
;
}

uintptr_t
getPedStructByActorHandle
(
uintptr_t handle
)
{
/*
        0054FF90 | 8B4C24 04                | mov ecx,dword ptr ss:[esp+4]                       |mov ecx, handle
        0054FF94 | 8B15 9044B700            | mov edx,dword ptr ds:[B74490]                      |mov edx, *0xB74490
        0054FF9A | 53                       | push ebx                                           |push 0
        0054FF9B | 56                       | push esi                                           |push 04600026
        0054FF9C | 8B72 04                  | mov esi,dword ptr ds:[edx+4]                       |mov esi, *(edx+4)
        0054FF9F | 8BC1                     | mov eax,ecx                                        |mov eax, handle
        0054FFA1 | C1F8 08                  | sar eax,8                                          |sar handle, 8
        0054FFA4 | 8A1C30                   | mov bl,byte ptr ds:[eax+esi]                       |mov bl, (eax + esi
        0054FFA7 | 5E                       | pop esi                                            |
        0054FFA8 | 3AD9                     | cmp bl,cl                                          |
        0054FFAA | 5B                       | pop ebx                                            |
        0054FFAB | 75 0B                    | jne gta_sa.54FFB8                                  |
        0054FFAD | 8B0A                     | mov ecx,dword ptr ds:[edx]                         |mov ecx, **0xB74490
        0054FFAF | 69C0 C4070000            | imul eax,eax,7C4                                   |handle *= 0x7c4
        0054FFB5 | 03C1                     | add eax,ecx                                        |eax += ecx
        0054FFB7 | C3                       | ret                                                |
        0054FFB8 | 33C0                     | xor eax,eax                                        |
        0054FFBA | C3                       | ret                                                |
        */
uintptr_t ecx
=
handle
;
uintptr_t edx
;
ReadProcessMemory
(
hProcess
,
(
LPVOID
)
0xB74490
,
&
edx
,
sizeof
(
uintptr_t
)
,
0
)
;
uintptr_t esi
;
ReadProcessMemory
(
hProcess
,
(
LPVOID
)
(
edx
+
4
)
,
&
esi
,
sizeof
(
uintptr_t
)
,
0
)
;
uintptr_t eax
=
ecx
;
eax
=
eax
>>
8
;
unsigned
char
bl
;
ReadProcessMemory
(
hProcess
,
(
LPVOID
)
(
eax
+
esi
)
,
&
bl
,
sizeof
(
unsigned
char
)
,
0
)
;
if
(
bl
==
(
ecx
&
0x000000FF
)
)
{
ReadProcessMemory
(
hProcess
,
(
LPVOID
)
(
edx
)
,
&
ecx
,
sizeof
(
uintptr_t
)
,
0
)
;
eax
*=
0x7c4
;
eax
+=
ecx
;
return
eax
;
}
else
{
return
0
;
}
}

#pragma once
static
DWORD CRUTCH_LOCAL_VARIABLE
=
0
;
RpHAnimHierarchy
*
GtaSA
::
RpSkinAtomicGetHAnimHierarchy
(
const
RpAtomic
*
atomic
)
// 0x7C7540
{
/*
007C7540 | 8B4424 04                | mov eax,dword ptr ss:[esp+4]       |
007C7544 | 8B0D A478C900            | mov ecx,dword ptr ds:[C978A4]      |
007C754A | 8B0401                   | mov eax,dword ptr ds:[ecx+eax]     |
007C754D | C3                       | ret                                |
*/
uintptr_t eax
=
(
uintptr_t
)
atomic
;
uintptr_t ecx
=
this
->
read

(
0xC978A4
)
;
eax
=
this
->
read

(
eax
+
ecx
)
;
return
(
RpHAnimHierarchy
*
)
eax
;
}
void
GtaSA
::
RpClumpForAllAtomics
(
RpClump
*
clump
,
void
*
callback
,
void
*
data
)
{
/*
00749B70 | 8B4424 04                | mov eax,dword ptr ss:[esp+4]       |
00749B74 | 53                       | push ebx                           |
00749B75 | 55                       | push ebp                           |
00749B76 | 56                       | push esi                           |
00749B77 | 57                       | push edi                           |
00749B78 | 8D78 08                  | lea edi,dword ptr ds:[eax+8]       |
00749B7B | 8B40 08                  | mov eax,dword ptr ds:[eax+8]       |
00749B7E | 3BC7                     | cmp eax,edi                        |
00749B80 | 74 1E                    | je gta_sa.749BA0                   |
00749B82 | 8B5C24 1C                | mov ebx,dword ptr ss:[esp+1C]      |
00749B86 | 8B6C24 18                | mov ebp,dword ptr ss:[esp+18]      |
00749B8A | 8B30                     | mov esi,dword ptr ds:[eax]         |
00749B8C | 83C0 C0                  | add eax,FFFFFFC0                   |
00749B8F | 53                       | push ebx                           |
00749B90 | 50                       | push eax                           |
00749B91 | FFD5                     | call ebp                           |
00749B93 | 83C4 08                  | add esp,8                          |
00749B96 | 85C0                     | test eax,eax                       |
00749B98 | 74 06                    | je gta_sa.749BA0                   |
00749B9A | 3BF7                     | cmp esi,edi                        |
00749B9C | 8BC6                     | mov eax,esi                        |
00749B9E | 75 EA                    | jne gta_sa.749B8A                  |
00749BA0 | 8B4424 14                | mov eax,dword ptr ss:[esp+14]      |
00749BA4 | 5F                       | pop edi                            |
00749BA5 | 5E                       | pop esi                            |
00749BA6 | 5D                       | pop ebp                            |
00749BA7 | 5B                       | pop ebx                            |
00749BA8 | C3                       | ret                                |
*/
uintptr_t eax
=
(
uintptr_t
)
clump
;
uintptr_t edi
=
eax
+
8
;
eax
=
this
->
read

(
eax
+
8
)
;
if
(
eax
==
edi
)
{
eax
=
(
uintptr_t
)
clump
;
// 00749BA0 | 8B4424 14                | mov eax,dword ptr ss:[esp+14]      |
}
else
{
uintptr_t ebx
=
(
uintptr_t
)
data
;
// ????    // 00749B82 | 8B5C24 1C    | mov ebx, dword ptr ss: [esp+1C]
uintptr_t ebp
=
(
uintptr_t
)
callback
;
// 00749B86 | 8B6C24 18    | mov ebp, dword ptr ss: [esp + 18]
uintptr_t esi
=
this
->
read

(
eax
)
;
// 00749B8A | 8B30        | mov esi, dword ptr ds: [eax]
eax
+=
0xFFFFFFC0
;
// actually its a minus
/* callback start */
/*
        00734A20 | 8B4424 04                | mov eax,dword ptr ss:[esp+4]       |
        00734A24 | 50                       | push eax                           |
        00734A25 | E8 162B0900              | call gta_sa.7C7540                 |
        00734A2A | 8B4C24 0C                | mov ecx,dword ptr ss:[esp+C]       |
        00734A2E | 8901                     | mov dword ptr ds:[ecx],eax         |
        00734A30 | 83C4 04                  | add esp,4                          |
        00734A33 | 33C0                     | xor eax,eax                        |
        00734A35 | C3                       | ret                                |
        */
eax
=
(
uintptr_t
)
RpSkinAtomicGetHAnimHierarchy
(
(
const
RpAtomic
*
)
eax
)
;
// 00734A25 | E8 162B0900 | call gta_sa.7C7540 |
CRUTCH_LOCAL_VARIABLE
=
eax
;
// the next code - instead of 00734A2A...00734A2E instructions
eax
^=
eax
;
/* callback end */
if
(
eax
==
0
)
{
eax
=
(
uintptr_t
)
clump
;
}
else
{
std
::
cout

read

(
edx
+
0x10
)
;
edx
=
this
->
read

(
edx
+
0x4
)
;
uintptr_t ecx
=
0
;
if
(
edx
==
0
)
{
// just return
std
::
cout

read

(
esi
)
)
{
ecx
++
;
esi
+=
0x10
;
}
else
{
eax
=
ecx
;
break
;
}
}
while
(
ecx
!=
edx
)
;
}
return
eax
;
}
RwMatrix
*
GtaSA
::
RpHAnimHierarchyGetMatrixArray
(
RpHAnimHierarchy
*
hierarchy
)
{
/*
    007C5120 | 8B4424 04                | mov eax,dword ptr ss:[esp+4]       |
    007C5124 | 8B40 08                  | mov eax,dword ptr ds:[eax+8]       |
    007C5127 | C3                       | ret                                |
    */
uintptr_t eax
=
(
uintptr_t
)
hierarchy
;
eax
=
this
->
read

(
eax
+
8
)
;
return
(
RwMatrix
*
)
eax
;
}
void
GtaSA
::
vectorMult
(
uintptr_t edx
,
uintptr_t esi
,
uintptr_t ecx
)
{
float
ecxReaded
[
3
]
;
this
->
readBuf
(
ecx
,
4
*
3
,
(
void
*
)
ecxReaded
)
;
uintptr_t eax
=
(
uintptr_t
)
esi
;
// ecx = ecx;
float
st0
=
this
->
read

(
eax
+
0x20
)
;
st0
*=
ecxReaded
[
2
]
;
float
st1
=
st0
;
st0
=
this
->
read

(
eax
+
0x10
)
;
st0
*=
ecxReaded
[
1
]
;
st1
+=
st0
;
// ? 0059C8A7 | DEC1                    | faddp st(1),st(0)                  |
st0
=
this
->
read

(
eax
)
;
st0
*=
ecxReaded
[
0
]
;
st1
+=
st0
;
// ? 0059C8AD | DEC1                    | faddp st(1),st(0)                  |
st0
=
st1
;
st0
+=
this
->
read

(
eax
+
0x30
)
;
// ? 0059C8AF | D840 30                 | fadd st(0),dword ptr ds:[eax+30]   |
(
(
float
*
)
(
edx
)
)
[
0
]
=
st0
;
st0
=
this
->
read

(
eax
+
0x24
)
;
st0
*=
ecxReaded
[
2
]
;
st1
=
st0
;
st0
=
this
->
read

(
eax
+
0x4
)
;
st0
*=
ecxReaded
[
0
]
;
st1
+=
st0
;
//    0059C8C5 | DEC1                    | faddp st(1),st(0)                  |
//st0 = st1; //    0059C8C5 | DEC1                    | faddp st(1),st(0)                  |
st0
=
this
->
read

(
eax
+
0x14
)
;
st0
*=
ecxReaded
[
1
]
;
st1
+=
st0
;
st0
=
st1
;
st0
+=
this
->
read

(
eax
+
0x34
)
;
(
(
float
*
)
(
edx
)
)
[
1
]
=
st0
;
st0
=
this
->
read

(
eax
+
0x28
)
;
st0
*=
ecxReaded
[
2
]
;
st1
=
st0
;
st0
=
this
->
read

(
eax
+
0x8
)
;
st0
*=
ecxReaded
[
0
]
;
st1
+=
st0
;
// 0059C8E1 | DEC1                    | faddp st(1),st(0)                  |
st0
=
this
->
read

(
eax
+
0x18
)
;
st0
*=
ecxReaded
[
1
]
;
st1
+=
st0
;
st0
=
st1
;
st0
+=
this
->
read

(
eax
+
0x38
)
;
// ? 0059C8AF | D840 30                 | fadd st(0),dword ptr ds:[eax+30]   |
//ecx = eax;
//this->write(ecx, edx); // 0059C8F4 | 8911                    | mov dword ptr ds:[ecx],edx         |
//edx =
(
(
float
*
)
(
edx
)
)
[
2
]
=
st0
;
}
//-------------------------------------------------------------------
void
GtaSA
::
getBonePosition
(
uintptr_t pedStruct
,
Vector3
*
buf
,
unsigned
int
boneId
,
bool
updateSkinBones
)
{
uintptr_t esi
=
pedStruct
;
uintptr_t eax
=
0
;
eax
=
this
->
read

(
esi
+
0x474
)
;
if
(
updateSkinBones
)
{
std
::
cout

read

(
esi
+
0x18
)
;
// 005E42A9 | 8B4E 18                  | mov ecx,dword ptr ds:[esi+18]      |
eax
=
(
uintptr_t
)
GetAnimHierarchyFromSkinClump
(
(
RpClump
*
)
ecx
)
;
// 0x734A40
uintptr_t edi
=
eax
;
// 005E42B2 | 8BF8                     | mov edi,eax                        |
if
(
edi
==
0
)
{
// 005E42BF | 8B46 14                  | mov eax,dword ptr ds:[esi+14]      |
std
::
cout

x
=
this
->
read

(
eax
)
;
buf
->
y
=
this
->
read

(
eax
+
4
)
;
buf
->
z
=
this
->
read

(
eax
+
8
)
;
}
}
else
{
std
::
cout

read

(
esi
+
0x14
)
;
// ped struct
eax
=
eax
+
eax
*
2
;
uintptr_t ecx
=
eax
*
4
+
0x8D13A8
;
// IM STOPPED HERE
float
res
[
3
]
;
//uintptr_t edx = (uintptr_t)(res);
// push ecx
// push esi
// push edx
// call func 0x0059C890(edx, esi, ecx)
vectorMult
(
(
uintptr_t
)
res
,
esi
,
ecx
)
;
buf
->
x
=
res
[
0
]
;
// *(float*)(edx);
buf
->
y
=
res
[
1
]
;
//*(float*)(edx + 4);
buf
->
z
=
res
[
2
]
;
//*(float*)(edx + 8);
//float* firstMatrix = (float*)this->readBuf(16, edx);
//edx = LOCAL_VAR_ADDR
// push esi
// push edx
// call matrix multiply // 005E4303 | E8 8885FBFF             | call gta_sa.59C890                 |
/*float res[16];

            float arg1[16];
            this->readBuf(ecx, 4 * 4 * 4, arg1);
            ecx = (uintptr_t)arg1;

            float arg2[16];
            this->readBuf(esi, 16*4, arg2);

            ::vec3mx(arg1, arg1, res);
            uintptr_t edx = (uintptr_t)res;

            /*
            buf->x = *(float*)(edx);
            buf->y = *(float*)(edx + 4);
            buf->z = *(float*)(edx + 8);*/
}
}
}

void
SetSpreadMultiplier
(
float
fltMultiplier
)
{
*
reinterpret_cast

(
0x008D6114
)
=
fltMultiplier
/
20.00F
;
}

SetSpreadMultiplier
(
0.00F
)
;
// Установит процент разброса пули на 0 (разброса не будет).
SetSpreadMultiplier
(
50.00F
)
;
// Установит процент разброса пули на 50 (разброс будет в 2 раза меньше обычного).
SetSpreadMultiplier
(
100.00F
)
;
// Установит процент разброса пули на 100 (разброс останется неизмененным).