ModdingRX/GTAV-Classes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Script VM classes (#60)

Browse Source 
* feat(Script): Ported BBv2 script classes
* fix: Change hard tab indents to 4 width space indents
This commit is contained in:
Yimura 2022-11-08 22:11:50 +01:00 committed by GitHub
parent 13fb4e4dae
commit 89d2428864
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
64 changed files with 1963 additions and 1320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
.devcontainer/devcontainer.json
View File

@ -1,20 +1,20 @@
{ {
"name": "C++", "name": "C++",
"build": { "build": {
"dockerfile": "Dockerfile", "dockerfile": "Dockerfile",
"args": { } "args": { }
}, },
"workspaceMount": "source=${localWorkspaceFolder},target=/app,type=bind,consistency=delegated", "workspaceMount": "source=${localWorkspaceFolder},target=/app,type=bind,consistency=delegated",
"workspaceFolder": "/app", "workspaceFolder": "/app",
"runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined", "--network=host"], "runArgs": ["--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined", "--network=host"],
"settings": {}, "settings": {},
"extensions": [ "extensions": [
"ms-vscode.cpptools", "ms-vscode.cpptools",
"ms-vscode.cmake-tools", "ms-vscode.cmake-tools",
"ms-vscode.cpptools-extension-pack", "ms-vscode.cpptools-extension-pack",
"WakaTime.vscode-wakatime" "WakaTime.vscode-wakatime"
], ],
//"remoteUser": "vscode", //"remoteUser": "vscode",
} }

20
CMakeLists.txt
View File

@ -17,21 +17,21 @@ file(GLOB_RECURSE HEADERS "*.hpp")
message(STATUS "") message(STATUS "")
foreach(HEADER ${HEADERS}) foreach(HEADER ${HEADERS})
get_filename_component(FILENAME ${HEADER} NAME) get_filename_component(FILENAME ${HEADER} NAME)
check_include_file_cxx("${HEADER}" ${FILENAME}_OK) check_include_file_cxx("${HEADER}" ${FILENAME}_OK)
if(${FILENAME}_OK) if(${FILENAME}_OK)
message(STATUS "${FILENAME} OK!") message(STATUS "${FILENAME} OK!")
else() else()
set(OK FALSE) set(OK FALSE)
message(SEND_ERROR "${FILENAME} failed to compile!") message(SEND_ERROR "${FILENAME} failed to compile!")
endif() endif()
endforeach() endforeach()
message(STATUS "") message(STATUS "")
if(NOT OK) if(NOT OK)
file(READ "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/CMakeError.log" LOG) file(READ "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/CMakeError.log" LOG)
message(STATUS ${LOG}) message(STATUS ${LOG})
endif() endif()

16
base/CNavigation.hpp
View File

