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

FUCK TAKE2 & FUCK ROCKSTAR

Browse source
This commit is contained in:
Andreas Maerten 2024-09-25 01:24:45 +00:00
parent aad56b00db
commit 0729ab5ae1
245 changed files with 11493 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
.devcontainer/Dockerfile Normal file
View file

@ -0,0 +1,7 @@
FROM ubuntu:devel
RUN apt clean && apt update && apt install gcc g++ cmake make -y
WORKDIR /app
COPY . .

20
.devcontainer/devcontainer.json Normal file
View file

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

20
.github/workflows/build.yml vendored Normal file
View file

@ -0,0 +1,20 @@
name: Build
on: [push, pull_request]
jobs:
build:
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, windows-latest]
steps:
- uses: actions/checkout@v3
- name: Configure
run: cmake -S ${{github.workspace}} -B ${{github.workspace}}/build
- name: Build 64bit release DLL
run: cmake --build ${{github.workspace}}/build --config Release --target GTAV-Classes --

12
.gitignore vendored Normal file
View file

@ -0,0 +1,12 @@
.vscode
.vs
build/
*.suo
*.db
*.db-shm
*.db-wal
*.opendb
*.sln
*.vcxproj
*.user
*.filters

32
CMakeLists.txt Normal file
View file

@ -0,0 +1,32 @@
cmake_minimum_required(VERSION 3.11)
project(GTAV-Classes)
include(CheckIncludeFileCXX)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_REQUIRED_QUIET ON)
set(OK TRUE)
file(GLOB_RECURSE HEADERS "**.hpp")
file(GLOB_RECURSE SRC_MAIN "classes.cpp")
source_group(FILES ${SRC_MAIN})
add_library(GTAV-Classes MODULE "${SRC_MAIN}")
add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
message(STATUS "")
target_include_directories(GTAV-Classes PRIVATE
"${SRC_DIR}"
)
if(NOT OK)
file(READ "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/CMakeError.log" LOG)
message(STATUS ${LOG})
endif()

21
LICENSE Normal file
View file

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2021-2022 Yimura
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

92
README.md
View file

