yolinlin/mod-ale
1
0
Fork 0
mirror of https://github.com/azerothcore/mod-ale synced 2025-11-29 15:38:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Feat(Documentation): Add missing documentation for all methods and classes (#315)

Browse Source
This commit is contained in:
Aldori
2025-09-17 09:01:24 -04:00
committed by GitHub
parent 313596f86e
commit b559d02658
20 changed files with 498 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/LuaEngine/methods/AchievementMethods.h
View File

@@ -7,6 +7,11 @@
#ifndef ACHIEVEMENTMETHODS_H
#define ACHIEVEMENTMETHODS_H
/***
* Represents an entry from the game's achievement database (e.g., achievement earned for completing certain tasks).
*
* Inherits all methods from: none
*/
namespace LuaAchievement
{
/**

7
src/LuaEngine/methods/ChatHandlerMethods.h
View File

@@ -9,6 +9,13 @@
#include "Chat.h"
/***
* Provides access to in-game and console chat commands, messages, and selection context for command execution.
*
* Used primarily in GM scripts or command handlers to send messages, check permissions, and access selected targets.
*
* Inherits all methods from: none
*/
namespace LuaChatHandler
{
/**

12
src/LuaEngine/methods/CreatureMethods.h
View File

@@ -835,6 +835,12 @@ namespace LuaCreature
return 1;
}
/**
* Returns the loot mode flags for the specified [Creature].
*
* @param [Creature] creature : the creature whose loot mode to get
* @return uint16 lootMode : the loot mode bitmask of the creature
*/
int GetLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
{
Eluna::Push(L, creature->GetLootMode());
@@ -936,6 +942,12 @@ namespace LuaCreature
return 0;
}
/**
* Sets the loot mode flags for the specified [Creature].
*
* @param [Creature] creature : the creature whose loot mode to set
* @param uint16 lootMode : the loot mode bitmask to apply
*/
int SetLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
{
uint16 lootMode = Eluna::CHECKVAL<uint16>(L, 2);

3
src/LuaEngine/methods/GameObjectMethods.h
View File

@@ -8,6 +8,8 @@
#define GAMEOBJECTMETHODS_H
/***
* Represents a game object in the world, such as doors, chests, and other interactive objects.
*
* Inherits all methods from: [Object], [WorldObject]
*/
namespace LuaGameObject
@@ -224,7 +226,6 @@ namespace LuaGameObject
* @param uint32 amount = 1 : amount of the [Item] to add to the loot
* @return uint32 itemGUIDlow : low GUID of the [Item]
*/
int AddLoot(lua_State* L, GameObject* go)
{
int i = 1;

7
src/LuaEngine/methods/GemPropertiesEntryMethods.h
View File

@@ -7,6 +7,13 @@
#ifndef GEMPROPERTIESENTRYMETHODS_H
#define GEMPROPERTIESENTRYMETHODS_H
/***
* Represents static gem data used in item enhancement, including spell enchantments triggered by socketed gems.
*
* Provides access to gem-related properties from the DBC table `GemProperties.dbc`.
*
* Inherits all methods from: none
*/
namespace LuaGemPropertiesEntry
{

29
src/LuaEngine/methods/GlobalMethods.h
View File

@@ -105,7 +105,6 @@ namespace LuaGlobalFunctions
* - for TrinityCore returns the realmID as it is in the conf file.
* @return uint32 realm ID
*/
int GetRealmID(lua_State* L)
{
Eluna::Push(L, sConfigMgr->GetOption<uint32>("RealmID", 1));
@@ -362,6 +361,12 @@ namespace LuaGlobalFunctions
return 1;
}
/**
* Returns the [ItemTemplate] for the specified item ID. The ItemTemplate contains all static data about an item, such as name, quality, stats, required level, and more.
*
* @param uint32 itemID : the item entry ID from `item_template` to look up
* @return [ItemTemplate] itemTemplate
*/
int GetItemTemplate(lua_State* L)
{
uint32 entry = Eluna::CHECKVAL<uint32>(L, 1);
@@ -3453,15 +3458,14 @@ namespace LuaGlobalFunctions
}
/**
* Return the entrance position (x, y, z, o) of the specified dungeon map id
* Return the entrance position (x, y, z, o) of the specified dungeon map id.
*
* @param uint32 mapId
*
* return uint32 pos_x
* return uint32 pos_y
* return uint32 pos_z
* return uint32 pos_o
*
* @return uint32 pos_x
* @return uint32 pos_y
* @return uint32 pos_z
* @return uint32 pos_o
*/
int GetMapEntrance(lua_State* L)
{
@@ -3497,15 +3501,14 @@ namespace LuaGlobalFunctions
}
/**
* Returns the instance of the specified DBC (DatabaseClient) store.
* Returns an entry from the specified DBC (DatabaseClient) store.
*
* This function retrieves the DBC store associated with the provided name
* and pushes it onto the Lua stack.
* This function looks up an entry in a DBC file by name and ID, 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.
* @param string dbcName : The name of the DBC store (e.g., "ItemDisplayInfo")
* @param uint32 id : The ID used to look up within the specified DBC store
*
* @return [DBCStore] store : The requested DBC store instance.
* @return [DBCStore] store : The requested DBC store instance
*/
int LookupEntry(lua_State* L)
{

2
src/LuaEngine/methods/GroupMethods.h
View File

@@ -8,6 +8,8 @@
#define GROUPMETHODS_H
/***
* Represents a player group in the game, such as a party or raid.
*
* Inherits all methods from: none
*/
namespace LuaGroup

10
src/LuaEngine/methods/GuildMethods.h
View File

@@ -8,6 +8,8 @@
#define GUILDMETHODS_H
/***
* Represents a player guild. Used to manage guild members, ranks, guild bank.
*
* Inherits all methods from: none
*/
namespace LuaGuild
@@ -275,25 +277,25 @@ namespace LuaGuild
* Send message to [Guild] from specific [Player].
*
* @param [Player] player : the [Player] is the author of the message
* @param bool officierOnly : send message only on officier channel
* @param bool officerOnly : send message only on officer channel
* @param string msg : the message you need to send
* @param uint32 lang : language the [Player] will speak
*/
int SendMessage(lua_State* L, Guild* guild)
{
Player* player = Eluna::CHECKOBJ<Player>(L, 2);
bool officierOnly = Eluna::CHECKVAL<bool>(L, 3, false);
bool officerOnly = Eluna::CHECKVAL<bool>(L, 3, false);
std::string msg = Eluna::CHECKVAL<std::string>(L, 4);
uint32 language = Eluna::CHECKVAL<uint32>(L, 5, false);
guild->BroadcastToGuild(player->GetSession(), officierOnly, msg, language);
guild->BroadcastToGuild(player->GetSession(), officerOnly, msg, language);
return 0;
}
/**
* Invites [Guild] members to events based on level and rank filters.
*
* @param Player player : who sends the invitation
* @param [Player] player : who sends the invitation
* @param uint32 minLevel : the required min level
* @param uint32 maxLevel : the required max level
* @param uint32 minRank : the required min rank

20
src/LuaEngine/methods/ItemMethods.h
View File

@@ -8,6 +8,8 @@
#define ITEMMETHODS_H
/***
* Represents an instance of an item in the game world.
*
* Inherits all methods from: [Object]
*/
namespace LuaItem
@@ -298,6 +300,12 @@ namespace LuaItem
return 1;
}
/**
* Returns the GUID of the [Player] who owns the specified [Item].
*
* @param [Item] item
* @return uint64 ownerGUID
*/
int GetOwnerGUID(lua_State* L, Item* item)
{
Eluna::Push(L, item->GetOwnerGUID());
@@ -551,6 +559,12 @@ namespace LuaItem
return 1;
}
/**
* Returns the number of stat entries defined on the [Item]'s [ItemTemplate]. This reflects how many stat slots (e.g., Strength, Stamina, etc.) are defined for the item.
*
* @param [Item] item
* @return uint32 statsCount
*/
int GetStatsCount(lua_State* L, Item* item)
{
Eluna::Push(L, item->GetTemplate()->StatsCount);
@@ -568,6 +582,12 @@ namespace LuaItem
return 1;
}
/**
* Returns the random suffix ID of the specified [Item]. This corresponds to the `RandomSuffix` field from the item's [ItemTemplate], which controls the applied suffix (e.g., "of the Bear", "of the Eagle").
*
* @param [Item] item
* @return uint32 randomSuffixId
*/
int GetRandomSuffix(lua_State* L, Item* item)
{
Eluna::Push(L, item->GetTemplate()->RandomSuffix);

7
src/LuaEngine/methods/ItemTemplateMethods.h
View File

@@ -9,6 +9,13 @@
#include "Chat.h"
/***
* Represents item data defined in the database and DBCs, such as stats, quality, class restrictions, and display info.
*
* Used to access read-only metadata about items (not specific item instances in bags or equipment).
*
* Inherits all methods from: none
*/
namespace LuaItemTemplate
{
/**

2
src/LuaEngine/methods/LootMethods.h
View File

@@ -354,7 +354,7 @@ namespace LuaLoot
/**
* Returns the [Player] GUID that owns this loot for round robin distribution.
*
* @return ObjectGUID roundRobinPlayer : the player GUID
* @return ObjectGuid roundRobinPlayer : the player GUID
*/
int GetRoundRobinPlayer(lua_State* L, Loot* loot)
{

32
src/LuaEngine/methods/PlayerMethods.h
View File

@@ -531,6 +531,13 @@ namespace LuaPlayer
return 1;
}
/**
* Returns `true` if the [Player] is in the same group and visible to the specified [Player], `false` otherwise.
*
* @param [Player] player : the source player
* @param [Player] target : the player to check visibility from
* @return bool isGroupVisible
*/
int IsGroupVisibleFor(lua_State* L, Player* player)
{
Player* target = Eluna::CHECKOBJ<Player>(L, 2);
@@ -592,6 +599,12 @@ namespace LuaPlayer
return 1;
}
/**
* Returns `true` if the [Player] is currently visible to other players, `false` if hidden via GM invisibility.
*
* @param [Player] player
* @return bool isVisible
*/
int IsGMVisible(lua_State* L, Player* player)
{
Eluna::Push(L, player->isGMVisible());
@@ -609,6 +622,12 @@ namespace LuaPlayer
return 1;
}
/**
* Returns `true` if the [Player] has GM chat enabled, `false` otherwise.
*
* @param [Player] player
* @return bool isGMChat
*/
int IsGMChat(lua_State* L, Player* player)
{
Eluna::Push(L, player->isGMChat());
@@ -3123,6 +3142,12 @@ namespace LuaPlayer
return 1;
}
/**
* Adds a specified number of lifetime honorable kills to the [Player].
*
* @param [Player] player
* @param uint32 kills
*/
int AddLifetimeKills(lua_State* L, Player* player)
{
uint32 val = Eluna::CHECKVAL<uint32>(L, 2);
@@ -3417,9 +3442,10 @@ namespace LuaPlayer
}
/**
* Get glyphId of the glyph slot specified by `slotIndex` off the [Player]'s current talent specialization.`
* @param uint32 slotIndex
* @return glyphId of the glyph in the selected glyph slot or 0 in case the glyph slot is empty
* Returns the glyph ID in the specified glyph slot of the [Player]'s current talent specialization.
*
* @param [uint32] slotIndex
* @return [uint32] glyphId
*/
int GetGlyph(lua_State* L, Player* player)
{

2
src/LuaEngine/methods/QuestMethods.h
View File

@@ -8,6 +8,8 @@
#define QUESTMETHODS_H
/***
* Represents a quest in the game, including its objectives, rewards, and conditions.
*
* Inherits all methods from: none
*/
namespace LuaQuest

7
src/LuaEngine/methods/RollMethods.h
View File

@@ -9,6 +9,13 @@
#include "Group.h"
/***
* Represents a group loot roll session for an item, including player votes and roll statistics.
*
* Provides access to the item being rolled, player vote types, and counts of each roll type (Need, Greed, Pass).
*
* Inherits all methods from: none
*/
namespace LuaRoll
{
/**

150
src/LuaEngine/methods/SpellEntryMethods.h
View File

@@ -7,6 +7,13 @@
#ifndef SPELLENTRYMETHODS_H
#define SPELLENTRYMETHODS_H
/***
* Represents spell data loaded from the DBCs, including effects, costs, attributes, and requirements.
*
* Used for inspecting the properties of any spell in the game, such as mana cost, targets, or effects.
*
* Inherits all methods from: none
*/
namespace LuaSpellEntry
{
/**
@@ -152,6 +159,13 @@ namespace LuaSpellEntry
return 1;
}
/**
* Returns the stance restriction bitmask for which the [SpellEntry] cannot be used.
*
* This mask indicates which shapeshift forms (stances) prevent the spell from being cast.
*
* @return uint32 stancesNotMask
*/
int GetStancesNot(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->StancesNot);
@@ -180,66 +194,143 @@ namespace LuaSpellEntry
return 1;
}
/**
* Returns the SpellFocus ID required to cast this [SpellEntry].
*
* Some spells require proximity to a specific game object (e.g., a brazier or altar).
*
* @return uint32 spellFocusId
*/
int GetRequiresSpellFocus(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->RequiresSpellFocus);
return 1;
}
/**
* Returns the facing flags for this [SpellEntry].
*
* Indicates whether the caster must be facing the target or meet other orientation constraints.
*
* @return uint32 facingFlags
*/
int GetFacingCasterFlags(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->FacingCasterFlags);
return 1;
}
/**
* Returns the required caster aura state for this [SpellEntry].
*
* The spell can only be cast if the caster has a specific aura state active.
*
* @return uint32 casterAuraState
*/
int GetCasterAuraState(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->CasterAuraState);
return 1;
}
/**
* Returns the required target aura state for this [SpellEntry].
*
* The spell can only be cast if the target has a specific aura state active.
*
* @return uint32 targetAuraState
*/
int GetTargetAuraState(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->TargetAuraState);
return 1;
}
/**
* Returns the forbidden caster aura state for this [SpellEntry].
*
* The spell cannot be cast if the caster has this aura state active.
*
* @return uint32 casterAuraStateNot
*/
int GetCasterAuraStateNot(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->CasterAuraStateNot);
return 1;
}
/**
* Returns the forbidden target aura state for this [SpellEntry].
*
* The spell cannot be cast if the target has this aura state active.
*
* @return uint32 targetAuraStateNot
*/
int GetTargetAuraStateNot(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->TargetAuraStateNot);
return 1;
}
/**
* Returns the required aura spell ID that must be on the caster.
*
* The spell can only be cast if the caster has an aura from this spell.
*
* @return uint32 casterAuraSpellId
*/
int GetCasterAuraSpell(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->CasterAuraSpell);
return 1;
}
/**
* Returns the required aura spell ID that must be on the target.
*
* The spell can only be cast if the target has an aura from this spell.
*
* @return uint32 targetAuraSpellId
*/
int GetTargetAuraSpell(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->TargetAuraSpell);
return 1;
}
/**
* Returns the aura spell ID that must NOT be on the caster.
*
* The spell cannot be cast if the caster has an aura from this spell.
*
* @return uint32 excludeCasterAuraSpellId
*/
int GetExcludeCasterAuraSpell(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->ExcludeCasterAuraSpell);
return 1;
}
/**
* Returns the aura spell ID that must NOT be on the target.
*
* The spell cannot be cast if the target has an aura from this spell.
*
* @return uint32 excludeTargetAuraSpellId
*/
int GetExcludeTargetAuraSpell(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->ExcludeTargetAuraSpell);
return 1;
}
/**
* Returns the casting time index of this [SpellEntry].
*
* This index is used to look up the base casting time in SpellCastTimes.dbc.
*
* @return uint32 castingTimeIndex
*/
int GetCastingTimeIndex(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->CastingTimeIndex);
@@ -268,24 +359,52 @@ namespace LuaSpellEntry
return 1;
}
/**
* Returns the interrupt flags for this [SpellEntry].
*
* Determines what can interrupt this spell while casting (e.g., movement, taking damage).
*
* @return uint32 interruptFlags
*/
int GetInterruptFlags(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->InterruptFlags);
return 1;
}
/**
* Returns the aura interrupt flags for this [SpellEntry].
*
* Indicates what actions will break or remove the aura applied by this spell.
*
* @return uint32 auraInterruptFlags
*/
int GetAuraInterruptFlags(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->AuraInterruptFlags);
return 1;
}
/**
* Returns the channel interrupt flags for this [SpellEntry].
*
* Specifies conditions under which a channeled spell will be interrupted (e.g., moving or turning).
*
* @return uint32 channelInterruptFlags
*/
int GetChannelInterruptFlags(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->ChannelInterruptFlags);
return 1;
}
/**
* Returns the proc flags for this [SpellEntry].
*
* Determines the types of actions or triggers that can cause this spell to proc.
*
* @return uint32 procFlags
*/
int GetProcFlags(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->ProcFlags);
@@ -899,6 +1018,14 @@ namespace LuaSpellEntry
return 1;
}
/**
* Returns a table of [SpellFamilyFlags] for each effect of this [SpellEntry].
*
* These flags are used to categorize spell effects for use with spell group logic.
* The table contains up to 3 bitmask entries, one per effect.
*
* @return table effectSpellClassMask : table of [SpellFamilyFlags] per effect
*/
int GetEffectSpellClassMask(lua_State* L, SpellEntry* entry)
{
lua_newtable(L);
@@ -1055,13 +1182,26 @@ namespace LuaSpellEntry
return 1;
}
/**
* Returns the spell family name of this [SpellEntry].
*
* This identifies the broader category or class of spells (e.g., Mage, Warrior, Rogue).
*
* @return uint32 spellFamilyName
*/
int GetSpellFamilyName(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->SpellFamilyName);
return 1;
}
/**
* Returns the spell family flags of this [SpellEntry].
*
* These bitflags represent specific characteristics or subcategories of spells within a family.
*
* @return uint64 spellFamilyFlags
*/
int GetSpellFamilyFlags(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->SpellFamilyFlags);
@@ -1143,6 +1283,13 @@ namespace LuaSpellEntry
return 1;
}
/**
* Returns the Area Group ID associated with this [SpellEntry].
*
* AreaGroupId is used to restrict spell usage to specific zones or areas.
*
* @return uint32 areaGroupId
*/
int GetAreaGroupId(lua_State* L, SpellEntry* entry)
{
Eluna::Push(L, entry->AreaGroupId);
@@ -2256,4 +2403,3 @@ namespace LuaSpellEntry
}
#endif

