Net, Animation, and Train class improvements (#35)

* feat: expose object GUID info

* fix: stop using bitfields

* feat(netsync): add CAnimSceneInfrequentData

* feat(train): add CTrainConfig and more

* feat(netsync): add CAnimSceneCreationData

* fix(server): fix server messages and encryption keys

* feat(netsync): add CPedHealthData and CPedVitalityData

classes.cpp

@@ -19,6 +19,7 @@
 #include "network/CNetworkScSessionPlayer.hpp"
 #include "network/CScriptedGameEvent.hpp"
 #include "network/InFrame.hpp"
+#include "network/netEncryption.hpp"
 #include "network/netGameEvent.hpp"
 #include "network/netObject.hpp"
 #include "network/netPeerAddress.hpp"
@@ -41,10 +42,14 @@
 #include "network/sync/netSyncNodeBase.hpp"
 #include "network/sync/netSyncTree.hpp"
 #include "network/sync/animal/CAnimalCreationData.hpp"
+#include "network/sync/animscene/CAnimSceneCreationData.hpp"
+#include "network/sync/animscene/CAnimSceneInfrequentData.hpp"
 #include "network/sync/object/CObjectCreationData.hpp"
 #include "network/sync/ped/CPedAttachData.hpp"
 #include "network/sync/ped/CPedCreationData.hpp"
+#include "network/sync/ped/CPedHealthData.hpp"
 #include "network/sync/ped/CPedTaskTreeData.hpp"
+#include "network/sync/ped/CPedVitalityData.hpp"
 #include "network/sync/physical/CPhysicalAttachData.hpp"
 #include "network/sync/pickup/CPickupCreationData.hpp"
 #include "network/sync/player/CPlayerAppearanceData.hpp"
@@ -93,3 +98,4 @@
 #include "script/scriptIdBase.hpp"
 #include "script/scrProgram.hpp"
 #include "script/types.hpp"
+#include "train/CTrainConfig.hpp"

network/netEncryption.hpp

@@ -0,0 +1,12 @@
+#pragma once
+#include <cstdint>
+
+namespace rage
+{
+	class netEncryptionOverride
+	{
+	public:
+		char m_OverrideKey[33];
+		std::uint8_t m_EncryptionFlags;
+	};
+}

network/netObject.hpp

@@ -7,6 +7,44 @@ namespace rage
     class netObject
     {
     public:
+#pragma pack(push, 1)
+        struct GUID
+        {
+            std::uint64_t m_Data1;
+            std::uint64_t m_Data2;
+
+            std::uint32_t GetAccountId() const
+            {
+                return m_Data2 & 0xFFFFFFFF;
+            }
+
+            std::uint16_t GetAccountComponent() const
+            {
+                return (m_Data2 >> 32) & 0xFFFF;
+            }
+
+            std::uint64_t GetCreationTime() const
+            {
+                return m_Data1 & 0xFFFFFFFFFFFF;
+            }
+
+            std::uint16_t GetObjectToken() const
+            {
+                return m_Data1 >> 48;
+            }
+
+            std::uint16_t GetObjectType() const
+            {
+                return (m_Data2 >> 48) & 0xFF;
+            }
+
+            std::uint8_t GetCreationCycle() const
+            {
+                return m_Data2 >> 56;
+            }
+        };
+#pragma pack(pop)
+
         virtual ~netObject() = 0;
 
         char m_Pad[0x38];              // 0x08
@@ -18,6 +56,8 @@ namespace rage
         bool m_IsRemotelyControlled;   // 0x47
         char m_Pad2[0xA8];             // 0x48
         int m_OwnershipToken;          // 0xF0
+        char m_Pad3[0x14];             // 0xF4
+        GUID m_Guid;                   // 0x108
     };
-    static_assert(sizeof(rage::netObject) == 0xF8);
+    static_assert(sizeof(rage::netObject) == 0x118);
 }

network/netServerMessages.hpp