@ -1,93 +1,13 @@
# GTA V Classes # GTA V Classes
This repository contains a few classes that I've reverse engineered.
They are in no way complete but contain some basics to get you started...
## Getting started # Usage
To make it easy for you to get started with GitLab, here's a list of recommended next steps. To modify the Reclass.NET file you have to build Reclass from source, the prebuild binaries will give you an error trying to open the project.
Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)! ## Disclaimer
## Add your files This code is provided purely for educational purposes, if there are objections please open an issue stating your reasoning.
- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
```
cd existing_repo
git remote add origin https://gitlab.com/YimMenu/GTAV-Classes.git
git branch -M main
git push -uf origin main
```
## Integrate with your tools
- [ ] [Set up project integrations](https://gitlab.com/YimMenu/GTAV-Classes/-/settings/integrations)
## Collaborate with your team
- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
## Test and Deploy
Use the built-in continuous integration in GitLab.
- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
***
# Editing this README
When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
## Suggestions for a good README
Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
## Name
Choose a self-explaining name for your project.
## Description
Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
## Badges
On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
## Visuals
Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
## Installation
Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
## Usage
Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
## Support
Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
## Roadmap
If you have ideas for releases in the future, it is a good idea to list them in the README.
## Contributing
State if you are open to contributions and what your requirements are for accepting them.
For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
## Authors and acknowledgment
Show your appreciation to those who have contributed to the project.
## License
For open source projects, say how it is licensed.
## Project status
If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.

44
base/CBaseModelInfo.hpp Normal file
View file

@ -0,0 +1,44 @@
#pragma once
#include <cstdint>
#include "fwArchetype.hpp"
enum class eModelType : std::uint8_t
{
Invalid,
Object,
MLO,
Time,
Weapon,
Vehicle,
Ped,
Destructable,
WorldObject = 33,
Sprinkler = 35,
Unk65 = 65,
EmissiveLOD = 67,
Plant = 129,
LOD = 131,
Unk132 = 132,
Unk133 = 133,
OnlineOnlyPed = 134,
Building = 161,
Unk193 = 193
};
#pragma pack(push, 8)
class CBaseModelInfo : public rage::fwArchetype
{
public:
char pad_0070[8]; //0x0070
uint64_t unk_0078; //0x0078
uint64_t unk_0080; //0x0080
char pad_0088[8]; //0x0088
uint64_t unk_0090; //0x0090
char pad_0098[5]; //0x0098
eModelType m_model_type; //0x009D
char pad_009E[6]; //0x009E
uint64_t unk_00A8; //0x00A8
}; //Size: 0x00B0
static_assert(sizeof(CBaseModelInfo) == 0xB0);
#pragma pack(pop)

28
base/CNavigation.hpp Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include "../rage/vector.hpp"
#include "phArchetype.hpp"
#pragma pack(push, 1)
class CNavigation
{
public:
char pad_0000[16]; //0x0000
class rage::phArchetypeDamp* m_damp; //0x0010
char pad_0018[8]; //0x0018
rage::fmatrix44 m_transformation_matrix;
rage::fvector3* get_position()
{
return reinterpret_cast<rage::fvector3*>(&m_transformation_matrix.rows[3]);
}
void model_to_world(const rage::fvector3& model_coords, rage::fvector3& world_coords)
{
world_coords.x = model_coords.x * m_transformation_matrix.data[0][0] + model_coords.y * m_transformation_matrix.data[1][0] + model_coords.z * m_transformation_matrix.data[2][0] + m_transformation_matrix.data[3][0];
world_coords.y = model_coords.x * m_transformation_matrix.data[0][1] + model_coords.y * m_transformation_matrix.data[1][1] + model_coords.z * m_transformation_matrix.data[2][1] + m_transformation_matrix.data[3][1];
world_coords.z = model_coords.x * m_transformation_matrix.data[0][2] + model_coords.y * m_transformation_matrix.data[1][2] + model_coords.z * m_transformation_matrix.data[2][2] + m_transformation_matrix.data[3][2];
}
}; //Size: 0x0060
static_assert(sizeof(CNavigation) == 0x60);
#pragma pack(pop)

26
base/CObject.hpp Normal file
View file

@ -0,0 +1,26 @@
#pragma once
#include "../entities/CPhysical.hpp"
class CWeapon;
#pragma pack(push, 2)
class CObject : public rage::CPhysical
{
char gap30C[60];
uint64_t qword348;
char gap350[8];
uint64_t qword358;
uint16_t word360;
uint32_t dword362;
uint16_t word366;
char gap368[120];
uint64_t qword3E0;
char gap3E8[8];
uint64_t qword3F0;
uint64_t qword3F8;
uint64_t qword400;
uint64_t qword408;
uint64_t qword410;
};
static_assert(sizeof(CObject) == 0x3F8);
#pragma pack(pop)

28
base/HashTable.hpp Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include <cstdint>
#pragma pack(push, 1)
class HashNode
{
public:
int32_t m_hash; //0x0000
uint16_t m_idx; //0x0004
char pad_0006[2]; //0x0006
HashNode* m_next; //0x0008
}; //Size: 0x0010
static_assert(sizeof(HashNode) == 0x10);
template<typename T>
class HashTable
{
public:
T* m_data; //0x0000
uint16_t m_size; //0x0008
char pad_000A[14]; //0x000A
uint64_t m_item_size; //0x0018
char pad_0020[64]; //0x0020
HashNode** m_lookup_table; //0x0060
uint16_t m_lookup_key; //0x0068
}; //Size: 0x006A
// 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)

11
base/atRTTI.hpp Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#define DEFINE_RAGE_RTTI(className) private:\
virtual void* _0x00() = 0;\
virtual void* _0x08() = 0;\
virtual uint32_t _0x10() = 0;\
virtual className* _0x18(void*) = 0;\
virtual bool _0x20(void*) = 0;\
virtual bool _0x28(void**) = 0;\
virtual void destructor() = 0;\
public:

13
base/datBase.hpp Normal file
View file

@ -0,0 +1,13 @@
#pragma once
namespace rage
{
class datBase
{
public:
virtual ~datBase() = default;
}; //Size: 0x0008
static_assert(sizeof(datBase) == 0x8);
}

36
base/fwArchetype.hpp Normal file
View file

@ -0,0 +1,36 @@
#pragma once
#include <cstdint>
#include "../rage/vector.hpp"
#include "datBase.hpp"
#include "fwArchetypeDef.hpp"
namespace rage {
#pragma pack(push,8)
class fwArchetype : public datBase
{
public:
virtual void Initialize() = 0;
virtual void InitializeFromArchetypeDef(uint32_t mapTypeStoreIdx, fwArchetypeDef* archetypeDef, bool) = 0;
virtual class fwEntity* CreateEntity() = 0;
char pad_0008[16]; //0x0008
int32_t m_hash; //0x0018
char unk_001C[4]; //0x001C
fvector3 m_bounding_sphere_center; //0x0020
float m_bounding_sphere_radius; //0x002C
fvector3 m_aabbMin; //0x0030
float m_lod_dist; //0x003C
fvector3 m_aabbMax; //0x0040
float m_hd_texture_dist; //0x004C
uint32_t m_flags; //0x0050
char unk_0054[4]; //0x0054
uint64_t unk_0058; //0x0058
char unk_0060[4]; //0x0060
uint32_t m_asset_index; //0x0064
uint16_t unk_0068; //0x0068
uint16_t unk_006A; //0x006A
};
static_assert(sizeof(fwArchetype) == 0x70);
#pragma pack(pop)
}

43
base/fwArchetypeDef.hpp Normal file
View file

@ -0,0 +1,43 @@
#pragma once
#include <cstdint>
#include "../rage/vector.hpp"
namespace rage {
#pragma pack(push,8)
class fwArchetypeDef
{
public:
virtual ~fwArchetypeDef() = 0;
virtual int GetTypeIdentifier() = 0;
float m_lod_dist; //0x0008
uint32_t m_flags; //0x000C
uint32_t m_special_attribute; //0x0010
char pad_0014[12]; //0x0014
fvector4 m_bounding_box_min; //0x0020
fvector4 m_bounding_box_max; //0x0030
fvector4 m_bounding_sphere_center; //0x0040
float m_bounding_sphere_radius; //0x0050
float m_hd_texture_dist; //0x0054
uint32_t m_name_hash; //0x0058
uint32_t m_texture_dictionary; //0x005C
uint32_t m_clip_dictionary_hash; //0x0060
uint32_t m_drawable_dictionary_hash; //0x0064
uint32_t m_physics_dictionary_hash; //0x0068
enum eAssetType : uint32_t
{
ASSET_TYPE_UNINITIALIZED = 0,
ASSET_TYPE_FRAGMENT = 1,
ASSET_TYPE_DRAWABLE = 2,
ASSET_TYPE_DRAWABLEDICTIONARY = 3,
ASSET_TYPE_ASSETLESS = 4,
} m_asset_type; //0x006C
uint32_t m_asset_name_hash; //0x0070
uint64_t *m_extensions; //0x0078
uint16_t unk_0080; //0x0080
char pad_0082[12]; //0x0082
}; //Size: 0x0090
static_assert(sizeof(fwArchetypeDef) == 0x90);
#pragma pack(pop)
}

22
base/fwExtensibleBase.hpp Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include <typeinfo>
#include "fwRefAwareBase.hpp"
#include "fwExtensionContainer.hpp"
#include "../rage/joaat.hpp"
namespace rage
{
class fwExtensibleBase : public fwRefAwareBase
{
public:
// virtual bool is_of_type(std::uint32_t hash) = 0;
// virtual uint32_t const &get_type() = 0;
fwExtensionContainer* m_extension_container; // 0x0010
void *m_extensible_unk; // 0x0018
}; //Size: 0x0020
static_assert(sizeof(fwExtensibleBase) == 0x20);
}

18
base/fwExtension.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include <cstdint>
namespace rage
{
class fwExtension
{
public:
virtual ~fwExtension() = default;
virtual void unk_0x08() = 0;
virtual void unk_0x10() = 0;
virtual uint32_t get_id() = 0;
}; //Size: 0x0008
static_assert(sizeof(fwExtension) == 0x8);
}

16
base/fwExtensionContainer.hpp Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include "fwExtension.hpp"
namespace rage
{
class fwExtensionContainer
{
public:
fwExtension *m_entry; //0x0000
fwExtensionContainer* m_next; //0x0008
}; //Size: 0x0010
static_assert(sizeof(fwExtensionContainer) == 0x10);
}

14
base/fwRefAwareBase.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include "datBase.hpp"
#include "fwRefAwareBaseImpl.hpp"
namespace rage
{
class fwRefAwareBase : public fwRefAwareBaseImpl<datBase>
{
};
static_assert(sizeof(fwRefAwareBase) == 0x10);
}

13
base/fwRefAwareBaseImpl.hpp Normal file
View file

@ -0,0 +1,13 @@
#pragma once
namespace rage
{
template <typename T>
class fwRefAwareBaseImpl : public T
{
private:
void *m_ref; // 0x08
};
}

36
base/pgBase.hpp Normal file
View file

@ -0,0 +1,36 @@
#pragma once
namespace rage
{
class pgBase
{
public:
virtual ~pgBase() = default;
virtual int return_zero() = 0;
virtual void error() = 0;
void *unk_0000; // 0x0000
}; //Size: 0x0008
static_assert(sizeof(pgBase) == 0x10);
class pgBaseMetaDataType
{
public:
virtual ~pgBaseMetaDataType() = default;
virtual void Lookup(uint32_t hash) = 0;
}; //Size: 0x0008
class pgBaseMetaDataDebugNameType : public pgBaseMetaDataType
{
public:
virtual ~pgBaseMetaDataDebugNameType() = default;
char pad_0000[64];
}; //Size: 0x0072
class pgBaseRefCounted : public pgBase
{
public:
virtual ~pgBaseRefCounted() = default;
}; //Size: 0x0008
}

87
base/pgDictionary.hpp Normal file
View file

@ -0,0 +1,87 @@
#pragma once
namespace rage
{
class pgDictionaryBase
{
public:
virtual ~pgDictionaryBase() = default;
}; //Size: 0x0008
template<typename T>
class pgDictionary : public pgDictionaryBase
{
private:
struct Node {
T key;
Node* next;
Node(const T& k, Node* n = nullptr)
: key(k), next(n) {}
};
Node* head;
public:
pgDictionary() : head(nullptr) {}
~pgDictionary() {
clearDict();
}
void addDict(const T& key) {
Node* newNode = new Node(key, head);
head = newNode;
}
bool containsDict(const T& key) const {
Node* current = head;
while (current != nullptr) {
if (current->key == key) {
return true;
}
current = current->next;
}
return false;
}
void removeDict(const T& key) {
if (head == nullptr) {
return;
}
if (head->key == key) {
Node* temp = head;
head = head->next;
delete temp;
return;
}
Node* current = head;
while (current->next != nullptr) {
if (current->next->key == key) {
Node* temp = current->next;
current->next = current->next->next;
delete temp;
return;
}
current = current->next;
}
}
size_t sizeDict() const {
size_t count = 0;
Node* current = head;
while (current != nullptr) {
count++;
current = current->next;
}
return count;
}
void clearDict() {
while (head != nullptr) {
Node* temp = head;
head = head->next;
delete temp;
}
}
};
}

31
base/phArchetype.hpp Normal file
View file

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

41
base/phBound.hpp Normal file
View file

@ -0,0 +1,41 @@
#pragma once
#include <cstdint>
#include "pgBase.hpp"
#include "../rage/vector.hpp"
namespace rage {
class phBoundBase : public pgBase
{
};
enum class eBoundType : uint8_t
{
SPHERE,
CAPSULE,
BOX = 3,
GEOMETRY,
BVH = 8,
COMPOSITE = 10,
DISC = 12,
CYLINDER,
PLANE = 15
};
#pragma pack(push,4)
class phBound : public phBoundBase {
public:
eBoundType m_type; //0x0010
uint8_t m_flags; //0x0011
uint16_t m_part_index; //0x0012
float m_radius_around_centroid; //0x0014
char pad_0018[8]; //0x0018
fvector4 m_bounding_box_max_xyz_margin_w; //0x0020
fvector4 m_bounding_box_min_xyz_ref_count_w; //0x0030
fvector4 m_centroid_offset_xyz_material_id_0_w; //0x0040
fvector4 m_cg_offset_xyz_material_id_1_w; //0x0050
fvector4 m_volume_distribution; //0x0060
}; //Size: 0x0070
static_assert(sizeof(phBound) == 0x70);
#pragma pack(pop)
}

17
base/phBoundCapsule.hpp Normal file
View file

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

26
base/phBoundComposite.hpp Normal file
View file

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

17
camera/CCameraAngles.hpp Normal file
View file

@ -0,0 +1,17 @@
#pragma once
#include "../player/CPlayerAngles.hpp"
class CCameraAngles
{
private:
char pad_0000[704]; //0x0000
public:
CPlayerAngles* m_vehicle; //0x02C0
CPlayerAngles* m_vehicle_two; //0x02C8
private:
char pad_02D0[240]; //0x02D0
public:
CPlayerAngles* m_player_first_person; //0x03C0
}; //Size: 0x03C8
static_assert(sizeof(CCameraAngles) == 0x3C8);

10
camera/CCameraManagerAngles.hpp Normal file
View file

@ -0,0 +1,10 @@
#pragma once
#include "CCameraAngles.hpp"
class CCameraManagerAngles
{
public:
CCameraAngles* m_angles; //0x0000
}; //Size: 0x0008
static_assert(sizeof(CCameraManagerAngles) == 0x8);

11
camera/CGameCameraAngles.hpp Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#include "CCameraManagerAngles.hpp"
class CGameCameraAngles
{
public:
CCameraManagerAngles* m_angles; //0x0000
char pad_0008[56]; //0x0008
}; //Size: 0x0040
static_assert(sizeof(CGameCameraAngles) == 0x40);

219
classes.cpp Normal file
View file

@ -0,0 +1,219 @@
#include "base/atRTTI.hpp"
#include "base/CBaseModelInfo.hpp"
#include "base/CNavigation.hpp"
#include "base/CObject.hpp"
#include "base/datBase.hpp"
#include "base/fwArchetype.hpp"
#include "base/fwArchetypeDef.hpp"
#include "base/fwExtensibleBase.hpp"
#include "base/fwExtension.hpp"
#include "base/fwExtensionContainer.hpp"
#include "base/fwRefAwareBase.hpp"
#include "base/fwRefAwareBaseImpl.hpp"
#include "base/HashTable.hpp"
#include "base/pgBase.hpp"
#include "base/phArchetype.hpp"
#include "base/phBound.hpp"
#include "base/phBoundCapsule.hpp"
#include "base/phBoundComposite.hpp"
#include "base/pgDictionary.hpp"
#include "camera/CCameraAngles.hpp"
#include "camera/CCameraManagerAngles.hpp"
#include "camera/CGameCameraAngles.hpp"
#include "draw_handlers/CEntityDrawHandler.hpp"
#include "draw_handlers/CObjectDrawHandler.hpp"
#include "draw_handlers/CPedDrawHandler.hpp"
#include "draw_handlers/CVehicleDrawHandler.hpp"
#include "draw_handlers/fwDrawData.hpp"
#include "entities/CAttackers.hpp"
#include "entities/CDynamicEntity.hpp"
#include "entities/CEntity.hpp"
#include "entities/CPhysical.hpp"
#include "entities/fwEntity.hpp"
#include "enums/eExplosionTag.hpp"
#include "enums/eHandlingType.hpp"
#include "game_files/CGameConfig.hpp"
#include "misc/CTunables.hpp"
#include "misc/vfx/TimecycleKeyframeData.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "netsync/CProjectSyncTree.hpp"
#include "netsync/netSyncDataNode.hpp"
#include "netsync/netSyncNodeBase.hpp"
#include "netsync/netSyncParentNode.hpp"
#include "netsync/netSyncTree.hpp"
#include "netsync/NodeCommonDataOperations.hpp"
#include "netsync/nodes/automobile/CAutomobileCreationNode.hpp"
#include "netsync/nodes/CPedComponents.hpp"
#include "netsync/nodes/door/CDoorCreationDataNode.hpp"
#include "netsync/nodes/door/CDoorMovementDataNode.hpp"
#include "netsync/nodes/door/CDoorScriptGameStateDataNode.hpp"
#include "netsync/nodes/door/CDoorScriptInfoDataNode.hpp"
#include "netsync/nodes/dynamic_entity/CDynamicEntityGameStateDataNode.hpp"
#include "netsync/nodes/entity/CEntityOrientationDataNode.hpp"
#include "netsync/nodes/entity/CEntityScriptGameStateDataNode.hpp"
#include "netsync/nodes/entity/CEntityScriptInfoDataNode.hpp"
#include "netsync/nodes/heli/CHeliHealthDataNode.hpp"
#include "netsync/nodes/heli/CHeliControlDataNode.hpp"
#include "netsync/nodes/object/CObjectCreationDataNode.hpp"
#include "netsync/nodes/ped/CPedAIDataNode.hpp"
#include "netsync/nodes/ped/CPedAppearanceDataNode.hpp"
#include "netsync/nodes/ped/CPedAttachDataNode.hpp"
#include "netsync/nodes/ped/CPedComponentReservationDataNode.hpp"
#include "netsync/nodes/ped/CPedCreationDataNode.hpp"
#include "netsync/nodes/ped/CPedGameStateDataNode.hpp"
#include "netsync/nodes/ped/CPedHealthDataNode.hpp"
#include "netsync/nodes/ped/CPedInventoryDataNode.hpp"
#include "netsync/nodes/ped/CPedMovementDataNode.hpp"
#include "netsync/nodes/ped/CPedMovementGroupDataNode.hpp"
#include "netsync/nodes/ped/CPedOrientationDataNode.hpp"
#include "netsync/nodes/ped/CPedScriptCreationDataNode.hpp"
#include "netsync/nodes/ped/CPedTaskSequenceDataNode.hpp"
#include "netsync/nodes/ped/CPedTaskSpecificDataNode.hpp"
#include "netsync/nodes/ped/CPedTaskTreeDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalAngVelocityDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalAttachDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalGameStateDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalHealthDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalMigrationDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalScriptGameStateDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalScriptMigrationDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalVelocityDataNode.hpp"
#include "netsync/nodes/pickup/CPickupCreationDataNode.hpp"
#include "netsync/nodes/pickup_placement/CPickupPlacementCreationDataNode.hpp"
#include "netsync/nodes/player/CPlayerAmbientModelStreamingNode.hpp"
#include "netsync/nodes/player/CPlayerAppearanceDataNode.hpp"
#include "netsync/nodes/player/CPlayerCameraDataNode.hpp"
#include "netsync/nodes/player/CPlayerCreationDataNode.hpp"
#include "netsync/nodes/player/CPlayerGamerDataNode.hpp"
#include "netsync/nodes/player/CPlayerGameStateDataNode.hpp"
#include "netsync/nodes/player/CPlayerPedGroupDataNode.hpp"
#include "netsync/nodes/player/CPlayerSectorPosNode.hpp"
#include "netsync/nodes/player/CPlayerWantedAndLOSDataNode.hpp"
#include "netsync/nodes/proximity_migrateable/CGlobalFlagsDataNode.hpp"
#include "netsync/nodes/proximity_migrateable/CMigrationDataNode.hpp"
#include "netsync/nodes/proximity_migrateable/CSectorDataNode.hpp"
#include "netsync/nodes/proximity_migrateable/CSectorPositionDataNode.hpp"
#include "netsync/nodes/task/ClonedTakeOffPedVariationInfo.hpp"
#include "netsync/nodes/train/CTrainGameStateDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleCreationDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleControlDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleTaskDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleGadgetDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleProximityMigrationDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleComponentReservationDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleDamageStatusDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleSteeringDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleHealthDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleGameStateDataNode.hpp"
#include "netsync/trees/CDynamicEntitySyncTreeBase.hpp"
#include "netsync/trees/CEntitySyncTreeBase.hpp"
#include "netsync/trees/CPhysicalSyncTreeBase.hpp"
#include "netsync/trees/CProximityMigrateableSyncTreeBase.hpp"
#include "network/CCommunications.hpp"
#include "network/ChatData.hpp"
#include "network/CJoinRequestContext.hpp"
#include "network/ClanData.hpp"
#include "network/CMsgJoinResponse.hpp"
#include "network/CMsgTextMessage.hpp"
#include "network/CNetComplaintMgr.hpp"
#include "network/CNetGamePlayer.hpp"
#include "network/CNetGamePlayerDataMsg.hpp"
#include "network/CNetworkPlayerMgr.hpp"
#include "network/netObject.hpp"
#include "network/netPeerAddress.hpp"
#include "network/netPlayer.hpp"
#include "network/netPlayerMgrBase.hpp"
#include "network/netTime.hpp"
#include "network/Network.hpp"
#include "network/RemoteGamerInfoMsg.hpp"
#include "network/snConnectToPeerTask.hpp"
#include "network/snSession.hpp"
#include "network/netConnection.hpp"
#include "ped/CPed.hpp"
#include "ped/CPedBoneInfo.hpp"
#include "ped/CPedFactory.hpp"
#include "ped/CPedIntelligence.hpp"
#include "ped/CPedInventory.hpp"
#include "ped/CPedModelInfo.hpp"
#include "ped/CPedWeaponManager.hpp"
#include "player/CNonPhysicalPlayerData.hpp"
#include "player/CPlayerAngles.hpp"
#include "player/CPlayerInfo.hpp"
#include "rage/atArray.hpp"
#include "rage/atReferenceCounter.hpp"
#include "rage/atSingleton.hpp"
#include "rage/joaat.hpp"
#include "rage/rlGamerHandle.hpp"
#include "rage/rlGamerInfo.hpp"
#include "rage/rlGamerInfoBase.hpp"
#include "rage/rlMetric.hpp"
#include "rage/rlQueryPresenceAttributesContext.hpp"
#include "rage/rlScHandle.hpp"
#include "rage/rlSessionByGamerTaskResult.hpp"
#include "rage/rlSessionInfo.hpp"
#include "rage/rlTaskStatus.hpp"
#include "rage/sysMemAllocator.hpp"
#include "rage/vector.hpp"
#include "script/dataList.hpp"
#include "script/globals/GlobalPlayerBD.hpp"
#include "script/globals/GPBD_FM.hpp"
#include "script/globals/GPBD_FM_3.hpp"
#include "script/globals/GPBD_Kicking.hpp"
#include "script/globals/GPBD_MissionName.hpp"
#include "script/globals/GSBD.hpp"
#include "script/globals/GSBD_BlockB.hpp"
#include "script/globals/GSBD_FM.hpp"
#include "script/globals/GSBD_Kicking.hpp"
#include "script/globals/GSBD_PropertyInstances.hpp"
#include "script/globals/g_AMC_playerBD.hpp"
#include "script/CGameScriptObjInfo.hpp"
#include "script/GtaThread.hpp"
#include "script/HudColor.hpp"
#include "script/MPScriptData.hpp"
#include "script/scriptHandler.hpp"
#include "script/scriptHandlerMgr.hpp"
#include "script/scriptHandlerNetComponent.hpp"
#include "script/scriptId.hpp"
#include "script/scriptIdBase.hpp"
#include "script/scriptResource.hpp"
#include "script/scrNativeHandler.hpp"
#include "script/scrNativeRegistration.hpp"
#include "script/scrNativeRegistrationTable.hpp"
#include "script/scrProgram.hpp"
#include "script/scrProgramTable.hpp"
#include "script/scrProgramTableEntry.hpp"
#include "script/scrThread.hpp"
#include "script/scrThreadContext.hpp"
#include "script/scrVector.hpp"
#include "script/Timer.hpp"
#include "script/tlsContext.hpp"
#include "script/types.hpp"
#include "security/ObfVar.hpp"
#include "security/RageSecurity.hpp"
#include "socialclub/FriendInfo.hpp"
#include "socialclub/FriendRegistry.hpp"
#include "socialclub/ScInfo.hpp"
#include "stats/CPlayerCardStats.hpp"
#include "stats/CStatsSerializationContext.hpp"
#include "vehicle/CAdvancedData.hpp"
#include "vehicle/CBaseSubHandlingData.hpp"
#include "vehicle/CCarHandlingData.hpp"
#include "vehicle/CHandlingData.hpp"
#include "vehicle/CHandlingObject.hpp"
#include "vehicle/CVehicle.hpp"
#include "vehicle/CVehicleModelInfo.hpp"
#include "vehicle/CVehicleDriveByMetadataMgr.hpp"
#include "vehicle/CVehicleSeatMetadataMgr.hpp"
#include "vehicle/CTrainConfig.hpp"
#include "vehicle/CGetPedSeatReturnClass.hpp"
#include "weapon/CAmmoInfo.hpp"
#include "weapon/CAmmoProjectileInfo.hpp"
#include "weapon/CAmmoRocketInfo.hpp"
#include "weapon/CAmmoThrownInfo.hpp"
#include "weapon/CHomingRocketParams.hpp"
#include "weapon/CItemInfo.hpp"
#include "weapon/CWeaponBoneId.hpp"
#include "weapon/CWeaponInfo.hpp"
#include "ui/CBlipList.hpp"
// add your classes here

13
draw_handlers/CEntityDrawHandler.hpp Normal file
View file

@ -0,0 +1,13 @@
#pragma once
#include "fwDrawData.hpp"
namespace rage
{
class CEntityDrawHandler : public rage::fwDrawData
{
public:
};
static_assert(sizeof(CEntityDrawHandler) == 0x2C);
}

11
draw_handlers/CObjectDrawHandler.hpp Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#include "CEntityDrawHandler.hpp"
namespace rage
{
class CObjectFragmentDrawHandler : public CEntityDrawHandler
{
};
static_assert(sizeof(CObjectFragmentDrawHandler) == 0x2C);
}

20
draw_handlers/CPedDrawHandler.hpp Normal file
View file

@ -0,0 +1,20 @@
#pragma once
#include <cstdint>
#include "CEntityDrawHandler.hpp"
namespace rage
{
#pragma pack(push, 4)
class CPedDrawHandler : public CEntityDrawHandler
{
public:
uint64_t qword30;
uint64_t qword38;
char gap40[752];
uint32_t dword330;
};
static_assert(sizeof(CPedDrawHandler) == 0x330);
#pragma pack(pop)
}

86
draw_handlers/CVehicleDrawHandler.hpp Normal file
View file

@ -0,0 +1,86 @@
#pragma once
#include <cstdint>
#include "CEntityDrawHandler.hpp"
namespace rage
{
class CVehicleDrawHandler : public CEntityDrawHandler
{
public:
uint64_t qword30;
char gap38[848];
uint8_t m_primary_color; //0x0388
char gap389[3]; //0x0389
uint8_t m_pearlescent; //0x038C
char gap38D[3]; //0x038D
uint8_t m_secondary_color; //0x0390
char gap391[15]; //0x0391
uint8_t m_neon_blue; //0x03A0
uint8_t m_neon_green; //0x03A1
uint8_t m_neon_red; //0x03A2
char gap3A3[15]; //0x03A3
uint8_t m_spoiler; //0x03B2
uint8_t m_bumper_front; //0x03B3
uint8_t m_bumper_rear; //0x03B4
uint8_t m_sideskirts; //0x03B5
uint8_t m_exhaust; //0x03B6
uint8_t m_frame; //0x03B7
uint8_t m_grille; //0x03B8
uint8_t m_hood; //0x03B9
uint8_t m_fenders; //0x03BA
uint8_t m_bullbars; //0x03BB
uint8_t m_roof; //0x03BC
char gap3BD[3]; //0x03BD
uint8_t m_ornaments; //0x03C0
char gap3C1[1]; //0x03C1
uint8_t m_dail_design; //0x03C2
uint8_t m_sunstrips; //0x03C3
uint8_t m_seats; //0x03C4
uint8_t m_steering_wheel; //0x03C5
uint8_t m_column_shifter_levers; //0x03C6
char gap3C7[2]; //0x03C7
uint8_t m_truck_beds; //0x03C9
char gap3CA[4]; //0x03CA
uint8_t m_roll_cages; //0x03CE
uint8_t m_skid_plate; //0x03CF
uint8_t m_secondary_light_surrounds; //0x03D0
uint8_t m_hood_accessories; //0x03D1
uint8_t m_doors; //0x03D2
uint8_t m_snorkel; //0x03D3
uint8_t m_livery; //0x03D4
char gap3D5[1]; //0x03D5
uint8_t m_engine; //0x03D6
uint8_t m_brakes; //0x03D7
uint8_t m_transmission; //0x03D8
uint8_t m_horn; //0x03D9
uint8_t m_suspension; //0x03DA
uint8_t m_armor; //0x03DB
char gap3DC[1]; //0x03DC
uint8_t m_turbo; //0x03DD
char gap3DE[3]; //0x03DE
uint8_t m_xenon; //0x03E1
uint8_t m_tire_design; //0x03E2
char gap3E3[16]; //0x03E3
uint8_t m_truck_bed; //0x03F3
uint16_t m_modkit; //0x03F4
uint8_t byte3F6;
uint8_t byte3F7;
uint8_t byte3F8;
uint8_t m_wheel_color;
uint8_t byte3FA;
uint8_t byte3FB;
char gap3FC[3];
uint8_t m_window;
char gap400[2];
uint8_t m_neon_left;
uint8_t m_neon_right;
uint8_t m_neon_front;
uint8_t m_neon_rear;
char gap406[9];
uint32_t dword410;
uint32_t dword414;
};
static_assert(sizeof(CVehicleDrawHandler) == 0x418);
}

21
draw_handlers/fwDrawData.hpp Normal file
View file

@ -0,0 +1,21 @@
#pragma once
#include <cstdint>
namespace rage
{
#pragma pack(push, 4)
class fwDrawData
{
public:
std::uint64_t qword0;
std::uint64_t qword8;
char gap10[8];
std::uint32_t dword18;
std::uint32_t dword1C;
std::uint64_t qword20;
std::uint32_t dword28;
};
static_assert(sizeof(fwDrawData) == 0x2C);
#pragma pack(pop)
}

15
entities/CAttackers.hpp Normal file
View file

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

18
entities/CDynamicEntity.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include "CEntity.hpp"
#include "../network/netObject.hpp"
#include <cstdint>
namespace rage
{
class CDynamicEntity : public CEntity
{
public:
class rage::netObject *m_net_object; //0x00D0
char gapD8[16];
uint64_t qwordE8;
};
static_assert(sizeof(CDynamicEntity) == 0xF0);
}

52
entities/CEntity.hpp Normal file
View file

@ -0,0 +1,52 @@
#pragma once
#include "fwEntity.hpp"
#include <cstdint>
class CEntityDrawHandler;
namespace rage
{
class CEntity : public rage::fwEntity
{
public:
virtual void* _0x120() = 0; // implemented only by CPed
virtual void UpdatePositionImpl() = 0; // 0x128
virtual void _0x130() = 0;
virtual void _0x138(void*) = 0;
virtual void _0x140() = 0;
virtual void _0x148(int) = 0;
virtual bool _0x150() = 0;
virtual CEntityDrawHandler* CreateDrawHandler() = 0; // 0x158
virtual int GetTypeFlags() = 0; // 0x160
virtual int GetTypeFlags2() = 0; // 0x168
virtual bool _0x170() = 0; // implemented only by CPickup
virtual bool _0x178() = 0;
virtual void _0x180(bool) = 0;
virtual bool _0x188() = 0;
virtual bool _0x190() = 0;
virtual void ClearDecals() = 0; // 0x198
virtual void GetModelBounds(rage::fvector3* bounds) = 0; // 0x1A0
virtual void GetModelBounds2(rage::fvector3* bounds) = 0; // 0x1A8
virtual float GetBoundingBoxSize() = 0; // 0x1B0
virtual float _0x1B8(void*) = 0;
virtual float _0x1C0(void*) = 0;
virtual rage::fvector3* _0x1C8() = 0;
virtual rage::fvector3* GetCameraOffset() = 0; // 0x1D0
virtual void GetCameraBasePosition(rage::fvector3* pos) = 0; // 0x1D8
virtual bool _0x1E0() = 0;
virtual bool Update() = 0; // 0x1E8 always returns true
virtual bool _0x1F0() = 0;
virtual void Warp(rage::fvector3* pos, float heading, bool) = 0; // 0x1F8
uint8_t gapB9; //0x00B9
char gapBA[6]; //0x00BA
uint32_t m_flags_3; //0x00C0
uint32_t m_flags_4; //0x00C4
uint32_t dwordC8;
uint32_t dwordCC;
};
static_assert(sizeof(CEntity) == 0xD0);
}

33
entities/CPhysical.hpp Normal file
View file

@ -0,0 +1,33 @@
#pragma once
#include "CDynamicEntity.hpp"
#include "CAttackers.hpp"
#include <cstdint>
namespace rage
{
#pragma pack(push, 1)
class CPhysical : public CDynamicEntity
{
public:
char gapF0[144];
uint64_t qword180;
uint32_t m_damage_bits; //0x0188
uint8_t m_hostility; //0x018C
char gap18D[3];
uint8_t byte190;
char gap191[3];
uint32_t dword194;
char gap198[232];
float m_health; //0x0280
float m_maxhealth; //0x0284
class CAttackers* m_attackers;
char gap2B0[72];
uint64_t qword2F8;
uint64_t qword300;
uint32_t dword308;
};
static_assert(sizeof(CPhysical) == 0x2EC);
#pragma pack(pop)
}

98
entities/fwEntity.hpp Normal file
View file

@ -0,0 +1,98 @@
#pragma once
#include "../base/CBaseModelInfo.hpp"
#include "../base/CNavigation.hpp"
#include "../base/fwExtensibleBase.hpp"
#include "../base/atRTTI.hpp"
#include "../draw_handlers/fwDrawData.hpp"
#include <cstdint>
class CMoveObjectPooledObject;
namespace rage
{
class fwDynamicEntityComponent;
class crmtRequestPose;
class crmtRequestIk;
class crFrameFilter;
class fwAudEntity;
#pragma pack(push, 1)
class fwEntity : public fwExtensibleBase
{
public:
DEFINE_RAGE_RTTI(rage::fwEntity);
virtual void* _0x38(void*, void*) = 0;
virtual void AddExtension(void* extension) = 0; // 0x40
virtual void _0x48() = 0; // not implemented
virtual void _0x50() = 0; // only implemented by CEntityBatch
virtual void _0x58() = 0;
virtual void SetModelInfo(std::uint16_t* model_index) = 0; // 0x60
virtual void _0x68(int, fvector4*) = 0;
virtual void* _0x70(int) = 0;
virtual CNavigation* GetNavigation() = 0; // 0x78
virtual CMoveObjectPooledObject* CreateMoveObject() = 0; // 0x80
virtual std::uint32_t* GetType() = 0; // 0x88
virtual void _0x90() = 0;
virtual float _0x98() = 0;
virtual bool TryRequestInverseKinematics(rage::crmtRequestPose* pose, rage::crmtRequestIk* ik) = 0; // 0xA0 implemented only by CPed
virtual bool TryRequestFacialAnims(void*) = 0; // 0xA8 implemented only by CPed
virtual void* _0xB0() = 0;
virtual std::uint8_t _0xB8() = 0; // implemented only by CPed
virtual rage::crFrameFilter* GetFrameFilter() = 0; // 0xC0
virtual rage::fwAudEntity* GetEntityAudio() = 0; // 0xC8
virtual void _0xD0() = 0;
virtual void SetTransform(fmatrix44* matrix, bool update_pos) = 0; // 0xD8
virtual void SetTransform2(fmatrix44* matrix, bool update_pos) = 0; // 0xE0
virtual void SetPosition(fvector4* pos, bool update_pos) = 0; // 0xE8
virtual void SetHeading(float heading, bool update_pos) = 0; // 0xF0
virtual void SetEntityTypeFlags() = 0; // 0xF8
virtual void _0x100() = 0; // not implemented
virtual void UpdatePhysics(CNavigation* navigation) = 0; // 0x108
virtual void UpdatePhysics2(CNavigation* navigation) = 0; // 0x110
virtual void UpdatePosition() = 0; // 0x118
enum class EntityFlags
{
IS_VISIBLE = (1 << 0)
};
class CBaseModelInfo* m_model_info; //0x0020
uint8_t m_entity_type; //0x0028
char gap29; //0x0029
uint16_t gap2A; //0x002A
uint32_t m_flags; //0x002D
class CNavigation *m_navigation; //0x0030
uint16_t gap38; //0x0038
uint16_t gap3A; //0x003A
uint32_t gap3C; //0x003C
class rage::fwDynamicEntityComponent* m_dynamic_entity_component; //0x0040 (stores attachments and stuff)
class rage::fwDrawData* m_draw_data; //0x0048
class rage::fwDynamicEntityComponent* gap50; //0x0050
uint64_t gap58; //0x0058
fmatrix44 m_transformation_matrix; //0x0060
rage::fwEntity* m_render_focus_entity; //0x00A0
uint32_t m_render_focus_distance; //0x00A8
uint32_t m_flags_2; //0x00AC
uint32_t m_shadow_flags; //0x00B0
char gapB4[4]; //0x00B4
std::uint8_t byteB8; //0x00B8
rage::fvector3* get_position()
{
return reinterpret_cast<rage::fvector3*>(&m_transformation_matrix.rows[3]);
}
void model_to_world(const fvector3& model_coords, fvector3& world_coords)
{
world_coords.x = model_coords.x * m_transformation_matrix.data[0][0] + model_coords.y * m_transformation_matrix.data[1][0] + model_coords.z * m_transformation_matrix.data[2][0] + m_transformation_matrix.data[3][0];
world_coords.y = model_coords.x * m_transformation_matrix.data[0][1] + model_coords.y * m_transformation_matrix.data[1][1] + model_coords.z * m_transformation_matrix.data[2][1] + m_transformation_matrix.data[3][1];
world_coords.z = model_coords.x * m_transformation_matrix.data[0][2] + model_coords.y * m_transformation_matrix.data[1][2] + model_coords.z * m_transformation_matrix.data[2][2] + m_transformation_matrix.data[3][2];
}
};
static_assert(sizeof(fwEntity) == 0xB9);
#pragma pack(pop)
}

92
enums/eExplosionTag.hpp Normal file
View file

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

16
enums/eHandlingType.hpp Normal file
View file

@ -0,0 +1,16 @@
#pragma once
enum class eHandlingType
{
HANDLING_TYPE_BIKE,
HANDLING_TYPE_FLYING,
HANDLING_TYPE_VERTICAL_FLYING,
HANDLING_TYPE_BOAT,
HANDLING_TYPE_SEAPLANE,
HANDLING_TYPE_SUBMARINE,
HANDLING_TYPE_TRAIN,
HANDLING_TYPE_TRAILER,
HANDLING_TYPE_CAR,
HANDLING_TYPE_WEAPON,
HANDLING_TYPE_MAX_TYPES
};

262
game_files/CGameConfig.hpp Normal file
View file

@ -0,0 +1,262 @@
#pragma once
#include "rage/atArray.hpp"
class CPoolSizes;
class CPoolSize;
class CGameConfig;
#pragma pack(push, 1)
class CPoolSize {
public:
char* m_pool;
uint32_t m_size;
};
static_assert(sizeof(CPoolSize) == 0xC);
class CStackSizeData {
public:
rage::joaat_t m_stack_name;
int32_t m_size_of_stack;
int32_t m_number_of_stacks_of_this_size;
inline CStackSizeData(rage::joaat_t name, int size, int num) :
m_stack_name(name),
m_size_of_stack(size),
m_number_of_stacks_of_this_size(num)
{
}
inline CStackSizeData(const std::string& name, int size, int num) :
m_stack_name(rage::joaat(name)),
m_size_of_stack(size),
m_number_of_stacks_of_this_size(num)
{
}
};
static_assert(sizeof(CStackSizeData) == 0xC);
namespace rage
{
class parStructure;
class fwConfig
{
public:
virtual ~fwConfig() = 0;
virtual void copy_data_from_config(fwConfig* config) = 0;
virtual fwConfig* clone_config() = 0;
virtual parStructure* get_structure() = 0;
rage::atArray<CPoolSize> m_pool_sizes;
char padding[0x8];
};
static_assert(sizeof(fwConfig) == 0x20);
template <typename T>
class fwConfigManagerImpl
{
public:
virtual ~fwConfigManagerImpl() = 0;
virtual T* create_config() = 0;
char padding[0x10];
T* m_config;
};
static_assert(sizeof(fwConfigManagerImpl<CGameConfig>) == 0x20);
};
class CConfigPopulation
{
public:
int32_t m_scenario_peds_multiplier_base; //0x0000
int32_t m_scenario_peds_multiplier; //0x0004
int32_t m_ambient_peds_multiplier_base; //0x0008
int32_t m_ambient_peds_multiplier; //0x000C
int32_t m_max_total_peds_base; //0x0010
int32_t m_max_total_peds; //0x0014
int32_t m_ped_memory_multiplier; //0x0018
int32_t m_peds_for_vehicles_base; //0x001C
int32_t m_peds_for_vehicles; //0x0020
int32_t m_vehicle_timeslice_max_updates_per_frame_base; //0x0024
int32_t m_vehicle_timeslice_max_updates_per_frame; //0x0028
int32_t m_vehicle_ambient_density_multiplier_base; //0x002C
int32_t m_vehicle_ambient_density_multiplier; //0x0030
int32_t m_vehicle_memory_multiplier; //0x0034
int32_t m_vehicle_parked_density_multiplier_base; //0x0038
int32_t m_vehicle_parked_density_multiplier; //0x003C
int32_t m_vehicle_low_prio_parked_density_multiplier_base; //0x0040
int32_t m_vehicle_low_prio_parked_density_multiplier; //0x0044
int32_t m_vehicle_upper_limit_base; //0x0048
int32_t m_vehicle_upper_limit; //0x004C
int32_t m_vehicle_upper_limit_mp; //0x0050
int32_t m_vehicle_parked_upper_limit_base; //0x0054
int32_t m_vehicle_parked_upper_limit; //0x0058
int32_t m_vehicle_keyhole_shape_inner_thickness_base; //0x005C
int32_t m_vehicle_keyhole_shape_inner_thickness; //0x0060
int32_t m_vehicle_keyhole_shape_outer_thickness_base; //0x0064
int32_t m_vehicle_keyhole_shape_outer_thickness; //0x0068
int32_t m_vehicle_keyhole_shape_inner_radius_base; //0x006C
int32_t m_vehicle_keyhole_shape_inner_radius; //0x0070
int32_t m_vehicle_keyhole_shape_outer_radius_base; //0x0074
int32_t m_vehicle_keyhole_shape_outer_radius; //0x0078
int32_t m_vehicle_keyhole_side_wall_thickness_base; //0x007C
int32_t m_vehicle_keyhole_side_wall_thickness; //0x0080
int32_t m_vehicle_max_creation_distance_base; //0x0084
int32_t m_vehicle_max_creation_distance; //0x0088
int32_t m_vehicle_max_creation_distance_offscreen_base; //0x008C
int32_t m_vehicle_max_creation_distance_offscreen; //0x0090
int32_t m_vehicle_cull_range_base; //0x0094
int32_t m_vehicle_cull_range; //0x0098
int32_t m_vehicle_cull_range_on_screen_scale_base; //0x009C
int32_t m_vehicle_cull_range_on_screen_scale; //0x00A0
int32_t m_vehicle_cull_range_off_screen_base; //0x00A4
int32_t m_vehicle_cull_range_off_screen; //0x00A8
int32_t m_density_based_removal_rate_scale_base; //0x00AC
int32_t m_density_based_removal_rate_scale; //0x00B0
int32_t m_density_based_removal_target_headroom_base; //0x00B4
int32_t m_density_based_removal_target_headroom; //0x00B8
rage::atArray<int> m_vehicle_spacing_base; // TODO: these are atFixedArrays
char pad_00CC[48]; //0x00CC
rage::atArray<int> m_vehicle_spacing;
char pad_010C[48]; //0x010C
int32_t m_players_road_scan_distance_base; //0x013C
int32_t m_players_road_scan_distance; //0x0140
rage::atArray<int> m_player_road_density_inc_base;
char pad_0154[48]; //0x0154
rage::atArray<int> m_player_road_density_inc;
char pad_0194[48]; //0x0194
rage::atArray<int> m_non_player_road_density_dec_base;
char pad_01D4[56]; //0x01D4
rage::atArray<int> m_non_player_road_density_dec;
char pad_021C[40]; //0x021C
int32_t m_vehicle_population_frame_rate_base; //0x0244
int32_t m_vehicle_population_frame_rate; //0x0248
int32_t m_vehicle_population_cycles_per_frame_base; //0x024C
int32_t m_vehicle_population_cycles_per_frame; //0x0250
int32_t m_vehicle_population_frame_rate_mp_base; //0x0254
int32_t m_vehicle_population_frame_rate_mp; //0x0258
int32_t m_vehicle_population_cycles_per_frame_mp_base; //0x025C
int32_t m_vehicle_population_cycles_per_frame_mp; //0x0260
int32_t m_ped_population_frame_rate_base; //0x0264
int32_t m_ped_population_frame_rate; //0x0268
int32_t m_ped_population_cycles_per_frame_base; //0x026C
int32_t m_ped_population_cycles_per_frame; //0x0270
int32_t m_ped_population_frame_rate_mp_base; //0x0274
int32_t m_ped_population_frame_rate_mp; //0x0278
int32_t m_ped_population_cycles_per_frame_mp_base; //0x027C
int32_t m_ped_population_cycles_per_frame_mp; //0x0280
};
static_assert(sizeof(CConfigPopulation) == 0x284);
class CConfig2DEffects // looks unused
{
public:
int32_t m_max_attrs_audio; //0x0000
int32_t m_max_attrs_buoyancy; //0x0004
int32_t m_max_attrs_decal; //0x0008
int32_t m_max_attrs_explosion; //0x000C
int32_t m_max_attrs_ladder; //0x0010
char pad_0014[8]; //0x0014
int32_t m_max_attrs_light_shaft; //0x001C
int32_t m_max_attrs_particle; //0x0020
int32_t m_max_attrs_proc_obj; //0x0024
int32_t m_max_attrs_scroll_bar; //0x0028
int32_t m_max_attrs_spawn_point; //0x002C
char pad_0030[8]; //0x0030
int32_t m_max_attrs_wind_disturbance; //0x0038
int32_t m_max_attrs_world_point; //0x003C
int32_t m_0xFC5DD116; //0x0040
int32_t m_max_effects_world_2d; //0x0044
char pad[4];
};
static_assert(sizeof(CConfig2DEffects) == 0x4C);
class CConfigModelInfo
{
public:
char* m_default_player_name; //0x0000
char* m_default_prologue_player_name; //0x0008
int32_t m_max_base_model_infos; //0x0010
int32_t m_max_comp_entity_model_infos; //0x0014
int32_t m_max_mlo_instances; //0x0018
int32_t m_max_mlo_model_infos; //0x001C
int32_t m_max_ped_model_infos; //0x0020
int32_t m_max_time_model_infos; //0x0024
int32_t m_max_vehicle_model_infos; //0x0028
int32_t m_max_weapon_model_infos; //0x002C
int32_t m_max_extra_ped_model_infos; //0x0030
int32_t m_max_extra_vehicle_model_infos; //0x0034
int32_t m_max_extra_weapon_model_infos; //0x0038
int32_t m_unk;
};
static_assert(sizeof(CConfigModelInfo) == 0x40);
class CConfigExtensions
{
public:
int32_t m_max_door_extensions;
int32_t m_max_light_extensions;
int32_t m_max_spawn_point_override_extensions;
int32_t m_max_expression_extensions;
int32_t m_0xBDE77A4F;
};
static_assert(sizeof(CConfigExtensions) == 0x14);
class CConfigStreamingEngine
{
public:
int32_t m_archive_count;
int32_t m_physical_streaming_buffer;
int32_t m_virtual_streaming_buffer;
};
static_assert(sizeof(CConfigStreamingEngine) == 0xC);
class CConfigOnlineServices
{
public:
char* m_ros_title_name;
int32_t m_ros_title_version;
int32_t m_sc_version;
int64_t m_steam_app_id;
char* m_title_directory_name;
char* m_multiplayer_session_template_name;
char* m_sc_auth_title_id;
};
static_assert(sizeof(CConfigOnlineServices) == 0x30);
class CConfigUGCDescriptions
{
public:
int32_t m_max_description_length;
int32_t m_max_num_descriptions;
int32_t m_size_of_description_buffer;
};
static_assert(sizeof(CConfigUGCDescriptions) == 0xC);
class CConfigScriptStackSizes
{
public:
rage::atArray<CStackSizeData> m_stack_size_data;
};
static_assert(sizeof(CConfigScriptStackSizes) == 0x10);
class CGameConfig : public rage::fwConfig {
public:
CConfigPopulation m_config_population;
CConfig2DEffects m_config_2d_effects;
CConfigModelInfo m_config_model_info;
CConfigExtensions m_config_extensions;
CConfigStreamingEngine m_config_streaming_engine;
CConfigOnlineServices m_config_online_services;
CConfigUGCDescriptions m_config_ugc_descriptions;
char padding[0x488 - 0x38C]; // CConfigNetScriptBroadcastData
CConfigScriptStackSizes m_config_script_stack_sizes;
// TODO: more stuff down here
};
#pragma pack(pop)

14
graphics/CViewport.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include "rage/grcViewport.hpp"
struct CViewportGame
{
public:
virtual ~CViewportGame() = 0;
private:
char m_pad[8];
public:
rage::grcViewport viewport;
};

BIN
gtav.rcnet Normal file
View file

Binary file not shown.

22
misc/CTunables.hpp Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include <cstdint>
#include "../base/datBase.hpp"
enum eTunableType
{
TunableType_DONTCARE = -1,
TunableType_UNK0,
TunableType_4BYTE,
TunableType_1BYTE,
};
class CTunables : public rage::datBase
{
public:
char pad_0000[104]; //0x0008
uint64_t m_bPtr; //0x0070
uint16_t m_bCount; //0x0078
char pad_007A[0x4E]; //0x007A
}; //Size: 0x00C8
static_assert(sizeof(CTunables) == 0xC8);

96
misc/vfx/TimecycleKeyframeData.hpp Normal file
View file

@ -0,0 +1,96 @@
#pragma once
class TimecycleKeyframeData
{
public:
char pad_0000[32]; //0x0000
rage::fvector4 m_azimuth_east; //0x0020
float m_azimuth_east_intensity; //0x0030
char pad_0034[28]; //0x0034
rage::fvector4 m_azimuth_west; //0x0050
float m_azimuth_west_intensity; //0x0060
char pad_0064[28]; //0x0064
rage::fvector4 m_azimuth_transition; //0x0080
float m_azimuth_transition_intensity; //0x0090
char pad_0094[4]; //0x0094
float m_azimuth_transition_position; //0x0098
char pad_009C[20]; //0x009C
rage::fvector4 m_zenith; //0x00B0
float m_zenith_intensity; //0x00C0
char pad_00C4[28]; //0x00C4
rage::fvector4 m_zenith_transition; //0x00E0
float m_zenith_transition_intensity; //0x00F0
float m_zenith_transition_position; //0x00F4
float m_zenith_transition_east_blend; //0x00F8
float m_zenith_transition_west_blend; //0x00FC
float m_zenith_blend_start; //0x0100
char pad_0104[60]; //0x0104
rage::fvector3 m_plane; //0x0140
float m_plane_intensity; //0x014C
char pad_0150[52]; //0x0150
float m_hdr; //0x0184
float m_unk_188; //0x0188
bool m_update_sky_attributes; //0x018C
char pad_018D[3]; //0x018D
uint32_t m_unk_190; //0x0190
uint32_t m_unk_194; //0x0194
char pad_0198[8]; //0x0198
rage::fvector4 m_unk_1A0; //0x01A0
char pad_01AC[16]; //0x01AC
rage::fvector4 m_sun; //0x01C0
char pad_01CC[32]; //0x01CC
rage::fvector4 m_sun_disc; //0x01F0
char pad_01FC[32]; //0x01FC
float m_sun_disc_size; //0x0220
float m_sun_hdr; //0x0224
float m_sun_miephase; //0x0228
float m_sun_miescatter; //0x022C
float m_sun_mie_intensity_mult; //0x0230
char pad_0234[28]; //0x0234
rage::fvector4 m_unk_250; //0x0250
char pad_025C[16]; //0x025C
float m_cloud_shadow_strength; //0x0270
float m_cloud_density_mult; //0x0274
float m_cloud_density_bias; //0x0278
float m_cloud_fadeout; //0x027C
char pad_0280[32]; //0x0280
float m_unk_2A0; //0x02A0
float m_cloud_offset; //0x02A4
float m_cloud_overall_color; //0x02A8
float m_cloud_hdr; //0x02AC
char pad_02B0[32]; //0x02B0
float m_cloud_dither_strength; //0x02D0
char pad_02D4[44]; //0x02D4
float m_cloud_edge_strength; //0x0300
char pad_0304[4]; //0x0304
float m_cloud_overall_strength; //0x0308
char pad_030C[16]; //0x030C
rage::fvector4 m_unk_320; //0x031C
rage::fvector4 m_cloud_base; //0x032C
rage::fvector4 m_unk_340; //0x033C
char pad_0348[16]; //0x0348
rage::fvector4 m_cloud_1; //0x035C
char pad_0368[20]; //0x0368
rage::fvector4 m_cloud_mid; //0x0380
char pad_038C[32]; //0x038C
float m_unk_380; //0x03B0
float m_small_cloud_detail_strength; //0x03B4
float m_small_cloud_density_mult; //0x03B8
float m_unk_3BC; //0x03BC
char pad_03C0[32]; //0x03C0
rage::fvector4 m_small_cloud; //0x03E0
char pad_03EC[32]; //0x03EC
float m_sun_influence_radius; //0x0410
float m_sun_scatter_inten; //0x0414
float m_moon_influence_radius; //0x0418
float m_moon_scatter_inten; //0x041C
char pad_0420[212]; //0x0420
float m_stars_iten; //0x04F4
char pad_04F8[60]; //0x04F8
float m_moon_disc_size; //0x0534
char pad_0538[24]; //0x0538
rage::fvector4 m_moon; //0x0550
float m_moon_intensity; //0x0560
char pad_0564[140]; //0x0564
}; //Size: 0x05F0
static_assert(sizeof(TimecycleKeyframeData) == 0x5F0);

46
netsync/CProjectBaseSyncDataNode.hpp Normal file
View file

@ -0,0 +1,46 @@
#pragma once
#include "netSyncDataNode.hpp"
#include "NodeCommonDataOperations.hpp"
namespace rage
{
class netSyncData;
class netObject;
}
class CProjectBaseSyncDataNode : public rage::netSyncDataNode
{
public:
virtual bool IsSyncNode() { return false; } // 0x50
virtual bool _0x58() { return false; } // 0x58
virtual bool IsGlobalFlags() { return false; } // 0x60
virtual void DoPreCache(rage::netSyncData* data) {} // 0x68
virtual std::uint8_t GetSyncFrequency(int index) { return 0; } // 0x70
virtual int GetSyncInterval(int index) { return 0; } // 0x78
virtual int GetBandwidthForPlayer(int player) { return 200; } // 0x80 (should always return 200)
virtual void _0x88(void*) {} // 0x88
virtual bool _0x90(void*, void*, int, int, int) { return false; } // 0x90
virtual int CalculateSize() { return 0; } // 0x98 need to verify later
virtual bool IsPreCacheDisabled() { return false; } // 0xA0
virtual bool CanApply(rage::netObject* object) { return false; } // 0xA8
virtual int GetPlayersInScope() { return -1; } // 0xB0
virtual void DeserializeImpl() {} // 0xB8 need to verify later
virtual void SerializeImpl() {} // 0xC0 need to verify later
virtual int CalculateSize2() { return 0; } // 0xC8
virtual int _0xD0() { return 0; } // 0xD0 calls NodeCommonDataOperations::Unk()
virtual void Log() {} // 0xD8
virtual bool CanPreCache(int) { return false; } // 0xE0 arg is always zero afaik
virtual bool CanBeEmpty() { return false; } // 0xE8
virtual bool IsEmpty() { return false; } // 0xF0 returns true if all data is default
virtual void SetEmpty() {} // 0xF8 sets all data to their default values
virtual void Log2() {} // 0x100
virtual void ResetScriptData() {} // 0x108
virtual bool _0x110() { return false; } // 0x110
private:
NodeCommonDataOperations m_common_data_operations; // 0xB0 this is generally invalidated by MoveCommonDataOpsVFT()
};
static_assert(sizeof(CProjectBaseSyncDataNode) == 0xC0);
class CSyncDataNodeFrequent : public CProjectBaseSyncDataNode {};
class CSyncDataNodeInfrequent : public CProjectBaseSyncDataNode {};

10
netsync/CProjectSyncTree.hpp Normal file
View file

@ -0,0 +1,10 @@
#pragma once
#include "netSyncTree.hpp"
class CProjectSyncTree : public rage::netSyncTree
{
void* m_unk_data;
int m_unk_data_size;
char pad_04C4[4];
};
static_assert(sizeof(CProjectSyncTree) == 0x4C8);

23
netsync/NodeCommonDataOperations.hpp Normal file
View file

@ -0,0 +1,23 @@
#pragma once
namespace rage
{
class datBitBuffer;
class netSyncDataNode;
}
class NodeCommonDataOperations
{
public:
virtual ~NodeCommonDataOperations() = default;
virtual void ReadFromBuffer(rage::netSyncDataNode* node) {}; // 0x08
virtual void WriteToBuffer(rage::netSyncDataNode* node) {}; // 0x10
virtual void Unk() {}; // 0x18
virtual int CalculateSize(rage::netSyncDataNode* node) { return 0; }; // 0x20
virtual int CalculateSize2(rage::netSyncDataNode* node) { return 0; }; // 0x28
virtual void LogSyncData(rage::netSyncDataNode* node) {}; // 0x30
virtual void LogSyncData2(rage::netSyncDataNode* node) {}; // 0x38
rage::datBitBuffer* m_buffer; // 0x8
};
static_assert(sizeof(NodeCommonDataOperations) == 0x10);

23
netsync/netSyncDataNode.hpp Normal file
View file

@ -0,0 +1,23 @@
#pragma once
#include "netSyncNodeBase.hpp"
namespace rage
{
#pragma pack(push, 8)
class netSyncDataNode : public netSyncNodeBase
{
public:
uint32_t flags; //0x40
uint32_t pad3; //0x44
uint64_t pad4; //0x48
netSyncDataNode* parentData; //0x50
uint32_t childCount; //0x58
netSyncDataNode* children[8]; //0x5C
uint8_t syncFrequencies[8]; //0x9C
void* commonDataOpsVFT; //0xA8 wtf
};
static_assert(sizeof(netSyncDataNode) == 0xB0);
#pragma pack(pop)
}

40
netsync/netSyncNodeBase.hpp Normal file
View file

@ -0,0 +1,40 @@
#pragma once
#include <cstdint>
namespace rage
{
class datBitBuffer;
class netSyncTree;
#pragma pack(push, 8)
class netSyncNodeBase
{
public:
virtual ~netSyncNodeBase() = default; // 0x00
virtual bool IsDataNode() { return false; }; // 0x08
virtual bool IsParentNode() { return false; }; // 0x10
virtual void MoveCommonDataOpsVFT() {}; // 0x18
virtual void ClearChildren() {}; // 0x20
virtual void _0x28(void*, void*, void*, int* out_count) {}; // 0x28
virtual bool Serialize(int flags, int flags2, void*, rage::datBitBuffer* buffer, int, void*, bool, int*, int* num_serialized) { return false; } // 0x30
virtual bool Deserialize(int flags, int flags2, rage::datBitBuffer* buffer, void*) { return false; } // 0x38
virtual int CalculateSize(int flags, int flags2, void*) { return 0; } // 0x40
virtual int CalculateSize2(int flags, int flags2, bool) { return 0; } // 0x48
netSyncNodeBase* m_next_sibling; //0x0008
netSyncNodeBase* m_prev_sibling; //0x0010
netSyncTree* m_root; //0x0018
netSyncNodeBase* m_parent; //0x0020
uint32_t m_flags1; //0x0028
uint32_t m_flags2; //0x002C
uint32_t m_flags3; //0x0030
uint32_t m_pad2; //0x0034
netSyncNodeBase* m_first_child; //0x0038
}; //Size: 0x0040
static_assert(sizeof(netSyncNodeBase) == 0x40);
#pragma pack(pop)
}

14
netsync/netSyncParentNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include "netSyncNodeBase.hpp"
namespace rage
{
class netSyncParentNode : public netSyncNodeBase
{
public:
char pad_0040[32];
};
static_assert(sizeof(netSyncParentNode) == 0x60);
}
class CProjectBaseSyncParentNode : public rage::netSyncParentNode {};

27
netsync/netSyncTree.hpp Normal file
View file

@ -0,0 +1,27 @@
#pragma once
#include "netSyncNodeBase.hpp"
namespace rage
{
#pragma pack(push, 1)
class netSyncTree
{
public:
virtual ~netSyncTree() = default;
char pad_0008[8]; //0x0008
netSyncNodeBase* m_next_sync_node; //0x0010
netSyncNodeBase* m_last_sync_node; //0x0018
uint32_t m_child_node_count; //0x0020
uint32_t m_unk_array_count; //0x0024
char pad_0028[8]; //0x0028
netSyncNodeBase* m_child_nodes[42]; //0x0030
uint32_t m_child_node_max_count; //0x0180
netSyncNodeBase* m_unk_array[32]; //0x0188
uint32_t m_unk_array_max_count; //0x0288
char pad_0290[560]; //0x0290
}; //Size: 0x0030
static_assert(sizeof(netSyncTree) == 0x4B8);
#pragma pack(pop)
}

47
netsync/nodes/CPedComponents.hpp Normal file
View file

@ -0,0 +1,47 @@
#pragma once
#include <cstdint>
#pragma pack(push, 4)
class CPedComponents
{
public:
uint32_t m_component_bitset; //0x0
char pad_0x4[4]; //0x4
uint32_t unk_0x8[12]; //0x8
uint32_t m_drawables[12]; //0x38
uint32_t m_textures[12]; //0x68
uint32_t m_palettes[12]; //0x98
inline uint32_t get_drawable(int index)
{
if (m_component_bitset & (1 << index))
{
return m_drawables[index];
}
return 0;
}
inline uint32_t get_texture(int index)
{
if (m_component_bitset & (1 << index))
{
return m_textures[index];
}
return 0;
}
inline uint32_t get_palette(int index)
{
if (m_component_bitset & (1 << index))
{
return m_palettes[index];
}
return 0;
}
};
static_assert(sizeof(CPedComponents) == 0xC8);
#pragma pack(pop)

10
netsync/nodes/automobile/CAutomobileCreationNode.hpp Normal file
View file

@ -0,0 +1,10 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
class CAutomobileCreationDataNode : CProjectBaseSyncDataNode
{
public:
bool m_all_doors_closed; //0x00C0
bool m_door_closed[10]; //0x00C1
};
static_assert(sizeof(CAutomobileCreationDataNode) == 0xD0);

18
netsync/nodes/door/CDoorCreationDataNode.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CDoorCreationDataNode : CProjectBaseSyncDataNode
{
public:
uint32_t m_model; //0x00C0
char pad_00C4[12]; //0x00C4
rage::fvector3 m_pos; //0x00D0
char pad_00DC[12]; //0x00DC
bool m_is_script_door; //0x00E8
bool m_player_wants_control; //0x00E9
}; //Size: 0x00EC
static_assert(sizeof(CDoorCreationDataNode) == 0xEC);
#pragma pack(pop)

17
netsync/nodes/door/CDoorMovementDataNode.hpp Normal file
View file

@ -0,0 +1,17 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CDoorMovementDataNode : CSyncDataNodeFrequent
{
public:
bool m_is_manual_door; // 0xC0
float m_open_ratio; // 0xC4
bool m_opening; // 0xC8
bool m_fully_open; // 0xC9
bool m_closed; // 0xCA
};
static_assert(sizeof(CDoorMovementDataNode) == 0xCC);
#pragma pack(pop)

18
netsync/nodes/door/CDoorScriptGameStateDataNode.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
struct CDoorScriptGameStateDataNode : CSyncDataNodeInfrequent
{
public:
uint32_t m_door_system_state; // 0xC0
float m_automatic_distance; // 0xC4
float m_slide_rate; // 0xC8
bool m_has_broken_flags; // 0xCC
uint32_t m_broken_flags; // 0xD0
bool m_has_damaged_flags; // 0xD4
uint32_t m_damaged_flags; // 0xD8
bool m_hold_open; // 0xDC
};
static_assert(sizeof(CDoorScriptGameStateDataNode) == 0xE0);
#pragma pack(pop)

16
netsync/nodes/door/CDoorScriptInfoDataNode.hpp Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "script/CGameScriptObjInfo.hpp"
#pragma pack(push, 4)
struct CDoorScriptInfoDataNode : CSyncDataNodeInfrequent
{
public:
bool m_has_script_info;
int m_pad;
CGameScriptObjInfo m_script_info;
uint32_t m_door_system_hash;
bool m_existing_door_system_entry;
};
static_assert(sizeof(CDoorScriptInfoDataNode) == 0x120);
#pragma pack(pop)

26
netsync/nodes/dynamic_entity/CDynamicEntityGameStateDataNode.hpp Normal file
View file

@ -0,0 +1,26 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 1)
struct CDecorator
{
uint32_t m_type;
uint32_t m_name_hash;
uint32_t m_value;
};
#pragma pack(pop)
#pragma pack(push, 4)
class CDynamicEntityGameStateDataNode : CSyncDataNodeInfrequent
{
public:
uint32_t m_interior_index; // 0x00C0
bool m_loads_collisions; // 0x00C4
bool m_retained; // 0x00C5
uint32_t m_decor_count; // 0x00C8
CDecorator m_decors[10]; // 0x00CC
char pad[8]; // TODO!
}; //Size: 0x15C
static_assert(sizeof(CDynamicEntityGameStateDataNode) == 0x14C);
#pragma pack(pop)

