1996 lines
94 KiB
C++
1996 lines
94 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
|
|
*/
|
|
|
|
extern "C"
|
|
{
|
|
#include "lua.h"
|
|
};
|
|
|
|
// ALE
|
|
#include "LuaEngine.h"
|
|
#include "ALEEventMgr.h"
|
|
#include "ALEIncludes.h"
|
|
#include "ALETemplate.h"
|
|
#include "ALEUtility.h"
|
|
|
|
// Method includes
|
|
#include "GlobalMethods.h"
|
|
#include "ObjectMethods.h"
|
|
#include "WorldObjectMethods.h"
|
|
#include "UnitMethods.h"
|
|
#include "PlayerMethods.h"
|
|
#include "CreatureMethods.h"
|
|
#include "GroupMethods.h"
|
|
#include "GuildMethods.h"
|
|
#include "GameObjectMethods.h"
|
|
#include "ALEQueryMethods.h"
|
|
#include "AuraMethods.h"
|
|
#include "ItemMethods.h"
|
|
#include "WorldPacketMethods.h"
|
|
#include "SpellMethods.h"
|
|
#include "QuestMethods.h"
|
|
#include "MapMethods.h"
|
|
#include "CorpseMethods.h"
|
|
#include "VehicleMethods.h"
|
|
#include "BattleGroundMethods.h"
|
|
#include "ChatHandlerMethods.h"
|
|
#include "AchievementMethods.h"
|
|
#include "ItemTemplateMethods.h"
|
|
#include "RollMethods.h"
|
|
#include "TicketMethods.h"
|
|
#include "SpellInfoMethods.h"
|
|
#include "PetMethods.h"
|
|
#include "LootMethods.h"
|
|
#include "TransportMethods.h"
|
|
|
|
// DBCStores includes
|
|
#include "GemPropertiesEntryMethods.h"
|
|
#include "SpellEntryMethods.h"
|
|
|
|
luaL_Reg GlobalMethods[] =
|
|
{
|
|
// Hooks
|
|
{ "RegisterPacketEvent", &LuaGlobalFunctions::RegisterPacketEvent },
|
|
{ "RegisterServerEvent", &LuaGlobalFunctions::RegisterServerEvent },
|
|
{ "RegisterPlayerEvent", &LuaGlobalFunctions::RegisterPlayerEvent },
|
|
{ "RegisterGuildEvent", &LuaGlobalFunctions::RegisterGuildEvent },
|
|
{ "RegisterGroupEvent", &LuaGlobalFunctions::RegisterGroupEvent },
|
|
{ "RegisterCreatureEvent", &LuaGlobalFunctions::RegisterCreatureEvent },
|
|
{ "RegisterUniqueCreatureEvent", &LuaGlobalFunctions::RegisterUniqueCreatureEvent },
|
|
{ "RegisterCreatureGossipEvent", &LuaGlobalFunctions::RegisterCreatureGossipEvent },
|
|
{ "RegisterGameObjectEvent", &LuaGlobalFunctions::RegisterGameObjectEvent },
|
|
{ "RegisterGameObjectGossipEvent", &LuaGlobalFunctions::RegisterGameObjectGossipEvent },
|
|
{ "RegisterItemEvent", &LuaGlobalFunctions::RegisterItemEvent },
|
|
{ "RegisterItemGossipEvent", &LuaGlobalFunctions::RegisterItemGossipEvent },
|
|
{ "RegisterPlayerGossipEvent", &LuaGlobalFunctions::RegisterPlayerGossipEvent },
|
|
{ "RegisterBGEvent", &LuaGlobalFunctions::RegisterBGEvent },
|
|
{ "RegisterMapEvent", &LuaGlobalFunctions::RegisterMapEvent },
|
|
{ "RegisterInstanceEvent", &LuaGlobalFunctions::RegisterInstanceEvent },
|
|
{ "RegisterTicketEvent", &LuaGlobalFunctions::RegisterTicketEvent },
|
|
{ "RegisterSpellEvent", &LuaGlobalFunctions::RegisterSpellEvent },
|
|
{ "RegisterAllCreatureEvent", &LuaGlobalFunctions::RegisterAllCreatureEvent },
|
|
|
|
|
|
{ "ClearBattleGroundEvents", &LuaGlobalFunctions::ClearBattleGroundEvents },
|
|
{ "ClearCreatureEvents", &LuaGlobalFunctions::ClearCreatureEvents },
|
|
{ "ClearUniqueCreatureEvents", &LuaGlobalFunctions::ClearUniqueCreatureEvents },
|
|
{ "ClearCreatureGossipEvents", &LuaGlobalFunctions::ClearCreatureGossipEvents },
|
|
{ "ClearGameObjectEvents", &LuaGlobalFunctions::ClearGameObjectEvents },
|
|
{ "ClearGameObjectGossipEvents", &LuaGlobalFunctions::ClearGameObjectGossipEvents },
|
|
{ "ClearGroupEvents", &LuaGlobalFunctions::ClearGroupEvents },
|
|
{ "ClearGuildEvents", &LuaGlobalFunctions::ClearGuildEvents },
|
|
{ "ClearItemEvents", &LuaGlobalFunctions::ClearItemEvents },
|
|
{ "ClearItemGossipEvents", &LuaGlobalFunctions::ClearItemGossipEvents },
|
|
{ "ClearPacketEvents", &LuaGlobalFunctions::ClearPacketEvents },
|
|
{ "ClearPlayerEvents", &LuaGlobalFunctions::ClearPlayerEvents },
|
|
{ "ClearPlayerGossipEvents", &LuaGlobalFunctions::ClearPlayerGossipEvents },
|
|
{ "ClearServerEvents", &LuaGlobalFunctions::ClearServerEvents },
|
|
{ "ClearMapEvents", &LuaGlobalFunctions::ClearMapEvents },
|
|
{ "ClearInstanceEvents", &LuaGlobalFunctions::ClearInstanceEvents },
|
|
{ "ClearTicketEvents", &LuaGlobalFunctions::ClearTicketEvents },
|
|
{ "ClearSpellEvents", &LuaGlobalFunctions::ClearSpellEvents },
|
|
{ "ClearAllCreatureEvents", &LuaGlobalFunctions::ClearAllCreatureEvents },
|
|
|
|
// Getters
|
|
{ "GetLuaEngine", &LuaGlobalFunctions::GetLuaEngine },
|
|
{ "GetCoreName", &LuaGlobalFunctions::GetCoreName },
|
|
{ "GetConfigValue", &LuaGlobalFunctions::GetConfigValue },
|
|
{ "GetRealmID", &LuaGlobalFunctions::GetRealmID },
|
|
{ "GetCoreVersion", &LuaGlobalFunctions::GetCoreVersion },
|
|
{ "GetCoreExpansion", &LuaGlobalFunctions::GetCoreExpansion },
|
|
{ "GetStateMap", &LuaGlobalFunctions::GetStateMap },
|
|
{ "GetStateMapId", &LuaGlobalFunctions::GetStateMapId },
|
|
{ "GetStateInstanceId", &LuaGlobalFunctions::GetStateInstanceId },
|
|
{ "GetQuest", &LuaGlobalFunctions::GetQuest },
|
|
{ "GetPlayerByGUID", &LuaGlobalFunctions::GetPlayerByGUID },
|
|
{ "GetPlayerByName", &LuaGlobalFunctions::GetPlayerByName },
|
|
{ "GetGameTime", &LuaGlobalFunctions::GetGameTime },
|
|
{ "GetPlayersInWorld", &LuaGlobalFunctions::GetPlayersInWorld },
|
|
{ "GetGuildByName", &LuaGlobalFunctions::GetGuildByName },
|
|
{ "GetGuildByLeaderGUID", &LuaGlobalFunctions::GetGuildByLeaderGUID },
|
|
{ "GetPlayerCount", &LuaGlobalFunctions::GetPlayerCount },
|
|
{ "GetPlayerGUID", &LuaGlobalFunctions::GetPlayerGUID },
|
|
{ "GetItemGUID", &LuaGlobalFunctions::GetItemGUID },
|
|
{ "GetItemTemplate", &LuaGlobalFunctions::GetItemTemplate },
|
|
{ "GetObjectGUID", &LuaGlobalFunctions::GetObjectGUID },
|
|
{ "GetUnitGUID", &LuaGlobalFunctions::GetUnitGUID },
|
|
{ "GetGUIDLow", &LuaGlobalFunctions::GetGUIDLow },
|
|
{ "GetGUIDType", &LuaGlobalFunctions::GetGUIDType },
|
|
{ "GetGUIDEntry", &LuaGlobalFunctions::GetGUIDEntry },
|
|
{ "GetPackedGUIDSize", &LuaGlobalFunctions::GetPackedGUIDSize },
|
|
{ "GetAreaName", &LuaGlobalFunctions::GetAreaName },
|
|
{ "GetOwnerHalaa", &LuaGlobalFunctions::GetOwnerHalaa },
|
|
{ "bit_not", &LuaGlobalFunctions::bit_not },
|
|
{ "bit_xor", &LuaGlobalFunctions::bit_xor },
|
|
{ "bit_rshift", &LuaGlobalFunctions::bit_rshift },
|
|
{ "bit_lshift", &LuaGlobalFunctions::bit_lshift },
|
|
{ "bit_or", &LuaGlobalFunctions::bit_or },
|
|
{ "bit_and", &LuaGlobalFunctions::bit_and },
|
|
{ "GetItemLink", &LuaGlobalFunctions::GetItemLink },
|
|
{ "GetMapById", &LuaGlobalFunctions::GetMapById },
|
|
{ "GetCurrTime", &LuaGlobalFunctions::GetCurrTime },
|
|
{ "GetTimeDiff", &LuaGlobalFunctions::GetTimeDiff },
|
|
{ "PrintInfo", &LuaGlobalFunctions::PrintInfo },
|
|
{ "PrintError", &LuaGlobalFunctions::PrintError },
|
|
{ "PrintDebug", &LuaGlobalFunctions::PrintDebug },
|
|
{ "GetActiveGameEvents", &LuaGlobalFunctions::GetActiveGameEvents },
|
|
{ "GetGossipMenuOptionLocale", &LuaGlobalFunctions::GetGossipMenuOptionLocale },
|
|
{ "GetMapEntrance", &LuaGlobalFunctions::GetMapEntrance },
|
|
{ "GetSpellInfo", &LuaGlobalFunctions::GetSpellInfo },
|
|
|
|
// Boolean
|
|
{ "IsCompatibilityMode", &LuaGlobalFunctions::IsCompatibilityMode },
|
|
{ "IsInventoryPos", &LuaGlobalFunctions::IsInventoryPos },
|
|
{ "IsEquipmentPos", &LuaGlobalFunctions::IsEquipmentPos },
|
|
{ "IsBankPos", &LuaGlobalFunctions::IsBankPos },
|
|
{ "IsBagPos", &LuaGlobalFunctions::IsBagPos },
|
|
{ "IsGameEventActive", &LuaGlobalFunctions::IsGameEventActive },
|
|
|
|
// Other
|
|
{ "ReloadALE", &LuaGlobalFunctions::ReloadALE },
|
|
{ "RunCommand", &LuaGlobalFunctions::RunCommand },
|
|
{ "SendWorldMessage", &LuaGlobalFunctions::SendWorldMessage },
|
|
{ "WorldDBQuery", &LuaGlobalFunctions::WorldDBQuery },
|
|
{ "WorldDBQueryAsync", &LuaGlobalFunctions::WorldDBQueryAsync },
|
|
{ "WorldDBExecute", &LuaGlobalFunctions::WorldDBExecute },
|
|
{ "CharDBQuery", &LuaGlobalFunctions::CharDBQuery },
|
|
{ "CharDBQueryAsync", &LuaGlobalFunctions::CharDBQueryAsync },
|
|
{ "CharDBExecute", &LuaGlobalFunctions::CharDBExecute },
|
|
{ "AuthDBQuery", &LuaGlobalFunctions::AuthDBQuery },
|
|
{ "AuthDBQueryAsync", &LuaGlobalFunctions::AuthDBQueryAsync },
|
|
{ "AuthDBExecute", &LuaGlobalFunctions::AuthDBExecute },
|
|
{ "CreateLuaEvent", &LuaGlobalFunctions::CreateLuaEvent },
|
|
{ "RemoveEventById", &LuaGlobalFunctions::RemoveEventById },
|
|
{ "RemoveEvents", &LuaGlobalFunctions::RemoveEvents },
|
|
{ "PerformIngameSpawn", &LuaGlobalFunctions::PerformIngameSpawn },
|
|
{ "CreatePacket", &LuaGlobalFunctions::CreatePacket },
|
|
{ "AddVendorItem", &LuaGlobalFunctions::AddVendorItem },
|
|
{ "VendorRemoveItem", &LuaGlobalFunctions::VendorRemoveItem },
|
|
{ "VendorRemoveAllItems", &LuaGlobalFunctions::VendorRemoveAllItems },
|
|
{ "Kick", &LuaGlobalFunctions::Kick },
|
|
{ "Ban", &LuaGlobalFunctions::Ban },
|
|
{ "SaveAllPlayers", &LuaGlobalFunctions::SaveAllPlayers },
|
|
{ "SendMail", &LuaGlobalFunctions::SendMail },
|
|
{ "AddTaxiPath", &LuaGlobalFunctions::AddTaxiPath },
|
|
{ "CreateInt64", &LuaGlobalFunctions::CreateLongLong },
|
|
{ "CreateUint64", &LuaGlobalFunctions::CreateULongLong },
|
|
{ "StartGameEvent", &LuaGlobalFunctions::StartGameEvent },
|
|
{ "StopGameEvent", &LuaGlobalFunctions::StopGameEvent },
|
|
{ "HttpRequest", &LuaGlobalFunctions::HttpRequest },
|
|
{ "SetOwnerHalaa", &LuaGlobalFunctions::SetOwnerHalaa },
|
|
{ "LookupEntry", &LuaGlobalFunctions::LookupEntry },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Object> ObjectMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetEntry", &LuaObject::GetEntry },
|
|
{ "GetGUID", &LuaObject::GetGUID },
|
|
{ "GetGUIDLow", &LuaObject::GetGUIDLow },
|
|
{ "GetInt32Value", &LuaObject::GetInt32Value },
|
|
{ "GetUInt32Value", &LuaObject::GetUInt32Value },
|
|
{ "GetFloatValue", &LuaObject::GetFloatValue },
|
|
{ "GetByteValue", &LuaObject::GetByteValue },
|
|
{ "GetUInt16Value", &LuaObject::GetUInt16Value },
|
|
{ "GetUInt64Value", &LuaObject::GetUInt64Value },
|
|
{ "GetScale", &LuaObject::GetScale },
|
|
{ "GetTypeId", &LuaObject::GetTypeId },
|
|
|
|
// Setters
|
|
{ "SetInt32Value", &LuaObject::SetInt32Value },
|
|
{ "SetUInt32Value", &LuaObject::SetUInt32Value },
|
|
{ "UpdateUInt32Value", &LuaObject::UpdateUInt32Value },
|
|
{ "SetFloatValue", &LuaObject::SetFloatValue },
|
|
{ "SetByteValue", &LuaObject::SetByteValue },
|
|
{ "SetUInt16Value", &LuaObject::SetUInt16Value },
|
|
{ "SetInt16Value", &LuaObject::SetInt16Value },
|
|
{ "SetUInt64Value", &LuaObject::SetUInt64Value },
|
|
{ "SetScale", &LuaObject::SetScale },
|
|
{ "SetFlag", &LuaObject::SetFlag },
|
|
|
|
// Boolean
|
|
{ "IsInWorld", &LuaObject::IsInWorld },
|
|
{ "IsPlayer", &LuaObject::IsPlayer },
|
|
{ "HasFlag", &LuaObject::HasFlag },
|
|
|
|
// Other
|
|
{ "ToGameObject", &LuaObject::ToGameObject },
|
|
{ "ToUnit", &LuaObject::ToUnit },
|
|
{ "ToCreature", &LuaObject::ToCreature },
|
|
{ "ToPlayer", &LuaObject::ToPlayer },
|
|
{ "ToCorpse", &LuaObject::ToCorpse },
|
|
{ "RemoveFlag", &LuaObject::RemoveFlag },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<WorldObject> WorldObjectMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetName", &LuaWorldObject::GetName },
|
|
{ "GetMap", &LuaWorldObject::GetMap },
|
|
{ "GetPhaseMask", &LuaWorldObject::GetPhaseMask },
|
|
{ "SetPhaseMask", &LuaWorldObject::SetPhaseMask },
|
|
{ "GetInstanceId", &LuaWorldObject::GetInstanceId },
|
|
{ "GetAreaId", &LuaWorldObject::GetAreaId },
|
|
{ "GetZoneId", &LuaWorldObject::GetZoneId },
|
|
{ "GetMapId", &LuaWorldObject::GetMapId },
|
|
{ "GetX", &LuaWorldObject::GetX },
|
|
{ "GetY", &LuaWorldObject::GetY },
|
|
{ "GetZ", &LuaWorldObject::GetZ },
|
|
{ "GetO", &LuaWorldObject::GetO },
|
|
{ "GetLocation", &LuaWorldObject::GetLocation },
|
|
{ "GetPlayersInRange", &LuaWorldObject::GetPlayersInRange },
|
|
{ "GetCreaturesInRange", &LuaWorldObject::GetCreaturesInRange },
|
|
{ "GetGameObjectsInRange", &LuaWorldObject::GetGameObjectsInRange },
|
|
{ "GetNearestPlayer", &LuaWorldObject::GetNearestPlayer },
|
|
{ "GetNearestGameObject", &LuaWorldObject::GetNearestGameObject },
|
|
{ "GetNearestCreature", &LuaWorldObject::GetNearestCreature },
|
|
{ "GetNearObject", &LuaWorldObject::GetNearObject },
|
|
{ "GetNearObjects", &LuaWorldObject::GetNearObjects },
|
|
{ "GetDistance", &LuaWorldObject::GetDistance },
|
|
{ "GetExactDistance", &LuaWorldObject::GetExactDistance },
|
|
{ "GetDistance2d", &LuaWorldObject::GetDistance2d },
|
|
{ "GetExactDistance2d", &LuaWorldObject::GetExactDistance2d },
|
|
{ "GetRelativePoint", &LuaWorldObject::GetRelativePoint },
|
|
{ "GetAngle", &LuaWorldObject::GetAngle },
|
|
{ "GetTransport", &LuaWorldObject::GetTransport },
|
|
|
|
// Boolean
|
|
{ "IsWithinLoS", &LuaWorldObject::IsWithinLoS },
|
|
{ "IsInMap", &LuaWorldObject::IsInMap },
|
|
{ "IsWithinDist3d", &LuaWorldObject::IsWithinDist3d },
|
|
{ "IsWithinDist2d", &LuaWorldObject::IsWithinDist2d },
|
|
{ "IsWithinDist", &LuaWorldObject::IsWithinDist },
|
|
{ "IsWithinDistInMap", &LuaWorldObject::IsWithinDistInMap },
|
|
{ "IsInRange", &LuaWorldObject::IsInRange },
|
|
{ "IsInRange2d", &LuaWorldObject::IsInRange2d },
|
|
{ "IsInRange3d", &LuaWorldObject::IsInRange3d },
|
|
{ "IsInFront", &LuaWorldObject::IsInFront },
|
|
{ "IsInBack", &LuaWorldObject::IsInBack },
|
|
|
|
// Other
|
|
{ "SummonGameObject", &LuaWorldObject::SummonGameObject },
|
|
{ "SpawnCreature", &LuaWorldObject::SpawnCreature },
|
|
{ "SendPacket", &LuaWorldObject::SendPacket },
|
|
{ "RegisterEvent", &LuaWorldObject::RegisterEvent },
|
|
{ "RemoveEventById", &LuaWorldObject::RemoveEventById },
|
|
{ "RemoveEvents", &LuaWorldObject::RemoveEvents },
|
|
{ "PlayMusic", &LuaWorldObject::PlayMusic },
|
|
{ "PlayDirectSound", &LuaWorldObject::PlayDirectSound },
|
|
{ "PlayDistanceSound", &LuaWorldObject::PlayDistanceSound },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Unit> UnitMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetLevel", &LuaUnit::GetLevel },
|
|
{ "GetHealth", &LuaUnit::GetHealth },
|
|
{ "GetDisplayId", &LuaUnit::GetDisplayId },
|
|
{ "GetNativeDisplayId", &LuaUnit::GetNativeDisplayId },
|
|
{ "GetPower", &LuaUnit::GetPower },
|
|
{ "GetMaxPower", &LuaUnit::GetMaxPower },
|
|
{ "GetPowerType", &LuaUnit::GetPowerType },
|
|
{ "GetMaxHealth", &LuaUnit::GetMaxHealth },
|
|
{ "GetHealthPct", &LuaUnit::GetHealthPct },
|
|
{ "GetPowerPct", &LuaUnit::GetPowerPct },
|
|
{ "GetGender", &LuaUnit::GetGender },
|
|
{ "GetRace", &LuaUnit::GetRace },
|
|
{ "GetClass", &LuaUnit::GetClass },
|
|
{ "GetRaceMask", &LuaUnit::GetRaceMask },
|
|
{ "GetClassMask", &LuaUnit::GetClassMask },
|
|
{ "GetRaceAsString", &LuaUnit::GetRaceAsString },
|
|
{ "GetClassAsString", &LuaUnit::GetClassAsString },
|
|
{ "GetAura", &LuaUnit::GetAura },
|
|
{ "GetFaction", &LuaUnit::GetFaction },
|
|
{ "GetCurrentSpell", &LuaUnit::GetCurrentSpell },
|
|
{ "GetCreatureType", &LuaUnit::GetCreatureType },
|
|
{ "GetMountId", &LuaUnit::GetMountId },
|
|
{ "GetOwner", &LuaUnit::GetOwner },
|
|
{ "GetFriendlyUnitsInRange", &LuaUnit::GetFriendlyUnitsInRange },
|
|
{ "GetUnfriendlyUnitsInRange", &LuaUnit::GetUnfriendlyUnitsInRange },
|
|
{ "GetOwnerGUID", &LuaUnit::GetOwnerGUID },
|
|
{ "GetCreatorGUID", &LuaUnit::GetCreatorGUID },
|
|
{ "GetMinionGUID", &LuaUnit::GetPetGUID },
|
|
{ "GetCharmerGUID", &LuaUnit::GetCharmerGUID },
|
|
{ "GetCharmGUID", &LuaUnit::GetCharmGUID },
|
|
{ "GetPetGUID", &LuaUnit::GetPetGUID },
|
|
{ "GetCritterGUID", &LuaUnit::GetCritterGUID },
|
|
{ "GetControllerGUID", &LuaUnit::GetControllerGUID },
|
|
{ "GetControllerGUIDS", &LuaUnit::GetControllerGUIDS },
|
|
{ "GetStandState", &LuaUnit::GetStandState },
|
|
{ "GetVictim", &LuaUnit::GetVictim },
|
|
{ "GetSpeed", &LuaUnit::GetSpeed },
|
|
{ "GetSpeedRate", &LuaUnit::GetSpeedRate },
|
|
{ "GetStat", &LuaUnit::GetStat },
|
|
{ "GetBaseSpellPower", &LuaUnit::GetBaseSpellPower },
|
|
{ "GetVehicleKit", &LuaUnit::GetVehicleKit },
|
|
// {"GetVehicle", &LuaUnit::GetVehicle}, // :GetVehicle() - UNDOCUMENTED - Gets the Vehicle kit of the vehicle the unit is on
|
|
{ "GetMovementType", &LuaUnit::GetMovementType },
|
|
{ "GetAttackers", &LuaUnit::GetAttackers },
|
|
{ "GetThreat", &LuaUnit::GetThreat },
|
|
|
|
// Setters
|
|
{ "SetFaction", &LuaUnit::SetFaction },
|
|
{ "SetLevel", &LuaUnit::SetLevel },
|
|
{ "SetHealth", &LuaUnit::SetHealth },
|
|
{ "SetMaxHealth", &LuaUnit::SetMaxHealth },
|
|
{ "SetPower", &LuaUnit::SetPower },
|
|
{ "SetMaxPower", &LuaUnit::SetMaxPower },
|
|
{ "SetPowerType", &LuaUnit::SetPowerType },
|
|
{ "SetDisplayId", &LuaUnit::SetDisplayId },
|
|
{ "SetNativeDisplayId", &LuaUnit::SetNativeDisplayId },
|
|
{ "SetFacing", &LuaUnit::SetFacing },
|
|
{ "SetFacingToObject", &LuaUnit::SetFacingToObject },
|
|
{ "SetSpeed", &LuaUnit::SetSpeed },
|
|
{ "SetSpeedRate", &LuaUnit::SetSpeedRate },
|
|
// {"SetStunned", &LuaUnit::SetStunned}, // :SetStunned([enable]) - UNDOCUMENTED - Stuns or removes stun
|
|
{"SetRooted", &LuaUnit::SetRooted},
|
|
{"SetConfused", &LuaUnit::SetConfused},
|
|
{"SetFeared", &LuaUnit::SetFeared},
|
|
{ "SetPvP", &LuaUnit::SetPvP },
|
|
{ "SetFFA", &LuaUnit::SetFFA },
|
|
{ "SetSanctuary", &LuaUnit::SetSanctuary },
|
|
// {"SetCanFly", &LuaUnit::SetCanFly}, // :SetCanFly(apply) - UNDOCUMENTED
|
|
// {"SetVisible", &LuaUnit::SetVisible}, // :SetVisible(x) - UNDOCUMENTED
|
|
{ "SetOwnerGUID", &LuaUnit::SetOwnerGUID },
|
|
{ "SetName", &LuaUnit::SetName },
|
|
{ "SetSheath", &LuaUnit::SetSheath },
|
|
{ "SetCreatorGUID", &LuaUnit::SetCreatorGUID },
|
|
{ "SetMinionGUID", &LuaUnit::SetPetGUID },
|
|
{ "SetPetGUID", &LuaUnit::SetPetGUID },
|
|
{ "SetCritterGUID", &LuaUnit::SetCritterGUID },
|
|
{ "SetWaterWalk", &LuaUnit::SetWaterWalk },
|
|
{ "SetStandState", &LuaUnit::SetStandState },
|
|
{ "SetInCombatWith", &LuaUnit::SetInCombatWith },
|
|
{ "ModifyPower", &LuaUnit::ModifyPower },
|
|
{ "SetImmuneTo", &LuaUnit::SetImmuneTo },
|
|
|
|
// Boolean
|
|
{ "IsAlive", &LuaUnit::IsAlive },
|
|
{ "IsDead", &LuaUnit::IsDead },
|
|
{ "IsDying", &LuaUnit::IsDying },
|
|
{ "IsPvPFlagged", &LuaUnit::IsPvPFlagged },
|
|
{ "IsInCombat", &LuaUnit::IsInCombat },
|
|
{ "IsBanker", &LuaUnit::IsBanker },
|
|
{ "IsBattleMaster", &LuaUnit::IsBattleMaster },
|
|
{ "IsCharmed", &LuaUnit::IsCharmed },
|
|
{ "IsArmorer", &LuaUnit::IsArmorer },
|
|
{ "IsAttackingPlayer", &LuaUnit::IsAttackingPlayer },
|
|
{ "IsInWater", &LuaUnit::IsInWater },
|
|
{ "IsUnderWater", &LuaUnit::IsUnderWater },
|
|
{ "IsAuctioneer", &LuaUnit::IsAuctioneer },
|
|
{ "IsGuildMaster", &LuaUnit::IsGuildMaster },
|
|
{ "IsInnkeeper", &LuaUnit::IsInnkeeper },
|
|
{ "IsTrainer", &LuaUnit::IsTrainer },
|
|
{ "IsGossip", &LuaUnit::IsGossip },
|
|
{ "IsTaxi", &LuaUnit::IsTaxi },
|
|
{ "IsSpiritHealer", &LuaUnit::IsSpiritHealer },
|
|
{ "IsSpiritGuide", &LuaUnit::IsSpiritGuide },
|
|
{ "IsTabardDesigner", &LuaUnit::IsTabardDesigner },
|
|
{ "IsServiceProvider", &LuaUnit::IsServiceProvider },
|
|
{ "IsSpiritService", &LuaUnit::IsSpiritService },
|
|
{ "HealthBelowPct", &LuaUnit::HealthBelowPct },
|
|
{ "HealthAbovePct", &LuaUnit::HealthAbovePct },
|
|
{ "IsMounted", &LuaUnit::IsMounted },
|
|
{ "AttackStop", &LuaUnit::AttackStop },
|
|
{ "Attack", &LuaUnit::Attack },
|
|
// {"IsVisible", &LuaUnit::IsVisible}, // :IsVisible() - UNDOCUMENTED
|
|
// {"IsMoving", &LuaUnit::IsMoving}, // :IsMoving() - UNDOCUMENTED
|
|
// {"IsFlying", &LuaUnit::IsFlying}, // :IsFlying() - UNDOCUMENTED
|
|
{ "IsStopped", &LuaUnit::IsStopped },
|
|
{ "HasUnitState", &LuaUnit::HasUnitState },
|
|
{ "IsQuestGiver", &LuaUnit::IsQuestGiver },
|
|
{ "IsInAccessiblePlaceFor", &LuaUnit::IsInAccessiblePlaceFor },
|
|
{ "IsVendor", &LuaUnit::IsVendor },
|
|
{ "IsRooted", &LuaUnit::IsRooted },
|
|
{ "IsFullHealth", &LuaUnit::IsFullHealth },
|
|
{ "HasAura", &LuaUnit::HasAura },
|
|
{ "IsCasting", &LuaUnit::IsCasting },
|
|
{ "IsStandState", &LuaUnit::IsStandState },
|
|
{ "IsOnVehicle", &LuaUnit::IsOnVehicle },
|
|
|
|
// Other
|
|
{ "HandleStatFlatModifier", &LuaUnit::HandleStatFlatModifier },
|
|
{ "AddAura", &LuaUnit::AddAura },
|
|
{ "RemoveAura", &LuaUnit::RemoveAura },
|
|
{ "RemoveAllAuras", &LuaUnit::RemoveAllAuras },
|
|
{ "RemoveArenaAuras", &LuaUnit::RemoveArenaAuras },
|
|
{ "ClearInCombat", &LuaUnit::ClearInCombat },
|
|
{ "DeMorph", &LuaUnit::DeMorph },
|
|
{ "SendUnitWhisper", &LuaUnit::SendUnitWhisper },
|
|
{ "SendUnitEmote", &LuaUnit::SendUnitEmote },
|
|
{ "SendUnitSay", &LuaUnit::SendUnitSay },
|
|
{ "SendUnitYell", &LuaUnit::SendUnitYell },
|
|
{ "CastSpell", &LuaUnit::CastSpell },
|
|
{ "CastCustomSpell", &LuaUnit::CastCustomSpell },
|
|
{ "CastSpellAoF", &LuaUnit::CastSpellAoF },
|
|
{ "Kill", &LuaUnit::Kill },
|
|
{ "StopSpellCast", &LuaUnit::StopSpellCast },
|
|
{ "InterruptSpell", &LuaUnit::InterruptSpell },
|
|
{ "SendChatMessageToPlayer", &LuaUnit::SendChatMessageToPlayer },
|
|
{ "PerformEmote", &LuaUnit::PerformEmote },
|
|
{ "EmoteState", &LuaUnit::EmoteState },
|
|
{ "CountPctFromCurHealth", &LuaUnit::CountPctFromCurHealth },
|
|
{ "CountPctFromMaxHealth", &LuaUnit::CountPctFromMaxHealth },
|
|
{ "Dismount", &LuaUnit::Dismount },
|
|
{ "Mount", &LuaUnit::Mount },
|
|
// {"RestoreDisplayId", &LuaUnit::RestoreDisplayId}, // :RestoreDisplayId() - UNDOCUMENTED
|
|
// {"RestoreFaction", &LuaUnit::RestoreFaction}, // :RestoreFaction() - UNDOCUMENTED
|
|
// {"RemoveBindSightAuras", &LuaUnit::RemoveBindSightAuras}, // :RemoveBindSightAuras() - UNDOCUMENTED
|
|
// {"RemoveCharmAuras", &LuaUnit::RemoveCharmAuras}, // :RemoveCharmAuras() - UNDOCUMENTED
|
|
{ "ClearThreatList", &LuaUnit::ClearThreatList },
|
|
{ "GetThreatList", &LuaUnit::GetThreatList },
|
|
{ "ClearUnitState", &LuaUnit::ClearUnitState },
|
|
{ "AddUnitState", &LuaUnit::AddUnitState },
|
|
// {"DisableMelee", &LuaUnit::DisableMelee}, // :DisableMelee([disable]) - UNDOCUMENTED - if true, enables
|
|
// {"SummonGuardian", &LuaUnit::SummonGuardian}, // :SummonGuardian(entry, x, y, z, o[, duration]) - UNDOCUMENTED - summons a guardian to location. Scales with summoner, is friendly to him and guards him.
|
|
{ "NearTeleport", &LuaUnit::NearTeleport },
|
|
{ "MoveIdle", &LuaUnit::MoveIdle },
|
|
{ "MoveRandom", &LuaUnit::MoveRandom },
|
|
{ "MoveHome", &LuaUnit::MoveHome },
|
|
{ "MoveFollow", &LuaUnit::MoveFollow },
|
|
{ "MoveChase", &LuaUnit::MoveChase },
|
|
{ "MoveConfused", &LuaUnit::MoveConfused },
|
|
{ "MoveFleeing", &LuaUnit::MoveFleeing },
|
|
{ "MoveTo", &LuaUnit::MoveTo },
|
|
{ "MoveJump", &LuaUnit::MoveJump },
|
|
{ "MoveStop", &LuaUnit::MoveStop },
|
|
{ "MoveExpire", &LuaUnit::MoveExpire },
|
|
{ "MoveClear", &LuaUnit::MoveClear },
|
|
{ "DealDamage", &LuaUnit::DealDamage },
|
|
{ "DealHeal", &LuaUnit::DealHeal },
|
|
{ "AddThreat", &LuaUnit::AddThreat },
|
|
{ "ModifyThreatPct", &LuaUnit::ModifyThreatPct },
|
|
{ "ClearThreat", &LuaUnit::ClearThreat },
|
|
{ "ResetAllThreat", &LuaUnit::ResetAllThreat },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Player> PlayerMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetInventoryFreeSlots", &LuaPlayer::GetInventoryFreeSlots },
|
|
{ "GetBankFreeSlots", &LuaPlayer::GetBankFreeSlots },
|
|
{ "GetSelection", &LuaPlayer::GetSelection },
|
|
{ "GetGMRank", &LuaPlayer::GetGMRank },
|
|
{ "GetGuildId", &LuaPlayer::GetGuildId },
|
|
{ "GetCoinage", &LuaPlayer::GetCoinage },
|
|
{ "GetTeam", &LuaPlayer::GetTeam },
|
|
{ "GetItemCount", &LuaPlayer::GetItemCount },
|
|
{ "GetGroup", &LuaPlayer::GetGroup },
|
|
{ "GetGuild", &LuaPlayer::GetGuild },
|
|
{ "GetAccountId", &LuaPlayer::GetAccountId },
|
|
{ "GetAccountName", &LuaPlayer::GetAccountName },
|
|
{ "GetCompletedQuestsCount", &LuaPlayer::GetCompletedQuestsCount },
|
|
{ "GetArenaPoints", &LuaPlayer::GetArenaPoints },
|
|
{ "GetHonorPoints", &LuaPlayer::GetHonorPoints },
|
|
{ "GetTodayHonorPoints", &LuaPlayer::GetTodayHonorPoints },
|
|
{ "GetYesterdayHonorPoints", &LuaPlayer::GetYesterdayHonorPoints },
|
|
{ "GetLifetimeKills", &LuaPlayer::GetLifetimeKills },
|
|
{ "GetTodayKills", &LuaPlayer::GetTodayKills },
|
|
{ "GetYesterdayKills", &LuaPlayer::GetYesterdayKills },
|
|
{ "GetPlayerIP", &LuaPlayer::GetPlayerIP },
|
|
{ "GetLevelPlayedTime", &LuaPlayer::GetLevelPlayedTime },
|
|
{ "GetTotalPlayedTime", &LuaPlayer::GetTotalPlayedTime },
|
|
{ "GetItemByPos", &LuaPlayer::GetItemByPos },
|
|
{ "GetItemByEntry", &LuaPlayer::GetItemByEntry },
|
|
{ "GetItemByGUID", &LuaPlayer::GetItemByGUID },
|
|
{ "GetMailCount", &LuaPlayer::GetMailCount },
|
|
{ "GetMailItem", &LuaPlayer::GetMailItem },
|
|
{ "GetReputation", &LuaPlayer::GetReputation },
|
|
{ "GetEquippedItemBySlot", &LuaPlayer::GetEquippedItemBySlot },
|
|
{ "GetQuestLevel", &LuaPlayer::GetQuestLevel },
|
|
{ "GetChatTag", &LuaPlayer::GetChatTag },
|
|
{ "GetRestBonus", &LuaPlayer::GetRestBonus },
|
|
{ "GetPhaseMaskForSpawn", &LuaPlayer::GetPhaseMaskForSpawn },
|
|
{ "GetAchievementPoints", &LuaPlayer::GetAchievementPoints },
|
|
{ "GetCompletedAchievementsCount", &LuaPlayer::GetCompletedAchievementsCount },
|
|
{ "GetReqKillOrCastCurrentCount", &LuaPlayer::GetReqKillOrCastCurrentCount },
|
|
{ "GetQuestStatus", &LuaPlayer::GetQuestStatus },
|
|
{ "GetInGameTime", &LuaPlayer::GetInGameTime },
|
|
{ "GetComboPoints", &LuaPlayer::GetComboPoints },
|
|
{ "GetComboTarget", &LuaPlayer::GetComboTarget },
|
|
{ "GetGuildName", &LuaPlayer::GetGuildName },
|
|
{ "GetFreeTalentPoints", &LuaPlayer::GetFreeTalentPoints },
|
|
{ "GetActiveSpec", &LuaPlayer::GetActiveSpec },
|
|
{ "GetSpecsCount", &LuaPlayer::GetSpecsCount },
|
|
{ "GetSpellCooldownDelay", &LuaPlayer::GetSpellCooldownDelay },
|
|
{ "GetGuildRank", &LuaPlayer::GetGuildRank },
|
|
{ "GetDifficulty", &LuaPlayer::GetDifficulty },
|
|
{ "GetHealthBonusFromStamina", &LuaPlayer::GetHealthBonusFromStamina },
|
|
{ "GetManaBonusFromIntellect", &LuaPlayer::GetManaBonusFromIntellect },
|
|
{ "GetMaxSkillValue", &LuaPlayer::GetMaxSkillValue },
|
|
{ "GetPureMaxSkillValue", &LuaPlayer::GetPureMaxSkillValue },
|
|
{ "GetSkillValue", &LuaPlayer::GetSkillValue },
|
|
{ "GetBaseSkillValue", &LuaPlayer::GetBaseSkillValue },
|
|
{ "GetPureSkillValue", &LuaPlayer::GetPureSkillValue },
|
|
{ "GetSkillPermBonusValue", &LuaPlayer::GetSkillPermBonusValue },
|
|
{ "GetSkillTempBonusValue", &LuaPlayer::GetSkillTempBonusValue },
|
|
{ "GetReputationRank", &LuaPlayer::GetReputationRank },
|
|
{ "GetDrunkValue", &LuaPlayer::GetDrunkValue },
|
|
{ "GetBattlegroundId", &LuaPlayer::GetBattlegroundId },
|
|
{ "GetBattlegroundTypeId", &LuaPlayer::GetBattlegroundTypeId },
|
|
{ "GetXP", &LuaPlayer::GetXP },
|
|
{ "GetXPRestBonus", &LuaPlayer::GetXPRestBonus },
|
|
{ "GetGroupInvite", &LuaPlayer::GetGroupInvite },
|
|
{ "GetSubGroup", &LuaPlayer::GetSubGroup },
|
|
{ "GetNextRandomRaidMember", &LuaPlayer::GetNextRandomRaidMember },
|
|
{ "GetOriginalGroup", &LuaPlayer::GetOriginalGroup },
|
|
{ "GetOriginalSubGroup", &LuaPlayer::GetOriginalSubGroup },
|
|
{ "GetChampioningFaction", &LuaPlayer::GetChampioningFaction },
|
|
{ "GetLatency", &LuaPlayer::GetLatency },
|
|
// {"GetRecruiterId", &LuaPlayer::GetRecruiterId}, // :GetRecruiterId() - UNDOCUMENTED - Returns player's recruiter's ID
|
|
{ "GetDbLocaleIndex", &LuaPlayer::GetDbLocaleIndex },
|
|
{ "GetDbcLocale", &LuaPlayer::GetDbcLocale },
|
|
{ "GetCorpse", &LuaPlayer::GetCorpse },
|
|
{ "GetGossipTextId", &LuaPlayer::GetGossipTextId },
|
|
{ "GetQuestRewardStatus", &LuaPlayer::GetQuestRewardStatus },
|
|
{ "GetShieldBlockValue", &LuaPlayer::GetShieldBlockValue },
|
|
{ "GetPlayerSettingValue", &LuaPlayer::GetPlayerSettingValue },
|
|
{ "GetTrader", &LuaPlayer::GetTrader },
|
|
{ "GetBonusTalentCount", &LuaPlayer::GetBonusTalentCount },
|
|
{ "GetKnownTaxiNodes", &LuaPlayer::GetKnownTaxiNodes },
|
|
{ "GetPet", &LuaPlayer::GetPet },
|
|
{ "GetTemporaryUnsummonedPetNumber", &LuaPlayer::GetTemporaryUnsummonedPetNumber },
|
|
{ "GetLastPetNumber", &LuaPlayer::GetLastPetNumber },
|
|
{ "GetLastPetSpell", &LuaPlayer::GetLastPetSpell },
|
|
{ "GetQuestSlotQuestId", &LuaPlayer::GetQuestSlotQuestId },
|
|
|
|
// Setters
|
|
{ "SetTemporaryUnsummonedPetNumber", &LuaPlayer::SetTemporaryUnsummonedPetNumber },
|
|
{ "SetLastPetNumber", &LuaPlayer::SetLastPetNumber },
|
|
{ "SetLastPetSpell", &LuaPlayer::SetLastPetSpell },
|
|
{ "SetShowDKPet", &LuaPlayer::SetShowDKPet },
|
|
{ "AdvanceSkillsToMax", &LuaPlayer::AdvanceSkillsToMax },
|
|
{ "AdvanceSkill", &LuaPlayer::AdvanceSkill },
|
|
{ "AdvanceAllSkills", &LuaPlayer::AdvanceAllSkills },
|
|
{ "AddLifetimeKills", &LuaPlayer::AddLifetimeKills },
|
|
{ "SetCoinage", &LuaPlayer::SetCoinage },
|
|
{ "SetKnownTitle", &LuaPlayer::SetKnownTitle },
|
|
{ "UnsetKnownTitle", &LuaPlayer::UnsetKnownTitle },
|
|
{ "SetBindPoint", &LuaPlayer::SetBindPoint },
|
|
{ "SetArenaPoints", &LuaPlayer::SetArenaPoints },
|
|
{ "SetHonorPoints", &LuaPlayer::SetHonorPoints },
|
|
{ "SetSpellPower", &LuaPlayer::SetSpellPower },
|
|
{ "SetLifetimeKills", &LuaPlayer::SetLifetimeKills },
|
|
{ "SetGameMaster", &LuaPlayer::SetGameMaster },
|
|
{ "SetGMChat", &LuaPlayer::SetGMChat },
|
|
{ "SetKnownTaxiNodes", &LuaPlayer::SetKnownTaxiNodes },
|
|
{ "SetTaxiCheat", &LuaPlayer::SetTaxiCheat },
|
|
{ "SetGMVisible", &LuaPlayer::SetGMVisible },
|
|
{ "SetPvPDeath", &LuaPlayer::SetPvPDeath },
|
|
{ "SetAcceptWhispers", &LuaPlayer::SetAcceptWhispers },
|
|
{ "SetRestBonus", &LuaPlayer::SetRestBonus },
|
|
{ "SetQuestStatus", &LuaPlayer::SetQuestStatus },
|
|
{ "SetReputation", &LuaPlayer::SetReputation },
|
|
{ "SetFreeTalentPoints", &LuaPlayer::SetFreeTalentPoints },
|
|
{ "SetGuildRank", &LuaPlayer::SetGuildRank },
|
|
// {"SetMovement", &LuaPlayer::SetMovement}, // :SetMovement(type) - UNDOCUMENTED - Sets player's movement type
|
|
{ "SetSkill", &LuaPlayer::SetSkill },
|
|
{ "SetFactionForRace", &LuaPlayer::SetFactionForRace },
|
|
{ "SetDrunkValue", &LuaPlayer::SetDrunkValue },
|
|
{ "SetAtLoginFlag", &LuaPlayer::SetAtLoginFlag },
|
|
{ "SetPlayerLock", &LuaPlayer::SetPlayerLock },
|
|
{ "SetGender", &LuaPlayer::SetGender },
|
|
{ "SetSheath", &LuaPlayer::SetSheath },
|
|
{ "SetBonusTalentCount", &LuaPlayer::SetBonusTalentCount },
|
|
{ "AddBonusTalent", &LuaPlayer::AddBonusTalent },
|
|
{ "RemoveBonusTalent", &LuaPlayer::RemoveBonusTalent },
|
|
{ "GetHomebind", &LuaPlayer::GetHomebind },
|
|
{ "GetSpells", &LuaPlayer::GetSpells },
|
|
{ "GetAverageItemLevel", &LuaPlayer::GetAverageItemLevel },
|
|
{ "GetBarberShopCost", &LuaPlayer::GetBarberShopCost },
|
|
{ "GetSightRange", &LuaPlayer::GetSightRange },
|
|
{ "GetWeaponProficiency", &LuaPlayer::GetWeaponProficiency },
|
|
{ "GetArmorProficiency", &LuaPlayer::GetArmorProficiency },
|
|
{ "GetAmmoDPS", &LuaPlayer::GetAmmoDPS },
|
|
{ "GetShield", &LuaPlayer::GetShield },
|
|
{ "GetRunesState", &LuaPlayer::GetRunesState },
|
|
{ "GetViewpoint", &LuaPlayer::GetViewpoint },
|
|
{ "GetDodgeFromAgility", &LuaPlayer::GetDodgeFromAgility },
|
|
{ "GetMeleeCritFromAgility", &LuaPlayer::GetMeleeCritFromAgility },
|
|
{ "GetSpellCritFromIntellect", &LuaPlayer::GetSpellCritFromIntellect },
|
|
{ "GetInventoryItem", &LuaPlayer::GetInventoryItem },
|
|
{ "GetBankItem", &LuaPlayer::GetBankItem },
|
|
{ "GetCreationTime", &LuaPlayer::GetCreationTime },
|
|
{ "SetCanFly", &LuaPlayer::SetCanFly },
|
|
|
|
// Boolean
|
|
{ "HasTankSpec", &LuaPlayer::HasTankSpec },
|
|
{ "HasMeleeSpec", &LuaPlayer::HasMeleeSpec },
|
|
{ "HasCasterSpec", &LuaPlayer::HasCasterSpec },
|
|
{ "HasHealSpec", &LuaPlayer::HasHealSpec },
|
|
{ "IsInGroup", &LuaPlayer::IsInGroup },
|
|
{ "IsInGuild", &LuaPlayer::IsInGuild },
|
|
{ "IsGM", &LuaPlayer::IsGM },
|
|
{ "IsImmuneToDamage", &LuaPlayer::IsImmuneToDamage },
|
|
{ "IsAlliance", &LuaPlayer::IsAlliance },
|
|
{ "IsHorde", &LuaPlayer::IsHorde },
|
|
{ "HasTitle", &LuaPlayer::HasTitle },
|
|
{ "HasItem", &LuaPlayer::HasItem },
|
|
{ "Teleport", &LuaPlayer::Teleport },
|
|
{ "AddItem", &LuaPlayer::AddItem },
|
|
{ "IsInArenaTeam", &LuaPlayer::IsInArenaTeam },
|
|
{ "CanRewardQuest", &LuaPlayer::CanRewardQuest },
|
|
{ "CanCompleteRepeatableQuest", &LuaPlayer::CanCompleteRepeatableQuest },
|
|
{ "CanCompleteQuest", &LuaPlayer::CanCompleteQuest },
|
|
{ "CanEquipItem", &LuaPlayer::CanEquipItem },
|
|
{ "IsFalling", &LuaPlayer::IsFalling },
|
|
{ "ToggleAFK", &LuaPlayer::ToggleAFK },
|
|
{ "ToggleDND", &LuaPlayer::ToggleDND },
|
|
{ "IsAFK", &LuaPlayer::IsAFK },
|
|
{ "IsDND", &LuaPlayer::IsDND },
|
|
{ "IsAcceptingWhispers", &LuaPlayer::IsAcceptingWhispers },
|
|
{ "IsGMChat", &LuaPlayer::IsGMChat },
|
|
{ "IsTaxiCheater", &LuaPlayer::IsTaxiCheater },
|
|
{ "IsGMVisible", &LuaPlayer::IsGMVisible },
|
|
{ "HasQuest", &LuaPlayer::HasQuest },
|
|
{ "InBattlegroundQueue", &LuaPlayer::InBattlegroundQueue },
|
|
// {"IsImmuneToEnvironmentalDamage", &LuaPlayer::IsImmuneToEnvironmentalDamage}, // :IsImmuneToEnvironmentalDamage() - UNDOCUMENTED - Returns true if the player is immune to environmental damage
|
|
{ "CanSpeak", &LuaPlayer::CanSpeak },
|
|
{ "HasAtLoginFlag", &LuaPlayer::HasAtLoginFlag },
|
|
// {"InRandomLfgDungeon", &LuaPlayer::InRandomLfgDungeon}, // :InRandomLfgDungeon() - UNDOCUMENTED - Returns true if the player is in a random LFG dungeon
|
|
// {"HasPendingBind", &LuaPlayer::HasPendingBind}, // :HasPendingBind() - UNDOCUMENTED - Returns true if the player has a pending instance bind
|
|
{ "HasAchieved", &LuaPlayer::HasAchieved },
|
|
{ "GetAchievementCriteriaProgress", &LuaPlayer::GetAchievementCriteriaProgress },
|
|
{ "SetAchievement", &LuaPlayer::SetAchievement },
|
|
{ "CanUninviteFromGroup", &LuaPlayer::CanUninviteFromGroup },
|
|
{ "IsRested", &LuaPlayer::IsRested },
|
|
// {"CanFlyInZone", &LuaPlayer::CanFlyInZone}, // :CanFlyInZone(mapid, zone) - UNDOCUMENTED - Returns true if the player can fly in the area
|
|
// {"IsNeverVisible", &LuaPlayer::IsNeverVisible}, // :IsNeverVisible() - UNDOCUMENTED - Returns true if the player is never visible
|
|
{ "IsVisibleForPlayer", &LuaPlayer::IsVisibleForPlayer },
|
|
// {"IsUsingLfg", &LuaPlayer::IsUsingLfg}, // :IsUsingLfg() - UNDOCUMENTED - Returns true if the player is using LFG
|
|
{ "HasQuestForItem", &LuaPlayer::HasQuestForItem },
|
|
{ "HasQuestForGO", &LuaPlayer::HasQuestForGO },
|
|
{ "CanShareQuest", &LuaPlayer::CanShareQuest },
|
|
// {"HasReceivedQuestReward", &LuaPlayer::HasReceivedQuestReward}, // :HasReceivedQuestReward(entry) - UNDOCUMENTED - Returns true if the player has recieved the quest's reward
|
|
{ "HasTalent", &LuaPlayer::HasTalent },
|
|
{ "IsInSameGroupWith", &LuaPlayer::IsInSameGroupWith },
|
|
{ "IsInSameRaidWith", &LuaPlayer::IsInSameRaidWith },
|
|
{ "IsGroupVisibleFor", &LuaPlayer::IsGroupVisibleFor },
|
|
{ "HasSkill", &LuaPlayer::HasSkill },
|
|
{ "IsHonorOrXPTarget", &LuaPlayer::IsHonorOrXPTarget },
|
|
{ "CanParry", &LuaPlayer::CanParry },
|
|
{ "CanBlock", &LuaPlayer::CanBlock },
|
|
{ "CanTitanGrip", &LuaPlayer::CanTitanGrip },
|
|
{ "InBattleground", &LuaPlayer::InBattleground },
|
|
{ "InArena", &LuaPlayer::InArena },
|
|
// {"IsOutdoorPvPActive", &LuaPlayer::IsOutdoorPvPActive}, // :IsOutdoorPvPActive() - UNDOCUMENTED - Returns true if the player is outdoor pvp active
|
|
// {"IsARecruiter", &LuaPlayer::IsARecruiter}, // :IsARecruiter() - UNDOCUMENTED - Returns true if the player is a recruiter
|
|
{ "CanUseItem", &LuaPlayer::CanUseItem },
|
|
{ "HasSpell", &LuaPlayer::HasSpell },
|
|
{ "HasSpellCooldown", &LuaPlayer::HasSpellCooldown },
|
|
{ "IsInWater", &LuaPlayer::IsInWater },
|
|
{ "CanFly", &LuaPlayer::CanFly },
|
|
{ "IsMoving", &LuaPlayer::IsMoving },
|
|
{ "IsFlying", &LuaPlayer::IsFlying },
|
|
{ "CanPetResurrect", &LuaPlayer::CanPetResurrect },
|
|
{ "IsExistPet", &LuaPlayer::IsExistPet },
|
|
{ "CanTameExoticPets", &LuaPlayer::CanTameExoticPets },
|
|
{ "IsPetNeedBeTemporaryUnsummoned", &LuaPlayer::IsPetNeedBeTemporaryUnsummoned },
|
|
{ "CanResummonPet", &LuaPlayer::CanResummonPet },
|
|
{ "CanSeeDKPet", &LuaPlayer::CanSeeDKPet },
|
|
{ "IsMaxLevel", &LuaPlayer::IsMaxLevel },
|
|
{ "IsDailyQuestDone", &LuaPlayer::IsDailyQuestDone },
|
|
{ "IsPvP", &LuaPlayer::IsPvP },
|
|
{ "IsFFAPvP", &LuaPlayer::IsFFAPvP },
|
|
{ "IsUsingLfg", &LuaPlayer::IsUsingLfg },
|
|
{ "InRandomLfgDungeon", &LuaPlayer::InRandomLfgDungeon },
|
|
{ "CanInteractWithQuestGiver", &LuaPlayer::CanInteractWithQuestGiver },
|
|
{ "CanSeeStartQuest", &LuaPlayer::CanSeeStartQuest },
|
|
{ "CanTakeQuest", &LuaPlayer::CanTakeQuest },
|
|
{ "CanAddQuest", &LuaPlayer::CanAddQuest },
|
|
{ "CalculateReputationGain", &LuaPlayer::CalculateReputationGain },
|
|
{ "HasTitleByIndex", &LuaPlayer::HasTitleByIndex },
|
|
{ "IsAtGroupRewardDistance", &LuaPlayer::IsAtGroupRewardDistance },
|
|
{ "IsAtLootRewardDistance", &LuaPlayer::IsAtLootRewardDistance },
|
|
{ "CanTeleport", &LuaPlayer::CanTeleport },
|
|
{ "IsSpectator", &LuaPlayer::IsSpectator },
|
|
{ "HasKnownTaxiNode", &LuaPlayer::HasKnownTaxiNode },
|
|
{ "IsBot", &LuaPlayer::IsBot },
|
|
// { "HasSpellMod", &LuaPlayer::HasSpellMod },
|
|
|
|
// Gossip
|
|
{ "GossipMenuAddItem", &LuaPlayer::GossipMenuAddItem },
|
|
{ "GossipSendMenu", &LuaPlayer::GossipSendMenu },
|
|
{ "GossipComplete", &LuaPlayer::GossipComplete },
|
|
{ "GossipClearMenu", &LuaPlayer::GossipClearMenu },
|
|
|
|
// Other
|
|
{ "SendBroadcastMessage", &LuaPlayer::SendBroadcastMessage },
|
|
{ "SendAreaTriggerMessage", &LuaPlayer::SendAreaTriggerMessage },
|
|
{ "SendNotification", &LuaPlayer::SendNotification },
|
|
{ "SendPacket", &LuaPlayer::SendPacket },
|
|
{ "SendAddonMessage", &LuaPlayer::SendAddonMessage },
|
|
{ "ModifyMoney", &LuaPlayer::ModifyMoney },
|
|
{ "LearnSpell", &LuaPlayer::LearnSpell },
|
|
{ "LearnTalent", &LuaPlayer::LearnTalent },
|
|
|
|
{ "RunCommand", &LuaPlayer::RunCommand },
|
|
{ "SetGlyph", &LuaPlayer::SetGlyph },
|
|
{ "GetGlyph", &LuaPlayer::GetGlyph },
|
|
{ "RemoveArenaSpellCooldowns", &LuaPlayer::RemoveArenaSpellCooldowns },
|
|
{ "RemoveItem", &LuaPlayer::RemoveItem },
|
|
{ "RemoveLifetimeKills", &LuaPlayer::RemoveLifetimeKills },
|
|
{ "ResurrectPlayer", &LuaPlayer::ResurrectPlayer },
|
|
{ "EquipItem", &LuaPlayer::EquipItem },
|
|
{ "ResetSpellCooldown", &LuaPlayer::ResetSpellCooldown },
|
|
{ "ResetTypeCooldowns", &LuaPlayer::ResetTypeCooldowns },
|
|
{ "ResetAllCooldowns", &LuaPlayer::ResetAllCooldowns },
|
|
{ "GiveXP", &LuaPlayer::GiveXP }, // :GiveXP(xp[, victim, pureXP, triggerHook]) - UNDOCUMENTED - Gives XP to the player. If pure is false, bonuses are count in. If triggerHook is false, GiveXp hook is not triggered.
|
|
// {"RemovePet", &LuaPlayer::RemovePet}, // :RemovePet([mode, returnreagent]) - UNDOCUMENTED - Removes the player's pet. Mode determines if the pet is saved and how
|
|
// {"SummonPet", &LuaPlayer::SummonPet}, // :SummonPet(entry, x, y, z, o, petType, despwtime) - Summons a pet for the player
|
|
{ "Say", &LuaPlayer::Say },
|
|
{ "Yell", &LuaPlayer::Yell },
|
|
{ "TextEmote", &LuaPlayer::TextEmote },
|
|
{ "Whisper", &LuaPlayer::Whisper },
|
|
{ "CompleteQuest", &LuaPlayer::CompleteQuest },
|
|
{ "IncompleteQuest", &LuaPlayer::IncompleteQuest },
|
|
{ "FailQuest", &LuaPlayer::FailQuest },
|
|
{ "AddQuest", &LuaPlayer::AddQuest },
|
|
{ "RemoveQuest", &LuaPlayer::RemoveQuest },
|
|
// {"RemoveActiveQuest", &LuaPlayer::RemoveActiveQuest}, // :RemoveActiveQuest(entry) - UNDOCUMENTED - Removes an active quest
|
|
// {"RemoveRewardedQuest", &LuaPlayer::RemoveRewardedQuest}, // :RemoveRewardedQuest(entry) - UNDOCUMENTED - Removes a rewarded quest
|
|
{ "AreaExploredOrEventHappens", &LuaPlayer::AreaExploredOrEventHappens },
|
|
{ "GroupEventHappens", &LuaPlayer::GroupEventHappens },
|
|
{ "KilledMonsterCredit", &LuaPlayer::KilledMonsterCredit },
|
|
// {"KilledPlayerCredit", &LuaPlayer::KilledPlayerCredit}, // :KilledPlayerCredit() - UNDOCUMENTED - Satisfies a player kill for the player
|
|
// {"KillGOCredit", &LuaPlayer::KillGOCredit}, // :KillGOCredit(GOEntry[, GUID]) - UNDOCUMENTED - Credits the player for destroying a GO, guid is optional
|
|
{ "TalkedToCreature", &LuaPlayer::TalkedToCreature },
|
|
{ "ResetPetTalents", &LuaPlayer::ResetPetTalents },
|
|
{ "AddComboPoints", &LuaPlayer::AddComboPoints },
|
|
// {"GainSpellComboPoints", &LuaPlayer::GainSpellComboPoints}, // :GainSpellComboPoints(amount) - UNDOCUMENTED - Player gains spell combo points
|
|
{ "ClearComboPoints", &LuaPlayer::ClearComboPoints },
|
|
{ "RemoveSpell", &LuaPlayer::RemoveSpell },
|
|
{ "ResetTalents", &LuaPlayer::ResetTalents },
|
|
{ "ResetTalentsCost", &LuaPlayer::ResetTalentsCost },
|
|
// {"AddTalent", &LuaPlayer::AddTalent}, // :AddTalent(spellid, spec, learning) - UNDOCUMENTED - Adds a talent spell for the player to given spec
|
|
{ "RemoveFromGroup", &LuaPlayer::RemoveFromGroup },
|
|
{ "KillPlayer", &LuaPlayer::KillPlayer },
|
|
{ "DurabilityLossAll", &LuaPlayer::DurabilityLossAll },
|
|
{ "DurabilityLoss", &LuaPlayer::DurabilityLoss },
|
|
{ "DurabilityPointsLoss", &LuaPlayer::DurabilityPointsLoss },
|
|
{ "DurabilityPointsLossAll", &LuaPlayer::DurabilityPointsLossAll },
|
|
{ "DurabilityPointLossForEquipSlot", &LuaPlayer::DurabilityPointLossForEquipSlot },
|
|
{ "DurabilityRepairAll", &LuaPlayer::DurabilityRepairAll },
|
|
{ "DurabilityRepair", &LuaPlayer::DurabilityRepair },
|
|
{ "ModifyHonorPoints", &LuaPlayer::ModifyHonorPoints },
|
|
{ "ModifyArenaPoints", &LuaPlayer::ModifyArenaPoints },
|
|
{ "LeaveBattleground", &LuaPlayer::LeaveBattleground },
|
|
// {"BindToInstance", &LuaPlayer::BindToInstance}, // :BindToInstance() - UNDOCUMENTED - Binds the player to the current instance
|
|
{ "UnbindInstance", &LuaPlayer::UnbindInstance },
|
|
{ "UnbindAllInstances", &LuaPlayer::UnbindAllInstances },
|
|
{ "RemoveFromBattlegroundRaid", &LuaPlayer::RemoveFromBattlegroundRaid },
|
|
{ "ResetAchievements", &LuaPlayer::ResetAchievements },
|
|
{ "KickPlayer", &LuaPlayer::KickPlayer },
|
|
{ "LogoutPlayer", &LuaPlayer::LogoutPlayer },
|
|
{ "SendTrainerList", &LuaPlayer::SendTrainerList },
|
|
{ "SendListInventory", &LuaPlayer::SendListInventory },
|
|
{ "SendShowBank", &LuaPlayer::SendShowBank },
|
|
{ "SendTabardVendorActivate", &LuaPlayer::SendTabardVendorActivate },
|
|
{ "SendSpiritResurrect", &LuaPlayer::SendSpiritResurrect },
|
|
{ "SendTaxiMenu", &LuaPlayer::SendTaxiMenu },
|
|
{ "SendUpdateWorldState", &LuaPlayer::SendUpdateWorldState },
|
|
{ "RewardQuest", &LuaPlayer::RewardQuest },
|
|
{ "SendAuctionMenu", &LuaPlayer::SendAuctionMenu },
|
|
{ "SendShowMailBox", &LuaPlayer::SendShowMailBox },
|
|
{ "StartTaxi", &LuaPlayer::StartTaxi },
|
|
{ "GossipSendPOI", &LuaPlayer::GossipSendPOI },
|
|
{ "GossipAddQuests", &LuaPlayer::GossipAddQuests },
|
|
{ "SendQuestTemplate", &LuaPlayer::SendQuestTemplate },
|
|
{ "SpawnBones", &LuaPlayer::SpawnBones },
|
|
{ "RemovedInsignia", &LuaPlayer::RemovedInsignia },
|
|
{ "SendGuildInvite", &LuaPlayer::SendGuildInvite },
|
|
{ "Mute", &LuaPlayer::Mute },
|
|
{ "SummonPlayer", &LuaPlayer::SummonPlayer },
|
|
{ "SaveToDB", &LuaPlayer::SaveToDB },
|
|
{ "GroupInvite", &LuaPlayer::GroupInvite },
|
|
{ "GroupCreate", &LuaPlayer::GroupCreate },
|
|
{ "SendCinematicStart", &LuaPlayer::SendCinematicStart },
|
|
{ "SendMovieStart", &LuaPlayer::SendMovieStart },
|
|
{ "UpdatePlayerSetting", &LuaPlayer::UpdatePlayerSetting },
|
|
{ "TeleportTo", &LuaPlayer::TeleportTo },
|
|
{ "SummonPet", &LuaPlayer::SummonPet },
|
|
{ "CreatePet", &LuaPlayer::CreatePet },
|
|
{ "UnsummonPetTemporarily", &LuaPlayer::UnsummonPetTemporarily },
|
|
{ "RemovePet", &LuaPlayer::RemovePet },
|
|
{ "ResetPetTalents", &LuaPlayer::ResetPetTalents },
|
|
{ "LearnPetTalent", &LuaPlayer::LearnPetTalent },
|
|
{ "ResummonPetTemporaryUnSummonedIfAny", &LuaPlayer::ResummonPetTemporaryUnSummonedIfAny },
|
|
{ "SetPlayerFlag", &LuaPlayer::SetPlayerFlag },
|
|
{ "RemovePlayerFlag", &LuaPlayer::RemovePlayerFlag },
|
|
{ "DoRandomRoll", &LuaPlayer::DoRandomRoll },
|
|
{ "EnvironmentalDamage", &LuaPlayer::EnvironmentalDamage },
|
|
{ "InitTaxiNodesForLevel", &LuaPlayer::InitTaxiNodesForLevel },
|
|
{ "AbandonQuest", &LuaPlayer::AbandonQuest },
|
|
{ "AddWeaponProficiency", &LuaPlayer::AddWeaponProficiency },
|
|
{ "AddArmorProficiency", &LuaPlayer::AddArmorProficiency },
|
|
{ "SetAmmo", &LuaPlayer::SetAmmo },
|
|
{ "RemoveAmmo", &LuaPlayer::RemoveAmmo },
|
|
{ "SetCanTeleport", &LuaPlayer::SetCanTeleport },
|
|
{ "SetIsSpectator", &LuaPlayer::SetIsSpectator },
|
|
{ "SetViewpoint", &LuaPlayer::SetViewpoint },
|
|
{ "ToggleInstantFlight", &LuaPlayer::ToggleInstantFlight },
|
|
{ "SetCreationTime", &LuaPlayer::SetCreationTime },
|
|
{ "ApplyRatingMod", &LuaPlayer::ApplyRatingMod },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Creature> CreatureMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetAITarget", &LuaCreature::GetAITarget },
|
|
{ "GetAITargets", &LuaCreature::GetAITargets },
|
|
{ "GetAITargetsCount", &LuaCreature::GetAITargetsCount },
|
|
{ "GetHomePosition", &LuaCreature::GetHomePosition },
|
|
{ "GetCorpseDelay", &LuaCreature::GetCorpseDelay },
|
|
{ "GetCreatureSpellCooldownDelay", &LuaCreature::GetCreatureSpellCooldownDelay },
|
|
{ "GetScriptId", &LuaCreature::GetScriptId },
|
|
{ "GetAIName", &LuaCreature::GetAIName },
|
|
{ "GetScriptName", &LuaCreature::GetScriptName },
|
|
{ "GetAggroRange", &LuaCreature::GetAggroRange },
|
|
{ "GetDefaultMovementType", &LuaCreature::GetDefaultMovementType },
|
|
{ "GetRespawnDelay", &LuaCreature::GetRespawnDelay },
|
|
{ "GetWanderRadius", &LuaCreature::GetWanderRadius },
|
|
{ "GetCurrentWaypointId", &LuaCreature::GetCurrentWaypointId },
|
|
{ "GetSpawnId", &LuaCreature::GetSpawnId },
|
|
{ "GetWaypointPath", &LuaCreature::GetWaypointPath },
|
|
{ "GetLootMode", &LuaCreature::GetLootMode },
|
|
{ "GetLootRecipient", &LuaCreature::GetLootRecipient },
|
|
{ "GetLootRecipientGroup", &LuaCreature::GetLootRecipientGroup },
|
|
{ "GetNPCFlags", &LuaCreature::GetNPCFlags },
|
|
{ "GetUnitFlags", &LuaCreature::GetUnitFlags },
|
|
{ "GetUnitFlagsTwo", &LuaCreature::GetUnitFlagsTwo },
|
|
{ "GetExtraFlags", &LuaCreature::GetExtraFlags },
|
|
{ "GetRank", &LuaCreature::GetRank },
|
|
{ "GetShieldBlockValue", &LuaCreature::GetShieldBlockValue },
|
|
{ "GetDBTableGUIDLow", &LuaCreature::GetDBTableGUIDLow },
|
|
{ "GetCreatureFamily", &LuaCreature::GetCreatureFamily },
|
|
{ "GetReactState", &LuaCreature::GetReactState },
|
|
{ "GetLoot", &LuaCreature::GetLoot },
|
|
|
|
// Setters
|
|
{ "SetRegeneratingHealth", &LuaCreature::SetRegeneratingHealth },
|
|
{ "SetHover", &LuaCreature::SetHover },
|
|
{ "SetDisableGravity", &LuaCreature::SetDisableGravity },
|
|
{ "SetAggroEnabled", &LuaCreature::SetAggroEnabled },
|
|
{ "SetCorpseDelay", &LuaCreature::SetCorpseDelay },
|
|
{ "SetNoCallAssistance", &LuaCreature::SetNoCallAssistance },
|
|
{ "SetNoSearchAssistance", &LuaCreature::SetNoSearchAssistance },
|
|
{ "SetDefaultMovementType", &LuaCreature::SetDefaultMovementType },
|
|
{ "SetRespawnDelay", &LuaCreature::SetRespawnDelay },
|
|
{ "SetWanderRadius", &LuaCreature::SetWanderRadius },
|
|
{ "SetInCombatWithZone", &LuaCreature::SetInCombatWithZone },
|
|
{ "SetDisableReputationGain", &LuaCreature::SetDisableReputationGain },
|
|
{ "SetLootMode", &LuaCreature::SetLootMode },
|
|
{ "SetNPCFlags", &LuaCreature::SetNPCFlags },
|
|
{ "SetUnitFlags", &LuaCreature::SetUnitFlags },
|
|
{ "SetUnitFlagsTwo", &LuaCreature::SetUnitFlagsTwo },
|
|
{ "SetReactState", &LuaCreature::SetReactState },
|
|
{ "SetDeathState", &LuaCreature::SetDeathState },
|
|
{ "SetWalk", &LuaCreature::SetWalk },
|
|
{ "SetHomePosition", &LuaCreature::SetHomePosition },
|
|
{ "SetEquipmentSlots", &LuaCreature::SetEquipmentSlots },
|
|
|
|
// Boolean
|
|
{ "IsRegeneratingHealth", &LuaCreature::IsRegeneratingHealth },
|
|
{ "IsDungeonBoss", &LuaCreature::IsDungeonBoss },
|
|
{ "IsWorldBoss", &LuaCreature::IsWorldBoss },
|
|
{ "IsRacialLeader", &LuaCreature::IsRacialLeader },
|
|
{ "IsCivilian", &LuaCreature::IsCivilian },
|
|
{ "IsTrigger", &LuaCreature::IsTrigger },
|
|
{ "IsGuard", &LuaCreature::IsGuard },
|
|
{ "IsElite", &LuaCreature::IsElite },
|
|
{ "IsInEvadeMode", &LuaCreature::IsInEvadeMode },
|
|
{ "HasCategoryCooldown", &LuaCreature::HasCategoryCooldown },
|
|
{ "CanWalk", &LuaCreature::CanWalk },
|
|
{ "CanSwim", &LuaCreature::CanSwim },
|
|
{ "CanAggro", &LuaCreature::CanAggro },
|
|
{ "CanStartAttack", &LuaCreature::CanStartAttack },
|
|
{ "HasSearchedAssistance", &LuaCreature::HasSearchedAssistance },
|
|
{ "IsTappedBy", &LuaCreature::IsTappedBy },
|
|
{ "HasLootRecipient", &LuaCreature::HasLootRecipient },
|
|
{ "CanAssistTo", &LuaCreature::CanAssistTo },
|
|
{ "IsTargetableForAttack", &LuaCreature::IsTargetableForAttack },
|
|
{ "CanCompleteQuest", &LuaCreature::CanCompleteQuest },
|
|
{ "IsReputationGainDisabled", &LuaCreature::IsReputationGainDisabled },
|
|
{ "IsDamageEnoughForLootingAndReward", &LuaCreature::IsDamageEnoughForLootingAndReward },
|
|
{ "HasLootMode", &LuaCreature::HasLootMode },
|
|
{ "HasSpell", &LuaCreature::HasSpell },
|
|
{ "HasQuest", &LuaCreature::HasQuest },
|
|
{ "HasSpellCooldown", &LuaCreature::HasSpellCooldown },
|
|
{ "CanFly", &LuaCreature::CanFly },
|
|
|
|
// Other
|
|
{ "FleeToGetAssistance", &LuaCreature::FleeToGetAssistance },
|
|
{ "CallForHelp", &LuaCreature::CallForHelp },
|
|
{ "CallAssistance", &LuaCreature::CallAssistance },
|
|
{ "RemoveCorpse", &LuaCreature::RemoveCorpse },
|
|
{ "AllLootRemovedFromCorpse", &LuaCreature::AllLootRemovedFromCorpse },
|
|
{ "DespawnOrUnsummon", &LuaCreature::DespawnOrUnsummon },
|
|
{ "Respawn", &LuaCreature::Respawn },
|
|
{ "AttackStart", &LuaCreature::AttackStart },
|
|
{ "AddLootMode", &LuaCreature::AddLootMode },
|
|
{ "ResetLootMode", &LuaCreature::ResetLootMode },
|
|
{ "RemoveLootMode", &LuaCreature::RemoveLootMode },
|
|
{ "SaveToDB", &LuaCreature::SaveToDB },
|
|
{ "SelectVictim", &LuaCreature::SelectVictim },
|
|
{ "MoveWaypoint", &LuaCreature::MoveWaypoint },
|
|
{ "UpdateEntry", &LuaCreature::UpdateEntry },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<GameObject> GameObjectMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetDisplayId", &LuaGameObject::GetDisplayId },
|
|
{ "GetGoState", &LuaGameObject::GetGoState },
|
|
{ "GetLootState", &LuaGameObject::GetLootState },
|
|
{ "GetLootRecipient", &LuaGameObject::GetLootRecipient },
|
|
{ "GetLootRecipientGroup", &LuaGameObject::GetLootRecipientGroup },
|
|
{ "GetSpawnId", &LuaGameObject::GetSpawnId },
|
|
|
|
// Setters
|
|
{ "SetGoState", &LuaGameObject::SetGoState },
|
|
{ "SetLootState", &LuaGameObject::SetLootState },
|
|
{ "SetRespawnTime", &LuaGameObject::SetRespawnTime },
|
|
{ "SetRespawnDelay", &LuaGameObject::SetRespawnDelay },
|
|
|
|
// Boolean
|
|
{ "IsTransport", &LuaGameObject::IsTransport },
|
|
// {"IsDestructible", &LuaGameObject::IsDestructible}, // :IsDestructible() - UNDOCUMENTED
|
|
{ "IsActive", &LuaGameObject::IsActive },
|
|
{ "HasQuest", &LuaGameObject::HasQuest },
|
|
{ "IsSpawned", &LuaGameObject::IsSpawned },
|
|
|
|
// Other
|
|
{ "RemoveFromWorld", &LuaGameObject::RemoveFromWorld },
|
|
{ "UseDoorOrButton", &LuaGameObject::UseDoorOrButton },
|
|
{ "Despawn", &LuaGameObject::Despawn },
|
|
{ "Respawn", &LuaGameObject::Respawn },
|
|
{ "SaveToDB", &LuaGameObject::SaveToDB },
|
|
{ "AddLoot", &LuaGameObject::AddLoot },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Item> ItemMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetOwnerGUID", &LuaItem::GetOwnerGUID },
|
|
{ "GetOwner", &LuaItem::GetOwner },
|
|
{ "GetCount", &LuaItem::GetCount },
|
|
{ "GetMaxStackCount", &LuaItem::GetMaxStackCount },
|
|
{ "GetSlot", &LuaItem::GetSlot },
|
|
{ "GetBagSlot", &LuaItem::GetBagSlot },
|
|
{ "GetEnchantmentId", &LuaItem::GetEnchantmentId },
|
|
{ "GetSpellId", &LuaItem::GetSpellId },
|
|
{ "GetSpellTrigger", &LuaItem::GetSpellTrigger },
|
|
{ "GetItemLink", &LuaItem::GetItemLink },
|
|
{ "GetClass", &LuaItem::GetClass },
|
|
{ "GetSubClass", &LuaItem::GetSubClass },
|
|
{ "GetName", &LuaItem::GetName },
|
|
{ "GetDisplayId", &LuaItem::GetDisplayId },
|
|
{ "GetQuality", &LuaItem::GetQuality },
|
|
{ "GetBuyCount", &LuaItem::GetBuyCount },
|
|
{ "GetBuyPrice", &LuaItem::GetBuyPrice },
|
|
{ "GetSellPrice", &LuaItem::GetSellPrice },
|
|
{ "GetInventoryType", &LuaItem::GetInventoryType },
|
|
{ "GetAllowableClass", &LuaItem::GetAllowableClass },
|
|
{ "GetAllowableRace", &LuaItem::GetAllowableRace },
|
|
{ "GetItemLevel", &LuaItem::GetItemLevel },
|
|
{ "GetRequiredLevel", &LuaItem::GetRequiredLevel },
|
|
{ "GetStatsCount", &LuaItem::GetStatsCount },
|
|
{ "GetRandomProperty", &LuaItem::GetRandomProperty },
|
|
{ "GetRandomSuffix", &LuaItem::GetRandomSuffix },
|
|
{ "GetItemSet", &LuaItem::GetItemSet },
|
|
{ "GetBagSize", &LuaItem::GetBagSize },
|
|
{ "GetItemTemplate", &LuaItem::GetItemTemplate },
|
|
|
|
// Setters
|
|
{ "SetOwner", &LuaItem::SetOwner },
|
|
{ "SetBinding", &LuaItem::SetBinding },
|
|
{ "SetCount", &LuaItem::SetCount },
|
|
{ "SetRandomProperty", &LuaItem::SetRandomProperty },
|
|
{ "SetRandomSuffix", &LuaItem::SetRandomSuffix },
|
|
|
|
// Boolean
|
|
{ "IsSoulBound", &LuaItem::IsSoulBound },
|
|
{ "IsBoundAccountWide", &LuaItem::IsBoundAccountWide },
|
|
{ "IsBoundByEnchant", &LuaItem::IsBoundByEnchant },
|
|
{ "IsNotBoundToPlayer", &LuaItem::IsNotBoundToPlayer },
|
|
{ "IsLocked", &LuaItem::IsLocked },
|
|
{ "IsBag", &LuaItem::IsBag },
|
|
{ "IsCurrencyToken", &LuaItem::IsCurrencyToken },
|
|
{ "IsNotEmptyBag", &LuaItem::IsNotEmptyBag },
|
|
{ "IsBroken", &LuaItem::IsBroken },
|
|
{ "CanBeTraded", &LuaItem::CanBeTraded },
|
|
{ "IsInTrade", &LuaItem::IsInTrade },
|
|
{ "IsInBag", &LuaItem::IsInBag },
|
|
{ "IsEquipped", &LuaItem::IsEquipped },
|
|
{ "HasQuest", &LuaItem::HasQuest },
|
|
{ "IsPotion", &LuaItem::IsPotion },
|
|
{ "IsWeaponVellum", &LuaItem::IsWeaponVellum },
|
|
{ "IsArmorVellum", &LuaItem::IsArmorVellum },
|
|
{ "IsConjuredConsumable", &LuaItem::IsConjuredConsumable },
|
|
//{"IsRefundExpired", &LuaItem::IsRefundExpired}, // :IsRefundExpired() - UNDOCUMENTED - Returns true if the item's refund time has expired
|
|
{ "SetEnchantment", &LuaItem::SetEnchantment },
|
|
{ "ClearEnchantment", &LuaItem::ClearEnchantment },
|
|
|
|
// Other
|
|
{ "SaveToDB", &LuaItem::SaveToDB },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<ItemTemplate> ItemTemplateMethods[] =
|
|
{
|
|
{ "GetItemId", &LuaItemTemplate::GetItemId },
|
|
{ "GetClass", &LuaItemTemplate::GetClass },
|
|
{ "GetSubClass", &LuaItemTemplate::GetSubClass },
|
|
{ "GetName", &LuaItemTemplate::GetName },
|
|
{ "GetDisplayId", &LuaItemTemplate::GetDisplayId },
|
|
{ "GetQuality", &LuaItemTemplate::GetQuality },
|
|
{ "GetFlags", &LuaItemTemplate::GetFlags },
|
|
{ "GetExtraFlags", &LuaItemTemplate::GetExtraFlags },
|
|
{ "GetBuyCount", &LuaItemTemplate::GetBuyCount },
|
|
{ "GetBuyPrice", &LuaItemTemplate::GetBuyPrice },
|
|
{ "GetSellPrice", &LuaItemTemplate::GetSellPrice },
|
|
{ "GetInventoryType", &LuaItemTemplate::GetInventoryType },
|
|
{ "GetAllowableClass", &LuaItemTemplate::GetAllowableClass },
|
|
{ "GetAllowableRace", &LuaItemTemplate::GetAllowableRace },
|
|
{ "GetItemLevel", &LuaItemTemplate::GetItemLevel },
|
|
{ "GetRequiredLevel", &LuaItemTemplate::GetRequiredLevel },
|
|
{ "GetIcon", &LuaItemTemplate::GetIcon },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Aura> AuraMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetCaster", &LuaAura::GetCaster },
|
|
{ "GetCasterGUID", &LuaAura::GetCasterGUID },
|
|
{ "GetCasterLevel", &LuaAura::GetCasterLevel },
|
|
{ "GetDuration", &LuaAura::GetDuration },
|
|
{ "GetMaxDuration", &LuaAura::GetMaxDuration },
|
|
{ "GetAuraId", &LuaAura::GetAuraId },
|
|
{ "GetStackAmount", &LuaAura::GetStackAmount },
|
|
{ "GetOwner", &LuaAura::GetOwner },
|
|
|
|
// Setters
|
|
{ "SetDuration", &LuaAura::SetDuration },
|
|
{ "SetMaxDuration", &LuaAura::SetMaxDuration },
|
|
{ "SetStackAmount", &LuaAura::SetStackAmount },
|
|
|
|
// Other
|
|
{ "Remove", &LuaAura::Remove },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Spell> SpellMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetCaster", &LuaSpell::GetCaster },
|
|
{ "GetCastTime", &LuaSpell::GetCastTime },
|
|
{ "GetEntry", &LuaSpell::GetEntry },
|
|
{ "GetDuration", &LuaSpell::GetDuration },
|
|
{ "GetPowerCost", &LuaSpell::GetPowerCost },
|
|
{ "GetReagentCost", &LuaSpell::GetReagentCost },
|
|
{ "GetTargetDest", &LuaSpell::GetTargetDest },
|
|
{ "GetTarget", &LuaSpell::GetTarget },
|
|
|
|
// Setters
|
|
{ "SetAutoRepeat", &LuaSpell::SetAutoRepeat },
|
|
|
|
// Boolean
|
|
{ "IsAutoRepeat", &LuaSpell::IsAutoRepeat },
|
|
|
|
// Other
|
|
{ "Cancel", &LuaSpell::Cancel },
|
|
{ "Cast", &LuaSpell::Cast },
|
|
{ "Finish", &LuaSpell::Finish },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Quest> QuestMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetId", &LuaQuest::GetId },
|
|
{ "GetLevel", &LuaQuest::GetLevel },
|
|
// {"GetMaxLevel", &LuaQuest::GetMaxLevel}, // :GetMaxLevel() - UNDOCUMENTED - Returns the quest's max level
|
|
{ "GetMinLevel", &LuaQuest::GetMinLevel },
|
|
{ "GetNextQuestId", &LuaQuest::GetNextQuestId },
|
|
{ "GetPrevQuestId", &LuaQuest::GetPrevQuestId },
|
|
{ "GetNextQuestInChain", &LuaQuest::GetNextQuestInChain },
|
|
{ "GetFlags", &LuaQuest::GetFlags },
|
|
{ "GetType", &LuaQuest::GetType },
|
|
|
|
// Boolean
|
|
{ "HasFlag", &LuaQuest::HasFlag },
|
|
{ "IsDaily", &LuaQuest::IsDaily },
|
|
{ "IsRepeatable", &LuaQuest::IsRepeatable },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Group> GroupMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetMembers", &LuaGroup::GetMembers },
|
|
{ "GetLeaderGUID", &LuaGroup::GetLeaderGUID },
|
|
{ "GetGUID", &LuaGroup::GetGUID },
|
|
{ "GetMemberGroup", &LuaGroup::GetMemberGroup },
|
|
{ "GetMemberGUID", &LuaGroup::GetMemberGUID },
|
|
{ "GetMembersCount", &LuaGroup::GetMembersCount },
|
|
{ "GetGroupType", &LuaGroup::GetGroupType },
|
|
|
|
// Setters
|
|
{ "SetLeader", &LuaGroup::SetLeader },
|
|
{ "SetMembersGroup", &LuaGroup::SetMembersGroup },
|
|
{ "SetTargetIcon", &LuaGroup::SetTargetIcon },
|
|
{ "SetMemberFlag", &LuaGroup::SetMemberFlag },
|
|
|
|
// Boolean
|
|
{ "IsLeader", &LuaGroup::IsLeader },
|
|
{ "AddMember", &LuaGroup::AddMember },
|
|
{ "RemoveMember", &LuaGroup::RemoveMember },
|
|
{ "Disband", &LuaGroup::Disband },
|
|
{ "IsFull", &LuaGroup::IsFull },
|
|
{ "IsLFGGroup", &LuaGroup::IsLFGGroup },
|
|
{ "IsRaidGroup", &LuaGroup::IsRaidGroup },
|
|
{ "IsBGGroup", &LuaGroup::IsBGGroup },
|
|
// {"IsBFGroup", &LuaGroup::IsBFGroup}, // :IsBFGroup() - UNDOCUMENTED - Returns true if the group is a battlefield group
|
|
{ "IsMember", &LuaGroup::IsMember },
|
|
{ "IsAssistant", &LuaGroup::IsAssistant },
|
|
{ "SameSubGroup", &LuaGroup::SameSubGroup },
|
|
{ "HasFreeSlotSubGroup", &LuaGroup::HasFreeSlotSubGroup },
|
|
|
|
// Other
|
|
{ "SendPacket", &LuaGroup::SendPacket },
|
|
// {"ConvertToLFG", &LuaGroup::ConvertToLFG}, // :ConvertToLFG() - UNDOCUMENTED - Converts the group to an LFG group
|
|
{ "ConvertToRaid", &LuaGroup::ConvertToRaid },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Guild> GuildMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetMembers", &LuaGuild::GetMembers },
|
|
{ "GetLeader", &LuaGuild::GetLeader },
|
|
{ "GetLeaderGUID", &LuaGuild::GetLeaderGUID },
|
|
{ "GetId", &LuaGuild::GetId },
|
|
{ "GetName", &LuaGuild::GetName },
|
|
{ "GetMOTD", &LuaGuild::GetMOTD },
|
|
{ "GetInfo", &LuaGuild::GetInfo },
|
|
{ "GetMemberCount", &LuaGuild::GetMemberCount },
|
|
{ "GetCreatedDate", &LuaGuild::GetCreatedDate },
|
|
{ "GetTotalBankMoney", &LuaGuild::GetTotalBankMoney },
|
|
|
|
// Setters
|
|
{ "SetBankTabText", &LuaGuild::SetBankTabText },
|
|
{ "SetMemberRank", &LuaGuild::SetMemberRank },
|
|
{ "SetLeader", &LuaGuild::SetLeader },
|
|
{ "SetName", &LuaGuild::SetName },
|
|
|
|
// Other
|
|
{ "SendPacket", &LuaGuild::SendPacket },
|
|
{ "SendPacketToRanked", &LuaGuild::SendPacketToRanked },
|
|
{ "Disband", &LuaGuild::Disband },
|
|
{ "AddMember", &LuaGuild::AddMember },
|
|
{ "DeleteMember", &LuaGuild::DeleteMember },
|
|
{ "SendMessage", &LuaGuild::SendMessage },
|
|
{ "UpdateMemberData", &LuaGuild::UpdateMemberData },
|
|
{ "MassInviteToEvent", &LuaGuild::MassInviteToEvent },
|
|
{ "SwapItems", &LuaGuild::SwapItems },
|
|
{ "SwapItemsWithInventory", &LuaGuild::SwapItemsWithInventory },
|
|
{ "ResetTimes", &LuaGuild::ResetTimes },
|
|
{ "ModifyBankMoney", &LuaGuild::ModifyBankMoney },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Vehicle> VehicleMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetOwner", &LuaVehicle::GetOwner },
|
|
{ "GetEntry", &LuaVehicle::GetEntry },
|
|
{ "GetPassenger", &LuaVehicle::GetPassenger },
|
|
|
|
// Boolean
|
|
{ "IsOnBoard", &LuaVehicle::IsOnBoard },
|
|
|
|
// Other
|
|
{ "AddPassenger", &LuaVehicle::AddPassenger },
|
|
{ "RemovePassenger", &LuaVehicle::RemovePassenger },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<ALEQuery> QueryMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetColumnCount", &LuaQuery::GetColumnCount },
|
|
{ "GetRowCount", &LuaQuery::GetRowCount },
|
|
{ "GetRow", &LuaQuery::GetRow },
|
|
{ "GetBool", &LuaQuery::GetBool },
|
|
{ "GetUInt8", &LuaQuery::GetUInt8 },
|
|
{ "GetUInt16", &LuaQuery::GetUInt16 },
|
|
{ "GetUInt32", &LuaQuery::GetUInt32 },
|
|
{ "GetUInt64", &LuaQuery::GetUInt64 },
|
|
{ "GetInt8", &LuaQuery::GetInt8 },
|
|
{ "GetInt16", &LuaQuery::GetInt16 },
|
|
{ "GetInt32", &LuaQuery::GetInt32 },
|
|
{ "GetInt64", &LuaQuery::GetInt64 },
|
|
{ "GetFloat", &LuaQuery::GetFloat },
|
|
{ "GetDouble", &LuaQuery::GetDouble },
|
|
{ "GetString", &LuaQuery::GetString },
|
|
|
|
// Boolean
|
|
{ "NextRow", &LuaQuery::NextRow },
|
|
{ "IsNull", &LuaQuery::IsNull },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<WorldPacket> PacketMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetOpcode", &LuaPacket::GetOpcode },
|
|
{ "GetSize", &LuaPacket::GetSize },
|
|
|
|
// Setters
|
|
{ "SetOpcode", &LuaPacket::SetOpcode },
|
|
|
|
// Readers
|
|
{ "ReadByte", &LuaPacket::ReadByte },
|
|
{ "ReadUByte", &LuaPacket::ReadUByte },
|
|
{ "ReadShort", &LuaPacket::ReadShort },
|
|
{ "ReadUShort", &LuaPacket::ReadUShort },
|
|
{ "ReadLong", &LuaPacket::ReadLong },
|
|
{ "ReadULong", &LuaPacket::ReadULong },
|
|
{ "ReadGUID", &LuaPacket::ReadGUID },
|
|
{ "ReadPackedGUID", &LuaPacket::ReadPackedGUID },
|
|
{ "ReadString", &LuaPacket::ReadString },
|
|
{ "ReadFloat", &LuaPacket::ReadFloat },
|
|
{ "ReadDouble", &LuaPacket::ReadDouble },
|
|
|
|
// Writers
|
|
{ "WriteByte", &LuaPacket::WriteByte },
|
|
{ "WriteUByte", &LuaPacket::WriteUByte },
|
|
{ "WriteShort", &LuaPacket::WriteShort },
|
|
{ "WriteUShort", &LuaPacket::WriteUShort },
|
|
{ "WriteLong", &LuaPacket::WriteLong },
|
|
{ "WriteULong", &LuaPacket::WriteULong },
|
|
{ "WriteGUID", &LuaPacket::WriteGUID },
|
|
{ "WritePackedGUID", &LuaPacket::WritePackedGUID },
|
|
{ "WriteString", &LuaPacket::WriteString },
|
|
{ "WriteFloat", &LuaPacket::WriteFloat },
|
|
{ "WriteDouble", &LuaPacket::WriteDouble },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Map> MapMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetName", &LuaMap::GetName },
|
|
{ "GetDifficulty", &LuaMap::GetDifficulty },
|
|
{ "GetInstanceId", &LuaMap::GetInstanceId },
|
|
{ "GetInstanceData", &LuaMap::GetInstanceData },
|
|
{ "GetPlayerCount", &LuaMap::GetPlayerCount },
|
|
{ "GetPlayers", &LuaMap::GetPlayers },
|
|
{ "GetMapId", &LuaMap::GetMapId },
|
|
{ "GetAreaId", &LuaMap::GetAreaId },
|
|
{ "GetHeight", &LuaMap::GetHeight },
|
|
{ "GetWorldObject", &LuaMap::GetWorldObject },
|
|
{ "GetCreatures", &LuaMap::GetCreatures },
|
|
{ "GetCreaturesByAreaId", &LuaMap::GetCreaturesByAreaId },
|
|
{ "GetTransports", &LuaMap::GetTransports },
|
|
|
|
|
|
// Setters
|
|
{ "SetWeather", &LuaMap::SetWeather },
|
|
|
|
// Boolean
|
|
{ "IsArena", &LuaMap::IsArena },
|
|
{ "IsBattleground", &LuaMap::IsBattleground },
|
|
{ "IsDungeon", &LuaMap::IsDungeon },
|
|
{ "IsEmpty", &LuaMap::IsEmpty },
|
|
{ "IsHeroic", &LuaMap::IsHeroic },
|
|
{ "IsRaid", &LuaMap::IsRaid },
|
|
|
|
// Other
|
|
{ "SaveInstanceData", &LuaMap::SaveInstanceData },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Corpse> CorpseMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetOwnerGUID", &LuaCorpse::GetOwnerGUID },
|
|
{ "GetGhostTime", &LuaCorpse::GetGhostTime },
|
|
{ "GetType", &LuaCorpse::GetType },
|
|
|
|
// Other
|
|
{ "ResetGhostTime", &LuaCorpse::ResetGhostTime },
|
|
{ "SaveToDB", &LuaCorpse::SaveToDB },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<AuctionHouseEntry> AuctionMethods[] =
|
|
{
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<BattleGround> BattleGroundMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetName", &LuaBattleGround::GetName },
|
|
{ "GetAlivePlayersCountByTeam", &LuaBattleGround::GetAlivePlayersCountByTeam },
|
|
{ "GetMap", &LuaBattleGround::GetMap },
|
|
{ "GetBonusHonorFromKillCount", &LuaBattleGround::GetBonusHonorFromKillCount },
|
|
{ "GetEndTime", &LuaBattleGround::GetEndTime },
|
|
{ "GetFreeSlotsForTeam", &LuaBattleGround::GetFreeSlotsForTeam },
|
|
{ "GetInstanceId", &LuaBattleGround::GetInstanceId },
|
|
{ "GetMapId", &LuaBattleGround::GetMapId },
|
|
{ "GetTypeId", &LuaBattleGround::GetTypeId },
|
|
{ "GetMaxLevel", &LuaBattleGround::GetMaxLevel },
|
|
{ "GetMinLevel", &LuaBattleGround::GetMinLevel },
|
|
{ "GetMaxPlayers", &LuaBattleGround::GetMaxPlayers },
|
|
{ "GetMinPlayers", &LuaBattleGround::GetMinPlayers },
|
|
{ "GetMaxPlayersPerTeam", &LuaBattleGround::GetMaxPlayersPerTeam },
|
|
{ "GetMinPlayersPerTeam", &LuaBattleGround::GetMinPlayersPerTeam },
|
|
{ "GetWinner", &LuaBattleGround::GetWinner },
|
|
{ "GetStatus", &LuaBattleGround::GetStatus },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<ChatHandler> ChatHandlerMethods[] =
|
|
{
|
|
{ "SendSysMessage", &LuaChatHandler::SendSysMessage },
|
|
{ "IsConsole", &LuaChatHandler::IsConsole },
|
|
{ "GetPlayer", &LuaChatHandler::GetPlayer },
|
|
{ "SendGlobalSysMessage", &LuaChatHandler::SendGlobalSysMessage },
|
|
{ "SendGlobalGMSysMessage", &LuaChatHandler::SendGlobalGMSysMessage },
|
|
{ "HasLowerSecurity", &LuaChatHandler::HasLowerSecurity },
|
|
{ "HasLowerSecurityAccount", &LuaChatHandler::HasLowerSecurityAccount },
|
|
{ "GetSelectedPlayer", &LuaChatHandler::GetSelectedPlayer },
|
|
{ "GetSelectedCreature", &LuaChatHandler::GetSelectedCreature },
|
|
{ "GetSelectedUnit", &LuaChatHandler::GetSelectedUnit },
|
|
{ "GetSelectedObject", &LuaChatHandler::GetSelectedObject },
|
|
{ "GetSelectedPlayerOrSelf", &LuaChatHandler::GetSelectedPlayerOrSelf },
|
|
{ "IsAvailable", &LuaChatHandler::IsAvailable },
|
|
{ "HasSentErrorMessage", &LuaChatHandler::HasSentErrorMessage },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<AchievementEntry> AchievementMethods[] =
|
|
{
|
|
{ "GetId", &LuaAchievement::GetId },
|
|
{ "GetName", &LuaAchievement::GetName },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Roll> RollMethods[] =
|
|
{
|
|
{ "GetItemGUID", &LuaRoll::GetItemGUID },
|
|
{ "GetItemId", &LuaRoll::GetItemId },
|
|
{ "GetItemRandomPropId", &LuaRoll::GetItemRandomPropId },
|
|
{ "GetItemRandomSuffix", &LuaRoll::GetItemRandomSuffix },
|
|
{ "GetItemCount", &LuaRoll::GetItemCount },
|
|
{ "GetPlayerVote", &LuaRoll::GetPlayerVote },
|
|
{ "GetPlayerVoteGUIDs", &LuaRoll::GetPlayerVoteGUIDs },
|
|
{ "GetTotalPlayersRolling", &LuaRoll::GetTotalPlayersRolling },
|
|
{ "GetTotalNeed", &LuaRoll::GetTotalNeed },
|
|
{ "GetTotalGreed", &LuaRoll::GetTotalGreed },
|
|
{ "GetTotalPass", &LuaRoll::GetTotalPass },
|
|
{ "GetItemSlot", &LuaRoll::GetItemSlot },
|
|
{ "GetRollVoteMask", &LuaRoll::GetRollVoteMask },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<GmTicket> TicketMethods[] =
|
|
{
|
|
{ "IsClosed", &LuaTicket::IsClosed },
|
|
{ "IsCompleted", &LuaTicket::IsCompleted },
|
|
{ "IsFromPlayer", &LuaTicket::IsFromPlayer },
|
|
{ "IsAssigned", &LuaTicket::IsAssigned },
|
|
{ "IsAssignedTo", &LuaTicket::IsAssignedTo },
|
|
{ "IsAssignedNotTo", &LuaTicket::IsAssignedNotTo },
|
|
|
|
{ "GetId", &LuaTicket::GetId },
|
|
{ "GetPlayer", &LuaTicket::GetPlayer },
|
|
{ "GetPlayerName", &LuaTicket::GetPlayerName },
|
|
{ "GetMessage", &LuaTicket::GetMessage },
|
|
{ "GetAssignedPlayer", &LuaTicket::GetAssignedPlayer },
|
|
{ "GetAssignedToGUID", &LuaTicket::GetAssignedToGUID },
|
|
{ "GetLastModifiedTime", &LuaTicket::GetLastModifiedTime },
|
|
{ "GetResponse", &LuaTicket::GetResponse },
|
|
{ "GetChatLog", &LuaTicket::GetChatLog },
|
|
|
|
{ "SetAssignedTo", &LuaTicket::SetAssignedTo },
|
|
{ "SetResolvedBy", &LuaTicket::SetResolvedBy },
|
|
{ "SetCompleted", &LuaTicket::SetCompleted },
|
|
{ "SetMessage", &LuaTicket::SetMessage },
|
|
{ "SetComment", &LuaTicket::SetComment },
|
|
{ "SetViewed", &LuaTicket::SetViewed },
|
|
{ "SetUnassigned", &LuaTicket::SetUnassigned },
|
|
{ "SetPosition", &LuaTicket::SetPosition },
|
|
{ "AppendResponse", &LuaTicket::AppendResponse },
|
|
{ "DeleteResponse", &LuaTicket::DeleteResponse },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<SpellInfo> SpellInfoMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetAttributes", &LuaSpellInfo::GetAttributes },
|
|
{ "GetCategory", &LuaSpellInfo::GetCategory },
|
|
{ "GetName", &LuaSpellInfo::GetName },
|
|
{ "CheckShapeshift", &LuaSpellInfo::CheckShapeshift },
|
|
{ "CheckLocation", &LuaSpellInfo::CheckLocation },
|
|
{ "CheckTarget", &LuaSpellInfo::CheckTarget },
|
|
{ "CheckExplicitTarget", &LuaSpellInfo::CheckExplicitTarget },
|
|
{ "CheckTargetCreatureType", &LuaSpellInfo::CheckTargetCreatureType },
|
|
{ "CheckTargetCreatureType", &LuaSpellInfo::CheckTargetCreatureType },
|
|
{ "GetSchoolMask", &LuaSpellInfo::GetSchoolMask },
|
|
{ "GetAllEffectsMechanicMask", &LuaSpellInfo::GetAllEffectsMechanicMask },
|
|
{ "GetEffectMechanicMask", &LuaSpellInfo::GetEffectMechanicMask },
|
|
{ "GetSpellMechanicMaskByEffectMask", &LuaSpellInfo::GetSpellMechanicMaskByEffectMask },
|
|
{ "GetEffectMechanic", &LuaSpellInfo::GetEffectMechanic },
|
|
{ "GetDispelMask", &LuaSpellInfo::GetDispelMask },
|
|
{ "GetExplicitTargetMask", &LuaSpellInfo::GetExplicitTargetMask },
|
|
{ "GetAuraState", &LuaSpellInfo::GetAuraState },
|
|
{ "GetSpellSpecific", &LuaSpellInfo::GetSpellSpecific },
|
|
{ "GetEffectMiscValueA", &LuaSpellInfo::GetEffectMiscValueA },
|
|
{ "GetEffectMiscValueB", &LuaSpellInfo::GetEffectMiscValueB },
|
|
|
|
// Setters
|
|
|
|
// Boolean
|
|
{ "HasAreaAuraEffect", &LuaSpellInfo::HasAreaAuraEffect },
|
|
{ "HasAttribute", &LuaSpellInfo::HasAttribute },
|
|
{ "HasAura", &LuaSpellInfo::HasAura },
|
|
{ "HasEffect", &LuaSpellInfo::HasEffect },
|
|
|
|
{ "IsAbilityLearnedWithProfession", &LuaSpellInfo::IsAbilityLearnedWithProfession },
|
|
{ "IsAbilityOfSkillType", &LuaSpellInfo::IsAbilityOfSkillType },
|
|
{ "IsAffectingArea", &LuaSpellInfo::IsAffectingArea },
|
|
{ "IsAllowingDeadTarget", &LuaSpellInfo::IsAllowingDeadTarget },
|
|
{ "IsAutocastable", &LuaSpellInfo::IsAutocastable },
|
|
{ "IsAutoRepeatRangedSpell", &LuaSpellInfo::IsAutoRepeatRangedSpell },
|
|
{ "IsBreakingStealth", &LuaSpellInfo::IsBreakingStealth },
|
|
{ "IsChanneled", &LuaSpellInfo::IsChanneled },
|
|
{ "IsCooldownStartedOnEvent", &LuaSpellInfo::IsCooldownStartedOnEvent },
|
|
{ "IsDeathPersistent", &LuaSpellInfo::IsDeathPersistent },
|
|
{ "IsExplicitDiscovery", &LuaSpellInfo::IsExplicitDiscovery },
|
|
{ "IsLootCrafting", &LuaSpellInfo::IsLootCrafting },
|
|
{ "IsMultiSlotAura", &LuaSpellInfo::IsMultiSlotAura },
|
|
{ "IsPassive", &LuaSpellInfo::IsPassive },
|
|
{ "IsPassiveStackableWithRanks", &LuaSpellInfo::IsPassiveStackableWithRanks },
|
|
{ "IsPositive", &LuaSpellInfo::IsPositive },
|
|
{ "IsPositiveEffect", &LuaSpellInfo::IsPositiveEffect },
|
|
{ "IsPrimaryProfession", &LuaSpellInfo::IsPrimaryProfession },
|
|
{ "IsPrimaryProfessionFirstRank", &LuaSpellInfo::IsPrimaryProfessionFirstRank },
|
|
{ "IsProfession", &LuaSpellInfo::IsProfession },
|
|
{ "IsProfessionOrRiding", &LuaSpellInfo::IsProfessionOrRiding },
|
|
{ "IsRangedWeaponSpell", &LuaSpellInfo::IsRangedWeaponSpell },
|
|
{ "IsRequiringDeadTarget", &LuaSpellInfo::IsRequiringDeadTarget },
|
|
{ "IsStackableWithRanks", &LuaSpellInfo::IsStackableWithRanks },
|
|
{ "IsTargetingArea", &LuaSpellInfo::IsTargetingArea },
|
|
{ "IsAffectedBySpellMods", &LuaSpellInfo::IsAffectedBySpellMods },
|
|
/* { "IsAffectedBySpellMod", &LuaSpellInfo::IsAffectedBySpellMod }, */
|
|
{ "CanPierceImmuneAura", &LuaSpellInfo::CanPierceImmuneAura },
|
|
{ "CanDispelAura", &LuaSpellInfo::CanDispelAura },
|
|
{ "IsSingleTarget", &LuaSpellInfo::IsSingleTarget },
|
|
{ "IsAuraExclusiveBySpecificWith", &LuaSpellInfo::IsAuraExclusiveBySpecificWith },
|
|
{ "IsAuraExclusiveBySpecificPerCasterWith", &LuaSpellInfo::IsAuraExclusiveBySpecificPerCasterWith },
|
|
{ "CanBeUsedInCombat", &LuaSpellInfo::CanBeUsedInCombat },
|
|
|
|
{ "NeedsComboPoints", &LuaSpellInfo::NeedsComboPoints },
|
|
{ "NeedsExplicitUnitTarget", &LuaSpellInfo::NeedsExplicitUnitTarget },
|
|
{ "NeedsToBeTriggeredByCaster", &LuaSpellInfo::NeedsToBeTriggeredByCaster },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<GemPropertiesEntry> GemPropertiesEntryMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetId", &LuaGemPropertiesEntry::GetId },
|
|
{ "GetSpellItemEnchantement", &LuaGemPropertiesEntry::GetSpellItemEnchantement },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<SpellEntry> SpellEntryMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetId", &LuaSpellEntry::GetId },
|
|
{ "GetCategory", &LuaSpellEntry::GetCategory },
|
|
{ "GetDispel", &LuaSpellEntry::GetDispel },
|
|
{ "GetMechanic", &LuaSpellEntry::GetMechanic },
|
|
{ "GetAttributes", &LuaSpellEntry::GetAttributes },
|
|
{ "GetAttributesEx", &LuaSpellEntry::GetAttributesEx },
|
|
{ "GetAttributesEx2", &LuaSpellEntry::GetAttributesEx2 },
|
|
{ "GetAttributesEx3", &LuaSpellEntry::GetAttributesEx3 },
|
|
{ "GetAttributesEx4", &LuaSpellEntry::GetAttributesEx4 },
|
|
{ "GetAttributesEx5", &LuaSpellEntry::GetAttributesEx5 },
|
|
{ "GetAttributesEx6", &LuaSpellEntry::GetAttributesEx6 },
|
|
{ "GetAttributesEx7", &LuaSpellEntry::GetAttributesEx7 },
|
|
{ "GetStances", &LuaSpellEntry::GetStances },
|
|
{ "GetStancesNot", &LuaSpellEntry::GetStancesNot },
|
|
{ "GetTargets", &LuaSpellEntry::GetTargets },
|
|
{ "GetTargetCreatureType", &LuaSpellEntry::GetTargetCreatureType },
|
|
{ "GetRequiresSpellFocus", &LuaSpellEntry::GetRequiresSpellFocus },
|
|
{ "GetFacingCasterFlags", &LuaSpellEntry::GetFacingCasterFlags },
|
|
{ "GetCasterAuraState", &LuaSpellEntry::GetCasterAuraState },
|
|
{ "GetTargetAuraState", &LuaSpellEntry::GetTargetAuraState },
|
|
{ "GetCasterAuraStateNot", &LuaSpellEntry::GetCasterAuraStateNot },
|
|
{ "GetTargetAuraStateNot", &LuaSpellEntry::GetTargetAuraStateNot },
|
|
{ "GetCasterAuraSpell", &LuaSpellEntry::GetCasterAuraSpell },
|
|
{ "GetTargetAuraSpell", &LuaSpellEntry::GetTargetAuraSpell },
|
|
{ "GetExcludeCasterAuraSpell", &LuaSpellEntry::GetExcludeCasterAuraSpell },
|
|
{ "GetExcludeTargetAuraSpell", &LuaSpellEntry::GetExcludeTargetAuraSpell },
|
|
{ "GetCastingTimeIndex", &LuaSpellEntry::GetCastingTimeIndex },
|
|
{ "GetRecoveryTime", &LuaSpellEntry::GetRecoveryTime },
|
|
{ "GetCategoryRecoveryTime", &LuaSpellEntry::GetCategoryRecoveryTime },
|
|
{ "GetInterruptFlags", &LuaSpellEntry::GetInterruptFlags },
|
|
{ "GetAuraInterruptFlags", &LuaSpellEntry::GetAuraInterruptFlags },
|
|
{ "GetChannelInterruptFlags", &LuaSpellEntry::GetChannelInterruptFlags },
|
|
{ "GetProcFlags", &LuaSpellEntry::GetProcFlags },
|
|
{ "GetProcChance", &LuaSpellEntry::GetProcChance },
|
|
{ "GetProcCharges", &LuaSpellEntry::GetProcCharges },
|
|
{ "GetMaxLevel", &LuaSpellEntry::GetMaxLevel },
|
|
{ "GetBaseLevel", &LuaSpellEntry::GetBaseLevel },
|
|
{ "GetSpellLevel", &LuaSpellEntry::GetSpellLevel },
|
|
{ "GetDurationIndex", &LuaSpellEntry::GetDurationIndex },
|
|
{ "GetPowerType", &LuaSpellEntry::GetPowerType },
|
|
{ "GetManaCost", &LuaSpellEntry::GetManaCost },
|
|
{ "GetManaCostPerlevel", &LuaSpellEntry::GetManaCostPerlevel },
|
|
{ "GetManaPerSecond", &LuaSpellEntry::GetManaPerSecond },
|
|
{ "GetManaPerSecondPerLevel", &LuaSpellEntry::GetManaPerSecondPerLevel },
|
|
{ "GetRangeIndex", &LuaSpellEntry::GetRangeIndex },
|
|
{ "GetSpeed", &LuaSpellEntry::GetSpeed },
|
|
{ "GetStackAmount", &LuaSpellEntry::GetStackAmount },
|
|
{ "GetTotem", &LuaSpellEntry::GetTotem },
|
|
{ "GetReagent", &LuaSpellEntry::GetReagent },
|
|
{ "GetReagentCount", &LuaSpellEntry::GetReagentCount },
|
|
{ "GetEquippedItemClass", &LuaSpellEntry::GetEquippedItemClass },
|
|
{ "GetEquippedItemSubClassMask", &LuaSpellEntry::GetEquippedItemSubClassMask },
|
|
{ "GetEquippedItemInventoryTypeMask", &LuaSpellEntry::GetEquippedItemInventoryTypeMask },
|
|
{ "GetEffect", &LuaSpellEntry::GetEffect },
|
|
{ "GetEffectDieSides", &LuaSpellEntry::GetEffectDieSides },
|
|
{ "GetEffectRealPointsPerLevel", &LuaSpellEntry::GetEffectRealPointsPerLevel },
|
|
{ "GetEffectBasePoints", &LuaSpellEntry::GetEffectBasePoints },
|
|
{ "GetEffectMechanic", &LuaSpellEntry::GetEffectMechanic },
|
|
{ "GetEffectImplicitTargetA", &LuaSpellEntry::GetEffectImplicitTargetA },
|
|
{ "GetEffectImplicitTargetB", &LuaSpellEntry::GetEffectImplicitTargetB },
|
|
{ "GetEffectRadiusIndex", &LuaSpellEntry::GetEffectRadiusIndex },
|
|
{ "GetEffectApplyAuraName", &LuaSpellEntry::GetEffectApplyAuraName },
|
|
{ "GetEffectAmplitude", &LuaSpellEntry::GetEffectAmplitude },
|
|
{ "GetEffectValueMultiplier", &LuaSpellEntry::GetEffectValueMultiplier },
|
|
{ "GetEffectChainTarget", &LuaSpellEntry::GetEffectChainTarget },
|
|
{ "GetEffectItemType", &LuaSpellEntry::GetEffectItemType },
|
|
{ "GetEffectMiscValue", &LuaSpellEntry::GetEffectMiscValue },
|
|
{ "GetEffectMiscValueB", &LuaSpellEntry::GetEffectMiscValueB },
|
|
{ "GetEffectTriggerSpell", &LuaSpellEntry::GetEffectTriggerSpell },
|
|
{ "GetEffectPointsPerComboPoint", &LuaSpellEntry::GetEffectPointsPerComboPoint },
|
|
{ "GetEffectSpellClassMask", &LuaSpellEntry::GetEffectSpellClassMask },
|
|
{ "GetSpellVisual", &LuaSpellEntry::GetSpellVisual },
|
|
{ "GetSpellIconID", &LuaSpellEntry::GetSpellIconID },
|
|
{ "GetActiveIconID", &LuaSpellEntry::GetActiveIconID },
|
|
{ "GetSpellPriority", &LuaSpellEntry::GetSpellPriority },
|
|
{ "GetSpellName", &LuaSpellEntry::GetSpellName },
|
|
{ "GetRank", &LuaSpellEntry::GetRank },
|
|
{ "GetManaCostPercentage", &LuaSpellEntry::GetManaCostPercentage },
|
|
{ "GetStartRecoveryCategory", &LuaSpellEntry::GetStartRecoveryCategory },
|
|
{ "GetStartRecoveryTime", &LuaSpellEntry::GetStartRecoveryTime },
|
|
{ "GetMaxTargetLevel", &LuaSpellEntry::GetMaxTargetLevel },
|
|
{ "GetSpellFamilyName", &LuaSpellEntry::GetSpellFamilyName },
|
|
{ "GetSpellFamilyFlags", &LuaSpellEntry::GetSpellFamilyFlags },
|
|
{ "GetMaxAffectedTargets", &LuaSpellEntry::GetMaxAffectedTargets },
|
|
{ "GetDmgClass", &LuaSpellEntry::GetDmgClass },
|
|
{ "GetPreventionType", &LuaSpellEntry::GetPreventionType },
|
|
{ "GetEffectDamageMultiplier", &LuaSpellEntry::GetEffectDamageMultiplier },
|
|
{ "GetTotemCategory", &LuaSpellEntry::GetTotemCategory },
|
|
{ "GetAreaGroupId", &LuaSpellEntry::GetAreaGroupId },
|
|
{ "GetSchoolMask", &LuaSpellEntry::GetSchoolMask },
|
|
{ "GetRuneCostID", &LuaSpellEntry::GetRuneCostID },
|
|
{ "GetEffectBonusMultiplier", &LuaSpellEntry::GetEffectBonusMultiplier },
|
|
|
|
// Setters
|
|
{ "SetCategory", &LuaSpellEntry::SetCategory },
|
|
{ "SetDispel", &LuaSpellEntry::SetDispel },
|
|
{ "SetMechanic", &LuaSpellEntry::SetMechanic },
|
|
{ "SetAttributes", &LuaSpellEntry::SetAttributes },
|
|
{ "SetAttributesEx", &LuaSpellEntry::SetAttributesEx },
|
|
{ "SetAttributesEx2", &LuaSpellEntry::SetAttributesEx2 },
|
|
{ "SetAttributesEx3", &LuaSpellEntry::SetAttributesEx3 },
|
|
{ "SetAttributesEx4", &LuaSpellEntry::SetAttributesEx4 },
|
|
{ "SetAttributesEx5", &LuaSpellEntry::SetAttributesEx5 },
|
|
{ "SetAttributesEx6", &LuaSpellEntry::SetAttributesEx6 },
|
|
{ "SetAttributesEx7", &LuaSpellEntry::SetAttributesEx7 },
|
|
{ "SetStances", &LuaSpellEntry::SetStances },
|
|
{ "SetStancesNot", &LuaSpellEntry::SetStancesNot },
|
|
{ "SetTargets", &LuaSpellEntry::SetTargets },
|
|
{ "SetTargetCreatureType", &LuaSpellEntry::SetTargetCreatureType },
|
|
{ "SetRequiresSpellFocus", &LuaSpellEntry::SetRequiresSpellFocus },
|
|
{ "SetFacingCasterFlags", &LuaSpellEntry::SetFacingCasterFlags },
|
|
{ "SetCasterAuraState", &LuaSpellEntry::SetCasterAuraState },
|
|
{ "SetTargetAuraState", &LuaSpellEntry::SetTargetAuraState },
|
|
{ "SetCasterAuraStateNot", &LuaSpellEntry::SetCasterAuraStateNot },
|
|
{ "SetTargetAuraStateNot", &LuaSpellEntry::SetTargetAuraStateNot },
|
|
{ "SetCasterAuraSpell", &LuaSpellEntry::SetCasterAuraSpell },
|
|
{ "SetTargetAuraSpell", &LuaSpellEntry::SetTargetAuraSpell },
|
|
{ "SetExcludeCasterAuraSpell", &LuaSpellEntry::SetExcludeCasterAuraSpell },
|
|
{ "SetExcludeTargetAuraSpell", &LuaSpellEntry::SetExcludeTargetAuraSpell },
|
|
{ "SetRecoveryTime", &LuaSpellEntry::SetRecoveryTime },
|
|
{ "SetCategoryRecoveryTime", &LuaSpellEntry::SetCategoryRecoveryTime },
|
|
{ "SetInterruptFlags", &LuaSpellEntry::SetInterruptFlags },
|
|
{ "SetAuraInterruptFlags", &LuaSpellEntry::SetAuraInterruptFlags },
|
|
{ "SetChannelInterruptFlags", &LuaSpellEntry::SetChannelInterruptFlags },
|
|
{ "SetProcFlags", &LuaSpellEntry::SetProcFlags },
|
|
{ "SetProcChance", &LuaSpellEntry::SetProcChance },
|
|
{ "SetProcCharges", &LuaSpellEntry::SetProcCharges },
|
|
{ "SetMaxLevel", &LuaSpellEntry::SetMaxLevel },
|
|
{ "SetBaseLevel", &LuaSpellEntry::SetBaseLevel },
|
|
{ "SetSpellLevel", &LuaSpellEntry::SetSpellLevel },
|
|
{ "SetPowerType", &LuaSpellEntry::SetPowerType },
|
|
{ "SetManaCost", &LuaSpellEntry::SetManaCost },
|
|
{ "SetManaCostPerlevel", &LuaSpellEntry::SetManaCostPerlevel },
|
|
{ "SetManaPerSecond", &LuaSpellEntry::SetManaPerSecond },
|
|
{ "SetManaPerSecondPerLevel", &LuaSpellEntry::SetManaPerSecondPerLevel },
|
|
{ "SetSpeed", &LuaSpellEntry::SetSpeed },
|
|
{ "SetStackAmount", &LuaSpellEntry::SetStackAmount },
|
|
{ "SetEquippedItemClass", &LuaSpellEntry::SetEquippedItemClass },
|
|
{ "SetEquippedItemSubClassMask", &LuaSpellEntry::SetEquippedItemSubClassMask },
|
|
{ "SetEquippedItemInventoryTypeMask", &LuaSpellEntry::SetEquippedItemInventoryTypeMask },
|
|
{ "SetSpellIconID", &LuaSpellEntry::SetSpellIconID },
|
|
{ "SetActiveIconID", &LuaSpellEntry::SetActiveIconID },
|
|
{ "SetSpellPriority", &LuaSpellEntry::SetSpellPriority },
|
|
{ "SetManaCostPercentage", &LuaSpellEntry::SetManaCostPercentage },
|
|
{ "SetStartRecoveryCategory", &LuaSpellEntry::SetStartRecoveryCategory },
|
|
{ "SetStartRecoveryTime", &LuaSpellEntry::SetStartRecoveryTime },
|
|
{ "SetMaxTargetLevel", &LuaSpellEntry::SetMaxTargetLevel },
|
|
{ "SetSpellFamilyName", &LuaSpellEntry::SetSpellFamilyName },
|
|
{ "SetMaxAffectedTargets", &LuaSpellEntry::SetMaxAffectedTargets },
|
|
{ "SetDmgClass", &LuaSpellEntry::SetDmgClass },
|
|
{ "SetPreventionType", &LuaSpellEntry::SetPreventionType },
|
|
{ "SetSchoolMask", &LuaSpellEntry::SetSchoolMask },
|
|
{ "SetRuneCostID", &LuaSpellEntry::SetRuneCostID },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Pet> PetMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetPetType", &LuaPet::GetPetType },
|
|
{ "GetDuration", &LuaPet::GetDuration },
|
|
{ "GetHappinessState", &LuaPet::GetHappinessState },
|
|
{ "GetCurrentFoodBenefitLevel", &LuaPet::GetCurrentFoodBenefitLevel },
|
|
{ "GetMaxTalentPointsForLevel", &LuaPet::GetMaxTalentPointsForLevel },
|
|
{ "GetFreeTalentPoints", &LuaPet::GetFreeTalentPoints },
|
|
{ "GetUsedTalentCount", &LuaPet::GetUsedTalentCount },
|
|
{ "GetAuraUpdateMaskForRaid", &LuaPet::GetAuraUpdateMaskForRaid },
|
|
{ "GetOwner", &LuaPet::GetOwner },
|
|
{ "GetPetAutoSpellSize", &LuaPet::GetPetAutoSpellSize },
|
|
{ "GetPetAutoSpellOnPos", &LuaPet::GetPetAutoSpellOnPos },
|
|
|
|
// Setters
|
|
{ "SetPetType", &LuaPet::SetPetType },
|
|
{ "SetDuration", &LuaPet::SetDuration },
|
|
{ "SetFreeTalentPoints", &LuaPet::SetFreeTalentPoints },
|
|
{ "SetUsedTalentCount", &LuaPet::SetUsedTalentCount },
|
|
{ "SetAuraUpdateMaskForRaid", &LuaPet::SetAuraUpdateMaskForRaid },
|
|
{ "SetRemoved", &LuaPet::SetRemoved },
|
|
|
|
// Boolean
|
|
{ "IsControlled", &LuaPet::IsControlled },
|
|
{ "IsTemporarySummoned", &LuaPet::IsTemporarySummoned },
|
|
{ "IsPermanentPetFor", &LuaPet::IsPermanentPetFor },
|
|
{ "HaveInDiet", &LuaPet::HaveInDiet },
|
|
{ "HasTempSpell", &LuaPet::HasTempSpell },
|
|
{ "IsRemoved", &LuaPet::IsRemoved },
|
|
{ "IsBeingLoaded", &LuaPet::IsBeingLoaded },
|
|
|
|
// Other
|
|
{ "CreateBaseAtCreature", &LuaPet::CreateBaseAtCreature },
|
|
{ "GivePetXP", &LuaPet::GivePetXP },
|
|
{ "GivePetLevel", &LuaPet::GivePetLevel },
|
|
{ "SynchronizeLevelWithOwner", &LuaPet::SynchronizeLevelWithOwner },
|
|
{ "ToggleAutocast", &LuaPet::ToggleAutocast },
|
|
{ "LearnPetPassives", &LuaPet::LearnPetPassives },
|
|
{ "CastWhenWillAvailable", &LuaPet::CastWhenWillAvailable },
|
|
{ "ClearCastWhenWillAvailable", &LuaPet::ClearCastWhenWillAvailable },
|
|
{ "AddSpell", &LuaPet::AddSpell },
|
|
{ "LearnSpell", &LuaPet::LearnSpell },
|
|
{ "LearnSpellHighRank", &LuaPet::LearnSpellHighRank },
|
|
{ "InitLevelupSpellsForLevel", &LuaPet::InitLevelupSpellsForLevel },
|
|
{ "UnlearnSpell", &LuaPet::UnlearnSpell },
|
|
{ "RemoveSpell", &LuaPet::RemoveSpell },
|
|
{ "CleanupActionBar", &LuaPet::CleanupActionBar },
|
|
{ "GenerateActionBarData", &LuaPet::GenerateActionBarData },
|
|
{ "InitPetCreateSpells", &LuaPet::InitPetCreateSpells },
|
|
{ "ResetTalents", &LuaPet::ResetTalents },
|
|
{ "InitTalentForLevel", &LuaPet::InitTalentForLevel },
|
|
{ "ResetAuraUpdateMaskForRaid", &LuaPet::ResetAuraUpdateMaskForRaid },
|
|
{ "SavePetToDB", &LuaPet::SavePetToDB },
|
|
{ "Remove", &LuaPet::Remove },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Loot> LootMethods[] =
|
|
{
|
|
// Get
|
|
{ "GetMoney", &LuaLoot::GetMoney },
|
|
{ "GetItems", &LuaLoot::GetItems },
|
|
{ "GetQuestItems", &LuaLoot::GetQuestItems },
|
|
{ "GetUnlootedCount", &LuaLoot::GetUnlootedCount },
|
|
{ "GetLootType", &LuaLoot::GetLootType },
|
|
{ "GetRoundRobinPlayer", &LuaLoot::GetRoundRobinPlayer },
|
|
{ "GetLootOwner", &LuaLoot::GetLootOwner },
|
|
{ "GetContainer", &LuaLoot::GetContainer },
|
|
{ "GetSourceWorldObject", &LuaLoot::GetSourceWorldObject },
|
|
{ "GetItemCount", &LuaLoot::GetItemCount },
|
|
{ "GetMaxSlotForPlayer", &LuaLoot::GetMaxSlotForPlayer },
|
|
|
|
// Set
|
|
{ "AddItem", &LuaLoot::AddItem },
|
|
{ "RemoveItem", &LuaLoot::RemoveItem },
|
|
{ "SetMoney", &LuaLoot::SetMoney },
|
|
{ "SetUnlootedCount", &LuaLoot::SetUnlootedCount },
|
|
{ "UpdateItemIndex", &LuaLoot::UpdateItemIndex },
|
|
{ "SetItemLooted", &LuaLoot::SetItemLooted },
|
|
{ "SetLootType", &LuaLoot::SetLootType },
|
|
{ "SetRoundRobinPlayer", &LuaLoot::SetRoundRobinPlayer },
|
|
{ "SetLootOwner", &LuaLoot::SetLootOwner },
|
|
{ "SetContainer", &LuaLoot::SetContainer },
|
|
{ "SetSourceWorldObject", &LuaLoot::SetSourceWorldObject },
|
|
{ "Clear", &LuaLoot::Clear },
|
|
{ "AddLooter", &LuaLoot::AddLooter },
|
|
{ "RemoveLooter", &LuaLoot::RemoveLooter },
|
|
|
|
// Boolean
|
|
{ "HasItem", &LuaLoot::HasItem },
|
|
{ "HasQuestItems", &LuaLoot::HasQuestItems },
|
|
{ "HasItemForAll", &LuaLoot::HasItemForAll },
|
|
{ "HasOverThresholdItem", &LuaLoot::HasOverThresholdItem },
|
|
{ "IsLooted", &LuaLoot::IsLooted },
|
|
{ "IsEmpty", &LuaLoot::IsEmpty },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
ALERegister<Transport> TransportMethods[] =
|
|
{
|
|
// Getters
|
|
{ "GetPassengers", &LuaTransport::GetPassengers },
|
|
|
|
// Boolean
|
|
{ "IsMotionTransport", &LuaTransport::IsMotionTransport },
|
|
|
|
// Other
|
|
{ "AddPassenger", &LuaTransport::AddPassenger },
|
|
{ "RemovePassenger", &LuaTransport::RemovePassenger },
|
|
{ "EnableMovement", &LuaTransport::EnableMovement },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
// fix compile error about accessing vehicle destructor
|
|
template<> int ALETemplate<Vehicle>::CollectGarbage(lua_State* L)
|
|
{
|
|
ASSERT(!manageMemory);
|
|
|
|
// Get object pointer (and check type, no error)
|
|
ALEObject* obj = ALE::CHECKOBJ<ALEObject>(L, 1, false);
|
|
delete obj;
|
|
return 0;
|
|
}
|
|
|
|
// Template by Mud from http://stackoverflow.com/questions/4484437/lua-integer-type/4485511#4485511
|
|
template<> int ALETemplate<unsigned long long>::Add(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) + ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Substract(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) - ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Multiply(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) * ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Divide(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) / ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Mod(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) % ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
// template<> int ALETemplate<unsigned long long>::UnaryMinus(lua_State* L) { ALE::Push(L, -ALE::CHECKVAL<unsigned long long>(L, 1)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Equal(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) == ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Less(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) < ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::LessOrEqual(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) <= ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<unsigned long long>::Pow(lua_State* L)
|
|
{
|
|
ALE::Push(L, static_cast<unsigned long long>(powl(static_cast<long double>(ALE::CHECKVAL<unsigned long long>(L, 1)), static_cast<long double>(ALE::CHECKVAL<unsigned long long>(L, 2)))));
|
|
return 1;
|
|
}
|
|
template<> int ALETemplate<unsigned long long>::ToString(lua_State* L)
|
|
{
|
|
unsigned long long l = ALE::CHECKVAL<unsigned long long>(L, 1);
|
|
std::ostringstream ss;
|
|
ss << l;
|
|
ALE::Push(L, ss.str());
|
|
return 1;
|
|
}
|
|
|
|
template<> int ALETemplate<long long>::Add(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) + ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::Substract(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) - ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::Multiply(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) * ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::Divide(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) / ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::Mod(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) % ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::UnaryMinus(lua_State* L) { ALE::Push(L, -ALE::CHECKVAL<long long>(L, 1)); return 1; }
|
|
template<> int ALETemplate<long long>::Equal(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) == ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::Less(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) < ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::LessOrEqual(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) <= ALE::CHECKVAL<long long>(L, 2)); return 1; }
|
|
template<> int ALETemplate<long long>::Pow(lua_State* L)
|
|
{
|
|
ALE::Push(L, static_cast<long long>(powl(static_cast<long double>(ALE::CHECKVAL<long long>(L, 1)), static_cast<long double>(ALE::CHECKVAL<long long>(L, 2)))));
|
|
return 1;
|
|
}
|
|
template<> int ALETemplate<long long>::ToString(lua_State* L)
|
|
{
|
|
long long l = ALE::CHECKVAL<long long>(L, 1);
|
|
std::ostringstream ss;
|
|
ss << l;
|
|
ALE::Push(L, ss.str());
|
|
return 1;
|
|
}
|
|
|
|
void RegisterFunctions(ALE* E)
|
|
{
|
|
ALEGlobal::SetMethods(E, GlobalMethods);
|
|
|
|
ALETemplate<Object>::Register(E, "Object");
|
|
ALETemplate<Object>::SetMethods(E, ObjectMethods);
|
|
|
|
ALETemplate<WorldObject>::Register(E, "WorldObject");
|
|
ALETemplate<WorldObject>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<WorldObject>::SetMethods(E, WorldObjectMethods);
|
|
|
|
ALETemplate<Unit>::Register(E, "Unit");
|
|
ALETemplate<Unit>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<Unit>::SetMethods(E, WorldObjectMethods);
|
|
ALETemplate<Unit>::SetMethods(E, UnitMethods);
|
|
|
|
ALETemplate<Player>::Register(E, "Player");
|
|
ALETemplate<Player>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<Player>::SetMethods(E, WorldObjectMethods);
|
|
ALETemplate<Player>::SetMethods(E, UnitMethods);
|
|
ALETemplate<Player>::SetMethods(E, PlayerMethods);
|
|
|
|
ALETemplate<Creature>::Register(E, "Creature");
|
|
ALETemplate<Creature>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<Creature>::SetMethods(E, WorldObjectMethods);
|
|
ALETemplate<Creature>::SetMethods(E, UnitMethods);
|
|
ALETemplate<Creature>::SetMethods(E, CreatureMethods);
|
|
|
|
ALETemplate<GameObject>::Register(E, "GameObject");
|
|
ALETemplate<GameObject>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<GameObject>::SetMethods(E, WorldObjectMethods);
|
|
ALETemplate<GameObject>::SetMethods(E, GameObjectMethods);
|
|
|
|
ALETemplate<Transport>::Register(E, "Transport");
|
|
ALETemplate<Transport>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<Transport>::SetMethods(E, WorldObjectMethods);
|
|
ALETemplate<Transport>::SetMethods(E, GameObjectMethods);
|
|
ALETemplate<Transport>::SetMethods(E, TransportMethods);
|
|
|
|
ALETemplate<Corpse>::Register(E, "Corpse");
|
|
ALETemplate<Corpse>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<Corpse>::SetMethods(E, WorldObjectMethods);
|
|
ALETemplate<Corpse>::SetMethods(E, CorpseMethods);
|
|
|
|
ALETemplate<Item>::Register(E, "Item");
|
|
ALETemplate<Item>::SetMethods(E, ObjectMethods);
|
|
ALETemplate<Item>::SetMethods(E, ItemMethods);
|
|
|
|
ALETemplate<ItemTemplate>::Register(E, "ItemTemplate");
|
|
ALETemplate<ItemTemplate>::SetMethods(E, ItemTemplateMethods);
|
|
|
|
ALETemplate<Vehicle>::Register(E, "Vehicle");
|
|
ALETemplate<Vehicle>::SetMethods(E, VehicleMethods);
|
|
|
|
ALETemplate<Group>::Register(E, "Group");
|
|
ALETemplate<Group>::SetMethods(E, GroupMethods);
|
|
|
|
ALETemplate<Guild>::Register(E, "Guild");
|
|
ALETemplate<Guild>::SetMethods(E, GuildMethods);
|
|
|
|
ALETemplate<Aura>::Register(E, "Aura");
|
|
ALETemplate<Aura>::SetMethods(E, AuraMethods);
|
|
|
|
ALETemplate<Spell>::Register(E, "Spell");
|
|
ALETemplate<Spell>::SetMethods(E, SpellMethods);
|
|
|
|
ALETemplate<Quest>::Register(E, "Quest");
|
|
ALETemplate<Quest>::SetMethods(E, QuestMethods);
|
|
|
|
ALETemplate<Map>::Register(E, "Map");
|
|
ALETemplate<Map>::SetMethods(E, MapMethods);
|
|
|
|
ALETemplate<AuctionHouseEntry>::Register(E, "AuctionHouseEntry");
|
|
ALETemplate<AuctionHouseEntry>::SetMethods(E, AuctionMethods);
|
|
|
|
ALETemplate<BattleGround>::Register(E, "BattleGround");
|
|
ALETemplate<BattleGround>::SetMethods(E, BattleGroundMethods);
|
|
|
|
ALETemplate<ChatHandler>::Register(E, "ChatHandler");
|
|
ALETemplate<ChatHandler>::SetMethods(E, ChatHandlerMethods);
|
|
|
|
ALETemplate<WorldPacket>::Register(E, "WorldPacket", true);
|
|
ALETemplate<WorldPacket>::SetMethods(E, PacketMethods);
|
|
|
|
ALETemplate<ALEQuery>::Register(E, "ALEQuery", true);
|
|
ALETemplate<ALEQuery>::SetMethods(E, QueryMethods);
|
|
|
|
ALETemplate<AchievementEntry>::Register(E, "AchievementEntry");
|
|
ALETemplate<AchievementEntry>::SetMethods(E, AchievementMethods);
|
|
|
|
ALETemplate<Roll>::Register(E, "Roll");
|
|
ALETemplate<Roll>::SetMethods(E, RollMethods);
|
|
|
|
ALETemplate<GmTicket>::Register(E, "Ticket");
|
|
ALETemplate<GmTicket>::SetMethods(E, TicketMethods);
|
|
|
|
ALETemplate<SpellInfo>::Register(E, "SpellInfo");
|
|
ALETemplate<SpellInfo>::SetMethods(E, SpellInfoMethods);
|
|
|
|
ALETemplate<GemPropertiesEntry>::Register(E, "GemPropertiesEntry");
|
|
ALETemplate<GemPropertiesEntry>::SetMethods(E, GemPropertiesEntryMethods);
|
|
|
|
ALETemplate<SpellEntry>::Register(E, "SpellEntry");
|
|
ALETemplate<SpellEntry>::SetMethods(E, SpellEntryMethods);
|
|
|
|
ALETemplate<CreatureTemplate>::Register(E, "CreatureTemplate");
|
|
|
|
ALETemplate<Loot>::Register(E, "Loot");
|
|
ALETemplate<Loot>::SetMethods(E, LootMethods);
|
|
|
|
ALETemplate<long long>::Register(E, "long long", true);
|
|
|
|
ALETemplate<unsigned long long>::Register(E, "unsigned long long", true);
|
|
}
|