fix: Make pets behave more accurately to Live

dCommon/CMakeLists.txt

@@ -4,6 +4,7 @@ set(DCOMMON_SOURCES
 		"BinaryIO.cpp"
 		"dConfig.cpp"
 		"Diagnostics.cpp"
+		"Flag.h"
 		"Logger.cpp"
 		"Game.cpp"
 		"GeneralUtils.cpp"

dCommon/Flag.h

@@ -0,0 +1,159 @@
+#include "GeneralUtils.h"
+
+/**
+ * A bitset flag class capable of compile-time bounds-checking.
+ * It should be possible to unify its methods with C++23, but until then
+ * use the compile-time overloads preferentially.
+*/
+template <typename T>
+	requires std::is_enum_v<T>
+class Flag {
+public:
+	// Type aliases
+	using type = T;
+	using underlying_type = std::underlying_type_t<T>;
+
+	// Static constants
+	static constexpr auto MAX_FLAG_VAL = sizeof(underlying_type) * CHAR_BIT;
+
+	// Constructors
+	Flag() = default;
+
+	// Run-time constructor
+	constexpr Flag(const T value) : m_Flags{ ConvertFlag(value) } {}
+
+	/**
+	 * RUNTIME: Sets one or more flags
+	 * @param flag Flag(s) to set
+	*/
+	template <std::same_as<T>... varArg>
+	constexpr void Set(const varArg... flag) noexcept {
+		m_Flags |= (ConvertFlag(flag) | ...);
+	}
+
+	/**
+	 * COMPILETIME: Sets one or more flags
+	 * @param flag Flag(s) to set
+	*/
+	template <T... flag>
+	constexpr void Set() noexcept {
+		m_Flags |= (ConvertFlag<flag>() | ...);
+	}
+
+	/**
+	 * RUNTIME: Sets ONLY have the specified flag(s), clearing all others
+	 * @param flag Flag(s) to set exclusively
+	*/
+	template <std::same_as<T>... varArg>
+	constexpr void Reset(const varArg... flag) {
+		m_Flags = (ConvertFlag(flag) | ...);
+	}
+
+	/**
+	 * COMPILETIME: Sets ONLY have the specified flag(s), clearing all others
+	 * @param flag Flag(s) to set exclusively
+	*/
+	template <T... flag>
+	constexpr void Reset() noexcept {
+		m_Flags = (ConvertFlag<flag>() | ...);
+	}
+
+	/**
+	 * RUNTIME: Unsets one or more flags
+	 * @param flag Flag(s) to unset
+	*/
+	template <std::same_as<T>... varArg>
+	constexpr void Unset(const varArg... flag) {
+		m_Flags &= ~(ConvertFlag(flag) | ...);
+	}
+
+	/**
+	 * COMPILETIME: Unsets one or more flags
+	 * @param flag Flag(s) to unset
+	*/
+	template <T... flag>
+	constexpr void Unset() noexcept {
+		m_Flags &= ~(ConvertFlag<flag>() | ...);
+	}
+
+	/**
+	 * RUNTIME: Returns true all the specified flag(s) are set
+	 * @param flag Flag(s) to check
+	*/
+	template <std::same_as<T>... varArg>
+	[[nodiscard]]
+	constexpr bool Has(const varArg... flag) const {
+		return (m_Flags & (ConvertFlag(flag) | ...)) == (ConvertFlag(flag) | ...);
+	}
+
+	/**
+	 * COMPILETIME: Returns true if all the specified flag(s) are set
+	 * @param flag Flag(s) to check
+	*/
+	template <T... flag>
+	[[nodiscard]]
+	constexpr bool Has() const noexcept {
+		return (m_Flags & (ConvertFlag<flag>() | ...)) == (ConvertFlag<flag>() | ...);
+	}
+
+	/**
+	 * RUNTIME: Returns true if ONLY the specified flag(s) are set
+	 * @param flag Flag(s) to check
+	*/
+	template <std::same_as<T>... varArg>
+	[[nodiscard]]
+	constexpr bool HasOnly(const varArg... flag) const {
+		return m_Flags == (ConvertFlag(flag) | ...);
+	}
+
+	/**
+	 * COMPILETIME: Returns true if ONLY the specified flag(s) are set
+	 * @param flag Flag(s) to check
+	*/
+	template <T... flag>
+	[[nodiscard]]
+	constexpr bool HasOnly() const noexcept {
+		return m_Flags == (ConvertFlag<flag>() | ...);
+	}
+
+	/**
+	 * @return the raw value of the flags set
+	*/
+	[[nodiscard]]
+	constexpr T Value() const noexcept {
+		return static_cast<T>(m_Flags);
+	}
+
+	/**
+	 * Operator overload to allow for '=' assignment
+	*/
+	constexpr Flag& operator=(const T value) {
+		m_Flags = ConvertFlag(value);
+		return *this;
+	}
+
+private:
+	template <T flag>
+	[[nodiscard]]
+	static consteval underlying_type ConvertFlag() noexcept {
+		constexpr auto flag_val = GeneralUtils::ToUnderlying(flag);
+		static_assert(flag_val <= MAX_FLAG_VAL, "Flag value is too large to set!");
+
+		return flag_val != 0 ? 1 << flag_val : flag_val;
+	}
+
+	[[nodiscard]]
+	static constexpr underlying_type ConvertFlag(const T flag) {
+		auto flag_val = GeneralUtils::ToUnderlying(flag);
+
+		// This is less-efficient than the compile-time check, but still works
+		// We can probably unify this and the above functions with C++23 and 'if consteval'
+		if (flag_val > MAX_FLAG_VAL) {
+			throw std::runtime_error{ "Flag value is too large to set!" };
+		}
+
+		return flag_val != 0 ? 1 << flag_val : flag_val;
+	}
+
+	underlying_type m_Flags;
+};

dCommon/dEnums/eHelpType.h

@@ -1,9 +1,10 @@
-
 #ifndef __EHELPTYPE__H__
 #define __EHELPTYPE__H__
 
 #include <cstdint>
 
+#include "magic_enum.hpp"
+
 enum class eHelpType : int32_t {
 	NONE = 0,
 	UNLOCK_MINIMAP = 2,
@@ -38,4 +39,10 @@ enum class eHelpType : int32_t {
 	UI_INVENTORY_FULL_CANNOT_PICKUP_ITEM = 86
 };
 
+template <>
+struct magic_enum::customize::enum_range<eHelpType> {
+	static constexpr int min = 0;
+	static constexpr int max = 86;
+};
+
 #endif  //!__EHELPTYPE__H__

dCommon/dEnums/ePetAbilityType.h

@@ -1,5 +1,5 @@
-#ifndef __EPETABILITYTYPE__H__
-#define __EPETABILITYTYPE__H__
+#ifndef EPETABILITYTYPE_H
+#define EPETABILITYTYPE_H
 
 #include <cstdint>
 
@@ -10,4 +10,4 @@ enum class ePetAbilityType : uint32_t {
 	DigAtPosition
 };
 
-#endif  //!__EPETABILITYTYPE__H__
+#endif  //!EPETABILITYTYPE_H

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -20,6 +20,7 @@
 #include "CDMissionsTable.h"
 #include "CDObjectSkillsTable.h"
 #include "CDObjectsTable.h"
+#include "CDPetAbilitiesTable.h"
 #include "CDPhysicsComponentTable.h"
 #include "CDRebuildComponentTable.h"
 #include "CDScriptComponentTable.h"
@@ -89,6 +90,7 @@ DEFINE_TABLE_STORAGE(CDObjectSkillsTable);
 DEFINE_TABLE_STORAGE(CDObjectsTable);
 DEFINE_TABLE_STORAGE(CDPhysicsComponentTable);
 DEFINE_TABLE_STORAGE(CDPackageComponentTable);
+DEFINE_TABLE_STORAGE(CDPetAbilitiesTable);
 DEFINE_TABLE_STORAGE(CDPetComponentTable);
 DEFINE_TABLE_STORAGE(CDProximityMonitorComponentTable);
 DEFINE_TABLE_STORAGE(CDPropertyEntranceComponentTable);
@@ -136,6 +138,7 @@ void CDClientManager::LoadValuesFromDatabase() {
 	CDCLIENT_DONT_CACHE_TABLE(CDObjectsTable::Instance().LoadValuesFromDatabase());
 	CDPhysicsComponentTable::Instance().LoadValuesFromDatabase();
 	CDPackageComponentTable::Instance().LoadValuesFromDatabase();
+	CDPetAbilitiesTable::Instance().LoadValuesFromDatabase();
 	CDPetComponentTable::Instance().LoadValuesFromDatabase();
 	CDProximityMonitorComponentTable::Instance().LoadValuesFromDatabase();
 	CDPropertyEntranceComponentTable::Instance().LoadValuesFromDatabase();
@@ -155,5 +158,6 @@ void CDClientManager::LoadValuesFromDatabase() {
 void CDClientManager::LoadValuesFromDefaults() {
 	LOG("Loading default CDClient tables!");
 
+	CDPetAbilitiesTable::Instance().LoadValuesFromDefaults();
 	CDPetComponentTable::Instance().LoadValuesFromDefaults();
 }

dDatabase/CDClientDatabase/CDClientTables/CDPetAbilitiesTable.cpp

@@ -0,0 +1,43 @@
+#include "CDPetAbilitiesTable.h"
+#include "ePetAbilityType.h"
+
+namespace {
+	// Default entries for fallback
+	CDPetAbilities defaultEntry{
+		.id = ePetAbilityType::Invalid,
+		UNUSED_ENTRY(.AbilityName = "invalid",)
+		.imaginationCost = 0,
+		UNUSED_ENTRY(.locStatus = 2,)
+	};
+}
+
+void CDPetAbilitiesTable::LoadValuesFromDatabase() {
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PetAbilities");
+	auto& entries = GetEntriesMutable();
+	while (!tableData.eof()) {
+		const auto abilityId =
+			static_cast<ePetAbilityType>(tableData.getIntField("id", static_cast<int>(defaultEntry.id)));
+		auto& entry = entries[abilityId];
+
+		entry.id = abilityId;
+		UNUSED_COLUMN(entry.abilityName = tableData.getStringField("AbilityName", defaultEntry.abilityName));
+		entry.imaginationCost = tableData.getIntField("ImaginationCost", defaultEntry.imaginationCost);
+		UNUSED_COLUMN(entry.locStatus = tableData.getIntField("locStatus", defaultEntry.locStatus));
+
+		tableData.nextRow();
+	}
+}
+
+void CDPetAbilitiesTable::LoadValuesFromDefaults() {
+	GetEntriesMutable().emplace(defaultEntry.id, defaultEntry);
+}
+
+const CDPetAbilities& CDPetAbilitiesTable::GetByID(const ePetAbilityType id) {
+	const auto& entries = GetEntries();
+	const auto itr = entries.find(id);
+	if (itr == entries.cend()) {
+		LOG("Unable to load pet ability (ID %i) values from database! Using default values instead.", id);
+		return defaultEntry;
+	}
+	return itr->second;
+}

dDatabase/CDClientDatabase/CDClientTables/CDPetAbilitiesTable.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "CDTable.h"
+#include <cstdint>
+#include <string>
+
+// Forward declarations
+enum class ePetAbilityType : uint32_t;
+
+struct CDPetAbilities {
+	ePetAbilityType id;
+	UNUSED_COLUMN(std::string abilityName;)
+	int32_t imaginationCost;
+	UNUSED_COLUMN(uint32_t locStatus;)
+};
+
+class CDPetAbilitiesTable : public CDTable<CDPetAbilitiesTable, std::map<ePetAbilityType, CDPetAbilities>> {
+public:
+
+	/**
+	 * Load values from the CD client database
+	*/
+	void LoadValuesFromDatabase();
+
+	/**
+	 * Load the default values into memory instead of attempting to connect to the CD client database
+	*/
+	void LoadValuesFromDefaults();
+
+	/**
+	 * Gets the pet ability table corresponding to the pet ability ID
+	 * @returns A pointer to the corresponding table, or nullptr if one could not be found
+	*/
+	const CDPetAbilities& GetByID(const ePetAbilityType id);
+};

dDatabase/CDClientDatabase/CDClientTables/CDPetComponentTable.cpp

@@ -53,10 +53,10 @@ void CDPetComponentTable::LoadValuesFromDefaults() {
 	GetEntriesMutable().emplace(defaultEntry.id, defaultEntry);
 }
 
-CDPetComponent& CDPetComponentTable::GetByID(const uint32_t componentID) {
-	auto& entries = GetEntriesMutable();
-	auto itr = entries.find(componentID);
-	if (itr == entries.end()) {
+const CDPetComponent& CDPetComponentTable::GetByID(const uint32_t componentID) {
+	const auto& entries = GetEntries();
+	const auto itr = entries.find(componentID);
+	if (itr == entries.cend()) {
 		LOG("Unable to load pet component (ID %i) values from database! Using default values instead.", componentID);
 		return defaultEntry;
 	}

dDatabase/CDClientDatabase/CDClientTables/CDPetComponentTable.h

@@ -28,7 +28,7 @@ class CDPetComponentTable : public CDTable<CDPetComponentTable, std::map<uint32_
 	 * Load values from the CD client database
 	*/
 	void LoadValuesFromDatabase();
-	
+
 	/**
 	 * Load the default values into memory instead of attempting to connect to the CD client database
 	*/
@@ -38,5 +38,5 @@ class CDPetComponentTable : public CDTable<CDPetComponentTable, std::map<uint32_
 	 * Gets the pet component table corresponding to the pet component ID
 	 * @returns A reference to the corresponding table, or the default if one could not be found
 	*/
-	CDPetComponent& GetByID(const uint32_t componentID);
+	const CDPetComponent& GetByID(const uint32_t componentID);
 };

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

@@ -23,6 +23,7 @@ set(DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDMovementAIComponentTable.cpp"
 	"CDObjectSkillsTable.cpp"
 	"CDObjectsTable.cpp"
+	"CDPetAbilitiesTable.cpp"
 	"CDPetComponentTable.cpp"
 	"CDPackageComponentTable.cpp"
 	"CDPhysicsComponentTable.cpp"

dGame/dComponents/InventoryComponent.cpp

@@ -1221,7 +1221,7 @@ void InventoryComponent::SpawnPet(Item* item) {
 	auto* current = PetComponent::GetActivePet(m_Parent->GetObjectID());
 
 	if (current != nullptr) {
-		current->Deactivate();
+		current->Deactivate(eHelpType::PET_DESPAWN_BY_OWNER_HIBERNATE);
 
 		if (current->GetDatabaseId() == item->GetSubKey()) {
 			return;