11
netsync/nodes/entity/CEntityOrientationDataNode.hpp Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CEntityOrientationDataNode : CSyncDataNodeFrequent
{
public:
rage::fmatrix44 m_eulers;
}; //Size: 0x00EC
static_assert(sizeof(CEntityOrientationDataNode) == 0x100);
#pragma pack(pop)

12
netsync/nodes/entity/CEntityScriptGameStateDataNode.hpp Normal file
View file

@ -0,0 +1,12 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
struct CEntityScriptGameStateDataNode : CSyncDataNodeInfrequent
{
bool m_fixed; //0x00C0
bool m_uses_collision; //0x00C1
bool m_completely_disabled_collision; //0x00C2
}; //Size: 0x00C3
static_assert(sizeof(CEntityScriptGameStateDataNode) == 0xC4);
#pragma pack(pop)

14
netsync/nodes/entity/CEntityScriptInfoDataNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "script/CGameScriptObjInfo.hpp"
#pragma pack(push, 4)
struct CEntityScriptInfoDataNode : CSyncDataNodeInfrequent
{
public:
bool m_has_script_info;
int m_pad;
CGameScriptObjInfo m_script_info;
};
static_assert(sizeof(CEntityScriptInfoDataNode) == 0x118);
#pragma pack(pop)

25
netsync/nodes/heli/CHeliControlDataNode.hpp Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "netsync/nodes/vehicle/CVehicleControlDataNode.hpp"
#pragma pack(push, 8)
class CHeliControlDataNode : CVehicleControlDataNode
{
public:
char m_pad[0x10]; // 0x130
float m_yaw_control; // 0x140
float m_pitch_control; // 0x144
float m_roll_control; // 0x148
float m_throttle_control; // 0x14C
bool m_engine_off; // 0x150
int m_landing_gear_state; // 0x154
bool m_has_landing_gear; // 0x158
bool m_has_vehicle_task; // 0x159
bool m_is_thruster_model; // 0x15A
float m_thruster_side_rcs_throttle; // 0x15C
float m_thruster_throttle; // 0x160
bool m_unk8; // 0x164
};
static_assert(sizeof(CHeliControlDataNode) == 0x168);
#pragma pack(pop)

