Feat: Add DBCStores access via Lua with getters for DBC entries

src/LuaEngine/ElunaDBCRegistry.cpp

@@ -0,0 +1,6 @@
+#include "ElunaDBCRegistry.h"
+
+std::vector<DBCDefinition> dbcRegistry = {
+    REGISTER_DBC(GemProperties, GemPropertiesEntry, sGemPropertiesStore),
+    REGISTER_DBC(Spell,         SpellEntry,         sSpellStore),
+};

src/LuaEngine/ElunaDBCRegistry.h

@@ -0,0 +1,37 @@
+#ifndef ELUNADBCREGISTRY_H
+#define ELUNADBCREGISTRY_H
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <typeinfo>
+
+#include "DBCStores.h"
+#include "LuaEngine.h"
+
+struct DBCDefinition
+{
+    std::string name;
+    void* storage;
+    const std::type_info& type;
+    std::function<const void*(uint32)> lookupFunction;
+    std::function<void(lua_State*, const void*)> pushFunction;
+};
+
+extern std::vector<DBCDefinition> dbcRegistry;
+
+#define REGISTER_DBC(dbcName, entryType, store) \
+    {                                           \
+        #dbcName,                               \
+        reinterpret_cast<void*>(&store),        \
+        typeid(DBCStorage<entryType>),          \
+        [](uint32 id) -> const void* {          \
+            return store.LookupEntry(id);       \
+        },                                      \
+        [](lua_State* L, const void* entry) {   \
+            auto cast_entry = static_cast<const entryType*>(entry); \
+            Eluna::Push(L, *cast_entry);        \
+        }                                       \
+    }
+
+#endif // ELUNADBCREGISTRY_H

src/LuaEngine/LuaEngine.cpp

@@ -690,6 +690,16 @@ void Eluna::Push(lua_State* luastate, ObjectGuid const guid)
     ElunaTemplate<unsigned long long>::Push(luastate, new unsigned long long(guid.GetRawValue()));
 }
 