@@ -3,41 +3,41 @@
 
 namespace rage 
 {
-class ServerRPCSerializer 
-{
-public:
-  virtual int dtor() = 0;
-  virtual int Unk() = 0;
-  virtual void *GetData() = 0;
-  virtual int GetSize() = 0;
-};
+	class netRpcBuilder 
+	{
+	public:
+		virtual ~netRpcBuilder() = default;
+		virtual int Unk() = 0;
+		virtual void* GetData() = 0;
+		virtual int GetSize() = 0;
+	};
 
-class ServerMsgData 
-{
-public:
-  unsigned char *data;
-  int size;
-  bool is_json;
-};
+	class netRpcReaderContext 
+	{
+	public:
+		void* m_Data;
+		int m_Size;
+		void* m_JsonReader;
+	};
 
-class ServerMsg 
-{
-public:
-  virtual ~ServerMsg() = default;
-  virtual void _0x08() = 0;
-  virtual void _0x10() = 0;
-  virtual void _0x18() = 0;
-  virtual void _0x20() = 0;
-  virtual void _0x28() = 0;
-  virtual void _0x30() = 0;
-  virtual const char *GetName() = 0;
-  virtual void _0x40() = 0;
-  virtual void _0x48() = 0;
-  virtual void _0x50() = 0;
-  virtual void _0x58() = 0;
-  virtual void _0x60() = 0;
-  virtual void _0x68() = 0;
-  virtual void _0x70() = 0;
-  virtual ServerMsgData *GetMsgData() = 0;
-};
+	class netRpcReader 
+	{
+	public:
+		virtual ~netRpcReader() = default;
+		virtual void _0x08() = 0;
+		virtual void _0x10() = 0;
+		virtual void _0x18() = 0;
+		virtual void _0x20() = 0;
+		virtual void _0x28() = 0;
+		virtual void _0x30() = 0;
+		virtual const char* GetName() = 0;
+		virtual void _0x40() = 0;
+		virtual void _0x48() = 0;
+		virtual void _0x50() = 0;
+		virtual void _0x58() = 0;
+		virtual void _0x60() = 0;
+		virtual void _0x68() = 0;
+		virtual void _0x70() = 0;
+		virtual netRpcReaderContext* GetContext() = 0;
+	};
 }

network/rlScSessionEvent.hpp

@@ -16,8 +16,18 @@ namespace rage
 		QUEUE_ERROR = 17,
 		LOCALIZED_MESSAGE = 19,
 		CONFIG_PARAM = 20,
+		INVITE_RESULT = 21,
+		INVITE_QUEUED = 22,
+		TRANSITION_READY_INVITE = 28,
+		TRANSITION_READY_PLAYER_QUEUE = 29,
+		KEEP_ALIVE_REQUEST = 30,
 		COMPLAINT_RECEIVED = 31,
 		QUEUE_ENTERED = 32,
+		PREPARE_SERVER_TRANSFER = 33,
+		SERVER_TRANSFER_RESULT = 34,
+		TRANSITION_READY_SERVER_TRANSFER = 35,
+		TRANSFER_TO_SERVER = 36,
+		PAUSE_FOR_SERVER_TRANSFER = 37,
 		ADMIN_SECURITY_INVITE = 38
 	};
 

network/sync/animscene/CAnimSceneCreationData.hpp

@@ -0,0 +1,12 @@
+#pragma once
+#include <cstdint>
+
+class CAnimSceneCreationData
+{
+public:
+    uint32_t m_AnimDict;        // 0x0000
+    int32_t m_PlaybackListName; // 0x0004
+    uint32_t m_Flags;           // 0x0008 - TODO: fix this
+    char m_Pad[116];            // 0x0012
+}; //Size: 0x0080
+static_assert(sizeof(CAnimSceneCreationData) == 0x80);