25
netsync/nodes/heli/CHeliHealthDataNode.hpp Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "netsync/nodes/physical/CPhysicalHealthDataNode.hpp"
#pragma pack(push, 8)
class CHeliHealthDataNode : CPhysicalHealthDataNode // intentionally private since the physical health node fields aren't serialized
{
public:
char m_pad[0x10]; // 0xF0
uint32_t m_main_rotor_health;
uint32_t m_rear_rotor_health;
bool m_can_tail_boom_break_off;
bool m_is_tail_boom_broken;
bool m_has_custom_health;
bool m_disable_explode_from_body_damage;
uint32_t m_body_health;
uint32_t m_petrol_tank_health;
uint32_t m_engine_health;
float m_main_rotor_damage_scale;
float m_rear_rotor_damage_scale;
float m_tail_boom_damage_scale;
};
static_assert(sizeof(CHeliHealthDataNode) == 0x118);
#pragma pack(pop)

45
netsync/nodes/object/CObjectCreationDataNode.hpp Normal file
View file

@ -0,0 +1,45 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CObjectCreationDataNode : CProjectBaseSyncDataNode
{
public:
uint32_t unk_00C0; //0x00C0
uint32_t unk_00C4; //0x00C4
uint32_t unk_00C8; //0x00C8
bool unk_00CC;
bool unk_00CD;
uint16_t unk_00D0; //0x00D0
char pad_0xC2[14]; //0x00D2
rage::fvector4 m_object_orientation; //0x00E0
char pad_00E0[30]; //0x00F0
rage::fvector3 m_object_position; //0x0110
char pad_010C[4]; //0x011C
rage::fvector3 m_dummy_position; //0x011E
char pad_011A[20]; //0x012C
rage::fvector3 m_script_grab_position; //0x0140
char pad_013C[12]; //0x013C
float m_script_grab_radius; //0x0148
uint32_t m_created_by; //0x014C
uint32_t m_model; //0x0150
uint32_t m_frag_group_index; //0x0154
uint32_t m_ownership_token; //0x0158
uint32_t unk_015C; //0x015C
bool m_no_reassign; //0x0160
bool unk_0161; //0x0161
bool m_player_wants_control; //0x0162
bool m_has_init_physics; //0x0163
bool m_script_grabbed_from_world; //0x0164
bool m_has_frag_group; //0x0165
bool m_is_broken; //0x0166
bool m_has_exploded; //0x0167
bool m_keep_registered; //0x0168
bool unk_0169; //0x0169
bool unk_016A; //0x016A
bool unk_016B; //0x016B
}; //Size: 0x016C
static_assert(sizeof(CObjectCreationDataNode) == 0x17C);
#pragma pack(pop)

