2406 lines
65 KiB
C++
2406 lines
65 KiB
C++
/*
|
|
* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
|
|
* This program is free software licensed under GPL version 3
|
|
* Please see the included DOCS/LICENSE.md for more information
|
|
*/
|
|
|
|
#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
|
|
{
|
|
/**
|
|
* Returns the ID of the [SpellEntry].
|
|
*
|
|
* @return uint32 id
|
|
*/
|
|
int GetId(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Id);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the category ID for the [SpellEntry].
|
|
*
|
|
* @return uint32 categoryId
|
|
*/
|
|
int GetCategory(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Category);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the dispel ID for the [SpellEntry].
|
|
*
|
|
* @return uint32 dispelId
|
|
*/
|
|
int GetDispel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Dispel);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the mechanic ID for the [SpellEntry].
|
|
*
|
|
* @return uint32 mechanicId
|
|
*/
|
|
int GetMechanic(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Mechanic);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attribute bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attribute : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributes(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Attributes);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx2 bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx2 : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx2(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx2);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx3 bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx3 : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx3(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx3);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx4 bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx4 : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx4(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx4);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx5 bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx5 : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx5(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx5);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx6 bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx6 : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx6(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx6);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the attributeEx7 bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 attributeEx7 : bitmask, but returned as uint32
|
|
*/
|
|
int GetAttributesEx7(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->AttributesEx7);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the stance bitflags for the [SpellEntry].
|
|
*
|
|
* @return uint32 stance : bitmask, but returned as uint32
|
|
*/
|
|
int GetStances(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Stances);
|
|
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)
|
|
{
|
|
ALE::Push(L, entry->StancesNot);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the target bitmasks for the [SpellEntry].
|
|
*
|
|
* @return uint32 target : bitmasks, but returned as uint32.
|
|
*/
|
|
int GetTargets(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Targets);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the target creature type bitmasks for the [SpellEntry].
|
|
*
|
|
* @return uint32 targetCreatureType : bitmasks, but returned as uint32.
|
|
*/
|
|
int GetTargetCreatureType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->TargetCreatureType);
|
|
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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::Push(L, entry->CastingTimeIndex);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the recovery time for the [SpellEntry].
|
|
*
|
|
* @return uint32 recoveryTime
|
|
*/
|
|
int GetRecoveryTime(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->RecoveryTime);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the category recovery time for the [SpellEntry].
|
|
*
|
|
* @return uint32 categoryRecoveryTime : in milliseconds, returned as uint32
|
|
*/
|
|
int GetCategoryRecoveryTime(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->CategoryRecoveryTime);
|
|
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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::Push(L, entry->ProcFlags);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the proc chance of [SpellEntry].
|
|
*
|
|
* @return uint32 procChance
|
|
*/
|
|
int GetProcChance(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ProcChance);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the proc charges of [SpellEntry].
|
|
*
|
|
* @return uint32 procCharges
|
|
*/
|
|
int GetProcCharges(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ProcCharges);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the max level for the [SpellEntry].
|
|
*
|
|
* @return uint32 maxLevel : the [SpellEntry] max level.
|
|
*/
|
|
int GetMaxLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->MaxLevel);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the base level required for the [SpellEntry].
|
|
*
|
|
* @return uint32 baseLevel
|
|
*/
|
|
int GetBaseLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->BaseLevel);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the spell level for the [SpellEntry].
|
|
*
|
|
* @return uint32 spellLevel
|
|
*/
|
|
int GetSpellLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->SpellLevel);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the duration index for the [SpellEntry].
|
|
*
|
|
* @return uint32 durationIndex
|
|
*/
|
|
int GetDurationIndex(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->DurationIndex);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the power type ID for the [SpellEntry].
|
|
*
|
|
* @return uint32 powerTypeId
|
|
*/
|
|
int GetPowerType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->PowerType);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the mana cost for the [SpellEntry].
|
|
*
|
|
* @return uint32 manaCost
|
|
*/
|
|
int GetManaCost(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ManaCost);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the mana cost per level for [SpellEntry].
|
|
*
|
|
* @return uint32 manaCostPerLevel
|
|
*/
|
|
int GetManaCostPerlevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ManaCostPerlevel);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the mana per second for [SpellEntry].
|
|
*
|
|
* @return uint32 manaPerSecond
|
|
*/
|
|
int GetManaPerSecond(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ManaPerSecond);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the mana per second per level for [SpellEntry].
|
|
*
|
|
* @return uint32 manaPerSecondPerLevel
|
|
*/
|
|
int GetManaPerSecondPerLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ManaPerSecondPerLevel);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the range index for [SpellEntry].
|
|
*
|
|
* @return uint32 rangeIndex
|
|
*/
|
|
int GetRangeIndex(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->RangeIndex);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns speed for [SpellEntry].
|
|
*
|
|
* @return uint32 speed
|
|
*/
|
|
int GetSpeed(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->Speed);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the stack amount for [SpellEntry].
|
|
*
|
|
* @return uint32 stackAmount
|
|
*/
|
|
int GetStackAmount(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->StackAmount);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all totem values for [SpellEntry].
|
|
*
|
|
* @return table totem
|
|
*/
|
|
int GetTotem(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->Totem.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->Totem[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all reagent values for [SpellEntry].
|
|
*
|
|
* @return table reagent
|
|
*/
|
|
int GetReagent(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->Reagent.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->Reagent[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all reagent count values for [SpellEntry].
|
|
*
|
|
* @return table reagentCount
|
|
*/
|
|
int GetReagentCount(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->ReagentCount.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->ReagentCount[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the equipped item class ID for [SpellEntry].
|
|
*
|
|
* @return uint32 equippedItemClassId
|
|
*/
|
|
int GetEquippedItemClass(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->EquippedItemClass);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the equipped item sub class masks for [SpellEntry].
|
|
*
|
|
* @return uint32 equippedItemSubClassMasks : bitmasks, returned as uint32.
|
|
*/
|
|
int GetEquippedItemSubClassMask(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->EquippedItemSubClassMask);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the equipped item inventory type masks for [SpellEntry].
|
|
*
|
|
* @return uint32 equippedItemInventoryTypeMasks : bitmasks, returned as uint32.
|
|
*/
|
|
int GetEquippedItemInventoryTypeMask(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->EquippedItemInventoryTypeMask);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all spell effect IDs for [SpellEntry].
|
|
*
|
|
* @return table effect
|
|
*/
|
|
int GetEffect(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->Effect.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->Effect[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect die sides values for [SpellEntry].
|
|
*
|
|
* @return table effectDieSides
|
|
*/
|
|
int GetEffectDieSides(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectDieSides.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectDieSides[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect real points per level values for [SpellEntry].
|
|
*
|
|
* @return table effectRealPointsPerLevel
|
|
*/
|
|
int GetEffectRealPointsPerLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectRealPointsPerLevel.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectRealPointsPerLevel[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect base points values for [SpellEntry].
|
|
*
|
|
* @return table effectBasePoints
|
|
*/
|
|
int GetEffectBasePoints(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectBasePoints.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectBasePoints[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect mechanic IDs for [SpellEntry].
|
|
*
|
|
* @return table effectMechanic
|
|
*/
|
|
int GetEffectMechanic(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectMechanic.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectMechanic[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect implicit target a IDs for [SpellEntry].
|
|
*
|
|
* @return table effectImplicitTargetA
|
|
*/
|
|
int GetEffectImplicitTargetA(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectImplicitTargetA.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectImplicitTargetA[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect implicit target b IDs for [SpellEntry].
|
|
*
|
|
* @return table effectImplicitTargetB
|
|
*/
|
|
int GetEffectImplicitTargetB(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectImplicitTargetB.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectImplicitTargetB[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect radius index for [SpellEntry].
|
|
*
|
|
* @return table effectRadiusIndex
|
|
*/
|
|
int GetEffectRadiusIndex(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectRadiusIndex.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectRadiusIndex[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect apply aura IDs for [SpellEntry].
|
|
*
|
|
* @return table effectApplyAura
|
|
*/
|
|
int GetEffectApplyAuraName(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectApplyAuraName.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectApplyAuraName[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect amplitude values for [SpellEntry].
|
|
*
|
|
* @return table effectAmplitude
|
|
*/
|
|
int GetEffectAmplitude(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectAmplitude.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectAmplitude[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect value multiplier for [SpellEntry].
|
|
*
|
|
* @return table effectValueMultiplier
|
|
*/
|
|
int GetEffectValueMultiplier(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectValueMultiplier.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectValueMultiplier[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect chain target values for [SpellEntry].
|
|
*
|
|
* @return table effectChainTarget
|
|
*/
|
|
int GetEffectChainTarget(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectChainTarget.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectChainTarget[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect item type values for [SpellEntry].
|
|
*
|
|
* @return table effectItemType
|
|
*/
|
|
int GetEffectItemType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectItemType.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectItemType[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect misc value A for [SpellEntry].
|
|
*
|
|
* @return table effectMiscValueA
|
|
*/
|
|
int GetEffectMiscValue(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectMiscValue.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectMiscValue[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect misc value B for [SpellEntry].
|
|
*
|
|
* @return table effectMiscValueB
|
|
*/
|
|
int GetEffectMiscValueB(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectMiscValueB.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectMiscValueB[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect trigger spell for [SpellEntry].
|
|
*
|
|
* @return table effectTriggerSpell
|
|
*/
|
|
int GetEffectTriggerSpell(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectTriggerSpell.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectTriggerSpell[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect points per combo point of [SpellEntry]
|
|
*
|
|
* @return table effectPointsPerComboPoint : returns a table containing all the effect points per combo point values of [SpellEntry]
|
|
*/
|
|
int GetEffectPointsPerComboPoint(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectPointsPerComboPoint.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectPointsPerComboPoint[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
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);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectSpellClassMask.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectSpellClassMask[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with both spell visuals of [SpellEntry]
|
|
*
|
|
* @return table spellVisuals : returns a table containing both spellVisuals for [SpellEntry].
|
|
*/
|
|
int GetSpellVisual(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->SpellVisual.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->SpellVisual[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the spell icon ID for the [SpellEntry].
|
|
*
|
|
* @return uint32 spellIconId
|
|
*/
|
|
int GetSpellIconID(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->SpellIconID);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the active icon ID for the [SpellEntry].
|
|
*
|
|
* @return uint32 activeIconId
|
|
*/
|
|
int GetActiveIconID(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ActiveIconID);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the spell Priority for the [SpellEntry].
|
|
*
|
|
* @return uint32 spellPriority
|
|
*/
|
|
int GetSpellPriority(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->SpellPriority);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table of the [SpellEntry] names of all locals.
|
|
*
|
|
* @return table spellNames
|
|
*/
|
|
int GetSpellName(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->SpellName.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->SpellName[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table of the [SpellEntry] ranks.
|
|
*
|
|
* @return table spellRanks
|
|
*/
|
|
int GetRank(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->Rank.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->Rank[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the mana cost percentage of [SpellEntry].
|
|
*
|
|
* @return uint32 manaCostPercentage : the mana cost in percentage, returned as uint32.
|
|
*/
|
|
int GetManaCostPercentage(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->ManaCostPercentage);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the global cooldown time value for [SpellEntry].
|
|
*
|
|
* @return uint32 globalCooldownTime
|
|
*/
|
|
int GetStartRecoveryCategory(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->StartRecoveryCategory);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the global cooldown category value for [SpellEntry].
|
|
*
|
|
* @return uint32 globalCooldownCategory
|
|
*/
|
|
int GetStartRecoveryTime(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->StartRecoveryTime);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the max target level value for [SpellEntry].
|
|
*
|
|
* @return uint32 maxTargetLevel
|
|
*/
|
|
int GetMaxTargetLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->MaxTargetLevel);
|
|
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)
|
|
{
|
|
ALE::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)
|
|
{
|
|
ALE::Push(L, entry->SpellFamilyFlags);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the max affected targets value [SpellEntry].
|
|
*
|
|
* @return uint32 maxAffectedTargets
|
|
*/
|
|
int GetMaxAffectedTargets(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->MaxAffectedTargets);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the spell damage type ID [SpellEntry].
|
|
*
|
|
* @return uint32 spellDamageTypeId
|
|
*/
|
|
int GetDmgClass(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->DmgClass);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the prevention type ID [SpellEntry].
|
|
*
|
|
* @return uint32 preventionTypeId
|
|
*/
|
|
int GetPreventionType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->PreventionType);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect damage multiplier values [SpellEntry].
|
|
*
|
|
* @return table effectDamageMultipliers
|
|
*/
|
|
int GetEffectDamageMultiplier(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectDamageMultiplier.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectDamageMultiplier[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with totem categories IDs [SpellEntry].
|
|
*
|
|
* @return table totemCategory
|
|
*/
|
|
int GetTotemCategory(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->TotemCategory.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->TotemCategory[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
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)
|
|
{
|
|
ALE::Push(L, entry->AreaGroupId);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the school mask of [SpellEntry].
|
|
*
|
|
* @return uint32 schoolMask : bitmask, returned as uint32.
|
|
*/
|
|
int GetSchoolMask(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->SchoolMask);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the rune cost id for the [SpellEntry].
|
|
*
|
|
* @return uint32 runeCostId
|
|
*/
|
|
int GetRuneCostID(lua_State* L, SpellEntry* entry)
|
|
{
|
|
ALE::Push(L, entry->RuneCostID);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Returns a table with all effect bonus multiplier values [SpellEntry].
|
|
*
|
|
* @return table effectBonusMultipliers
|
|
*/
|
|
int GetEffectBonusMultiplier(lua_State* L, SpellEntry* entry)
|
|
{
|
|
lua_newtable(L);
|
|
int tbl = lua_gettop(L);
|
|
uint32 i = 0;
|
|
|
|
for (size_t index = 0; index < entry->EffectBonusMultiplier.size(); ++index)
|
|
{
|
|
ALE::Push(L, entry->EffectBonusMultiplier[index]);
|
|
lua_rawseti(L, tbl, ++i);
|
|
}
|
|
|
|
lua_settop(L, tbl); // push table to top of stack
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Sets the category for the [SpellEntry].
|
|
*
|
|
* @param uint32 category : the new category value
|
|
*/
|
|
int SetCategory(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 category = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->Category = category;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->CategoryEntry = category ? sSpellCategoryStore.LookupEntry(category) : nullptr;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the dispel type for the [SpellEntry].
|
|
*
|
|
* @param uint32 dispel : the new dispel type value
|
|
*/
|
|
int SetDispel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 dispel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->Dispel = dispel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->Dispel = dispel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the mechanic for the [SpellEntry].
|
|
*
|
|
* @param uint32 mechanic : the new mechanic value
|
|
*/
|
|
int SetMechanic(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 mechanic = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->Mechanic = mechanic;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->Mechanic = mechanic;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributes for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributes : the new attributes bitmask
|
|
*/
|
|
int SetAttributes(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributes = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->Attributes = attributes;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->Attributes = attributes;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx : the new attributesEx bitmask
|
|
*/
|
|
int SetAttributesEx(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx = attributesEx;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx = attributesEx;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx2 for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx2 : the new attributesEx2 bitmask
|
|
*/
|
|
int SetAttributesEx2(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx2 = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx2 = attributesEx2;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx2 = attributesEx2;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx3 for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx3 : the new attributesEx3 bitmask
|
|
*/
|
|
int SetAttributesEx3(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx3 = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx3 = attributesEx3;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx3 = attributesEx3;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx4 for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx4 : the new attributesEx4 bitmask
|
|
*/
|
|
int SetAttributesEx4(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx4 = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx4 = attributesEx4;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx4 = attributesEx4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx5 for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx5 : the new attributesEx5 bitmask
|
|
*/
|
|
int SetAttributesEx5(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx5 = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx5 = attributesEx5;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx5 = attributesEx5;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx6 for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx6 : the new attributesEx6 bitmask
|
|
*/
|
|
int SetAttributesEx6(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx6 = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx6 = attributesEx6;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx6 = attributesEx6;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the attributesEx7 for the [SpellEntry].
|
|
*
|
|
* @param uint32 attributesEx7 : the new attributesEx7 bitmask
|
|
*/
|
|
int SetAttributesEx7(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 attributesEx7 = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AttributesEx7 = attributesEx7;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AttributesEx7 = attributesEx7;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the stances for the [SpellEntry].
|
|
*
|
|
* @param uint32 stances : the new stances bitmask
|
|
*/
|
|
int SetStances(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 stances = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->Stances = stances;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->Stances = stances;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the stancesNot for the [SpellEntry].
|
|
*
|
|
* @param uint32 stancesNot : the new stancesNot bitmask
|
|
*/
|
|
int SetStancesNot(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 stancesNot = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->StancesNot = stancesNot;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->StancesNot = stancesNot;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the targets for the [SpellEntry].
|
|
*
|
|
* @param uint32 targets : the new targets bitmask
|
|
*/
|
|
int SetTargets(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 targets = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->Targets = targets;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->Targets = targets;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the target creature type for the [SpellEntry].
|
|
*
|
|
* @param uint32 targetCreatureType : the new target creature type bitmask
|
|
*/
|
|
int SetTargetCreatureType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 targetCreatureType = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->TargetCreatureType = targetCreatureType;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->TargetCreatureType = targetCreatureType;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the requires spell focus for the [SpellEntry].
|
|
*
|
|
* @param uint32 requiresSpellFocus : the new requires spell focus value
|
|
*/
|
|
int SetRequiresSpellFocus(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 requiresSpellFocus = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->RequiresSpellFocus = requiresSpellFocus;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->RequiresSpellFocus = requiresSpellFocus;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the facing caster flags for the [SpellEntry].
|
|
*
|
|
* @param uint32 facingCasterFlags : the new facing caster flags value
|
|
*/
|
|
int SetFacingCasterFlags(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 facingCasterFlags = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->FacingCasterFlags = facingCasterFlags;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->FacingCasterFlags = facingCasterFlags;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the caster aura state for the [SpellEntry].
|
|
*
|
|
* @param uint32 casterAuraState : the new caster aura state value
|
|
*/
|
|
int SetCasterAuraState(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 casterAuraState = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->CasterAuraState = casterAuraState;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->CasterAuraState = casterAuraState;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the target aura state for the [SpellEntry].
|
|
*
|
|
* @param uint32 targetAuraState : the new target aura state value
|
|
*/
|
|
int SetTargetAuraState(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 targetAuraState = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->TargetAuraState = targetAuraState;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->TargetAuraState = targetAuraState;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the caster aura state not for the [SpellEntry].
|
|
*
|
|
* @param uint32 casterAuraStateNot : the new caster aura state not value
|
|
*/
|
|
int SetCasterAuraStateNot(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 casterAuraStateNot = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->CasterAuraStateNot = casterAuraStateNot;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->CasterAuraStateNot = casterAuraStateNot;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the target aura state not for the [SpellEntry].
|
|
*
|
|
* @param uint32 targetAuraStateNot : the new target aura state not value
|
|
*/
|
|
int SetTargetAuraStateNot(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 targetAuraStateNot = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->TargetAuraStateNot = targetAuraStateNot;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->TargetAuraStateNot = targetAuraStateNot;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the caster aura spell for the [SpellEntry].
|
|
*
|
|
* @param uint32 casterAuraSpell : the new caster aura spell ID
|
|
*/
|
|
int SetCasterAuraSpell(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 casterAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->CasterAuraSpell = casterAuraSpell;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->CasterAuraSpell = casterAuraSpell;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the target aura spell for the [SpellEntry].
|
|
*
|
|
* @param uint32 targetAuraSpell : the new target aura spell ID
|
|
*/
|
|
int SetTargetAuraSpell(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 targetAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->TargetAuraSpell = targetAuraSpell;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->TargetAuraSpell = targetAuraSpell;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the exclude caster aura spell for the [SpellEntry].
|
|
*
|
|
* @param uint32 excludeCasterAuraSpell : the new exclude caster aura spell ID
|
|
*/
|
|
int SetExcludeCasterAuraSpell(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 excludeCasterAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ExcludeCasterAuraSpell = excludeCasterAuraSpell;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ExcludeCasterAuraSpell = excludeCasterAuraSpell;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the exclude target aura spell for the [SpellEntry].
|
|
*
|
|
* @param uint32 excludeTargetAuraSpell : the new exclude target aura spell ID
|
|
*/
|
|
int SetExcludeTargetAuraSpell(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 excludeTargetAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ExcludeTargetAuraSpell = excludeTargetAuraSpell;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ExcludeTargetAuraSpell = excludeTargetAuraSpell;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the recovery time for the [SpellEntry].
|
|
*
|
|
* @param uint32 recoveryTime : the new recovery time value
|
|
*/
|
|
int SetRecoveryTime(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 recoveryTime = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->RecoveryTime = recoveryTime;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->RecoveryTime = recoveryTime;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the category recovery time for the [SpellEntry].
|
|
*
|
|
* @param uint32 categoryRecoveryTime : the new category recovery time value in milliseconds
|
|
*/
|
|
int SetCategoryRecoveryTime(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 categoryRecoveryTime = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->CategoryRecoveryTime = categoryRecoveryTime;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->CategoryRecoveryTime = categoryRecoveryTime;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the interrupt flags for the [SpellEntry].
|
|
*
|
|
* @param uint32 interruptFlags : the new interrupt flags bitmask
|
|
*/
|
|
int SetInterruptFlags(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 interruptFlags = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->InterruptFlags = interruptFlags;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->InterruptFlags = interruptFlags;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the aura interrupt flags for the [SpellEntry].
|
|
*
|
|
* @param uint32 auraInterruptFlags : the new aura interrupt flags bitmask
|
|
*/
|
|
int SetAuraInterruptFlags(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 auraInterruptFlags = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->AuraInterruptFlags = auraInterruptFlags;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->AuraInterruptFlags = auraInterruptFlags;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the channel interrupt flags for the [SpellEntry].
|
|
*
|
|
* @param uint32 channelInterruptFlags : the new channel interrupt flags bitmask
|
|
*/
|
|
int SetChannelInterruptFlags(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 channelInterruptFlags = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ChannelInterruptFlags = channelInterruptFlags;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ChannelInterruptFlags = channelInterruptFlags;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the proc flags for the [SpellEntry].
|
|
*
|
|
* @param uint32 procFlags : the new proc flags bitmask
|
|
*/
|
|
int SetProcFlags(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 procFlags = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ProcFlags = procFlags;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ProcFlags = procFlags;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the proc chance for the [SpellEntry].
|
|
*
|
|
* @param uint32 procChance : the new proc chance value
|
|
*/
|
|
int SetProcChance(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 procChance = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ProcChance = procChance;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ProcChance = procChance;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the proc charges for the [SpellEntry].
|
|
*
|
|
* @param uint32 procCharges : the new proc charges value
|
|
*/
|
|
int SetProcCharges(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 procCharges = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ProcCharges = procCharges;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ProcCharges = procCharges;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the max level for the [SpellEntry].
|
|
*
|
|
* @param uint32 maxLevel : the new max level value
|
|
*/
|
|
int SetMaxLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 maxLevel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->MaxLevel = maxLevel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->MaxLevel = maxLevel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the base level for the [SpellEntry].
|
|
*
|
|
* @param uint32 baseLevel : the new base level value
|
|
*/
|
|
int SetBaseLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 baseLevel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->BaseLevel = baseLevel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->BaseLevel = baseLevel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the spell level for the [SpellEntry].
|
|
*
|
|
* @param uint32 spellLevel : the new spell level value
|
|
*/
|
|
int SetSpellLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 spellLevel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->SpellLevel = spellLevel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->SpellLevel = spellLevel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the mana cost for the [SpellEntry].
|
|
*
|
|
* @param uint32 manaCost : the new mana cost value
|
|
*/
|
|
int SetManaCost(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 manaCost = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ManaCost = manaCost;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ManaCost = manaCost;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the power type for the [SpellEntry].
|
|
*
|
|
* @param uint32 powerType : the new power type ID
|
|
*/
|
|
int SetPowerType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 powerType = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->PowerType = powerType;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->PowerType = powerType;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the mana cost per level for the [SpellEntry].
|
|
*
|
|
* @param uint32 manaCostPerlevel : the new mana cost per level value
|
|
*/
|
|
int SetManaCostPerlevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 manaCostPerlevel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ManaCostPerlevel = manaCostPerlevel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ManaCostPerlevel = manaCostPerlevel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the mana per second for the [SpellEntry].
|
|
*
|
|
* @param uint32 manaPerSecond : the new mana per second value
|
|
*/
|
|
int SetManaPerSecond(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 manaPerSecond = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ManaPerSecond = manaPerSecond;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ManaPerSecond = manaPerSecond;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the mana per second per level for the [SpellEntry].
|
|
*
|
|
* @param uint32 manaPerSecondPerLevel : the new mana per second per level value
|
|
*/
|
|
int SetManaPerSecondPerLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 manaPerSecondPerLevel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ManaPerSecondPerLevel = manaPerSecondPerLevel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ManaPerSecondPerLevel = manaPerSecondPerLevel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the speed for the [SpellEntry].
|
|
*
|
|
* @param float speed : the new speed value
|
|
*/
|
|
int SetSpeed(lua_State* L, SpellEntry* entry)
|
|
{
|
|
float speed = ALE::CHECKVAL<float>(L, 2);
|
|
entry->Speed = speed;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->Speed = speed;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the stack amount for the [SpellEntry].
|
|
*
|
|
* @param uint32 stackAmount : the new stack amount value
|
|
*/
|
|
int SetStackAmount(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 stackAmount = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->StackAmount = stackAmount;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->StackAmount = stackAmount;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the equipped item class for the [SpellEntry].
|
|
*
|
|
* @param int32 equippedItemClass : the new equipped item class value
|
|
*/
|
|
int SetEquippedItemClass(lua_State* L, SpellEntry* entry)
|
|
{
|
|
int32 equippedItemClass = ALE::CHECKVAL<int32>(L, 2);
|
|
entry->EquippedItemClass = equippedItemClass;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->EquippedItemClass = equippedItemClass;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the equipped item sub class mask for the [SpellEntry].
|
|
*
|
|
* @param int32 equippedItemSubClassMask : the new equipped item sub class mask bitmasks
|
|
*/
|
|
int SetEquippedItemSubClassMask(lua_State* L, SpellEntry* entry)
|
|
{
|
|
int32 equippedItemSubClassMask = ALE::CHECKVAL<int32>(L, 2);
|
|
entry->EquippedItemSubClassMask = equippedItemSubClassMask;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->EquippedItemSubClassMask = equippedItemSubClassMask;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the equipped item inventory type mask for the [SpellEntry].
|
|
*
|
|
* @param int32 equippedItemInventoryTypeMask : the new equipped item inventory type mask bitmasks
|
|
*/
|
|
int SetEquippedItemInventoryTypeMask(lua_State* L, SpellEntry* entry)
|
|
{
|
|
int32 equippedItemInventoryTypeMask = ALE::CHECKVAL<int32>(L, 2);
|
|
entry->EquippedItemInventoryTypeMask = equippedItemInventoryTypeMask;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->EquippedItemInventoryTypeMask = equippedItemInventoryTypeMask;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the spell icon ID for the [SpellEntry].
|
|
*
|
|
* @param uint32 spellIconID : the new spell icon ID value
|
|
*/
|
|
int SetSpellIconID(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 spellIconID = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->SpellIconID = spellIconID;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->SpellIconID = spellIconID;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the active icon ID for the [SpellEntry].
|
|
*
|
|
* @param uint32 activeIconID : the new active icon ID value
|
|
*/
|
|
int SetActiveIconID(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 activeIconID = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ActiveIconID = activeIconID;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ActiveIconID = activeIconID;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the spell priority for the [SpellEntry].
|
|
*
|
|
* @param uint32 spellPriority : the new spell priority value
|
|
*/
|
|
int SetSpellPriority(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 spellPriority = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->SpellPriority = spellPriority;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->SpellPriority = spellPriority;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the mana cost percentage for the [SpellEntry].
|
|
*
|
|
* @param uint32 manaCostPercentage : the new mana cost percentage value
|
|
*/
|
|
int SetManaCostPercentage(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 manaCostPercentage = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->ManaCostPercentage = manaCostPercentage;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->ManaCostPercentage = manaCostPercentage;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the start recovery category for the [SpellEntry].
|
|
*
|
|
* @param uint32 startRecoveryCategory : the new start recovery category value
|
|
*/
|
|
int SetStartRecoveryCategory(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 startRecoveryCategory = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->StartRecoveryCategory = startRecoveryCategory;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->StartRecoveryCategory = startRecoveryCategory;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the start recovery time for the [SpellEntry].
|
|
*
|
|
* @param uint32 startRecoveryTime : the new start recovery time value
|
|
*/
|
|
int SetStartRecoveryTime(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 startRecoveryTime = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->StartRecoveryTime = startRecoveryTime;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->StartRecoveryTime = startRecoveryTime;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the max target level for the [SpellEntry].
|
|
*
|
|
* @param uint32 maxTargetLevel : the new max target level value
|
|
*/
|
|
int SetMaxTargetLevel(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 maxTargetLevel = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->MaxTargetLevel = maxTargetLevel;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->MaxTargetLevel = maxTargetLevel;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the spell family name for the [SpellEntry].
|
|
*
|
|
* @param uint32 spellFamilyName : the new spell family name value
|
|
*/
|
|
int SetSpellFamilyName(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 spellFamilyName = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->SpellFamilyName = spellFamilyName;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->SpellFamilyName = spellFamilyName;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the max affected targets for the [SpellEntry].
|
|
*
|
|
* @param uint32 maxAffectedTargets : the new max affected targets value
|
|
*/
|
|
int SetMaxAffectedTargets(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 maxAffectedTargets = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->MaxAffectedTargets = maxAffectedTargets;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->MaxAffectedTargets = maxAffectedTargets;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the damage class for the [SpellEntry].
|
|
*
|
|
* @param uint32 dmgClass : the new damage class ID value
|
|
*/
|
|
int SetDmgClass(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 dmgClass = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->DmgClass = dmgClass;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->DmgClass = dmgClass;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the prevention type for the [SpellEntry].
|
|
*
|
|
* @param uint32 preventionType : the new prevention type ID value
|
|
*/
|
|
int SetPreventionType(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 preventionType = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->PreventionType = preventionType;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->PreventionType = preventionType;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the school mask for the [SpellEntry].
|
|
*
|
|
* @param uint32 schoolMask : the new school mask bitmask value
|
|
*/
|
|
int SetSchoolMask(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 schoolMask = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->SchoolMask = schoolMask;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->SchoolMask = schoolMask;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Sets the rune cost ID for the [SpellEntry].
|
|
*
|
|
* @param uint32 runeCostID : the new rune cost ID value
|
|
*/
|
|
int SetRuneCostID(lua_State* L, SpellEntry* entry)
|
|
{
|
|
uint32 runeCostID = ALE::CHECKVAL<uint32>(L, 2);
|
|
entry->RuneCostID = runeCostID;
|
|
|
|
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
|
|
{
|
|
const_cast<SpellInfo*>(spellInfo)->RuneCostID = runeCostID;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
#endif
|