├── .gitignore ├── CMakeLists.txt ├── README.md ├── base ├── datBase.hpp ├── fwExtensibleBase.hpp ├── fwRefAwareBase.hpp ├── fwRefAwareBaseImpl.hpp └── pgBase.hpp ├── classes.cpp ├── entity ├── CDynamicEntity.hpp ├── CEntity.hpp └── fwEntity.hpp ├── event ├── CEvent.hpp ├── CEventGroup.hpp └── CEventInventoryItemPickedUp.hpp ├── network ├── CFriend.hpp ├── CNetGamePlayer.hpp ├── CNetObjectMgr.hpp ├── CNetworkPlayerMgr.hpp ├── CNetworkScObjMgr.hpp ├── CNetworkScServerConnection.hpp ├── CNetworkScSession.hpp ├── CNetworkScSessionMultiplayerImpl.hpp ├── CNetworkScSessionPlayer.hpp ├── CScriptedGameEvent.hpp ├── InFrame.hpp ├── netEncryption.hpp ├── netGameEvent.hpp ├── netObject.hpp ├── netPeerAddress.hpp ├── netPlayer.hpp ├── netPlayerMgrBase.hpp ├── netServerMessages.hpp ├── rlGamerHandle.cpp ├── rlGamerHandle.hpp ├── rlGamerInfo.hpp ├── rlGamerInfoBase.hpp ├── rlScPeerConnection.hpp ├── rlScSession.hpp ├── rlScSessionEvent.hpp ├── rlScSessionManagerImpl.hpp ├── rlScSessionMultiplayer.hpp ├── rlScSessionPeer.hpp ├── snConnectToPeerTask.hpp └── sync │ ├── CProjectBaseSyncDataNode.hpp │ ├── NodeCommonDataOperations.hpp │ ├── animal │ └── CAnimalCreationData.hpp │ ├── animscene │ ├── CAnimSceneCreationData.hpp │ └── CAnimSceneInfrequentData.hpp │ ├── netSyncDataNode.hpp │ ├── netSyncNodeBase.hpp │ ├── netSyncTree.hpp │ ├── object │ └── CObjectCreationData.hpp │ ├── ped │ ├── CPedAttachData.hpp │ ├── CPedCreationData.hpp │ ├── CPedHealthData.hpp │ ├── CPedTaskTreeData.hpp │ └── CPedVitalityData.hpp │ ├── physical │ └── CPhysicalAttachData.hpp │ ├── pickup │ └── CPickupCreationData.hpp │ ├── player │ ├── CPlayerAppearanceData.hpp │ ├── CPlayerCameraUncommonData.hpp │ ├── CPlayerCreationData.hpp │ ├── CPlayerGameStateUncommonData.hpp │ └── CPlayerHealthData.hpp │ ├── projectile │ └── CProjectileCreationData.hpp │ ├── propset │ └── CPropSetCreationData.hpp │ └── vehicle │ ├── CVehicleCreationData.hpp │ ├── CVehicleGadgetData.hpp │ └── CVehicleProximityMigrationData.hpp ├── ped └── CPed.hpp ├── physical └── CPhysical.hpp ├── player └── CPlayerInfo.hpp ├── rage ├── Guid.hpp ├── atArray.hpp ├── atDelegate.hpp ├── atPlayerBits.hpp ├── atUri.hpp ├── datBitBuffer.hpp ├── fwBasePool.hpp ├── joaat.hpp ├── pools.hpp ├── rlJson.hpp ├── rlMetric.hpp ├── rlTaskStatus.hpp ├── tlsContext.hpp └── vector.hpp ├── rdr2.rcnet ├── script ├── globals │ ├── ACEData.hpp │ ├── ACEHostData.hpp │ ├── FMEManagerHostData.hpp │ ├── FetchManagerHostData.hpp │ ├── GunForHireMissionData.hpp │ ├── MPHostData.hpp │ ├── NetCampHostData.hpp │ ├── PlayerPersonaData.hpp │ ├── PlayerStatusSyncData.hpp │ └── SessionManagerPlayerData.hpp ├── scrNativeHandler.hpp ├── scrProgram.hpp ├── scrThread.hpp ├── scrThreadContext.hpp ├── scrVector.hpp ├── scriptHandlerNetComponent.hpp ├── scriptId.hpp ├── scriptIdBase.hpp └── types.hpp └── train └── CTrainConfig.hpp /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode 2 | .vs 3 | build/ 4 | *.suo 5 | *.db 6 | *.db-shm 7 | *.db-wal 8 | *.opendb 9 | *.sln 10 | *.vcxproj 11 | *.user 12 | *.filters -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.11) 2 | 3 | project(RDR-Classes LANGUAGES CXX VERSION 0.0.1 DESCRIPTION "Reversed structures for Red Dead Redemption 2 PC") 4 | 5 | include(CheckIncludeFileCXX) 6 | 7 | set(CMAKE_CXX_EXTENSIONS OFF) 8 | set(CMAKE_CXX_STANDARD 20) 9 | set(CMAKE_CXX_STANDARD_REQUIRED ON) 10 | 11 | set(CMAKE_REQUIRED_QUIET ON) 12 | 13 | set(OK TRUE) 14 | 15 | file(GLOB_RECURSE HEADERS "**.hpp") 16 | file(GLOB_RECURSE SRC_MAIN "**.cpp") 17 | source_group(FILES "${SRC_MAIN}") 18 | add_library(RDR-Classes STATIC "${SRC_MAIN}" "${HEADERS}") 19 | set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20) 20 | add_compile_definitions(_CRT_SECURE_NO_WARNINGS) 21 | 22 | message(STATUS "") 23 | 24 | target_include_directories(RDR-Classes PRIVATE 25 | "${SRC_DIR}" 26 | ) 27 | 28 | if(NOT OK) 29 | file(READ "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/CMakeError.log" LOG) 30 | message(STATUS ${LOG}) 31 | endif() 32 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # RDR-Classes -------------------------------------------------------------------------------- /base/datBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | namespace rage 3 | { 4 | class datBase 5 | { 6 | public: 7 | virtual ~datBase() = default; 8 | }; //Size: 0x0008 9 | static_assert(sizeof(datBase) == 0x8); 10 | } -------------------------------------------------------------------------------- /base/fwExtensibleBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "fwRefAwareBase.hpp" 3 | 4 | namespace rage 5 | { 6 | class fwExtensibleBase : public fwRefAwareBase 7 | { 8 | public: 9 | void* m_ExtensionContainer; // 0x0010 10 | void* m_ExtensibleUnk; // 0x0018 11 | }; //Size: 0x0020 12 | static_assert(sizeof(fwExtensibleBase) == 0x20); 13 | } 14 | -------------------------------------------------------------------------------- /base/fwRefAwareBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "datBase.hpp" 3 | #include "fwRefAwareBaseImpl.hpp" 4 | 5 | namespace rage 6 | { 7 | class fwRefAwareBase : public fwRefAwareBaseImpl 8 | { 9 | }; 10 | static_assert(sizeof(fwRefAwareBase) == 0x10); 11 | } -------------------------------------------------------------------------------- /base/fwRefAwareBaseImpl.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rage 4 | { 5 | template 6 | class fwRefAwareBaseImpl : public T 7 | { 8 | private: 9 | void *m_Ref; // 0x08 10 | }; 11 | } -------------------------------------------------------------------------------- /base/pgBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage { 5 | 6 | class pgBase { 7 | public: 8 | virtual void ShutdownClass() = 0; 9 | virtual void SetHandleIndex(uint32_t index) = 0; 10 | virtual void Validate(uint32_t arg) = 0; 11 | virtual void InitClass(int arg) = 0; 12 | virtual uint32_t GetHandleIndex() const { return 0; } 13 | 14 | uintptr_t LookupMetaData(uint32_t index) const { 15 | uintptr_t current = reinterpret_cast(this); 16 | 17 | uintptr_t nextPage = *reinterpret_cast(current + 8); 18 | if (nextPage == 0) 19 | return 0; 20 | 21 | uint8_t pageStatus = *reinterpret_cast(nextPage + 11); 22 | if (pageStatus == 0) 23 | return 0; 24 | 25 | uintptr_t* metadataStart = reinterpret_cast(nextPage + 16); 26 | uintptr_t metadataCount = *reinterpret_cast(nextPage + 24); 27 | 28 | for (uintptr_t i = 0; i < metadataCount; ++i) { 29 | uintptr_t currentMeta = *(metadataStart + i); 30 | 31 | uint32_t metaIndex = *reinterpret_cast(currentMeta + 8); 32 | if (metaIndex == index) { 33 | return currentMeta; 34 | } 35 | } 36 | 37 | return 0; 38 | } 39 | 40 | bool HasPageMap() const { 41 | uintptr_t nextPage = *reinterpret_cast(reinterpret_cast(this) + 8); 42 | if (nextPage == 0) 43 | return false; 44 | 45 | uint8_t pageStatus = *reinterpret_cast(nextPage + 11); 46 | if (pageStatus == 0) 47 | return false; 48 | 49 | nextPage = 0; 50 | bool hasPageMap = (nextPage != 0); 51 | 52 | return hasPageMap; 53 | } 54 | 55 | bool MapContainsPointer(void* ptr) const { 56 | uintptr_t basePage = reinterpret_cast(this); 57 | uintptr_t nextPage = *reinterpret_cast(basePage + 8); 58 | if (nextPage == 0) 59 | return false; 60 | 61 | uint8_t pageStatus = *reinterpret_cast(nextPage + 11); 62 | if (pageStatus == 0) 63 | return false; 64 | 65 | uintptr_t* data = reinterpret_cast(nextPage + 16); 66 | uintptr_t count = *reinterpret_cast(nextPage + 8); 67 | 68 | for (uintptr_t i = 0; i < count; ++i) { 69 | uintptr_t elementPage = *(data + i); 70 | if (elementPage >= reinterpret_cast(ptr) && elementPage < reinterpret_cast(ptr) + 24) { 71 | return true; 72 | } 73 | } 74 | 75 | return false; 76 | } 77 | 78 | private: 79 | uint32_t m_MapSize; 80 | }; 81 | 82 | class pgBaseRefCounted : public pgBase { 83 | public: 84 | virtual ~pgBaseRefCounted() = default; 85 | }; 86 | 87 | class pgBaseMetaDataType { 88 | public: 89 | static pgBaseMetaDataType* m_First; 90 | 91 | pgBaseMetaDataType(uint32_t id, uintptr_t value) 92 | : m_Id(id), m_Value(value), m_Next(nullptr) { 93 | if (!m_First) { 94 | m_First = this; 95 | } 96 | } 97 | 98 | ~pgBaseMetaDataType() { 99 | if (m_First == this) { 100 | m_First = m_Next; 101 | } else { 102 | pgBaseMetaDataType* current = m_First; 103 | while (current && current->m_Next != this) { 104 | current = current->m_Next; 105 | } 106 | if (current) { 107 | current->m_Next = m_Next; 108 | } 109 | } 110 | } 111 | 112 | static pgBaseMetaDataType* Lookup(uint32_t id) { 113 | pgBaseMetaDataType* current = m_First; 114 | while (current != nullptr) { 115 | if (current->m_Id == id) { 116 | return current; 117 | } 118 | current = current->m_Next; 119 | } 120 | return nullptr; 121 | } 122 | 123 | private: 124 | uint32_t m_Id; 125 | uintptr_t m_Value; 126 | pgBaseMetaDataType* m_Next; 127 | }; 128 | 129 | } -------------------------------------------------------------------------------- /classes.cpp: -------------------------------------------------------------------------------- 1 | #include "base/datBase.hpp" 2 | #include "base/fwExtensibleBase.hpp" 3 | #include "base/fwRefAwareBase.hpp" 4 | #include "base/fwRefAwareBaseImpl.hpp" 5 | #include "base/pgBase.hpp" 6 | #include "entity/CDynamicEntity.hpp" 7 | #include "entity/CEntity.hpp" 8 | #include "entity/fwEntity.hpp" 9 | #include "event/CEvent.hpp" 10 | #include "event/CEventGroup.hpp" 11 | #include "event/CEventInventoryItemPickedUp.hpp" 12 | #include "network/CFriend.hpp" 13 | #include "network/CNetGamePlayer.hpp" 14 | #include "network/CNetworkPlayerMgr.hpp" 15 | #include "network/CNetworkScObjMgr.hpp" 16 | #include "network/CNetworkScServerConnection.hpp" 17 | #include "network/CNetworkScSession.hpp" 18 | #include "network/CNetworkScSessionMultiplayerImpl.hpp" 19 | #include "network/CNetworkScSessionPlayer.hpp" 20 | #include "network/CScriptedGameEvent.hpp" 21 | #include "network/InFrame.hpp" 22 | #include "network/netEncryption.hpp" 23 | #include "network/netGameEvent.hpp" 24 | #include "network/netObject.hpp" 25 | #include "network/netPeerAddress.hpp" 26 | #include "network/netPlayer.hpp" 27 | #include "network/netPlayerMgrBase.hpp" 28 | #include "network/netServerMessages.hpp" 29 | #include "network/rlGamerHandle.hpp" 30 | #include "network/rlGamerInfo.hpp" 31 | #include "network/rlGamerInfoBase.hpp" 32 | #include "network/rlScPeerConnection.hpp" 33 | #include "network/rlScSession.hpp" 34 | #include "network/rlScSessionEvent.hpp" 35 | #include "network/rlScSessionManagerImpl.hpp" 36 | #include "network/rlScSessionMultiplayer.hpp" 37 | #include "network/rlScSessionPeer.hpp" 38 | #include "network/snConnectToPeerTask.hpp" 39 | #include "network/sync/CProjectBaseSyncDataNode.hpp" 40 | #include "network/sync/NodeCommonDataOperations.hpp" 41 | #include "network/sync/netSyncDataNode.hpp" 42 | #include "network/sync/netSyncNodeBase.hpp" 43 | #include "network/sync/netSyncTree.hpp" 44 | #include "network/sync/animal/CAnimalCreationData.hpp" 45 | #include "network/sync/animscene/CAnimSceneCreationData.hpp" 46 | #include "network/sync/animscene/CAnimSceneInfrequentData.hpp" 47 | #include "network/sync/object/CObjectCreationData.hpp" 48 | #include "network/sync/ped/CPedAttachData.hpp" 49 | #include "network/sync/ped/CPedCreationData.hpp" 50 | #include "network/sync/ped/CPedHealthData.hpp" 51 | #include "network/sync/ped/CPedTaskTreeData.hpp" 52 | #include "network/sync/ped/CPedVitalityData.hpp" 53 | #include "network/sync/physical/CPhysicalAttachData.hpp" 54 | #include "network/sync/pickup/CPickupCreationData.hpp" 55 | #include "network/sync/player/CPlayerAppearanceData.hpp" 56 | #include "network/sync/player/CPlayerCameraUncommonData.hpp" 57 | #include "network/sync/player/CPlayerCreationData.hpp" 58 | #include "network/sync/player/CPlayerGameStateUncommonData.hpp" 59 | #include "network/sync/player/CPlayerHealthData.hpp" 60 | #include "network/sync/projectile/CProjectileCreationData.hpp" 61 | #include "network/sync/propset/CPropSetCreationData.hpp" 62 | #include "network/sync/vehicle/CVehicleCreationData.hpp" 63 | #include "network/sync/vehicle/CVehicleGadgetData.hpp" 64 | #include "network/sync/vehicle/CVehicleProximityMigrationData.hpp" 65 | #include "ped/CPed.hpp" 66 | #include "physical/CPhysical.hpp" 67 | #include "player/CPlayerInfo.hpp" 68 | #include "rage/Guid.hpp" 69 | #include "rage/atArray.hpp" 70 | #include "rage/atDelegate.hpp" 71 | #include "rage/atPlayerBits.hpp" 72 | #include "rage/atUri.hpp" 73 | #include "rage/datBitBuffer.hpp" 74 | #include "rage/fwBasePool.hpp" 75 | #include "rage/joaat.hpp" 76 | #include "rage/pools.hpp" 77 | #include "rage/rlJson.hpp" 78 | #include "rage/rlMetric.hpp" 79 | #include "rage/rlTaskStatus.hpp" 80 | #include "rage/tlsContext.hpp" 81 | #include "rage/vector.hpp" 82 | #include "script/globals/ACEData.hpp" 83 | #include "script/globals/ACEHostData.hpp" 84 | #include "script/globals/FetchManagerHostData.hpp" 85 | #include "script/globals/FMEManagerHostData.hpp" 86 | #include "script/globals/GunForHireMissionData.hpp" 87 | #include "script/globals/MPHostData.hpp" 88 | #include "script/globals/NetCampHostData.hpp" 89 | #include "script/globals/PlayerPersonaData.hpp" 90 | #include "script/globals/PlayerStatusSyncData.hpp" 91 | #include "script/globals/SessionManagerPlayerData.hpp" 92 | #include "script/scrNativeHandler.hpp" 93 | #include "script/scrThread.hpp" 94 | #include "script/scrThreadContext.hpp" 95 | #include "script/scrVector.hpp" 96 | #include "script/scriptHandlerNetComponent.hpp" 97 | #include "script/scriptId.hpp" 98 | #include "script/scriptIdBase.hpp" 99 | #include "script/scrProgram.hpp" 100 | #include "script/types.hpp" 101 | #include "train/CTrainConfig.hpp" 102 | -------------------------------------------------------------------------------- /entity/CDynamicEntity.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "entity/CEntity.hpp" 3 | 4 | class CPortalTracker 5 | { 6 | public: 7 | virtual ~CPortalTracker() = default; 8 | 9 | char m_Pad[0x90]; // 0x0008 10 | }; 11 | static_assert(sizeof(CPortalTracker) == 0x98); // TODO: confirm 12 | 13 | class CDynamicEntity : public CEntity 14 | { 15 | public: 16 | class rage::netObject* m_NetObject; // 0x00E0 17 | char m_Pad3[0x28]; // 0x00E8 18 | CPortalTracker m_PortalTracker; // 0x0110 19 | char m_Pad4[8]; // 0x01A8 20 | }; 21 | static_assert(sizeof(CDynamicEntity) == 0x1B0); -------------------------------------------------------------------------------- /entity/CEntity.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "entity/fwEntity.hpp" 3 | 4 | class CEntity : public rage::fwEntity 5 | { 6 | public: 7 | char m_Pad2[0x30]; // 0xB0 8 | }; 9 | static_assert(sizeof(CEntity) == 0xE0); -------------------------------------------------------------------------------- /entity/fwEntity.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../base/fwExtensibleBase.hpp" 4 | #include "rage/vector.hpp" 5 | 6 | class CMoveObjectPooledObject; 7 | class CNavigation; 8 | class CBaseModelInfo; 9 | 10 | namespace rage 11 | { 12 | class fwDrawData; 13 | class fwDynamicEntityComponent; 14 | class crmtRequestPose; 15 | class crmtRequestIk; 16 | class crFrameFilter; 17 | class fwAudEntity; 18 | class netObject; 19 | class fwEntity : public fwExtensibleBase 20 | { 21 | public: 22 | class CBaseModelInfo* m_ModelInfo; // 0x0020 23 | void* m_Unk; // 0x0028 24 | uint8_t m_EntityType; // 0x0030 25 | char m_Pad1[0x38]; // 0x0038 26 | rage::vector3 m_Position; // 0x0070 27 | char m_Pad0080[0x1C]; // 0x0080 28 | uint32_t m_ComponentIndex; // 0x009C 29 | char m_Pad2[0x10]; // 0x00A0 30 | 31 | uint32_t GetComponentIndex() const 32 | { 33 | return (m_ComponentIndex & 0x1FFFFu); 34 | } 35 | }; 36 | static_assert(sizeof(fwEntity) == 0xB0); 37 | } 38 | -------------------------------------------------------------------------------- /event/CEvent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CEvent 4 | { 5 | public: 6 | virtual ~CEvent() = default; 7 | virtual CEvent* Clone() { return nullptr; } 8 | virtual bool operator==(CEvent& other) { return false; } 9 | virtual int _0x18() { return 0; } 10 | virtual float _0x20() { return 0.0f; } 11 | virtual float _0x28() { return 0.0f; } 12 | virtual bool IsEventScriptCommand() { return false; } 13 | virtual bool ExtractData(void* data, int size) { return false; } 14 | 15 | char m_Pad[0x58]; 16 | }; 17 | static_assert(sizeof(CEvent) == 0x60); -------------------------------------------------------------------------------- /event/CEventGroup.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CEvent; 4 | class CEventGroup 5 | { 6 | public: 7 | virtual ~CEventGroup() = default; 8 | virtual void AddEvent(CEvent* event, bool) = 0; 9 | virtual void Cleanup() = 0; 10 | virtual int GetEventGroupType() = 0; 11 | }; 12 | 13 | class CEventGroupNetwork : public CEventGroup 14 | { 15 | }; -------------------------------------------------------------------------------- /event/CEventInventoryItemPickedUp.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "CEvent.hpp" 3 | #include "script/types.hpp" 4 | 5 | class CEventInventoryItemPickedUp : public CEvent 6 | { 7 | SCR_INT m_Unk; 8 | SCR_INT m_RewardHash; 9 | SCR_INT m_ItemHash; 10 | SCR_BOOL m_Unk2; 11 | SCR_BOOL m_Unk3; 12 | PICKUP_INDEX m_Pickup; 13 | }; 14 | static_assert(sizeof(CEventInventoryItemPickedUp) == 0x90); -------------------------------------------------------------------------------- /network/CFriend.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CFriend 5 | { 6 | public: 7 | std::uint64_t m_RockstarId; 8 | char m_Pad[0x8]; 9 | char m_Name[24]; 10 | }; -------------------------------------------------------------------------------- /network/CNetGamePlayer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "netPlayer.hpp" 3 | 4 | class CPlayerInfo; 5 | class CNetGamePlayer : public rage::netPlayer 6 | { 7 | public: 8 | CPlayerInfo* m_PlayerInfo; //0x0128 9 | char pad_0130[2432]; //0x0130 10 | }; //Size: 0x0AB0 11 | static_assert(sizeof(CNetGamePlayer) == 0xAB0); -------------------------------------------------------------------------------- /network/CNetObjectMgr.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "CNetGamePlayer.hpp" 3 | #include "netObject.hpp" 4 | #include "rage/datBitBuffer.hpp" 5 | 6 | #include 7 | 8 | #pragma pack(push, 8) 9 | class CNetworkObjectMgr 10 | { 11 | public: 12 | virtual ~CNetworkObjectMgr() = default; 13 | virtual void _0x8() = 0; 14 | virtual void Initialize() = 0; // 0x10 15 | virtual void Shutdown() = 0; 16 | virtual void Update(bool) = 0; 17 | virtual void AddEntity(void *, void *) = 0; 18 | virtual void UnregisterNetworkObject_(void *unk, bool force) = 0; 19 | virtual void UnregisterNetworkObject(rage::netObject *object, int reason, bool force1, bool force2) = 0; 20 | virtual void ChangeOwner(rage::netObject *object, CNetGamePlayer *player, int migrationType, bool unk) = 0; 21 | virtual void HandleJoiningPlayer(CNetGamePlayer *player) = 0; 22 | virtual void HandleLeavingPlayer(CNetGamePlayer *player) = 0; 23 | virtual void _0x50(CNetGamePlayer *player) = 0; 24 | virtual void _0x58() = 0; 25 | virtual void _0x60() = 0; 26 | virtual int _0x68() = 0; 27 | virtual void RegisterNetworkObject(rage::netObject *object) = 0; 28 | virtual void PackCloneCreate(rage::netObject *object, CNetGamePlayer *player, rage::datBitBuffer *buffer) = 0; 29 | virtual bool PackCloneRemove(rage::netObject *object, CNetGamePlayer *player, bool) = 0; 30 | virtual void PackCloneSync(rage::netObject *object, CNetGamePlayer *player) = 0; 31 | }; 32 | #pragma pack(pop) -------------------------------------------------------------------------------- /network/CNetworkPlayerMgr.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "netPlayerMgrBase.hpp" 3 | #include "CNetGamePlayer.hpp" 4 | 5 | #include 6 | #pragma pack(push, 8) 7 | class CNetworkPlayerMgr : public rage::netPlayerMgrBase 8 | { 9 | public: 10 | CNetGamePlayer m_PlayerStorage[32]; // 0x08E0 11 | CNetGamePlayer* m_FirstPlayer; // 0x15EE0 12 | CNetGamePlayer* m_LastPlayer; // 0x15EE8 13 | std::uint64_t m_UnkCounter; // 0x15EF0 14 | }; 15 | static_assert(sizeof(CNetworkPlayerMgr) == 0x15EF8); 16 | #pragma pack(pop) -------------------------------------------------------------------------------- /network/CNetworkScObjMgr.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rage/atPlayerBits.hpp" 4 | 5 | class CNetworkScObjMgr 6 | { 7 | public: 8 | virtual ~CNetworkScObjMgr() = default; 9 | 10 | char pad[20]; 11 | std::uint32_t m_State; 12 | rage::atPlayerBits m_PlayersInScope; 13 | rage::atPlayerBits m_TimedOutPlayers; 14 | rage::atPlayerBits m_PlayersReadyForIdRemap; 15 | rage::atPlayerBits m_PlayersDistributedObjects; 16 | rage::atPlayerBits m_PlayersAckedFinalDistributeObjects; 17 | rage::atPlayerBits m_PlayersReadyForObjectRemap; 18 | rage::atPlayerBits m_PlayersCompletedDistributingObjects; 19 | rage::atPlayerBits m_PlayersReadyToRestartObjectRemap; 20 | char pad40[240]; 21 | }; 22 | static_assert(sizeof(CNetworkScObjMgr) == 0x130); -------------------------------------------------------------------------------- /network/CNetworkScServerConnection.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rlScSessionManagerImpl.hpp" 3 | 4 | class CNetworkScServerConnection 5 | { 6 | public: 7 | virtual ~CNetworkScServerConnection() = default; 8 | 9 | char m_Pad[0x78]; 10 | rage::rlScSessionManagerImpl m_SessionManager; 11 | int dwordBB58; 12 | rage::rlScSessionId m_CurrentSessionId; 13 | std::uint64_t qwordBB70[2]; 14 | 15 | inline rage::rlScSession* GetCurrentSession() 16 | { 17 | auto& list = m_SessionManager.m_SessionPool; 18 | for (auto entry = list.m_First; entry; entry = entry->m_Next) 19 | { 20 | if (entry->m_Session.m_SessionId == m_CurrentSessionId) 21 | return &entry->m_Session; 22 | } 23 | 24 | return nullptr; 25 | } 26 | }; 27 | static_assert(sizeof(CNetworkScServerConnection) == 0xBB80); -------------------------------------------------------------------------------- /network/CNetworkScSession.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rlScSessionMultiplayer.hpp" 3 | #include "CNetworkScSessionMultiplayerImpl.hpp" 4 | #include "CNetworkScServerConnection.hpp" 5 | 6 | class CNetworkScSession 7 | { 8 | public: 9 | rage::rlScSessionMultiplayer* m_RlineSession; 10 | CNetworkScSessionMultiplayerImpl* m_SessionMultiplayer; 11 | void* m_NetLog; 12 | bool m_Initialized; 13 | }; 14 | static_assert(sizeof(CNetworkScSession) == 0x20); -------------------------------------------------------------------------------- /network/CNetworkScSessionMultiplayerImpl.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rage/atPlayerBits.hpp" 4 | #include "CNetworkScObjMgr.hpp" 5 | #include "CNetworkScSessionPlayer.hpp" 6 | #include "rlGamerHandle.hpp" 7 | 8 | class CNetworkScSession; 9 | 10 | namespace rage 11 | { 12 | class rlScSessionVolumeLockData 13 | { 14 | public: 15 | virtual ~rlScSessionVolumeLockData() = default; 16 | 17 | char m_Pad[56]; 18 | }; 19 | } 20 | 21 | class CNetworkScVolumeLocksImpl 22 | { 23 | public: 24 | virtual ~CNetworkScVolumeLocksImpl() = default; 25 | 26 | char m_Pad[8]; 27 | rage::rlScSessionVolumeLockData m_Data[128]; 28 | }; 29 | static_assert(sizeof(CNetworkScVolumeLocksImpl) == 0x2010); 30 | 31 | class CNetworkPopulationResetMgr 32 | { 33 | public: 34 | char pad[0x28]; 35 | rage::atPlayerBits m_PlayersInScope; 36 | uint32_t dword2C; 37 | rage::atPlayerBits m_PlayersReady; 38 | uint32_t gap34; 39 | uint32_t dword38; 40 | rage::atPlayerBits m_PlayersFinished; 41 | rage::atPlayerBits m_TimedOutPlayers; 42 | }; 43 | 44 | class CNetworkScSessionMultiplayerImpl 45 | { 46 | public: 47 | virtual ~CNetworkScSessionMultiplayerImpl() = default; 48 | 49 | rage::rlScSessionMultiplayer* m_SessionOwner; 50 | CNetworkScSession* m_NetworkSession; 51 | void* m_NetLog; 52 | uint32_t m_SessionState; 53 | int m_SessionEnterTime; 54 | char pad1[0x10]; 55 | char m_TerminatePopulationReset; 56 | CNetworkScSessionPlayer* m_Players[32]; 57 | CNetworkScObjMgr m_ObjectMgr; 58 | int m_LastTimeCheckedPeerComplaints[32]; 59 | uint32_t m_MergeId; 60 | uint32_t dword2F4; 61 | uint64_t qword2F8; 62 | rage::atPlayerBits m_PendingInitializationPlayers; 63 | rage::atPlayerBits dword304; 64 | rage::atPlayerBits dword308; 65 | rage::atPlayerBits m_PlayersReadyForGameSync; 66 | rage::atPlayerBits m_PlayersAckedReadyForGameSync; 67 | char gap315[12]; 68 | CNetworkScVolumeLocksImpl m_VolumeLocks; 69 | char m_AutoSession[0xA8]; // CAutoSession 70 | CNetworkPopulationResetMgr m_PopulationResetMgr; 71 | uint64_t qword2420; 72 | char m_GangManager[0x3070]; // CScGangManager 73 | char pad2[0x30]; 74 | char m_ScriptShuttingDownForMerge; 75 | uint32_t m_ScriptShutdownMergeId; 76 | rage::atPlayerBits m_PlayersReadyForScriptShutdown; 77 | char pad3[0x20]; 78 | int m_LastJoinConfirmUpdateTime; 79 | int m_LastSessionChangeEventTime; 80 | uint64_t qword54FC; 81 | uint32_t dword5504; 82 | 83 | inline CNetworkScSessionPlayer* GetPlayerByHandle(const rage::rlGamerHandle& handle) 84 | { 85 | for (int i = 0; i < 32; i++) 86 | { 87 | if (m_Players[i] && m_Players[i]->m_GamerInfo.m_GamerHandle2 == handle) 88 | return m_Players[i]; 89 | } 90 | 91 | return nullptr; 92 | } 93 | 94 | inline CNetworkScSessionPlayer* GetPlayerByIndex(int index) 95 | { 96 | return m_Players[index]; // this works? 97 | } 98 | }; 99 | static_assert(sizeof(CNetworkScSessionMultiplayerImpl) == 0x5510); -------------------------------------------------------------------------------- /network/CNetworkScSessionPlayer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rlGamerInfo.hpp" 3 | 4 | class CNetGamePlayer; 5 | class CNetworkScSessionMultiplayerImpl; 6 | 7 | namespace rage 8 | { 9 | class rlScSessionPeer; 10 | } 11 | 12 | class CNetworkScSessionPlayer 13 | { 14 | public: 15 | CNetworkScSessionMultiplayerImpl* m_MultiplayerSession; 16 | rage::rlScSessionPeer* m_SessionPeer; 17 | char m_PlayerIndex; 18 | rage::rlGamerInfo m_GamerInfo; 19 | rage::rlGamerInfoBase m_PeerAddr; 20 | char m_NetPlayerData[224]; // CNetGamePlayerDataMsg 21 | bool m_HasGamerInfo; 22 | char m_GamerInfoUpdated; 23 | int m_ComplainedReasons; 24 | int m_ComplaintUnkReason; 25 | int m_TimeoutReason; 26 | char m_ComplaintData[224]; 27 | bool m_HasOurGamerInfo; 28 | bool m_Initialized; 29 | CNetGamePlayer* m_NetGamePlayer; 30 | int m_NameProfanityCheckId; 31 | char m_NameProfanityCheckComplete; 32 | }; 33 | static_assert(sizeof(CNetworkScSessionPlayer) == 0x370); -------------------------------------------------------------------------------- /network/CScriptedGameEvent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "netGameEvent.hpp" 3 | #include "script/scriptId.hpp" 4 | #include "rage/atPlayerBits.hpp" 5 | 6 | #pragma pack(push, 8) 7 | class CScriptedGameEvent : public rage::netGameEvent 8 | { 9 | public: 10 | CGameScriptId m_ScriptId; // 0x38 11 | int m_DataSize; // 0x60 12 | bool m_Unk; // 0x64 (netComponent && *(netComponent + 0x16C) == 32) 13 | bool m_ScriptIdOverridden; // 0x65 14 | bool m_HasScriptMetadataIdx; // 0x66 15 | std::uint64_t m_Data[54]; // 0x68 16 | rage::atPlayerBits m_ReceiverBits; // 0x218 17 | int m_ScriptMetadataIndex; // 0x21C 18 | int m_ScriptHash; // 0x220 19 | int16_t m_Status; // 0x224 20 | }; 21 | #pragma pack(pop) 22 | static_assert(sizeof(CScriptedGameEvent) == 0x228); -------------------------------------------------------------------------------- /network/InFrame.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "netPeerAddress.hpp" 4 | 5 | namespace rage 6 | { 7 | class netConnection 8 | { 9 | public: 10 | #pragma pack(push, 8) 11 | class InFrame 12 | { 13 | public: 14 | enum class EventType 15 | { 16 | ConnectionClosed = 4, 17 | FrameReceived = 5, 18 | BandwidthExceeded = 6, 19 | OutOfMemory = 7 20 | }; 21 | 22 | virtual ~InFrame() = default; 23 | 24 | virtual void Destroy() = 0; 25 | virtual EventType GetEventType() = 0; 26 | virtual uint32_t _0x18() = 0; 27 | 28 | char pad_0[0x38]; // 0x8 29 | InFrame* m_This; // 0x40 30 | int m_MsgId; // 0x48 31 | char m_Unk; // 0x4C 32 | int m_ConnectionId; // 0x50 33 | netPeerAddress m_Address; // 0x58 34 | uint32_t m_Length; // 0x78 35 | void* m_Data; // 0x80 36 | }; 37 | static_assert(sizeof(InFrame) == 0x88); 38 | }; 39 | #pragma pack(pop) 40 | } -------------------------------------------------------------------------------- /network/netEncryption.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage 5 | { 6 | class netEncryptionOverride 7 | { 8 | public: 9 | char m_OverrideKey[33]; 10 | std::uint8_t m_EncryptionFlags; 11 | }; 12 | } -------------------------------------------------------------------------------- /network/netGameEvent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CNetGamePlayer; 5 | namespace rage 6 | { 7 | class netGameEvent 8 | { 9 | public: 10 | virtual ~netGameEvent() = 0; // 0x00 11 | 12 | std::int16_t m_EventType; // 0x08 13 | bool m_RequiresReply; // 0x0A 14 | char m_Pad1[0xD]; // 0x0B 15 | class CNetGamePlayer* m_Sender; // 0x18 16 | char m_Pad2[0x18]; // 0x20 17 | }; 18 | static_assert(sizeof(rage::netGameEvent) == 0x38); 19 | } -------------------------------------------------------------------------------- /network/netObject.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CObject; 5 | namespace rage 6 | { 7 | class netObject 8 | { 9 | public: 10 | #pragma pack(push, 1) 11 | struct GUID 12 | { 13 | std::uint64_t m_Data1; 14 | std::uint64_t m_Data2; 15 | 16 | std::uint32_t GetAccountId() const 17 | { 18 | return m_Data2 & 0xFFFFFFFF; 19 | } 20 | 21 | std::uint16_t GetAccountComponent() const 22 | { 23 | return (m_Data2 >> 32) & 0xFFFF; 24 | } 25 | 26 | std::uint64_t GetCreationTime() const 27 | { 28 | return m_Data1 & 0xFFFFFFFFFFFF; 29 | } 30 | 31 | std::uint16_t GetObjectToken() const 32 | { 33 | return m_Data1 >> 48; 34 | } 35 | 36 | std::uint16_t GetObjectType() const 37 | { 38 | return (m_Data2 >> 48) & 0xFF; 39 | } 40 | 41 | std::uint8_t GetCreationCycle() const 42 | { 43 | return m_Data2 >> 56; 44 | } 45 | }; 46 | #pragma pack(pop) 47 | 48 | virtual ~netObject() = 0; 49 | 50 | char m_Pad[0x38]; // 0x08 51 | uint16_t m_ObjectType; // 0x40 52 | uint16_t m_ObjectId; // 0x42 53 | uint8_t m_Unk; // 0x44 54 | uint8_t m_OwnerId; // 0x45 55 | uint8_t m_MigratingOwnerId; // 0x46 56 | bool m_IsRemotelyControlled; // 0x47 57 | char m_Pad2[0xA8]; // 0x48 58 | int m_OwnershipToken; // 0xF0 59 | char m_Pad3[0x14]; // 0xF4 60 | GUID m_Guid; // 0x108 61 | }; 62 | static_assert(sizeof(rage::netObject) == 0x118); 63 | } -------------------------------------------------------------------------------- /network/netPeerAddress.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | union netAddress { 5 | uint32_t m_packed; //0x0000 6 | struct { 7 | uint8_t m_field4; //0x0000 8 | uint8_t m_field3; //0x0001 9 | uint8_t m_field2; //0x0002 10 | uint8_t m_field1; //0x0003 11 | }; 12 | }; //Size: 0x0004 13 | static_assert(sizeof(netAddress) == 0x04); 14 | 15 | namespace rage 16 | { 17 | #pragma pack(push, 8) 18 | class netPeerAddress 19 | { 20 | public: 21 | netAddress m_internal_ip; //0x0000 22 | uint16_t m_internal_port; //0x0004 23 | netAddress m_external_ip; //0x0008 24 | uint16_t m_external_port; //0x000C 25 | uint64_t m_peer_id; //0x0010 26 | netAddress m_relay_address; //0x0018 27 | uint16_t m_relay_port; //0x001C 28 | uint8_t m_connection_type; //0x001E 29 | }; 30 | static_assert(sizeof(netPeerAddress) == 0x20); 31 | #pragma pack(pop) 32 | } -------------------------------------------------------------------------------- /network/netPlayer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage 5 | { 6 | class rlGamerInfo; 7 | class netPlayer 8 | { 9 | public: 10 | virtual ~netPlayer() = default; // 0x00 11 | virtual void Initialize(void* unk, int message_id, int unk2) {}; // 0x08 12 | virtual void Initialize2(int unk) {}; // 0x10 13 | virtual void Reset() {}; // 0x18 14 | virtual bool IsValid() { return false; }; // 0x20 15 | virtual const char* GetName() { return nullptr; }; // 0x28 16 | virtual void* GetUnk() { return nullptr; }; // 0x30 17 | virtual void SetTeam(int new_team) {}; // 0x38 18 | virtual bool IsSameTeam(netPlayer* other) { return false; }; // 0x40 19 | virtual void _0x48() {}; // 0x48 some posse stuff 20 | virtual void RefreshData() {}; // 0x50 21 | virtual bool IsHost() { return true; }; // 0x58 22 | virtual rage::rlGamerInfo* GetGamerInfo() { return nullptr; }; // 0x60 23 | 24 | char pad_0008[12]; //0x0008 25 | uint32_t m_MessageId; //0x0014 26 | uint8_t m_ActiveIndex; //0x0018 27 | uint8_t m_PlayerIndex; //0x0019 28 | char pad_001A[10]; //0x001A 29 | uint32_t m_JoinTime; //0x0024 30 | char pad_0028[4]; //0x0028 31 | uint32_t m_Team; //0x002C 32 | char pad_0030[248]; //0x0030 33 | }; //Size: 0x0128 34 | static_assert(sizeof(rage::netPlayer) == 0x128); 35 | } -------------------------------------------------------------------------------- /network/netPlayerMgrBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CNetGamePlayer; 5 | class CNetGamePlayerDataMsg; 6 | class CNonPhysicalPlayerData; 7 | 8 | namespace rage 9 | { 10 | class rlGamerInfo; 11 | class netConnectionManager; 12 | #pragma pack(push, 8) 13 | // the same as GTA 1.63 14 | class netPlayerMgrBase 15 | { 16 | public: 17 | virtual ~netPlayerMgrBase() = default; 18 | virtual void Initialize() = 0; 19 | virtual void Shutdown() = 0; 20 | virtual void unk_0x18() = 0; 21 | virtual CNetGamePlayer* AddPlayer_raw(rage::rlGamerInfo* gamer_info, uint32_t a2, CNetGamePlayerDataMsg* player_data, CNonPhysicalPlayerData* non_physical_player_data) = 0; 22 | virtual void RemovePlayer(CNetGamePlayer* net_game_player) = 0; 23 | virtual void UpdatePlayerListsForPlayer(CNetGamePlayer* net_game_player) = 0; 24 | virtual CNetGamePlayer* AddPlayer(rage::rlGamerInfo* gamer_info, uint32_t a3, CNetGamePlayerDataMsg* player_data, CNonPhysicalPlayerData* non_physical_player_data) = 0; 25 | 26 | rage::netConnectionManager* m_NetConnectionManager; //0x0008 27 | uint64_t* m_NetBandwidthManager; //0x0010 28 | char pad_0018[208]; //0x0018 29 | CNetGamePlayer* m_LocalPlayer; //0x00E8 30 | char pad_00F0[144]; //0x00F0 31 | CNetGamePlayer* m_PlayerList[32]; //0x0180 (TODO: is this used?) 32 | uint16_t m_PlayerLimit; //0x0280 33 | char pad_0282[10]; //0x0282 34 | uint16_t m_PlayerCount; //0x028C 35 | char pad_0290[1618]; //0x0290 36 | }; //Size: 0x08E0 37 | static_assert(sizeof(netPlayerMgrBase) == 0x8E0); 38 | #pragma pack(pop) 39 | } -------------------------------------------------------------------------------- /network/netServerMessages.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage 5 | { 6 | class netRpcBuilder 7 | { 8 | public: 9 | virtual ~netRpcBuilder() = default; 10 | virtual int Unk() = 0; 11 | virtual void* GetData() = 0; 12 | virtual int GetSize() = 0; 13 | }; 14 | 15 | class netRpcReaderContext 16 | { 17 | public: 18 | void* m_Data; 19 | int m_Size; 20 | void* m_JsonReader; 21 | }; 22 | 23 | class netRpcReader 24 | { 25 | public: 26 | virtual ~netRpcReader() = default; 27 | virtual void _0x08() = 0; 28 | virtual void _0x10() = 0; 29 | virtual void _0x18() = 0; 30 | virtual void _0x20() = 0; 31 | virtual void _0x28() = 0; 32 | virtual void _0x30() = 0; 33 | virtual const char* GetName() = 0; 34 | virtual void _0x40() = 0; 35 | virtual void _0x48() = 0; 36 | virtual void _0x50() = 0; 37 | virtual void _0x58() = 0; 38 | virtual void _0x60() = 0; 39 | virtual void _0x68() = 0; 40 | virtual void _0x70() = 0; 41 | virtual netRpcReaderContext* GetContext() = 0; 42 | }; 43 | } -------------------------------------------------------------------------------- /network/rlGamerHandle.cpp: -------------------------------------------------------------------------------- 1 | #include "rlGamerHandle.hpp" 2 | #include "rage/datBitBuffer.hpp" 3 | 4 | bool rage::rlGamerHandle::Serialize(rage::datBitBuffer& buf) const 5 | { 6 | buf.Write(m_Platform, 8); 7 | if (m_Platform != 3) 8 | return false; 9 | buf.Write(m_RockstarId, 64, true); 10 | buf.Write(m_UnkData, 16); 11 | return true; 12 | } 13 | 14 | bool rage::rlGamerHandle::Deserialize(rage::datBitBuffer& buf) 15 | { 16 | m_Platform = buf.Read(8); 17 | if (m_Platform != 3) 18 | return false; 19 | m_RockstarId = buf.Read(64, true); 20 | m_UnkData = buf.Read(16); 21 | return true; 22 | } 23 | -------------------------------------------------------------------------------- /network/rlGamerHandle.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace rage 6 | { 7 | class datBitBuffer; 8 | 9 | #pragma pack(push,8) 10 | class rlGamerHandle 11 | { 12 | public: 13 | int64_t m_RockstarId; // 0x00 14 | uint16_t m_UnkData; // 0x08 15 | uint8_t m_Platform; // 0x0A 16 | 17 | inline rlGamerHandle() = default; 18 | 19 | inline rlGamerHandle(int64_t rockstar_id) : 20 | m_RockstarId(rockstar_id), 21 | m_Platform(3), 22 | m_UnkData(0) 23 | { 24 | } 25 | 26 | inline bool operator==(const rage::rlGamerHandle other) 27 | { 28 | return m_Platform == other.m_Platform && m_UnkData == other.m_UnkData && m_RockstarId == other.m_RockstarId && m_Platform == 3; 29 | } 30 | 31 | bool Serialize(rage::datBitBuffer& buf) const; 32 | bool Deserialize(rage::datBitBuffer& buf); 33 | }; //Size: 0x0010 34 | static_assert(sizeof(rlGamerHandle) == 0x10); 35 | #pragma pack(pop) 36 | } -------------------------------------------------------------------------------- /network/rlGamerInfo.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rlGamerInfoBase.hpp" 4 | 5 | #pragma pack(push, 8) 6 | namespace rage 7 | { 8 | class rlGamerInfo : public rage::rlGamerInfoBase 9 | { 10 | public: 11 | uint64_t m_HostToken; 12 | uint64_t m_PeerId2; 13 | rage::rlGamerHandle m_GamerHandle2; 14 | uint32_t m_ProfileIndex; 15 | char m_Name[21]; 16 | uint8_t m_Flags; 17 | }; 18 | static_assert(sizeof(rage::rlGamerInfo) == 0xD8); 19 | } 20 | #pragma pack(pop) 21 | -------------------------------------------------------------------------------- /network/rlGamerInfoBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rlGamerHandle.hpp" 4 | #include "netPeerAddress.hpp" 5 | 6 | #pragma pack(push, 8) 7 | namespace rage 8 | { 9 | class rlGamerInfoBase 10 | { 11 | public: 12 | uint64_t m_PeerId; 13 | rage::rlGamerHandle m_GamerHandle; 14 | char m_AesKey[33]; 15 | netAddress m_InternalAddress; 16 | uint16_t m_InternalPort; 17 | netAddress m_UnkAddress; 18 | uint16_t m_UnkPort; 19 | netAddress m_ExternalAddress; 20 | uint16_t m_ExternalPort; 21 | netAddress m_RelayAddress; 22 | uint16_t m_RelayPort; 23 | char gap5A[54]; // TODO: reverse this 24 | uint32_t m_RelayState; 25 | }; 26 | static_assert(sizeof(rage::rlGamerInfoBase) == 0x98); 27 | } 28 | #pragma pack(pop) 29 | -------------------------------------------------------------------------------- /network/rlScPeerConnection.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "snConnectToPeerTask.hpp" 3 | #include "rlGamerHandle.hpp" 4 | #include "rlGamerInfoBase.hpp" 5 | #include "rage/rlTaskStatus.hpp" 6 | #include "rage/atDelegate.hpp" 7 | 8 | namespace rage 9 | { 10 | class netConnectionManager; 11 | class rlScSessionPeer; 12 | 13 | class rlScPeerConnection 14 | { 15 | public: 16 | rage::atDelegate m_ConnectionSuccessful; 17 | rage::atDelegate m_ConnectionFailed; 18 | int m_State; 19 | int dword28; 20 | rage::snConnectToPeerTaskData m_ConnectToPeerData; 21 | rage::rlGamerInfoBase m_PeerAddress; 22 | rage::netConnectionManager* m_NetConnectionManager; 23 | char m_Unk[56]; 24 | rage::rlScSessionPeer* m_Peer; 25 | rage::rlTaskStatus m_TaskStatus; 26 | rage::snConnectToPeerTaskResult m_ConnectToPeerResult; 27 | int m_ConnectionMsgSize; 28 | char m_ConnectionMsgData[256]; 29 | int m_MessageId; 30 | char gap590[8]; 31 | int m_ConnectionId; 32 | int dword59C; 33 | }; 34 | static_assert(sizeof(rlScPeerConnection) == 0x5A0); 35 | } -------------------------------------------------------------------------------- /network/rlScSession.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rlScSessionPeer.hpp" 3 | 4 | namespace rage 5 | { 6 | class rlScSessionManagerImpl; 7 | class rlScSessionId 8 | { 9 | public: 10 | uint64_t m_Id; 11 | uint64_t m_Token; 12 | 13 | inline bool operator==(const rlScSessionId other) 14 | { 15 | return m_Id == other.m_Id && m_Token == other.m_Token; 16 | } 17 | }; 18 | static_assert(sizeof(rlScSessionId) == 0x10); 19 | using rlScSessionRequestId = rlScSessionId; // for now 20 | 21 | class rlScSessionPeerPoolEntry 22 | { 23 | public: 24 | rlScSessionPeerPoolEntry* m_Next; 25 | rlScSessionPeerPoolEntry* m_Prev; 26 | rage::rlScSessionPeer m_Peer; 27 | }; 28 | 29 | class rlScSessionPeerPool 30 | { 31 | public: 32 | rlScSessionPeerPoolEntry m_Entries[64]; 33 | rlScSessionPeerPoolEntry* m_Next; 34 | rlScSessionPeerPoolEntry* m_Last; 35 | rlScSessionPeerPoolEntry* m_First; 36 | rlScSessionPeerPoolEntry* qwordE18; 37 | int m_NumPeers; 38 | }; 39 | static_assert(sizeof(rlScSessionPeerPool) == 0xE28); 40 | 41 | class rlScSession 42 | { 43 | public: 44 | rage::rlScSessionId m_SessionId; 45 | char gap10[16]; 46 | rage::rlScSessionManagerImpl* m_SessionManager; 47 | int m_SlotCount; 48 | rage::rlScSessionPeerPool m_PeerPool; 49 | int m_HostPeerIndex; 50 | int m_LocalPeerIndex; 51 | char gapE60[4]; 52 | int m_PendingFlags; 53 | int m_Flags; 54 | int dwordE6C; 55 | int m_LastFlagUpdateTime; 56 | char pad[44]; 57 | 58 | inline rage::rlScSessionPeer* GetPeerByHandle(rage::rlGamerHandle& handle) 59 | { 60 | for (auto entry = m_PeerPool.m_First; entry; entry = entry->m_Next) 61 | { 62 | if (entry->m_Peer.m_Identifier.m_Handle == handle) 63 | return &entry->m_Peer; 64 | } 65 | 66 | return nullptr; 67 | } 68 | 69 | inline rage::rlScSessionPeer* GetPeerByIndex(int index) 70 | { 71 | for (auto entry = m_PeerPool.m_First; entry; entry = entry->m_Next) 72 | { 73 | if (entry->m_Peer.m_PeerIndex == index) 74 | return &entry->m_Peer; 75 | } 76 | 77 | return nullptr; 78 | } 79 | 80 | inline bool IsHost() 81 | { 82 | if (m_LocalPeerIndex >= 0) 83 | return m_LocalPeerIndex == m_HostPeerIndex; 84 | 85 | return false; 86 | } 87 | 88 | inline rage::rlScSessionPeer* GetHostPeer() 89 | { 90 | if (m_HostPeerIndex < 0) 91 | return nullptr; 92 | 93 | return GetPeerByIndex(m_HostPeerIndex); 94 | } 95 | }; 96 | } -------------------------------------------------------------------------------- /network/rlScSessionEvent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rage/atUri.hpp" 3 | #include "rlGamerHandle.hpp" 4 | #include "rlGamerInfoBase.hpp" 5 | #include "rlScSession.hpp" 6 | 7 | 8 | #pragma pack(push, 8) 9 | namespace rage { 10 | enum class SessionEvent : std::uint32_t { 11 | LEAVE_SESSION = 6, 12 | ADD_PLAYER = 7, 13 | REMOVE_PLAYER = 8, 14 | HOST_CHANGED = 9, 15 | QUEUE_ERROR = 17, 16 | LOCALIZED_MESSAGE = 19, 17 | CONFIG_PARAM = 20, 18 | INVITE_RESULT = 21, 19 | INVITE_QUEUED = 22, 20 | TRANSITION_READY_INVITE = 28, 21 | TRANSITION_READY_PLAYER_QUEUE = 29, 22 | KEEP_ALIVE_REQUEST = 30, 23 | COMPLAINT_RECEIVED = 31, 24 | QUEUE_ENTERED = 32, 25 | PREPARE_SERVER_TRANSFER = 33, 26 | SERVER_TRANSFER_RESULT = 34, 27 | TRANSITION_READY_SERVER_TRANSFER = 35, 28 | TRANSFER_TO_SERVER = 36, 29 | PAUSE_FOR_SERVER_TRANSFER = 37, 30 | ADMIN_SECURITY_INVITE = 38 31 | }; 32 | 33 | class rlScSessionEvent { 34 | public: 35 | virtual ~rlScSessionEvent() = default; 36 | 37 | SessionEvent m_EventType; 38 | 39 | template inline T *As() { return (T *)this; } 40 | }; 41 | static_assert(sizeof(rage::rlScSessionEvent) == 0x10); 42 | 43 | class rlScLeaveSessionEvent : public rlScSessionEvent { 44 | public: 45 | rage::rlScSessionId m_SessionId; 46 | int m_Reason; 47 | int m_Reason2; 48 | int m_PlayerCount; 49 | }; 50 | static_assert(sizeof(rage::rlScLeaveSessionEvent) == 0x30); 51 | 52 | class rlScAddPlayerEvent : public rlScSessionEvent { 53 | public: 54 | rage::rlScSessionId m_SessionId; 55 | rage::rlScSessionPeerIdentifier m_Identifier; 56 | rage::rlGamerInfoBase m_PeerAddress; 57 | }; 58 | static_assert(sizeof(rage::rlScAddPlayerEvent) == 0xD0); 59 | 60 | class rlScRemovePlayerEvent : public rlScSessionEvent { 61 | public: 62 | rage::rlScSessionId m_SessionId; 63 | rage::rlScSessionPeerIdentifier m_Identifier; 64 | }; 65 | static_assert(sizeof(rage::rlScRemovePlayerEvent) == 0x38); 66 | 67 | class rlScHostChangedEvent : public rlScSessionEvent { 68 | public: 69 | rage::rlScSessionId m_SessionId; 70 | int m_OldIndex; 71 | int m_NewIndex; 72 | }; 73 | static_assert(sizeof(rage::rlScHostChangedEvent) == 0x28); 74 | 75 | class rlScComplaintReceivedEvent : public rlScSessionEvent { 76 | public: 77 | rage::rlGamerHandle m_Complainer; 78 | }; 79 | static_assert(sizeof(rage::rlScComplaintReceivedEvent) == 0x20); 80 | 81 | class rlScQueueEnteredEvent : public rlScSessionEvent { 82 | public: 83 | rage::rlScSessionRequestId m_RequestId; 84 | int m_QueueGroup; 85 | int m_OptionFlags; 86 | }; 87 | static_assert(sizeof(rage::rlScQueueEnteredEvent) == 0x28); 88 | 89 | class rlScQueueErrorEvent : public rlScSessionEvent { 90 | public: 91 | rage::rlScSessionRequestId m_RequestId; 92 | int m_Reason; 93 | }; 94 | static_assert(sizeof(rage::rlScQueueErrorEvent) == 0x28); 95 | 96 | // not rlScLocalizedMessageEvent 97 | class rlScLocalizedMessage : public rlScSessionEvent { 98 | public: 99 | char m_Key[128]; 100 | }; 101 | static_assert(sizeof(rage::rlScLocalizedMessage) == 0x90); 102 | 103 | class rlScConfigParamEvent : public rlScSessionEvent { 104 | public: 105 | int m_NameHash; // TODO: reverse this 106 | char m_Value[32]; 107 | }; 108 | static_assert(sizeof(rage::rlScConfigParamEvent) == 0x38); 109 | 110 | class rlScAdminSecurityInviteEvent : public rlScSessionEvent { 111 | public: 112 | rage::rlGamerHandle m_Handle; 113 | int m_InviteId; 114 | int m_Flags; 115 | rage::atUri m_ServerUri; 116 | int m_SessionType; 117 | }; 118 | static_assert(sizeof(rage::rlScAdminSecurityInviteEvent) == 0x4B8); 119 | } // namespace rage 120 | #pragma pack(pop) -------------------------------------------------------------------------------- /network/rlScSessionManagerImpl.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rage/atUri.hpp" 3 | #include "rlScSession.hpp" 4 | 5 | namespace rage 6 | { 7 | class rlScSessionPoolEntry 8 | { 9 | public: 10 | rlScSessionPoolEntry* m_Next; 11 | rlScSessionPoolEntry* m_Prev; 12 | rage::rlScSession m_Session; 13 | }; 14 | 15 | class rlScSessionPool 16 | { 17 | public: 18 | rlScSessionPoolEntry m_Entries[4]; 19 | rlScSessionPoolEntry* m_Next; 20 | rlScSessionPoolEntry* m_Last; 21 | rlScSessionPoolEntry* m_First; 22 | rlScSessionPoolEntry* qword3AD8; 23 | int m_NumSessions; 24 | }; 25 | static_assert(sizeof(rlScSessionPool) == 0x3AE8); 26 | 27 | class rlScSessionManagerImpl 28 | { 29 | public: 30 | virtual ~rlScSessionManagerImpl() = default; 31 | 32 | char m_Pad[0x79F0]; 33 | rage::atUri m_ServerUri; 34 | rage::rlScSessionPool m_SessionPool; 35 | char m_Pad2[0x170]; 36 | }; 37 | static_assert(sizeof(rlScSessionManagerImpl) == 0xBAD8); 38 | } -------------------------------------------------------------------------------- /network/rlScSessionMultiplayer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CNetworkScSessionMultiplayerImpl; 5 | class CNetworkScServerConnection; 6 | 7 | namespace rage 8 | { 9 | #pragma pack(push, 8) 10 | struct rlScSessionMultiplayer 11 | { 12 | public: 13 | virtual ~rlScSessionMultiplayer() = default; 14 | 15 | uint64_t qword8; 16 | CNetworkScSessionMultiplayerImpl* m_SessionMultiplayer; 17 | uint64_t qword18; 18 | int16_t word20; 19 | char byte22; 20 | uint32_t dword24; 21 | char gap28[4184]; 22 | CNetworkScServerConnection* m_ServerConnection; 23 | void* m_NetConnectionManager; 24 | uint64_t qword1090; 25 | uint32_t m_SessionType; 26 | char gap109C[9176]; 27 | uint32_t m_ConnectionId; 28 | char gap347C[164]; 29 | }; 30 | static_assert(sizeof(rage::rlScSessionMultiplayer) == 0x3520); 31 | #pragma pack(pop) 32 | } -------------------------------------------------------------------------------- /network/rlScSessionPeer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rlGamerHandle.hpp" 4 | 5 | namespace rage 6 | { 7 | class rlScPeerConnection; 8 | class rlScSessionPeerIdentifier 9 | { 10 | public: 11 | std::uint32_t m_AccountId; 12 | rage::rlGamerHandle m_Handle; 13 | }; 14 | 15 | class rlScSessionPeer 16 | { 17 | public: 18 | rage::rlScPeerConnection* m_Connection; 19 | rage::rlScSessionPeerIdentifier m_Identifier; 20 | int m_PeerIndex; // 0 - 63 21 | bool m_IsHost; 22 | }; 23 | } -------------------------------------------------------------------------------- /network/snConnectToPeerTask.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage 5 | { 6 | #pragma pack(push, 8) 7 | class snConnectToPeerTaskData 8 | { 9 | public: 10 | int m_Unk; 11 | int m_Reason; 12 | uint64_t m_SessionToken; 13 | char m_Flags; 14 | }; 15 | static_assert(sizeof(rage::snConnectToPeerTaskData) == 0x18); 16 | #pragma pack(pop) 17 | 18 | class snConnectToPeerTaskResult 19 | { 20 | public: 21 | char pad[0x10]{}; 22 | int m_PeerId; 23 | char pad2[0x34C]{}; 24 | }; 25 | static_assert(sizeof(snConnectToPeerTaskResult) == 0x360); 26 | } -------------------------------------------------------------------------------- /network/sync/CProjectBaseSyncDataNode.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "netSyncDataNode.hpp" 3 | #include "NodeCommonDataOperations.hpp" 4 | 5 | namespace rage 6 | { 7 | class netSyncData; 8 | class netObject; 9 | } 10 | 11 | class CProjectBaseSyncDataNode : public rage::netSyncDataNode 12 | { 13 | private: 14 | NodeCommonDataOperations m_CommonDataOperations; // 0x120 15 | char m_Data[]; // 0x130 16 | 17 | public: 18 | #if _WIN32 19 | template 20 | T& GetData() 21 | { 22 | return *reinterpret_cast(&m_Data[rage::tlsContext::Get()->m_SyncThreadIndex * sizeof(T)]); 23 | } 24 | #endif 25 | }; 26 | static_assert(sizeof(CProjectBaseSyncDataNode) == 0x130); 27 | 28 | // We probably don't need these anymore 29 | //class CSyncDataNodeFrequent : public CProjectBaseSyncDataNode {}; 30 | //class CSyncDataNodeInfrequent : public CProjectBaseSyncDataNode {}; -------------------------------------------------------------------------------- /network/sync/NodeCommonDataOperations.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rage 4 | { 5 | class datBitBuffer; 6 | } 7 | 8 | class NodeCommonDataOperations 9 | { 10 | public: 11 | virtual ~NodeCommonDataOperations() = default; 12 | virtual void ReadFromBuffer(rage::datBitBuffer* buffer, void* log) {}; // 0x08 13 | virtual void WriteToBuffer(void* data_base, rage::datBitBuffer* buffer, void* log, bool cache) {}; // 0x10 14 | virtual void Unk() {}; // 0x18 15 | // TODO: 16 | virtual int CalculateSize(rage::datBitBuffer* buffer) { return 0; }; // 0x20 17 | virtual int CalculateSize2(rage::datBitBuffer* buffer) { return 0; }; // 0x28 18 | virtual void LogSyncData(rage::datBitBuffer* buffer) {}; // 0x30 19 | virtual void LogSyncData2(rage::datBitBuffer* buffer) {}; // 0x38 20 | rage::datBitBuffer* m_Buffer; // 0x8 21 | }; 22 | static_assert(sizeof(NodeCommonDataOperations) == 0x10); -------------------------------------------------------------------------------- /network/sync/animal/CAnimalCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | // TODO, CPedBaseCreationData 5 | class CAnimalCreationData 6 | { 7 | public: 8 | char pad_0000[4]; //0x0000 9 | uint32_t m_PopulationType; //0x0004 10 | uint32_t m_ModelHash; //0x0008 11 | char pad_000C[18]; //0x000C 12 | bool m_BannedPed; //0x001E 13 | char pad_001F[5]; //0x001F 14 | }; //Size: 0x0024 15 | static_assert(sizeof(CAnimalCreationData) == 0x24); -------------------------------------------------------------------------------- /network/sync/animscene/CAnimSceneCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CAnimSceneCreationData 5 | { 6 | public: 7 | uint32_t m_AnimDict; // 0x0000 8 | int32_t m_PlaybackListName; // 0x0004 9 | uint32_t m_Flags; // 0x0008 - TODO: fix this 10 | char m_Pad[116]; // 0x0012 11 | }; //Size: 0x0080 12 | static_assert(sizeof(CAnimSceneCreationData) == 0x80); -------------------------------------------------------------------------------- /network/sync/animscene/CAnimSceneInfrequentData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CAnimSceneSerializedVariable 4 | { 5 | public: 6 | enum class Type 7 | { 8 | Bool = 5, 9 | Float = 10, 10 | Int = 19 11 | }; 12 | 13 | std::uint32_t m_VariableName; 14 | Type m_Type; 15 | union 16 | { 17 | int m_Int; 18 | bool m_Bool; 19 | float m_Float; 20 | }; 21 | }; 22 | static_assert(sizeof(CAnimSceneSerializedVariable) == 0xC); 23 | 24 | class CAnimSceneSerializedEntityBase 25 | { 26 | public: 27 | virtual void Serialize(void*) {}; 28 | virtual void Reset() {}; 29 | 30 | std::uint32_t m_EntityName; 31 | bool m_TransferOwnership; 32 | }; 33 | static_assert(sizeof(CAnimSceneSerializedEntityBase) == 0x10); 34 | 35 | class CAnimSceneSerializedEntity : public CAnimSceneSerializedEntityBase 36 | { 37 | public: 38 | std::uint16_t m_ObjectId; 39 | bool m_Abort; 40 | }; 41 | static_assert(sizeof(CAnimSceneSerializedEntity) == 0x18); 42 | 43 | class CAnimSceneSerializedDoor : public CAnimSceneSerializedEntityBase 44 | { 45 | public: 46 | std::uint32_t m_DoorHash; 47 | }; 48 | static_assert(sizeof(CAnimSceneSerializedDoor) == 0x18); 49 | 50 | class CAnimSceneSerializedPlaybackList 51 | { 52 | public: 53 | virtual void Serialize(void*) {}; 54 | virtual void Reset() {}; 55 | 56 | std::uint32_t m_PlaybackList; 57 | float m_Time; 58 | }; 59 | static_assert(sizeof(CAnimSceneSerializedPlaybackList) == 0x10); 60 | 61 | class CAnimSceneInfrequentData 62 | { 63 | public: 64 | std::uint16_t m_NumEntities; 65 | std::uint16_t m_NumDoors; 66 | std::uint16_t m_NumVariables; 67 | std::uint16_t m_NumPlaybackLists; 68 | char m_Pad[0x50]; // origin, rotation, scene attachments 69 | CAnimSceneSerializedEntity m_Entities[32]; 70 | CAnimSceneSerializedDoor m_Doors[5]; 71 | CAnimSceneSerializedVariable m_Variables[32]; 72 | CAnimSceneSerializedPlaybackList m_PlaybackLists[9]; 73 | }; //Size: 0x05E0 74 | static_assert(sizeof(CAnimSceneInfrequentData) == 0x5E0); -------------------------------------------------------------------------------- /network/sync/netSyncDataNode.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "netSyncNodeBase.hpp" 4 | #include "rage/tlsContext.hpp" 5 | 6 | namespace rage 7 | { 8 | #pragma pack(push, 8) 9 | class netSyncDataNode : public netSyncNodeBase 10 | { 11 | struct ThreadData 12 | { 13 | bool m_Unk; 14 | bool m_NodeActive; 15 | }; 16 | static_assert(sizeof(ThreadData) == 2); 17 | 18 | public: 19 | uint32_t m_Flags; // 0x40 20 | uint32_t pad3; // 0x44 21 | uint64_t pad4; // 0x48 22 | netSyncDataNode* m_ParentData; // 0x50 23 | uint32_t m_MoreFlags; // 0x58 24 | netSyncDataNode* m_Children[19]; // 0x60 25 | ThreadData m_ThreadData[8]; // 0xF8 26 | char pad5[10]; // 0x110 27 | void* m_CommonDataOpsVFT; // 0x118 28 | 29 | #if _WIN32 30 | inline bool IsActive() 31 | { 32 | return m_ThreadData[rage::tlsContext::Get()->m_SyncThreadIndex].m_NodeActive; 33 | } 34 | #endif 35 | }; 36 | static_assert(sizeof(netSyncDataNode) == 0x120); 37 | #pragma pack(pop) 38 | } -------------------------------------------------------------------------------- /network/sync/netSyncNodeBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace rage 6 | { 7 | class datBitBuffer; 8 | class netSyncTree; 9 | 10 | #pragma pack(push, 8) 11 | class netSyncNodeBase 12 | { 13 | public: 14 | virtual ~netSyncNodeBase() = default; // 0x00 15 | virtual bool IsDataNode() = 0; // 0x08 16 | virtual bool IsParentNode() = 0; // 0x10 17 | virtual void MoveCommonDataOpsVFT() = 0; // 0x18 18 | virtual void ClearChildren() = 0; // 0x20 19 | virtual void _0x28(void*, void*, void*, int* out_count) = 0; // 0x28 20 | virtual bool Serialize(int flags, int flags2, void*, rage::datBitBuffer* buffer, int, void*, bool, int*, int* num_serialized) = 0; // 0x30 21 | virtual bool Deserialize(int flags, int flags2, rage::datBitBuffer* buffer, void*) = 0; // 0x38 22 | virtual int CalculateSize(int flags, int flags2, void*) = 0; // 0x40 23 | virtual int CalculateSize2(int flags, int flags2, bool) = 0; // 0x48 24 | 25 | netSyncNodeBase* m_NextSibling; //0x0008 26 | netSyncNodeBase* m_PrevSibling; //0x0010 27 | netSyncTree* m_Root; //0x0018 28 | netSyncNodeBase* m_Parent; //0x0020 29 | 30 | uint32_t m_Flags1; //0x0028 31 | uint32_t m_Flags2; //0x002C 32 | uint32_t m_Flags3; //0x0030 33 | 34 | uint32_t m_Pad2; //0x0034 35 | 36 | netSyncNodeBase* m_FirstChild; //0x0038 37 | }; //Size: 0x0040 38 | static_assert(sizeof(netSyncNodeBase) == 0x40); 39 | #pragma pack(pop) 40 | } -------------------------------------------------------------------------------- /network/sync/netSyncTree.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "netSyncNodeBase.hpp" 4 | 5 | namespace rage 6 | { 7 | #pragma pack(push, 8) 8 | class netSyncTree 9 | { 10 | public: 11 | char pad_0000[176]; //0x0000 12 | netSyncNodeBase* m_NextSyncNode; //0x00B0 13 | netSyncNodeBase* m_LastSyncNode; //0x00B8 14 | uint32_t m_NodeCount; //0x00C0 15 | uint32_t m_SyncNodeCount; //0x00C4 16 | char pad_00C8[24]; //0x00C8 17 | netSyncNodeBase* m_Nodes[74]; //0x00E0 18 | uint32_t m_NodeMaxCount; //0x0330 19 | netSyncNodeBase* m_SyncNodes[64]; //0x0338 20 | uint32_t m_SyncNodeMaxCount; //0x0538 21 | char pad_053C[900]; //0x053C 22 | }; //Size: 0x08C0 23 | static_assert(sizeof(rage::netSyncTree) == 0x8C0); 24 | #pragma pack(pop) 25 | } -------------------------------------------------------------------------------- /network/sync/object/CObjectCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | // TODO 5 | class CObjectCreationData 6 | { 7 | public: 8 | char pad_0000[284]; //0x0000 9 | uint32_t m_ObjectType; //0x011C 10 | uint32_t m_ModelHash; //0x0120 11 | char pad_0124[76]; //0x0124 12 | }; //Size: 0x0170 13 | static_assert(sizeof(CObjectCreationData) == 0x170); -------------------------------------------------------------------------------- /network/sync/ped/CPedAttachData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPedAttachData 5 | { 6 | public: 7 | char pad_0000[32]; //0x0000 8 | uint16_t m_AttachObjectId; //0x0020 9 | char pad_0022[15]; //0x0022 10 | bool m_IsAttached; //0x0031 11 | char pad_0032[14]; //0x0032 12 | }; //Size: 0x0040 13 | static_assert(sizeof(CPedAttachData) == 0x40); -------------------------------------------------------------------------------- /network/sync/ped/CPedCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | // TODO, CPedBaseCreationData 5 | class CPedCreationData 6 | { 7 | public: 8 | char pad_0000[4]; //0x0000 9 | uint32_t m_PopulationType; //0x0004 10 | uint32_t m_ModelHash; //0x0008 11 | char pad_000C[18]; //0x000C 12 | bool m_BannedPed; //0x001E 13 | char pad_001F[13]; //0x001F 14 | }; //Size: 0x002C 15 | static_assert(sizeof(CPedCreationData) == 0x2C); -------------------------------------------------------------------------------- /network/sync/ped/CPedHealthData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rage/vector.hpp" 3 | 4 | class CPedHealthData 5 | { 6 | public: 7 | rage::matrix44 m_WoundEffectPos; 8 | uint32_t m_DamageWeaponHash; 9 | uint32_t m_DamageWeaponMode; 10 | uint32_t m_KillerWeaponHash; 11 | uint32_t m_KillerWeaponMode; 12 | uint32_t m_HitComponent; 13 | float m_CurrentBleedOutDuration; 14 | uint32_t m_IncapacitationThreshold; 15 | uint32_t m_WoundIntensity; 16 | int m_DeathTime; 17 | uint32_t unk_0064; 18 | int m_Health; 19 | unsigned int unsigned_int6C; 20 | unsigned int m_HealthConfig; 21 | unsigned int unk_0074; 22 | uint16_t m_DamagerId; 23 | uint16_t m_KillerId; 24 | uint16_t unk_007C; 25 | char m_DamageCleanliness; 26 | char unk_007F; 27 | int m_DamageCleanlinessHits; 28 | uint8_t m_TotalBleedOutDuration; 29 | uint8_t unk_0085; 30 | uint8_t m_FireDamageAmount; 31 | char unk_0087; 32 | uint16_t m_IncapacitationFlags; 33 | uint8_t m_TranquilizerPlayerId; 34 | bool unk_008B; 35 | bool m_TotalBleedOutDurationOverridden; 36 | bool m_HasDefaultHealth; 37 | bool m_HasDamageBone; 38 | bool unk_008F; 39 | bool unk_0090; 40 | bool unk_0091; 41 | bool unk_0092; 42 | bool m_CanBeIncapacitated; 43 | bool m_Incapacitated; 44 | bool unk_0095; 45 | bool unk_0096; 46 | bool unk_0097; 47 | bool unk_0098; 48 | bool unk_0099; 49 | bool unk_009A; 50 | bool unk_009B; 51 | bool m_HasWound; 52 | bool m_HasBloodPool; 53 | bool unk_009E; 54 | bool m_TakingDamage; 55 | bool unk_00A0; 56 | bool unk_00A1; 57 | char epad[0xE]; 58 | }; 59 | static_assert(sizeof(CPedHealthData) == 0xB0); -------------------------------------------------------------------------------- /network/sync/ped/CPedTaskTreeData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPedTaskData 5 | { 6 | public: 7 | uint32_t m_TaskType; //0x0000 8 | uint32_t m_TaskUnk1; //0x0004 9 | uint32_t m_TaskTreeType; //0x0008 10 | uint32_t m_TaskSequenceId; //0x000C 11 | uint32_t m_TaskTreeDepth; //0x0010 12 | }; //Size: 0x0014 13 | static_assert(sizeof(CPedTaskData) == 0x14); 14 | 15 | class CPedTaskTree 16 | { 17 | public: 18 | uint32_t m_TreeType; //0x0000 not serialized 19 | char pad_0004[4]; //0x0004 unused 20 | uint32_t m_NumTasks; //0x0008 21 | bool m_SequenceTree; //0x000C 22 | class CPedTaskData m_Tasks[12]; //0x0010 23 | char pad_0100[16]; //0x0100 unused 24 | }; //Size: 0x0110 25 | static_assert(sizeof(CPedTaskTree) == 0x110); 26 | 27 | // TODO: incorrect name 28 | class CPedTaskTreeData 29 | { 30 | public: 31 | class CPedTaskTree m_Trees[5]; //0x0000 32 | char pad_0550[4]; //0x0550 unused 33 | uint32_t m_ScriptCommand; //0x0554 34 | uint32_t m_ScriptTaskStage; //0x0558 35 | 36 | int GetNumTaskTrees() 37 | { 38 | switch (m_Trees[0].m_TreeType) 39 | { 40 | case 0: return 5; 41 | case 1: return 2; 42 | case 2: return 0; 43 | case 3: return 1; 44 | } 45 | 46 | return 0; 47 | } 48 | }; //Size: 0x055C 49 | static_assert(sizeof(CPedTaskTreeData) == 0x55C); 50 | -------------------------------------------------------------------------------- /network/sync/ped/CPedVitalityData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPedVitalityData 5 | { 6 | public: 7 | uint32_t m_HealthInReserve[8]; 8 | uint32_t m_Health; 9 | uint32_t unk_0024; 10 | uint32_t unk_0028; 11 | uint32_t unk_002C; 12 | uint32_t unk_0030; 13 | uint32_t unk_0034; 14 | uint8_t m_NumHealthReserves; 15 | bool unk_0039; 16 | bool m_HasUpgradeData; 17 | bool unk_003B; 18 | bool unk_003C; 19 | bool unk_003D; 20 | bool m_HasHealthTankUpgrade; 21 | bool m_HasStaminaTankUpgrade; 22 | uint32_t unk_0040; 23 | uint32_t unk_0044; 24 | uint32_t unk_0048; 25 | bool unk_004C; 26 | bool unk_004D; 27 | bool unk_004E; 28 | uint32_t m_TotalHealth; 29 | uint32_t m_UnkComponentValue; 30 | uint32_t dword58; 31 | char gap5C[4]; 32 | uint64_t qword60; 33 | uint64_t qword68; 34 | bool m_HasDefaultHealth; 35 | bool m_IsDead; 36 | bool m_HasDefaultUnk; 37 | bool m_IsIncapacitated; 38 | bool unk_0074; 39 | bool unk_0075; 40 | }; 41 | static_assert(sizeof(CPedVitalityData) == 0x78); -------------------------------------------------------------------------------- /network/sync/physical/CPhysicalAttachData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rage/vector.hpp" 4 | #include 5 | 6 | #pragma pack(push, 8) 7 | class CPhysicalAttachData 8 | { 9 | public: 10 | bool m_IsAttached; //0x0000 11 | uint16_t m_AttachObjectId; //0x0002 12 | alignas(16) rage::fvector3 m_Offset; //0x0010 13 | rage::fvector4 m_Orientation; //0x0020 14 | rage::fvector3 m_ParentOffset; //0x0030 15 | uint16_t m_OtherAttachBone; //0x0040 16 | uint16_t m_AttachBone; //0x0042 17 | uint32_t m_AttachFlags; //0x0044 18 | char pad_0048[24]; //0x0048 19 | }; //Size: 0x0060 20 | #pragma pack(pop) 21 | static_assert(sizeof(CPhysicalAttachData) == 0x60); -------------------------------------------------------------------------------- /network/sync/pickup/CPickupCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPickupCreationData 5 | { 6 | public: 7 | char pad_0000[68]; //0x0000 8 | uint32_t m_PickupHash; //0x0044 9 | uint32_t m_ModelHash; //0x0048 10 | char pad_004C[236]; //0x004C 11 | }; //Size: 0x0138 12 | static_assert(sizeof(CPickupCreationData) == 0x138); -------------------------------------------------------------------------------- /network/sync/player/CPlayerAppearanceData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPlayerAppearanceData 5 | { 6 | public: 7 | char pad_0000[23612]; //0x0000 8 | uint32_t m_ModelHash; //0x5C3C 9 | char pad_5C40[7]; //0x5C40 10 | bool m_BannedPlayerModel; //0x5C47 11 | }; //Size: 0x5C48 12 | static_assert(sizeof(CPlayerAppearanceData) == 0x5C48); -------------------------------------------------------------------------------- /network/sync/player/CPlayerCameraUncommonData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rage/vector.hpp" 4 | 5 | #pragma pack(push, 8) 6 | class CPlayerCameraUncommonData 7 | { 8 | public: 9 | rage::vector3 m_UnkCameraOffset; // 0x0 10 | char m_Pad[8]; // 0x10 11 | bool m_IsSpectating; // 0x18 12 | private: 13 | char m_Pad2[7]; // 0x19 14 | }; //Size: 0x0010 15 | static_assert(sizeof(CPlayerCameraUncommonData) == 0x20); 16 | #pragma pack(pop) -------------------------------------------------------------------------------- /network/sync/player/CPlayerCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPlayerCreationData 5 | { 6 | public: 7 | uint32_t m_Hash; // 0x0000 8 | char m_Pad[20]; // 0x0004 9 | }; //Size: 0x18 10 | static_assert(sizeof(CPlayerCreationData) == 0x18); -------------------------------------------------------------------------------- /network/sync/player/CPlayerGameStateUncommonData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "rage/vector.hpp" 4 | 5 | #pragma pack(push, 8) 6 | class CPlayerGameStateUncommonData 7 | { 8 | private: 9 | char m_Pad[0x78]; 10 | public: 11 | std::uint16_t m_SpectatorId; // 0x78 12 | alignas(8) rage::vector3 m_SpectatePos; // 0x80 13 | private: 14 | char m_Pad2[0x4]; // 0x90 15 | public: 16 | bool m_IsSpectating; // 0x94 17 | bool m_IsSpectatingStaticPos; // 0x95 18 | private: 19 | char m_Pad3[0xA]; // 0x96 20 | }; //Size: 0x0010 21 | static_assert(sizeof(CPlayerGameStateUncommonData) == 0xA0); 22 | #pragma pack(pop) -------------------------------------------------------------------------------- /network/sync/player/CPlayerHealthData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #pragma pack(push, 8) 5 | class CPlayerHealthData 6 | { 7 | public: 8 | uint32_t m_Unused; //0x0000 9 | bool m_BulletProof; //0x0004 10 | bool m_FlameProof; //0x0005 11 | bool m_ExplosionProof; //0x0006 12 | bool m_CollisionProof; //0x0007 13 | bool m_MeleeProof; //0x0008 14 | bool m_SmokeProof; //0x0009 15 | bool m_SteamProof; //0x000A 16 | bool m_Godmode; //0x000B 17 | private: 18 | char m_Pad[4]; 19 | }; //Size: 0x0010 20 | static_assert(sizeof(CPlayerHealthData) == 0x10); 21 | #pragma pack(pop) -------------------------------------------------------------------------------- /network/sync/projectile/CProjectileCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rage/vector.hpp" 3 | #include 4 | 5 | 6 | struct CProjectileCreationData { 7 | char m_Pad1[2]; 8 | uint16_t m_OwnerObjectId; 9 | uint32_t m_AmmoHash; 10 | uint32_t m_WeaponHash; 11 | char m_Pad2[4]; 12 | rage::vector3 m_Velocity; 13 | char m_Pad3[4]; 14 | uint16_t m_ObjectId2; 15 | char m_Pad4[26]; 16 | rage::matrix34 m_InitialPosition; 17 | }; 18 | static_assert(sizeof(CProjectileCreationData) == 0x80); 19 | -------------------------------------------------------------------------------- /network/sync/propset/CPropSetCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CPropSetCreationData 5 | { 6 | public: 7 | char m_Pad[16]; // 0x0000 8 | uint32_t m_Hash; // 0x0010 9 | char m_Pad1[8]; // 0x0014 10 | int32_t m_Type; // 0x001C 11 | char m_Pad2[544]; // 0x0020 12 | }; //Size: 0x240 13 | static_assert(sizeof(CPropSetCreationData) == 0x240); -------------------------------------------------------------------------------- /network/sync/vehicle/CVehicleCreationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CVehicleCreationData 5 | { 6 | public: 7 | char pad_0000[4]; //0x0000 8 | uint32_t m_PopulationType; //0x0004 9 | char pad_0008[4]; //0x0008 10 | uint32_t m_ModelHash; //0x000C 11 | char pad_0010[24]; //0x0010 12 | }; //Size: 0x0028 13 | static_assert(sizeof(CVehicleCreationData) == 0x28); -------------------------------------------------------------------------------- /network/sync/vehicle/CVehicleGadgetData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class CGadgetData { 5 | public: 6 | uint32_t m_Type; 7 | uint8_t m_Data[0xF3]; 8 | }; 9 | static_assert(sizeof(CGadgetData) == 0xF8); 10 | 11 | // TODO: Fix this 12 | class CVehicleGadgetData { 13 | public: 14 | bool m_HasPosition; 15 | char pad_0001[15]; 16 | float m_Position[4]; 17 | uint32_t m_NumGadgets; 18 | char pad_0002[12]; 19 | CGadgetData m_Gadgets[2]; 20 | }; 21 | static_assert(sizeof(CVehicleGadgetData) == 0x220); -------------------------------------------------------------------------------- /network/sync/vehicle/CVehicleProximityMigrationData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "rage/vector.hpp" 3 | 4 | #pragma pack(push, 8) 5 | class CVehicleProximityMigrationData 6 | { 7 | public: 8 | uint32_t m_NumPassengers; //0x0000 9 | bool m_PassengersActive[17]; //0x0004 10 | uint16_t m_PassengerObjectIds[17]; //0x0016 11 | bool m_OverridePopulationType; //0x0038 12 | uint32_t m_PopulationType; //0x003C 13 | uint32_t m_Flags; //0x0040 14 | uint32_t m_Timestamp; //0x0044 15 | bool m_HasPositionData; //0x0048 16 | alignas(16) rage::fvector3 m_Position; //0x0050 17 | int m_VelocityX; 18 | int m_VelocityY; 19 | int m_VelocityZ; 20 | uint32_t m_UnkAmount; //0x006C 21 | }; //Size: 0x0070 22 | static_assert(sizeof(CVehicleProximityMigrationData) == 0x70); 23 | #pragma pack(pop) -------------------------------------------------------------------------------- /ped/CPed.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "physical/CPhysical.hpp" 3 | 4 | class CPed : public CPhysical 5 | { 6 | char m_Pad6[0x18]; // 0x0368 7 | }; 8 | static_assert(sizeof(CPed) == 0x380); -------------------------------------------------------------------------------- /physical/CPhysical.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "entity/CDynamicEntity.hpp" 3 | 4 | class CPhysical : public CDynamicEntity 5 | { 6 | public: 7 | char m_Pad5[0x1B8]; // 0x01B0 8 | }; 9 | static_assert(sizeof(CPhysical) == 0x368); -------------------------------------------------------------------------------- /player/CPlayerInfo.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../network/rlGamerInfo.hpp" 3 | 4 | class CPlayerInfo 5 | { 6 | public: 7 | char pad_0000[336]; //0x0000 8 | rage::rlGamerInfo m_GamerInfo; //0x0150 9 | char pad_0158[4000]; //0x0228 10 | void* m_Ped; //0x11C8 11 | char pad_11D0[3640]; //0x11D0 12 | }; //Size: 0x2008 13 | static_assert(sizeof(CPlayerInfo) == 0x2008); -------------------------------------------------------------------------------- /rage/Guid.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | template 5 | class Guid { 6 | public: 7 | static_assert(Len > 0); 8 | 9 | inline constexpr size_t size() const { return Len; } 10 | 11 | template 12 | inline constexpr T &At(size_t i) { 13 | static_assert(sizeof(T) <= sizeof(uint64_t)); 14 | assert(i < Len); 15 | return *reinterpret_cast(&m_Buffer[i]); 16 | } 17 | 18 | inline constexpr uint32_t &operator[](size_t i) { return At(i); } 19 | 20 | inline constexpr Guid() { 21 | for (size_t i = 0; i < size(); i++) 22 | m_Buffer[i] = 0; 23 | } 24 | 25 | template 26 | inline constexpr Guid &operator=(Guid g) { 27 | for (size_t i = 0; i < std::min(size(), g.size()); i++) 28 | m_Buffer[i] = g[i]; 29 | return *this; 30 | } 31 | 32 | template 33 | inline constexpr Guid(Guid g) { 34 | *this = g; 35 | } 36 | 37 | inline constexpr void *get() { return reinterpret_cast(&m_Buffer); } 38 | 39 | private: 40 | alignas(8) uint64_t m_Buffer[Len]; 41 | }; 42 | static_assert(sizeof(Guid<5>) == sizeof(uint64_t) * 5); -------------------------------------------------------------------------------- /rage/atArray.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | namespace rage 8 | { 9 | #pragma pack(push, 8) 10 | template 11 | class atArray 12 | { 13 | public: 14 | atArray() : 15 | m_Data(nullptr), 16 | m_Size(0), 17 | m_Count(0) 18 | { 19 | 20 | } 21 | 22 | T* begin() const 23 | { 24 | return &m_Data[0]; 25 | } 26 | 27 | T* end() const 28 | { 29 | return &m_Data[m_Size]; 30 | } 31 | 32 | T* data() const 33 | { 34 | return m_Data; 35 | } 36 | 37 | std::uint16_t size() const 38 | { 39 | return m_Size; 40 | } 41 | 42 | std::uint16_t count() const 43 | { 44 | return m_Count; 45 | } 46 | 47 | T& operator[](std::uint16_t index) const 48 | { 49 | return m_Data[index]; 50 | } 51 | 52 | bool contains(T comparator) 53 | { 54 | for (auto iter_value : this) 55 | { 56 | if (iter_value == comparator) 57 | { 58 | return true; 59 | } 60 | } 61 | return false; 62 | } 63 | 64 | private: 65 | T* m_Data; 66 | std::uint16_t m_Size; 67 | std::uint16_t m_Count; 68 | }; 69 | static_assert(sizeof(rage::atArray) == 0x10, "rage::atArray is not properly sized"); 70 | #pragma pack(pop) 71 | } -------------------------------------------------------------------------------- /rage/atDelegate.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rage 4 | { 5 | class atDelegate 6 | { 7 | public: 8 | void* m_Object; 9 | void* m_Callback; 10 | }; 11 | static_assert(sizeof(atDelegate) == 0x10); 12 | } -------------------------------------------------------------------------------- /rage/atPlayerBits.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #pragma pack(push, 8) 4 | namespace rage 5 | { 6 | class atPlayerBits 7 | { 8 | constexpr static int MAX_PLAYERS = 32; 9 | int m_PlayerBits[MAX_PLAYERS / 32]; 10 | 11 | public: 12 | bool IsSet(int id) 13 | { 14 | return _bittest((const long*)&m_PlayerBits[id / 32], id % 32); 15 | } 16 | 17 | void Set(int id) 18 | { 19 | m_PlayerBits[id / 32] |= (1 << (id % 32)); 20 | } 21 | 22 | void Clear(int id) 23 | { 24 | m_PlayerBits[id / 32] &= ~(1 << (id % 32)); 25 | } 26 | 27 | // TODO: bit count, CNetGamePlayer... 28 | }; 29 | static_assert(sizeof(rage::atPlayerBits) == 4); 30 | } 31 | #pragma pack(pop) -------------------------------------------------------------------------------- /rage/atUri.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #pragma pack(push, 8) 5 | namespace rage 6 | { 7 | class atUri 8 | { 9 | public: 10 | enum ProtocolType 11 | { 12 | HTTP, 13 | HTTPS, 14 | WS, 15 | WSS 16 | }; 17 | 18 | ProtocolType m_ProtocolType; 19 | char m_Host[128]; 20 | std::int16_t m_Port; 21 | char m_Path[512]; 22 | char m_QueryString[512]; 23 | }; 24 | static_assert(sizeof(atUri) == 0x488); 25 | } 26 | #pragma pack(pop) -------------------------------------------------------------------------------- /rage/datBitBuffer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage 5 | { 6 | class datBitBuffer 7 | { 8 | public: 9 | datBitBuffer(void* data, uint32_t size, bool read = false) 10 | { 11 | m_Data = data; 12 | m_BitOffset = 0; 13 | m_MaxBit = size * 8; 14 | m_BitsRead = 0; 15 | m_CurBit = 0; 16 | m_HighestBitsRead = 0; 17 | m_ErrorCallback = nullptr; 18 | m_FlagBits = read ? 1 : 0; 19 | } 20 | 21 | static void ReadBitsSingle(uint8_t* data, int* out, int size, int offset) 22 | { 23 | int v5; // r11d 24 | int v6; // ebx 25 | uint8_t* v7; // r14 26 | char v8; // cl 27 | int v9; // r11d 28 | unsigned int v10; // r8d 29 | int v11; // esi 30 | __int64 v12; // r9 31 | 32 | v5 = offset; 33 | v6 = 1; 34 | v7 = &data[offset >> 3]; 35 | v8 = offset & 7; 36 | if (size > 0) 37 | v5 = size + offset - 1; 38 | v9 = (v5 >> 3) - (offset >> 3); 39 | v10 = (unsigned __int8)(*v7 << v8); 40 | v11 = 8; 41 | if (size > 8) 42 | { 43 | v12 = 1i64; 44 | do 45 | { 46 | if (v12 > v9) 47 | break; 48 | ++v6; 49 | v10 = (v10 << 8) | (v7[v12++] << v8); 50 | v11 += 8; 51 | } while (v11 < size); 52 | } 53 | if (v6 <= v9) 54 | v10 |= v7[v6] >> (8 - v8); 55 | *out = v10 >> (((size + 7) & 0xF8) - size); 56 | } 57 | 58 | static void WriteBitsSingle(uint8_t* data, int value, int size, int offset) 59 | { 60 | uint8_t* v4; // r10 61 | int v5; // r9d 62 | unsigned int v6; // r11d 63 | uint8_t* v7; // r10 64 | unsigned int v8; // r11d 65 | int v9; // ebx 66 | __int64 v10; // rdx 67 | char v11; // cl 68 | 69 | v4 = &data[(__int64)offset >> 3]; 70 | v5 = offset & 7; 71 | v6 = value << (32 - size); 72 | *v4 = ((v6 >> 24) >> v5) | *v4 & ~((unsigned int)(-1 << (32 - size)) >> 24 >> v5); 73 | v7 = v4 + 1; 74 | v8 = v6 << (8 - v5); 75 | v9 = -1 << (32 - size) << (8 - v5); 76 | if (8 - v5 < size) 77 | { 78 | v10 = ((unsigned int)(size - (8 - v5) - 1) >> 3) + 1; 79 | do 80 | { 81 | v11 = (v8 >> 24) | *v7 & ~(v9 >> 24); 82 | v8 <<= 8; 83 | *v7++ = v11; 84 | v9 <<= 8; 85 | --v10; 86 | } while (v10); 87 | } 88 | } 89 | 90 | inline bool IsReadBuffer() 91 | { 92 | return m_FlagBits & 1; 93 | } 94 | 95 | inline bool IsSizeCalculator() 96 | { 97 | return m_FlagBits & 2; 98 | } 99 | 100 | void Seek(int bits, bool read) 101 | { 102 | m_BitsRead += bits; 103 | 104 | if (read) 105 | { 106 | if (m_HighestBitsRead > m_CurBit) 107 | m_CurBit = m_HighestBitsRead; 108 | } 109 | else 110 | { 111 | if (m_BitsRead > m_CurBit) 112 | m_CurBit = m_BitsRead; 113 | } 114 | } 115 | 116 | inline bool ReadDword(int* out, int size) 117 | { 118 | if (IsSizeCalculator()) 119 | return false; 120 | 121 | if (m_BitsRead + size > (IsReadBuffer() ? m_MaxBit : m_CurBit)) 122 | return false; 123 | 124 | ReadBitsSingle(static_cast(m_Data), out, size, m_BitsRead + m_BitOffset); 125 | Seek(size, true); 126 | return true; 127 | } 128 | 129 | inline bool WriteDword(int val, int size) 130 | { 131 | if (IsReadBuffer()) 132 | return false; 133 | 134 | if (m_BitsRead + size > m_MaxBit) 135 | return false; 136 | 137 | if (!IsSizeCalculator()) 138 | WriteBitsSingle(static_cast(m_Data), val, size, m_BitsRead + m_BitOffset); 139 | Seek(size, false); 140 | return true; 141 | } 142 | 143 | inline bool ReadQword(uint64_t* out, int size) 144 | { 145 | if (size <= 32) 146 | return ReadDword(reinterpret_cast(out), size); 147 | 148 | return ReadDword(reinterpret_cast(out), 32) && !ReadDword(reinterpret_cast(out) + 1, size - 32); 149 | } 150 | 151 | inline bool WriteQword(uint64_t value, int size) 152 | { 153 | if (size <= 32) 154 | return WriteDword(static_cast(value), size); 155 | 156 | int low = (int)(value) & 0xFFFFFFFF; 157 | int high = (int)((uint64_t)value >> 32); 158 | 159 | return WriteDword(low, 32) && WriteDword(high, size - 32); 160 | } 161 | 162 | inline bool ReadInt64(int64_t* value, int size) 163 | { 164 | unsigned int last_bit{}; 165 | uint64_t rest{}; 166 | 167 | if (!ReadQword((uint64_t*)&last_bit, 1) || ReadQword(&rest, size - 1)) 168 | return false; 169 | 170 | *value = ((uint64_t)last_bit << 63) | rest ^ -(int64_t)last_bit; 171 | return true; 172 | } 173 | 174 | inline bool WriteInt64(int64_t value, int size) 175 | { 176 | auto last_bit = value >> 63; 177 | if (!WriteQword(last_bit, 1) || !WriteQword((uint64_t)value ^ -(__int64)(unsigned int)last_bit, size - 1)) 178 | return false; 179 | 180 | return true; 181 | } 182 | 183 | // unsigned 184 | // TODO: signed likely only works for 64 bit values! 185 | template 186 | T Read(int size, bool _signed = false) 187 | { 188 | static_assert(sizeof(T) <= 8); 189 | 190 | uint64_t data{}; 191 | int64_t data_signed{}; 192 | if (_signed) 193 | ReadInt64(&data_signed, size); 194 | else 195 | ReadQword(&data, size); 196 | 197 | if (_signed) 198 | return T(data_signed); 199 | else 200 | return T(data); 201 | } 202 | 203 | // unsigned 204 | // TODO: signed likely only works for 64 bit values! 205 | template 206 | void Write(T data, int size, bool _signed = false) 207 | { 208 | static_assert(sizeof(T) <= 8); 209 | 210 | if (_signed) 211 | WriteInt64(int64_t(data), size); 212 | else 213 | WriteQword(uint64_t(data), size); 214 | } 215 | 216 | public: 217 | void* m_Data; //0x0000 218 | uint32_t m_BitOffset; //0x0008 219 | uint32_t m_MaxBit; //0x000C 220 | uint32_t m_BitsRead; //0x0010 221 | uint32_t m_CurBit; //0x0014 222 | uint32_t m_HighestBitsRead; //0x0018 223 | void* m_ErrorCallback; //0x0020 224 | uint8_t m_FlagBits; //0x0028 225 | }; 226 | } -------------------------------------------------------------------------------- /rage/fwBasePool.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | namespace rage 5 | { 6 | class fwBasePool 7 | { 8 | public: 9 | virtual ~fwBasePool() = 0; // 0x0000 10 | uintptr_t m_Entries; // 0x0008 11 | uint8_t* m_Flags; // 0x0010 12 | uint32_t m_Size; // 0x0018 13 | uint32_t m_ItemSize; // 0x001C 14 | uint32_t m_NextSlotIndex; // 0x0020 15 | uint32_t m_0024; // 0x0024 16 | uint32_t m_FreeSlotIndex; // 0x0028 17 | 18 | bool Full() const 19 | { 20 | return m_Size - (m_FreeSlotIndex & 0x3FFFFFFF) <= 256; 21 | } 22 | 23 | int64_t GetNumFreeSlots() const 24 | { 25 | return static_cast(m_Size) - static_cast((m_FreeSlotIndex * 4) >> 2); 26 | } 27 | 28 | int32_t GetScriptGuid(int32_t Index) const 29 | { 30 | return (Index << 8) + m_Flags[Index]; 31 | } 32 | 33 | int32_t GetIndex(int32_t ScriptGuid) const 34 | { 35 | return ScriptGuid >> 8; 36 | } 37 | 38 | bool IsValid(int32_t Index) const 39 | { 40 | return !(m_Flags[Index] & 0x80); 41 | } 42 | 43 | void* GetAt(size_t Index) const 44 | { 45 | if (m_Flags[Index]) 46 | { 47 | if (_fwObj* obj = reinterpret_cast<_fwObj*>(m_Entries + Index * m_ItemSize); obj->m_0010) 48 | return obj; 49 | } 50 | 51 | return nullptr; 52 | } 53 | 54 | // Helper class to check object validity (m_0010) 55 | class _fwObj 56 | { 57 | public: 58 | virtual ~_fwObj() = 0; 59 | uint64_t m_0008; 60 | void* m_0010; 61 | }; 62 | 63 | }; //Size: 0x0030 64 | static_assert(sizeof(fwBasePool) == 0x30); 65 | } 66 | -------------------------------------------------------------------------------- /rage/joaat.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace rage 7 | { 8 | using joaat_t = std::uint32_t; 9 | inline constexpr char JoaatToLower(char c) 10 | { 11 | return c >= 'A' && c <= 'Z' ? c | 1 << 5 : c; 12 | } 13 | 14 | inline constexpr joaat_t Joaat(const std::string_view str) 15 | { 16 | joaat_t hash = 0; 17 | for (auto c : str) 18 | { 19 | hash += JoaatToLower(c); 20 | hash += (hash << 10); 21 | hash ^= (hash >> 6); 22 | } 23 | hash += (hash << 3); 24 | hash ^= (hash >> 11); 25 | hash += (hash << 15); 26 | return hash; 27 | } 28 | }; -------------------------------------------------------------------------------- /rage/pools.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | class PoolEncryption 5 | { 6 | public: 7 | bool m_IsSet; //0x0000 8 | uint64_t m_First; //0x0008 9 | uint64_t m_Second; //0x0010 10 | }; //Size: 0x0018 11 | static_assert(sizeof(PoolEncryption) == 0x18); 12 | -------------------------------------------------------------------------------- /rage/rlJson.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #pragma pack(push, 4) 5 | namespace rage 6 | { 7 | class rlJson 8 | { 9 | uint32_t unk0; // 0x00 10 | uint32_t unk1; // 0x04 11 | char* m_Buffer; // 0x08 12 | uint32_t m_Curlen;// 0x10 13 | uint32_t m_Maxlen;// 0x14 14 | uint32_t unk4; // 0x18 15 | uint32_t m_Flags; // 0x1C 16 | uint8_t m_Flags2; // 0x20 17 | 18 | public: 19 | rlJson(char* _buffer, uint32_t _length) : 20 | m_Buffer(_buffer), 21 | m_Maxlen(_length) 22 | { 23 | unk0 = 0; 24 | unk1 = 0; 25 | m_Curlen = 0; 26 | unk4 = 1; 27 | m_Flags = 0; 28 | m_Flags2 = 0; 29 | } 30 | 31 | inline char* GetBuffer() const 32 | { 33 | return m_Buffer; 34 | } 35 | }; 36 | static_assert(sizeof(rage::rlJson) == 0x24); 37 | } 38 | #pragma pack(pop) -------------------------------------------------------------------------------- /rage/rlMetric.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "joaat.hpp" 3 | 4 | namespace rage 5 | { 6 | class rlJson; 7 | class rlMetric 8 | { 9 | public: 10 | virtual ~rlMetric() = default; // 0x00 11 | virtual int GetType() = 0; // 0x08 12 | virtual int GetType2() = 0; // 0x10 13 | virtual const char* GetName() = 0; // 0x18 14 | virtual bool Serialize(rage::rlJson* serializer) = 0; // 0x20 15 | virtual int GetSize() = 0; // 0x28 16 | virtual joaat_t GetNameHash() = 0; // 0x30 17 | virtual bool _0x38() = 0; 18 | virtual bool _0x40() = 0; 19 | }; 20 | static_assert(sizeof(rage::rlMetric) == 0x8); 21 | } -------------------------------------------------------------------------------- /rage/rlTaskStatus.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rage 4 | { 5 | struct rlTaskStatus 6 | { 7 | int m_Status = 0; 8 | int m_ErrorCode = 0; 9 | }; 10 | } -------------------------------------------------------------------------------- /rage/tlsContext.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if _WIN32 4 | #include 5 | #endif 6 | 7 | namespace rage 8 | { 9 | #pragma pack(push, 8) 10 | class tlsContext 11 | { 12 | public: 13 | char pad[0x600]; // 0x0000 14 | int m_SyncThreadIndex; // 0x0600 15 | char pad2[0x12EC]; // 0x0604 16 | bool m_RunningScript; // 0x18F0 17 | 18 | #if _WIN32 19 | static tlsContext* Get() 20 | { 21 | constexpr std::uint32_t TlsIndex = 0x0; 22 | return *reinterpret_cast(__readgsqword(0x58) + TlsIndex); 23 | } 24 | #endif 25 | }; 26 | #pragma pack(pop) 27 | static_assert(sizeof(rage::tlsContext) == 0x18F4); 28 | } -------------------------------------------------------------------------------- /rage/vector.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #pragma pack(push, 0x10) 5 | namespace rage 6 | { 7 | // atVector? 8 | class vector2 9 | { 10 | public: 11 | float x, y; 12 | 13 | constexpr vector2(float x, float y) : 14 | x(x), 15 | y(y) 16 | { 17 | } 18 | 19 | constexpr vector2() : 20 | x(), 21 | y() 22 | { 23 | } 24 | }; 25 | 26 | // atVector? 27 | class vector3 28 | { 29 | public: 30 | float x, y, z; 31 | private: 32 | int _PAD; // because alignof doesn't work 33 | public: 34 | 35 | constexpr vector3(float x, float y, float z) : 36 | x(x), 37 | y(y), 38 | z(z) 39 | { 40 | } 41 | 42 | constexpr vector3() : 43 | x(), 44 | y(), 45 | z() 46 | { 47 | } 48 | 49 | bool operator==(const vector3& other) const 50 | { 51 | return this->x == other.x && this->y == other.y && this->z == other.z; 52 | } 53 | 54 | template 55 | bool operator!=(const vector3& other) const 56 | { 57 | return this->x != other.x || this->y != other.y || this->z != other.z; 58 | } 59 | 60 | vector3 operator+(const vector3& other) const 61 | { 62 | vector3 vec; 63 | vec.x = this->x + other.x; 64 | vec.y = this->y + other.y; 65 | vec.z = this->z + other.z; 66 | return vec; 67 | } 68 | 69 | vector3 operator-(const vector3& other) const 70 | { 71 | vector3 vec; 72 | vec.x = this->x - other.x; 73 | vec.y = this->y - other.y; 74 | vec.z = this->z - other.z; 75 | return vec; 76 | } 77 | 78 | vector3 operator*(const vector3& other) const 79 | { 80 | vector3 vec; 81 | vec.x = this->x * other.x; 82 | vec.y = this->y * other.y; 83 | vec.z = this->z * other.z; 84 | return vec; 85 | } 86 | 87 | vector3 operator*(const float& other) const 88 | { 89 | vector3 vec; 90 | vec.x = this->x * other; 91 | vec.y = this->y * other; 92 | vec.z = this->z * other; 93 | return vec; 94 | } 95 | 96 | inline float GetMagnitude() const 97 | { 98 | return sqrt(x * x + y * y + z * z); 99 | } 100 | 101 | inline float GetDistance(const vector3& other) const 102 | { 103 | return (*this - other).GetMagnitude(); 104 | } 105 | }; 106 | static_assert(sizeof(rage::vector3) == 0x10); 107 | 108 | // atVector? 109 | class vector4 110 | { 111 | public: 112 | float x, y, z, w; 113 | 114 | constexpr vector4(float x, float y, float z, float w) : 115 | x(x), 116 | y(y), 117 | z(z), 118 | w(w) 119 | { 120 | } 121 | 122 | constexpr vector4() : 123 | x(), 124 | y(), 125 | z(), 126 | w() 127 | { 128 | } 129 | }; 130 | 131 | union matrix34 132 | { 133 | float data[4][4]; // yes, the underlying representation is 4x4 134 | struct { struct { float x, y, z, w; } rows[3]; }; 135 | }; 136 | 137 | union matrix44 138 | { 139 | float data[4][4]; 140 | struct { struct { float x, y, z, w; } rows[4]; }; 141 | }; 142 | 143 | 144 | // backwards compatibility 145 | // TODO: remove these! 146 | using fvector2 = vector2; 147 | using fvector3 = vector3; 148 | using fvector4 = vector4; 149 | }; 150 | #pragma pack(pop) -------------------------------------------------------------------------------- /rdr2.rcnet: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/YimMenu/RDR-Classes/30ffb972079e1f61b7035d2dfc23d2ce642e7513/rdr2.rcnet -------------------------------------------------------------------------------- /script/globals/ACEData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "SessionManagerPlayerData.hpp" 4 | 5 | enum class ACEHostState 6 | { 7 | INVALID = -1, 8 | INIT, 9 | UPDATE 10 | }; 11 | 12 | enum class ACESlotType 13 | { 14 | TRAIN, 15 | GFH_POSSE_VERSUS, 16 | AMBIENT_CONTENT, 17 | DEATHMATCH, 18 | MAX 19 | }; 20 | 21 | enum class ACEClientRequestState 22 | { 23 | INVALID = -1, 24 | PUSHED, 25 | STARTED, 26 | EVALUATED, 27 | PROCESSED 28 | }; 29 | 30 | enum class ACERequestOwner 31 | { 32 | INVALID = -1, 33 | GUN_FOR_HIRE, 34 | TRAIN_MANAGER, 35 | FETCH_MANAGER, 36 | FMA_MANAGER, 37 | COACH_JOB_MANAGER, 38 | PLAYER_DATA, 39 | AMBIENT_DEATHMATCH, 40 | NET_BEAT, 41 | END 42 | }; 43 | 44 | enum class ACERequestType 45 | { 46 | INVALID = -1, 47 | ADD_MISSION, 48 | UPDATE_MISSION_LAUNCH_DATA, 49 | UPDATE_MISSION_PRIORITY, 50 | UPDATE_MISSION_SLOT_TYPE, 51 | UPDATE_GFH_UID_AND_LAUNCH_FLAGS, 52 | SET_LAUNCH_CONFIG_FLAGS, 53 | SWITCH_MISSION_TO_UID_AND_SET_LAUNCH_DATA, 54 | REMOVE_MISSION 55 | }; 56 | 57 | enum class ACERequestResult 58 | { 59 | PROCESSING, 60 | SUCCESS, 61 | FAILURE 62 | }; 63 | 64 | enum class ACESlotPriority 65 | { 66 | EMPTY = -1, 67 | CLEANUP, 68 | LOW, 69 | HIGH, 70 | CRITICAL 71 | }; 72 | 73 | enum class ACEConfigFlags 74 | { 75 | USE_LAUNCHER, 76 | USE_GANG_SYNC, 77 | USE_SCRIPT_LAUNCHER = 4, 78 | USE_PROC_THREAD = 6, 79 | USE_BEAT_THREAD 80 | }; 81 | 82 | enum class ACEHostMissionState 83 | { 84 | INVALID = -1, 85 | DISABLED, 86 | IDLE, 87 | MISSION_RUNNING, 88 | PRE_CLEANUP, 89 | SYNC_FLAGS, 90 | CLEANUP, 91 | COMPLETED 92 | }; 93 | 94 | enum class ACEHostRuntimeState 95 | { 96 | INVALID = -1, 97 | DISABLED, 98 | IDLE, 99 | ACTIVE, 100 | CLEANUP 101 | }; 102 | 103 | struct ACE_MISSION_IDENTIFIER_DATA 104 | { 105 | SCR_GUID UID; 106 | SCR_INT GangId; 107 | SCR_INT PosseVersusSlotId; 108 | SCR_INT GunForHireIndex; 109 | SCR_INT DeathmatchSlotId; 110 | SCR_GUID GFHDeed; 111 | SCR_BITSET ContentLocks; // actually named (e)ContentLock but that'll break the linux build 112 | SCR_INT ExpectedSlotType; 113 | }; 114 | static_assert(sizeof(ACE_MISSION_IDENTIFIER_DATA) == 10 * 8); 115 | 116 | struct ACE_MISSION_LOCATION_DATA 117 | { 118 | SCR_INT Location; 119 | SCR_INT InstanceId; 120 | SCR_INT VolumeLockSize; 121 | SCR_INT LaunchDistance; 122 | }; 123 | 124 | struct ACE_MISSION_DATA 125 | { 126 | constexpr static int INVALID_EXPIRE_TIME = -15; 127 | 128 | SCR_HASH ScriptHash; 129 | SCR_INT StackSize; 130 | SCR_INT Radius; 131 | SCR_INT PAD_0003; 132 | SCR_INT ExpireTime; 133 | PLAYER_INDEX StartingPlayer; 134 | SCR_BITSET ConfigFlags; 135 | SCR_INT NumLocations; // always 1 136 | SCR_ARRAY Locations; 137 | alignas(8) ACEHostMissionState State; 138 | SCR_INT BeatParameter2; 139 | SCR_INT BeatParameter3; 140 | SCR_INT BeatParameter4; 141 | }; 142 | static_assert(sizeof(ACE_MISSION_DATA) == 17 * 8); 143 | 144 | // TODO: what is this actually called? 145 | struct ACE_MISSION_SLOT_DATA 146 | { 147 | alignas(8) ACESlotType Type; 148 | alignas(8) ACESlotPriority Priority; 149 | uint64_t PAD_0002[3]; // seemingly unused 150 | ACE_MISSION_IDENTIFIER_DATA IdentifierData; 151 | }; 152 | static_assert(sizeof(ACE_MISSION_SLOT_DATA) == 15 * 8); 153 | 154 | struct ACE_MISSION_REQUEST 155 | { 156 | alignas(8) ACEClientRequestState State; 157 | SCR_INT RequestIndex; 158 | alignas(8) ACERequestOwner Owner; 159 | PLAYER_INDEX PlayerOwner; 160 | SCR_INT RequestIndex2; // apparently 161 | alignas(8) ACERequestType RequestType; 162 | alignas(8) ACERequestResult Result; 163 | SCR_INT Timestamp; 164 | ACE_MISSION_SLOT_DATA SlotData; 165 | ACE_MISSION_DATA MissionData; 166 | }; 167 | static_assert(sizeof(ACE_MISSION_REQUEST) == 40 * 8); 168 | 169 | struct ACE_DATA 170 | { 171 | SCR_INT MaxItems; 172 | SCR_INT QueueAdd; 173 | SCR_INT QueueMod; 174 | SCR_ARRAY Requests; 175 | }; 176 | static_assert(sizeof(ACE_DATA) == 204 * 8); -------------------------------------------------------------------------------- /script/globals/ACEHostData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | 4 | #include "ACEData.hpp" 5 | 6 | struct ACE_MISSION_QUEUE 7 | { 8 | SCR_INT NumItems; 9 | SCR_INT QueueHead; 10 | SCR_ARRAY Requests; 11 | }; 12 | static_assert(sizeof(ACE_MISSION_QUEUE) == 203 * 8); 13 | 14 | struct ACE_MISSIONS 15 | { 16 | SCR_ARRAY Slots; 17 | SCR_ARRAY Datas; 18 | }; 19 | 20 | struct ACE_MISSION_LOCATION_RUNTIME_DATA 21 | { 22 | alignas(8) ACEHostRuntimeState State; 23 | SCR_INT VolumeLockState; 24 | SCR_INT VolumeLockRequestId; 25 | 26 | }; 27 | static_assert(sizeof(ACE_MISSION_LOCATION_RUNTIME_DATA) == 3 * 8); 28 | 29 | // TODO: find actual names 30 | struct ACE_MISSION_RUNTIME_DATA 31 | { 32 | SCR_ARRAY Locations; 33 | SCR_INT StartingGangId; 34 | PLAYER_INDEX StartingPlayer; 35 | }; 36 | static_assert(sizeof(ACE_MISSION_RUNTIME_DATA) == 6 * 8); 37 | 38 | struct ACE_HOST_RUNTIME_DATA 39 | { 40 | SCR_ARRAY RuntimeMissionDatas; 41 | SCR_ARRAY SlotIndices; 42 | SCR_INT NumSlots; 43 | }; 44 | static_assert(sizeof(ACE_HOST_RUNTIME_DATA) == 500 * 8); 45 | 46 | struct ACE_HOST_DATA 47 | { 48 | alignas(8) ACEHostState State; 49 | SCR_INT LastValidateTime; 50 | alignas(8) ACESlotType ValidatingSlot; 51 | SCR_ARRAY(ACESlotType::MAX)> MaxMissionsInSlot; 52 | SCR_ARRAY(ACESlotType::MAX)> AllMissionsInSlot; 53 | SCR_ARRAY(ACESlotType::MAX)> ValidMissionsInSlot; 54 | SCR_ARRAY(ACESlotType::MAX)> WrongMissionsInSlot; 55 | SCR_ARRAY(ACESlotType::MAX)> OverflowMissionsInSlot; 56 | ACE_MISSION_QUEUE MissionQueue; 57 | ACE_MISSIONS Missions; 58 | ACE_HOST_RUNTIME_DATA RuntimeData; 59 | }; 60 | static_assert(sizeof(ACE_HOST_DATA) == 3005 * 8); -------------------------------------------------------------------------------- /script/globals/FMEManagerHostData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | 4 | enum class FMERunningState 5 | { 6 | INVALID, 7 | INIT, 8 | LAUNCH_OFFLINE, 9 | MATCHMAKE, 10 | LAUNCH_ONLINE, 11 | MAIN, 12 | CLEANUP 13 | }; 14 | 15 | enum class FMEEvent 16 | { 17 | INVALID = -1, 18 | FIRST, 19 | CHALLENGES, 20 | DEAD_DROP, 21 | GOLDEN_HAT, 22 | HOT_PROPERTY, 23 | KING_OF_THE_CASTLE, 24 | KING_OF_THE_RAILS, 25 | WILDLIFE_PHOTOGRAPHER, 26 | THEMED_ESCAPED_CONVICTS, 27 | THEMED_ROUND_UP, 28 | THEMED_SUPPLY_TRAIN, 29 | THEMED_WRECKAGE, 30 | THEMED_CONDOR_EGG, 31 | THEMED_ANIMAL_TAGGING, 32 | THEMED_LAST, 33 | PV_CHALLENGE_HERBALIST, 34 | PV_CHALLENGE_BIGGEST_FISH, 35 | PV_CHALLENGE_FLYING_BIRD, 36 | HUNT_THE_POSSE_LEADER, 37 | MAX 38 | }; 39 | 40 | struct FME_VOLUME_LOCK 41 | { 42 | SCR_INT RequestId; 43 | SCR_INT RequestId2; // ??? 44 | }; 45 | 46 | struct FME_EVENT 47 | { 48 | alignas(8) FMERunningState State; 49 | alignas(8) FMEEvent Event; 50 | SCR_INT LocationId; 51 | SCR_INT VariationId; 52 | SCR_INT PAD_0004; // random int for volume stuff? 53 | SCR_GUID UID; 54 | PLAYER_INDEX LaunchPlayer; 55 | SCR_INT PAD_0008; // unused 56 | FME_VOLUME_LOCK VolumeLock; 57 | SCR_INT PAD_0011; // unused 58 | SCR_DATE LaunchWindowDate; 59 | SCR_DATE ExpirationDate; 60 | }; 61 | static_assert(sizeof(FME_EVENT) == 26 * 8); 62 | 63 | struct FME_MANAGER_HOST_DATA 64 | { 65 | SCR_INT State; 66 | SCR_ARRAY Events; 67 | SCR_DATE LaunchDate; 68 | SCR_DATE ThemedLaunchDate; 69 | alignas(8) FMEEvent LaunchingEvent; 70 | alignas(8) FMEEvent LaunchingThemedEvent; 71 | SCR_INT NumLaunchesToday; 72 | SCR_INT NumThemedLaunchesToday; 73 | }; 74 | static_assert(sizeof(FME_MANAGER_HOST_DATA) == 228 * 8); -------------------------------------------------------------------------------- /script/globals/FetchManagerHostData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "GunForHireMissionData.hpp" 4 | #include "ACEData.hpp" 5 | 6 | enum class MissionLaunchType 7 | { 8 | INVALID = -1, 9 | PLAYER_LAUNCHED, 10 | DYNAMIC_UNACCEPTED, 11 | AMBIENT_TRAIN, 12 | MAX 13 | }; 14 | 15 | enum class MissionState 16 | { 17 | INVALID = -1, 18 | INIT, 19 | WAITING_FOR_SLOT, 20 | RUNNING, 21 | CLEANUP 22 | }; 23 | 24 | enum class MissionFlags 25 | { 26 | IS_AGGRO, 27 | LAUNCHED, 28 | CLEANED_UP, 29 | IS_FORCE_PASSIVE, 30 | IS_STARTED, 31 | IS_ACTIVE, 32 | IS_COMPLETED, 33 | IS_RECONCILING, 34 | IN_LAUNCH_RADIUS, 35 | CHECKED_SHUTDOWN_RADIUS, 36 | OUTSIDE_SHUTDOWN_RADIUS, 37 | NOT_RUNNING_THREAD, 38 | ONLINE_STREAMING_COMPLETE, 39 | ALLOW_DISABLED_LAW, 40 | FORCE_DELETE, 41 | SPAWN_COMPLETED, 42 | FORCE_HIDE_UI, 43 | ACCEPTED, 44 | FAILED_TO_ACCEPT, 45 | IS_RELAUNCH, 46 | CHECKED_ONLINE_THREAD, 47 | GLOBAL_SIGNAL_READY, 48 | PREVENT_THREAD_SHUTDOWN, 49 | SHUTDOWN_DETECTED, 50 | INHERITED_MISSION_FROM_POSSE, 51 | ACTIVE_PLAYERS_LEFT, 52 | TALKED_TO_DYNAMIC_MISSION_GIVER, 53 | GAVE_IGNORED_MISSION_GIVER_HONOR, 54 | DELETE_EXISTING_VOLUME_LOCKS, 55 | REQUESTED_ACE_SLOT, 56 | FORCE_SHUTDOWN_PRIMARY_TEAM, 57 | IS_INSTANCED 58 | }; 59 | 60 | enum class SaleBit 61 | { 62 | INVALID = 31, 63 | SIZE_VERY_SMALL = 0, 64 | SIZE_SMALL, 65 | SIZE_MEDIUM, 66 | SIZE_LARGE, 67 | STRENGTH_WEAK, 68 | STRENGTH_AVERAGE, 69 | STRENGTH_STRONG, 70 | ORDER_ANY, 71 | ORDER_UNFLAVORED, 72 | ORDER_REGULAR, 73 | ORDER_IMPROVED, 74 | ORDER_SPECIAL, 75 | STORY_MISSION_COMPLETE 76 | }; 77 | 78 | struct MISSION_SALE_DATA 79 | { 80 | SCR_BITSET Flags; 81 | SCR_INT NumGoods; // used only for CAMP_SELL 82 | }; 83 | 84 | struct FETCH_MANAGER_MISSION 85 | { 86 | SCR_INT MissionIndex; // seemingly obtained from the server 87 | alignas(8) MissionLaunchType LaunchType; 88 | alignas(8) MissionState State; 89 | SCR_BITSET Flags; 90 | SCR_INT ACESlot; 91 | SCR_INT CampIndex; 92 | SCR_INT Location; 93 | SCR_INT GFHLocation; 94 | SCR_INT BeatIndex; 95 | SCR_INT Instance; // maybe, a random integer from 0 to 65535 96 | SCR_INT StartTime; 97 | SCR_INT GangMembers; 98 | SCR_INT RequiredRelGroups; // whatever that means 99 | SCR_INT GangId; 100 | SCR_INT LaunchPlayers; 101 | PLAYER_INDEX Owner; 102 | PLAYER_INDEX Target; // ??? 103 | PLAYER_INDEX SecondaryPlayer; 104 | PLAYER_INDEX BountyTarget; // ??? 105 | SCR_VEC3 Position; // used only for CAMP_RAID 106 | GFH_TARGET_DATA TargetData; 107 | MISSION_SALE_DATA SaleData; 108 | }; 109 | static_assert(sizeof(FETCH_MANAGER_MISSION) == 28 * 8); 110 | 111 | struct FETCH_MISSION_THREAD 112 | { 113 | SCR_INT MissionIndex; 114 | SCR_BOOL CleanedUp; 115 | }; 116 | 117 | struct FETCH_MANAGER_HOST_DATA 118 | { 119 | SCR_ARRAY Missions; 120 | SCR_ARRAY(MissionLaunchType::MAX)> RunningMissionsOfType; 121 | SCR_ARRAY MissionsThreads; 122 | ACE_DATA ACEData; 123 | SCR_INT State; // init, streaming, running 124 | SCR_INT PAD_0585; 125 | SCR_INT ViableTargets; 126 | SCR_INT NumRunningMissions; 127 | }; 128 | static_assert(sizeof(FETCH_MANAGER_HOST_DATA) == 588 * 8); -------------------------------------------------------------------------------- /script/globals/GunForHireMissionData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "ACEData.hpp" 4 | 5 | enum class GFHState 6 | { 7 | INVALID = -1, 8 | IDLE, 9 | WAITING_FOR_ACE_TO_ADD, 10 | WAIT_FOR_UID, 11 | PENDING, 12 | RUNNING, 13 | ENDING, 14 | WAITING_FOR_ACE_TO_REMOVE, 15 | CLEANING_UP_MISSION, 16 | WAIT_FOR_PLAYERS_TO_CLEAR, 17 | CLEAN_INVALID_GANG 18 | }; 19 | 20 | enum class GFHGangType 21 | { 22 | INVALID = -1, 23 | PRIMARY, 24 | RIVAL 25 | }; 26 | 27 | enum class GFHGangFlag 28 | { 29 | NONE, 30 | IS_ON_INSTANCED_MISSION, 31 | IS_RELAUNCHED_MISSION, 32 | CLEANUP_MISSION_FOR_RELAUNCH 33 | }; 34 | 35 | struct GFH_TARGET_DATA 36 | { 37 | SCR_INT Target; 38 | SCR_INT Instance; 39 | SCR_INT Class; 40 | SCR_INT Subclass; 41 | }; 42 | static_assert(sizeof(GFH_TARGET_DATA) == 4 * 8); 43 | 44 | struct GFH_GANG_MISSION_DATA 45 | { 46 | SCR_INT GiverIndex; // TODO: find an enum for this one 47 | SCR_INT LocationIndex; 48 | alignas(8) GFHState State; 49 | SCR_INT MissionIndex; // -1 = INVALID, and 70 = MAX. That's all we know 50 | SCR_INT PAD_0004; 51 | SCR_GUID UID; 52 | SCR_INT ACEAddStartTime; 53 | SCR_BITSET GangFlags; 54 | GFH_TARGET_DATA Data; 55 | }; 56 | static_assert(sizeof(GFH_GANG_MISSION_DATA) == 13 * 8); 57 | 58 | struct GFH_GANG_DATA 59 | { 60 | SCR_INT GangId; 61 | SCR_INT ACESlot; 62 | alignas(8) GFHState State; 63 | GFH_GANG_MISSION_DATA MissionData; 64 | }; 65 | static_assert(sizeof(GFH_GANG_DATA) == 16 * 8); 66 | 67 | struct GFH_MISSION_DATA 68 | { 69 | SCR_ARRAY GangDatas; 70 | ACE_DATA ACEData; 71 | }; 72 | static_assert(sizeof(GFH_MISSION_DATA) == 717 * 8); 73 | 74 | enum class GFHLocationGiverHostState 75 | { 76 | INVALID = -1, 77 | INIT, 78 | RUNNING, 79 | DISABLED 80 | }; 81 | 82 | struct GFH_LOCATION_GIVER_DATA 83 | { 84 | alignas(8) GFHLocationGiverHostState State; 85 | SCR_INT TimeInitialized; 86 | }; 87 | static_assert(sizeof(GFH_LOCATION_GIVER_DATA) == 2 * 8); -------------------------------------------------------------------------------- /script/globals/MPHostData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | 4 | enum class MPGameState 5 | { 6 | INVALID = -1, 7 | GAME_INIT, 8 | LOAD_INIT_THREADS, 9 | LOAD_MAIN_THREADS, 10 | ROUTE_TRANSITION, 11 | CREATE_PLAYER_CAMP, 12 | VERIFY_MADAM_NAZAR, 13 | CHECK_FOR_INVITE, 14 | SPAWN_PLAYER, 15 | MAIN_UPDATE_FIRST_FRAME, 16 | MAIN_UPDATE, 17 | END, 18 | ALL_LEAVE 19 | }; 20 | 21 | struct MP_HOST_DATA 22 | { 23 | alignas(8) MPGameState GameState; 24 | }; 25 | static_assert(sizeof(MP_HOST_DATA) == 1 * 8); -------------------------------------------------------------------------------- /script/globals/NetCampHostData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "rage/joaat.hpp" 4 | #include // TODO: remove! 5 | 6 | enum class CampState 7 | { 8 | INVALID = -1, 9 | WAITING, 10 | RUNNING, 11 | CLEANUP 12 | }; 13 | 14 | inline std::unordered_map g_CampStateMap = { 15 | {CampState::INVALID, "Invalid"}, 16 | {CampState::WAITING, "Waiting"}, 17 | {CampState::RUNNING, "Running"}, 18 | {CampState::CLEANUP, "Cleanup"} 19 | }; 20 | 21 | enum class CampLocationIndex : std::uint32_t 22 | { 23 | GRIZZLIES_CAMP = rage::Joaat("GRIZZLIES_CAMP"), 24 | BAYOU_NAWAS_CAMP = rage::Joaat("BAYOU_NAWAS_CAMP"), 25 | BIG_VALLEY_CAMP = rage::Joaat("BIG_VALLEY_CAMP"), 26 | CHOLLA_SPRINGS_CAMP = rage::Joaat("CHOLLA_SPRINGS_CAMP"), 27 | CUMBERLAND_FOREST_CAMP = rage::Joaat("CUMBERLAND_FOREST_CAMP"), 28 | GAPTOOTH_RIDGE_CAMP = rage::Joaat("GAPTOOTH_RIDGE_CAMP"), 29 | GREAT_PLAINS_CAMP = rage::Joaat("GREAT_PLAINS_CAMP"), 30 | HEARTLAND_CAMP = rage::Joaat("HEARTLAND_CAMP"), 31 | HENNIGANS_STEAD_CAMP = rage::Joaat("HENNIGANS_STEAD_CAMP"), 32 | RIO_BRAVO_CAMP = rage::Joaat("RIO_BRAVO_CAMP"), 33 | ROANOKE_RIDGE_CAMP = rage::Joaat("ROANOKE_RIDGE_CAMP"), 34 | SCARLETT_MEADOWS_CAMP = rage::Joaat("SCARLETT_MEADOWS_CAMP"), 35 | TALL_TREES_CAMP = rage::Joaat("TALL_TREES_CAMP"), 36 | }; 37 | 38 | inline std::unordered_map g_CampLocationMap = { 39 | {CampLocationIndex::GRIZZLIES_CAMP, "Grizzlies"}, 40 | {CampLocationIndex::BAYOU_NAWAS_CAMP, "Bayou Nawas"}, 41 | {CampLocationIndex::BIG_VALLEY_CAMP, "Big Valley"}, 42 | {CampLocationIndex::CHOLLA_SPRINGS_CAMP, "Cholla Springs"}, 43 | {CampLocationIndex::CUMBERLAND_FOREST_CAMP, "Cumberland Forest"}, 44 | {CampLocationIndex::GAPTOOTH_RIDGE_CAMP, "Gaptooth Ridge"}, 45 | {CampLocationIndex::GREAT_PLAINS_CAMP, "Great Plains"}, 46 | {CampLocationIndex::HEARTLAND_CAMP, "Heartland"}, 47 | {CampLocationIndex::HENNIGANS_STEAD_CAMP, "Hennigans Stead"}, 48 | {CampLocationIndex::RIO_BRAVO_CAMP, "Rio Bravo"}, 49 | {CampLocationIndex::ROANOKE_RIDGE_CAMP, "Roanoke Ridge"}, 50 | {CampLocationIndex::SCARLETT_MEADOWS_CAMP, "Scarlett Meadows"}, 51 | {CampLocationIndex::TALL_TREES_CAMP, "Tall Trees"} 52 | }; 53 | 54 | enum class CampBit 55 | { 56 | IS_LAUNCHED, 57 | IS_ATTACKING, 58 | IS_ACTIVE, 59 | BLIP_DISABLED, 60 | WHITE_FLAG_RAISED, 61 | WHITE_FLAG_LOCKED_LOWERED, 62 | SHOW_BLIPS_HIDDEN, 63 | IS_FOLLOWER_STOLEN, 64 | SUPPRESS_FOLLOWER, 65 | FOLLOWER_DEAD, 66 | IS_CAMPWORKS_LAUNCHED, 67 | WHITE_FLAG_RAISED_PRE_CONTENT, 68 | WHITE_FLAG_LOCKED_FOR_CONTENT 69 | }; 70 | 71 | inline std::unordered_map g_CampBitMap = { 72 | {CampBit::IS_LAUNCHED, "Is Launched"}, 73 | {CampBit::IS_ATTACKING, "Is Attacking"}, 74 | {CampBit::IS_ACTIVE, "Is Active"}, 75 | {CampBit::BLIP_DISABLED, "Blip Disabled"}, 76 | {CampBit::WHITE_FLAG_RAISED, "White Flag Raised"}, 77 | {CampBit::WHITE_FLAG_LOCKED_LOWERED, "White Flag Locked Lowered"}, 78 | {CampBit::SHOW_BLIPS_HIDDEN, "Show Blips Hidden"}, 79 | {CampBit::IS_FOLLOWER_STOLEN, "Is Follower Stolen"}, 80 | {CampBit::SUPPRESS_FOLLOWER, "Suppress Follower"}, 81 | {CampBit::FOLLOWER_DEAD, "Follower Dead"}, 82 | {CampBit::IS_CAMPWORKS_LAUNCHED, "Is Campworks Launched"}, 83 | {CampBit::WHITE_FLAG_RAISED_PRE_CONTENT, "White Flag Raised Pre Content"}, 84 | {CampBit::WHITE_FLAG_LOCKED_FOR_CONTENT, "White Flag Locked For Content"} 85 | }; 86 | 87 | enum class CampContentType 88 | { 89 | NONE, 90 | NET_BEAT, 91 | DYNAMIC_MISSION, 92 | TRADER_MISSION, 93 | CAMP_RAID 94 | }; 95 | 96 | inline std::unordered_map g_CampContentTypeMap = { 97 | {CampContentType::NONE, "None"}, 98 | {CampContentType::NET_BEAT, "Net Beat"}, 99 | {CampContentType::DYNAMIC_MISSION, "Dynamic Mission"}, 100 | {CampContentType::TRADER_MISSION, "Trader Mission"}, 101 | {CampContentType::CAMP_RAID, "Camp Raid"} 102 | }; 103 | 104 | struct CAMP_LOCATION 105 | { 106 | SCR_INT Size; // tents and the main camp 107 | alignas(8) CampLocationIndex Index; 108 | SCR_INT Instance; // or similar 109 | }; 110 | 111 | struct CAMP_CONTENT 112 | { 113 | SCR_BOOL Active; // actually a bitset with a single bit 114 | alignas(8) CampContentType Type; 115 | }; 116 | 117 | struct CAMP_VOLUME_LOCKS 118 | { 119 | SCR_INT CampRequestId; 120 | SCR_INT AllRequestId; 121 | }; 122 | 123 | struct NET_HOST_CAMP 124 | { 125 | alignas(8) CampState State; 126 | CAMP_LOCATION Location; 127 | uint64_t PAD_0004[3]; 128 | SCR_BITSET Flags; 129 | uint64_t PAD_0008; 130 | PLAYER_INDEX Owner; // likely the posse leader 131 | SCR_ARRAY TentOwners; // or residents 132 | CAMP_CONTENT ActiveContent; 133 | SCR_VEC3 Position; 134 | CAMP_VOLUME_LOCKS VolumeLocks; 135 | SCR_INT RelationshipBits; 136 | SCR_INT LastVolumeUpdateTime; 137 | }; 138 | static_assert(sizeof(NET_HOST_CAMP) == 27 * 8); 139 | 140 | enum class CampRequestState 141 | { 142 | INVALID = -1, 143 | INIT, 144 | WAIT_FOR_VOLUME_LOCKS, 145 | VERIFY, 146 | UPDATE_CAMP_SIZE, 147 | FIND_NEW_CAMP_IN_DISTRICT, 148 | FIND_NEW_CAMP_ANYWHERE, 149 | COMPLETE 150 | }; 151 | 152 | struct NET_HOST_CAMP_REQUEST 153 | { 154 | alignas(8) CampRequestState State; 155 | CAMP_LOCATION Location; 156 | SCR_INT RequestId; 157 | SCR_INT Flags; // TODO 158 | SCR_INT PlacementAttempts; 159 | }; 160 | static_assert(sizeof(NET_HOST_CAMP_REQUEST) == 7 * 8); 161 | 162 | enum class CampManagerHostState 163 | { 164 | INIT, 165 | STREAM, 166 | RUNNING 167 | }; 168 | 169 | struct NetCampHostData 170 | { 171 | SCR_ARRAY Camps; 172 | SCR_ARRAY CampRequests; 173 | alignas(8) CampManagerHostState State; 174 | SCR_INT CampPlayerBitset; 175 | }; 176 | static_assert(sizeof(NetCampHostData) == 1092 * 8); -------------------------------------------------------------------------------- /script/globals/PlayerPersonaData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "rage/joaat.hpp" 4 | 5 | enum class AbilityType : std::uint32_t 6 | { 7 | STRANGE_MEDICINE = rage::Joaat("NET_PLAYER_ABILITY__STRANGE_MEDICINE"), 8 | FOCUS_FIRE = rage::Joaat("NET_PLAYER_ABILITY__FOCUS_FIRE"), 9 | NECESSITY_BREEDS = rage::Joaat("NET_PLAYER_ABILITY__NECESSITY_BREEDS"), 10 | THE_GIFT_OF_FOCUS = rage::Joaat("NET_PLAYER_ABILITY__THE_GIFT_OF_FOCUS"), 11 | RIDE_LIKE_THE_WIND = rage::Joaat("NET_PLAYER_ABILITY__RIDE_LIKE_THE_WIND"), 12 | FOOL_ME_ONCE = rage::Joaat("NET_PLAYER_ABILITY__FOOL_ME_ONCE"), 13 | GUNSLINGERS_CHOICE = rage::Joaat("NET_PLAYER_ABILITY__GUNSLINGERS_CHOICE"), 14 | COME_BACK_STRONGER = rage::Joaat("NET_PLAYER_ABILITY__COME_BACK_STRONGER"), 15 | WINNING_STREAK = rage::Joaat("NET_PLAYER_ABILITY__WINNING_STREAK"), 16 | KICK_IN_THE_BUTT = rage::Joaat("NET_PLAYER_ABILITY__KICK_IN_THE_BUTT"), 17 | PEAK_CONDITION = rage::Joaat("NET_PLAYER_ABILITY__PEAK_CONDITION"), 18 | THE_SHORT_GAME = rage::Joaat("NET_PLAYER_ABILITY__THE_SHORT_GAME"), 19 | OVERRIDE_REVENGE_SLOW_TIME = rage::Joaat("NET_PLAYER_ABILITY__OVERRIDE_REVENGE_SLOW_TIME"), 20 | IRON_LUNG = rage::Joaat("NET_PLAYER_ABILITY__IRON_LUNG"), 21 | THE_UNBLINKING_EYE = rage::Joaat("NET_PLAYER_ABILITY__THE_UNBLINKING_EYE"), 22 | INVALID = 0, 23 | FRIENDS_FOR_LIFE = rage::Joaat("NET_PLAYER_ABILITY__FRIENDS_FOR_LIFE"), 24 | NEVER_WITHOUT_ONE = rage::Joaat("NET_PLAYER_ABILITY__NEVER_WITHOUT_ONE"), 25 | OF_SINGLE_PURPOSE = rage::Joaat("NET_PLAYER_ABILITY__OF_SINGLE_PURPOSE"), 26 | A_MOMENT_TO_RECUPERATE = rage::Joaat("NET_PLAYER_ABILITY__A_MOMENT_TO_RECUPERATE"), 27 | SLIPPERY_BASTARD = rage::Joaat("NET_PLAYER_ABILITY__SLIPPERY_BASTARD"), 28 | PAINT_IT_BLACK = rage::Joaat("NET_PLAYER_ABILITY__PAINT_IT_BLACK"), 29 | TAKE_THE_PAIN_AWAY = rage::Joaat("NET_PLAYER_ABILITY__TAKE_THE_PAIN_AWAY"), 30 | EYE_FOR_AN_EYE = rage::Joaat("NET_PLAYER_ABILITY__EYE_FOR_AN_EYE"), 31 | COLD_BLOODED = rage::Joaat("NET_PLAYER_ABILITY__COLD_BLOODED"), 32 | HUNKER_DOWN = rage::Joaat("NET_PLAYER_ABILITY__HUNKER_DOWN"), 33 | QUITE_AN_INSPIRATION = rage::Joaat("NET_PLAYER_ABILITY__QUITE_AN_INSPIRATION"), 34 | TO_FIGHT_ANOTHER_DAY = rage::Joaat("NET_PLAYER_ABILITY__TO_FIGHT_ANOTHER_DAY"), 35 | HORSEMAN = rage::Joaat("NET_PLAYER_ABILITY__HORSEMAN"), 36 | LIVE_FOR_THE_FIGHT = rage::Joaat("NET_PLAYER_ABILITY__LIVE_FOR_THE_FIGHT"), 37 | HANGMAN = rage::Joaat("NET_PLAYER_ABILITY__HANGMAN"), 38 | STRENGTH_IN_NUMBERS = rage::Joaat("NET_PLAYER_ABILITY__STRENGTH_IN_NUMBERS"), 39 | SLOW_AND_STEADY = rage::Joaat("NET_PLAYER_ABILITY__SLOW_AND_STEADY"), 40 | LANDONS_PATIENCE = rage::Joaat("NET_PLAYER_ABILITY__LANDONS_PATIENCE"), 41 | SHARPSHOOTER = rage::Joaat("NET_PLAYER_ABILITY__SHARPSHOOTER") 42 | }; 43 | 44 | enum class OutfitTheme 45 | { 46 | NONE, 47 | CITY, 48 | RUGGED, 49 | MAX 50 | }; 51 | 52 | enum class ClothingFlag 53 | { 54 | IS_ANIMAL 55 | }; 56 | 57 | struct METAPED_PLAYER_CLOTHING_DATA 58 | { 59 | SCR_HASH Model; 60 | SCR_INT PAD_0001; 61 | alignas(8) OutfitTheme GangOutfitTheme; 62 | SCR_HASH Outfit; 63 | SCR_HASH OverrideOutfit; // or mission outfit 64 | SCR_HASH HeadItem; 65 | SCR_HASH FacialHairItem; 66 | SCR_HASH HairItem; 67 | SCR_HASH EyesItem; 68 | SCR_HASH TeethItem; 69 | SCR_BITSET Flags; 70 | }; 71 | static_assert(sizeof(METAPED_PLAYER_CLOTHING_DATA) == 11 * 8); 72 | 73 | struct ABILITY_EQUIP_DATA 74 | { 75 | alignas(8) AbilityType Type; 76 | SCR_INT Tier; 77 | SCR_INT PAD_0002; 78 | }; 79 | 80 | struct HONOR_INFO 81 | { 82 | SCR_INT GrossHonor; 83 | SCR_INT HonorLevel; // not sure how these values are different, if at all 84 | }; 85 | 86 | // WARNING: many of these fields are overwritten every tick 87 | struct PLAYER_PERSONA_DATA_ENTRY 88 | { 89 | SCR_INT Rank; 90 | GAMER_HANDLE Handle; 91 | HONOR_INFO HonorInfo; 92 | SCR_ARRAY Abilities; 93 | METAPED_PLAYER_CLOTHING_DATA ClothingData; 94 | SCR_FLOAT DistanceMultiplier; // unknown usage 95 | }; 96 | static_assert(sizeof(PLAYER_PERSONA_DATA_ENTRY) == 30 * 8); 97 | 98 | struct PLAYER_PERSONA_DATA 99 | { 100 | SCR_ARRAY Entries; 101 | }; 102 | static_assert(sizeof(PLAYER_PERSONA_DATA) == 961 * 8); -------------------------------------------------------------------------------- /script/globals/PlayerStatusSyncData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "unordered_map" 4 | 5 | enum class PlayerStatus 6 | { 7 | INITIALIZATION, 8 | PLAYING, 9 | JUST_DIED, 10 | DEAD, 11 | RESPAWN, 12 | POST_RESPAWN, 13 | RESPAWN_INIT, 14 | RESPAWN_FADE_WAIT, 15 | RESPAWN_INVENTORY_OVERRIDE_WAIT, 16 | RESPAWN_FIND_DESIRED_SPAWN, 17 | RESPAWN_RESURRECT, 18 | RESPAWN_UPDATE_TELEPORT, 19 | RESPAWN_STREAM_LOCATION, 20 | RESPAWN_REGION_RESET, 21 | RESPAWN_REGION_WAIT_FOR_RESET, 22 | RESPAWN_CREATE_PERSONAL_TRANSPORT, 23 | RESPAWN_INITIALIZE_PLAYER, 24 | RESPAWN_STREAM_WEAPONS, 25 | RESPAWN_ALLOW_WEAPONS_TO_EQUIP, 26 | RESPAWN_ON_SOMETHING, 27 | RESPAWN_VALIDATE_SCENARIO, 28 | RESPAWN_ARBITRARY_STREAM_WAIT, 29 | RESPAWN_EXIT, 30 | DEAD_INIT, 31 | DEAD_SHOW_DEATH, 32 | DEAD_EXIT, 33 | INVALID, 34 | CLEANUP 35 | }; 36 | 37 | enum class ParentStatus 38 | { 39 | INITIALIZATION, 40 | PLAYING, 41 | JUST_DIED, 42 | DEAD, 43 | RESPAWN, 44 | POST_RESPAWN 45 | }; 46 | 47 | enum class ScanState 48 | { 49 | INIT, 50 | FIND_DESIRED_SPAWN, 51 | START_SPAWN_SEARCH, 52 | PROCESS_SPAWN_SEARCH, 53 | VERIFY_SPAWN_LOCATION, 54 | CLEANUP, 55 | COMPLETE 56 | }; 57 | 58 | // TODO 59 | enum class PlayerFlags 60 | { 61 | SPECTATING = 5, 62 | DEAD_EYE_ACTIVE = 9, 63 | IN_JAIL = 20 64 | }; 65 | 66 | enum class PlayerStatusFlags 67 | { 68 | FORCE_RESPAWN, 69 | IN_RESPAWN_SEQUENCE, 70 | BYPASS_RESSURRECT_AND_TELEPORT, 71 | FORCE_RESPAWN_DESIRED, 72 | FORCE_RESPAWN_ABSOLUTE, 73 | FORCE_RESPAWN_AT_CAMP, 74 | FORCE_RESPAWN_IN_MOONSHINE, 75 | FORCE_RESPAWN_JAIL, 76 | FORCE_RESPAWN_FAST_TRAVEL_STATION, 77 | FORCE_RESPAWN_TRADE, 78 | FORCE_RESPAWN_DEBUG, 79 | FORCE_RESPAWN_ASAP, 80 | SCRIPT_CONTROL_OVERRIDE, 81 | MODE_OVERRIDE, 82 | MISSION_OVERRIDE, 83 | VERSUS_OVERRIDE, 84 | GENERIC_SPAWN_FAR_ONCE, 85 | PAUSE_RESPAWN_FADE_UP, 86 | SKIP_RESPAWN_FADE_IN, 87 | SKIP_RESPAWN_FADE_OUT, 88 | SKIP_LOADING_SCREEN_SHUTDOWN, 89 | DISABLE_POST_FX, 90 | DISABLE_POST_FX_ONCE, 91 | CLEANUP_MATCHMAKING_POST_FX, 92 | RESPAWN_INVISIBLE_ONCE, 93 | RESPAWN_WITHOUT_CONTROL_ONCE, 94 | REQUEST_SCRIPT_CONTROL_INFO, 95 | PREVENT_REGION_RESET, 96 | HIDE_SPECTATOR_UI, 97 | SKIP_SPECTATOR_MODE_ON_DEATH, 98 | DISABLE_SPECTATOR_MODE_ON_DEATH, 99 | INVISIBLE_TO_SPECTATOR_CAM, 100 | DISABLE_DEATH_CAM_HOLD_TIME, 101 | MAINTAIN_DEATH_CAM_ON_RESPAWN, 102 | DISABLE_LOCKON, 103 | DISABLE_FIRING, 104 | SECURITY_CLIENT, 105 | PREVENT_RESPAWN_INVINCIBILITY, 106 | CAMP_RELOAD, 107 | RESPAWN_GHOSTTOWN, 108 | FAKE_GAMER_TAG, 109 | REQUEST_CUSTOM_INVENTORY_CONFIG, 110 | RESPAWN_USE_CUSTOM_INVENTORY_CONFIG, 111 | REQUEST_CUSTOM_AMMO_UI_CONFIG, 112 | RESPAWN_USE_CUSTOM_AMMO_UI_CONFIG, 113 | DISABLE_DROP_WEAPONS_ON_DEATH, 114 | DISABLE_LOOTING, 115 | ACTIVATE_CUSTOM_CAM_ON_RESPAWN, 116 | REQUEST_CUSTOM_SPAWN_CONFIG, 117 | RESPAWN_USE_CUSTOM_SPAWN_CONFIG, 118 | USE_CUSTOM_POSITION_WITH_MOUNT, 119 | RESPAWN_WITH_COUPON, 120 | RESPAWN_WITH_COUPON_ONCE, 121 | RESPAWN_WITH_HUB, 122 | RESPAWN_WITH_HUB_ONCE, 123 | RESPAWN_WITH_HANDHELD = 59, 124 | RESPAWN_WITH_HANDHELD_ONCE, 125 | RESPAWN_WITH_BLACKBOARD, 126 | RESPAWN_WITH_BLACKBOARD_ONCE, 127 | RESPAWN_WITH_ANIMATION, 128 | RESPAWN_WITH_ANIMATION_ONCE, 129 | RESPAWN_WITH_MOUNT, 130 | RESPAWN_WITH_MOUNT_ONCE, 131 | RESPAWN_WITH_RESPOT_DISABLED, 132 | RESPAWN_WITH_RESPOT_DISABLED_ONCE, 133 | RESPAWN_ON_MOUNT, 134 | RESPAWN_ON_MOUNT_ONCE, 135 | RESPAWN_ON_TARGET_MOUNT, 136 | RESPAWN_ON_TARGET_MOUNT_ONCE, 137 | DESTROY_MOUNT_ON_RESPAWN, 138 | RESPAWN_ON_VEHICLE, 139 | RESPAWN_ON_VEHICLE_ONCE, 140 | DESTROY_VEHICLE_ON_RESPAWN, 141 | RESPAWN_WITH_VEHICLE, 142 | RESPAWN_WITH_VEHICLE_ONCE, 143 | RESPAWN_ON_VEHICLE_NAVMESH, 144 | RESPAWN_ON_VEHICLE_NAVMESH_ONCE, 145 | RESPAWN_ON_TRAIN, 146 | RESPAWN_ON_TRAIN_ONCE, 147 | RESPAWN_ON_TARGET_TRAIN, 148 | RESPAWN_ON_TARGET_TRAIN_ONCE, 149 | RESPAWN_ON_TARGET_VEHICLE, 150 | RESPAWN_ON_TARGET_VEHICLE_ONCE, 151 | RESPAWN_USE_ADJUSTED_OFFSET_FOR_TRANSPORT, 152 | RESPAWN_USE_ADJUSTED_OFFSET_FOR_TRANSPORT_ONCE, 153 | RESPAWN_DISABLE_WATER_FAILSAFE, 154 | RESPAWN_SPAWN_IN_WATER, 155 | RESPAWN_SPAWN_IN_WATER_ONCE, 156 | RESPAWN_WITH_RANDOM_SEED, 157 | RESPAWN_SPAWN_NEAR_LOCATION_ONCE, 158 | DONT_RESPAWN_IN_VOLUME_LOCKS_ONCE, 159 | REGENERATE_PEDSHOT_ONCE, 160 | RESPAWN_WITH_DESIRED_WEAPON_IN_HAND, 161 | RESPAWN_WITH_DESIRED_WEAPON_IN_HAND_ONCE, 162 | RESPAWN_WITH_BEST_WEAPON_IN_HAND, 163 | RESPAWN_WITH_BEST_WEAPON_IN_HAND_ONCE, 164 | RESPAWN_WITH_LAST_WEAPON_IN_HAND, 165 | RESPAWN_WITH_LAST_WEAPON_IN_HAND_ONCE, 166 | RESPAWN_WITH_NO_WEAPON_IN_HAND, 167 | RESPAWN_WITH_NO_WEAPON_IN_HAND_ONCE, 168 | RESPAWN_WITH_NO_WEAPON_PROCESSING, 169 | RESPAWN_WITH_NO_WEAPON_PROCESSING_ONCE, 170 | RESPAWN_WITH_NO_ANIMAL_INVULNERABILITY, 171 | RESPAWN_WITH_NO_ANIMAL_INVULNERABILITY_ONCE, 172 | PREVENT_MOUNT_RELEASE, 173 | DONT_USE_ALPHA_FADE_ON_RESPAWN, 174 | DONT_USE_ALPHA_FADE_ON_RESPAWN_ONCE, 175 | RESPAWN_LEAVES_ALIVE_PED_ONCE, 176 | FORCE_COLLISION_WHEN_RESPOT_TIMER_FINISHED, 177 | ALLOW_INCAPACITATION, 178 | STORE_DAMAGE_EVENT, 179 | PAY_BOUNTY_ON_RESPAWN, 180 | RESPAWN_PRESERVE_DEADEYE, 181 | RESPAWN_PRESERVE_HEALTH, 182 | RESPAWN_SANS_WEAPONS, 183 | REGISTER_LOADOUT_OVERRIDE_ON_RESPAWN, 184 | REQUEST_LOADOUT_OVERRIDE_REGISTRATION, 185 | CLEAR_LOADOUT_OVERRIDE_ON_RESPAWN, 186 | REFRESH_WEAPONS_IN_HAND, 187 | REFRESH_LOADOUT, 188 | REFRESH_INVENTORY_OVERRIDE, 189 | REFRESH_OUTFIT_OVERRIDE, 190 | REFRESH_AMMO_TYPE_UNLOCKS, 191 | SPECIAL_ABILITY_OVERRIDE_DEACTIVATION, 192 | SPECIAL_ABILITY_DEACTIVATE_ON_CANCEL, 193 | RESPAWN_NO_COMPONENT_LOAD, 194 | RESPAWN_NO_EXPRESSION_LOAD, 195 | RESPAWN_BLOCK_TEAM_RESET, 196 | PAUSE_RELATIONSHIP_UPDATE, 197 | DONT_PROCESS_FAST_INSTANCING, 198 | RESPAWN_INTO_FAST_INSTANCE, 199 | GANG_FEUDS_ARE_UNLOCKED, 200 | OVERRIDE_PLAYER_ABILITIES, 201 | DESTROY_CORPSE_ON_RESPAWN_ONCE, 202 | DESTROY_CORPSE_ON_RESPAWN, 203 | KEEP_CORPSE_ON_RESPAWN_ONCE, 204 | KEEP_CORPSE_ON_RESPAWN, 205 | CANNOT_BE_CARRIED_WHEN_DEAD, 206 | CLEANUP_TRANSITION_SETTINGS, 207 | DONT_CLEAR_DRUNK_FOR_SPAWNING_OR_CUTSCENES = 144, 208 | DONT_SESSION_ON_RESPAWN_ONCE, 209 | MAX 210 | }; 211 | 212 | // TODO: move this somewhere else 213 | enum class Region 214 | { 215 | INVALID = -1, 216 | BAY_CRAWDADWILLIES, 217 | BAY_MACOMBS_END, 218 | BAY_MERKINSWALLER, 219 | BAY_LAGRAS, 220 | BAY_LAKAY, 221 | BAY_SAINT_DENIS, 222 | BAY_ORANGE_PLANTATION, 223 | BAY_SERIAL_KILLER, 224 | BAY_SERENDIPITY, 225 | BAY_SHADYBELLE, 226 | BAY_SILTWATERSTRAND, 227 | BGV_APPLESEEDTIMBER, 228 | BGV_BERYLS_DREAM, 229 | BGV_BLACKBONEFOREST_TRAPPER, 230 | BGV_DAKOTARIVER_TRAPPER, 231 | BGV_FORTRIGGS, 232 | BGV_HANGINGDOG, 233 | BGV_LONEMULESTEAD, 234 | BGV_MISSING_HUSBAND, 235 | BGV_MONTO_REST, 236 | BGV_OWANJILA_DAM, 237 | BGV_PAINTEDSKY, 238 | BGV_PRONGHORN, 239 | BGV_RIGGS_STATION, 240 | BGV_SHACK, 241 | BGV_SHEPHERDS_RISE, 242 | BGV_STRAWBERRY, 243 | BGV_VALLEY_VIEW, 244 | BGV_WALLACE_STATION, 245 | BGV_OLD_MAN_JONES, 246 | BGV_WATSONSCABIN, 247 | BLU_CANEBREAK_MANOR, 248 | BLU_COPPERHEAD, 249 | BLU_SISIKA, 250 | BLU_TRAVELLING_SALESMAN, 251 | CML_BACCHUSBRIDGE, 252 | CML_DINO_LADY, 253 | CML_OLDFORTWALLACE, 254 | CML_SIXPOINTCABIN, 255 | GRT_BEECHERS, 256 | GRT_BLACKWATER, 257 | GRT_QUAKERS_COVE, 258 | GRZ_ADLERRANCH, 259 | GRZ_DEAD_RIVAL, 260 | GRZ_CHEZPORTER, 261 | GRZ_COLTER, 262 | GRZ_FROZEN_EXPLORER, 263 | GRZ_MILLESANI_CLAIM, 264 | GRZ_MOUNTAIN_MAN, 265 | GRZ_MOUNT_HAGEN_PEAK, 266 | GRZ_STARVING_CHILDREN, 267 | GRZ_TEMPEST_RIM, 268 | GRZ_WINTERMINING_TOWN, 269 | GRZ_CALUMETRAVINE, 270 | GRE_CIVIL_WAR_BRIDE, 271 | GRZ_COHUTTA, 272 | GRZ_COTORRA_SPRINGS, 273 | GRZ_GUNFIGHT, 274 | GRZ_THELOFT, 275 | GRE_VETERAN, 276 | GRZ_WAPITI, 277 | GRZ_TRAVELLING_SALESMAN, 278 | GUA_AGUASDULCES, 279 | GUA_CAMP, 280 | GUA_CINCOTORRES, 281 | GUA_LACAPILLA, 282 | GUA_MANICATO, 283 | HRT_ABANDONED_MILL, 284 | ROA_BEECHERS_C, 285 | HRT_CARMODYDELL, 286 | HRT_CORNWALLKEROSENE, 287 | HRT_CROP_FARM, 288 | HRT_CUMBERLANDFALLS, 289 | HRT_DOWNSRANCH, 290 | HRT_EMERALDRANCH, 291 | HRT_GRANGERS_HOGGERY, 292 | HRT_HORSESHOEOVERLOOK, 293 | HRT_LARNEDSOD, 294 | HRT_LOONY_CULT, 295 | HRT_LUCKYSCABIN, 296 | HRT_SWANSONS_STATION, 297 | HRT_VALENTINE, 298 | ROA_ABERDEENPIGFARM, 299 | ROA_ANNESBURG, 300 | ROA_BEAVERHOLLOW, 301 | ROA_BLACK_BALSAM_RISE, 302 | ROA_BRANDYWINE_DROP, 303 | ROA_BUTCHERCREEK, 304 | ROA_DOVERHILL, 305 | ROA_HAPPY_FAMILY, 306 | ROA_ISOLATIONIST, 307 | ROA_MACLEANSHOUSE, 308 | ROA_MOSSY_FLATS, 309 | ROA_ROANOKE_VALLEY, 310 | ROA_ROCKYSEVEN, 311 | ROA_TRAPPER, 312 | ROA_OLD_MAN_JONES, 313 | ROA_VANHORNMANSION, 314 | ROA_VANHORNPOST, 315 | SCM_BRAITHWAITEMANOR, 316 | SCM_BULGERGLADE, 317 | SCM_CALIGAHALL, 318 | SCM_CATFISHJACKSONS, 319 | SCM_CLEMENSCOVE, 320 | SCM_CLEMENSPOINT, 321 | SCM_COMPSONS_STEAD, 322 | SCM_DAIRY_FARM, 323 | SCM_HORSE_SHOP, 324 | SCM_LONNIESSHACK, 325 | SCM_LOVE_TRIANGLE, 326 | SCM_RADLEYS_PASTURE, 327 | SCM_RHODES, 328 | SCM_SLAVE_PEN, 329 | TAL_AURORA_BASIN, 330 | TAL_DEAD_SETTLER, 331 | TAL_COCHINAY, 332 | TAL_MANZANITAPOST, 333 | TAL_PACIFICUNIONRR, 334 | TAL_TANNERSREACH, 335 | TAL_TRAPPER, 336 | GAP_GAPTOOTH_BREACH, 337 | GAP_TUMBLEWEED, 338 | GAP_RATHSKELLER_FORK, 339 | RIO_BENEDICT_POINT, 340 | RIO_FORT_MERCER, 341 | RIO_PLAIN_VIEW, 342 | RIO_TRAVELLING_SALESMAN, 343 | CHO_ARMADILLO, 344 | CHO_COOTS_CHAPEL, 345 | CHO_DON_JULIO_HOUSE, 346 | CHO_RILEYS_CHARGE, 347 | CHO_RIDGEWOOD_FARM, 348 | CHO_TWIN_ROCKS, 349 | CHO_TRAVELLING_SALESMAN, 350 | CHO_TRAPPER, 351 | HEN_MACFARLANES_RANCH, 352 | HEN_THIEVES_LANDING, 353 | HEN_TRAVELLING_SALESMAN, 354 | HEN_HARRIET, 355 | CENTRALUNIONRR, 356 | MAX 357 | }; 358 | 359 | inline std::unordered_map g_RegionMap = { 360 | { Region::INVALID, "Invalid" }, 361 | { Region::BAY_CRAWDADWILLIES, "Crawdad Willies" }, 362 | { Region::BAY_MACOMBS_END, "Macomb's End" }, 363 | { Region::BAY_MERKINSWALLER, "Merkins Waller" }, 364 | { Region::BAY_LAGRAS, "Lagras" }, 365 | { Region::BAY_LAKAY, "Lakay" }, 366 | { Region::BAY_SAINT_DENIS, "Saint Denis" }, 367 | { Region::BAY_ORANGE_PLANTATION, "Orange Plantation" }, 368 | { Region::BAY_SERIAL_KILLER, "Serial Killer" }, 369 | { Region::BAY_SERENDIPITY, "Serendipity" }, 370 | { Region::BAY_SHADYBELLE, "Shady Belle" }, 371 | { Region::BAY_SILTWATERSTRAND, "Siltwater Strand" }, 372 | { Region::BGV_APPLESEEDTIMBER, "Appleseed Timber" }, 373 | { Region::BGV_BERYLS_DREAM, "Beryl's Dream" }, 374 | { Region::BGV_BLACKBONEFOREST_TRAPPER, "Blackbone Forest Trapper" }, 375 | { Region::BGV_DAKOTARIVER_TRAPPER, "Dakota River Trapper" }, 376 | { Region::BGV_FORTRIGGS, "Fort Riggs" }, 377 | { Region::BGV_HANGINGDOG, "Hanging Dog" }, 378 | { Region::BGV_LONEMULESTEAD, "Lone Mule Stead" }, 379 | { Region::BGV_MISSING_HUSBAND, "Missing Husband" }, 380 | { Region::BGV_MONTO_REST, "Monto Rest" }, 381 | { Region::BGV_OWANJILA_DAM, "Owanjila Dam" }, 382 | { Region::BGV_PAINTEDSKY, "Painted Sky" }, 383 | { Region::BGV_PRONGHORN, "Pronghorn" }, 384 | { Region::BGV_RIGGS_STATION, "Riggs Station" }, 385 | { Region::BGV_SHACK, "Shack" }, 386 | { Region::BGV_SHEPHERDS_RISE, "Shepherd's Rise" }, 387 | { Region::BGV_STRAWBERRY, "Strawberry" }, 388 | { Region::BGV_VALLEY_VIEW, "Valley View" }, 389 | { Region::BGV_WALLACE_STATION, "Wallace Station" }, 390 | { Region::BGV_OLD_MAN_JONES, "Old Man Jones" }, 391 | { Region::BGV_WATSONSCABIN, "Watson's Cabin" }, 392 | { Region::BLU_CANEBREAK_MANOR, "Canebreak Manor" }, 393 | { Region::BLU_COPPERHEAD, "Copperhead" }, 394 | { Region::BLU_SISIKA, "Sisika" }, 395 | { Region::BLU_TRAVELLING_SALESMAN, "Travelling Salesman" }, 396 | { Region::CML_BACCHUSBRIDGE, "Bacchus Bridge" }, 397 | { Region::CML_DINO_LADY, "Dino Lady" }, 398 | { Region::CML_OLDFORTWALLACE, "Old Fort Wallace" }, 399 | { Region::CML_SIXPOINTCABIN, "Six Point Cabin" }, 400 | { Region::GRT_BEECHERS, "Beechers" }, 401 | { Region::GRT_BLACKWATER, "Blackwater" }, 402 | { Region::GRT_QUAKERS_COVE, "Quakers Cove" }, 403 | { Region::GRZ_ADLERRANCH, "Adler Ranch" }, 404 | { Region::GRZ_DEAD_RIVAL, "Dead Rival" }, 405 | { Region::GRZ_CHEZPORTER, "Chez Porter" }, 406 | { Region::GRZ_COLTER, "Colter" }, 407 | { Region::GRZ_FROZEN_EXPLORER, "Frozen Explorer" }, 408 | { Region::GRZ_MILLESANI_CLAIM, "Millesani Claim" }, 409 | { Region::GRZ_MOUNTAIN_MAN, "Mountain Man" }, 410 | { Region::GRZ_MOUNT_HAGEN_PEAK, "Mount Hagen Peak" }, 411 | { Region::GRZ_STARVING_CHILDREN, "Starving Children" }, 412 | { Region::GRZ_TEMPEST_RIM, "Tempest Rim" }, 413 | { Region::GRZ_WINTERMINING_TOWN, "Winter Mining Town" }, 414 | { Region::GRZ_CALUMETRAVINE, "Calumet Ravine" }, 415 | { Region::GRE_CIVIL_WAR_BRIDE, "Gre Civil War Bride" }, 416 | { Region::GRZ_COHUTTA, "Cohutta" }, 417 | { Region::GRZ_COTORRA_SPRINGS, "Cotorra Springs" }, 418 | { Region::GRZ_GUNFIGHT, "Gunfight" }, 419 | { Region::GRZ_THELOFT, "The Loft" }, 420 | { Region::GRE_VETERAN, "Gre Veteran" }, 421 | { Region::GRZ_WAPITI, "Wapiti" }, 422 | { Region::GRZ_TRAVELLING_SALESMAN, "Travelling Salesman" }, 423 | { Region::GUA_AGUASDULCES, "Aguas Dulces" }, 424 | { Region::GUA_CAMP, "Camp" }, 425 | { Region::GUA_CINCOTORRES, "Cinco Torres" }, 426 | { Region::GUA_LACAPILLA, "La Capilla" }, 427 | { Region::GUA_MANICATO, "Manicato" }, 428 | { Region::HRT_ABANDONED_MILL, "Abandoned Mill" }, 429 | { Region::ROA_BEECHERS_C, "Beecher's C" }, 430 | { Region::HRT_CARMODYDELL, "Carmody Dell" }, 431 | { Region::HRT_CORNWALLKEROSENE, "Cornwall Kerosene" }, 432 | { Region::HRT_CROP_FARM, "Crop Farm" }, 433 | { Region::HRT_CUMBERLANDFALLS, "Cumberland Falls" }, 434 | { Region::HRT_DOWNSRANCH, "Downs Ranch" }, 435 | { Region::HRT_EMERALDRANCH, "Emerald Ranch" }, 436 | { Region::HRT_GRANGERS_HOGGERY, "Granger's Hoggery" }, 437 | { Region::HRT_HORSESHOEOVERLOOK, "Horseshoe Overlook" }, 438 | { Region::HRT_LARNEDSOD, "Larned Sod" }, 439 | { Region::HRT_LOONY_CULT, "Loony Cult" }, 440 | { Region::HRT_LUCKYSCABIN, "Lucky's Cabin" }, 441 | { Region::HRT_SWANSONS_STATION, "Swanson's Station" }, 442 | { Region::HRT_VALENTINE, "Valentine" }, 443 | { Region::ROA_ABERDEENPIGFARM, "Aberdeen Pig Farm" }, 444 | { Region::ROA_ANNESBURG, "Annesburg" }, 445 | { Region::ROA_BEAVERHOLLOW, "Beaver Hollow" }, 446 | { Region::ROA_BLACK_BALSAM_RISE, "Black Balsam Rise" }, 447 | { Region::ROA_BRANDYWINE_DROP, "Brandywine Drop" }, 448 | { Region::ROA_BUTCHERCREEK, "Butcher Creek" }, 449 | { Region::ROA_DOVERHILL, "Dover Hill" }, 450 | { Region::ROA_HAPPY_FAMILY, "Happy Family" }, 451 | { Region::ROA_ISOLATIONIST, "Isolationist" }, 452 | { Region::ROA_MACLEANSHOUSE, "Maclean's House" }, 453 | { Region::ROA_MOSSY_FLATS, "Mossy Flats" }, 454 | { Region::ROA_ROANOKE_VALLEY, "Roanoke Valley" }, 455 | { Region::ROA_ROCKYSEVEN, "Rocky Seven" }, 456 | { Region::ROA_TRAPPER, "Trapper" }, 457 | { Region::ROA_OLD_MAN_JONES, "Old Man Jones" }, 458 | { Region::ROA_VANHORNMANSION, "Van Horn Mansion" }, 459 | { Region::ROA_VANHORNPOST, "Van Horn Post" }, 460 | { Region::SCM_BRAITHWAITEMANOR, "Braithwaite Manor" }, 461 | { Region::SCM_BULGERGLADE, "Bulger Glade" }, 462 | { Region::SCM_CALIGAHALL, "Caligahall" }, 463 | { Region::SCM_CATFISHJACKSONS, "Catfish Jacksons" }, 464 | { Region::SCM_CLEMENSCOVE, "Clemens Cove" }, 465 | { Region::SCM_CLEMENSPOINT, "Clemens Point" }, 466 | { Region::SCM_COMPSONS_STEAD, "Compsons Stead" }, 467 | { Region::SCM_DAIRY_FARM, "Dairy Farm" }, 468 | { Region::SCM_HORSE_SHOP, "Horse Shop" }, 469 | { Region::SCM_LONNIESSHACK, "Lonnie's Shack" }, 470 | { Region::SCM_LOVE_TRIANGLE, "Love Triangle" }, 471 | { Region::SCM_RADLEYS_PASTURE, "Radley's Pasture" }, 472 | { Region::SCM_RHODES, "Rhodes" }, 473 | { Region::SCM_SLAVE_PEN, "Slave Pen" }, 474 | { Region::TAL_AURORA_BASIN, "Aurora Basin" }, 475 | { Region::TAL_DEAD_SETTLER, "Dead Settler" }, 476 | { Region::TAL_COCHINAY, "Cochinay" }, 477 | { Region::TAL_MANZANITAPOST, "Manzanita Post" }, 478 | { Region::TAL_PACIFICUNIONRR, "Pacific Union RR" }, 479 | { Region::TAL_TANNERSREACH, "Tanner's Reach" }, 480 | { Region::TAL_TRAPPER, "Trapper" }, 481 | { Region::GAP_GAPTOOTH_BREACH, "Gaptooth Breach" }, 482 | { Region::GAP_TUMBLEWEED, "Tumbleweed" }, 483 | { Region::GAP_RATHSKELLER_FORK, "Rathskeller Fork" }, 484 | { Region::RIO_BENEDICT_POINT, "Benedict Point" }, 485 | { Region::RIO_FORT_MERCER, "Fort Mercer" }, 486 | { Region::RIO_PLAIN_VIEW, "Plain View" }, 487 | { Region::RIO_TRAVELLING_SALESMAN, "Travelling Salesman" }, 488 | { Region::CHO_ARMADILLO, "Armadillo" }, 489 | { Region::CHO_COOTS_CHAPEL, "Coots Chapel" }, 490 | { Region::CHO_DON_JULIO_HOUSE, "Don Julio House" }, 491 | { Region::CHO_RILEYS_CHARGE, "Riley's Charge" }, 492 | { Region::CHO_RIDGEWOOD_FARM, "Ridgewood Farm" }, 493 | { Region::CHO_TWIN_ROCKS, "Twin Rocks" }, 494 | { Region::CHO_TRAVELLING_SALESMAN, "Travelling Salesman" }, 495 | { Region::CHO_TRAPPER, "Trapper" }, 496 | { Region::HEN_MACFARLANES_RANCH, "Macfarlane's Ranch" }, 497 | { Region::HEN_THIEVES_LANDING, "Thieves Landing" }, 498 | { Region::HEN_TRAVELLING_SALESMAN, "Travelling Salesman" }, 499 | { Region::HEN_HARRIET, "Harriet" }, 500 | { Region::CENTRALUNIONRR, "Central Union RR" }, 501 | { Region::MAX, "Max" } 502 | }; 503 | 504 | enum class District 505 | { 506 | INVALID = -1, 507 | BAYOU_NWA, 508 | BIG_VALLEY, 509 | BLUEGILL_MARSH, 510 | CUMBERLAND_FOREST, 511 | GREAT_PLAINS, 512 | GRIZZLIES, 513 | GRIZZLIES_EAST, 514 | GRIZZLIES_WEST, 515 | GUAMA, 516 | HEARTLAND, 517 | ROANOKE_RIDGE, 518 | SCARLETT_MEADOWS, 519 | TALL_TREES, 520 | GAPTOOTH_RIDGE, 521 | RIO_BRAVO, 522 | CHOLLA_SPRINGS, 523 | HENNIGANS_STEAD 524 | }; 525 | 526 | inline std::unordered_map g_DistrictMap = { 527 | { District::INVALID, "Invalid" }, 528 | { District::BAYOU_NWA, "Bayou Nwa" }, 529 | { District::BIG_VALLEY, "Big Valley" }, 530 | { District::BLUEGILL_MARSH, "Bluegill Marsh" }, 531 | { District::CUMBERLAND_FOREST, "Cumberland Forest" }, 532 | { District::GREAT_PLAINS, "Great Plains" }, 533 | { District::GRIZZLIES, "Grizzlies" }, 534 | { District::GRIZZLIES_EAST, "Grizzlies East" }, 535 | { District::GRIZZLIES_WEST, "Grizzlies West" }, 536 | { District::GUAMA, "Guama" }, 537 | { District::HEARTLAND, "Heartland" }, 538 | { District::ROANOKE_RIDGE, "Roanoke Ridge" }, 539 | { District::SCARLETT_MEADOWS, "Scarlett Meadows" }, 540 | { District::TALL_TREES, "Tall Trees" }, 541 | { District::GAPTOOTH_RIDGE, "Gaptooth Ridge" }, 542 | { District::RIO_BRAVO, "Rio Bravo" }, 543 | { District::CHOLLA_SPRINGS, "Cholla Springs" }, 544 | { District::HENNIGANS_STEAD, "Hennigan's Stead" } 545 | }; 546 | 547 | // seriously move this somewhere else 548 | enum class Language 549 | { 550 | UNDEFINED = -1, 551 | ENGLISH, 552 | FRENCH, 553 | GERMAN, 554 | ITALIAN, 555 | SPANISH, 556 | PORTUGESE, 557 | POLISH, 558 | RUSSIAN, 559 | KOREAN, 560 | CHINESE_TRAD, 561 | JAPANESE, 562 | MEXICAN, 563 | CHINESE_SIMP 564 | }; 565 | 566 | inline std::unordered_map g_LanguageMap = { 567 | { Language::UNDEFINED, "Undefined" }, 568 | { Language::ENGLISH, "English" }, 569 | { Language::FRENCH, "French" }, 570 | { Language::GERMAN, "German" }, 571 | { Language::ITALIAN, "Italian" }, 572 | { Language::SPANISH, "Spanish" }, 573 | { Language::PORTUGESE, "Portuguese" }, 574 | { Language::POLISH, "Polish" }, 575 | { Language::RUSSIAN, "Russian" }, 576 | { Language::KOREAN, "Korean" }, 577 | { Language::CHINESE_TRAD, "Chinese Traditional" }, 578 | { Language::JAPANESE, "Japanese" }, 579 | { Language::MEXICAN, "Mexican" }, 580 | { Language::CHINESE_SIMP, "Chinese Simplified" } 581 | }; 582 | 583 | enum class PassiveState 584 | { 585 | NOT_PASSIVE, 586 | WAITING_FOR_PASSIVE, 587 | PASSIVE, 588 | WAITING_FOR_NOT_PASSIVE, 589 | FORCED_FROM_PASSIVE 590 | }; 591 | 592 | inline std::unordered_map g_PassiveStateMap = { 593 | {PassiveState::NOT_PASSIVE, "Not Passive"}, 594 | {PassiveState::WAITING_FOR_PASSIVE, "Waiting for Passive"}, 595 | {PassiveState::PASSIVE, "Passive"}, 596 | {PassiveState::WAITING_FOR_NOT_PASSIVE, "Waiting to Leave Passive"}, 597 | {PassiveState::FORCED_FROM_PASSIVE, "Forced from Passive"} 598 | }; 599 | 600 | enum class AnimalTransformationFlag 601 | { 602 | IS_ANIMAL, 603 | PENDING_TRANSFORMATION_TO_HUMAN 604 | }; 605 | 606 | struct ANIMAL_TRANSFORMATION_DATA 607 | { 608 | SCR_INT TransitionTimestamp; 609 | SCR_BITSET Flags; 610 | }; 611 | 612 | // WARNING: the first 20 fields of this struct are overwritten every tick from another global 613 | struct PLAYER_STATUS_SYNC_DATA_ENTRY 614 | { 615 | alignas(8) PlayerStatus Status; 616 | alignas(8) ParentStatus ParentStatus; // essentially a condensed version of Status 617 | alignas(8) ScanState ScanState; 618 | SCR_BITSET Flags; 619 | SCR_BITSET_LARGE(PlayerStatusFlags::MAX)> StatusFlags; 620 | alignas(8) Region CurrentRegion; 621 | alignas(8) District CurrentDistrict; 622 | TEXT_LABEL_31 FakeGamerTag; 623 | SCR_BOOL CompletedFirstRespawn; 624 | alignas(8) Language PlayerLanguage; // can't name this Language because GCC 625 | SCR_FLOAT GangNotoriety; 626 | PLAYER_INDEX SpectateTarget; 627 | // ---------------------------------------------------------------------------------------------- 628 | GAMER_HANDLE LastPlayerKilledHandle; 629 | SCR_INT LastPlayerKilledTime; 630 | PLAYER_INDEX LastPlayerKilled; 631 | GAMER_HANDLE LastPlayerKilledByHandle; 632 | GAMER_HANDLE LastPlayerKilledByHandle2; // seemingly the same thing 633 | SCR_INT LastPlayerKilledByTime; 634 | PLAYER_INDEX LastPlayerKilledBy; 635 | SCR_FLOAT Notoriety; 636 | SCR_INT PassiveRequestTime; 637 | SCR_INT PassiveUpdateTime; 638 | alignas(8) PassiveState PassiveState; 639 | SCR_BOOL PassivePenaltyApplied; 640 | SCR_INT NotorietyFlags; 641 | ANIMAL_TRANSFORMATION_DATA AnimalTransformationData; 642 | }; 643 | static_assert(sizeof(PLAYER_STATUS_SYNC_DATA_ENTRY) == 38 * 8); 644 | 645 | struct PLAYER_STATUS_SYNC_DATA 646 | { 647 | SCR_ARRAY Entries; 648 | }; 649 | static_assert(sizeof(PLAYER_STATUS_SYNC_DATA) == 1217 * 8); -------------------------------------------------------------------------------- /script/globals/SessionManagerPlayerData.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "script/types.hpp" 3 | #include "rage/joaat.hpp" 4 | #include "PlayerStatusSyncData.hpp" 5 | 6 | enum class ContentLock 7 | { 8 | PROC_MISSIONS, 9 | GANG_EVENTS, 10 | SHOPS, 11 | HIDEOUTS, 12 | CAMPS, 13 | REGIONS, 14 | TRAINS, 15 | FM_ACTIVITIES, 16 | STORY_MISSIONS, 17 | PROPERTIES, 18 | GUN_FOR_HIRE, 19 | MINIGAMES, 20 | PLAYER_BOUNTIES, 21 | AMBIENT_ROAD_POPULATION 22 | }; 23 | 24 | struct SESSION_MANAGER_PLAYER_DATA_ENTRY 25 | { 26 | SCR_BITSET ContentLocks; 27 | uint64_t PAD_0001[3]; // unused? 28 | SCR_BITSET_LARGE(Region::MAX), 30, 7> LockedRegions; 29 | }; 30 | static_assert(sizeof(SESSION_MANAGER_PLAYER_DATA_ENTRY) == 12 * 8); 31 | 32 | struct SESSION_MANAGER_PLAYER_DATA 33 | { 34 | SCR_ARRAY Entries; 35 | }; 36 | static_assert(sizeof(SESSION_MANAGER_PLAYER_DATA) == 385 * 8); -------------------------------------------------------------------------------- /script/scrNativeHandler.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | 6 | namespace rage 7 | { 8 | class scrNativeCallContext 9 | { 10 | public: 11 | constexpr void reset() 12 | { 13 | m_ArgCount = 0; 14 | m_DataCount = 0; 15 | } 16 | 17 | template 18 | constexpr void PushArg(T&& value) 19 | { 20 | static_assert(sizeof(T) <= sizeof(std::uint64_t)); 21 | *reinterpret_cast>*>(reinterpret_cast(m_Args) + (m_ArgCount++)) = std::forward(value); 22 | } 23 | 24 | template 25 | constexpr T& GetArg(std::size_t index) 26 | { 27 | static_assert(sizeof(T) <= sizeof(std::uint64_t)); 28 | return *reinterpret_cast(reinterpret_cast(m_Args) + index); 29 | } 30 | 31 | template 32 | constexpr void SetArg(std::size_t index, T&& value) 33 | { 34 | static_assert(sizeof(T) <= sizeof(std::uint64_t)); 35 | *reinterpret_cast>*>(reinterpret_cast(m_Args) + index) = std::forward(value); 36 | } 37 | 38 | template 39 | constexpr T* GetReturnValue() 40 | { 41 | return reinterpret_cast(m_ReturnValue); 42 | } 43 | 44 | template 45 | constexpr void SetReturnValue(T&& value) 46 | { 47 | *reinterpret_cast>*>(m_ReturnValue) = std::forward(value); 48 | } 49 | protected: 50 | void* m_ReturnValue; 51 | std::uint32_t m_ArgCount; 52 | void* m_Args; 53 | std::int32_t m_DataCount; 54 | std::uint32_t m_Data[48]; 55 | }; 56 | static_assert(sizeof(scrNativeCallContext) == 0xE0); 57 | 58 | using scrNativeHash = std::int64_t; 59 | using scrNativePair = std::pair; 60 | using scrNativeHandler = void(*)(scrNativeCallContext*); 61 | } -------------------------------------------------------------------------------- /script/scrProgram.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "base/pgBase.hpp" 3 | #include "scrNativeHandler.hpp" 4 | 5 | #include 6 | 7 | namespace rage 8 | { 9 | class scrProgram : public pgBase 10 | { 11 | public: 12 | std::uint8_t **m_CodeBlocks; // 0x10 13 | std::uint32_t m_Hash; // 0x18 14 | std::uint32_t m_CodeSize; // 0x1C 15 | std::uint32_t m_ArgCount; // 0x20 16 | std::uint32_t m_LocalCount; // 0x24 17 | std::uint32_t m_GlobalCount; // 0x28 18 | std::uint32_t m_NativeCount; // 0x2C 19 | void *m_LocalData; // 0x30 20 | void **m_GlobalData; // 0x38 21 | scrNativeHandler *m_NativeEntrypoints; // 0x40 22 | std::uint32_t m_ProcCount; // 0x48 23 | char pad_004C[4]; // 0x4C 24 | const char **m_ProcNames; // 0x50 25 | std::uint32_t m_NameHash; // 0x58 26 | std::uint32_t m_RefCount; // 0x5C 27 | const char *m_Name; // 0x60 28 | const char **m_StringsData; // 0x68 29 | std::uint32_t m_StringsCount; // 0x70 30 | char m_Breakpoints[0x0C]; // 0x74 This is an atMap, which we don't have the 31 | // class for ATM. 32 | 33 | bool IsValid() const { return m_CodeSize != 0; } 34 | 35 | std::uint32_t GetNumCodePages() const { return (m_CodeSize + 0x3FFF) >> 14; } 36 | 37 | std::uint32_t GetCodePageSize(std::uint32_t page) const { 38 | auto num = GetNumCodePages(); 39 | if (page < num) { 40 | if (page == num - 1) 41 | return m_CodeSize & 0x3FFF; 42 | return 0x4000; 43 | } 44 | 45 | return 0; 46 | } 47 | 48 | std::uint32_t GetFullCodeSize() const { 49 | auto numPages = GetNumCodePages(); 50 | if (!numPages) 51 | return 0; 52 | if (numPages == 1) 53 | --numPages; 54 | 55 | return (numPages * 0x4000) + (m_CodeSize & 0x3FFF); 56 | } 57 | 58 | std::uint8_t *GetCodePage(std::uint32_t page) const { 59 | return m_CodeBlocks[page]; 60 | } 61 | 62 | std::uint8_t *GetCodeAddress(std::uint32_t index) const { 63 | if (index < m_CodeSize) 64 | return &m_CodeBlocks[index >> 14][index & 0x3FFF]; 65 | 66 | return nullptr; 67 | } 68 | 69 | const char *GetString(std::uint32_t index) const { 70 | if (index < m_StringsCount) 71 | return &m_StringsData[index >> 14][index & 0x3FFF]; 72 | 73 | return nullptr; 74 | } 75 | 76 | scrNativeHandler *GetAddressOfNativeEntrypoint(scrNativeHandler entrypoint) { 77 | for (std::uint32_t i = 0; i < m_NativeCount; ++i) { 78 | if (m_NativeEntrypoints[i] == entrypoint) { 79 | return m_NativeEntrypoints + i; 80 | } 81 | } 82 | 83 | return nullptr; 84 | } 85 | }; 86 | static_assert(sizeof(scrProgram) == 0x80); 87 | } -------------------------------------------------------------------------------- /script/scrThread.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "scrThreadContext.hpp" 3 | 4 | namespace rage 5 | { 6 | class scrThread 7 | { 8 | public: 9 | virtual ~scrThread() = default; // 0 (0x00) 10 | virtual void Reset(std::uint32_t script_hash, void* args, std::uint32_t arg_count) = 0; // 1 (0x08) 11 | virtual eThreadState Run() = 0; // 2 (0x10) 12 | virtual eThreadState Tick(std::uint32_t ops_to_execute) = 0; // 3 (0x18) 13 | virtual void Kill() = 0; // 4 (0x20) 14 | 15 | public: 16 | scrThreadContext m_Context; // 0x008 17 | void* m_Stack; // 0x6B8 18 | char m_padding[0x8]; // 0x6C0 19 | uint32_t m_ArgsSize; // 0x6C8 20 | uint32_t m_ArgsPointer; // 0x6CC 21 | const char* m_ExitMessage; // 0x6D0 22 | char m_padding2[0x8]; // 0x6D8 23 | void* m_Handler; // 0x6E0 24 | void* m_HandlerNetComponent; // 0x6E8 25 | }; 26 | static_assert(sizeof(rage::scrThread) == 0x6F0); 27 | } -------------------------------------------------------------------------------- /script/scrThreadContext.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "../rage/joaat.hpp" 5 | 6 | namespace rage 7 | { 8 | enum class eThreadState : std::uint32_t 9 | { 10 | idle, 11 | running, 12 | killed, 13 | unk_3, 14 | unk_4, 15 | }; 16 | 17 | class scrThreadContext 18 | { 19 | public: 20 | std::uint32_t m_ThreadId; // 0x00 21 | joaat_t m_ScriptHash; // 0x04 22 | eThreadState m_State; // 0x08 23 | std::uint32_t m_ProgramCounter; // 0x0C 24 | std::uint32_t m_FramePointer; // 0x10 25 | std::uint32_t m_StackPointer; // 0x14 26 | float m_TimerA; // 0x18 27 | float m_TimerB; // 0x1C 28 | float m_TimerC; // 0x20 29 | char m_padding1[0x2C]; // 0x24 30 | std::uint32_t m_StackSize; // 0x50 31 | uint32_t m_SetjmpPC; // 0x54 32 | uint32_t m_SetjmpFrame; // 0x58 33 | uint32_t m_SetjmpStack; // 0x5C 34 | uint32_t m_SetjmpUnk; // 0x60 35 | uint32_t m_StackFrameCount; // 0x64 actually used in RDR2 36 | uint32_t m_StackFrames[16]; // 0x68 37 | void* m_SecureFrames[96]; // 0xA8 38 | void* m_SecureStatics[96]; // 0x3A8 39 | void* m_UnkSecureVar; // 0x6A8 40 | }; 41 | static_assert(sizeof(scrThreadContext) == 0x6B0); 42 | } -------------------------------------------------------------------------------- /script/scrVector.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../rage/vector.hpp" 3 | #include 4 | #include 5 | #include 6 | 7 | namespace rage 8 | { 9 | class scrVector 10 | { 11 | public: 12 | scrVector() = default; 13 | 14 | scrVector(rage::fvector3 vec) : 15 | x(vec.x), y(vec.y), z(vec.z) 16 | { 17 | } 18 | 19 | scrVector(float x, float y, float z) : 20 | x(x), y(y), z(z) 21 | { 22 | } 23 | 24 | scrVector operator+(const scrVector& other) 25 | { 26 | scrVector vec; 27 | vec.x = this->x + other.x; 28 | vec.y = this->y + other.y; 29 | vec.z = this->z + other.z; 30 | return vec; 31 | } 32 | 33 | scrVector operator-(const scrVector& other) 34 | { 35 | scrVector vec; 36 | vec.x = this->x - other.x; 37 | vec.y = this->y - other.y; 38 | vec.z = this->z - other.z; 39 | return vec; 40 | } 41 | 42 | scrVector operator*(const scrVector& other) 43 | { 44 | scrVector vec; 45 | vec.x = this->x * other.x; 46 | vec.y = this->y * other.y; 47 | vec.z = this->z * other.z; 48 | return vec; 49 | } 50 | 51 | scrVector operator*(const float& other) 52 | { 53 | scrVector vec; 54 | vec.x = this->x * other; 55 | vec.y = this->y * other; 56 | vec.z = this->z * other; 57 | return vec; 58 | } 59 | 60 | bool operator==(const scrVector& other) 61 | { 62 | return this->x == other.x && this->y == other.y && this->z == other.z; 63 | } 64 | 65 | bool operator!=(const scrVector& other) 66 | { 67 | return this->x != other.x || this->y != other.y || this->z != other.z; 68 | } 69 | 70 | std::string ToString() const 71 | { 72 | std::stringstream ss; 73 | ss << *this; 74 | return ss.str(); 75 | } 76 | 77 | friend std::ostream& operator<<(std::ostream& os, const scrVector& vec) 78 | { 79 | os << "(" << vec.x << ", " << vec.y << ", " << vec.z << ")"; 80 | return os; 81 | } 82 | 83 | operator rage::fvector3() 84 | { 85 | return { x, y, z }; 86 | } 87 | 88 | alignas(8) float x{}; 89 | alignas(8) float y{}; 90 | alignas(8) float z{}; 91 | }; 92 | } 93 | 94 | class Vector2 final 95 | { 96 | public: 97 | Vector2() = default; 98 | 99 | Vector2(float x, float y) 100 | : x(x), y(y) 101 | { 102 | } 103 | 104 | public: 105 | alignas(8) float x; 106 | alignas(8) float y; 107 | }; 108 | 109 | class Vector4 final 110 | { 111 | public: 112 | Vector4() = default; 113 | 114 | Vector4(float x, float y, float z, float w) 115 | : x(x), y(y), z(z), w(w) 116 | { 117 | } 118 | 119 | public: 120 | alignas(8) float x; 121 | alignas(8) float y; 122 | alignas(8) float z; 123 | alignas(8) float w; 124 | }; -------------------------------------------------------------------------------- /script/scriptHandlerNetComponent.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CNetGamePlayer; 4 | 5 | class CScriptParticipant 6 | { 7 | public: 8 | char m_Pad[16]; // 0x0000 9 | class CNetGamePlayer *m_NetGamePlayer; // 0x0010 10 | char m_Pad2[2]; // 0x0018 11 | int16_t m_ParticipantIndex; // 0x001A 12 | char m_Pad3[12]; // 0x001C 13 | }; 14 | static_assert(sizeof(CScriptParticipant) == 0x28); 15 | 16 | #pragma pack(push, 8) 17 | namespace rage 18 | { 19 | class scriptHandler; 20 | class scriptHandlerNetComponent 21 | { 22 | public: 23 | virtual ~scriptHandlerNetComponent() = default; 24 | virtual bool _0x08(void *) = 0; 25 | virtual void _0x10(CNetGamePlayer *) = 0; 26 | virtual void *HandlePlayerLeft(CNetGamePlayer *player) = 0; 27 | virtual void *SendHostMigrationEvent(CNetGamePlayer *player) = 0; 28 | virtual void PlayerJoined(void **, void *msg_ctx) = 0; 29 | virtual void PlayerJoinedAck(void **, void *msg_ctx) = 0; 30 | virtual void PlayerJoinedHostAck(void *, void *) = 0; 31 | virtual void *_0x40(void *, void *) = 0; 32 | virtual void *_0x48(void *, void *, void *) = 0; 33 | virtual void *_0x50(void *, void *) = 0; 34 | virtual void *_0x58(void *, void *) = 0; 35 | virtual void *_0x60(void *, void *) = 0; 36 | virtual void *_0x68(void *, void *) = 0; 37 | virtual void _0x70(void *, void *) = 0; 38 | virtual void _0x78(void *, void *) = 0; 39 | virtual short _0x80(void *, void *) = 0; 40 | virtual void *_0x88(void *, void *) = 0; 41 | virtual void *_0x90(void *, void *) = 0; 42 | virtual bool _0x98(void *, void *) = 0; 43 | virtual void *_0xA0(void *, void *) = 0; 44 | virtual void *_0xA8(void *, void *) = 0; 45 | virtual short _0xB0(void *, void *) = 0; 46 | virtual short _0xB8(void *, void *) = 0; 47 | virtual short _0xC0(void *, void *) = 0; 48 | virtual bool RegisterHostBroadcastData(void *data, int size, char *a3) = 0; 49 | virtual bool RegisterPlayerBroadcastData(int a1, int size, bool a3) = 0; 50 | virtual bool CanStartJoining() = 0; 51 | virtual bool _0xE0() = 0; 52 | virtual bool AddPlayerToScript(CNetGamePlayer *player, 53 | short *out_participant_id, 54 | short *out_slot_number, 55 | int *out_fail_reason) = 0; 56 | virtual bool AddPlayerToScriptImpl(CNetGamePlayer *player, 57 | short participant_id, 58 | short slot_number) = 0; 59 | virtual bool RemovePlayerFromScript(CNetGamePlayer *player) = 0; 60 | virtual void *PlayerLeftImpl(CNetGamePlayer *, bool) = 0; 61 | virtual bool DoHostMigration(CNetGamePlayer *player, short host_token, 62 | bool unk) = 0; 63 | virtual void *LeaveFromScript() = 0; 64 | 65 | public: 66 | scriptHandler *m_ScriptHandler; // 0x08 67 | char m_Pad[0x20]; // 0x10 68 | CScriptParticipant *m_Host; // 0x30 69 | std::uint8_t m_LocalParticipantId; // 0x38 70 | void *m_Pad2[4]; // 0x40 71 | CScriptParticipant *m_Participants[32]; // 0x60 72 | int m_Pad3[3]; // 0x160 73 | std::uint8_t m_NumParticipants; // 0x168 74 | 75 | inline CNetGamePlayer *GetHost() const 76 | { 77 | if (!m_Host) 78 | return nullptr; 79 | 80 | return m_Host->m_NetGamePlayer; 81 | } 82 | }; 83 | static_assert(sizeof(rage::scriptHandlerNetComponent) == 0x170); 84 | } 85 | #pragma pack(pop) -------------------------------------------------------------------------------- /script/scriptId.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "scriptIdBase.hpp" 3 | 4 | #pragma pack(push, 8) 5 | namespace rage 6 | { 7 | class scriptId : public scriptIdBase 8 | { 9 | public: 10 | joaat_t m_ScriptHash; // 0x08 11 | }; 12 | static_assert(sizeof(scriptId) == 0x10); 13 | } 14 | 15 | class CGameScriptId : public rage::scriptId 16 | { 17 | public: 18 | int m_Timestamp; // 0x10 (verify) 19 | int m_ObjectBrainPositionHash; // 0x14 20 | union 21 | { 22 | int m_PedBrainObjectId; // 0x18 23 | int m_WorldPointBrainIndex; // 0x18 24 | int m_FallbackId; // 0x18 25 | }; 26 | int m_InstanceHash; // 0x1C (derived from brain parameters) 27 | bool m_IsPedBrainScript; // 0x20 28 | }; 29 | 30 | static_assert(sizeof(CGameScriptId) == 0x28); 31 | #pragma pack(pop) -------------------------------------------------------------------------------- /script/scriptIdBase.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../rage/joaat.hpp" 4 | 5 | #pragma pack(push, 8) 6 | namespace rage 7 | { 8 | class datBitBuffer; 9 | class netLoggingInterface; 10 | class scrThread; 11 | 12 | class scriptIdBase 13 | { 14 | public: 15 | virtual ~scriptIdBase() = default; 16 | 17 | // Assumes the script thread's identity. 18 | virtual void FromThread(scrThread*) {}; 19 | 20 | // Returns whether the hash of the script id is valid. 21 | virtual bool IsValid() { return false; }; 22 | 23 | // Gets the hash of the script id. 24 | virtual joaat_t* GetHash(joaat_t* out) { return 0; }; 25 | 26 | // Gets an unknown value from the script id. 27 | virtual std::uint32_t* GetInstanceHash(std::uint32_t* out) { return 0; }; 28 | 29 | // Serializes the script id from the buffer. 30 | virtual void Deserialize(datBitBuffer* buffer) {}; 31 | 32 | // Serializes the script id to the buffer. 33 | virtual void Serialize(datBitBuffer* buffer) {}; 34 | 35 | // Calculates bitbuffer size. 36 | virtual std::uint32_t CalculateSize() { return 0; }; 37 | 38 | // Calls _0x40 and returns its value added to another value. (packed size?) 39 | virtual std::uint32_t CalculateSize2() { return 0; }; 40 | 41 | // Gets the hash of the script id again. 42 | virtual joaat_t GetHash2() { return 0; } 43 | 44 | // Copies the information of other to this object. 45 | virtual void FromScriptId(scriptIdBase* other) {} 46 | 47 | // Returns whether the other script id is equal. 48 | virtual bool operator==(scriptIdBase*) { return false; }; 49 | 50 | virtual bool SameScriptHash(scriptIdBase*) { return false; }; 51 | }; 52 | } 53 | #pragma pack(pop) -------------------------------------------------------------------------------- /script/types.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "scrVector.hpp" 4 | 5 | #ifndef BOOL 6 | #define BOOL int 7 | #endif 8 | 9 | using Vector3 = rage::scrVector; 10 | typedef int Void; 11 | typedef int Any; 12 | typedef int uint; 13 | typedef int Hash; 14 | typedef int Entity; 15 | typedef int Player; 16 | typedef int FireId; 17 | typedef int Ped; 18 | typedef int Vehicle; 19 | typedef int Cam; 20 | typedef int CarGenerator; 21 | typedef int Group; 22 | typedef int Train; 23 | typedef int Pickup; 24 | typedef int Object; 25 | typedef int Weapon; 26 | typedef int Interior; 27 | typedef int Blip; 28 | typedef int Texture; 29 | typedef int TextureDict; 30 | typedef int CoverPoint; 31 | typedef int Camera; 32 | typedef int TaskSequence; 33 | typedef int ColourIndex; 34 | typedef int Sphere; 35 | typedef int INT, ScrHandle; 36 | typedef int AnimScene; 37 | typedef int Volume; 38 | typedef int ItemSet; 39 | typedef int PropSet; 40 | typedef int PopZone; 41 | typedef int PersChar; 42 | typedef int Prompt; 43 | 44 | #define PLAYER_INDEX alignas(8) int 45 | #define ENTITY_INDEX alignas(8) int 46 | #define PED_INDEX alignas(8) int 47 | #define PICKUP_INDEX alignas(8) int 48 | #define VEHICLE_INDEX alignas(8) int 49 | #define INTERIOR_INDEX alignas(8) int 50 | #define NETWORK_INDEX alignas(8) int 51 | 52 | #define SCR_HASH alignas(8) Hash 53 | #define SCR_INT alignas(8) int 54 | #define SCR_BOOL alignas(8) BOOL 55 | #define SCR_FLOAT alignas(8) float 56 | #define SCR_VEC3 Vector3 57 | 58 | template 59 | struct SCR_TEXT_LABEL 60 | { 61 | alignas(8) char Data[SIZE]; 62 | public: 63 | operator char* () { return Data; } 64 | }; 65 | 66 | #define TEXT_LABEL_15 SCR_TEXT_LABEL<16> 67 | #define TEXT_LABEL_23 SCR_TEXT_LABEL<24> 68 | #define TEXT_LABEL_31 SCR_TEXT_LABEL<32> 69 | #define TEXT_LABEL_63 SCR_TEXT_LABEL<64> 70 | 71 | template 72 | struct SCR_ARRAY 73 | { 74 | SCR_INT Size; 75 | alignas(8) T Data[SIZE]; 76 | 77 | T& operator [](int index) 78 | { 79 | return Data[index]; 80 | } 81 | }; 82 | 83 | template 84 | struct SCR_BITSET 85 | { 86 | alignas(8) int Value; 87 | 88 | bool IsSet(T val) 89 | { 90 | return Value & (1 << (int)val); 91 | } 92 | 93 | void Set(T val) 94 | { 95 | Value |= (1 << (int)val); 96 | } 97 | 98 | void Clear(T val) 99 | { 100 | Value &= ~(1 << (int)val); 101 | } 102 | }; 103 | 104 | /// This is very untested, beware! 105 | /// MODULUS should be 32 for maximum efficiency but most Rockstar scripts use 31 106 | template 107 | struct SCR_BITSET_LARGE 108 | { 109 | SCR_ARRAY Array; 110 | 111 | bool IsSet(T val) 112 | { 113 | return Array[(int)val / MODULUS] & (1 << ((int)val % MODULUS)); 114 | } 115 | 116 | void Set(T val) 117 | { 118 | Array[(int)val / MODULUS] |= (1 << ((int)val % MODULUS)); 119 | } 120 | 121 | void Clear(T val) 122 | { 123 | Array[(int)val / MODULUS] &= ~(1 << ((int)val % MODULUS)); 124 | } 125 | }; 126 | 127 | struct SCR_DATE 128 | { 129 | SCR_INT Year; 130 | SCR_INT Month; 131 | SCR_INT Day; 132 | SCR_INT Hour; 133 | SCR_INT Minute; 134 | SCR_INT Second; 135 | SCR_INT Millisecond; 136 | }; 137 | 138 | struct SCR_GUID 139 | { 140 | SCR_INT Element1; 141 | SCR_INT Element2; 142 | }; 143 | 144 | struct Color3 145 | { 146 | SCR_INT R; 147 | SCR_INT G; 148 | SCR_INT B; 149 | }; 150 | static_assert(sizeof(Color3) == 3 * 8); 151 | 152 | // serialized bitbuffer data of rage::rlGamerHandle 153 | struct GAMER_HANDLE 154 | { 155 | private: 156 | uint64_t Data[2]; 157 | }; 158 | static_assert(sizeof(GAMER_HANDLE) == 2 * 8); -------------------------------------------------------------------------------- /train/CTrainConfig.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | #include "rage/atArray.hpp" 7 | 8 | class CTrainCarriageInfo 9 | { 10 | public: 11 | uint32_t m_ModelName; 12 | uint32_t _0x5E64EA3E; 13 | uint32_t _0xE2BDEA7B; 14 | uint32_t _0xECA6D302; 15 | uint32_t _0xFBF5C716; 16 | float _0x46B81FF8; 17 | float _0xEC4633A5; 18 | uint _0x535A0BBE; 19 | uint m_ModelId; 20 | int m_Extras; 21 | bool _0x153918B6; 22 | bool _0x88A76D74; 23 | bool _0xC77853E4; 24 | uint8_t m_TintPreset; 25 | }; 26 | static_assert(sizeof(CTrainCarriageInfo) == 0x2C); 27 | 28 | class CTrainConfigRef 29 | { 30 | public: 31 | uint32_t m_TrainConfigName; 32 | uint8_t _0x07E33620; 33 | }; 34 | static_assert(sizeof(CTrainConfigRef) == 0x8); 35 | 36 | class CTrainConfig 37 | { 38 | public: 39 | uint32_t m_Name; 40 | float _0x0ED29061; 41 | float _0xE43D854D; 42 | float _0x72443177; 43 | float _0xA50FC0EB; 44 | bool _0xFD90C5F8; 45 | bool _0x0546B416; 46 | bool _0xD41F8E7D; 47 | bool m_CarriagesSwing; 48 | bool _0xEDD766A7; 49 | bool _0xDB277834; 50 | bool m_NoRandomSpawn; 51 | bool m_NoDriver; 52 | float m_CarriageGap; 53 | rage::atArray m_Carriages; 54 | uint32_t _0xA400A33A; 55 | float m_DefaultMaxSpeed; 56 | float m_MaxAcceleration; 57 | float m_MaxDeceleration; 58 | bool m_IsTram; 59 | }; 60 | static_assert(sizeof(CTrainConfig) == 0x48); 61 | 62 | class CTrainConfigGroup 63 | { 64 | public: 65 | uint32_t m_Name; 66 | rage::atArray m_Refs; 67 | }; 68 | static_assert(sizeof(CTrainConfigGroup) == 0x18); 69 | 70 | class CTrainConfigs 71 | { 72 | public: 73 | rage::atArray m_TrainConfigs; 74 | rage::atArray m_TrainGroups; 75 | }; --------------------------------------------------------------------------------