Invoker stuff (YimMenu#1)

* feat: initialize classes repo

* feat(script): stuff for native invoker

* feat: add some more classes

* feat(player): complete CNetworkPlayerMgr

* feat(network): add some more stuff

* feat(network): add rlGamerInfo

* feat(player): add CPlayerInfo

Author: maybegreat48

.gitignore

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

CMakeLists.txt

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

classes.cpp

@@ -0,0 +1,17 @@
+#include "network/CNetGamePlayer.hpp"
+#include "network/CNetworkPlayerMgr.hpp"
+#include "network/netPeerAddress.hpp"
+#include "network/netPlayer.hpp"
+#include "network/netPlayerMgrBase.hpp"
+#include "network/rlGamerHandle.hpp"
+#include "network/rlGamerInfoBase.hpp"
+#include "network/rlGamerInfo.hpp"
+#include "player/CPlayerInfo.hpp"
+#include "rage/joaat.hpp"
+#include "rage/vector.hpp"
+#include "script/scriptHandlerNetComponent.hpp"
+#include "script/scrNativeHandler.hpp"
+#include "script/scrThread.hpp"
+#include "script/scrThreadContext.hpp"
+#include "script/scrVector.hpp"
+#include "script/types.hpp"

network/CNetGamePlayer.hpp

@@ -0,0 +1,11 @@
+#pragma once
+#include "netPlayer.hpp"
+
+class CPlayerInfo;
+class CNetGamePlayer : public rage::netPlayer
+{
+public:
+	CPlayerInfo* m_PlayerInfo; //0x0128
+	char pad_0130[2432]; //0x0130
+}; //Size: 0x0AB0
+static_assert(sizeof(CNetGamePlayer) == 0xAB0);

network/CNetworkPlayerMgr.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include "netPlayerMgrBase.hpp"
+#include "CNetGamePlayer.hpp"
+
+#include <cstdint>
+#pragma pack(push, 8)
+class CNetworkPlayerMgr : public rage::netPlayerMgrBase
+{
+public:
+	CNetGamePlayer m_PlayerStorage[32]; // 0x08E0
+	CNetGamePlayer* m_FirstPlayer;      // 0x15EE0
+	CNetGamePlayer* m_LastPlayer;       // 0x15EE8
+	std::uint64_t m_UnkCounter;         // 0x15EF0
+};
+static_assert(sizeof(CNetworkPlayerMgr) == 0x15EF8);
+#pragma pack(pop)

network/netPeerAddress.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include <cstdint>
+
+union netAddress {
+	uint32_t m_packed; //0x0000
+	struct {
+		uint8_t m_field4; //0x0000
+		uint8_t m_field3; //0x0001
+		uint8_t m_field2; //0x0002
+		uint8_t m_field1; //0x0003
+	};
+}; //Size: 0x0004
+static_assert(sizeof(netAddress) == 0x04);
+
+namespace rage
+{
+#pragma pack(push, 4)
+	class netPeerAddress
+	{
+	public:
+		netAddress m_internal_ip; //0x0000
+		uint16_t m_internal_port; //0x0004
+		netAddress m_external_ip; //0x0008
+		uint16_t m_external_port; //0x000C
+		uint64_t m_peer_id; //0x0010
+		netAddress m_relay_address; //0x0018
+		uint16_t m_relay_port; //0x001C
+		uint8_t m_connection_type; //0x001E
+	};
+	static_assert(sizeof(netPeerAddress) == 0x20);
+#pragma pack(pop)
+}

network/netPlayer.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include <cstdint>
+
+namespace rage
+{
+	class rlGamerInfo;
+	class netPlayer
+	{
+	public:
+		virtual ~netPlayer() = default;                                   // 0x00
+		virtual void Initialize(void* unk, int message_id, int unk2) {};  // 0x08
+		virtual void Initialize2(int unk) {};                             // 0x10
+		virtual void Reset() {};                                          // 0x18
+		virtual bool IsValid() { return false; };                         // 0x20
+		virtual const char* GetName() { return nullptr; };                // 0x28
+		virtual void* GetUnk() { return nullptr; };                       // 0x30
+		virtual void SetTeam(int new_team) {};                            // 0x38
+		virtual bool IsSameTeam(netPlayer* other) { return false; };      // 0x40
+		virtual void _0x48() {};                                          // 0x48 some posse stuff
+		virtual void RefreshData() {};                                    // 0x50
+		virtual bool IsHost() { return true; };                           // 0x58
+		virtual rage::rlGamerInfo* GetGamerInfo() { return nullptr; };    // 0x60
+
+		char pad_0008[12]; //0x0008
+		uint32_t m_MessageId; //0x0014
+		uint8_t m_ActiveIndex; //0x0018
+		uint8_t m_PlayerIndex; //0x0019
+		char pad_001A[10]; //0x001A
+		uint32_t m_JoinTime; //0x0024
+		char pad_0028[4]; //0x0028
+		uint32_t m_Team; //0x002C
+		char pad_0030[248]; //0x0030
+	}; //Size: 0x0128
+	static_assert(sizeof(rage::netPlayer) == 0x128);
+}

network/netPlayerMgrBase.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include <cstdint>
+
+class CNetGamePlayer;
+class CNetGamePlayerDataMsg;
+class CNonPhysicalPlayerData;
+
+namespace rage
+{
+	class rlGamerInfo;
+	class netConnectionManager;
+#pragma pack(push, 8)
+	// the same as GTA 1.63
+	class netPlayerMgrBase
+	{
+	public:
+		virtual ~netPlayerMgrBase() = default;
+		virtual void Initialize() = 0;
+		virtual void Shutdown() = 0;
+		virtual void unk_0x18() = 0;
+		virtual CNetGamePlayer* AddPlayer_raw(rage::rlGamerInfo* gamer_info, uint32_t a2, CNetGamePlayerDataMsg* player_data, CNonPhysicalPlayerData* non_physical_player_data) = 0;
+		virtual void RemovePlayer(CNetGamePlayer* net_game_player) = 0;
+		virtual void UpdatePlayerListsForPlayer(CNetGamePlayer* net_game_player) = 0;
+		virtual CNetGamePlayer* AddPlayer(rage::rlGamerInfo* gamer_info, uint32_t a3, CNetGamePlayerDataMsg* player_data, CNonPhysicalPlayerData* non_physical_player_data) = 0;
+
+		rage::netConnectionManager* m_NetConnectionManager; //0x0008
+		uint64_t* m_NetBandwidthManager; //0x0010
+		char pad_0018[208]; //0x0018
+		CNetGamePlayer* m_LocalPlayer; //0x00E8
+		char pad_00F0[144]; //0x00F0
+		CNetGamePlayer* m_PlayerList[32]; //0x0180 (TODO: is this used?)
+		uint16_t m_PlayerLimit; //0x0280
+		char pad_0282[10]; //0x0282
+		uint16_t m_PlayerCount; //0x028C
+		char pad_0290[1618]; //0x0290
+	}; //Size: 0x08E0
+	static_assert(sizeof(netPlayerMgrBase) == 0x8E0);
+#pragma pack(pop)
+}

network/rlGamerHandle.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstdint>
+
+namespace rage
+{
+#pragma pack(push,8)
+    class rlGamerHandle
+    {
+    public:
+        uint64_t m_rockstar_id; //0x0000
+        uint8_t m_platform; //0x0008
+        uint8_t unk_0009; //0x0009
+
+        inline rlGamerHandle() = default;
+
+        inline rlGamerHandle(uint64_t rockstar_id) :
+            m_rockstar_id(rockstar_id),
+            m_platform(3),
+            unk_0009(0)
+        {
+        }
+    }; //Size: 0x0010
+    static_assert(sizeof(rlGamerHandle) == 0x10);
+#pragma pack(pop)
+}

network/rlGamerInfo.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <cstdint>
+#include "rlGamerInfoBase.hpp"
+
+#pragma pack(push, 8)
+namespace rage
+{
+	class rlGamerInfo : public rage::rlGamerInfoBase
+	{
+		uint64_t m_HostToken;
+		uint64_t m_PeerId2;
+		rage::rlGamerHandle m_GamerHandle2;
+		uint32_t m_ProfileIndex;
+		char m_Name[21];
+		uint8_t m_Flags;
+	};
+	static_assert(sizeof(rage::rlGamerInfo) == 0xD8);
+}
+#pragma pack(pop)