11
netsync/nodes/ped/CPedAIDataNode.hpp Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
class CPedAIDataNode : CSyncDataNodeInfrequent
{
public:
uint32_t m_relationship_group; //0x00C0
uint32_t m_decision_maker_type; //0x00C4
}; //Size: 0x00C8
static_assert(sizeof(CPedAIDataNode) == 0xC8);

33
netsync/nodes/ped/CPedAppearanceDataNode.hpp Normal file
View file

@ -0,0 +1,33 @@
#pragma once
#include "../CPedComponents.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPedAppearanceDataNode : CSyncDataNodeInfrequent
{
public:
uint32_t unk_0xC0[6]; //0xC0
uint32_t unk_0xD8[6]; //0xD8
class CPedComponents components; //0xF0
char pad_0x1B8[8]; //0x1B8
uint32_t unk_0x1C0; //0x1C0
uint8_t unk_0x1C4; //0x1C4
uint8_t unk_0x1C5; //0x1C5
char pad_0x1C6[2]; //0x1C6
uint32_t unk_0x1C8; //0x1C8
uint32_t unk_0x1CC; //0x1CC
uint32_t unk_0x1D0; //0x1D0
bool unk_0x1D4; //0x1D4
bool unk_0x1D5; //0x1D5
bool unk_0x1D6; //0x1D6
uint8_t unk_0x1D7; //0x1D7
uint16_t unk_0x1D8; //0x1D8
uint16_t unk_0x1DA; //0x1DA
uint16_t unk_0x1DC; //0x1DC
bool unk_0x1DE; //0x1DE
bool unk_0x1DF; //0x1DF
bool unk_0x1E0; //0x1E0
uint8_t unk_0x1E1; //0x1E1
};
static_assert(sizeof(CPedAppearanceDataNode) == 0x1E4);
#pragma pack(pop)

