feat: PipboyValue

Author: qudix

include/RE/P/PipboyPrimitiveValue.h

@@ -12,31 +12,33 @@ namespace RE
 		public PipboyValue
 	{
 	public:
-		virtual ~PipboyPrimitiveValue() {}  // 00
+		static constexpr auto RTTI{ RTTI::PipboyPrimitiveValue_unsignedint_ };
+		static constexpr auto VTABLE{ VTABLE::PipboyPrimitiveValue_unsignedint_ };
+
+		PipboyPrimitiveValue(std::uint32_t a_value, PipboyValue* a_parent) :
+			PipboyValue(a_parent), m_value(a_value)
+		{}
 
 		// override
 		virtual void                    CleanDirtyToGame() override {}                                                                                              // 00
 		virtual void                    Serialize([[maybe_unused]] Json::Value* a_json) override {}                                                                 // 01
 		virtual void                    SerializeChanges([[maybe_unused]] BSBinarySerializer& a_serializer, [[maybe_unused]] bool a_fullSerialization) override {}  // 03
 		virtual SERIALIZATION_DATA_TYPE GetType() override { return SERIALIZATION_DATA_TYPE::kUint32; }
 
-		PipboyPrimitiveValue(std::uint32_t a_value, PipboyValue* a_parentValue) :
-			PipboyValue(a_parentValue), value(a_value) {}
-
-		void ctor(std::uint32_t a_value, PipboyValue* a_parentValue)
+		void ctor(std::uint32_t a_value, PipboyValue* a_parent)
 		{
 			using func_t = decltype(&PipboyPrimitiveValue<std::uint32_t>::ctor);
 			static REL::Relocation<func_t> func{ ID::PipboyPrimitiveValue::uint32::ctor };
-			func(this, a_value, a_parentValue);
+			func(this, a_value, a_parent);
 		}
 
 		operator std::uint32_t() const
 		{
-			return value;
+			return m_value;
 		}
 
 		// members
-		std::uint32_t value;  // 18
+		std::uint32_t m_value;  // 0x18
 	};
 	static_assert(sizeof(PipboyPrimitiveValue<std::uint32_t>) == 0x20);
 
@@ -45,31 +47,33 @@ namespace RE
 		public PipboyValue
 	{
 	public:
-		virtual ~PipboyPrimitiveValue() {}  // 00
+		static constexpr auto RTTI{ RTTI::PipboyPrimitiveValue_bool_ };
+		static constexpr auto VTABLE{ VTABLE::PipboyPrimitiveValue_bool_ };
+
+		PipboyPrimitiveValue(bool a_value, PipboyValue* a_parent) :
+			PipboyValue(a_parent), m_value(a_value)
+		{}
 
 		// override
 		virtual void                    CleanDirtyToGame() override {}                                                                                              // 00
 		virtual void                    Serialize([[maybe_unused]] Json::Value* a_json) override {}                                                                 // 01
 		virtual void                    SerializeChanges([[maybe_unused]] BSBinarySerializer& a_serializer, [[maybe_unused]] bool a_fullSerialization) override {}  // 03
 		virtual SERIALIZATION_DATA_TYPE GetType() override { return SERIALIZATION_DATA_TYPE::kBool; }
 
-		PipboyPrimitiveValue(bool a_value, PipboyValue* a_parentValue) :
-			PipboyValue(a_parentValue), value(a_value) {}
-
-		void ctor(bool a_value, PipboyValue* a_parentValue)
+		void ctor(bool a_value, PipboyValue* a_parent)
 		{
 			using func_t = decltype(&PipboyPrimitiveValue<bool>::ctor);
 			static REL::Relocation<func_t> func{ ID::PipboyPrimitiveValue::boolean::ctor };
-			func(this, a_value, a_parentValue);
+			func(this, a_value, a_parent);
 		}
 
 		operator bool() const
 		{
-			return value;
+			return m_value;
 		}
 
 		// members
-		bool value;  // 18
+		bool m_value;  // 0x18
 	};
 	static_assert(sizeof(PipboyPrimitiveValue<bool>) == 0x20);
 }

include/RE/P/PipboyValue.h

@@ -28,6 +28,11 @@ namespace RE
 			kObject = 0x8,
 		};
 
+		PipboyValue(PipboyValue* a_parent)
+		{
+			ctor(a_parent);
+		};
+
 		virtual ~PipboyValue() = default;  // 00
 
 		// add
@@ -36,23 +41,18 @@ namespace RE
 		virtual void                    SerializeChanges(BSBinarySerializer& a_serializer, bool a_fullSerialize);  // 03
 		virtual SERIALIZATION_DATA_TYPE GetType() = 0;                                                             // 04
 
-		PipboyValue(PipboyValue* a_parentValue)
-		{
-			ctor(a_parentValue);
-		};
-
-		void ctor(PipboyValue* a_parentValue)
+		void ctor(PipboyValue* a_parent)
 		{
 			using func_t = decltype(&PipboyValue::ctor);
 			static REL::Relocation<func_t> func{ ID::PipboyValue::ctor };
-			return func(this, a_parentValue);
+			func(this, a_parent);
 		}
 
 		// members
-		std::uint32_t id;                  // 08
-		bool          isDirtyGame;         // 0C
-		bool          isDirtyToCompanion;  // 0D
-		PipboyValue*  parentValue;         // 10
+		std::uint32_t m_id;                  // 0x08
+		bool          m_isDirtyGame;         // 0x0C
+		bool          m_isDirtyToCompanion;  // 0x0D
+		PipboyValue*  m_parent;              // 0x10
 	};
 	static_assert(sizeof(PipboyValue) == 0x18);
 }