network/sync/animscene/CAnimSceneInfrequentData.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+class CAnimSceneSerializedVariable
+{
+public:
+	enum class Type
+	{
+		Bool = 5,
+		Float = 10,
+		Int = 19
+	};
+
+	std::uint32_t m_VariableName;
+	Type m_Type;
+	union
+	{
+		int m_Int;
+		bool m_Bool;
+		float m_Float;
+	};
+};
+static_assert(sizeof(CAnimSceneSerializedVariable) == 0xC);
+
+class CAnimSceneSerializedEntityBase
+{
+public:
+	virtual void Serialize(void*) {};
+	virtual void Reset() {};
+
+	std::uint32_t m_EntityName;
+	bool m_TransferOwnership;
+};
+static_assert(sizeof(CAnimSceneSerializedEntityBase) == 0x10);
+
+class CAnimSceneSerializedEntity : public CAnimSceneSerializedEntityBase
+{
+public:
+	std::uint16_t m_ObjectId;
+	bool m_Abort;
+};
+static_assert(sizeof(CAnimSceneSerializedEntity) == 0x18);
+
+class CAnimSceneSerializedDoor : public CAnimSceneSerializedEntityBase
+{
+public:
+	std::uint32_t m_DoorHash;
+};
+static_assert(sizeof(CAnimSceneSerializedDoor) == 0x18);
+
+class CAnimSceneSerializedPlaybackList
+{
+public:
+	virtual void Serialize(void*) {};
+	virtual void Reset() {};
+
+	std::uint32_t m_PlaybackList;
+	float m_Time;
+};
+static_assert(sizeof(CAnimSceneSerializedPlaybackList) == 0x10);
+
+class CAnimSceneInfrequentData
+{
+public:
+	std::uint16_t m_NumEntities;
+	std::uint16_t m_NumDoors;
+	std::uint16_t m_NumVariables;
+	std::uint16_t m_NumPlaybackLists;
+	char m_Pad[0x50]; // origin, rotation, scene attachments
+	CAnimSceneSerializedEntity m_Entities[32];
+	CAnimSceneSerializedDoor m_Doors[5];
+	CAnimSceneSerializedVariable m_Variables[32];
+	CAnimSceneSerializedPlaybackList m_PlaybackLists[9];
+}; //Size: 0x05E0
+static_assert(sizeof(CAnimSceneInfrequentData) == 0x5E0);

network/sync/ped/CPedHealthData.hpp

@@ -0,0 +1,59 @@
+#pragma once
+#include "rage/vector.hpp"
+
+class CPedHealthData
+{
+public:
+	rage::matrix44 m_WoundEffectPos;
+	uint32_t m_DamageWeaponHash;
+	uint32_t m_DamageWeaponMode;
+	uint32_t m_KillerWeaponHash;
+	uint32_t m_KillerWeaponMode;
+	uint32_t m_HitComponent;
+	float m_CurrentBleedOutDuration;
+	uint32_t m_IncapacitationThreshold;
+	uint32_t m_WoundIntensity;
+	int m_DeathTime;
+	uint32_t unk_0064;
+	int m_Health;
+	unsigned int unsigned_int6C;
+	unsigned int m_HealthConfig;
+	unsigned int unk_0074;
+	uint16_t m_DamagerId;
+	uint16_t m_KillerId;
+	uint16_t unk_007C;
+	char m_DamageCleanliness;
+	char unk_007F;
+	int m_DamageCleanlinessHits;
+	uint8_t m_TotalBleedOutDuration;
+	uint8_t unk_0085;
+	uint8_t m_FireDamageAmount;
+	char unk_0087;
+	uint16_t m_IncapacitationFlags;
+	uint8_t m_TranquilizerPlayerId;
+	bool unk_008B;
+	bool m_TotalBleedOutDurationOverridden;
+	bool m_HasDefaultHealth;
+	bool m_HasDamageBone;
+	bool unk_008F;
+	bool unk_0090;
+	bool unk_0091;
+	bool unk_0092;
+	bool m_CanBeIncapacitated;
+	bool m_Incapacitated;
+	bool unk_0095;
+	bool unk_0096;
+	bool unk_0097;
+	bool unk_0098;
+	bool unk_0099;
+	bool unk_009A;
+	bool unk_009B;
+	bool m_HasWound;
+	bool m_HasBloodPool;
+	bool unk_009E;
+	bool m_TakingDamage;
+	bool unk_00A0;
+	bool unk_00A1;
+	char epad[0xE];
+};
+static_assert(sizeof(CPedHealthData) == 0xB0);