22
netsync/nodes/ped/CPedAttachDataNode.hpp Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPedAttachDataNode : CSyncDataNodeInfrequent
{
public:
rage::fvector3 m_offset; //0x00C0
char pad_00CC[4]; //0x00CC
rage::fvector4 m_orientation; //0x00D0
uint16_t m_attached_to; //0x00E0
uint16_t m_attachment_bone; //0x00E2
uint32_t m_attachment_flags; //0x00E4
float m_heading_1; //0x00E8
float m_heading_2; //0x00EC
bool m_attached; //0x00F0
bool unk_00F1; //0x00F1
};
static_assert(sizeof(CPedAttachDataNode) == 0xF4);
#pragma pack(pop)

14
netsync/nodes/ped/CPedComponentReservationDataNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPedComponentReservationDataNode : CSyncDataNodeInfrequent
{
public:
uint32_t m_num_peds_using_component; //0x00C0
uint16_t m_peds_using_component[32]; //0x00C4
}; //Size: 0x00C8
#pragma pack(pop)
static_assert(sizeof(CPedComponentReservationDataNode) == 0x104);

28
netsync/nodes/ped/CPedCreationDataNode.hpp Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPedCreationDataNode : CProjectBaseSyncDataNode
{
public:
uint32_t m_pop_type; //0x00C0
uint32_t m_model; //0x00C4
uint32_t m_random_seed; //0x00C8
uint32_t m_max_health; //0x00CC
bool m_in_vehicle; //0x00D0
char pad_0xD1[1]; //0x00D1
uint16_t m_vehicle_id; //0x00D2
uint32_t m_vehicle_seat; //0x00D4
bool m_has_prop; //0x00D8
char pad_0xD9[3]; //0x00D9
uint32_t m_prop_model; //0x00DC
bool m_is_standing; //0x00E0
bool m_is_respawn_object_id; //0x00E1
bool m_is_respawn_flagged_for_removal; //0x00E2
bool m_has_attr_damage_to_player; //0x00E3
uint8_t m_attribute_damage_to_player; //0x00E4
uint32_t m_voice_hash; //0x00E8
}; //Size: 0x00EC
static_assert(sizeof(CPedCreationDataNode) == 0xEC);
#pragma pack(pop)