@ -7,15 +7,15 @@
class CNavigation class CNavigation
{ {
public: public:
char pad_0000[16]; //0x0000 char pad_0000[16]; //0x0000
class rage::phArchetypeDamp* m_damp; //0x0010 class rage::phArchetypeDamp* m_damp; //0x0010
char pad_0018[8]; //0x0018 char pad_0018[8]; //0x0018
rage::fmatrix44 m_transformation_matrix; rage::fmatrix44 m_transformation_matrix;
rage::fvector3* get_position() rage::fvector3* get_position()
{ {
return reinterpret_cast<rage::fvector3*>(&m_transformation_matrix.rows[3]); return reinterpret_cast<rage::fvector3*>(&m_transformation_matrix.rows[3]);
} }
}; //Size: 0x0060 }; //Size: 0x0060
static_assert(sizeof(CNavigation) == 0x60); static_assert(sizeof(CNavigation) == 0x60);
#pragma pack(pop) #pragma pack(pop)

22
base/HashTable.hpp
View File

@ -5,10 +5,10 @@
class HashNode class HashNode
{ {
public: public:
int32_t m_hash; //0x0000 int32_t m_hash; //0x0000
uint16_t m_idx; //0x0004 uint16_t m_idx; //0x0004
char pad_0006[2]; //0x0006 char pad_0006[2]; //0x0006
HashNode* m_next; //0x0008 HashNode* m_next; //0x0008
}; //Size: 0x0010 }; //Size: 0x0010
static_assert(sizeof(HashNode) == 0x10); static_assert(sizeof(HashNode) == 0x10);
@ -16,13 +16,13 @@ template<typename T>
class HashTable class HashTable
{ {
public: public:
T* m_data; //0x0000 T* m_data; //0x0000
uint16_t m_size; //0x0008 uint16_t m_size; //0x0008
char pad_000A[14]; //0x000A char pad_000A[14]; //0x000A
uint64_t m_item_size; //0x0018 uint64_t m_item_size; //0x0018
char pad_0020[64]; //0x0020 char pad_0020[64]; //0x0020
HashNode** m_lookup_table; //0x0060 HashNode** m_lookup_table; //0x0060
uint16_t m_lookup_key; //0x0068 uint16_t m_lookup_key; //0x0068
}; //Size: 0x006A }; //Size: 0x006A
// static_assert(sizeof(HashTable<void*>) == 0x6A); // compiler gives assert error without telling me what the problem is, the class is correct though. // static_assert(sizeof(HashTable<void*>) == 0x6A); // compiler gives assert error without telling me what the problem is, the class is correct though.
#pragma pack(pop) #pragma pack(pop)

8
base/datBase.hpp
View File

@ -4,10 +4,10 @@ namespace rage
{ {
class datBase class datBase
{ {
public: public:
virtual ~datBase() = default; virtual ~datBase() = default;
}; //Size: 0x0008 }; //Size: 0x0008
static_assert(sizeof(datBase) == 0x8); static_assert(sizeof(datBase) == 0x8);
} }

28
base/fwExtensibleBase.hpp
View File

@ -9,23 +9,23 @@
namespace rage namespace rage
{ {
class fwExtensibleBase : public fwRefAwareBase class fwExtensibleBase : public fwRefAwareBase
{ {
public: public:
virtual bool is_of_type(std::uint32_t hash) = 0; virtual bool is_of_type(std::uint32_t hash) = 0;
virtual uint32_t const &get_type() = 0; virtual uint32_t const &get_type() = 0;
fwExtensionContainer* m_extension_container; // 0x0010 fwExtensionContainer* m_extension_container; // 0x0010
void *m_extensible_unk; // 0x0018 void *m_extensible_unk; // 0x0018
template <typename T> template <typename T>
bool is_of_type() bool is_of_type()
{ {
static auto name = (typeid(T).name()) + 6; // Skip "class " static auto name = (typeid(T).name()) + 6; // Skip "class "
static auto name_hash = joaat(name); static auto name_hash = joaat(name);
return is_of_type(name_hash); return is_of_type(name_hash);
} }
}; //Size: 0x0020 }; //Size: 0x0020
static_assert(sizeof(fwExtensibleBase) == 0x20); static_assert(sizeof(fwExtensibleBase) == 0x20);
} }

10
base/fwExtensionContainer.hpp
View File

@ -6,11 +6,11 @@ namespace rage
{ {
class fwExtensionContainer class fwExtensionContainer
{ {
public: public:
fwExtension *m_entry; //0x0000 fwExtension *m_entry; //0x0000
fwExtensionContainer* m_next; //0x0008 fwExtensionContainer* m_next; //0x0008
}; //Size: 0x0010 }; //Size: 0x0010
static_assert(sizeof(fwExtensionContainer) == 0x10); static_assert(sizeof(fwExtensionContainer) == 0x10);
} }

4
base/fwRefAwareBase.hpp
View File

@ -7,8 +7,8 @@ namespace rage
{ {
class fwRefAwareBase : public fwRefAwareBaseImpl<datBase> class fwRefAwareBase : public fwRefAwareBaseImpl<datBase>
{ {
}; };
static_assert(sizeof(fwRefAwareBase) == 0x10); static_assert(sizeof(fwRefAwareBase) == 0x10);
} }

10
base/fwRefAwareBaseImpl.hpp
View File

@ -4,10 +4,10 @@ namespace rage
{ {
template <typename T> template <typename T>
class fwRefAwareBaseImpl : public T class fwRefAwareBaseImpl : public T
{ {
private: private:
void *m_ref; // 0x08 void *m_ref; // 0x08
}; };
} }

14
base/pgBase.hpp
View File

@ -4,14 +4,14 @@ namespace rage
{ {
class pgBase class pgBase
{ {
public: public:
virtual ~pgBase() = default; virtual ~pgBase() = default;
virtual int return_zero() = 0; virtual int return_zero() = 0;
virtual void error() = 0; virtual void error() = 0;
void *unk_0000; // 0x0000 void *unk_0000; // 0x0000
}; //Size: 0x0008 }; //Size: 0x0008
static_assert(sizeof(pgBase) == 0x10); static_assert(sizeof(pgBase) == 0x10);
} }

42
base/phArchetype.hpp
View File

@ -4,28 +4,26 @@
namespace rage namespace rage
{ {
class phArchetype class phArchetype
{ {
public: char pad_0000[32]; //0x0000
char pad_0000[32]; //0x0000 class phBound* m_bound; //0x0020
class phBound* m_bound; //0x0020 char pad_0028[16]; //0x0028
char pad_0028[16]; //0x0028 }; //Size: 0x0038
}; //Size: 0x0038 static_assert(sizeof(phArchetype) == 0x38);
static_assert(sizeof(phArchetype) == 0x38);
class phArchetypePhys : public phArchetype class phArchetypePhys : public phArchetype
{ {
public: char pad_0038[28]; //0x0028
char pad_0038[28]; //0x0028 float m_water_collision; //0x0054
float m_water_collision; //0x0054 char pad_0058[40]; //0x0058
char pad_0058[40]; //0x0058 }; //Size: 0x0080
}; //Size: 0x0080 static_assert(sizeof(phArchetypePhys) == 0x80);
static_assert(sizeof(phArchetypePhys) == 0x80);
class phArchetypeDamp : public phArchetypePhys class phArchetypeDamp : public phArchetypePhys
{ {
public: public:
char pad_0080[96]; //0x0080 char pad_0080[96]; //0x0080
}; //Size: 0x00E0 }; //Size: 0x00E0
static_assert(sizeof(phArchetypeDamp) == 0xE0); static_assert(sizeof(phArchetypeDamp) == 0xE0);
} }

16
base/phBoundCapsule.hpp
View File

@ -5,13 +5,13 @@
namespace rage namespace rage
{ {
#pragma pack(push,1) #pragma pack(push,1)
class phBoundCapsule : public phBound class phBoundCapsule : public phBound
{ {
public: public:
float m_capsule_half_height; float m_capsule_half_height;
uint64_t unk_0074; uint64_t unk_0074;
uint32_t unk_007C; uint32_t unk_007C;
}; //Size: 0x0080 }; //Size: 0x0080
static_assert(sizeof(phBoundCapsule) == 0x80); static_assert(sizeof(phBoundCapsule) == 0x80);
#pragma pack(pop) #pragma pack(pop)
} }

30
base/phBoundComposite.hpp
View File

@ -7,20 +7,20 @@
namespace rage namespace rage
{ {
#pragma pack(push,8) #pragma pack(push,8)
class phBoundComposite : public phBound class phBoundComposite : public phBound
{ {
public: public:
class phBound** m_bounds; //0x0070 class phBound** m_bounds; //0x0070
fmatrix34* m_current_matrices; //0x0078 fmatrix34* m_current_matrices; //0x0078
fmatrix34* m_last_matrices; //0x0080 fmatrix34* m_last_matrices; //0x0080
fvector3* unk_0088; //0x0088 fvector3* unk_0088; //0x0088
uint32_t* m_type_and_include_flags; //0x0090 uint32_t* m_type_and_include_flags; //0x0090
uint32_t* m_owned_type_and_include_flags; //0x0098 uint32_t* m_owned_type_and_include_flags; //0x0098
uint16_t m_max_num_bounds; //0x00A0 uint16_t m_max_num_bounds; //0x00A0
uint16_t m_num_bounds; //0x00A2 uint16_t m_num_bounds; //0x00A2
char pad_00A4[4]; //0x00A4 char pad_00A4[4]; //0x00A4
void* unk_00A8; //0x00A8 void* unk_00A8; //0x00A8
}; //Size: 0x00B0 }; //Size: 0x00B0
static_assert(sizeof(phBoundComposite) == 0xB0); static_assert(sizeof(phBoundComposite) == 0xB0);
#pragma pack(pop) #pragma pack(pop)
} }

6
camera/CCameraAngles.hpp
View File

@ -5,8 +5,8 @@
class CCameraAngles class CCameraAngles
{ {
public: public:
char pad_0000[960]; //0x0000 char pad_0000[960]; //0x0000
CPlayerAngles* angles; //0x03C0 CPlayerAngles* angles; //0x03C0
char pad_03C8[60]; //0x03C8 char pad_03C8[60]; //0x03C8
}; //Size: 0x0408 }; //Size: 0x0408
static_assert(sizeof(CCameraAngles) == 0x408); static_assert(sizeof(CCameraAngles) == 0x408);

2
camera/CCameraManagerAngles.hpp
View File

@ -5,6 +5,6 @@
class CCameraManagerAngles class CCameraManagerAngles
{ {
public: public:
CCameraAngles* m_angles; //0x0000 CCameraAngles* m_angles; //0x0000
}; //Size: 0x0008 }; //Size: 0x0008
static_assert(sizeof(CCameraManagerAngles) == 0x8); static_assert(sizeof(CCameraManagerAngles) == 0x8);

4
camera/CGameCameraAngles.hpp
View File

@ -5,7 +5,7 @@
class CGameCameraAngles class CGameCameraAngles
{ {
public: public:
CCameraManagerAngles* m_angles; //0x0000 CCameraManagerAngles* m_angles; //0x0000
char pad_0008[56]; //0x0008 char pad_0008[56]; //0x0008
}; //Size: 0x0040 }; //Size: 0x0040
static_assert(sizeof(CGameCameraAngles) == 0x40); static_assert(sizeof(CGameCameraAngles) == 0x40);

58
datanodes/object/CObjectCreationDataNode.hpp
View File

@ -7,35 +7,35 @@
class CObjectCreationDataNode class CObjectCreationDataNode
{ {
public: public:
char pad_0000[192]; //0x0000 char pad_0000[192]; //0x0000
uint16_t unk_00C0; //0x00C0 uint16_t unk_00C0; //0x00C0
char pad_0xC2[14]; //0x00C2 char pad_0xC2[14]; //0x00C2
rage::fvector4 m_object_orientation; //0x00D0 rage::fvector4 m_object_orientation; //0x00D0
char pad_00E0[30]; //0x00E0 char pad_00E0[30]; //0x00E0
rage::fvector3 m_object_position; //0x0100 rage::fvector3 m_object_position; //0x0100
char pad_010C[4]; //0x010C char pad_010C[4]; //0x010C
rage::fvector3 m_dummy_position; //0x010E rage::fvector3 m_dummy_position; //0x010E
char pad_011A[20]; //0x011C char pad_011A[20]; //0x011C
rage::fvector3 m_script_grab_position; //0x0130 rage::fvector3 m_script_grab_position; //0x0130
char pad_013C[12]; //0x013C char pad_013C[12]; //0x013C
float m_script_grab_radius; //0x0148 float m_script_grab_radius; //0x0148
uint32_t m_created_by; //0x014C uint32_t m_created_by; //0x014C
uint32_t m_model; //0x0150 uint32_t m_model; //0x0150
uint32_t m_frag_group_index; //0x0154 uint32_t m_frag_group_index; //0x0154
uint32_t m_ownership_token; //0x0158 uint32_t m_ownership_token; //0x0158
uint32_t unk_015C; //0x015C uint32_t unk_015C; //0x015C
bool m_no_reassign; //0x0160 bool m_no_reassign; //0x0160
bool unk_0161; //0x0161 bool unk_0161; //0x0161
bool m_player_wants_control; //0x0162 bool m_player_wants_control; //0x0162
bool m_has_init_physics; //0x0163 bool m_has_init_physics; //0x0163
bool m_script_grabbed_from_world; //0x0164 bool m_script_grabbed_from_world; //0x0164
bool m_has_frag_group; //0x0165 bool m_has_frag_group; //0x0165
bool m_is_broken; //0x0166 bool m_is_broken; //0x0166
bool m_has_exploded; //0x0167 bool m_has_exploded; //0x0167
bool m_keep_registered; //0x0168 bool m_keep_registered; //0x0168
bool unk_0169; //0x0169 bool unk_0169; //0x0169
bool unk_016A; //0x016A bool unk_016A; //0x016A
bool unk_016B; //0x016B bool unk_016B; //0x016B
}; //Size: 0x016C }; //Size: 0x016C
static_assert(sizeof(CObjectCreationDataNode) == 0x16C); static_assert(sizeof(CObjectCreationDataNode) == 0x16C);
#pragma pack(pop) #pragma pack(pop)

166
datanodes/player/CPlayerAppearanceDataNode.hpp
View File

@ -6,89 +6,89 @@
class CPlayerAppearanceDataNode class CPlayerAppearanceDataNode
{ {
public: public:
char pad_0x0[192]; //0xB0 char pad_0x0[192]; //0xB0
uint32_t unk_0xC0[56]; //0xC0 uint32_t unk_0xC0[56]; //0xC0
class CPedComponents components; //0x1A0 class CPedComponents components; //0x1A0
char pad_0x268[8]; //0x268 char pad_0x268[8]; //0x268
uint32_t unk_0x270[6]; //0x270 uint32_t unk_0x270[6]; //0x270
uint32_t unk_0x288[6]; //0x288 uint32_t unk_0x288[6]; //0x288
char pad_0x2A0[8]; //0x2A0 char pad_0x2A0[8]; //0x2A0
float unk_0x2A8; //0x2A8 float unk_0x2A8; //0x2A8
uint8_t unk_0x2AC; //0x2AC uint8_t unk_0x2AC; //0x2AC
uint8_t unk_0x2AD; //0x2AD uint8_t unk_0x2AD; //0x2AD
char pad_0x2AE[26]; //0x2AE char pad_0x2AE[26]; //0x2AE
float m_shape_mix; //0x2C8 float m_shape_mix; //0x2C8
float m_skin_mix; //0x2CC float m_skin_mix; //0x2CC
float m_third_mix; //0x2D0 float m_third_mix; //0x2D0
float unk_0x2D4; //0x2D4 float unk_0x2D4; //0x2D4
float unk_0x2D8[13]; //0x2D8 float unk_0x2D8[13]; //0x2D8
float unk_0x30C[13]; //0x30C float unk_0x30C[13]; //0x30C
float unk_0x340[20]; //0x340 float unk_0x340[20]; //0x340
uint8_t unk_0x390[13]; //0x390 uint8_t unk_0x390[13]; //0x390
uint8_t unk_0x39D[13]; //0x39D uint8_t unk_0x39D[13]; //0x39D
uint8_t unk_0x3AA[13]; //0x3AA uint8_t unk_0x3AA[13]; //0x3AA
uint8_t m_shape_first; //0x3B7 uint8_t m_shape_first; //0x3B7
uint8_t m_shape_second; //0x3B8 uint8_t m_shape_second; //0x3B8
uint8_t m_shape_third; //0x3B9 uint8_t m_shape_third; //0x3B9
uint8_t m_skin_first; //0x3BA uint8_t m_skin_first; //0x3BA
uint8_t m_skin_second; //0x3BB uint8_t m_skin_second; //0x3BB
uint8_t m_skin_third; //0x3BC uint8_t m_skin_third; //0x3BC
uint8_t unk_0x3BD[13]; //0x3BD uint8_t unk_0x3BD[13]; //0x3BD
uint8_t unk_0x3CA[11]; //0x3CA uint8_t unk_0x3CA[11]; //0x3CA
int16_t unk_0x3D6; //0x3D6 int16_t unk_0x3D6; //0x3D6
uint8_t unk_0x3D8; //0x3D8 uint8_t unk_0x3D8; //0x3D8
uint8_t unk_0x3D9; //0x3D9 uint8_t unk_0x3D9; //0x3D9
char pad_0x3DA[1]; //0x3DA char pad_0x3DA[1]; //0x3DA
bool unk_0x3DB; //0x3DB bool unk_0x3DB; //0x3DB
bool unk_0x3DC; //0x3DC bool unk_0x3DC; //0x3DC
char pad_0x3DD[3]; //0x3DD char pad_0x3DD[3]; //0x3DD
uint32_t unk_0x3E0; //0x3E0 uint32_t unk_0x3E0; //0x3E0
uint32_t unk_0x3E4; //0x3E4 uint32_t unk_0x3E4; //0x3E4
uint32_t unk_0x3E8; //0x3E8 uint32_t unk_0x3E8; //0x3E8
uint32_t unk_0x3EC; //0x3EC uint32_t unk_0x3EC; //0x3EC
uint32_t unk_0x3F0; //0x3F0 uint32_t unk_0x3F0; //0x3F0
float unk_0x3F4; //0x3F4 float unk_0x3F4; //0x3F4
float unk_0x3F8; //0x3F8 float unk_0x3F8; //0x3F8
float unk_0x3FC; //0x3FC float unk_0x3FC; //0x3FC
uint32_t unk_0x400; //0x400 uint32_t unk_0x400; //0x400
uint32_t unk_0x404; //0x404 uint32_t unk_0x404; //0x404
uint32_t unk_0x408; //0x408 uint32_t unk_0x408; //0x408
uint32_t unk_0x40C; //0x40C uint32_t unk_0x40C; //0x40C
uint32_t unk_0x410; //0x410 uint32_t unk_0x410; //0x410
bool unk_0x414; //0x414 bool unk_0x414; //0x414
bool unk_0x415; //0x415 bool unk_0x415; //0x415
bool unk_0x416; //0x416 bool unk_0x416; //0x416
bool unk_0x417; //0x417 bool unk_0x417; //0x417
bool unk_0x418; //0x418 bool unk_0x418; //0x418
bool unk_0x419; //0x419 bool unk_0x419; //0x419
uint32_t unk_0x41C; //0x41C uint32_t unk_0x41C; //0x41C
uint32_t m_model_hash; //0x420 uint32_t m_model_hash; //0x420
uint32_t m_voice_hash; //0x424 uint32_t m_voice_hash; //0x424
uint32_t m_phone_mode; //0x428 uint32_t m_phone_mode; //0x428
uint32_t unk_0x42C; //0x42C uint32_t unk_0x42C; //0x42C
uint8_t m_parachute_tint_index; //0x430 uint8_t m_parachute_tint_index; //0x430
uint8_t m_parachute_pack_tint_index; //0x431 uint8_t m_parachute_pack_tint_index; //0x431
uint16_t m_respawn_object; //0x432 uint16_t m_respawn_object; //0x432
bool m_has_head_blend_data; //0x434 bool m_has_head_blend_data; //0x434
bool unk_0x435; //0x435 bool unk_0x435; //0x435
bool m_has_respawn_object; //0x436 bool m_has_respawn_object; //0x436
char pad_0x437; //0x437 char pad_0x437; //0x437
uint32_t unk_0x438_clip_maybe; //0x438 uint32_t unk_0x438_clip_maybe; //0x438
uint32_t unk_0x43C; //0x43C uint32_t unk_0x43C; //0x43C
uint32_t unk_0x440; //0x440 uint32_t unk_0x440; //0x440
bool unk_0x444; //0x444 bool unk_0x444; //0x444
bool unk_0x445; //0x445 bool unk_0x445; //0x445
bool unk_0x446; //0x446 bool unk_0x446; //0x446
uint8_t unk_0x447; //0x447 uint8_t unk_0x447; //0x447
uint16_t unk_0x448; //0x448 uint16_t unk_0x448; //0x448
uint16_t unk_0x44A; //0x44A uint16_t unk_0x44A; //0x44A
uint16_t unk_0x44C; //0x44C uint16_t unk_0x44C; //0x44C
bool unk_0x44E; //0x44E bool unk_0x44E; //0x44E
bool unk_0x44F; //0x44F bool unk_0x44F; //0x44F
bool unk_0x450; //0x450 bool unk_0x450; //0x450
uint8_t unk_0x451; //0x451 uint8_t unk_0x451; //0x451
uint32_t unk_0x452; //0x452 uint32_t unk_0x452; //0x452
uint32_t unk_0x456; //0x456 uint32_t unk_0x456; //0x456
}; };
static_assert(sizeof(CPlayerAppearanceDataNode) == 0x45C); static_assert(sizeof(CPlayerAppearanceDataNode) == 0x45C);
#pragma pack(pop) #pragma pack(pop)

268
datanodes/player/CPlayerGameStateDataNode.hpp
View File

@ -6,142 +6,142 @@
class CPlayerGameStateDataNode class CPlayerGameStateDataNode
{ {
public: public:
char pad_0000[192]; //0x0000 char pad_0000[192]; //0x0000
uint32_t m_player_state; //0x00C0 uint32_t m_player_state; //0x00C0
bool m_controls_disabled_by_script; //0x00C4 bool m_controls_disabled_by_script; //0x00C4
bool m_is_max_armor_and_health_default; //0x00C5 bool m_is_max_armor_and_health_default; //0x00C5
bool unk_000C6; //0x00C6 bool unk_000C6; //0x00C6
bool m_is_spectating; //0x00C7 bool m_is_spectating; //0x00C7
bool m_is_antagonistic_to_another_player; //0x00C8 bool m_is_antagonistic_to_another_player; //0x00C8
bool m_never_target; //0x00C9 bool m_never_target; //0x00C9
bool m_use_kinematic_physics; //0x00CA bool m_use_kinematic_physics; //0x00CA
bool m_has_tutorial_data; //0x00CB bool m_has_tutorial_data; //0x00CB
bool m_pending_tutorial_change; //0x00CC bool m_pending_tutorial_change; //0x00CC
bool unk_00CD; //0x00CD bool unk_00CD; //0x00CD
bool m_respawning; //0x00CE bool m_respawning; //0x00CE
bool m_will_jack_any_player; //0x00CF bool m_will_jack_any_player; //0x00CF
bool m_will_jack_wanted_players; //0x00D0 bool m_will_jack_wanted_players; //0x00D0
bool m_dont_drag_from_car; //0x00D1 bool m_dont_drag_from_car; //0x00D1
bool m_random_peds_flee; //0x00D2 bool m_random_peds_flee; //0x00D2
bool m_every_ped_back_away; //0x00D3 bool m_every_ped_back_away; //0x00D3
bool m_has_microphone; //0x00D4 bool m_has_microphone; //0x00D4
bool m_is_invincible; //0x00D5 bool m_is_invincible; //0x00D5
bool unk_00D6; //0x00D6 bool unk_00D6; //0x00D6
bool unk_00D7; //0x00D7 bool unk_00D7; //0x00D7
bool m_seatbelt; //0x00D8 bool m_seatbelt; //0x00D8
bool unk_00D9; //0x00D9 bool unk_00D9; //0x00D9
bool m_bullet_proof; //0x00DA bool m_bullet_proof; //0x00DA
bool m_fire_proof; //0x00DB bool m_fire_proof; //0x00DB
bool m_explosion_proof; //0x00DC bool m_explosion_proof; //0x00DC
bool m_collision_proof; //0x00DD bool m_collision_proof; //0x00DD
bool m_melee_proof; //0x00DE bool m_melee_proof; //0x00DE
bool m_water_proof; //0x00DF bool m_water_proof; //0x00DF
bool m_steam_proof; //0x00E0 bool m_steam_proof; //0x00E0
bool unk_00E1; //0x00E1 bool unk_00E1; //0x00E1
bool unk_00E2; //0x00E2 bool unk_00E2; //0x00E2
bool unk_00E3; //0x00E3 bool unk_00E3; //0x00E3
bool unk_00E4; //0x00E4 bool unk_00E4; //0x00E4
bool unk_00E5; //0x00E5 bool unk_00E5; //0x00E5
bool unk_00E6; //0x00E6 bool unk_00E6; //0x00E6
bool unk_00E7; //0x00E7 bool unk_00E7; //0x00E7
bool unk_00E8; //0x00E8 bool unk_00E8; //0x00E8
bool unk_00E9; //0x00E9 bool unk_00E9; //0x00E9
bool unk_00EA; //0x00EA bool unk_00EA; //0x00EA
bool unk_00EB; //0x00EB bool unk_00EB; //0x00EB
bool unk_00EC; //0x00EC bool unk_00EC; //0x00EC
bool unk_00ED; //0x00ED bool unk_00ED; //0x00ED
bool unk_00EE; //0x00EE bool unk_00EE; //0x00EE
bool unk_00EF; //0x00EF bool unk_00EF; //0x00EF
bool unk_00F0; //0x00F0 bool unk_00F0; //0x00F0
bool unk_00F1; //0x00F1 bool unk_00F1; //0x00F1
bool unk_00F2; //0x00F2 bool unk_00F2; //0x00F2
bool unk_00F3; //0x00F3 bool unk_00F3; //0x00F3
bool unk_00F4; //0x00F4 bool unk_00F4; //0x00F4
bool unk_00F5; //0x00F5 bool unk_00F5; //0x00F5
bool unk_00F6; //0x00F6 bool unk_00F6; //0x00F6
bool unk_00F7; //0x00F7 bool unk_00F7; //0x00F7
bool unk_00F8; //0x00F8 bool unk_00F8; //0x00F8
bool unk_00F9; //0x00F9 bool unk_00F9; //0x00F9
bool unk_00FA; //0x00FA bool unk_00FA; //0x00FA
bool unk_00FB; //0x00FB bool unk_00FB; //0x00FB
uint32_t unk_00FC; //0x00FC uint32_t unk_00FC; //0x00FC
uint32_t m_mobile_ring_state; //0x0100 uint32_t m_mobile_ring_state; //0x0100
int32_t m_player_team; //0x0104 int32_t m_player_team; //0x0104
float m_air_drag_multiplier; //0x0108 float m_air_drag_multiplier; //0x0108
uint32_t m_max_health; //0x010C uint32_t m_max_health; //0x010C
uint32_t m_max_armor; //0x0110 uint32_t m_max_armor; //0x0110
uint32_t m_jack_speed; //0x0114 uint32_t m_jack_speed; //0x0114
uint16_t m_player_is_targetable_by_team; //0x0118 uint16_t m_player_is_targetable_by_team; //0x0118
uint32_t m_override_receive_chat; //0x011C uint32_t m_override_receive_chat; //0x011C
uint32_t m_override_send_chat; //0x0120 uint32_t m_override_send_chat; //0x0120
bool unk_0124; //0x0124 bool unk_0124; //0x0124
bool unk_0125; //0x0125 bool unk_0125; //0x0125
bool unk_0126; //0x0126 bool unk_0126; //0x0126
bool unk_0127; //0x0127 bool unk_0127; //0x0127
uint16_t m_spectating_net_id; //0x0128 uint16_t m_spectating_net_id; //0x0128
uint8_t m_antagonistic_to_player_id; //0x012C uint8_t m_antagonistic_to_player_id; //0x012C
uint8_t m_tutorial_index; //0x012B uint8_t m_tutorial_index; //0x012B
uint8_t m_tutorial_instance_id; //0x012C uint8_t m_tutorial_instance_id; //0x012C
char pad_012D[2]; //0x012D char pad_012D[2]; //0x012D
float m_microphone_volume; //0x0130 float m_microphone_volume; //0x0130
uint32_t m_voice_channel; //0x0134 uint32_t m_voice_channel; //0x0134
bool m_is_overriding_voice_proximity; //0x0138 bool m_is_overriding_voice_proximity; //0x0138
char pad_0139[7]; //0x0139 char pad_0139[7]; //0x0139
float m_voice_proximity_x; //0x0140 float m_voice_proximity_x; //0x0140
float m_voice_proximity_y; //0x0144 float m_voice_proximity_y; //0x0144
float m_voice_proximity_z; //0x0148 float m_voice_proximity_z; //0x0148
float m_voice_proximity_radius_maybe; //0x014C float m_voice_proximity_radius_maybe; //0x014C
uint32_t unk_0150; //0x0150 uint32_t unk_0150; //0x0150
uint32_t m_vehicle_weapon_index; //0x0154 uint32_t m_vehicle_weapon_index; //0x0154
bool m_has_vehicle_weapon_index; //0x0158 bool m_has_vehicle_weapon_index; //0x0158
uint32_t m_decor_count; //0x015C uint32_t m_decor_count; //0x015C
uint32_t m_decor_type[3]; // 0x0160 uint32_t m_decor_type[3]; // 0x0160
uint32_t m_decor_value[3]; // 0x016C uint32_t m_decor_value[3]; // 0x016C
uint32_t m_decor_name_hash[3]; // 0x0178 uint32_t m_decor_name_hash[3]; // 0x0178
bool m_friendly_fire_allowed; //0x0184 bool m_friendly_fire_allowed; //0x0184
bool unk_0185; //0x0185 bool unk_0185; //0x0185
uint8_t m_current_garage_instance_index; //0x0186 uint8_t m_current_garage_instance_index; //0x0186
uint8_t m_current_property_id; //0x0187 uint8_t m_current_property_id; //0x0187
uint8_t unk_0188; //0x0188 uint8_t unk_0188; //0x0188
uint8_t unk_0189; //0x0189 uint8_t unk_0189; //0x0189
bool m_battle_aware; //0x018A bool m_battle_aware; //0x018A
bool m_vehicle_jump_down; //0x018B bool m_vehicle_jump_down; //0x018B
float m_weapon_defence_modifier; //0x018C float m_weapon_defence_modifier; //0x018C
float m_weapon_defence_modifier_2; //0x0190 float m_weapon_defence_modifier_2; //0x0190
bool m_is_overriding_population_control_sphere; //0x0194 bool m_is_overriding_population_control_sphere; //0x0194
char pad_0195[11]; //0x0195 char pad_0195[11]; //0x0195
float m_population_control_sphere_x; //0x01A0 float m_population_control_sphere_x; //0x01A0
float m_population_control_sphere_y; //0x01A4 float m_population_control_sphere_y; //0x01A4
float m_population_control_sphere_z; //0x01A8 float m_population_control_sphere_z; //0x01A8
uint16_t unk_01AC; //0x01AC uint16_t unk_01AC; //0x01AC
uint16_t unk_01AE; //0x01AE uint16_t unk_01AE; //0x01AE
uint16_t unk_01B0; //0x01B0 uint16_t unk_01B0; //0x01B0
bool pad_01B2; //0x01B2 bool pad_01B2; //0x01B2
bool unk_01B3; //0x01B3 bool unk_01B3; //0x01B3
bool m_no_collision; //0x01B4 bool m_no_collision; //0x01B4
bool unk_01B5; //0x01B5 bool unk_01B5; //0x01B5
bool unk_01B6; //0x01B6 bool unk_01B6; //0x01B6
bool m_super_jump; //0x01B7 bool m_super_jump; //0x01B7
bool unk_01B8; //0x01B8 bool unk_01B8; //0x01B8
bool unk_01B9; //0x01B9 bool unk_01B9; //0x01B9
uint16_t unk_01BA; //0x01BA uint16_t unk_01BA; //0x01BA
uint32_t unk_01BC; //0x01BC uint32_t unk_01BC; //0x01BC
float unk_01C0; //0x01C0 float unk_01C0; //0x01C0
float m_weapon_damage_modifier; //0x01C4 Divisor: 0x3F800000 float m_weapon_damage_modifier; //0x01C4 Divisor: 0x3F800000
float m_melee_weapon_damage_modifier; //0x01C8 Divisor: 0x3F800000 float m_melee_weapon_damage_modifier; //0x01C8 Divisor: 0x3F800000
float unk_01CC; //0x01CC float unk_01CC; //0x01CC
bool unk_01D0; //0x01D0 bool unk_01D0; //0x01D0
char pad_01D1[15]; //0x01D1 char pad_01D1[15]; //0x01D1
float unk_01E0; //0x01E0 float unk_01E0; //0x01E0
float unk_01E4; //0x01E4 float unk_01E4; //0x01E4
float unk_01E8; //0x01E8 float unk_01E8; //0x01E8
uint32_t unk_01EC; //0x01EC uint32_t unk_01EC; //0x01EC
uint8_t unk_01F0; //0x01F0 uint8_t unk_01F0; //0x01F0
uint8_t unk_01F1; //0x01F1 uint8_t unk_01F1; //0x01F1
bool unk_01F2; //0x01F2 bool unk_01F2; //0x01F2
uint8_t unk_01F3; //0x01F3 uint8_t unk_01F3; //0x01F3
bool unk_01F4; //0x01F4 bool unk_01F4; //0x01F4
bool unk_01F5; //0x01F5 bool unk_01F5; //0x01F5
}; //Size: 0x01F8 }; //Size: 0x01F8
static_assert(sizeof(CPlayerGameStateDataNode) == 0x1F8); static_assert(sizeof(CPlayerGameStateDataNode) == 0x1F8);
#pragma pack(pop) #pragma pack(pop)

8
datanodes/proximity_migrateable/CSectorDataNode.hpp
View File

@ -6,10 +6,10 @@
class CSectorDataNode class CSectorDataNode
{ {
public: public:
char pad_0x0[192]; //0x0 char pad_0x0[192]; //0x0
uint16_t m_pos_x; //0xC0 uint16_t m_pos_x; //0xC0
uint16_t m_pos_y; //0xC2 uint16_t m_pos_y; //0xC2
uint16_t m_pos_z; //0xC4 uint16_t m_pos_z; //0xC4
}; };
static_assert(sizeof(CSectorDataNode) == 0xC6); static_assert(sizeof(CSectorDataNode) == 0xC6);
#pragma pack(pop) #pragma pack(pop)

10
entities/CAttackers.hpp
View File

@ -6,10 +6,10 @@ class CPed; //fwdec
class CAttackers class CAttackers
{ {
public: public:
CPed* m_attacker0; //0x0000 CPed* m_attacker0; //0x0000
char pad_0x0008[0x10]; //0x0008 char pad_0x0008[0x10]; //0x0008
CPed* m_attacker1; //0x0018 CPed* m_attacker1; //0x0018
char pad_0x0020[0x10]; //0x0020 char pad_0x0020[0x10]; //0x0020
CPed* m_attacker2; //0x0030 CPed* m_attacker2; //0x0030
}; //Size=0x0038 }; //Size=0x0038
#pragma pack(pop) #pragma pack(pop)

170
enums/eExplosionTag.hpp
View File

@ -4,89 +4,89 @@
enum eExplosionTag : int32_t enum eExplosionTag : int32_t
{ {
DONTCARE = -1, DONTCARE = -1,
GRENADE, GRENADE,
GRENADELAUNCHER, GRENADELAUNCHER,
STICKYBOMB, STICKYBOMB,
MOLOTOV, MOLOTOV,
ROCKET, ROCKET,
TANKSHELL, TANKSHELL,
HI_OCTANE, HI_OCTANE,
CAR, CAR,
PLANE, PLANE,
PETROL_PUMP, PETROL_PUMP,
BIKE, BIKE,
DIR_STEAM, DIR_STEAM,
DIR_FLAME, DIR_FLAME,
DIR_WATER_HYDRANT, DIR_WATER_HYDRANT,
DIR_GAS_CANISTER, DIR_GAS_CANISTER,
BOAT, BOAT,
SHIP_DESTROY, SHIP_DESTROY,
TRUCK, TRUCK,
BULLET, BULLET,
SMOKEGRENADELAUNCHER, SMOKEGRENADELAUNCHER,
SMOKEGRENADE, SMOKEGRENADE,
BZGAS, BZGAS,
FLARE, FLARE,
GAS_CANISTER, GAS_CANISTER,
EXTINGUISHER, EXTINGUISHER,
_0x988620B8, _0x988620B8,
EXP_TAG_TRAIN, EXP_TAG_TRAIN,
EXP_TAG_BARREL, EXP_TAG_BARREL,
EXP_TAG_PROPANE, EXP_TAG_PROPANE,
EXP_TAG_BLIMP, EXP_TAG_BLIMP,
EXP_TAG_DIR_FLAME_EXPLODE, EXP_TAG_DIR_FLAME_EXPLODE,
EXP_TAG_TANKER, EXP_TAG_TANKER,
PLANE_ROCKET, PLANE_ROCKET,
EXP_TAG_VEHICLE_BULLET, EXP_TAG_VEHICLE_BULLET,
EXP_TAG_GAS_TANK, EXP_TAG_GAS_TANK,
EXP_TAG_BIRD_CRAP, EXP_TAG_BIRD_CRAP,
EXP_TAG_RAILGUN, EXP_TAG_RAILGUN,
EXP_TAG_BLIMP2, EXP_TAG_BLIMP2,
EXP_TAG_FIREWORK, EXP_TAG_FIREWORK,
EXP_TAG_SNOWBALL, EXP_TAG_SNOWBALL,
EXP_TAG_PROXMINE, EXP_TAG_PROXMINE,
EXP_TAG_VALKYRIE_CANNON, EXP_TAG_VALKYRIE_CANNON,
EXP_TAG_AIR_DEFENCE, EXP_TAG_AIR_DEFENCE,
EXP_TAG_PIPEBOMB, EXP_TAG_PIPEBOMB,
EXP_TAG_VEHICLEMINE, EXP_TAG_VEHICLEMINE,
EXP_TAG_EXPLOSIVEAMMO, EXP_TAG_EXPLOSIVEAMMO,
EXP_TAG_APCSHELL, EXP_TAG_APCSHELL,
EXP_TAG_BOMB_CLUSTER, EXP_TAG_BOMB_CLUSTER,
EXP_TAG_BOMB_GAS, EXP_TAG_BOMB_GAS,
EXP_TAG_BOMB_INCENDIARY, EXP_TAG_BOMB_INCENDIARY,
EXP_TAG_BOMB_STANDARD, EXP_TAG_BOMB_STANDARD,
EXP_TAG_TORPEDO, EXP_TAG_TORPEDO,
EXP_TAG_TORPEDO_UNDERWATER, EXP_TAG_TORPEDO_UNDERWATER,
EXP_TAG_BOMBUSHKA_CANNON, EXP_TAG_BOMBUSHKA_CANNON,
EXP_TAG_BOMB_CLUSTER_SECONDARY, EXP_TAG_BOMB_CLUSTER_SECONDARY,
EXP_TAG_HUNTER_BARRAGE, EXP_TAG_HUNTER_BARRAGE,
EXP_TAG_HUNTER_CANNON, EXP_TAG_HUNTER_CANNON,
EXP_TAG_ROGUE_CANNON, EXP_TAG_ROGUE_CANNON,
EXP_TAG_MINE_UNDERWATER, EXP_TAG_MINE_UNDERWATER,
EXP_TAG_ORBITAL_CANNON, EXP_TAG_ORBITAL_CANNON,
EXP_TAG_BOMB_STANDARD_WIDE, EXP_TAG_BOMB_STANDARD_WIDE,
EXP_TAG_EXPLOSIVEAMMO_SHOTGUN, EXP_TAG_EXPLOSIVEAMMO_SHOTGUN,
EXP_TAG_OPPRESSOR2_CANNON, EXP_TAG_OPPRESSOR2_CANNON,
EXP_TAG_MORTAR_KINETIC, EXP_TAG_MORTAR_KINETIC,
EXP_TAG_VEHICLEMINE_KINETIC, EXP_TAG_VEHICLEMINE_KINETIC,
EXP_TAG_VEHICLEMINE_EMP, EXP_TAG_VEHICLEMINE_EMP,
EXP_TAG_VEHICLEMINE_SPIKE, EXP_TAG_VEHICLEMINE_SPIKE,
EXP_TAG_VEHICLEMINE_SLICK, EXP_TAG_VEHICLEMINE_SLICK,
EXP_TAG_VEHICLEMINE_TAR, EXP_TAG_VEHICLEMINE_TAR,
EXP_TAG_SCRIPT_DRONE, EXP_TAG_SCRIPT_DRONE,
EXP_TAG_RAYGUN, EXP_TAG_RAYGUN,
EXP_TAG_BURIEDMINE, EXP_TAG_BURIEDMINE,
EXP_TAG_SCRIPT_MISSILE, EXP_TAG_SCRIPT_MISSILE,
EXP_TAG_RCTANK_ROCKET, EXP_TAG_RCTANK_ROCKET,
EXP_TAG_BOMB_WATER, EXP_TAG_BOMB_WATER,
EXP_TAG_BOMB_WATER_SECONDARY, EXP_TAG_BOMB_WATER_SECONDARY,
_0xF728C4A9, _0xF728C4A9,
_0xBAEC056F, _0xBAEC056F,
EXP_TAG_FLASHGRENADE, EXP_TAG_FLASHGRENADE,
EXP_TAG_STUNGRENADE, EXP_TAG_STUNGRENADE,
_0x763D3B3B, _0x763D3B3B,
EXP_TAG_SCRIPT_MISSILE_LARGE, EXP_TAG_SCRIPT_MISSILE_LARGE,
EXP_TAG_SUBMARINE_BIG, EXP_TAG_SUBMARINE_BIG,
EXP_TAG_EMPLAUNCHER_EMP, EXP_TAG_EMPLAUNCHER_EMP,
}; };

16
misc/CTunables.hpp
View File

@ -5,18 +5,18 @@
enum eTunableType enum eTunableType
{ {
TunableType_DONTCARE = -1, TunableType_DONTCARE = -1,
TunableType_UNK0, TunableType_UNK0,
TunableType_4BYTE, TunableType_4BYTE,
TunableType_1BYTE, TunableType_1BYTE,
}; };
class CTunables : public rage::datBase class CTunables : public rage::datBase
{ {
public: public:
char pad_0000[104]; //0x0008 char pad_0000[104]; //0x0008
uint64_t m_bPtr; //0x0070 uint64_t m_bPtr; //0x0070
uint16_t m_bCount; //0x0078 uint16_t m_bCount; //0x0078
char pad_007A[0x4E]; //0x007A char pad_007A[0x4E]; //0x007A
}; //Size: 0x00C8 }; //Size: 0x00C8
static_assert(sizeof(CTunables) == 0xC8); static_assert(sizeof(CTunables) == 0xC8);

94
network/CNetComplaintMgr.hpp
View File

@ -4,67 +4,67 @@
class CNetRemoteComplaint class CNetRemoteComplaint
{ {
public: public:
uint64_t m_complainer_token; //0x0000 uint64_t m_complainer_token; //0x0000
uint64_t m_complainee_token; //0x0008 uint64_t m_complainee_token; //0x0008
uint32_t m_flags; //0x0010 uint32_t m_flags; //0x0010
uint32_t m_time; //0x0014 uint32_t m_time; //0x0014
}; //Size: 0x0018 }; //Size: 0x0018
static_assert(sizeof(CNetRemoteComplaint) == 0x18); static_assert(sizeof(CNetRemoteComplaint) == 0x18);
class CNetComplaintMgr class CNetComplaintMgr
{ {
public: public:
uint64_t m_host_token; //0x0000 uint64_t m_host_token; //0x0000
uint32_t m_host_peer_id; //0x0008 uint32_t m_host_peer_id; //0x0008
char pad_000C[4]; //0x000C char pad_000C[4]; //0x000C
void* m_net_connection_mgr; //0x0010 void* m_net_connection_mgr; //0x0010
char pad_0018[64]; //0x0018 char pad_0018[64]; //0x0018
uint64_t m_host_tokens_in_scope[64]; //0x0058 uint64_t m_host_tokens_in_scope[64]; //0x0058
uint32_t m_num_tokens_in_scope; //0x0258 uint32_t m_num_tokens_in_scope; //0x0258
char pad_025C[4]; //0x025C char pad_025C[4]; //0x025C
class CNetRemoteComplaint m_remote_complaints[64]; //0x0260 class CNetRemoteComplaint m_remote_complaints[64]; //0x0260
uint32_t m_num_remote_complaints; //0x0860 uint32_t m_num_remote_complaints; //0x0860
char pad_0864[4]; //0x0864 char pad_0864[4]; //0x0864
uint64_t m_host_tokens_complained[64]; //0x0868 uint64_t m_host_tokens_complained[64]; //0x0868
uint32_t m_num_tokens_complained; //0x0A68 uint32_t m_num_tokens_complained; //0x0A68
char pad_0A6C[520]; //0x0A6C char pad_0A6C[520]; //0x0A6C
uint32_t m_connection_identifier; //0x0C74 uint32_t m_connection_identifier; //0x0C74
uint32_t m_last_resend_time; //0x0C78 uint32_t m_last_resend_time; //0x0C78
char pad_0C7C[4]; //0x0C7C char pad_0C7C[4]; //0x0C7C
uint32_t m_time_to_resend; //0x0C80 uint32_t m_time_to_resend; //0x0C80
uint32_t m_flags; //0x0C84 uint32_t m_flags; //0x0C84
char pad_0C88[16]; //0x0C88 char pad_0C88[16]; //0x0C88
inline bool has_local_complaint(uint64_t host_token) inline bool has_local_complaint(uint64_t host_token)
{ {
for (std::uint32_t i = 0; i < m_num_tokens_complained; i++) for (std::uint32_t i = 0; i < m_num_tokens_complained; i++)
if (m_host_tokens_complained[i] == host_token) if (m_host_tokens_complained[i] == host_token)
return true; return true;
return false; return false;
} }
inline void raise_complaint(uint64_t host_token) inline void raise_complaint(uint64_t host_token)
{ {
if (has_local_complaint(host_token)) if (has_local_complaint(host_token))
return; return;
m_host_tokens_complained[m_num_tokens_complained++] = host_token; m_host_tokens_complained[m_num_tokens_complained++] = host_token;
// big::g_pointers->m_raise_network_complaint(this, host_token); // big::g_pointers->m_raise_network_complaint(this, host_token);
} }
inline void remove_complaint(uint64_t host_token) inline void remove_complaint(uint64_t host_token)
{ {
if (!has_local_complaint(host_token)) if (!has_local_complaint(host_token))
return; return;
for (std::uint32_t i = 0; i < m_num_tokens_complained; i++) for (std::uint32_t i = 0; i < m_num_tokens_complained; i++)
if (m_host_tokens_complained[i] == host_token) if (m_host_tokens_complained[i] == host_token)
m_host_tokens_complained[i] = m_host_tokens_complained[m_num_tokens_complained - 1]; m_host_tokens_complained[i] = m_host_tokens_complained[m_num_tokens_complained - 1];
m_num_tokens_complained--; m_num_tokens_complained--;
} }
}; //Size: 0x0C98 }; //Size: 0x0C98
static_assert(sizeof(CNetComplaintMgr) == 0xC98); static_assert(sizeof(CNetComplaintMgr) == 0xC98);

266
network/Network.hpp
View File

@ -9,211 +9,211 @@
class MetricSessionMigrated : public rage::rlMetric class MetricSessionMigrated : public rage::rlMetric
{ {
public: public:
char pad_0008[804]; //0x0008 char pad_0008[804]; //0x0008
uint32_t m_num_players; //0x032C uint32_t m_num_players; //0x032C
}; //Size: 0x0330 }; //Size: 0x0330
static_assert(sizeof(MetricSessionMigrated) == 0x330); static_assert(sizeof(MetricSessionMigrated) == 0x330);
class NetworkGameConfig class NetworkGameConfig
{ {
public: public:
char pad_0000[48]; //0x0000 char pad_0000[48]; //0x0000
uint32_t m_public_slots; //0x0030 uint32_t m_public_slots; //0x0030
uint32_t m_private_slots; //0x0034 uint32_t m_private_slots; //0x0034
char pad_0038[272]; //0x0038 char pad_0038[272]; //0x0038
}; //Size: 0x0148 }; //Size: 0x0148
static_assert(sizeof(NetworkGameConfig) == 0x148); static_assert(sizeof(NetworkGameConfig) == 0x148);
class NetworkGameFilter class NetworkGameFilter
{ {
public: public:
char pad_0000[16]; //0x0000 char pad_0000[16]; //0x0000
char m_game_mode[24]; //0x0010 char m_game_mode[24]; //0x0010
char pad_0028[8]; //0x0028 char pad_0028[8]; //0x0028
uint32_t m_attribute_values[8]; //0x0030 uint32_t m_attribute_values[8]; //0x0030
char m_attribute_names[8][24]; //0x0050 char m_attribute_names[8][24]; //0x0050
char pad_0110[564]; //0x0110 char pad_0110[564]; //0x0110
}; //Size: 0x0344 }; //Size: 0x0344
static_assert(sizeof(NetworkGameFilter) == 0x344); static_assert(sizeof(NetworkGameFilter) == 0x344);
class SessionInfoBackup class SessionInfoBackup
{ {
public: public:
class rage::rlSessionInfo m_session_info; class rage::rlSessionInfo m_session_info;
uint32_t m_unk; //0x0070 uint32_t m_unk; //0x0070
char pad_0074[4]; //0x0074 char pad_0074[4]; //0x0074
uint32_t m_flags; //0x0078 uint32_t m_flags; //0x0078
}; //Size: 0x007C }; //Size: 0x007C
static_assert(sizeof(SessionInfoBackup) == 0x7C); static_assert(sizeof(SessionInfoBackup) == 0x7C);
class MatchmakingSessionResult class MatchmakingSessionResult
{ {
public: public:
class rage::rlSessionDetail m_detail; class rage::rlSessionDetail m_detail;
char pad_03B8[24]; //0x03B8 char pad_03B8[24]; //0x03B8
}; //Size: 0x03D0 }; //Size: 0x03D0
static_assert(sizeof(MatchmakingSessionResult) == 0x3D0); static_assert(sizeof(MatchmakingSessionResult) == 0x3D0);
class PlayerNameMapNode class PlayerNameMapNode
{ {
public: public:
char m_name[24]; //0x0000 char m_name[24]; //0x0000
class rage::rlGamerHandle m_handle; //0x0018 class rage::rlGamerHandle m_handle; //0x0018
class PlayerNameMapNode* m_next; //0x0028 class PlayerNameMapNode* m_next; //0x0028
class PlayerNameMapNode* m_prev; //0x0030 class PlayerNameMapNode* m_prev; //0x0030
}; //Size: 0x0038 }; //Size: 0x0038
static_assert(sizeof(PlayerNameMapNode) == 0x38); static_assert(sizeof(PlayerNameMapNode) == 0x38);
class JoiningPlayerNameMap class JoiningPlayerNameMap
{ {
public: public:
class PlayerNameMapNode m_names[100]; //0x0000 class PlayerNameMapNode m_names[100]; //0x0000
char pad_15E0[40]; //0x15E0 char pad_15E0[40]; //0x15E0
uint32_t m_num_name_nodes; //0x1608 uint32_t m_num_name_nodes; //0x1608
char pad_160C[796]; //0x160C char pad_160C[796]; //0x160C
}; //Size: 0x1928 }; //Size: 0x1928
static_assert(sizeof(JoiningPlayerNameMap) == 0x1928); static_assert(sizeof(JoiningPlayerNameMap) == 0x1928);
class CNetBlacklistNode class CNetBlacklistNode
{ {
public: public:
class rage::rlGamerHandle m_handle; //0x0000 class rage::rlGamerHandle m_handle; //0x0000
bool m_block_rejoin; //0x0010 bool m_block_rejoin; //0x0010
char pad_0011[3]; //0x0011 char pad_0011[3]; //0x0011
uint32_t m_added_time; //0x0014 uint32_t m_added_time; //0x0014
class CNetBlacklistNode* m_next; //0x0018 class CNetBlacklistNode* m_next; //0x0018
class CNetBlacklistNode* m_prev; //0x0020 class CNetBlacklistNode* m_prev; //0x0020
}; //Size: 0x0028 }; //Size: 0x0028
static_assert(sizeof(CNetBlacklistNode) == 0x28); static_assert(sizeof(CNetBlacklistNode) == 0x28);
class CNetBlacklist class CNetBlacklist
{ {
public: public:
class CNetBlacklistNode m_nodes[16]; //0x0000 class CNetBlacklistNode m_nodes[16]; //0x0000
class CNetBlacklistNode* m_head; //0x0280 class CNetBlacklistNode* m_head; //0x0280
class CNetBlacklistNode* m_tail; //0x0288 class CNetBlacklistNode* m_tail; //0x0288
uint32_t m_free_nodes; //0x0290 uint32_t m_free_nodes; //0x0290
char pad_0294[4]; //0x0294 char pad_0294[4]; //0x0294
class CNetBlacklistNode* m_start; //0x0298 class CNetBlacklistNode* m_start; //0x0298
char pad_02A0[24]; //0x02A0 char pad_02A0[24]; //0x02A0
}; //Size: 0x02B8 }; //Size: 0x02B8
static_assert(sizeof(CNetBlacklist) == 0x2B8); static_assert(sizeof(CNetBlacklist) == 0x2B8);
class RemotePlayerData class RemotePlayerData
{ {
public: public:
class rage::netGamePlayerData m_data[32]; //0x0000 class rage::netGamePlayerData m_data[32]; //0x0000
uint32_t m_count; //0x0600 uint32_t m_count; //0x0600
char pad_0604[4]; //0x0604 char pad_0604[4]; //0x0604
}; //Size: 0x0608 }; //Size: 0x0608
static_assert(sizeof(RemotePlayerData) == 0x608); static_assert(sizeof(RemotePlayerData) == 0x608);
class InvitedGamer class InvitedGamer
{ {
public: public:
class rage::rlGamerHandle m_handle; class rage::rlGamerHandle m_handle;
char pad_0010[12]; //0x0010 char pad_0010[12]; //0x0010
uint32_t m_flags; //0x001C uint32_t m_flags; //0x001C
}; //Size: 0x0020 }; //Size: 0x0020
static_assert(sizeof(InvitedGamer) == 0x20); static_assert(sizeof(InvitedGamer) == 0x20);
class InvitedGamers class InvitedGamers
{ {
public: public:
class InvitedGamer m_invited_gamers[100]; //0x0000 class InvitedGamer m_invited_gamers[100]; //0x0000
uint32_t m_num_invited_gamers; //0x0C80 uint32_t m_num_invited_gamers; //0x0C80
char pad_0C84[4]; //0x0C84 char pad_0C84[4]; //0x0C84
}; //Size: 0x0C88 }; //Size: 0x0C88
static_assert(sizeof(InvitedGamers) == 0xC88); static_assert(sizeof(InvitedGamers) == 0xC88);
class Network class Network
{ {
public: public:
class rage::rlSessionInfo m_session_info; //0x0000 class rage::rlSessionInfo m_session_info; //0x0000
class Obf32 m_num_dinput8_instances; //0x0070 class Obf32 m_num_dinput8_instances; //0x0070
class Obf32 m_last_time_dinput8_checked; //0x0080 class Obf32 m_last_time_dinput8_checked; //0x0080
class rage::snSession* m_game_session_ptr; //0x0090 class rage::snSession* m_game_session_ptr; //0x0090
class rage::snSession* m_transition_session_ptr; //0x0098 class rage::snSession* m_transition_session_ptr; //0x0098
char pad_00A0[24]; //0x00A0 char pad_00A0[24]; //0x00A0
class rage::snSession m_game_session; //0x00B8 class rage::snSession m_game_session; //0x00B8
class rage::snSession m_transition_session; //0x3F28 class rage::snSession m_transition_session; //0x3F28
char pad_7D98[16]; //0x7D98 char pad_7D98[16]; //0x7D98
class NetworkGameConfig m_network_game_config; //0x7DA8 class NetworkGameConfig m_network_game_config; //0x7DA8
class NetworkGameConfig m_network_transition_config; //0x7EF0 class NetworkGameConfig m_network_transition_config; //0x7EF0
bool m_session_attributes_dirty; //0x8038 bool m_session_attributes_dirty; //0x8038
char pad_8039[19]; //0x8039 char pad_8039[19]; //0x8039
uint32_t m_session_visibility_flags; //0x804C uint32_t m_session_visibility_flags; //0x804C
uint32_t m_transition_visibility_flags; //0x8050 uint32_t m_transition_visibility_flags; //0x8050
char pad_8054[36]; //0x8054 char pad_8054[36]; //0x8054
class MetricSessionMigrated m_metric_session_migrated; //0x8078 class MetricSessionMigrated m_metric_session_migrated; //0x8078
bool m_migrated_metric_enabled; //0x83A8 bool m_migrated_metric_enabled; //0x83A8
char pad_83A9[3]; //0x83A9 char pad_83A9[3]; //0x83A9
uint32_t m_game_session_state; //0x83AC uint32_t m_game_session_state; //0x83AC
class NetworkGameFilter m_network_game_filter; //0x83B0 class NetworkGameFilter m_network_game_filter; //0x83B0
char pad_86F4[33]; //0x86F4 char pad_86F4[33]; //0x86F4
bool m_was_invited; //0x8715 bool m_was_invited; //0x8715
char pad_8716[757]; //0x8716 char pad_8716[757]; //0x8716
bool m_need_host_change; //0x8A0B bool m_need_host_change; //0x8A0B
char pad_8A0C[2620]; //0x8A0C char pad_8A0C[2620]; //0x8A0C
class rage::rlSessionDetail m_joining_session_detail; //0x9448 class rage::rlSessionDetail m_joining_session_detail; //0x9448
class SessionInfoBackup m_last_joined_session; //0x9800 class SessionInfoBackup m_last_joined_session; //0x9800
char pad_987C[40]; //0x987C char pad_987C[40]; //0x987C
uint32_t m_current_matchmaking_group; //0x98A4 uint32_t m_current_matchmaking_group; //0x98A4
uint32_t m_matchmaking_group_max_players[5]; //0x98A8 uint32_t m_matchmaking_group_max_players[5]; //0x98A8
uint32_t m_num_active_matchmaking_groups; //0x98Bc uint32_t m_num_active_matchmaking_groups; //0x98Bc
char pad_98C0[8]; //0x98C0 char pad_98C0[8]; //0x98C0
uint8_t m_matchmaking_property_id; //0x98C8 uint8_t m_matchmaking_property_id; //0x98C8
uint8_t m_matchmaking_mental_state; //0x98C9 uint8_t m_matchmaking_mental_state; //0x98C9
char pad_98CA[374]; //0x98CA char pad_98CA[374]; //0x98CA
class rage::rlMatchmakingFindResult m_game_session_matchmaking[3]; //0x9A40 class rage::rlMatchmakingFindResult m_game_session_matchmaking[3]; //0x9A40
char pad_14390[40]; //0x14390 char pad_14390[40]; //0x14390
class MatchmakingSessionResult m_game_matchmaking_session_results[10]; //0x143B8 class MatchmakingSessionResult m_game_matchmaking_session_results[10]; //0x143B8
char pad_169D8[320]; //0x169D8 char pad_169D8[320]; //0x169D8
class rage::rlGamerHandle m_transition_creator_handle; //0x16B18 class rage::rlGamerHandle m_transition_creator_handle; //0x16B18
char pad_16B28[24]; //0x16B28 char pad_16B28[24]; //0x16B28
bool m_local_player_info_dirty; //0x16B40 bool m_local_player_info_dirty; //0x16B40
char pad_16B41[495]; //0x16B41 char pad_16B41[495]; //0x16B41
class rage::rlGamerHandle m_inviter_handle; //0x16D30 class rage::rlGamerHandle m_inviter_handle; //0x16D30
class CNetComplaintMgr m_game_complaint_mgr; //0x16D40 class CNetComplaintMgr m_game_complaint_mgr; //0x16D40
class CNetComplaintMgr m_transition_complaint_mgr; //0x179D8 class CNetComplaintMgr m_transition_complaint_mgr; //0x179D8
char pad_18670[32]; //0x18670 char pad_18670[32]; //0x18670
class JoiningPlayerNameMap m_unused_joining_player_name_map; //0x18690 class JoiningPlayerNameMap m_unused_joining_player_name_map; //0x18690
char pad_19FB8[8]; //0x19FB8 char pad_19FB8[8]; //0x19FB8
class CNetBlacklist m_blacklist; //0x19FC0 class CNetBlacklist m_blacklist; //0x19FC0
char pad_1A278[8]; //0x1A278 char pad_1A278[8]; //0x1A278
class InvitedGamers m_game_invited_gamers; //0x1A280 class InvitedGamers m_game_invited_gamers; //0x1A280
char pad_1AF08[56]; //0x1AF08 char pad_1AF08[56]; //0x1AF08
class SessionInfoBackup m_last_joined_transition; //0x1AF40 class SessionInfoBackup m_last_joined_transition; //0x1AF40
char pad_1AFBC[4]; //0x1AFBC char pad_1AFBC[4]; //0x1AFBC
uint32_t m_activity_spectator_max_players; //0x1AFC0 uint32_t m_activity_spectator_max_players; //0x1AFC0
char pad_1AFC4[56]; //0x1AFC4 char pad_1AFC4[56]; //0x1AFC4
bool m_is_activity_session; //0x1AFFC bool m_is_activity_session; //0x1AFFC
char pad_1AFFD[35]; //0x1AFFD char pad_1AFFD[35]; //0x1AFFD
class RemotePlayerData m_remote_player_data; //0x1B020 class RemotePlayerData m_remote_player_data; //0x1B020
char pad_1B628[8]; //0x1B628 char pad_1B628[8]; //0x1B628
class rage::netGamePlayerData m_local_net_game_player_data; //0x1B630 class rage::netGamePlayerData m_local_net_game_player_data; //0x1B630
char pad_1B660[600]; //0x1B660 char pad_1B660[600]; //0x1B660
class rage::rlMatchmakingFindResult m_transition_matchmaking[4]; //0x1B8B8 class rage::rlMatchmakingFindResult m_transition_matchmaking[4]; //0x1B8B8
class NetworkGameFilter m_transition_filters[4]; //0x29A78 class NetworkGameFilter m_transition_filters[4]; //0x29A78
char pad_2A788[20]; //0x2A788 char pad_2A788[20]; //0x2A788
uint32_t m_transition_quickmatch_group_handle_count; //0x2A79C uint32_t m_transition_quickmatch_group_handle_count; //0x2A79C
class rage::rlGamerHandle m_transition_quickmatch_group_handles[32]; //0x2A7A0 class rage::rlGamerHandle m_transition_quickmatch_group_handles[32]; //0x2A7A0
char pad_2A9A0[8]; //0x2A9A0 char pad_2A9A0[8]; //0x2A9A0
class rage::rlSessionInfo m_transition_to_activity_session_info; //0x2A9A8 class rage::rlSessionInfo m_transition_to_activity_session_info; //0x2A9A8
char pad_2AA18[48]; //0x2AA18 char pad_2AA18[48]; //0x2AA18
class MatchmakingSessionResult m_transition_matchmaking_session_results[10]; //0x2AA48 class MatchmakingSessionResult m_transition_matchmaking_session_results[10]; //0x2AA48
char pad_2D068[8]; //0x2D068 char pad_2D068[8]; //0x2D068
class InvitedGamers m_transition_invited_gamers; //0x2D070 class InvitedGamers m_transition_invited_gamers; //0x2D070
char pad_2DCF8[16]; //0x2DCF8 char pad_2DCF8[16]; //0x2DCF8
class rage::rlGamerHandle m_transition_to_game_handle; //0x2DD08 class rage::rlGamerHandle m_transition_to_game_handle; //0x2DD08
class rage::rlSessionInfo m_transition_to_game_session_info; //0x2DD18 class rage::rlSessionInfo m_transition_to_game_session_info; //0x2DD18
char pad_2DD88[4]; //0x2DD88 char pad_2DD88[4]; //0x2DD88
uint32_t m_transition_to_game_session_participant_count; //0x2DD8C uint32_t m_transition_to_game_session_participant_count; //0x2DD8C
class rage::rlGamerHandle m_transition_to_game_session_participants[32]; //0x2DD90 class rage::rlGamerHandle m_transition_to_game_session_participants[32]; //0x2DD90
char pad_2DF90[72]; //0x2DF90 char pad_2DF90[72]; //0x2DF90
class rage::rlGamerHandle m_follower_handles[32]; //0x2DFD8 class rage::rlGamerHandle m_follower_handles[32]; //0x2DFD8
uint32_t m_follower_count; //0x2E1D8 uint32_t m_follower_count; //0x2E1D8
char pad_2E1DC[628]; //0x2E1DC char pad_2E1DC[628]; //0x2E1DC
}; //Size: 0x2E450 }; //Size: 0x2E450
static_assert(sizeof(Network) == 0x2E450); static_assert(sizeof(Network) == 0x2E450);
#pragma pack(pop) #pragma pack(pop)

210
network/netObject.hpp
View File

@ -20,111 +20,111 @@ namespace rage
char pad_004E[1]; //0x004E char pad_004E[1]; //0x004E
bool m_should_not_be_delete; //0x004F bool m_should_not_be_delete; //0x004F
virtual ~netObject() = 0; virtual ~netObject() = 0;
virtual void mov1() = 0; virtual void mov1() = 0;
virtual void mov2() = 0; virtual void mov2() = 0;
virtual void m_8() = 0; virtual void m_8() = 0;
virtual void m_10() = 0; virtual void m_10() = 0;
virtual void m_18() = 0; virtual void m_18() = 0;
virtual void* m_20() = 0; virtual void* m_20() = 0;
virtual void m_28() = 0; virtual void m_28() = 0;
virtual netSyncTree* GetSyncTree() = 0; virtual netSyncTree* GetSyncTree() = 0;
virtual void m_38() = 0; virtual void m_38() = 0;
virtual void m_40() = 0; virtual void m_40() = 0;
virtual void m_48() = 0; virtual void m_48() = 0;
virtual void m_50() = 0; virtual void m_50() = 0;
virtual void m_58() = 0; virtual void m_58() = 0;
virtual void m_60() = 0; virtual void m_60() = 0;
virtual void m_68() = 0; virtual void m_68() = 0;
virtual void m_70() = 0; virtual void m_70() = 0;
virtual void m_78() = 0; virtual void m_78() = 0;
virtual CObject* GetGameObject() = 0; virtual CObject* GetGameObject() = 0;
virtual void m_88() = 0; virtual void m_88() = 0;
virtual void m_90() = 0; virtual void m_90() = 0;
virtual void m_98() = 0; virtual void m_98() = 0;
virtual int GetObjectFlags() = 0; virtual int GetObjectFlags() = 0;
virtual void m_A8() = 0; virtual void m_A8() = 0;
virtual void m_B0() = 0; virtual void m_B0() = 0;
virtual void m_B8() = 0; virtual void m_B8() = 0;
virtual void m_C0() = 0; virtual void m_C0() = 0;
virtual void m_C8() = 0; virtual void m_C8() = 0;
virtual int GetSyncFrequency() = 0; virtual int GetSyncFrequency() = 0;
virtual void m_D8() = 0; virtual void m_D8() = 0;
virtual void m_E0() = 0; virtual void m_E0() = 0;
virtual void m_E8() = 0; virtual void m_E8() = 0;
virtual void m_F0() = 0; virtual void m_F0() = 0;
virtual void m_F8() = 0; virtual void m_F8() = 0;
virtual void Update() = 0; virtual void Update() = 0;
virtual bool m_108_1604() = 0; // added in 1604 virtual bool m_108_1604() = 0; // added in 1604
virtual void m_108() = 0; virtual void m_108() = 0;
virtual void m_110() = 0; virtual void m_110() = 0;
virtual void m_118() = 0; virtual void m_118() = 0;
virtual void m_120() = 0; virtual void m_120() = 0;
virtual void m_128() = 0; virtual void m_128() = 0;
virtual void m_130() = 0; virtual void m_130() = 0;
virtual void m_138() = 0; virtual void m_138() = 0;
virtual void m_140() = 0; virtual void m_140() = 0;
virtual void m_148() = 0; virtual void m_148() = 0;
virtual void m_150() = 0; virtual void m_150() = 0;
virtual bool m_158(void* player, int type, int* outReason) = 0; virtual bool m_158(void* player, int type, int* outReason) = 0;
virtual void m_160() = 0; virtual void m_160() = 0;
virtual bool m_168(int* outReason) = 0; virtual bool m_168(int* outReason) = 0;
virtual void m_170() = 0; virtual void m_170() = 0;
virtual void m_178() = 0; virtual void m_178() = 0;
virtual void m_180() = 0; virtual void m_180() = 0;
virtual void m_188() = 0; virtual void m_188() = 0;
virtual void m_190() = 0; virtual void m_190() = 0;
virtual void m_198() = 0; virtual void m_198() = 0;
virtual void m_1A0() = 0; virtual void m_1A0() = 0;
virtual void m_1A8() = 0; virtual void m_1A8() = 0;
virtual void m_1B0() = 0; virtual void m_1B0() = 0;
virtual void m_1B8() = 0; virtual void m_1B8() = 0;
virtual void m_1C0() = 0; virtual void m_1C0() = 0;
virtual void m_1C8() = 0; virtual void m_1C8() = 0;
virtual void m_1D0() = 0; virtual void m_1D0() = 0;
virtual void m_1D8() = 0; virtual void m_1D8() = 0;
virtual void m_1E0() = 0; virtual void m_1E0() = 0;
virtual void m_1E8() = 0; virtual void m_1E8() = 0;
virtual void m_1F0() = 0; virtual void m_1F0() = 0;
virtual void m_1F8() = 0; virtual void m_1F8() = 0;
virtual void m_200() = 0; virtual void m_200() = 0;
virtual void m_208() = 0; virtual void m_208() = 0;
virtual void m_210() = 0; virtual void m_210() = 0;
virtual void m_218() = 0; virtual void m_218() = 0;
virtual void m_220() = 0; virtual void m_220() = 0;
virtual void m_228() = 0; virtual void m_228() = 0;
virtual void m_230() = 0; virtual void m_230() = 0;
virtual void m_238() = 0; virtual void m_238() = 0;
virtual void m_240() = 0; virtual void m_240() = 0;
virtual void m_248() = 0; virtual void m_248() = 0;
virtual void m_250() = 0; virtual void m_250() = 0;
virtual void m_258() = 0; virtual void m_258() = 0;
virtual void m_260() = 0; virtual void m_260() = 0;
virtual void m_268() = 0; virtual void m_268() = 0;
virtual void m_270() = 0; virtual void m_270() = 0;
virtual void m_278() = 0; virtual void m_278() = 0;
virtual void m_280() = 0; virtual void m_280() = 0;
virtual void m_288() = 0; virtual void m_288() = 0;
virtual void m_290() = 0; virtual void m_290() = 0;
virtual void m_298() = 0; virtual void m_298() = 0;
virtual void m_2A0() = 0; virtual void m_2A0() = 0;
virtual void m_2A8() = 0; virtual void m_2A8() = 0;
virtual void m_2B0() = 0; virtual void m_2B0() = 0;
virtual void m_2B8() = 0; virtual void m_2B8() = 0;
virtual void m_2C0() = 0; virtual void m_2C0() = 0;
virtual void m_2C8() = 0; virtual void m_2C8() = 0;
virtual void m_2D0() = 0; virtual void m_2D0() = 0;
virtual void m_2D8() = 0; virtual void m_2D8() = 0;
virtual void m_2E0() = 0; virtual void m_2E0() = 0;
virtual void m_2E8() = 0; virtual void m_2E8() = 0;
virtual void m_2F0() = 0; virtual void m_2F0() = 0;
virtual void m_2F8() = 0; virtual void m_2F8() = 0;
virtual void m_300() = 0; virtual void m_300() = 0;
virtual void m_308() = 0; virtual void m_308() = 0;
virtual void m_310() = 0; virtual void m_310() = 0;
virtual void m_318() = 0; virtual void m_318() = 0;
virtual void m_320() = 0; virtual void m_320() = 0;
virtual void UpdatePendingVisibilityChanges() = 0; virtual void UpdatePendingVisibilityChanges() = 0;
}; //Size: 0x0050 }; //Size: 0x0050
static_assert(sizeof(netObject) == 0x50); static_assert(sizeof(netObject) == 0x50);
} }

316
network/snSession.hpp
View File

@ -6,188 +6,188 @@
#pragma pack(push, 1) #pragma pack(push, 1)
namespace rage namespace rage
{ {
class netConnectionManager; class netConnectionManager;
class sysMemAllocator; class sysMemAllocator;
class snPlayer class snPlayer
{ {
public: public:
uint64_t m_msg_id; //0x0000 uint64_t m_msg_id; //0x0000
class rage::rlGamerInfo m_player_data; //0x0008 class rage::rlGamerInfo m_player_data; //0x0008
}; //Size: 0x00A0 }; //Size: 0x00A0
static_assert(sizeof(rage::snPlayer) == 0xA0); static_assert(sizeof(rage::snPlayer) == 0xA0);
class snPeer class snPeer
{ {
public: public:
class rage::rlGamerInfo m_peer_data; //0x0000 class rage::rlGamerInfo m_peer_data; //0x0000
char pad_0098[40]; //0x0098 char pad_0098[40]; //0x0098
}; //Size: 0x00C0 }; //Size: 0x00C0
static_assert(sizeof(rage::snPeer) == 0xC0); static_assert(sizeof(rage::snPeer) == 0xC0);
class rlRemoteGamer class rlRemoteGamer
{ {
public: public:
rage::rlGamerHandle m_handle; rage::rlGamerHandle m_handle;
char pad_0010[4]; //0x0010 char pad_0010[4]; //0x0010
uint32_t m_timeout_time; //0x0014 uint32_t m_timeout_time; //0x0014
uint32_t m_time_unk; //0x0018 uint32_t m_time_unk; //0x0018
char pad_001C[4]; //0x001C char pad_001C[4]; //0x001C
}; //Size: 0x0020 }; //Size: 0x0020
static_assert(sizeof(rage::rlRemoteGamer) == 0x20); static_assert(sizeof(rage::rlRemoteGamer) == 0x20);
class rlSession class rlSession
{ {
public: public:
char pad_0008[168]; //0x0008 char pad_0008[168]; //0x0008
class rage::rlSessionInfo m_session_info; //0x00B0 class rage::rlSessionInfo m_session_info; //0x00B0
char pad_0120[288]; //0x0120 char pad_0120[288]; //0x0120
uint64_t m_session_id; //0x0240 uint64_t m_session_id; //0x0240
char pad_0248[1648]; //0x0248 char pad_0248[1648]; //0x0248
virtual ~rlSession() = default; virtual ~rlSession() = default;
}; //Size: 0x08B8 }; //Size: 0x08B8
static_assert(sizeof(rage::rlSession) == 0x8B8); static_assert(sizeof(rage::rlSession) == 0x8B8);
class rlSessionDetail class rlSessionDetail
{ {
public: public:
class rage::rlGamerInfoBase m_base_gamer_info; class rage::rlGamerInfoBase m_base_gamer_info;
char pad_0060[8]; //0x0060 char pad_0060[8]; //0x0060
class rage::rlSessionInfo m_session_info; //0x0068 class rage::rlSessionInfo m_session_info; //0x0068
char pad_00D8[14]; //0x00D8 char pad_00D8[14]; //0x00D8
uint16_t m_session_type; //0x00E6 uint16_t m_session_type; //0x00E6
char pad_00E8[324]; //0x00E8 char pad_00E8[324]; //0x00E8
uint32_t m_player_count; //0x022C uint32_t m_player_count; //0x022C
uint32_t m_unk_player_count; //0x0230 uint32_t m_unk_player_count; //0x0230
char pad_0234[2]; //0x0234 char pad_0234[2]; //0x0234
int16_t m_unk_pos_x; //0x0236 int16_t m_unk_pos_x; //0x0236
int16_t m_unk_pos_y; //0x0238 int16_t m_unk_pos_y; //0x0238
int16_t m_unk_pos_z; //0x023A int16_t m_unk_pos_z; //0x023A
uint8_t m_matchmaking_property_ids[32]; //0x023C uint8_t m_matchmaking_property_ids[32]; //0x023C
char pad_025C[2]; //0x025C char pad_025C[2]; //0x025C
uint16_t m_rank; //0x025E uint16_t m_rank; //0x025E
char pad_0260[1]; //0x0260 char pad_0260[1]; //0x0260
uint8_t m_mental_state; //0x0261 uint8_t m_mental_state; //0x0261
char pad_0262[21]; //0x0262 char pad_0262[21]; //0x0262
uint8_t m_population_density; //0x0277 uint8_t m_population_density; //0x0277
char pad_0278[320]; //0x0278 char pad_0278[320]; //0x0278
}; //Size: 0x03CA }; //Size: 0x03CA
static_assert(sizeof(rlSessionDetail) == 0x3B8); static_assert(sizeof(rlSessionDetail) == 0x3B8);
class rlMatchmakingFindResult class rlMatchmakingFindResult
{ {
public: public:
class rage::rlSessionDetail m_result_session_details[15]; //0x0000 class rage::rlSessionDetail m_result_session_details[15]; //0x0000
char pad_37C8[168]; //0x37C8 char pad_37C8[168]; //0x37C8
}; //Size: 0x3870 }; //Size: 0x3870
static_assert(sizeof(rage::rlMatchmakingFindResult) == 0x3870); static_assert(sizeof(rage::rlMatchmakingFindResult) == 0x3870);
class netGamePlayerData class netGamePlayerData
{ {
public: public:
class rlGamerHandle m_handle; class rlGamerHandle m_handle;
bool m_is_activity_spectator; //0x0010 bool m_is_activity_spectator; //0x0010
char pad_0011[7]; //0x0011 char pad_0011[7]; //0x0011
uint64_t m_crew_id; //0x0018 uint64_t m_crew_id; //0x0018
uint16_t m_rank; //0x0020 uint16_t m_rank; //0x0020
uint16_t m_debug_unk; //0x0022 uint16_t m_debug_unk; //0x0022
char pad_0024[4]; //0x0024 char pad_0024[4]; //0x0024
uint32_t m_nat_type; //0x0028 uint32_t m_nat_type; //0x0028
bool m_is_rockstar_dev; //0x002C bool m_is_rockstar_dev; //0x002C
char pad_002D[3]; //0x002D char pad_002D[3]; //0x002D
}; //Size: 0x0030 }; //Size: 0x0030
static_assert(sizeof(rage::netGamePlayerData) == 0x30); static_assert(sizeof(rage::netGamePlayerData) == 0x30);
class snSession class snSession
{ {
public: public:
rage::sysMemAllocator* m_memory_allocator; //0x0000 rage::sysMemAllocator* m_memory_allocator; //0x0000
char pad_0008[64]; //0x0008 char pad_0008[64]; //0x0008
rage::netConnectionManager* m_net_connection_mgr; //0x0048 rage::netConnectionManager* m_net_connection_mgr; //0x0048
char pad_0050[48]; //0x0050 char pad_0050[48]; //0x0050
class rage::rlSession m_rline_session; //0x0080 class rage::rlSession m_rline_session; //0x0080
class rage::snPlayer m_local_player; //0x0938 class rage::snPlayer m_local_player; //0x0938
uint64_t m_host_token; //0x09D8 uint64_t m_host_token; //0x09D8
char pad_09E0[144]; //0x09E0 char pad_09E0[144]; //0x09E0
class rage::snPeer m_peer_storage[32]; //0x0A70 class rage::snPeer m_peer_storage[32]; //0x0A70
char pad_2270[24]; //0x2270 char pad_2270[24]; //0x2270
class rage::snPeer* m_peers[32]; //0x2288 class rage::snPeer* m_peers[32]; //0x2288
uint32_t m_peer_count; //0x2388 uint32_t m_peer_count; //0x2388
char pad_238C[4]; //0x238C char pad_238C[4]; //0x238C
class rage::snPlayer m_player_storage[32]; //0x2390 class rage::snPlayer m_player_storage[32]; //0x2390
char pad_3790[24]; //0x3790 char pad_3790[24]; //0x3790
class rage::snPlayer* m_players[32]; //0x37A8 class rage::snPlayer* m_players[32]; //0x37A8
uint32_t m_player_count; //0x38A8 uint32_t m_player_count; //0x38A8
char pad_38AC[4]; //0x38AC char pad_38AC[4]; //0x38AC
class rage::rlRemoteGamer m_remote_gamers[32]; //0x38B0 class rage::rlRemoteGamer m_remote_gamers[32]; //0x38B0
uint32_t m_num_remote_gamers; //0x3CB0 uint32_t m_num_remote_gamers; //0x3CB0
bool m_player_joining; //0x3CB4 bool m_player_joining; //0x3CB4
char pad_3CB5[107]; //0x3CB5 char pad_3CB5[107]; //0x3CB5
uint32_t m_connection_identifier; //0x3D20 uint32_t m_connection_identifier; //0x3D20
char pad_3D24[8]; //0x3D24 char pad_3D24[8]; //0x3D24
char m_token_key[64]; //0x3D2C char m_token_key[64]; //0x3D2C
char m_id_key[64]; //0x3D6C char m_id_key[64]; //0x3D6C
char m_info_key[64]; //0x3DAC char m_info_key[64]; //0x3DAC
char m_host_key[64]; //0x3DEC char m_host_key[64]; //0x3DEC
char m_join_key[64]; //0x3E2C char m_join_key[64]; //0x3E2C
char pad_3E6C[4]; //0x3E6C char pad_3E6C[4]; //0x3E6C
inline bool is_host() inline bool is_host()
{ {
return m_local_player.m_player_data.m_host_token == m_host_token; return m_local_player.m_player_data.m_host_token == m_host_token;
} }
inline snPlayer* get_player_by_token(uint64_t token) inline snPlayer* get_player_by_token(uint64_t token)
{ {
for (std::uint32_t i = 0; i < m_player_count; i++) for (std::uint32_t i = 0; i < m_player_count; i++)
{ {
if (m_players[i]->m_player_data.m_host_token == token) if (m_players[i]->m_player_data.m_host_token == token)
{ {
return m_players[i]; return m_players[i];
} }
} }
return nullptr; return nullptr;
} }
inline snPeer* get_peer_by_rockstar_id(uint64_t rid) inline snPeer* get_peer_by_rockstar_id(uint64_t rid)
{ {
for (uint32_t i = 0; i < m_peer_count; i++) for (uint32_t i = 0; i < m_peer_count; i++)
{ {
if (m_peers[i]->m_peer_data.m_gamer_handle_2.m_rockstar_id == rid) if (m_peers[i]->m_peer_data.m_gamer_handle_2.m_rockstar_id == rid)
{ {
return m_peers[i]; return m_peers[i];
} }
} }
return nullptr; return nullptr;
} }
}; //Size: 0x3E70 }; //Size: 0x3E70
static_assert(sizeof(rage::snSession) == 0x3E70); static_assert(sizeof(rage::snSession) == 0x3E70);
class snMsgRemoveGamersFromSessionCmd class snMsgRemoveGamersFromSessionCmd
{ {
public: public:
uint64_t m_session_id; //0x0000 uint64_t m_session_id; //0x0000
uint64_t m_peer_ids[32]; //0x0008 uint64_t m_peer_ids[32]; //0x0008
int32_t m_unk = -1; //0x0108 int32_t m_unk = -1; //0x0108
uint32_t m_num_peers; //0x010C uint32_t m_num_peers; //0x010C
}; //Size: 0x0110 }; //Size: 0x0110
static_assert(sizeof(rage::snMsgRemoveGamersFromSessionCmd) == 0x110); static_assert(sizeof(rage::snMsgRemoveGamersFromSessionCmd) == 0x110);
} }
class SessionSortEntry class SessionSortEntry
{ {
public: public:
class rage::rlSessionDetail* m_session_detail; //0x0000 class rage::rlSessionDetail* m_session_detail; //0x0000
char pad_0008[4]; //0x0008 char pad_0008[4]; //0x0008
float m_score; //0x000C float m_score; //0x000C
char pad_0010[8]; //0x0010 char pad_0010[8]; //0x0010
}; //Size: 0x0018 }; //Size: 0x0018
static_assert(sizeof(SessionSortEntry) == 0x18); static_assert(sizeof(SessionSortEntry) == 0x18);
#pragma pack(pop) #pragma pack(pop)

58
ped/CPed.hpp
View File

@ -18,35 +18,35 @@
class CPed : public rage::CPhysical class CPed : public rage::CPhysical
{ {
public: public:
char gap2EC[20]; char gap2EC[20];
rage::fvector3 m_velocity; //0x0300 rage::fvector3 m_velocity; //0x0300
char pad_030C[260]; //0x030C char pad_030C[260]; //0x030C
class CPedBoneInfo m_bone_info; //0x0410 class CPedBoneInfo m_bone_info; //0x0410
char pad_04A0[2160]; //0x04A0 char pad_04A0[2160]; //0x04A0
class CVehicle *m_vehicle; //0x0D10 class CVehicle *m_vehicle; //0x0D10
char pad_0D18[896]; //0x0D18 char pad_0D18[896]; //0x0D18
uint32_t m_ped_type; //0x1098 uint32_t m_ped_type; //0x1098
char pad_109C[4]; //0x109C char pad_109C[4]; //0x109C
class CPedOxygenInfo* m_oxygen_info; //0x10A0 class CPedOxygenInfo* m_oxygen_info; //0x10A0
class CPlayerInfo *m_player_info; //0x10A8 class CPlayerInfo *m_player_info; //0x10A8
class CPedInventory* m_inventory; //0x10B0 class CPedInventory* m_inventory; //0x10B0
class CPedWeaponManager *m_weapon_manager; //0x10B8 class CPedWeaponManager *m_weapon_manager; //0x10B8
char pad_10C0[892]; //0x10C0 char pad_10C0[892]; //0x10C0
uint8_t m_seatbelt; //0x143C uint8_t m_seatbelt; //0x143C
char pad_143D[13]; //0x143D char pad_143D[13]; //0x143D
uint8_t m_can_switch_weapon; //0x144A uint8_t m_can_switch_weapon; //0x144A
uint8_t m_ped_task_flag; //0x144B uint8_t m_ped_task_flag; //0x144B
char pad_144C[4]; //0x144C char pad_144C[4]; //0x144C
uint8_t m_forced_aim; //0x1450 m_forced_aim ^= (m_forced_aim ^ -(char)toggle) & 0x20; uint8_t m_forced_aim; //0x1450 m_forced_aim ^= (m_forced_aim ^ -(char)toggle) & 0x20;
char pad_1451[187]; //0x1451 char pad_1451[187]; //0x1451
float m_armor; //0x150C float m_armor; //0x150C
float unk_health_threshold; //0x1510 float unk_health_threshold; //0x1510
float m_fatigued_health_threshold; //0x1514 float m_fatigued_health_threshold; //0x1514
float m_injured_health_threshold; //0x1518 float m_injured_health_threshold; //0x1518
float m_dying_health_threshold; //0x151C float m_dying_health_threshold; //0x151C
float m_hurt_health_threshold; //0x1520 float m_hurt_health_threshold; //0x1520
char pad_1524[240]; //0x1524 char pad_1524[240]; //0x1524
uint16_t m_cash; //0x1614 uint16_t m_cash; //0x1614
}; //Size: 0x1616 }; //Size: 0x1616
static_assert(sizeof(CPed) == 0x1616); static_assert(sizeof(CPed) == 0x1616);

36
ped/CPedBoneInfo.hpp
View File

@ -5,23 +5,23 @@
class CPedBoneInfo class CPedBoneInfo
{ {
public: public:
rage::fvector3 m_bone_head_model_coords; //0x0000 rage::fvector3 m_bone_head_model_coords; //0x0000
char pad_000C[4]; //0x000C char pad_000C[4]; //0x000C
rage::fvector3 m_bone_left_foot_model_coords; //0x0010 rage::fvector3 m_bone_left_foot_model_coords; //0x0010
char pad_001C[4]; //0x001C char pad_001C[4]; //0x001C
rage::fvector3 m_bone_right_foot_model_coords; //0x0020 rage::fvector3 m_bone_right_foot_model_coords; //0x0020
char pad_002C[4]; //0x002C char pad_002C[4]; //0x002C
rage::fvector3 m_bone_left_ankle_model_coords; //0x0030 rage::fvector3 m_bone_left_ankle_model_coords; //0x0030
char pad_003C[4]; //0x003C char pad_003C[4]; //0x003C
rage::fvector3 m_bone_right_ankle_model_coords; //0x0040 rage::fvector3 m_bone_right_ankle_model_coords; //0x0040
char pad_004C[4]; //0x004C char pad_004C[4]; //0x004C
rage::fvector3 m_bone_left_hand_model_coords; //0x0050 rage::fvector3 m_bone_left_hand_model_coords; //0x0050
char pad_005C[4]; //0x005C char pad_005C[4]; //0x005C
rage::fvector3 m_bone_right_hand_model_coords; //0x0060 rage::fvector3 m_bone_right_hand_model_coords; //0x0060
char pad_006C[4]; //0x006C char pad_006C[4]; //0x006C
rage::fvector3 m_bone_neck_model_coords; //0x0070 rage::fvector3 m_bone_neck_model_coords; //0x0070
char pad_007C[4]; //0x007C char pad_007C[4]; //0x007C
rage::fvector3 m_bone_abdomen_model_coords; //0x0080 rage::fvector3 m_bone_abdomen_model_coords; //0x0080
char pad_008C[4]; //0x008C char pad_008C[4]; //0x008C
}; //Size: 0x0090 }; //Size: 0x0090
static_assert(sizeof(CPedBoneInfo) == 0x90); static_assert(sizeof(CPedBoneInfo) == 0x90);

4
ped/CPedFactory.hpp
View File

@ -5,7 +5,7 @@
class CPedFactory class CPedFactory
{ {
public: public:
char pad_0000[8]; //0x0000 char pad_0000[8]; //0x0000
class CPed* m_local_ped; //0x0008 class CPed* m_local_ped; //0x0008
}; //Size: 0x0010 }; //Size: 0x0010
static_assert(sizeof(CPedFactory) == 0x10); static_assert(sizeof(CPedFactory) == 0x10);

70
ped/CPedModelInfo.hpp
View File

@ -7,40 +7,40 @@
class CPedModelInfo : public CBaseModelInfo class CPedModelInfo : public CBaseModelInfo
{ {
public: public:
char gapB0[48]; char gapB0[48];
uint64_t qwordE0; uint64_t qwordE0;
uint32_t dwordE8; uint32_t dwordE8;
char gapEC[4]; char gapEC[4];
uint32_t dwordF0; uint32_t dwordF0;
char gapF4[4]; char gapF4[4];
uint64_t qwordF8; uint64_t qwordF8;
uint32_t dword100; uint32_t dword100;
uint64_t qword108; uint64_t qword108;
uint64_t qword110; uint64_t qword110;
uint64_t qword118; uint64_t qword118;
uint64_t qword120; uint64_t qword120;
uint64_t qword128; uint64_t qword128;
uint32_t dword130; uint32_t dword130;
char gap134[148]; char gap134[148];
uint64_t qword1C8; uint64_t qword1C8;
uint32_t dword1D0; uint32_t dword1D0;
uint64_t qword1D8; uint64_t qword1D8;
uint32_t dword1E0; uint32_t dword1E0;
char gap1E4[52]; char gap1E4[52];
uint64_t qword218; uint64_t qword218;
char gap220[8]; char gap220[8];
uint64_t qword228; uint64_t qword228;
uint32_t dword230; uint32_t dword230;
char gap234[4]; char gap234[4];
uint32_t dword238; uint32_t dword238;
char gap23C[12]; char gap23C[12];
uint64_t qword248; uint64_t qword248;
uint64_t qword250; uint64_t qword250;
uint64_t qword258; uint64_t qword258;
uint64_t qword260; uint64_t qword260;
uint64_t qword268; uint64_t qword268;
uint64_t qword270; uint64_t qword270;
uint64_t qword278; uint64_t qword278;
char gap280[16]; char gap280[16];
}; };
static_assert(sizeof(CPedModelInfo) == 0x290); static_assert(sizeof(CPedModelInfo) == 0x290);

4
ped/CPedOxygenInfo.hpp
View File

@ -3,7 +3,7 @@
class CPedOxygenInfo class CPedOxygenInfo
{ {
public: public:
char pad_0000[632]; //0x0000 char pad_0000[632]; //0x0000
float m_oxygen_time; //0x0278 float m_oxygen_time; //0x0278
}; //Size: 0x027C }; //Size: 0x027C
static_assert(sizeof(CPedOxygenInfo) == 0x27C); static_assert(sizeof(CPedOxygenInfo) == 0x27C);

14
ped/CPedWeaponManager.hpp
View File

@ -7,12 +7,12 @@
class CPedWeaponManager class CPedWeaponManager
{ {
public: public:
char pad_0000[16]; //0x0000 char pad_0000[16]; //0x0000
class CPed* m_owner; //0x0010 class CPed* m_owner; //0x0010
uint32_t m_selected_weapon_hash; //0x0018 uint32_t m_selected_weapon_hash; //0x0018
char pad_001C[4]; //0x001C char pad_001C[4]; //0x001C
class CWeaponInfo* m_weapon_info; //0x0020 class CWeaponInfo* m_weapon_info; //0x0020
char pad_0028[72]; //0x0028 char pad_0028[72]; //0x0028
class CWeaponInfo* m_vehicle_weapon_info; //0x0070 class CWeaponInfo* m_vehicle_weapon_info; //0x0070
}; //Size: 0x0078 }; //Size: 0x0078
static_assert(sizeof(CPedWeaponManager) == 0x78); static_assert(sizeof(CPedWeaponManager) == 0x78);

6
player/CNonPhysicalPlayerData.hpp
View File

@ -22,9 +22,9 @@ namespace rage
class CNonPhysicalPlayerData : public rage::nonPhysicalPlayerDataBase class CNonPhysicalPlayerData : public rage::nonPhysicalPlayerDataBase
{ {
public: public:
int32_t m_bubble_id; //0x0008 int32_t m_bubble_id; //0x0008
int32_t m_player_id; //0x000C int32_t m_player_id; //0x000C
rage::fvector3 m_position; //0x0010 rage::fvector3 m_position; //0x0010
}; //Size: 0x001C }; //Size: 0x001C
static_assert(sizeof(CNonPhysicalPlayerData) == 0x1C); static_assert(sizeof(CNonPhysicalPlayerData) == 0x1C);
#pragma pack(pop) #pragma pack(pop)

22
player/CPlayerAngles.hpp
View File

@ -7,16 +7,16 @@ class CPlayerCameraData;
class CPlayerAngles class CPlayerAngles
{ {
public: public:
char pad_0000[16]; //0x0000 char pad_0000[16]; //0x0000
CPlayerCameraData* m_cam_data; //0x0010 CPlayerCameraData* m_cam_data; //0x0010
char pad_0018[24]; //0x0018 char pad_0018[24]; //0x0018
rage::fvector3 m_right; //0x0030 rage::fvector3 m_right; //0x0030
char pad_003C[4]; //0x003C char pad_003C[4]; //0x003C
rage::fvector3 m_forward; //0x0040 rage::fvector3 m_forward; //0x0040
char pad_004C[4]; //0x004C char pad_004C[4]; //0x004C
rage::fvector3 m_up; //0x0050 rage::fvector3 m_up; //0x0050
char pad_005C[4]; //0x005C char pad_005C[4]; //0x005C
rage::fvector3 m_position; //0x0060 rage::fvector3 m_position; //0x0060
char pad_006C[36]; //0x006C char pad_006C[36]; //0x006C
}; //Size: 0x0090 }; //Size: 0x0090
static_assert(sizeof(CPlayerAngles) == 0x90); static_assert(sizeof(CPlayerAngles) == 0x90);

96
player/CPlayerInfo.hpp
View File

@ -6,60 +6,60 @@
enum class eGameState : int32_t enum class eGameState : int32_t
{ {
Invalid = -1, Invalid = -1,
Playing, Playing,
Died, Died,
Arrested, Arrested,
FailedMission, FailedMission,
LeftGame, LeftGame,
Respawn, Respawn,
InMPCutscene InMPCutscene
}; };
#pragma pack(push, 4) #pragma pack(push, 4)
class CPlayerInfo class CPlayerInfo
{ {
public: public:
char pad_0000[32]; //0x0000 char pad_0000[32]; //0x0000
class rage::rlGamerInfo m_net_player_data; //0x0020 class rage::rlGamerInfo m_net_player_data; //0x0020
char pad_00B8[184]; //0x00B8 char pad_00B8[184]; //0x00B8
float m_swim_speed; //0x0170 float m_swim_speed; //0x0170
char pad_0174[20]; //0x0174 char pad_0174[20]; //0x0174
uint32_t m_water_proof; //0x0188 uint32_t m_water_proof; //0x0188
char pad_018C[76]; //0x018C char pad_018C[76]; //0x018C
eGameState m_game_state; //0x01D8 eGameState m_game_state; //0x01D8
char pad_01DC[12]; //0x01DC char pad_01DC[12]; //0x01DC
class CPed *m_ped; //0x01E8 class CPed *m_ped; //0x01E8
char pad_01F0[40]; //0x01F0 char pad_01F0[40]; //0x01F0
uint32_t m_frame_flags; //0x0218 uint32_t m_frame_flags; //0x0218
char pad_021C[52]; //0x021C char pad_021C[52]; //0x021C
uint32_t m_player_controls; //0x0250 uint32_t m_player_controls; //0x0250
char pad_0254[1256]; //0x0254 char pad_0254[1256]; //0x0254
float m_wanted_can_change; //0x073C float m_wanted_can_change; //0x073C
char pad_0740[144]; //0x0740 char pad_0740[144]; //0x0740
float m_wanted_level_difficulty; //0x07D0 min:-1 max:1 float m_wanted_level_difficulty; //0x07D0 min:-1 max:1
char pad_07D4[52]; //0x07D4 char pad_07D4[52]; //0x07D4
float m_wanted_level_multiplier; //0x0808 min:0 max:1 float m_wanted_level_multiplier; //0x0808 min:0 max:1
char pad_080C[100]; //0x080C char pad_080C[100]; //0x080C
uint32_t m_npc_ignore; //0x0870 uint32_t m_npc_ignore; //0x0870
char pad_0874[12]; //0x0874 char pad_0874[12]; //0x0874
bool m_is_wanted; //0x0880 bool m_is_wanted; //0x0880
char pad_0881[7]; //0x0881 char pad_0881[7]; //0x0881
uint32_t m_wanted_level; //0x0888 uint32_t m_wanted_level; //0x0888
uint32_t m_wanted_level_display; //0x088C uint32_t m_wanted_level_display; //0x088C
char pad_0890[1120]; //0x0890 char pad_0890[1120]; //0x0890
float m_run_speed; //0x0CF0 float m_run_speed; //0x0CF0
float m_stamina; //0x0CF4 float m_stamina; //0x0CF4
float m_stamina_regen; //0x0CF8 float m_stamina_regen; //0x0CF8
char pad_0CFC[16]; //0x0CFC char pad_0CFC[16]; //0x0CFC
float m_weapon_damage_mult; //0x0D0C float m_weapon_damage_mult; //0x0D0C
float m_weapon_defence_mult; //0x0D10 float m_weapon_defence_mult; //0x0D10
char pad_0D14[4]; //0x0D14 char pad_0D14[4]; //0x0D14
float m_melee_weapon_damage_mult; //0x0D18 float m_melee_weapon_damage_mult; //0x0D18
float m_melee_damage_mult; //0x0D1C float m_melee_damage_mult; //0x0D1C
float m_melee_defence_mult; //0x0D20 float m_melee_defence_mult; //0x0D20
char pad_0D24[8]; //0x0D24 char pad_0D24[8]; //0x0D24
float m_melee_weapon_defence_mult; //0x0D2C float m_melee_weapon_defence_mult; //0x0D2C
}; //Size: 0x0D30 }; //Size: 0x0D30
static_assert(sizeof(CPlayerInfo) == 0xD30); static_assert(sizeof(CPlayerInfo) == 0xD30);
#pragma pack(pop) #pragma pack(pop)

28
rage/atSingleton.hpp
View File

@ -3,20 +3,20 @@
namespace rage namespace rage
{ {
template <typename T> template <typename T>
struct atSingleton struct atSingleton
{ {
private: private:
T* m_basePtr{}; T* m_basePtr{};
public: public:
bool isValid() const bool isValid() const
{ {
return m_basePtr != nullptr; return m_basePtr != nullptr;
} }
T* getInstance() T* getInstance()
{ {
return m_basePtr; return m_basePtr;
} }
}; };
} }

28
rage/joaat.hpp
View File

@ -6,22 +6,22 @@
namespace rage namespace rage
{ {
using joaat_t = std::uint32_t; using joaat_t = std::uint32_t;
inline constexpr char joaat_to_lower(char c) inline constexpr char joaat_to_lower(char c)
{ {
return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c; return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c;
} }
inline joaat_t joaat(std::string_view str) inline joaat_t joaat(std::string_view str)
{ {
joaat_t hash = 0; joaat_t hash = 0;
for (auto c : str) { for (auto c : str) {
hash += joaat_to_lower(c); hash += joaat_to_lower(c);
hash += (hash << 10); hash += (hash << 10);
hash ^= (hash >> 6); hash ^= (hash >> 6);
} }
hash += (hash << 3); hash += (hash << 3);
hash ^= (hash >> 11); hash ^= (hash >> 11);
hash += (hash << 15); hash += (hash << 15);
return hash; return hash;
} }
}; };

22
rage/rlMetric.hpp
View File

@ -3,21 +3,21 @@
namespace rage namespace rage
{ {
class rlMetric class rlMetric
{ {
public: public:
virtual ~rlMetric() = default; virtual ~rlMetric() = default;
virtual int _0x08() { return 0; }; // returns a constant integer virtual int _0x08() { return 0; }; // returns a constant integer
virtual int _0x10() { return 0; }; // returns a constant integer virtual int _0x10() { return 0; }; // returns a constant integer
virtual const char* get_name() { return ""; }; virtual const char* get_name() { return ""; };
virtual bool serialize(void* serializer) { return false; }; virtual bool serialize(void* serializer) { return false; };
virtual int get_size() { return 0; }; virtual int get_size() { return 0; };
virtual joaat_t get_name_hash() { return 0; }; virtual joaat_t get_name_hash() { return 0; };
}; };
}; };

12
rage/rlSessionByGamerTaskResult.hpp
View File

@ -4,10 +4,10 @@
namespace rage namespace rage
{ {
class rlSessionByGamerTaskResult class rlSessionByGamerTaskResult
{ {
public: public:
rlGamerHandle m_gamer_handle{ 0 }; rlGamerHandle m_gamer_handle{ 0 };
rlSessionInfo m_session_info; rlSessionInfo m_session_info;
}; };
} }

25
rage/sysMemAllocator.hpp Normal file
View File

@ -0,0 +1,25 @@
#pragma once
#include <cstddef>
namespace rage
{
class sysMemAllocator
{
public:
virtual ~sysMemAllocator() = 0;
virtual void SetQuitOnFail(bool) = 0;
virtual void* Allocate(std::size_t size, std::size_t align, int subAllocator) = 0;
virtual void* TryAllocate(std::size_t size, std::size_t align, int subAllocator) = 0;
virtual void Free(void* pointer) = 0;
virtual void TryFree(void* pointer) = 0;
virtual void Resize(void* pointer, std::size_t size) = 0;
virtual sysMemAllocator* GetAllocator(int allocator) const = 0;
virtual sysMemAllocator* GetAllocator(int allocator) = 0;
virtual sysMemAllocator* GetPointerOwner(void* pointer) = 0;
virtual std::size_t GetSize(void* pointer) const = 0;
virtual std::size_t GetMemoryUsed(int memoryBucket) = 0;
virtual std::size_t GetMemoryAvailable() = 0;
};
}

0
script/GtaThread.hpp Normal file
View File

22
script/dataList.hpp Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include "../base/datBase.hpp"
namespace rage
{
template <typename T, typename Base = datBase>
class atDNode : public Base
{
public:
T m_data;
void *m_unk;
atDNode<T, Base> *m_next;
};
template <typename Node>
class atDList
{
public:
Node *m_head;
Node *m_tail;
};
}

60
script/scrNativeHandler.hpp Normal file
View File

@ -0,0 +1,60 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include <utility>
namespace rage
{
using scrNativeHash = std::int64_t;
using scrNativePair = std::pair<scrNativeHash, scrNativeHash>;
class scrNativeCallContext
{
public:
void reset()
{
m_arg_count = 0;
m_data_count = 0;
}
template <typename T>
void push_arg(T &&value)
{
static_assert(sizeof(T) <= sizeof(std::uint64_t));
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<std::uint64_t*>(m_args) + (m_arg_count++)) = std::forward<T>(value);
}
template <typename T>
T &get_arg(std::size_t index)
{
static_assert(sizeof(T) <= sizeof(std::uint64_t));
return *reinterpret_cast<T*>(reinterpret_cast<std::uint64_t*>(m_args) + index);
}
template <typename T>
void set_arg(std::size_t index, T &&value)
{
static_assert(sizeof(T) <= sizeof(std::uint64_t));
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<std::uint64_t*>(m_args) + index) = std::forward<T>(value);
}
template <typename T>
T *get_return_value()
{
return reinterpret_cast<T*>(m_return_value);
}
template <typename T>
void set_return_value(T &&value)
{
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(m_return_value) = std::forward<T>(value);
}
protected:
void *m_return_value;
std::uint32_t m_arg_count;
void *m_args;
std::int32_t m_data_count;
std::uint32_t m_data[48];
};
static_assert(sizeof(scrNativeCallContext) == 0xE0);
}

43
script/scrNativeRegistration.hpp Normal file
View File

@ -0,0 +1,43 @@
#pragma once
#include <cstdint>
namespace rage
{
class scrNativeRegistration
{
public:
uint64_t m_next_registration1;
uint64_t m_next_registration2;
void* m_handlers[7];
uint32_t m_num_entries1;
uint32_t m_num_entries2;
uint64_t m_hashes;
scrNativeRegistration* get_next_registration() {
std::uintptr_t result;
auto nextReg = uintptr_t(&m_next_registration1);
auto newReg = nextReg ^ m_next_registration2;
auto charTableOfRegs = (char*)&result - nextReg;
for (auto i = 0; i < 3; i++) {
*(std::uint32_t*)&charTableOfRegs[nextReg] = static_cast<std::uint32_t>(newReg) ^ *(std::uint32_t*)nextReg;
nextReg += 4;
}
return reinterpret_cast<scrNativeRegistration*>(result);
}
std::uint32_t get_num_entries() {
return static_cast<std::uint32_t>(((std::uintptr_t)&m_num_entries1) ^ m_num_entries1 ^ m_num_entries2);
}
std::uint64_t get_hash(std::uint32_t index) {
auto nativeAddress = 16 * index + std::uintptr_t(&m_next_registration1) + 0x54;
std::uint64_t result;
auto charTableOfRegs = (char*)&result - nativeAddress;
auto addressIndex = nativeAddress ^ *(std::uint32_t*)(nativeAddress + 8);
for (auto i = 0; i < 3; i++) {
*(std::uint32_t*)&charTableOfRegs[nativeAddress] = static_cast<std::uint32_t>(addressIndex ^ *(std::uint32_t*)(nativeAddress));
nativeAddress += 4;
}
return result;
}
};
}

16
script/scrNativeRegistrationTable.hpp Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <cstdint>
#include "scrNativeRegistration.hpp"
#pragma pack(push, 1)
namespace rage
{
class scrNativeRegistrationTable
{
scrNativeRegistration *m_entries[0xFF];
std::uint32_t m_unk;
bool m_initialized;
};
}
#pragma pack(pop)

100
script/scrProgram.hpp Normal file
View File

@ -0,0 +1,100 @@
#pragma once
#include <cstdint>
#include "../base/pgBase.hpp"
#pragma pack(push, 1)
namespace rage
{
class scrProgram : public pgBase
{
public:
std::uint8_t** m_code_blocks; // 0x10
std::uint32_t m_hash; // 0x18
std::uint32_t m_code_size; // 0x1C
std::uint32_t m_arg_count; // 0x20
std::uint32_t m_local_count; // 0x24
std::uint32_t m_global_count; // 0x28
std::uint32_t m_native_count; // 0x2C
void *m_local_data; // 0x30
std::int64_t **m_global_data; // 0x38
void **m_native_entrypoints; // 0x40
char m_padding6[0x10]; // 0x48
std::uint32_t m_name_hash; // 0x58
char m_padding7[0x04]; // 0x5C
const char* m_name; // 0x60
const char** m_strings_data; // 0x68
std::uint32_t m_strings_count; // 0x70
char m_padding8[0x0C]; // 0x74
bool is_valid() const
{
return m_code_size != 0;
}
std::uint32_t get_num_code_pages() const
{
return (m_code_size + 0x3FFF) >> 14;
}
std::uint32_t get_code_page_size(std::uint32_t page) const
{
auto num = get_num_code_pages();
if (page < num)
{
if (page == num - 1)
return m_code_size & 0x3FFF;
return 0x4000;
}
return 0;
}
std::uint32_t get_full_code_size() const
{
auto numPages = get_num_code_pages();
if (!numPages)
return 0;
if (numPages == 1)
--numPages;
return (numPages * 0x4000) + (m_code_size & 0x3FFF);
}
std::uint8_t* get_code_page(std::uint32_t page) const
{
return m_code_blocks[page];
}
std::uint8_t* get_code_address(std::uint32_t index) const
{
if (index < m_code_size)
return &m_code_blocks[index >> 14][index & 0x3FFF];
return nullptr;
}
const char* get_string(std::uint32_t index) const
{
if (index < m_strings_count)
return &m_strings_data[index >> 14][index & 0x3FFF];
return nullptr;
}
void** get_address_of_native_entrypoint(void* entrypoint)
{
for (std::uint32_t i = 0; i < m_native_count; ++i)
{
if (m_native_entrypoints[i] == entrypoint)
{
return m_native_entrypoints + i;
}
}
return nullptr;
}
};
static_assert(sizeof(scrProgram) == 0x80);
}
#pragma pack(pop)

41
script/scrProgramTable.hpp Normal file
View File

@ -0,0 +1,41 @@
#pragma once
#include <list>
#include "scrProgramTableEntry.hpp"
#pragma pack(push, 1)
namespace rage
{
class scrProgramTable
{
public:
scrProgramTableEntry* m_data; // 0x00
char m_padding[0x10]; // 0x08
std::uint32_t m_size; // 0x18
scrProgram* find_script(joaat_t hash)
{
for (std::uint32_t i = 0; i < m_size; ++i)
{
if (m_data[i].m_hash == hash)
{
return m_data[i].m_program;
}
}
return nullptr;
}
scrProgramTableEntry* begin()
{
return m_data;
}
scrProgramTableEntry* end()
{
return m_data + m_size;
}
};
static_assert(sizeof(scrProgramTable) == 0x1C);
}
#pragma pack(pop)

17
script/scrProgramTableEntry.hpp Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "scrProgram.hpp"
#include "../rage/joaat.hpp"
#pragma pack(push, 1)
namespace rage
{
class scrProgramTableEntry
{
public:
scrProgram* m_program; // 0x00
char m_Pad1[0x04]; // 0x08
joaat_t m_hash; // 0x0C
};
static_assert(sizeof(scrProgramTableEntry) == 0x10);
}
#pragma pack(pop)

31
script/scrThread.hpp Normal file
View File

@ -0,0 +1,31 @@
#pragma once
#include "scriptHandler.hpp"
#include "scriptHandlerNetComponent.hpp"
#include "scrThreadContext.hpp"
namespace rage
{
class scrThread
{
public:
virtual ~scrThread() = default; // 0 (0x00)
virtual void reset(std::uint32_t script_hash, void* args, std::uint32_t arg_count) = 0; // 1 (0x08)
virtual eThreadState run() = 0; // 2 (0x10)
virtual eThreadState tick(std::uint32_t ops_to_execute) = 0; // 3 (0x18)
virtual void kill() = 0;
public:
scrThreadContext m_context; // 0x08
void* m_stack; // 0xB0
char m_padding[0x4]; // 0xB8
uint32_t m_arg_size; // 0xBC
uint32_t m_arg_loc; // 0xC0
char m_padding2[0x4]; // 0xC4
const char* m_exit_message; // 0xC8
char m_pad[0x4];
char m_name[0x40]; // 0xD4
scriptHandler* m_handler; // 0x114
scriptHandlerNetComponent* m_net_component; // 0x11C
};
}

34
script/scrThreadContext.hpp Normal file
View File

@ -0,0 +1,34 @@
#pragma once
#include <cstdint>
#include "../rage/joaat.hpp"
namespace rage
{
enum class eThreadState : std::uint32_t
{
idle,
running,
killed,
unk_3,
unk_4,
};
class scrThreadContext
{
public:
std::uint32_t m_thread_id; // 0x00
joaat_t m_script_hash; // 0x04
eThreadState m_state; // 0x08
std::uint32_t m_instruction_pointer; // 0x0C
std::uint32_t m_frame_pointer; // 0x10
std::uint32_t m_stack_pointer; // 0x14
float m_timer_a; // 0x18
float m_timer_b; // 0x1C
float m_timer_c; // 0x20
char m_padding1[0x2C]; // 0x24
std::uint32_t m_stack_size; // 0x50
char m_padding2[0x54]; // 0x54
};
static_assert(sizeof(scrThreadContext) == 0xA8);
}

81
script/scriptHandler.hpp Normal file
View File

@ -0,0 +1,81 @@
#pragma once
#include <cstdint>
#include "dataList.hpp"
#include "scriptHandlerNetComponent.hpp"
#include "scriptId.hpp"
#include "scriptResource.hpp"
#include "scrThread.hpp"
#pragma pack(push, 1)
namespace rage
{
class scriptHandlerObject;
class scriptHandler
{
public:
class atDScriptObjectNode : public atDNode<scriptHandlerObject*>
{
};
public:
virtual ~scriptHandler() = default; // 0 (0x00)
virtual bool _0x08() = 0; // 1 (0x08)
virtual void _0x10() = 0; // 2 (0x10)
virtual void cleanup_objects() = 0; // 3 (0x18)
virtual scriptId *_0x20() = 0; // 4 (0x20)
virtual scriptId *get_id() = 0; // 5 (0x28)
// Returns whether the script handler belongs to a networked script.
virtual bool is_networked() = 0; // 6 (0x30)
// Initializes the network component for the script handler.
virtual void init_net_component() = 0; // 7 (0x38)
// Deletes the script handler's network component, if it exists.
virtual void reset_net_component() = 0; // 8 (0x40)
// Destroys the script handler.
virtual bool destroy() = 0; // 9 (0x48)
// Adds the object to the script handler's list of objects.
virtual void add_object(scriptHandlerObject*, bool is_network, bool is_network_and_scriptcheck) = 0; // 10 (0x50)
// Something related to reservations.
virtual void _0x58(void*) = 0; // 11 (0x58)
virtual void register_resource(scriptResource*, void*) = 0; // 12 (0x60)
virtual void _0x68() = 0; // 13 (0x68)
virtual void _0x70() = 0; // 14 (0x70)
virtual void _0x78() = 0; // 15 (0x78)
virtual void _0x80() = 0; // 16 (0x80)
virtual void _0x88() = 0; // 17 (0x88)
virtual void _0x90() = 0; // 18 (0x90)
virtual void _0x98() = 0; // 19 (0x98)
public:
void *m_0x08; // 0x08
void *m_0x10; // 0x10
scrThread *m_script_thread; // 0x18
atDList<atDScriptObjectNode> m_objects; // 0x20
scriptResource *m_resource_list_head; // 0x30
scriptResource *m_resource_list_tail; // 0x38
void *m_0x40; // 0x40
scriptHandlerNetComponent *m_net_component; // 0x48
std::uint32_t m_0x50; // 0x50
std::uint32_t m_0x54; // 0x54
std::uint32_t m_0x58; // 0x58
std::uint32_t m_0x60; // 0x5C
};
}
#pragma pack(pop)

61
script/scriptHandlerMgr.hpp Normal file
View File

@ -0,0 +1,61 @@
#pragma once
#include "../network/netPlayer.hpp"
#include "scriptHandler.hpp"
#include "scrThread.hpp"
#pragma pack(push, 1)
namespace rage
{
class netLoggingInterface;
class scriptHandlerMgr
{
public:
virtual ~scriptHandlerMgr() = default;
// Initializes some scripting-related pools.
virtual bool initialize() = 0; // 1 (0x08)
// Called every tick.
virtual void _0x10() = 0; // 2 (0x10)
// Frees some scripting-related pools.
virtual void shutdown() = 0; // 3 (0x18)
virtual void _0x20() = 0; // 4 (0x20)
virtual void _0x28() = 0; // 5 (0x28)
virtual void _0x30() = 0; // 6 (0x30)
// Generates a rage::scriptId from the thread and copies it over to a global structure.
virtual void _0x38(scrThread*) = 0; // 7 (0x38)
// Allocates and constructs a script handler.
virtual scriptHandler *create_script_handler() = 0; // 8 (0x40)
// Finds the script handler for a given script id.
virtual scriptHandler *get_script_handler(scriptId*) = 0; // 9 (0x48)
// Attaches a script thread.
virtual void attach_thread(scrThread*) = 0; // 10 (0x50)
// Detaches a script thread.
virtual void detach_thread(scrThread*) = 0; // 11 (0x58)
// Called when a player joins.
virtual void on_player_join(netPlayer*) = 0; // 12 (0x60)
// Called when a player leaves.
virtual void on_player_left(netPlayer*) = 0; // 13 (0x68)
virtual std::int32_t _0x70() = 0; // 14 (0x70)
virtual void *_0x78() = 0; // 15 (0x78)
public:
char m_padding1[0x28]; // 0x08
bool m_initialized; // 0x30
bool m_initialized2; // 0x31
char m_padding2[0x0E]; // 0x32
netLoggingInterface *m_logger; // 0x40
};
}
#pragma pack(pop)

16
script/scriptHandlerNetComponent.hpp Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#pragma pack(push, 1)
namespace rage
{
class scriptHandler;
class scriptHandlerNetComponent
{
public:
virtual ~scriptHandlerNetComponent() = default;
public:
scriptHandler *m_script_handler; // 0x08
};
}
#pragma pack(pop)

14
script/scriptId.hpp Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include "scriptIdBase.hpp"
#pragma pack(push, 1)
namespace rage
{
class scriptId : public scriptIdBase
{
public:
joaat_t m_hash; // 0x08
char m_name[0x20]; // 0x0C
};
}
#pragma pack(pop)

57
script/scriptIdBase.hpp Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <cstdint>
#include "../rage/joaat.hpp"
#pragma pack(push, 1)
namespace rage
{
class datBitBuffer;
class netLoggingInterface;
class scrThread;
class scriptIdBase
{
public:
virtual ~scriptIdBase() = default; // 0 (0x00)
// Assumes the script thread's identity.
virtual void assume_thread_identity(scrThread*) = 0; // 1 (0x08)
// Returns whether the hash of the script id is valid.
virtual bool is_valid() = 0; // 2 (0x10)
// Gets the hash of the script id.
virtual joaat_t *get_hash(joaat_t *out) = 0; // 3 (0x18)
// Gets an unknown value from the script id.
virtual std::uint32_t *get_hash2(std::uint32_t *out) = 0; // 4 (0x20)
// Gets the name of the script id.
virtual const char *get_name() = 0; // 5 (0x28)
// Serializes the script id from the buffer.
virtual void deserialize(datBitBuffer* buffer) = 0; // 6 (0x30)
// Serializes the script id to the buffer.
virtual void serialize(datBitBuffer* buffer) = 0; // 7 (0x38)
// Calculates some information with the position hash & instance id.
virtual std::uint32_t _0x40() = 0; // 8 (0x40)
// Calls _0x40 and returns it's value added to another value.
virtual std::uint32_t _0x48() = 0; // 9 (0x48)
// Logs some information about the script id.
virtual void log_information(netLoggingInterface* logger) = 0; // 10 (0x50)
// Copies the information of other to this object.
virtual void copy_data(scriptIdBase *other) = 0; // 11 (0x58)
// Returns whether the other script id is equal.
virtual bool operator==(scriptIdBase*) = 0; // 12 (0x60)
virtual bool _0x68(void*) = 0; // 13 (0x68)
};
}
#pragma pack(pop)

10
script/scriptResource.hpp Normal file
View File

@ -0,0 +1,10 @@
#pragma once
namespace rage
{
class scriptResource
{
public:
virtual ~scriptResource() = default;
};
}

17
script/tlsContext.hpp Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "../rage/sysMemAllocator.hpp"
#include "scrThread.hpp"
namespace rage
{
class tlsContext
{
public:
char m_padding1[0xC8]; // 0x00
sysMemAllocator* m_allocator; // 0xC8
char m_padding2[0x758]; // 0xD0
scrThread* m_script_thread; // 0x828
bool m_is_script_thread_active; // 0x830
};
static_assert(sizeof(tlsContext) == 0x838);
}

26
security/Obf32.hpp
View File

@ -4,22 +4,22 @@
#pragma pack(push, 1) #pragma pack(push, 1)
class Obf32 class Obf32
{ {
std::uint32_t a; std::uint32_t a;
std::uint32_t b; std::uint32_t b;
std::uint32_t c; std::uint32_t c;
std::uint32_t d; std::uint32_t d;
public: public:
inline void operator=(std::uint32_t val) inline void operator=(std::uint32_t val)
{ {
a = val & d; a = val & d;
b = val & ~d; b = val & ~d;
} }
inline operator std::uint32_t() inline operator std::uint32_t()
{ {
return (a & d) | (b & ~d); return (a & d) | (b & ~d);
} }
}; };
static_assert(sizeof(Obf32) == 0x10); static_assert(sizeof(Obf32) == 0x10);
#pragma pack(pop) #pragma pack(pop)

18
socialclub/FriendInfo.hpp
View File

@ -6,15 +6,15 @@
class FriendInfo class FriendInfo
{ {
public: public:
char m_name[20]; //0x0000 char m_name[20]; //0x0000
char pad_0014[36]; //0x0014 char pad_0014[36]; //0x0014
uint64_t m_rockstar_id; //0x0038 uint64_t m_rockstar_id; //0x0038
uint8_t unk; //0x0040 uint8_t unk; //0x0040
char pad_0041[3]; //0x0041 char pad_0041[3]; //0x0041
uint32_t m_friend_state; //0x0044 uint32_t m_friend_state; //0x0044
char pad_0048[304]; //0x0048 char pad_0048[304]; //0x0048
uint32_t m_is_joinable; //0x0178 uint32_t m_is_joinable; //0x0178
char pad_017C[4]; //0x017C char pad_017C[4]; //0x017C
}; //Size: 0x0180 }; //Size: 0x0180
static_assert(sizeof(FriendInfo) == 0x180); static_assert(sizeof(FriendInfo) == 0x180);
#pragma pack(pop) #pragma pack(pop)

14
socialclub/FriendRegistry.hpp
View File

@ -8,14 +8,14 @@
class FriendRegistry class FriendRegistry
{ {
public: public:
uint32_t m_friend_count; //0x0000 uint32_t m_friend_count; //0x0000
char pad_0004[8]; //0x0004 char pad_0004[8]; //0x0004
FriendInfo (*m_friends)[250]; //0x000C FriendInfo (*m_friends)[250]; //0x000C
inline FriendInfo* get(std::uint32_t idx) inline FriendInfo* get(std::uint32_t idx)
{ {
return &(*m_friends)[idx]; return &(*m_friends)[idx];
} }
}; //Size: 0x0014 }; //Size: 0x0014
static_assert(sizeof(FriendRegistry) == 0x14); static_assert(sizeof(FriendRegistry) == 0x14);
#pragma pack(pop) #pragma pack(pop)

142
vehicle/CHandlingData.hpp
View File

@ -7,76 +7,76 @@
class CHandlingData class CHandlingData
{ {
public: public:
uint64_t qword0; //0x0000 uint64_t qword0; //0x0000
uint32_t m_model_hash; //0x0008 uint32_t m_model_hash; //0x0008
float m_mass; //0x000C float m_mass; //0x000C
float m_initial_drag_coeff; //0x0010 float m_initial_drag_coeff; //0x0010
float m_downforce_multiplier; //0x0014 float m_downforce_multiplier; //0x0014
float m_popup_light_rotation; //0x0018 float m_popup_light_rotation; //0x0018
char pad_001C[4]; //0x001C char pad_001C[4]; //0x001C
rage::fvector3 m_centre_of_mass; //0x0020 rage::fvector3 m_centre_of_mass; //0x0020
char pad_002C[4]; //0x002C char pad_002C[4]; //0x002C
rage::fvector3 m_inertia_mult; //0x0030 rage::fvector3 m_inertia_mult; //0x0030
char pad_003C[4]; //0x003C char pad_003C[4]; //0x003C
float m_buoyancy; //0x0040 float m_buoyancy; //0x0040
float m_drive_bias_rear; //0x0044 float m_drive_bias_rear; //0x0044
float m_drive_bias_front; //0x0048 float m_drive_bias_front; //0x0048
float m_acceleration; //0x004C float m_acceleration; //0x004C
uint8_t m_initial_drive_gears; //0x0050 uint8_t m_initial_drive_gears; //0x0050
char pad_0051[3]; //0x0051 char pad_0051[3]; //0x0051
float m_drive_inertia; //0x0054 float m_drive_inertia; //0x0054
float m_upshift; //0x0058 float m_upshift; //0x0058
float m_downshift; //0x005C float m_downshift; //0x005C
float m_initial_drive_force; //0x0060 float m_initial_drive_force; //0x0060
float m_drive_max_flat_velocity; //0x0064 float m_drive_max_flat_velocity; //0x0064
float m_initial_drive_max_flat_vel; //0x0068 float m_initial_drive_max_flat_vel; //0x0068
float m_brake_force; //0x006C float m_brake_force; //0x006C
char pad_0070[4]; //0x0070 char pad_0070[4]; //0x0070
float m_brake_bias_front; //0x0074 float m_brake_bias_front; //0x0074
float m_brake_bias_rear; //0x0078 float m_brake_bias_rear; //0x0078
float m_handbrake_force; //0x007C float m_handbrake_force; //0x007C
float m_steering_lock; //0x0080 float m_steering_lock; //0x0080
float m_steering_lock_ratio; //0x0084 float m_steering_lock_ratio; //0x0084
float m_traction_curve_max; //0x0088 float m_traction_curve_max; //0x0088
float m_traction_curve_lateral; //0x008C float m_traction_curve_lateral; //0x008C
float m_traction_curve_min; //0x0090 float m_traction_curve_min; //0x0090
float m_traction_curve_ratio; //0x0094 float m_traction_curve_ratio; //0x0094
float m_curve_lateral; //0x0098 float m_curve_lateral; //0x0098
float m_curve_lateral_ratio; //0x009C float m_curve_lateral_ratio; //0x009C
float m_traction_spring_delta_max; //0x00A0 float m_traction_spring_delta_max; //0x00A0
float m_traction_spring_delta_max_ratio; //0x00A4 float m_traction_spring_delta_max_ratio; //0x00A4
float m_low_speed_traction_loss_mult; //0x00A8 float m_low_speed_traction_loss_mult; //0x00A8
float m_camber_stiffness; //0x00AC float m_camber_stiffness; //0x00AC
float m_traction_bias_front; //0x00B0 float m_traction_bias_front; //0x00B0
float m_traction_bias_rear; //0x00B4 float m_traction_bias_rear; //0x00B4
float m_traction_loss_mult; //0x00B8 float m_traction_loss_mult; //0x00B8
float m_suspension_force; //0x00BC float m_suspension_force; //0x00BC
float m_suspension_comp_damp; //0x00C0 float m_suspension_comp_damp; //0x00C0
float m_suspension_rebound_damp; //0x00C4 float m_suspension_rebound_damp; //0x00C4
float m_suspension_upper_limit; //0x00C8 float m_suspension_upper_limit; //0x00C8
float m_suspension_lower_limit; //0x00CC float m_suspension_lower_limit; //0x00CC
float m_suspension_raise; //0x00D0 float m_suspension_raise; //0x00D0
float m_suspension_bias_front; //0x00D4 float m_suspension_bias_front; //0x00D4
float m_suspension_bias_rear; //0x00D8 float m_suspension_bias_rear; //0x00D8
float m_anti_rollbar_force; //0x00DC float m_anti_rollbar_force; //0x00DC
float m_anti_rollbar_bias_front; //0x00E0 float m_anti_rollbar_bias_front; //0x00E0
float m_anti_rollbar_bias_rear; //0x00E4 float m_anti_rollbar_bias_rear; //0x00E4
float m_roll_centre_height_front; //0x00E8 float m_roll_centre_height_front; //0x00E8
float m_roll_centre_height_rear; //0x00EC float m_roll_centre_height_rear; //0x00EC
float m_collision_damage_mult; //0x00F0 float m_collision_damage_mult; //0x00F0
float m_weapon_damamge_mult; //0x00F4 float m_weapon_damamge_mult; //0x00F4
float m_deformation_mult; //0x00F8 float m_deformation_mult; //0x00F8
float m_engine_damage_mult; //0x00FC float m_engine_damage_mult; //0x00FC
float m_petrol_tank_volume; //0x0100 float m_petrol_tank_volume; //0x0100
float m_oil_volume; //0x0104 float m_oil_volume; //0x0104
char pad_0108[4]; //0x0108 char pad_0108[4]; //0x0108
rage::fvector3 m_seat_offset_dist; //0x010C rage::fvector3 m_seat_offset_dist; //0x010C
uint32_t m_monetary_value; //0x0118 uint32_t m_monetary_value; //0x0118
char pad_011C[8]; //0x011C char pad_011C[8]; //0x011C
uint32_t m_model_flags; //0x0124 uint32_t m_model_flags; //0x0124
uint32_t m_handling_flags; //0x0128 uint32_t m_handling_flags; //0x0128
uint32_t m_damage_flags; //0x012C uint32_t m_damage_flags; //0x012C
char pad_0130[12]; //0x0130 char pad_0130[12]; //0x0130
uint32_t m_ai_handling_hash; //0x013C uint32_t m_ai_handling_hash; //0x013C
}; //Size: 0x0140 }; //Size: 0x0140
static_assert(sizeof(CHandlingData) == 0x140); static_assert(sizeof(CHandlingData) == 0x140);

182
vehicle/CVehicleModelInfo.hpp
View File

@ -6,107 +6,107 @@
enum class eVehicleType : std::uint32_t enum class eVehicleType : std::uint32_t
{ {
VEHICLE_TYPE_NONE = 4294967295, VEHICLE_TYPE_NONE = 4294967295,
VEHICLE_TYPE_CAR = 0, VEHICLE_TYPE_CAR = 0,
VEHICLE_TYPE_PLANE = 1, VEHICLE_TYPE_PLANE = 1,
VEHICLE_TYPE_TRAILER = 2, VEHICLE_TYPE_TRAILER = 2,
VEHICLE_TYPE_QUADBIKE = 3, VEHICLE_TYPE_QUADBIKE = 3,
VEHICLE_TYPE_DRAFT = 4, VEHICLE_TYPE_DRAFT = 4,
VEHICLE_TYPE_SUBMARINECAR = 5, VEHICLE_TYPE_SUBMARINECAR = 5,
VEHICLE_TYPE_AMPHIBIOUS_AUTOMOBILE = 6, VEHICLE_TYPE_AMPHIBIOUS_AUTOMOBILE = 6,
VEHICLE_TYPE_AMPHIBIOUS_QUADBIKE = 7, VEHICLE_TYPE_AMPHIBIOUS_QUADBIKE = 7,
VEHICLE_TYPE_HELI = 8, VEHICLE_TYPE_HELI = 8,
VEHICLE_TYPE_BLIMP = 9, VEHICLE_TYPE_BLIMP = 9,
VEHICLE_TYPE_AUTOGYRO = 10, VEHICLE_TYPE_AUTOGYRO = 10,
VEHICLE_TYPE_BIKE = 11, VEHICLE_TYPE_BIKE = 11,
VEHICLE_TYPE_BICYCLE = 12, VEHICLE_TYPE_BICYCLE = 12,
VEHICLE_TYPE_BOAT = 13, VEHICLE_TYPE_BOAT = 13,
VEHICLE_TYPE_TRAIN = 14, VEHICLE_TYPE_TRAIN = 14,
VEHICLE_TYPE_SUBMARINE = 15, VEHICLE_TYPE_SUBMARINE = 15,
}; };
enum class eVehicleClass : std::uint8_t enum class eVehicleClass : std::uint8_t
{ {
VC_COMPACT = 0, VC_COMPACT = 0,
VC_SEDAN = 1, VC_SEDAN = 1,
VC_SUV = 2, VC_SUV = 2,
VC_COUPE = 3, VC_COUPE = 3,
VC_MUSCLE = 4, VC_MUSCLE = 4,
VC_SPORT_CLASSIC = 5, VC_SPORT_CLASSIC = 5,
VC_SPORT = 6, VC_SPORT = 6,
VC_SUPER = 7, VC_SUPER = 7,
VC_MOTORCYCLE = 8, VC_MOTORCYCLE = 8,
VC_OFF_ROAD = 9, VC_OFF_ROAD = 9,
VC_INDUSTRIAL = 10, VC_INDUSTRIAL = 10,
VC_UTILITY = 11, VC_UTILITY = 11,
VC_VAN = 12, VC_VAN = 12,
VC_CYCLE = 13, VC_CYCLE = 13,
VC_BOAT = 14, VC_BOAT = 14,
VC_HELICOPTER = 15, VC_HELICOPTER = 15,
VC_PLANE = 16, VC_PLANE = 16,
VC_SERVICE = 17, VC_SERVICE = 17,
VC_EMERGENCY = 18, VC_EMERGENCY = 18,
VC_MILITARY = 19, VC_MILITARY = 19,
VC_COMMERCIAL = 20, VC_COMMERCIAL = 20,
VC_RAIL = 21, VC_RAIL = 21,
VC_OPEN_WHEEL = 22, VC_OPEN_WHEEL = 22,
}; };
#pragma pack(push, 1) #pragma pack(push, 1)
class CVehicleModelInfo : public CBaseModelInfo class CVehicleModelInfo : public CBaseModelInfo
{ {
public: public:
char pad_00A4[72]; //0x00A4 char pad_00A4[72]; //0x00A4
uint8_t m_primary_color_combinations[25]; //0x00F8 uint8_t m_primary_color_combinations[25]; //0x00F8
uint8_t m_secondary_color_combinations[25]; //0x0111 uint8_t m_secondary_color_combinations[25]; //0x0111
uint8_t m_unk_color_combos1[25]; //0x012A uint8_t m_unk_color_combos1[25]; //0x012A
uint8_t m_unk_color_combos2[25]; //0x0143 uint8_t m_unk_color_combos2[25]; //0x0143
uint8_t m_interior_color_combinations[25]; //0x015C uint8_t m_interior_color_combinations[25]; //0x015C
uint8_t m_dashboard_color_combinations[25]; //0x0175 uint8_t m_dashboard_color_combinations[25]; //0x0175
char pad_018E[266]; //0x018E char pad_018E[266]; //0x018E
char m_name[12]; //0x0298 char m_name[12]; //0x0298
char m_manufacturer[12]; //0x02A4 char m_manufacturer[12]; //0x02A4
uint16_t* m_modkits; //0x02B0 uint16_t* m_modkits; //0x02B0
uint16_t m_modkits_count; //0x02B8 uint16_t m_modkits_count; //0x02B8
char pad_02BA[30]; //0x02BA char pad_02BA[30]; //0x02BA
uint8_t m_passenger_capacity; //0x02D8 uint8_t m_passenger_capacity; //0x02D8
char pad_02D9[103]; //0x02D9 char pad_02D9[103]; //0x02D9
eVehicleType m_vehicle_type; //0x0340 eVehicleType m_vehicle_type; //0x0340
uint32_t m_unk_vehicle_type; //0x0344 uint32_t m_unk_vehicle_type; //0x0344
uint32_t m_diffuse_tint; //0x0348 uint32_t m_diffuse_tint; //0x0348
char pad_034C[20]; //0x034C char pad_034C[20]; //0x034C
rage::fvector3 m_first_person_driveby_ik_offset; //0x0360 rage::fvector3 m_first_person_driveby_ik_offset; //0x0360
char pad_036C[4]; //0x036C char pad_036C[4]; //0x036C
rage::fvector3 m_first_person_driveby_unarmed_ik_offset; //0x0370 rage::fvector3 m_first_person_driveby_unarmed_ik_offset; //0x0370
char pad_037C[20]; //0x037C char pad_037C[20]; //0x037C
rage::fvector3 m_first_person_driveby_right_passenger_ik_offset; //0x0390 rage::fvector3 m_first_person_driveby_right_passenger_ik_offset; //0x0390
char pad_039C[36]; //0x039C char pad_039C[36]; //0x039C
rage::fvector3 m_first_person_driveby_right_passenger_unarmed_ik_offset; //0x03C0 rage::fvector3 m_first_person_driveby_right_passenger_unarmed_ik_offset; //0x03C0
char pad_03CC[4]; //0x03CC char pad_03CC[4]; //0x03CC
rage::fvector3 m_first_person_projectile_driveby_ik_offset; //0x03D0 rage::fvector3 m_first_person_projectile_driveby_ik_offset; //0x03D0
char pad_03DC[4]; //0x03DC char pad_03DC[4]; //0x03DC
rage::fvector3 m_first_person_projectile_driveby_passenger_ik_offset; //0x03E0 rage::fvector3 m_first_person_projectile_driveby_passenger_ik_offset; //0x03E0
char pad_03EC[52]; //0x03EC char pad_03EC[52]; //0x03EC
rage::fvector3 m_first_person_mobile_phone_offset; //0x0420 rage::fvector3 m_first_person_mobile_phone_offset; //0x0420
char pad_042C[4]; //0x042C char pad_042C[4]; //0x042C
rage::fvector3 m_first_person_passenger_mobile_phone_offset; //0x0430 rage::fvector3 m_first_person_passenger_mobile_phone_offset; //0x0430
char pad_043C[20]; //0x043C char pad_043C[20]; //0x043C
rage::fvector3 m_pov_camera_offset; //0x0450 rage::fvector3 m_pov_camera_offset; //0x0450
char pad_045C[36]; //0x045C char pad_045C[36]; //0x045C
float m_pov_camera_vertical_adjustement_for_rollcage; //0x0480 float m_pov_camera_vertical_adjustement_for_rollcage; //0x0480
char pad_0484[8]; //0x0484 char pad_0484[8]; //0x0484
float m_wheel_scale; //0x048C float m_wheel_scale; //0x048C
float m_wheel_scale_rear; //0x0490 float m_wheel_scale_rear; //0x0490
float m_default_health; //0x0494 float m_default_health; //0x0494
char pad_0498[4]; //0x0498 char pad_0498[4]; //0x0498
float m_steer_wheel_multiplier; //0x049C float m_steer_wheel_multiplier; //0x049C
char pad_04A0[168]; //0x04A0 char pad_04A0[168]; //0x04A0
eVehicleClass m_vehicle_class; //0x0548 eVehicleClass m_vehicle_class; //0x0548
char pad_0549[11]; char pad_0549[11];
float m_min_seat_height; //0x0554 float m_min_seat_height; //0x0554
char pad_0558[40]; //0x0558 char pad_0558[40]; //0x0558
uint32_t m_is_jetski; //0x0580 uint32_t m_is_jetski; //0x0580
char pad_0584[28]; //0x0584 char pad_0584[28]; //0x0584
}; //Size: 0x05A0 }; //Size: 0x05A0
static_assert(sizeof(CVehicleModelInfo) == 0x5A0); static_assert(sizeof(CVehicleModelInfo) == 0x5A0);
#pragma pack(pop) #pragma pack(pop)

10
weapon/CItemInfo.hpp
View File

@ -5,10 +5,10 @@
class CItemInfo class CItemInfo
{ {
public: public:
char pad_0000[16]; //0x0000 char pad_0000[16]; //0x0000
uint32_t m_name; //0x0010 uint32_t m_name; //0x0010
uint32_t m_model; //0x0014 uint32_t m_model; //0x0014
uint32_t m_audio; //0x0018 uint32_t m_audio; //0x0018
uint32_t m_slot; //0x001C uint32_t m_slot; //0x001C
}; //Size: 0x0020 }; //Size: 0x0020
static_assert(sizeof(CItemInfo) == 0x20); static_assert(sizeof(CItemInfo) == 0x20);