+void Eluna::Push(lua_State* luastate, GemPropertiesEntry const& gemProperties)
+{
+    Push(luastate, &gemProperties);
+}
+
+void Eluna::Push(lua_State* luastate, SpellEntry const& spell)
+{
+    Push(luastate, &spell);
+}
+
 static int CheckIntegerRange(lua_State* luastate, int narg, int min, int max)
 {
     double value = luaL_checknumber(luastate, narg);

src/LuaEngine/LuaEngine.h

@@ -256,6 +256,8 @@ class ELUNA_GAME_API Eluna
     static void Push(lua_State* luastate, Pet const* pet);
     static void Push(lua_State* luastate, TempSummon const* summon);
     static void Push(lua_State* luastate, ObjectGuid const guid);
+    static void Push(lua_State* luastate, GemPropertiesEntry const& gemProperties);
+    static void Push(lua_State* luastate, SpellEntry const& spell);
     template<typename T>
     static void Push(lua_State* luastate, T const* ptr)
     {

src/LuaEngine/LuaFunctions.cpp

@@ -41,6 +41,10 @@ extern "C"
 #include "ItemTemplateMethods.h"
 #include "RollMethods.h"
 
+// DBCStores includes
+#include "GemPropertiesEntryMethods.h"
+#include "SpellEntryMethods.h"
+
 luaL_Reg GlobalMethods[] =
 {
     // Hooks
@@ -160,6 +164,7 @@ luaL_Reg GlobalMethods[] =
     { "StopGameEvent", &LuaGlobalFunctions::StopGameEvent },
     { "HttpRequest", &LuaGlobalFunctions::HttpRequest },
     { "SetOwnerHalaa", &LuaGlobalFunctions::SetOwnerHalaa },
+    { "LookupEntry", &LuaGlobalFunctions::LookupEntry },
 
     { NULL, NULL }
 };
@@ -1290,6 +1295,114 @@ ElunaRegister<Roll> RollMethods[] =
     { NULL, NULL }
 };
 
+ElunaRegister<GemPropertiesEntry> GemPropertiesEntryMethods[] =
+{
+    // Getters
+    { "GetId", &LuaGemPropertiesEntry::GetId },
+    { "GetSpellItemEnchantement", &LuaGemPropertiesEntry::GetSpellItemEnchantement },
+
+    { NULL, NULL }
+};
+
+ElunaRegister<SpellEntry> SpellEntryMethods[] =
+{
+    // Getters
+    { "GetId", &LuaSpellEntry::GetId },
+    { "GetCategory", &LuaSpellEntry::GetCategory },
+    { "GetDispel", &LuaSpellEntry::GetDispel },
+    { "GetMechanic", &LuaSpellEntry::GetMechanic },
+    { "GetAttributes", &LuaSpellEntry::GetAttributes },
+    { "GetAttributesEx", &LuaSpellEntry::GetAttributesEx },
+    { "GetAttributesEx2", &LuaSpellEntry::GetAttributesEx2 },
+    { "GetAttributesEx3", &LuaSpellEntry::GetAttributesEx3 },
+    { "GetAttributesEx4", &LuaSpellEntry::GetAttributesEx4 },
+    { "GetAttributesEx5", &LuaSpellEntry::GetAttributesEx5 },
+    { "GetAttributesEx6", &LuaSpellEntry::GetAttributesEx6 },
+    { "GetAttributesEx7", &LuaSpellEntry::GetAttributesEx7 },
+    { "GetStances", &LuaSpellEntry::GetStances },
+    { "GetStancesNot", &LuaSpellEntry::GetStancesNot },
+    { "GetTargets", &LuaSpellEntry::GetTargets },
+    { "GetTargetCreatureType", &LuaSpellEntry::GetTargetCreatureType },
+    { "GetRequiresSpellFocus", &LuaSpellEntry::GetRequiresSpellFocus },
+    { "GetFacingCasterFlags", &LuaSpellEntry::GetFacingCasterFlags },
+    { "GetCasterAuraState", &LuaSpellEntry::GetCasterAuraState },
+    { "GetTargetAuraState", &LuaSpellEntry::GetTargetAuraState },
+    { "GetCasterAuraStateNot", &LuaSpellEntry::GetCasterAuraStateNot },
+    { "GetTargetAuraStateNot", &LuaSpellEntry::GetTargetAuraStateNot },
+    { "GetCasterAuraSpell", &LuaSpellEntry::GetCasterAuraSpell },
+    { "GetTargetAuraSpell", &LuaSpellEntry::GetTargetAuraSpell },
+    { "GetExcludeCasterAuraSpell", &LuaSpellEntry::GetExcludeCasterAuraSpell },
+    { "GetExcludeTargetAuraSpell", &LuaSpellEntry::GetExcludeTargetAuraSpell },
+    { "GetCastingTimeIndex", &LuaSpellEntry::GetCastingTimeIndex },
+    { "GetRecoveryTime", &LuaSpellEntry::GetRecoveryTime },
+    { "GetCategoryRecoveryTime", &LuaSpellEntry::GetCategoryRecoveryTime },
+    { "GetInterruptFlags", &LuaSpellEntry::GetInterruptFlags },
+    { "GetAuraInterruptFlags", &LuaSpellEntry::GetAuraInterruptFlags },
+    { "GetChannelInterruptFlags", &LuaSpellEntry::GetChannelInterruptFlags },
+    { "GetProcFlags", &LuaSpellEntry::GetProcFlags },
+    { "GetProcChance", &LuaSpellEntry::GetProcChance },
+    { "GetProcCharges", &LuaSpellEntry::GetProcCharges },
+    { "GetMaxLevel", &LuaSpellEntry::GetMaxLevel },
+    { "GetBaseLevel", &LuaSpellEntry::GetBaseLevel },
+    { "GetSpellLevel", &LuaSpellEntry::GetSpellLevel },
+    { "GetDurationIndex", &LuaSpellEntry::GetDurationIndex },
+    { "GetPowerType", &LuaSpellEntry::GetPowerType },
+    { "GetManaCost", &LuaSpellEntry::GetManaCost },
+    { "GetManaCostPerlevel", &LuaSpellEntry::GetManaCostPerlevel },
+    { "GetManaPerSecond", &LuaSpellEntry::GetManaPerSecond },
+    { "GetManaPerSecondPerLevel", &LuaSpellEntry::GetManaPerSecondPerLevel },
+    { "GetRangeIndex", &LuaSpellEntry::GetRangeIndex },
+    { "GetSpeed", &LuaSpellEntry::GetSpeed },
+    { "GetStackAmount", &LuaSpellEntry::GetStackAmount },
+    { "GetTotem", &LuaSpellEntry::GetTotem },
+    { "GetReagent", &LuaSpellEntry::GetReagent },
+    { "GetReagentCount", &LuaSpellEntry::GetReagentCount },
+    { "GetEquippedItemClass", &LuaSpellEntry::GetEquippedItemClass },
+    { "GetEquippedItemSubClassMask", &LuaSpellEntry::GetEquippedItemSubClassMask },
+    { "GetEquippedItemInventoryTypeMask", &LuaSpellEntry::GetEquippedItemInventoryTypeMask },
+    { "GetEffect", &LuaSpellEntry::GetEffect },
+    { "GetEffectDieSides", &LuaSpellEntry::GetEffectDieSides },
+    { "GetEffectRealPointsPerLevel", &LuaSpellEntry::GetEffectRealPointsPerLevel },
+    { "GetEffectBasePoints", &LuaSpellEntry::GetEffectBasePoints },
+    { "GetEffectMechanic", &LuaSpellEntry::GetEffectMechanic },
+    { "GetEffectImplicitTargetA", &LuaSpellEntry::GetEffectImplicitTargetA },
+    { "GetEffectImplicitTargetB", &LuaSpellEntry::GetEffectImplicitTargetB },
+    { "GetEffectRadiusIndex", &LuaSpellEntry::GetEffectRadiusIndex },
+    { "GetEffectApplyAuraName", &LuaSpellEntry::GetEffectApplyAuraName },
+    { "GetEffectAmplitude", &LuaSpellEntry::GetEffectAmplitude },
+    { "GetEffectValueMultiplier", &LuaSpellEntry::GetEffectValueMultiplier },
+    { "GetEffectChainTarget", &LuaSpellEntry::GetEffectChainTarget },
+    { "GetEffectItemType", &LuaSpellEntry::GetEffectItemType },
+    { "GetEffectMiscValue", &LuaSpellEntry::GetEffectMiscValue },
+    { "GetEffectMiscValueB", &LuaSpellEntry::GetEffectMiscValueB },
+    { "GetEffectTriggerSpell", &LuaSpellEntry::GetEffectTriggerSpell },
+    { "GetEffectPointsPerComboPoint", &LuaSpellEntry::GetEffectPointsPerComboPoint },
+    { "GetEffectSpellClassMask", &LuaSpellEntry::GetEffectSpellClassMask },
+    { "GetSpellVisual", &LuaSpellEntry::GetSpellVisual },
+    { "GetSpellIconID", &LuaSpellEntry::GetSpellIconID },
+    { "GetActiveIconID", &LuaSpellEntry::GetActiveIconID },
+    { "GetSpellPriority", &LuaSpellEntry::GetSpellPriority },
+    { "GetSpellName", &LuaSpellEntry::GetSpellName },
+    { "GetRank", &LuaSpellEntry::GetRank },
+    { "GetManaCostPercentage", &LuaSpellEntry::GetManaCostPercentage },
+    { "GetStartRecoveryCategory", &LuaSpellEntry::GetStartRecoveryCategory },
+    { "GetStartRecoveryTime", &LuaSpellEntry::GetStartRecoveryTime },
+    { "GetMaxTargetLevel", &LuaSpellEntry::GetMaxTargetLevel },
+    { "GetSpellFamilyName", &LuaSpellEntry::GetSpellFamilyName },
+    { "GetSpellFamilyFlags", &LuaSpellEntry::GetSpellFamilyFlags },
+    { "GetMaxAffectedTargets", &LuaSpellEntry::GetMaxAffectedTargets },
+    { "GetDmgClass", &LuaSpellEntry::GetDmgClass },
+    { "GetPreventionType", &LuaSpellEntry::GetPreventionType },
+    { "GetEffectDamageMultiplier", &LuaSpellEntry::GetEffectDamageMultiplier },
+    { "GetTotemCategory", &LuaSpellEntry::GetTotemCategory },
+    { "GetAreaGroupId", &LuaSpellEntry::GetAreaGroupId },
+    { "GetSchoolMask", &LuaSpellEntry::GetSchoolMask },
+    { "GetRuneCostID", &LuaSpellEntry::GetRuneCostID },
+    { "GetEffectBonusMultiplier", &LuaSpellEntry::GetEffectBonusMultiplier },
+
+    { NULL, NULL }
+};
+
 // fix compile error about accessing vehicle destructor
 template<> int ElunaTemplate<Vehicle>::CollectGarbage(lua_State* L)
 {
@@ -1435,6 +1548,12 @@ void RegisterFunctions(Eluna* E)
     ElunaTemplate<Roll>::Register(E, "Roll");
     ElunaTemplate<Roll>::SetMethods(E, RollMethods);
 
+    ElunaTemplate<GemPropertiesEntry>::Register(E, "GemPropertiesEntry");
+    ElunaTemplate<GemPropertiesEntry>::SetMethods(E, GemPropertiesEntryMethods);
+
+    ElunaTemplate<SpellEntry>::Register(E, "SpellEntry");
+    ElunaTemplate<SpellEntry>::SetMethods(E, SpellEntryMethods);
+
     ElunaTemplate<long long>::Register(E, "long long", true);
 
     ElunaTemplate<unsigned long long>::Register(E, "unsigned long long", true);

src/LuaEngine/methods/GemPropertiesEntryMethods.h

@@ -0,0 +1,40 @@
+/*
+* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#ifndef GEMPROPERTIESENTRYMETHODS_H
+#define GEMPROPERTIESENTRYMETHODS_H
+
+namespace LuaGemPropertiesEntry
+{
+
+    /**
+     * Returns the ID of a [GemPropertiesEntry].
+     *
+     * This method retrieves the ID from a given GemPropertiesEntry instance 
+     * and pushes it onto the Lua stack.
+     *
+     * @return uint32 id : The ID of the specified GemPropertiesEntry.
+     */
+    int GetId(lua_State* L, GemPropertiesEntry* gemProperties)
+    {
+        Eluna::Push(L, gemProperties->ID);
+        return 1;
+    }
+
+    /**
+     * Returns the spell item enchantment of a [GemPropertiesEntry].
+     *
+     * This function retrieves the `spellitemenchantement` attribute from the provided `GemPropertiesEntry`.
+     *
+     * @return uint32 spellitemenchantement : The spell item enchantment ID.
+     */
+    int GetSpellItemEnchantement(lua_State* L, GemPropertiesEntry* entry)
+    {
+        Eluna::Push(L, entry->spellitemenchantement);
+        return 1;
+    }
+}
+#endif

src/LuaEngine/methods/GlobalMethods.h

@@ -8,13 +8,15 @@
 #define GLOBALMETHODS_H
 
 #include "BindingMap.h"
+#include "ElunaDBCRegistry.h"
 
 #include "BanMgr.h"
 #include "GameTime.h"
 #include "SharedDefines.h"
 #include "OutdoorPvPMgr.h"
 #include "../../../../src/server/scripts/OutdoorPvP/OutdoorPvPNA.h"
 
+
 enum BanMode
 {
     BAN_ACCOUNT = 1,
@@ -3143,5 +3145,37 @@ namespace LuaGlobalFunctions
 
         return 0;
     }
+
+    /**
+     * Returns the instance of the specified DBC (DatabaseClient) store.
+     *
+     * This function retrieves the DBC store associated with the provided name 
+     * and pushes it onto the Lua stack.
+     *
+     * @param const char* dbcName : The name of the DBC store to retrieve.
+     * @param uint32 id : The ID used to look up within the specified DBC store.
+     *
+     * @return [DBCStore] store : The requested DBC store instance.
+     */
+    int LookupEntry(lua_State* L)
+    {
+        const char* dbcName = Eluna::CHECKVAL<const char*>(L, 1);
+        uint32 id = Eluna::CHECKVAL<uint32>(L, 2);
+
+        for (const auto& dbc : dbcRegistry)
+        {
+            if (dbc.name == dbcName)
+            {
+                const void* entry = dbc.lookupFunction(id);
+                if (!entry)
+                    return 0;
+
+                dbc.pushFunction(L, entry);
+                return 1;
+            }
+        }
+
+        return luaL_error(L, "Invalid DBC name: %s", dbcName);
+    }
 }
 #endif