77
netsync/nodes/ped/CPedGameStateDataNode.hpp Normal file
View file

@ -0,0 +1,77 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,2)
class CPedGameStateDataNode : CSyncDataNodeInfrequent
{
public:
bool m_weapon_component_something[12]; //0x0C0
uint32_t m_weapon_component_hash[12]; //0x0CC
uint32_t m_gadget_hash[3]; //0x0F8
uint32_t unk_0104; // 0x0104
uint32_t unk_0108; // 0x0108
uint32_t unk_010C; // 0x010C
float unk_0110; // 0x0110
float unk_0114; // 0x0114
float unk_0118; // 0x0118
bool unk_011C; // 0x011C
char pad_011D[3]; //0x011D
uint32_t m_arrest_state; //0x0120
uint32_t m_death_state; //0x0124
uint32_t m_weapon_hash; //0x0128
uint32_t m_num_weapon_components; //0x012C
uint32_t m_num_equiped_gadgets; //0x0130
uint32_t m_seat; //0x0134
uint32_t m_action_mode_override; //0x0138
uint32_t unk_013C; // 0x013C
uint16_t m_vehicle; //0x0140
uint16_t m_mount_id; //0x0142
uint16_t m_custodian_id; //0x0144
uint16_t unk_0146; // 0x0146
bool m_tint_index; //0x0148
char pad_0149; //0x0149
uint8_t unk_014A; // 0x014A
bool m_is_handcuffed; //0x014B
bool m_can_preform_arrest; //0x014C
bool m_can_preform_uncuff; //0x014D
bool m_can_be_arrested; //0x014E
bool m_is_in_custody; //0x014F
char pad_0150; //0x0150
bool m_weapon_exists; //0x0151
bool m_weapon_visible; //0x0152
bool m_weapon_has_ammo; //0x0153
bool m_weapon_attach_left; //0x0154
char pad_0155; //0x0155
bool m_in_seat; //0x0156
bool m_in_vehicle; //0x0157
bool m_on_mount; //0x0158
bool m_has_custodian_or_arrest_flags; //0x0159
char pad_015A; //0x015A
bool m_action_mode_enabled; //0x015B
bool m_stealth_mode_enabled; //0x015C
bool unk_015D; // 0x015D
bool unk_015E; // 0x015E
bool unk_015F; // 0x015F
bool unk_0160; // 0x0160
bool unk_0161; // 0x0161
bool unk_0162; // 0x0162
bool unk_0163; // 0x0163
bool unk_0164; // 0x0164
bool unk_0165; // 0x0165
bool unk_0166; // 0x0166
bool unk_0167; // 0x0167
bool unk_0168; // 0x0168
bool unk_0169; // 0x0169
bool unk_016A; // 0x016A
bool unk_016B; // 0x016B
bool unk_016C; // 0x016C
bool unk_016D; // 0x016D
bool unk_016E; // 0x016E
bool unk_016F; // 0x016F
bool unk_0170; // 0x0170
bool unk_0171; // 0x0171
bool unk_0172; // 0x0172
}; //Size: 0x0174
static_assert(sizeof(CPedGameStateDataNode) == 0x178);
#pragma pack(pop)

28
netsync/nodes/ped/CPedHealthDataNode.hpp Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include <cstdint>
#pragma pack(push,2)
class CPedHealthDataNode : CSyncDataNodeInfrequent
{
public:
uint32_t unk_00C0; //0x00C0
uint32_t m_health; //0x00C4
uint32_t m_armor; //0x00C8
uint32_t unk_00CC; //0x00CC
uint32_t unk_00D0; //0x00D0
uint32_t m_weapon_damage_hash; //0x00D4
uint32_t m_hurt_end_time; //0x00D8
uint32_t m_weapon_damage_component; //0x00DC
uint16_t m_weapon_damage_entity; //0x00E0
bool m_has_max_health; //0x00E2
bool m_has_default_armor; //0x00E3
bool unk_00E4; //0x00E4
bool m_killed_with_headshot; //0x00E5
bool m_killed_with_melee; //0x00E6
char m_hurt_started; //0x00E7
bool unk_00E8; //0x00E8
bool unk_00E9; //0x00E9
}; //Size: 0x0EA
static_assert(sizeof(CPedHealthDataNode) == 0xEA);
#pragma pack(pop)

22
netsync/nodes/ped/CPedInventoryDataNode.hpp Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include <cstdint>
// todo?
#pragma pack(push, 4)
class CPedInventoryDataNode
{
public:
char pad_0000[5232];
uint32_t m_items[105];
uint32_t m_num_items;
uint32_t m_ammos[65];
uint32_t m_ammo_quantities[65];
uint32_t m_num_ammos;
uint8_t m_item_slot_tint[105];
uint8_t m_item_slot_num_components[105];
char pad_1680[1260];
bool m_infinite_ammos[65];
bool m_ammo_all_infinite;
};
static_assert(sizeof(CPedInventoryDataNode) == 0x1E24);
#pragma pack(pop)

17
netsync/nodes/ped/CPedMovementDataNode.hpp Normal file
View file

@ -0,0 +1,17 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPedMovementDataNode : CSyncDataNodeFrequent
{
public:
bool m_has_desired_move_blend_ratio_x; //0x00C0
bool m_has_desired_move_blend_ratio_y; //0x00C1
bool unk_00C2; //0x00C2
float m_desired_move_blend_ratio_x; //0x00C4
float m_desired_move_blend_ratio_y; //0x00C8
float unk_00CC; //0x00CC
float m_desired_pitch; //0x00D0
}; //Size: 0x00D4
static_assert(sizeof(CPedMovementDataNode) == 0xD4);
#pragma pack(pop)

24
netsync/nodes/ped/CPedMovementGroupDataNode.hpp Normal file
View file

@ -0,0 +1,24 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPedMovementGroupDataNode : CSyncDataNodeFrequent
{
public:
float m_unk; // 0xC0 (CTaskMotionInAutomobile+0x1EC)
uint32_t m_movement_task_index; // 0xC4
uint32_t m_movement_task_stage; // 0xC8
uint32_t m_movement_group; // 0xCC
uint32_t m_overridden_weapon_group; // 0xD0
uint32_t m_overridden_unk_group; // 0xD4 (SET_PED_ALTERNATE_MOVEMENT_ANIM?)
bool m_is_crouching; // 0xD8
bool m_is_stealthy; // 0xD9
bool m_is_strafing; // 0xDA
bool m_is_ragdolling; // 0xDB
bool m_is_ragdoll_constraint_ankle_active;// 0xDC
bool m_is_ragdoll_constraint_wrist_active;// 0xDD
char m_pad1[2]; // 0xDE
char m_tennis_data[0x20]; // 0xE0 TODO
};
static_assert(sizeof(CPedMovementGroupDataNode) == 0x100);
#pragma pack(pop)

14
netsync/nodes/ped/CPedOrientationDataNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPedOrientationDataNode : CSyncDataNodeFrequent
{
public:
bool m_has_desired_heading_x; //000C1
bool m_has_desired_heading_y; //000C2
float m_desired_heading_x; //0x00C4
float m_desired_heading_y; //0x00C8
};
static_assert(sizeof(CPedOrientationDataNode) == 0xCC);
#pragma pack(pop)

11
netsync/nodes/ped/CPedScriptCreationDataNode.hpp Normal file
View file

@ -0,0 +1,11 @@
#pragma once
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPedScriptCreationDataNode : CProjectBaseSyncDataNode
{
public:
bool m_stay_in_car_when_jacked; //0x00C0
}; //Size: 0x00C1
static_assert(sizeof(CPedScriptCreationDataNode) == 0xC4);
#pragma pack(pop)

25
netsync/nodes/ped/CPedTaskSequenceDataNode.hpp Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPedTaskSequenceData
{
public:
int m_task_type; // 0x00
int m_task_data_size; // 0x04
char m_task_data[602]; // 0x08
};
static_assert(sizeof(CPedTaskSequenceData) == 0x264);
class CPedTaskSequenceDataNode : CSyncDataNodeFrequent
{
public:
bool m_has_sequence; // 0xC0
int m_sequence_resource_id; // 0xC4
int m_num_tasks_in_sequence; // 0xC8
CPedTaskSequenceData m_task_data[10]; // 0xCC
int m_unk; // 0x18B4
};
static_assert(sizeof(CPedTaskSequenceDataNode) == 0x18B8);
#pragma pack(pop)

15
netsync/nodes/ped/CPedTaskSpecificDataNode.hpp Normal file
View file

@ -0,0 +1,15 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPedTaskSpecificDataNode : CSyncDataNodeFrequent
{
public:
uint32_t m_task_index; //0x00C0
uint32_t m_task_type; //0x00C4
uint32_t m_buffer_size; //0x00C8
uint8_t m_task_data_buffer[603]; //0x00CC
}; //Size: 0x0328
static_assert(sizeof(CPedTaskSpecificDataNode) == 0x328);
#pragma pack(pop)

26
netsync/nodes/ped/CPedTaskTreeDataNode.hpp Normal file
View file

@ -0,0 +1,26 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPedTaskData
{
public:
int m_task_type; // 0x00
int m_priority; // 0x04
int m_tree_depth; // 0x08
int m_sequence_id; // 0x0C
bool m_active; // 0x10
};
static_assert(sizeof(CPedTaskData) == 0x14);
class CPedTaskTreeDataNode : CSyncDataNodeFrequent
{
public:
CPedTaskData m_tasks[8]; // 0xC0
int m_task_bitset; // 0x160
int m_script_command; // 0x164
int m_script_command_stage; // 0x168
};
static_assert(sizeof(CPedTaskTreeDataNode) == 0x16C); // tree offset != size for this one
#pragma pack(pop)