195
src/LuaEngine/methods/SpellInfoMethods.h
View File

@@ -7,6 +7,14 @@
#ifndef SPELLINFOMETHODS_H
#define SPELLINFOMETHODS_H
/***
* Represents spell metadata used for behavior, targeting, attributes, mechanics, auras, and conditions.
*
* Unlike [SpellEntry], this class includes helper functions and logic used to determine spell behavior in-game.
* Used for checking if a spell is passive, area-targeted, profession-related, or has specific effects or auras.
*
* Inherits all methods from: none
*/
namespace LuaSpellInfo
{
@@ -391,13 +399,13 @@ namespace LuaSpellInfo
}
/**
* Checks if the [SpellInfo] requires to be triggered by the caster of another specified spell.
* Checks if the [SpellInfo] requires to be triggered by the caster of another specified [SpellInfo].
*
* Certain spells or abilities can only be activated or become effective when they are triggered by the caster
* of another specific spell (the triggeringSpell). This function examines if the spell or ability represented
* of another specific spell (the `triggeringSpell`). This function examines if the spell or ability represented
* by [SpellInfo] has such requirement.
*
* @param triggeringSpell The spell by the casting of which the ability or spell represented by [SpellInfo] is triggered.
* @param [SpellInfo] triggeringSpell : the spell by the casting of which the ability or spell represented by [SpellInfo] is triggered
* @return [bool] needs_to_be_triggered_by_caster
*/
int NeedsToBeTriggeredByCaster(lua_State* L, SpellInfo* spell_info)
@@ -528,24 +536,45 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] allows casting on dead targets, `false` otherwise.
*
* @return bool allowsDeadTarget
*/
int IsAllowingDeadTarget(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsAllowingDeadTarget());
return 1;
}
/**
* Returns `true` if the [SpellInfo] can be cast while in combat, `false` otherwise.
*
* @return bool usableInCombat
*/
int CanBeUsedInCombat(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->CanBeUsedInCombat());
return 1;
}
/**
* Returns `true` if the [SpellInfo] is considered a positive (beneficial) spell, `false` otherwise.
*
* @return bool isPositive
*/
int IsPositive(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsPositive());
return 1;
}
/**
* Returns `true` if the specified effect index of the [SpellInfo] is positive, `false` otherwise.
*
* @param uint8 effIndex
* @return bool isPositiveEffect
*/
int IsPositiveEffect(lua_State* L, SpellInfo* spell_info)
{
uint8 effIndex = Eluna::CHECKVAL<uint32>(L, 2);
@@ -553,37 +582,66 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] is a channeled spell, `false` otherwise.
*
* @return bool isChanneled
*/
int IsChanneled(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsChanneled());
return 1;
}
/**
* Returns `true` if the [SpellInfo] requires combo points to cast, `false` otherwise.
*
* @return bool needsComboPoints
*/
int NeedsComboPoints(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->NeedsComboPoints());
return 1;
}
/**
* Returns `true` if the [SpellInfo] breaks stealth when cast, `false` otherwise.
*
* @return bool breaksStealth
*/
int IsBreakingStealth(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsBreakingStealth());
return 1;
}
/**
* Returns `true` if the [SpellInfo] is a ranged weapon attack (e.g., shoot, throw), `false` otherwise.
*
* @return bool isRangedWeaponSpell
*/
int IsRangedWeaponSpell(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsRangedWeaponSpell());
return 1;
}
/**
* Returns `true` if the [SpellInfo] is an auto-repeat ranged spell (e.g., auto-shot), `false` otherwise.
*
* @return bool isAutoRepeat
*/
int IsAutoRepeatRangedSpell(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsAutoRepeatRangedSpell());
return 1;
}
/**
* Returns `true` if the [SpellInfo] is affected by spell modifiers (e.g., talents, auras), `false` otherwise.
*
* @return bool isAffectedByMods
*/
int IsAffectedBySpellMods(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsAffectedBySpellMods());
@@ -598,6 +656,12 @@ namespace LuaSpellInfo
}
*/
/**
* Returns `true` if the [SpellInfo] can pierce through an immunity aura defined by the given [SpellInfo], `false` otherwise.
*
* @param [SpellInfo] auraSpellInfo : the spell representing the immunity aura
* @return bool canPierce
*/
int CanPierceImmuneAura(lua_State* L, SpellInfo* spell_info)
{
const SpellInfo* auraSpellInfo = Eluna::CHECKOBJ<SpellInfo>(L, 2);
@@ -605,6 +669,12 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] can dispel the specified aura [SpellInfo], `false` otherwise.
*
* @param [SpellInfo] auraSpellInfo : the aura spell to check
* @return bool canDispel
*/
int CanDispelAura(lua_State* L, SpellInfo* spell_info)
{
const SpellInfo* auraSpellInfo = Eluna::CHECKOBJ<SpellInfo>(L, 2);
@@ -612,12 +682,23 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] only affects a single target, `false` if it affects multiple or area targets.
*
* @return bool isSingleTarget
*/
int IsSingleTarget(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->IsSingleTarget());
return 1;
}
/**
* Returns `true` if the [SpellInfo] is mutually exclusive with the specified [SpellInfo] due to specific aura exclusivity rules.
*
* @param [SpellInfo] otherSpellInfo : the spell to compare exclusivity with
* @return bool isExclusive
*/
int IsAuraExclusiveBySpecificWith(lua_State* L, SpellInfo* spell_info)
{
const SpellInfo* spellInfo = Eluna::CHECKOBJ<SpellInfo>(L, 2);
@@ -625,6 +706,12 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] is exclusive with the specified [SpellInfo] per caster, based on aura exclusivity rules.
*
* @param [SpellInfo] otherSpellInfo : the spell to compare exclusivity with
* @return bool isExclusivePerCaster
*/
int IsAuraExclusiveBySpecificPerCasterWith(lua_State* L, SpellInfo* spell_info)
{
const SpellInfo* spellInfo = Eluna::CHECKOBJ<SpellInfo>(L, 2);
@@ -632,6 +719,12 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] can be cast while in the specified shapeshift form.
*
* @param uint32 form : the shapeshift form to check
* @return bool isAllowed
*/
int CheckShapeshift(lua_State* L, SpellInfo* spell_info)
{
uint32 form = Eluna::CHECKVAL<uint32>(L, 2);
@@ -639,6 +732,16 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] can be cast in the specified location.
*
* @param uint32 map_id : required map ID
* @param uint32 zone_id : required zone ID
* @param uint32 area_id : required area ID
* @param [Player] player : the [Player] casting the spell
* @param bool strict = false : whether all conditions must strictly match
* @return bool isAllowed
*/
int CheckLocation(lua_State* L, SpellInfo* spell_info)
{
uint32 map_id = Eluna::CHECKVAL<uint32>(L, 2);
@@ -651,6 +754,14 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the target is valid for the [SpellInfo].
*
* @param [Unit] caster : the [Unit] casting the spell
* @param [WorldObject] target : the intended target
* @param bool implicit = true : whether implicit target checks should apply
* @return bool isValid
*/
int CheckTarget(lua_State* L, SpellInfo* spell_info)
{
const Unit* caster = Eluna::CHECKOBJ<Unit>(L, 2);
@@ -661,6 +772,14 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] can be explicitly cast on the given [target] with the optional [Item].
*
* @param [Unit] caster : the [Unit] attempting to cast the spell
* @param [WorldObject] target : the intended target of the spell
* @param [Item] item : optional item used in the cast
* @return bool isValid
*/
int CheckExplicitTarget(lua_State* L, SpellInfo* spell_info)
{
const Unit* caster = Eluna::CHECKOBJ<Unit>(L, 2);
@@ -671,6 +790,12 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns `true` if the [SpellInfo] can affect the [Unit] based on its creature type.
*
* @param [Unit] target : the [Unit] whose creature type is evaluated
* @return bool isValid
*/
int CheckTargetCreatureType(lua_State* L, SpellInfo* spell_info)
{
const Unit* target = Eluna::CHECKOBJ<Unit>(L, 2);
@@ -679,18 +804,38 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns the school mask of the [SpellInfo].
*
* The school mask is a bitmask representing the spell's school(s), such as arcane, fire, frost, etc.
*
* @return uint32 schoolMask
*/
int GetSchoolMask(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->GetSchoolMask());
return 1;
}
/**
* Returns a combined mechanic mask of all effects for the [SpellInfo].
*
* The mechanic mask is a bitmask representing all mechanics applied by the spell’s effects.
*
* @return uint32 mechanicMask
*/
int GetAllEffectsMechanicMask(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->GetAllEffectsMechanicMask());
return 1;
}
/**
* Returns the mechanic mask of a specific effect of the [SpellInfo].
*
* @param uint32 effIndex
* @return uint32 mechanicMask
*/
int GetEffectMechanicMask(lua_State* L, SpellInfo* spell_info)
{
uint32 effIndex = Eluna::CHECKVAL<uint32>(L, 2);
@@ -699,6 +844,12 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns the mechanic mask for the [SpellInfo] based on an effect bitmask.
*
* @param uint32 effectmask : bitmask of effects to include
* @return uint32 mechanicMask
*/
int GetSpellMechanicMaskByEffectMask(lua_State* L, SpellInfo* spell_info)
{
uint32 effectmask = Eluna::CHECKVAL<uint32>(L, 2);
@@ -707,6 +858,12 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns the mechanic of the specified effect index in the [SpellInfo].
*
* @param uint32 effIndex
* @return uint32 mechanic
*/
int GetEffectMechanic(lua_State* L, SpellInfo* spell_info)
{
uint32 effIndex = Eluna::CHECKVAL<uint32>(L, 2);
@@ -715,6 +872,14 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns the dispel mask for the [SpellInfo].
*
* The dispel mask is a bitmask representing the types of dispels that can remove the spell's effects.
*
* @param uint32 type : optional type of dispel to check. If not provided, uses the spell's own dispel type.
* @return uint32 dispelMask
*/
int GetDispelMask(lua_State* L, SpellInfo* spell_info)
{
uint32 type = Eluna::CHECKVAL<uint32>(L, 2, false);
@@ -723,18 +888,39 @@ namespace LuaSpellInfo
return 1;
}
/**
* Returns the explicit target mask of the [SpellInfo].
*
* This mask defines what types of targets the spell can explicitly target.
*
* @return uint32 targetMask
*/
int GetExplicitTargetMask(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->GetExplicitTargetMask());
return 1;
}
/**
* Returns the aura state requirement for the [SpellInfo].
*
* Used to check whether a specific aura state must be active to cast the spell.
*
* @return uint32 auraState
*/
int GetAuraState(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->GetAuraState());
return 1;
}
/**
* Returns the spell specific type of the [SpellInfo].
*
* Useful for identifying special types such as food, bandages, portals, etc.
*
* @return uint32 spellSpecific
*/
int GetSpellSpecific(lua_State* L, SpellInfo* spell_info)
{
Eluna::Push(L, spell_info->GetSpellSpecific());
@@ -742,4 +928,3 @@ namespace LuaSpellInfo
}
}
#endif

44
src/LuaEngine/methods/TicketMethods.h
View File

@@ -8,7 +8,7 @@
#define TICKETMETHODS_H
/***
* An instance of a spell, created when the spell is cast by a [Unit].
* Represents a support ticket created by a [Player] using the in-game ticket system.
*
* Inherits all methods from: none
*/
@@ -17,7 +17,7 @@ namespace LuaTicket
/**
* Returns true if the [Ticket] is closed or false.
*
* @return bool is_closed
* @return bool isClosed
*/
int IsClosed(lua_State* L, GmTicket* ticket)
{
@@ -28,7 +28,7 @@ namespace LuaTicket
/**
* Returns true if the [Ticket] is completed or false.
*
* @return bool is_completed
* @return bool isCompleted
*/
int IsCompleted(lua_State* L, GmTicket* ticket)
{
@@ -39,9 +39,9 @@ namespace LuaTicket
/**
* Return true if this GUID is the same as the [Player] who created the [Ticket] or false.
*
* @param guid playerGuid : desired playerGuid
* @param ObjectGuid playerGuid
*
* @return bool same_guid
* @return bool isSamePlayer
*/
int IsFromPlayer(lua_State* L, GmTicket* ticket)
{
@@ -54,7 +54,7 @@ namespace LuaTicket
/**
* Return true if the [Ticket] is assigned or false.
*
* @return bool is_assigned
* @return bool isAssigned
*/
int IsAssigned(lua_State* L, GmTicket* ticket)
{
@@ -63,11 +63,11 @@ namespace LuaTicket
}
/**
* Return true if the [Ticket] is assigned to the GUID or false.
* Return true if the [Ticket] is assigned to the [Player] or false.
*
* @param guid playerGuid : desired playerGuid
* @param ObjectGuid playerGuid
*
* @return bool is_assigned_to
* @return bool isAssignedTo
*/
int IsAssignedTo(lua_State* L, GmTicket* ticket)
{
@@ -78,11 +78,11 @@ namespace LuaTicket
}
/**
* Return true if the [Ticket] is not assigned to the GUID or false.
* Return true if the [Ticket] is not assigned to the [Player] or false.
*
* @param guid playerGuid : desired playerGuid
* @param ObjectGuid playerGuid
*
* @return bool is_assigned_not_to
* @return bool isAssignedNotTo
*/
int IsAssignedNotTo(lua_State* L, GmTicket* ticket)
{
@@ -95,7 +95,7 @@ namespace LuaTicket
/**
* Return the [Ticket] id.
*
* @return unint32 ticket_id
* @return uint32 ticketId
*/
int GetId(lua_State* L, GmTicket* ticket)
{
@@ -117,7 +117,7 @@ namespace LuaTicket
/**
* Return the [Player] name from the [Ticket].
*
* @return string player_name
* @return string playerName
*/
int GetPlayerName(lua_State* L, GmTicket* ticket)
{
@@ -139,7 +139,7 @@ namespace LuaTicket
/**
* Returns the assigned [Player].
*
* @return [Player] assigned_player
* @return [Player] assignedPlayer
*/
int GetAssignedPlayer(lua_State* L, GmTicket* ticket)
{
@@ -150,7 +150,7 @@ namespace LuaTicket
/**
* Returns the assigned guid.
*
* @return [ObjectGUID] assigned_guid
* @return uint32 assignedGuid
*/
int GetAssignedToGUID(lua_State* L, GmTicket* ticket)
{
@@ -161,7 +161,7 @@ namespace LuaTicket
/**
* Returns the last modified time from the [Ticket].
*
* @return uint64 last_modified
* @return uint64 lastModifiedTime
*/
int GetLastModifiedTime(lua_State* L, GmTicket* ticket)
{
@@ -172,8 +172,8 @@ namespace LuaTicket
/**
* Assign the [Ticket] to a player via his GUID.
*
* @param guid playerGuid : desired playerGuid
* @param bool isAdmin : true if the guid is an Admin or false (default false)
* @param ObjectGuid playerGuid
* @param bool isAdmin : true if the [Player] is an Admin or false (default false)
*/
int SetAssignedTo(lua_State* L, GmTicket* ticket)
{
@@ -186,7 +186,7 @@ namespace LuaTicket
/**
* Set [Ticket] resolved by player via his GUID.
*
* @param guid playerGuid : desired playerGuid
* @param ObjectGuid playerGuid
*/
int SetResolvedBy(lua_State* L, GmTicket* ticket)
{
@@ -234,7 +234,7 @@ namespace LuaTicket
}
/**
* Set [Ticket] is viewed.
* Set [Ticket] as viewed.
*
*/
int SetViewed(lua_State* /*L*/, GmTicket* ticket)
@@ -244,7 +244,7 @@ namespace LuaTicket
}
/**
* Set [Ticket] is unassigned.
* Set [Ticket] as unassigned.
*
*/
int SetUnassigned(lua_State* /*L*/, GmTicket* ticket)

15
src/LuaEngine/methods/UnitMethods.h
View File

@@ -8,6 +8,8 @@
#define UNITMETHODS_H
/***
* Represents a non-[Player] controlled [Unit] (i.e. NPCs).
*
* Inherits all methods from: [Object], [WorldObject]
*/
namespace LuaUnit
@@ -1175,13 +1177,11 @@ namespace LuaUnit
return 1;
}
/*
int GetVehicle(lua_State* L, Unit* unit)
/*int GetVehicle(lua_State* L, Unit* unit)
{
Eluna::Push(L, unit->GetVehicle());
return 1;
}
*/
}*/
/**
* Returns the Critter Guid
@@ -1793,6 +1793,13 @@ namespace LuaUnit
return 0;
}
/**
* Sets the [Unit]'s critter companion by GUID.
*
* This method assigns the specified [ObjectGuid] as the critter (non-combat pet) companion of the [Unit].
*
* @param [ObjectGuid] guid : The GUID of the critter to set
*/
int SetCritterGUID(lua_State* L, Unit* unit)
{
ObjectGuid guid = Eluna::CHECKVAL<ObjectGuid>(L, 2);

2
src/LuaEngine/methods/VehicleMethods.h
View File

@@ -8,6 +8,8 @@
#define VEHICLEMETHODS_H
/***
* Represents a vehicle in the game, which can carry passengers and provide special abilities or movement.
*
* Inherits all methods from: none
*/
namespace LuaVehicle

2
src/LuaEngine/methods/WorldObjectMethods.h
View File

@@ -8,6 +8,8 @@
#define WORLDOBJECTMETHODS_H
/***
* Represents a [WorldObject] in the game world.
*
* Inherits all methods from: [Object]
*/
namespace LuaWorldObject