network/sync/ped/CPedVitalityData.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <cstdint>
+
+class CPedVitalityData
+{
+public:
+	uint32_t m_HealthInReserve[8];
+	uint32_t m_Health;
+	uint32_t unk_0024;
+	uint32_t unk_0028;
+	uint32_t unk_002C;
+	uint32_t unk_0030;
+	uint32_t unk_0034;
+	uint8_t m_NumHealthReserves;
+	bool unk_0039;
+	bool m_HasUpgradeData;
+	bool unk_003B;
+	bool unk_003C;
+	bool unk_003D;
+	bool m_HasHealthTankUpgrade;
+	bool m_HasStaminaTankUpgrade;
+	uint32_t unk_0040;
+	uint32_t unk_0044;
+	uint32_t unk_0048;
+	bool unk_004C;
+	bool unk_004D;
+	bool unk_004E;
+	uint32_t m_TotalHealth;
+	uint32_t m_UnkComponentValue;
+	uint32_t dword58;
+	char gap5C[4];
+	uint64_t qword60;
+	uint64_t qword68;
+	bool m_HasDefaultHealth;
+	bool m_IsDead;
+	bool m_HasDefaultUnk;
+	bool m_IsIncapacitated;
+	bool unk_0074;
+	bool unk_0075;
+};
+static_assert(sizeof(CPedVitalityData) == 0x78);

train/CTrainConfig.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <cstdint>
+#include <string_view>
+
+#include "rage/atArray.hpp"
+
+class CTrainCarriageInfo
+{
+public:
+	uint32_t m_ModelName;
+	uint32_t _0x5E64EA3E;
+	uint32_t _0xE2BDEA7B;
+	uint32_t _0xECA6D302;
+	uint32_t _0xFBF5C716;
+	float _0x46B81FF8;
+	float _0xEC4633A5;
+	uint _0x535A0BBE;
+	uint m_ModelId;
+	int m_Extras;
+	bool _0x153918B6;
+	bool _0x88A76D74;
+	bool _0xC77853E4;
+	uint8_t m_TintPreset;
+};
+static_assert(sizeof(CTrainCarriageInfo) == 0x2C);
+
+class CTrainConfigRef
+{
+public:
+	uint32_t m_TrainConfigName;
+	uint8_t _0x07E33620;
+};
+static_assert(sizeof(CTrainConfigRef) == 0x8);
+
+class CTrainConfig
+{
+public:
+	uint32_t m_Name;
+	float _0x0ED29061;
+	float _0xE43D854D;
+	float _0x72443177;
+	float _0xA50FC0EB;
+	bool _0xFD90C5F8;
+	bool _0x0546B416;
+	bool _0xD41F8E7D;
+	bool m_CarriagesSwing;
+	bool _0xEDD766A7;
+	bool _0xDB277834;
+	bool m_NoRandomSpawn;
+	bool m_NoDriver;
+	float m_CarriageGap;
+	rage::atArray<CTrainCarriageInfo> m_Carriages;
+	uint32_t _0xA400A33A;
+	float m_DefaultMaxSpeed;
+	float m_MaxAcceleration;
+	float m_MaxDeceleration;
+	bool m_IsTram;
+};
+static_assert(sizeof(CTrainConfig) == 0x48);
+
+class CTrainConfigGroup
+{
+public:
+	uint32_t m_Name;
+	rage::atArray<CTrainConfigRef> m_Refs;
+};
+static_assert(sizeof(CTrainConfigGroup) == 0x18);
+
+class CTrainConfigs
+{
+public:
+	rage::atArray<CTrainConfig> m_TrainConfigs;
+	rage::atArray<CTrainConfigGroup> m_TrainGroups;
+};