14
netsync/nodes/physical/CPhysicalAngVelocityDataNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPhysicalAngVelocityDataNode : CSyncDataNodeFrequent
{
public:
int32_t m_ang_velocity_x; //0x00C0 Divide by 16.
int32_t m_ang_velocity_y; //0x00C4 Divide by 16.
int32_t m_ang_velocity_z; //0x00C8 Divide by 16.
}; // 0x00CC
static_assert(sizeof(CPhysicalAngVelocityDataNode) == 0xCC);
#pragma pack(pop)

31
netsync/nodes/physical/CPhysicalAttachDataNode.hpp Normal file
View file

@ -0,0 +1,31 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPhysicalAttachDataNode : CSyncDataNodeInfrequent
{
public:
bool m_attached; //0x00C0
bool unk_00C1; //0x00C1
uint16_t m_attached_to; //0x00C2
char pad_00C4[12]; //0x00C4
rage::fvector3 m_offset; //0x00D0
char pad_00DC[4]; //0x00DC
rage::fvector4 m_orientation; //0x00E0
rage::fvector3 m_parent_offset; //0x00F0
char pad_00FC[4]; //0x00FC
uint16_t m_other_attach_bone; //0x0100
uint16_t m_attach_bone; //0x0102
uint32_t m_attach_flags; //0x0104
bool m_allow_initial_separation; //0x0108
char pad_00109[3]; //0x0109
float unk_010C; //0x010C
float unk_0110; //0x0110
bool unk_0114; //0x0114
bool unk_0115; //0x0115
bool m_is_cargo_vehicle; //0x0116
}; //Size: 0x0118
static_assert(sizeof(CPhysicalAttachDataNode) == 0x118);
#pragma pack(pop)

19
netsync/nodes/physical/CPhysicalGameStateDataNode.hpp Normal file
View file

@ -0,0 +1,19 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPhysicalGameStateDataNode : CSyncDataNodeInfrequent
{
public:
bool m_is_visible; // 0xC0
bool m_flag2; // 0xC1
bool m_flag3; // 0xC2
bool m_flag4; // 0xC3
char m_pad; // 0xC4
uint32_t m_alpha_type; // 0xC8
int16_t m_custom_fade_duration; // 0xCC
bool m_unk5; // 0xCE
}; // 0x00CC
static_assert(sizeof(CPhysicalGameStateDataNode) == 0xD0);
#pragma pack(pop)

17
netsync/nodes/physical/CPhysicalHealthDataNode.hpp Normal file
View file

@ -0,0 +1,17 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 8)
struct CPhysicalHealthDataNode : CSyncDataNodeInfrequent
{
bool m_has_max_health; //0x00C0
bool m_has_max_health_changed; //0x00C1
uint32_t m_max_health; //0x00C4
uint32_t m_current_health; //0x00C8
uint16_t m_weapon_damage_entity; //0x00CC
uint32_t m_weapon_damage_hash; //0x00D0
uint64_t m_last_damaged_material_id; //0x00D8
};
static_assert(sizeof(CPhysicalHealthDataNode) == 0xE0);
#pragma pack(pop)

12
netsync/nodes/physical/CPhysicalMigrationDataNode.hpp Normal file
View file

@ -0,0 +1,12 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPhysicalMigrationDataNode : CProjectBaseSyncDataNode
{
public:
bool m_unk;
};
static_assert(sizeof(CPhysicalMigrationDataNode) == 0xC4);
#pragma pack(pop)

36
netsync/nodes/physical/CPhysicalScriptGameStateDataNode.hpp Normal file
View file

@ -0,0 +1,36 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPhysicalScriptGameStateDataNode : CSyncDataNodeInfrequent
{
public:
bool m_godmode;
bool m_dont_load_collision;
bool m_freeze_on_collision_load;
bool m_only_damaged_by_player;
bool m_bullet_proof;
bool m_fire_proof;
bool m_explosion_proof;
bool m_collision_proof;
bool m_melee_proof;
bool m_cannot_be_damaged_by_relationship_group;
bool m_can_only_be_damaged_by_relationship_group;
bool m_smoke_proof;
bool m_steam_proof;
bool m_can_only_be_damaged_by_participants;
bool m_dont_reset_proofs_on_cleanup_mission;
bool m_no_reassign;
bool m_pass_control_in_tutorial;
bool m_visible_in_cutscene;
bool m_visible_in_cutscene_remain_hack;
bool m_pickup_by_cargobob_disabled;
uint32_t m_relationship_group;
uint32_t m_always_cloned_for_players;
bool m_modified_max_speed;
bool m_trigger_damage_event_for_zero_damage;
float m_max_speed;
};
static_assert(sizeof(CPhysicalScriptGameStateDataNode) == 0xE4); // don't know the actual size of this one
#pragma pack(pop)

14
netsync/nodes/physical/CPhysicalScriptMigrationDataNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPhysicalScriptMigrationDataNode : CProjectBaseSyncDataNode
{
public:
bool m_has_data; // 0xC0
int m_script_participants; // 0xC4
uint16_t m_host_token; // 0xC8
};
static_assert(sizeof(CPhysicalScriptMigrationDataNode) == 0xCC);
#pragma pack(pop)

14
netsync/nodes/physical/CPhysicalVelocityDataNode.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPhysicalVelocityDataNode : CSyncDataNodeFrequent
{
public:
int32_t m_velocity_x; //0x00C0 Divide by 16.
int32_t m_velocity_y; //0x00C4 Divide by 16.
int32_t m_velocity_z; //0x00C8 Divide by 16.
}; // 0x00CC
static_assert(sizeof(CPhysicalVelocityDataNode) == 0xCC);
#pragma pack(pop)

27
netsync/nodes/pickup/CPickupCreationDataNode.hpp Normal file
View file

@ -0,0 +1,27 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "script/CGameScriptObjInfo.hpp"
#pragma pack(push, 8)
class CPickupCreationDataNode : CProjectBaseSyncDataNode
{
public:
bool m_has_placement; //0x00C0
char pad_00C1[7]; //0x00C1
CGameScriptObjInfo m_script_object_info; //0x00C8
uint32_t m_pickup_hash; //0x0118
uint32_t m_amount; //0x011C
uint32_t m_custom_model; //0x0120
uint32_t m_life_time; //0x0124
uint32_t m_weapon_component[12]; //0x0128
uint32_t m_num_weapon_components; //0x0154
uint32_t m_tint_index; //0x0158
bool m_player_gift; //0x015C
bool unk_015D; //0x015D
char pad_015E[6]; //0x015E
uint32_t unk_0164; //0x0164
bool unk_0168; //0x0168
}; //Size: 0x0170
static_assert(sizeof(CPickupCreationDataNode) == 0x170);
#pragma pack(pop)

24
netsync/nodes/pickup_placement/CPickupPlacementCreationDataNode.hpp Normal file
View file

@ -0,0 +1,24 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 8)
class CPickupPlacementCreationDataNode : CProjectBaseSyncDataNode
{
public:
bool m_has_pickup_data; //0x00C0
char pad_00C1[15]; //0x00C1
rage::fvector3 m_pickup_pos; //0x00D0
char pad_00DC[4]; //0x00DC
rage::fvector4 m_pickup_orientation; //0x00E0
uint32_t m_pickup_type; //0x00F0
uint32_t m_pickup_flags; //0x00F4
uint32_t m_amount; //0x00F8
uint32_t m_custom_model; //0x00FC
uint32_t m_custom_regeneration_time; //0x0100
uint32_t m_team_permits; //0x0104
uint64_t *unk_struct_0108; //0x0108
}; //Size: 0x0110
static_assert(sizeof(CPickupPlacementCreationDataNode) == 0x110);
#pragma pack(pop)

16
netsync/nodes/player/CPlayerAmbientModelStreamingNode.hpp Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPlayerAmbientModelStreamingNode : CSyncDataNodeInfrequent
{
public:
int m_allowed_ped_model_start_offset; // 0xC0
int m_allowed_vehicle_model_start_offset; // 0xC4
int m_vehicle_anim_streaming_target_entrypoint; // 0xC8
int16_t m_vehicle_anim_streaming_target; // 0xCC
};
static_assert(sizeof(CPlayerAmbientModelStreamingNode) == 0xD0);
#pragma pack(pop)

93
netsync/nodes/player/CPlayerAppearanceDataNode.hpp Normal file
View file

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

27
netsync/nodes/player/CPlayerCameraDataNode.hpp Normal file
View file

@ -0,0 +1,27 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 4)
class CPlayerCameraDataNode : CSyncDataNodeFrequent
{
public:
float m_free_cam_pos_x; //0x00C0
float m_free_cam_pos_y; //0x00C4
float m_free_cam_pos_z; //0x00C8
char pad_00CC[4]; //0x00CC
float m_lock_on_target_offset_x; //0x00D0
float m_lock_on_target_offset_y; //0x00D4
char pad_00D8[40]; //0x00D8
float m_camera_x; //0x0100
float m_camera_z; //0x0104
int16_t m_free_aim_locked_on_target; //0x0108
bool m_free_cam; //0x010A
char pad_010B[2]; //0x010B
bool m_has_position_offset; //0x010D
char pad_010E[1]; //0x010E
bool m_is_long_range_target; //0x010F
char pad_0110[48]; //0x0110
}; //Size: 0x0140
static_assert(sizeof(CPlayerCameraDataNode) == 0x140);
#pragma pack(pop)

19
netsync/nodes/player/CPlayerCreationDataNode.hpp Normal file
View file

@ -0,0 +1,19 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push,4)
class CPlayerCreationDataNode : CProjectBaseSyncDataNode
{
public:
uint32_t m_model; //0x00C0
uint32_t m_num_scars; //0x00C4
char unk_struct_0xC8[192]; //0x00C8
uint32_t unk_0188; //0x0188
char pad_018C[4]; //0x018C
char m_scar_struct[176]; //0x0190
bool unk_0240; //0x0240
char pad_0241[19]; //0x0241
}; //Size: 0x0254
static_assert(sizeof(CPlayerCreationDataNode) == 0x254);
#pragma pack(pop)

15
netsync/nodes/player/CPlayerExtendedGameStateNode.hpp Normal file
View file

@ -0,0 +1,15 @@
#pragma once
#include <cstdint>
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 1)
class CPlayerExtendedGameStateNode : CSyncDataNodeInfrequent
{
public:
float waypoint_x; //0x00C0
float waypoint_y; //0x00C4
uint16_t waypoint_entity; //0x00C5
bool has_active_waypoint; //0x00C6
bool owns_waypoint; //0x00C7
};
#pragma pack(pop)

148
netsync/nodes/player/CPlayerGameStateDataNode.hpp Normal file
View file

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

26
netsync/nodes/player/CPlayerGamerDataNode.hpp Normal file
View file

@ -0,0 +1,26 @@
#pragma once
#include <cstdint>
#include "network/ClanData.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#pragma pack(push, 8)
class CPlayerGamerDataNode : CSyncDataNodeInfrequent
{
public:
ClanData m_clan_data; //0x00C0
bool m_need_crew_rank_sysflags; //0x0178
bool m_need_crew_rank_title; //0x0179
char m_crew_rank_title[25]; //0x017A
bool m_has_started_transition; //0x0193
bool m_has_transition_info; //0x0194
char m_transition_info_buffer[169]; //0x0195
int m_player_privilege_flags; //0x0240
uint32_t m_matchmaking_group; //0x0244
bool m_need_mute_data; //0x0248
int32_t m_mute_count; //0x024C
int32_t m_mute_talkers_count; //0x0250
uint32_t m_unk; //0x0254
int32_t m_account_id; //0x0258
};
static_assert(sizeof(CPlayerGamerDataNode) == 0x260);
#pragma pack(pop)

35
netsync/nodes/player/CPlayerPedGroupDataNode.hpp Normal file
View file

@ -0,0 +1,35 @@
#pragma once
#include <cstdint>
#include "rage/vector.hpp"
#include "netsync/CProjectBaseSyncDataNode.hpp"
#include "ped/CPed.hpp"
#pragma pack(push, 8)
class CGroup;
class CGroupMember
{
public:
int16_t m_net_id;
CPed* m_ped; // this isn't serialized
};
static_assert(sizeof(CGroupMember) == 0x10);
class CPlayerPedGroupDataNode : CSyncDataNodeInfrequent
{
public:
char m_unused[0x10]; // 0xC0
CGroup* m_group; // 0xD0 (not serialized)
CGroupMember m_members[7]; // 0xD8
CGroupMember m_leader; // 0x148
char m_unused2[8]; // 0x158
float m_max_separation; // 0x160
char m_unused3[0xC]; // 0x164
int m_pop_type; // 0x170
bool m_needs_group_event_scan; // 0x175
char m_unused4[6]; // 0x176
int m_formation_type; // 0x17C
float m_formation_distance; // 0x180
char m_unused5[0xC]; // 0x184
};
static_assert(sizeof(CPlayerPedGroupDataNode) == 0x190);
#pragma pack(pop)

Some files were not shown because too many files have changed in this diff Show more