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

Merge branch 'threading_rewrite' of https://github.com/ShinDarth/azerothcore-wotlk into threading_rewrite

Browse Source
This commit is contained in:
Yehonal
2016-08-19 23:54:55 +02:00
parent 8ee36c5f64 cb30a6b404
commit ee0ead5e4f
36 changed files with 751 additions and 781 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
src/game/Chat/Chat.cpp
View File

@@ -26,53 +26,16 @@
bool ChatHandler::load_command_table = true;
// get number of commands in table
static size_t getCommandTableSize(const ChatCommand* commands)
std::vector<ChatCommand> const& ChatHandler::getCommandTable()
{
if (!commands)
return 0;
size_t count = 0;
while (commands[count].Name != NULL)
count++;
return count;
}
// append source command table to target, return number of appended commands
static size_t appendCommandTable(ChatCommand* target, const ChatCommand* source)
{
const size_t count = getCommandTableSize(source);
if (count)
memcpy(target, source, count * sizeof(ChatCommand));
return count;
}
ChatCommand* ChatHandler::getCommandTable()
{
// cache for commands, needed because some commands are loaded dynamically through ScriptMgr
// cache is never freed and will show as a memory leak in diagnostic tools
// can't use vector as vector storage is implementation-dependent, eg, there can be alignment gaps between elements
static ChatCommand* commandTableCache = NULL;
static std::vector<ChatCommand> commandTableCache;
if (LoadCommandTable())
{
SetLoadCommandTable(false);
{
// count total number of top-level commands
size_t total = 0;
std::vector<ChatCommand*> const& dynamic = sScriptMgr->GetChatCommands();
for (std::vector<ChatCommand*>::const_iterator it = dynamic.begin(); it != dynamic.end(); ++it)
total += getCommandTableSize(*it);
total += 1; // ending zero
// cache top-level commands
size_t added = 0;
commandTableCache = (ChatCommand*)malloc(sizeof(ChatCommand) * total);
memset(commandTableCache, 0, sizeof(ChatCommand) * total);
ACE_ASSERT(commandTableCache);
for (std::vector<ChatCommand*>::const_iterator it = dynamic.begin(); it != dynamic.end(); ++it)
added += appendCommandTable(commandTableCache + added, *it);
}
std::vector<ChatCommand> cmds = sScriptMgr->GetChatCommands();
commandTableCache.swap(cmds);
PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS);
PreparedQueryResult result = WorldDatabase.Query(stmt);
@@ -268,7 +231,7 @@ void ChatHandler::PSendSysMessage(const char *format, ...)
SendSysMessage(str);
}
bool ChatHandler::ExecuteCommandInTable(ChatCommand* table, const char* text, std::string& fullcmd)
bool ChatHandler::ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd)
{
char const* oldtext = text;
std::string cmd = "";
@@ -281,7 +244,7 @@ bool ChatHandler::ExecuteCommandInTable(ChatCommand* table, const char* text, st
while (*text == ' ') ++text;
for (uint32 i = 0; table[i].Name != NULL; ++i)
for (uint32 i = 0; i < table.size(); ++i)
{
if (!hasStringAbbr(table[i].Name, cmd.c_str()))
continue;
@@ -289,7 +252,7 @@ bool ChatHandler::ExecuteCommandInTable(ChatCommand* table, const char* text, st
bool match = false;
if (strlen(table[i].Name) > cmd.length())
{
for (uint32 j = 0; table[j].Name != NULL; ++j)
for (uint32 j = 0; j < table.size(); ++j)
{
if (!hasStringAbbr(table[j].Name, cmd.c_str()))
continue;
@@ -306,14 +269,8 @@ bool ChatHandler::ExecuteCommandInTable(ChatCommand* table, const char* text, st
if (match)
continue;
if (table[i].Name[0] != '\0' && table[i].Name)
{
fullcmd += table[i].Name;
fullcmd += " ";
}
// select subcommand from child commands list
if (table[i].ChildCommands != NULL)
if (!table[i].ChildCommands.empty())
{
if (!ExecuteCommandInTable(table[i].ChildCommands, text, fullcmd))
{
@@ -334,28 +291,34 @@ bool ChatHandler::ExecuteCommandInTable(ChatCommand* table, const char* text, st
SetSentErrorMessage(false);
// table[i].Name == "" is special case: send original command to handler
const char* aText = table[i].Name[0] != '\0' ? text : oldtext;
if (aText)
fullcmd += aText;
if ((table[i].Handler)(this, aText))
if ((table[i].Handler)(this, table[i].Name[0] != '\0' ? text : oldtext))
{
// pussywizard: ignore logging spect command
std::string fc = fullcmd;
if (fc.size() >= 5)
std::transform(fc.begin(), fc.end(), fc.begin(), ::tolower);
bool ignore = fc.size() >= 5 && fc.substr(0,5) == "spect";
if (!m_session) // ignore console
return true;
if (!AccountMgr::IsPlayerAccount(table[i].SecurityLevel) && !ignore)
Player* player = m_session->GetPlayer();
if (!AccountMgr::IsPlayerAccount(m_session->GetSecurity()))
{
// chat case
if (m_session)
uint64 guid = player->GetTarget();
uint32 areaId = player->GetAreaId();
std::string areaName = "Unknown";
std::string zoneName = "Unknown";
if (AreaTableEntry const* area = GetAreaEntryByAreaID(areaId))
{
Player* p = m_session->GetPlayer();
uint64 sel_guid = p->GetTarget();
sLog->outCommand(m_session->GetAccountId(), "Command: .%s [Player: %s (Account: %u) X: %f Y: %f Z: %f Map: %u Selected %s: %s (GUID: %u)]",
fullcmd.c_str(), p->GetName().c_str(), m_session->GetAccountId(), p->GetPositionX(), p->GetPositionY(), p->GetPositionZ(), p->GetMapId(),
GetLogNameForGuid(sel_guid), (p->GetSelectedUnit()) ? p->GetSelectedUnit()->GetName().c_str() : "", GUID_LOPART(sel_guid));
int locale = GetSessionDbcLocale();
areaName = area->area_name[locale];
if (AreaTableEntry const* zone = GetAreaEntryByAreaID(area->zone))
zoneName = zone->area_name[locale];
}
sLog->outCommand(m_session->GetAccountId(), "Command: %s [Player: %s (%ul) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%ul)]",
fullcmd.c_str(), player->GetName().c_str(), player->GetGUID(),
m_session->GetAccountId(), player->GetPositionX(), player->GetPositionY(),
player->GetPositionZ(), player->GetMapId(),
player->GetMap() ? player->GetMap()->GetMapName() : "Unknown",
areaId, areaName.c_str(), zoneName.c_str(),
(player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
guid);
}
}
// some commands have custom error messages. Don't send the default one in these cases.
@@ -373,7 +336,7 @@ bool ChatHandler::ExecuteCommandInTable(ChatCommand* table, const char* text, st
return false;
}
bool ChatHandler::SetDataForCommandInTable(ChatCommand* table, char const* text, uint32 security, std::string const& help, std::string const& fullcommand)
bool ChatHandler::SetDataForCommandInTable(std::vector<ChatCommand>& table, char const* text, uint32 security, std::string const& help, std::string const& fullcommand)
{
std::string cmd = "";
@@ -385,14 +348,14 @@ bool ChatHandler::SetDataForCommandInTable(ChatCommand* table, char const* text,
while (*text == ' ') ++text;
for (uint32 i = 0; table[i].Name != NULL; i++)
for (uint32 i = 0; i < table.size(); i++)
{
// for data fill use full explicit command names
if (table[i].Name != cmd)
continue;
// select subcommand from child commands list (including "")
if (table[i].ChildCommands != NULL)
if (!table[i].ChildCommands.empty())
{
if (SetDataForCommandInTable(table[i].ChildCommands, text, security, help, fullcommand))
return true;
@@ -419,7 +382,7 @@ bool ChatHandler::SetDataForCommandInTable(ChatCommand* table, char const* text,
// in case "" command let process by caller
if (!cmd.empty())
{
if (table == getCommandTable())
if (&table == &getCommandTable())
sLog->outError("Table `command` have not existed command '%s', skip.", cmd.c_str());
else
sLog->outError("Table `command` have not existed subcommand '%s' in command '%s', skip.", cmd.c_str(), fullcommand.c_str());
@@ -528,10 +491,10 @@ Valid examples:
return LinkExtractor(message).IsValidMessage();
}
bool ChatHandler::ShowHelpForSubCommands(ChatCommand* table, char const* cmd, char const* subcmd)
bool ChatHandler::ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd)
{
std::string list;
for (uint32 i = 0; table[i].Name != NULL; ++i)
for (uint32 i = 0; i < table.size(); ++i)
{
// must be available (ignore handler existence for show command with possible available subcommands)
if (!isAvailable(table[i]))
@@ -548,14 +511,14 @@ bool ChatHandler::ShowHelpForSubCommands(ChatCommand* table, char const* cmd, ch
list += table[i].Name;
if (table[i].ChildCommands)
if (!table[i].ChildCommands.empty())
list += " ...";
}
if (list.empty())
return false;
if (table == getCommandTable())
if (&table == &getCommandTable())
{
SendSysMessage(LANG_AVIABLE_CMD);
PSendSysMessage("%s", list.c_str());
@@ -566,11 +529,11 @@ bool ChatHandler::ShowHelpForSubCommands(ChatCommand* table, char const* cmd, ch
return true;
}
bool ChatHandler::ShowHelpForCommand(ChatCommand* table, const char* cmd)
bool ChatHandler::ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd)
{
if (*cmd)
{
for (uint32 i = 0; table[i].Name != NULL; ++i)
for (uint32 i = 0; i < table.size(); ++i)
{
// must be available (ignore handler existence for show command with possible available subcommands)
if (!isAvailable(table[i]))
@@ -582,7 +545,7 @@ bool ChatHandler::ShowHelpForCommand(ChatCommand* table, const char* cmd)
// have subcommand
char const* subcmd = (*cmd) ? strtok(NULL, " ") : "";
if (table[i].ChildCommands && subcmd && *subcmd)
if (!table[i].ChildCommands.empty() && subcmd && *subcmd)
{
if (ShowHelpForCommand(table[i].ChildCommands, subcmd))
return true;
@@ -591,7 +554,7 @@ bool ChatHandler::ShowHelpForCommand(ChatCommand* table, const char* cmd)
if (!table[i].Help.empty())
SendSysMessage(table[i].Help.c_str());
if (table[i].ChildCommands)
if (!table[i].ChildCommands.empty())
if (ShowHelpForSubCommands(table[i].ChildCommands, table[i].Name, subcmd ? subcmd : ""))
return true;
@@ -600,7 +563,7 @@ bool ChatHandler::ShowHelpForCommand(ChatCommand* table, const char* cmd)
}
else
{
for (uint32 i = 0; table[i].Name != NULL; ++i)
for (uint32 i = 0; i < table.size(); ++i)
{
// must be available (ignore handler existence for show command with possible available subcommands)
if (!isAvailable(table[i]))
@@ -612,7 +575,7 @@ bool ChatHandler::ShowHelpForCommand(ChatCommand* table, const char* cmd)
if (!table[i].Help.empty())
SendSysMessage(table[i].Help.c_str());
if (table[i].ChildCommands)
if (!table[i].ChildCommands.empty())
if (ShowHelpForSubCommands(table[i].ChildCommands, "", ""))
return true;

23
src/game/Chat/Chat.h
View File

@@ -24,13 +24,18 @@ struct GameTele;
class ChatCommand
{
typedef bool(*pHandler)(ChatHandler*, char const*);
public:
const char * Name;
uint32 SecurityLevel; // function pointer required correct align (use uint32)
ChatCommand(char const* name, uint32 securityLevel, bool allowConsole, pHandler handler, std::string help, std::vector<ChatCommand> childCommands = std::vector<ChatCommand>())
: Name(name), SecurityLevel(securityLevel), AllowConsole(allowConsole), Handler(handler), Help(std::move(help)), ChildCommands(std::move(childCommands)) { }
char const* Name;
uint32 SecurityLevel;
bool AllowConsole;
bool (*Handler)(ChatHandler*, const char* args);
pHandler Handler;
std::string Help;
ChatCommand* ChildCommands;
std::vector<ChatCommand> ChildCommands;
};
class ChatHandler
@@ -61,7 +66,7 @@ class ChatHandler
bool ParseCommands(const char* text);
static ChatCommand* getCommandTable();
static std::vector<ChatCommand> const& getCommandTable();
bool isValidChatMessage(const char* msg);
void SendGlobalSysMessage(const char *str);
@@ -111,12 +116,12 @@ class ChatHandler
static bool LoadCommandTable() { return load_command_table; }
static void SetLoadCommandTable(bool val) { load_command_table = val; }
bool ShowHelpForCommand(ChatCommand* table, const char* cmd);
bool ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd);
protected:
explicit ChatHandler() : m_session(NULL), sentErrorMessage(false) {} // for CLI subclass
static bool SetDataForCommandInTable(ChatCommand* table, const char* text, uint32 security, std::string const& help, std::string const& fullcommand);
bool ExecuteCommandInTable(ChatCommand* table, const char* text, std::string& fullcmd);
bool ShowHelpForSubCommands(ChatCommand* table, char const* cmd, char const* subcmd);
static bool SetDataForCommandInTable(std::vector<ChatCommand>& table, const char* text, uint32 securityLevel, std::string const& help, std::string const& fullcommand);
bool ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd);
bool ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd);
private:

10
src/game/Scripting/ScriptMgr.cpp
View File

@@ -20,6 +20,7 @@
#include "CreatureAI.h"
#include "Player.h"
#include "WorldPacket.h"
#include "Chat.h"
// This is the global static registry of scripts.
/*template<class TScript>
@@ -951,12 +952,15 @@ OutdoorPvP* ScriptMgr::CreateOutdoorPvP(OutdoorPvPData const* data)
return tmpscript->GetOutdoorPvP();
}
std::vector<ChatCommand*> ScriptMgr::GetChatCommands()
std::vector<ChatCommand> ScriptMgr::GetChatCommands()
{
std::vector<ChatCommand*> table;
std::vector<ChatCommand> table;
FOR_SCRIPTS_RET(CommandScript, itr, end, table)
table.push_back(itr->second->GetCommands());
{
std::vector<ChatCommand> cmds = itr->second->GetCommands();
table.insert(table.end(), cmds.begin(), cmds.end());
}
return table;
}

4
src/game/Scripting/ScriptMgr.h
View File

@@ -549,7 +549,7 @@ class CommandScript : public ScriptObject
public:
// Should return a pointer to a valid command table (ChatCommand array) to be used by ChatHandler.
virtual ChatCommand* GetCommands() const = 0;
virtual std::vector<ChatCommand> GetCommands() const = 0;
};
class WeatherScript : public ScriptObject, public UpdatableScript<Weather>
@@ -969,7 +969,7 @@ class ScriptMgr
public: /* CommandScript */
std::vector<ChatCommand*> GetChatCommands();
std::vector<ChatCommand> GetChatCommands();
public: /* WeatherScript */

34
src/scripts/Commands/cs_account.cpp
View File

@@ -23,31 +23,31 @@ class account_commandscript : public CommandScript
public:
account_commandscript() : CommandScript("account_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand accountSetCommandTable[] =
static std::vector<ChatCommand> accountSetCommandTable =
{
{ "addon", SEC_ADMINISTRATOR, true, &HandleAccountSetAddonCommand, "", NULL },
{ "gmlevel", SEC_CONSOLE, true, &HandleAccountSetGmLevelCommand, "", NULL },
{ "password", SEC_CONSOLE, true, &HandleAccountSetPasswordCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "addon", SEC_ADMINISTRATOR, true, &HandleAccountSetAddonCommand, "" },
{ "gmlevel", SEC_CONSOLE, true, &HandleAccountSetGmLevelCommand, "" },
{ "password", SEC_CONSOLE, true, &HandleAccountSetPasswordCommand, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand accountCommandTable[] =
static std::vector<ChatCommand> accountCommandTable =
{
{ "addon", SEC_MODERATOR, false, &HandleAccountAddonCommand, "", NULL },
{ "create", SEC_CONSOLE, true, &HandleAccountCreateCommand, "", NULL },
{ "delete", SEC_CONSOLE, true, &HandleAccountDeleteCommand, "", NULL },
{ "onlinelist", SEC_CONSOLE, true, &HandleAccountOnlineListCommand, "", NULL },
{ "lock", SEC_PLAYER, false, &HandleAccountLockCommand, "", NULL },
{ "addon", SEC_MODERATOR, false, &HandleAccountAddonCommand, "" },
{ "create", SEC_CONSOLE, true, &HandleAccountCreateCommand, "" },
{ "delete", SEC_CONSOLE, true, &HandleAccountDeleteCommand, "" },
{ "onlinelist", SEC_CONSOLE, true, &HandleAccountOnlineListCommand, "" },
{ "lock", SEC_PLAYER, false, &HandleAccountLockCommand, "" },
{ "set", SEC_ADMINISTRATOR, true, NULL, "", accountSetCommandTable },
{ "password", SEC_PLAYER, false, &HandleAccountPasswordCommand, "", NULL },
{ "", SEC_PLAYER, false, &HandleAccountCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "password", SEC_PLAYER, false, &HandleAccountPasswordCommand, "" },
{ "", SEC_PLAYER, false, &HandleAccountCommand, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "account", SEC_PLAYER, true, NULL, "", accountCommandTable },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ NULL, SEC_PLAYER, false, NULL, "" }
};
return commandTable;
}

14
src/scripts/Commands/cs_achievement.cpp
View File

@@ -21,18 +21,18 @@ class achievement_commandscript : public CommandScript
public:
achievement_commandscript() : CommandScript("achievement_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand achievementCommandTable[] =
static std::vector<ChatCommand> achievementCommandTable =
{
{ "add", SEC_ADMINISTRATOR, false, &HandleAchievementAddCommand, "", NULL },
{ "checkall", SEC_ADMINISTRATOR, false, &HandleAchievementCheckAllCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "add", SEC_ADMINISTRATOR, false, &HandleAchievementAddCommand, "" },
{ "checkall", SEC_ADMINISTRATOR, false, &HandleAchievementCheckAllCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "achievement", SEC_ADMINISTRATOR, false, NULL, "", achievementCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

50
src/scripts/Commands/cs_ban.cpp
View File

@@ -24,45 +24,45 @@ class ban_commandscript : public CommandScript
public:
ban_commandscript() : CommandScript("ban_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand unbanCommandTable[] =
static std::vector<ChatCommand> unbanCommandTable =
{
{ "account", SEC_ADMINISTRATOR, true, &HandleUnBanAccountCommand, "", NULL },
{ "character", SEC_ADMINISTRATOR, true, &HandleUnBanCharacterCommand, "", NULL },
{ "playeraccount", SEC_ADMINISTRATOR, true, &HandleUnBanAccountByCharCommand, "", NULL },
{ "ip", SEC_ADMINISTRATOR, true, &HandleUnBanIPCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "account", SEC_ADMINISTRATOR, true, &HandleUnBanAccountCommand, "" },
{ "character", SEC_ADMINISTRATOR, true, &HandleUnBanCharacterCommand, "" },
{ "playeraccount", SEC_ADMINISTRATOR, true, &HandleUnBanAccountByCharCommand, "" },
{ "ip", SEC_ADMINISTRATOR, true, &HandleUnBanIPCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand banlistCommandTable[] =
static std::vector<ChatCommand> banlistCommandTable =
{
{ "account", SEC_ADMINISTRATOR, true, &HandleBanListAccountCommand, "", NULL },
{ "character", SEC_ADMINISTRATOR, true, &HandleBanListCharacterCommand, "", NULL },
{ "ip", SEC_ADMINISTRATOR, true, &HandleBanListIPCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "account", SEC_ADMINISTRATOR, true, &HandleBanListAccountCommand, "" },
{ "character", SEC_ADMINISTRATOR, true, &HandleBanListCharacterCommand, "" },
{ "ip", SEC_ADMINISTRATOR, true, &HandleBanListIPCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand baninfoCommandTable[] =
static std::vector<ChatCommand> baninfoCommandTable =
{
{ "account", SEC_ADMINISTRATOR, true, &HandleBanInfoAccountCommand, "", NULL },
{ "character", SEC_ADMINISTRATOR, true, &HandleBanInfoCharacterCommand, "", NULL },
{ "ip", SEC_ADMINISTRATOR, true, &HandleBanInfoIPCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "account", SEC_ADMINISTRATOR, true, &HandleBanInfoAccountCommand, "" },
{ "character", SEC_ADMINISTRATOR, true, &HandleBanInfoCharacterCommand, "" },
{ "ip", SEC_ADMINISTRATOR, true, &HandleBanInfoIPCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand banCommandTable[] =
static std::vector<ChatCommand> banCommandTable =
{
{ "account", SEC_ADMINISTRATOR, true, &HandleBanAccountCommand, "", NULL },
{ "character", SEC_ADMINISTRATOR, true, &HandleBanCharacterCommand, "", NULL },
{ "playeraccount", SEC_ADMINISTRATOR, true, &HandleBanAccountByCharCommand, "", NULL },
{ "ip", SEC_ADMINISTRATOR, true, &HandleBanIPCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "account", SEC_ADMINISTRATOR, true, &HandleBanAccountCommand, "" },
{ "character", SEC_ADMINISTRATOR, true, &HandleBanCharacterCommand, "" },
{ "playeraccount", SEC_ADMINISTRATOR, true, &HandleBanAccountByCharCommand, "" },
{ "ip", SEC_ADMINISTRATOR, true, &HandleBanIPCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "ban", SEC_ADMINISTRATOR, true, NULL, "", banCommandTable },
{ "baninfo", SEC_ADMINISTRATOR, true, NULL, "", baninfoCommandTable },
{ "banlist", SEC_ADMINISTRATOR, true, NULL, "", banlistCommandTable },
{ "unban", SEC_ADMINISTRATOR, true, NULL, "", unbanCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

20
src/scripts/Commands/cs_bf.cpp
View File

@@ -20,21 +20,21 @@ class bf_commandscript : public CommandScript
public:
bf_commandscript() : CommandScript("bf_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand battlefieldcommandTable[] =
static std::vector<ChatCommand> battlefieldcommandTable =
{
{ "start", SEC_ADMINISTRATOR, false, &HandleBattlefieldStart, "", NULL },
{ "stop", SEC_ADMINISTRATOR, false, &HandleBattlefieldEnd, "", NULL },
{ "switch", SEC_ADMINISTRATOR, false, &HandleBattlefieldSwitch, "", NULL },
{ "timer", SEC_ADMINISTRATOR, false, &HandleBattlefieldTimer, "", NULL },
{ "enable", SEC_ADMINISTRATOR, false, &HandleBattlefieldEnable, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "start", SEC_ADMINISTRATOR, false, &HandleBattlefieldStart, "" },
{ "stop", SEC_ADMINISTRATOR, false, &HandleBattlefieldEnd, "" },
{ "switch", SEC_ADMINISTRATOR, false, &HandleBattlefieldSwitch, "" },
{ "timer", SEC_ADMINISTRATOR, false, &HandleBattlefieldTimer, "" },
{ "enable", SEC_ADMINISTRATOR, false, &HandleBattlefieldEnable, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "bf", SEC_ADMINISTRATOR, false, NULL, "", battlefieldcommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

22
src/scripts/Commands/cs_cast.cpp
View File

@@ -23,22 +23,22 @@ class cast_commandscript : public CommandScript
public:
cast_commandscript() : CommandScript("cast_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand castCommandTable[] =
static std::vector<ChatCommand> castCommandTable =
{
{ "back", SEC_ADMINISTRATOR, false, &HandleCastBackCommand, "", NULL },
{ "dist", SEC_ADMINISTRATOR, false, &HandleCastDistCommand, "", NULL },
{ "self", SEC_ADMINISTRATOR, false, &HandleCastSelfCommand, "", NULL },
{ "target", SEC_ADMINISTRATOR, false, &HandleCastTargetCommad, "", NULL },
{ "dest", SEC_ADMINISTRATOR, false, &HandleCastDestCommand, "", NULL },
{ "", SEC_ADMINISTRATOR, false, &HandleCastCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "back", SEC_ADMINISTRATOR, false, &HandleCastBackCommand, "" },
{ "dist", SEC_ADMINISTRATOR, false, &HandleCastDistCommand, "" },
{ "self", SEC_ADMINISTRATOR, false, &HandleCastSelfCommand, "" },
{ "target", SEC_ADMINISTRATOR, false, &HandleCastTargetCommad, "" },
{ "dest", SEC_ADMINISTRATOR, false, &HandleCastDestCommand, "" },
{ "", SEC_ADMINISTRATOR, false, &HandleCastCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "cast", SEC_ADMINISTRATOR, false, NULL, "", castCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

34
src/scripts/Commands/cs_character.cpp
View File

@@ -24,33 +24,33 @@ class character_commandscript : public CommandScript
public:
character_commandscript() : CommandScript("character_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand pdumpCommandTable[] =
static std::vector<ChatCommand> pdumpCommandTable =
{
{ "load", SEC_ADMINISTRATOR, true, &HandlePDumpLoadCommand, "", NULL },
{ "write", SEC_ADMINISTRATOR, true, &HandlePDumpWriteCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "load", SEC_ADMINISTRATOR, true, &HandlePDumpLoadCommand, "" },
{ "write", SEC_ADMINISTRATOR, true, &HandlePDumpWriteCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand characterCommandTable[] =
static std::vector<ChatCommand> characterCommandTable =
{
{ "customize", SEC_GAMEMASTER, true, &HandleCharacterCustomizeCommand, "", NULL },
{ "changefaction", SEC_GAMEMASTER, true, &HandleCharacterChangeFactionCommand, "", NULL },
{ "changerace", SEC_GAMEMASTER, true, &HandleCharacterChangeRaceCommand, "", NULL },
{ "level", SEC_ADMINISTRATOR, true, &HandleCharacterLevelCommand, "", NULL },
{ "rename", SEC_GAMEMASTER, true, &HandleCharacterRenameCommand, "", NULL },
{ "reputation", SEC_GAMEMASTER, true, &HandleCharacterReputationCommand, "", NULL },
{ "titles", SEC_GAMEMASTER, true, &HandleCharacterTitlesCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "customize", SEC_GAMEMASTER, true, &HandleCharacterCustomizeCommand, "" },
{ "changefaction", SEC_GAMEMASTER, true, &HandleCharacterChangeFactionCommand, "" },
{ "changerace", SEC_GAMEMASTER, true, &HandleCharacterChangeRaceCommand, "" },
{ "level", SEC_ADMINISTRATOR, true, &HandleCharacterLevelCommand, "" },
{ "rename", SEC_GAMEMASTER, true, &HandleCharacterRenameCommand, "" },
{ "reputation", SEC_GAMEMASTER, true, &HandleCharacterReputationCommand, "" },
{ "titles", SEC_GAMEMASTER, true, &HandleCharacterTitlesCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "character", SEC_GAMEMASTER, true, NULL, "", characterCommandTable },
{ "levelup", SEC_ADMINISTRATOR, false, &HandleLevelUpCommand, "", NULL },
{ "levelup", SEC_ADMINISTRATOR, false, &HandleLevelUpCommand, "" },
{ "pdump", SEC_ADMINISTRATOR, true, NULL, "", pdumpCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

96
src/scripts/Commands/cs_debug.cpp
View File

@@ -29,65 +29,65 @@ class debug_commandscript : public CommandScript
public:
debug_commandscript() : CommandScript("debug_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand debugPlayCommandTable[] =
static std::vector<ChatCommand> debugPlayCommandTable =
{
{ "cinematic", SEC_GAMEMASTER, false, &HandleDebugPlayCinematicCommand, "", NULL },
{ "movie", SEC_GAMEMASTER, false, &HandleDebugPlayMovieCommand, "", NULL },
{ "sound", SEC_GAMEMASTER, false, &HandleDebugPlaySoundCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "cinematic", SEC_GAMEMASTER, false, &HandleDebugPlayCinematicCommand, "" },
{ "movie", SEC_GAMEMASTER, false, &HandleDebugPlayMovieCommand, "" },
{ "sound", SEC_GAMEMASTER, false, &HandleDebugPlaySoundCommand, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand debugSendCommandTable[] =
static std::vector<ChatCommand> debugSendCommandTable =
{
{ "buyerror", SEC_ADMINISTRATOR, false, &HandleDebugSendBuyErrorCommand, "", NULL },
{ "channelnotify", SEC_ADMINISTRATOR, false, &HandleDebugSendChannelNotifyCommand, "", NULL },
{ "chatmmessage", SEC_ADMINISTRATOR, false, &HandleDebugSendChatMsgCommand, "", NULL },
{ "equiperror", SEC_ADMINISTRATOR, false, &HandleDebugSendEquipErrorCommand, "", NULL },
{ "largepacket", SEC_ADMINISTRATOR, false, &HandleDebugSendLargePacketCommand, "", NULL },
{ "opcode", SEC_ADMINISTRATOR, false, &HandleDebugSendOpcodeCommand, "", NULL },
{ "qpartymsg", SEC_ADMINISTRATOR, false, &HandleDebugSendQuestPartyMsgCommand, "", NULL },
{ "qinvalidmsg", SEC_ADMINISTRATOR, false, &HandleDebugSendQuestInvalidMsgCommand, "", NULL },
{ "sellerror", SEC_ADMINISTRATOR, false, &HandleDebugSendSellErrorCommand, "", NULL },
{ "setphaseshift", SEC_ADMINISTRATOR, false, &HandleDebugSendSetPhaseShiftCommand, "", NULL },
{ "spellfail", SEC_ADMINISTRATOR, false, &HandleDebugSendSpellFailCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "buyerror", SEC_ADMINISTRATOR, false, &HandleDebugSendBuyErrorCommand, "" },
{ "channelnotify", SEC_ADMINISTRATOR, false, &HandleDebugSendChannelNotifyCommand, "" },
{ "chatmmessage", SEC_ADMINISTRATOR, false, &HandleDebugSendChatMsgCommand, "" },
{ "equiperror", SEC_ADMINISTRATOR, false, &HandleDebugSendEquipErrorCommand, "" },
{ "largepacket", SEC_ADMINISTRATOR, false, &HandleDebugSendLargePacketCommand, "" },
{ "opcode", SEC_ADMINISTRATOR, false, &HandleDebugSendOpcodeCommand, "" },
{ "qpartymsg", SEC_ADMINISTRATOR, false, &HandleDebugSendQuestPartyMsgCommand, "" },
{ "qinvalidmsg", SEC_ADMINISTRATOR, false, &HandleDebugSendQuestInvalidMsgCommand, "" },
{ "sellerror", SEC_ADMINISTRATOR, false, &HandleDebugSendSellErrorCommand, "" },
{ "setphaseshift", SEC_ADMINISTRATOR, false, &HandleDebugSendSetPhaseShiftCommand, "" },
{ "spellfail", SEC_ADMINISTRATOR, false, &HandleDebugSendSpellFailCommand, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand debugCommandTable[] =
static std::vector<ChatCommand> debugCommandTable =
{
{ "setbit", SEC_ADMINISTRATOR, false, &HandleDebugSet32BitCommand, "", NULL },
{ "threat", SEC_ADMINISTRATOR, false, &HandleDebugThreatListCommand, "", NULL },
{ "hostil", SEC_ADMINISTRATOR, false, &HandleDebugHostileRefListCommand, "", NULL },
{ "anim", SEC_GAMEMASTER, false, &HandleDebugAnimCommand, "", NULL },
{ "arena", SEC_ADMINISTRATOR, false, &HandleDebugArenaCommand, "", NULL },
{ "bg", SEC_ADMINISTRATOR, false, &HandleDebugBattlegroundCommand, "", NULL },
{ "getitemstate", SEC_ADMINISTRATOR, false, &HandleDebugGetItemStateCommand, "", NULL },
{ "lootrecipient", SEC_GAMEMASTER, false, &HandleDebugGetLootRecipientCommand, "", NULL },
{ "getvalue", SEC_ADMINISTRATOR, false, &HandleDebugGetValueCommand, "", NULL },
{ "getitemvalue", SEC_ADMINISTRATOR, false, &HandleDebugGetItemValueCommand, "", NULL },
{ "Mod32Value", SEC_ADMINISTRATOR, false, &HandleDebugMod32ValueCommand, "", NULL },
{ "setbit", SEC_ADMINISTRATOR, false, &HandleDebugSet32BitCommand, "" },
{ "threat", SEC_ADMINISTRATOR, false, &HandleDebugThreatListCommand, "" },
{ "hostil", SEC_ADMINISTRATOR, false, &HandleDebugHostileRefListCommand, "" },
{ "anim", SEC_GAMEMASTER, false, &HandleDebugAnimCommand, "" },
{ "arena", SEC_ADMINISTRATOR, false, &HandleDebugArenaCommand, "" },
{ "bg", SEC_ADMINISTRATOR, false, &HandleDebugBattlegroundCommand, "" },
{ "getitemstate", SEC_ADMINISTRATOR, false, &HandleDebugGetItemStateCommand, "" },
{ "lootrecipient", SEC_GAMEMASTER, false, &HandleDebugGetLootRecipientCommand, "" },
{ "getvalue", SEC_ADMINISTRATOR, false, &HandleDebugGetValueCommand, "" },
{ "getitemvalue", SEC_ADMINISTRATOR, false, &HandleDebugGetItemValueCommand, "" },
{ "Mod32Value", SEC_ADMINISTRATOR, false, &HandleDebugMod32ValueCommand, "" },
{ "play", SEC_GAMEMASTER, false, NULL, "", debugPlayCommandTable },
{ "send", SEC_ADMINISTRATOR, false, NULL, "", debugSendCommandTable },
{ "setaurastate", SEC_ADMINISTRATOR, false, &HandleDebugSetAuraStateCommand, "", NULL },
{ "setitemvalue", SEC_ADMINISTRATOR, false, &HandleDebugSetItemValueCommand, "", NULL },
{ "setvalue", SEC_ADMINISTRATOR, false, &HandleDebugSetValueCommand, "", NULL },
{ "spawnvehicle", SEC_ADMINISTRATOR, false, &HandleDebugSpawnVehicleCommand, "", NULL },
{ "setvid", SEC_ADMINISTRATOR, false, &HandleDebugSetVehicleIdCommand, "", NULL },
{ "entervehicle", SEC_ADMINISTRATOR, false, &HandleDebugEnterVehicleCommand, "", NULL },
{ "uws", SEC_ADMINISTRATOR, false, &HandleDebugUpdateWorldStateCommand, "", NULL },
{ "update", SEC_ADMINISTRATOR, false, &HandleDebugUpdateCommand, "", NULL },
{ "itemexpire", SEC_ADMINISTRATOR, false, &HandleDebugItemExpireCommand, "", NULL },
{ "areatriggers", SEC_ADMINISTRATOR, false, &HandleDebugAreaTriggersCommand, "", NULL },
{ "los", SEC_GAMEMASTER, false, &HandleDebugLoSCommand, "", NULL },
{ "moveflags", SEC_ADMINISTRATOR, false, &HandleDebugMoveflagsCommand, "", NULL },
{ "unitstate", SEC_ADMINISTRATOR, false, &HandleDebugUnitStateCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "setaurastate", SEC_ADMINISTRATOR, false, &HandleDebugSetAuraStateCommand, "" },
{ "setitemvalue", SEC_ADMINISTRATOR, false, &HandleDebugSetItemValueCommand, "" },
{ "setvalue", SEC_ADMINISTRATOR, false, &HandleDebugSetValueCommand, "" },
{ "spawnvehicle", SEC_ADMINISTRATOR, false, &HandleDebugSpawnVehicleCommand, "" },
{ "setvid", SEC_ADMINISTRATOR, false, &HandleDebugSetVehicleIdCommand, "" },
{ "entervehicle", SEC_ADMINISTRATOR, false, &HandleDebugEnterVehicleCommand, "" },
{ "uws", SEC_ADMINISTRATOR, false, &HandleDebugUpdateWorldStateCommand, "" },
{ "update", SEC_ADMINISTRATOR, false, &HandleDebugUpdateCommand, "" },
{ "itemexpire", SEC_ADMINISTRATOR, false, &HandleDebugItemExpireCommand, "" },
{ "areatriggers", SEC_ADMINISTRATOR, false, &HandleDebugAreaTriggersCommand, "" },
{ "los", SEC_GAMEMASTER, false, &HandleDebugLoSCommand, "" },
{ "moveflags", SEC_ADMINISTRATOR, false, &HandleDebugMoveflagsCommand, "" },
{ "unitstate", SEC_ADMINISTRATOR, false, &HandleDebugUnitStateCommand, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "debug", SEC_GAMEMASTER, true, NULL, "", debugCommandTable },
{ "wpgps", SEC_ADMINISTRATOR, false, &HandleWPGPSCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "wpgps", SEC_ADMINISTRATOR, false, &HandleWPGPSCommand, "", },
{ NULL, SEC_PLAYER, false, NULL, "", }
};
return commandTable;
}

18
src/scripts/Commands/cs_event.cpp
View File

@@ -22,20 +22,20 @@ class event_commandscript : public CommandScript
public:
event_commandscript() : CommandScript("event_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand eventCommandTable[] =
static std::vector<ChatCommand> eventCommandTable =
{
{ "activelist", SEC_GAMEMASTER, true, &HandleEventActiveListCommand, "", NULL },
{ "start", SEC_GAMEMASTER, true, &HandleEventStartCommand, "", NULL },
{ "stop", SEC_GAMEMASTER, true, &HandleEventStopCommand, "", NULL },
{ "", SEC_GAMEMASTER, true, &HandleEventInfoCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "activelist", SEC_GAMEMASTER, true, &HandleEventActiveListCommand, "" },
{ "start", SEC_GAMEMASTER, true, &HandleEventStartCommand, "" },
{ "stop", SEC_GAMEMASTER, true, &HandleEventStopCommand, "" },
{ "", SEC_GAMEMASTER, true, &HandleEventInfoCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "event", SEC_GAMEMASTER, false, NULL, "", eventCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

22
src/scripts/Commands/cs_gm.cpp
View File

@@ -25,22 +25,22 @@ class gm_commandscript : public CommandScript
public:
gm_commandscript() : CommandScript("gm_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand gmCommandTable[] =
static std::vector<ChatCommand> gmCommandTable =
{
{ "chat", SEC_GAMEMASTER, false, &HandleGMChatCommand, "", NULL },
{ "fly", SEC_ADMINISTRATOR, false, &HandleGMFlyCommand, "", NULL },
//{ "ingame", SEC_PLAYER, true, &HandleGMListIngameCommand, "", NULL },
{ "list", SEC_ADMINISTRATOR, true, &HandleGMListFullCommand, "", NULL },
{ "visible", SEC_GAMEMASTER, false, &HandleGMVisibleCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleGMCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "chat", SEC_GAMEMASTER, false, &HandleGMChatCommand, "" },
{ "fly", SEC_ADMINISTRATOR, false, &HandleGMFlyCommand, "" },
//{ "ingame", SEC_PLAYER, true, &HandleGMListIngameCommand, "" },
{ "list", SEC_ADMINISTRATOR, true, &HandleGMListFullCommand, "" },
{ "visible", SEC_GAMEMASTER, false, &HandleGMVisibleCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleGMCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "gm", SEC_GAMEMASTER, false, NULL, "", gmCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

30
src/scripts/Commands/cs_go.cpp
View File

@@ -24,27 +24,27 @@ class go_commandscript : public CommandScript
public:
go_commandscript() : CommandScript("go_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand goCommandTable[] =
static std::vector<ChatCommand> goCommandTable =
{
{ "creature", SEC_GAMEMASTER, false, &HandleGoCreatureCommand, "", NULL },
{ "graveyard", SEC_GAMEMASTER, false, &HandleGoGraveyardCommand, "", NULL },
{ "grid", SEC_GAMEMASTER, false, &HandleGoGridCommand, "", NULL },
{ "object", SEC_GAMEMASTER, false, &HandleGoObjectCommand, "", NULL },
{ "taxinode", SEC_GAMEMASTER, false, &HandleGoTaxinodeCommand, "", NULL },
{ "trigger", SEC_GAMEMASTER, false, &HandleGoTriggerCommand, "", NULL },
{ "zonexy", SEC_GAMEMASTER, false, &HandleGoZoneXYCommand, "", NULL },
{ "xyz", SEC_GAMEMASTER, false, &HandleGoXYZCommand, "", NULL },
{ "ticket", SEC_GAMEMASTER, false, &HandleGoTicketCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleGoXYZCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "creature", SEC_GAMEMASTER, false, &HandleGoCreatureCommand, "" },
{ "graveyard", SEC_GAMEMASTER, false, &HandleGoGraveyardCommand, "" },
{ "grid", SEC_GAMEMASTER, false, &HandleGoGridCommand, "" },
{ "object", SEC_GAMEMASTER, false, &HandleGoObjectCommand, "" },
{ "taxinode", SEC_GAMEMASTER, false, &HandleGoTaxinodeCommand, "" },
{ "trigger", SEC_GAMEMASTER, false, &HandleGoTriggerCommand, "" },
{ "zonexy", SEC_GAMEMASTER, false, &HandleGoZoneXYCommand, "" },
{ "xyz", SEC_GAMEMASTER, false, &HandleGoXYZCommand, "" },
{ "ticket", SEC_GAMEMASTER, false, &HandleGoTicketCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleGoXYZCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "go", SEC_GAMEMASTER, false, NULL, "", goCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

40
src/scripts/Commands/cs_gobject.cpp
View File

@@ -28,37 +28,37 @@ class gobject_commandscript : public CommandScript
public:
gobject_commandscript() : CommandScript("gobject_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand gobjectAddCommandTable[] =
static std::vector<ChatCommand> gobjectAddCommandTable =
{
{ "temp", SEC_GAMEMASTER, false, &HandleGameObjectAddTempCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleGameObjectAddCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "temp", SEC_GAMEMASTER, false, &HandleGameObjectAddTempCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleGameObjectAddCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand gobjectSetCommandTable[] =
static std::vector<ChatCommand> gobjectSetCommandTable =
{
{ "phase", SEC_GAMEMASTER, false, &HandleGameObjectSetPhaseCommand, "", NULL },
{ "state", SEC_GAMEMASTER, false, &HandleGameObjectSetStateCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "phase", SEC_GAMEMASTER, false, &HandleGameObjectSetPhaseCommand, "" },
{ "state", SEC_GAMEMASTER, false, &HandleGameObjectSetStateCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand gobjectCommandTable[] =
static std::vector<ChatCommand> gobjectCommandTable =
{
{ "activate", SEC_GAMEMASTER, false, &HandleGameObjectActivateCommand, "", NULL },
{ "delete", SEC_GAMEMASTER, false, &HandleGameObjectDeleteCommand, "", NULL },
{ "info", SEC_GAMEMASTER, false, &HandleGameObjectInfoCommand, "", NULL },
{ "move", SEC_GAMEMASTER, false, &HandleGameObjectMoveCommand, "", NULL },
{ "near", SEC_GAMEMASTER, false, &HandleGameObjectNearCommand, "", NULL },
{ "target", SEC_GAMEMASTER, false, &HandleGameObjectTargetCommand, "", NULL },
{ "turn", SEC_GAMEMASTER, false, &HandleGameObjectTurnCommand, "", NULL },
{ "activate", SEC_GAMEMASTER, false, &HandleGameObjectActivateCommand, "" },
{ "delete", SEC_GAMEMASTER, false, &HandleGameObjectDeleteCommand, "" },
{ "info", SEC_GAMEMASTER, false, &HandleGameObjectInfoCommand, "" },
{ "move", SEC_GAMEMASTER, false, &HandleGameObjectMoveCommand, "" },
{ "near", SEC_GAMEMASTER, false, &HandleGameObjectNearCommand, "" },
{ "target", SEC_GAMEMASTER, false, &HandleGameObjectTargetCommand, "" },
{ "turn", SEC_GAMEMASTER, false, &HandleGameObjectTurnCommand, "" },
{ "add", SEC_GAMEMASTER, false, NULL, "", gobjectAddCommandTable },
{ "set", SEC_GAMEMASTER, false, NULL, "", gobjectSetCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "gobject", SEC_GAMEMASTER, false, NULL, "", gobjectCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

20
src/scripts/Commands/cs_guild.cpp
View File

@@ -23,21 +23,21 @@ class guild_commandscript : public CommandScript
public:
guild_commandscript() : CommandScript("guild_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand guildCommandTable[] =
static std::vector<ChatCommand> guildCommandTable =
{
{ "create", SEC_GAMEMASTER, true, &HandleGuildCreateCommand, "", NULL },
{ "delete", SEC_GAMEMASTER, true, &HandleGuildDeleteCommand, "", NULL },
{ "invite", SEC_GAMEMASTER, true, &HandleGuildInviteCommand, "", NULL },
{ "uninvite", SEC_GAMEMASTER, true, &HandleGuildUninviteCommand, "", NULL },
{ "rank", SEC_GAMEMASTER, true, &HandleGuildRankCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "create", SEC_GAMEMASTER, true, &HandleGuildCreateCommand, "" },
{ "delete", SEC_GAMEMASTER, true, &HandleGuildDeleteCommand, "" },
{ "invite", SEC_GAMEMASTER, true, &HandleGuildInviteCommand, "" },
{ "uninvite", SEC_GAMEMASTER, true, &HandleGuildUninviteCommand, "" },
{ "rank", SEC_GAMEMASTER, true, &HandleGuildRankCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "guild", SEC_ADMINISTRATOR, true, NULL, "", guildCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

20
src/scripts/Commands/cs_honor.cpp
View File

@@ -22,26 +22,26 @@ class honor_commandscript : public CommandScript
public:
honor_commandscript() : CommandScript("honor_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand honorAddCommandTable[] =
static std::vector<ChatCommand> honorAddCommandTable =
{
{ "kill", SEC_GAMEMASTER, false, &HandleHonorAddKillCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleHonorAddCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "kill", SEC_GAMEMASTER, false, &HandleHonorAddKillCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleHonorAddCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand honorCommandTable[] =
static std::vector<ChatCommand> honorCommandTable =
{
{ "add", SEC_GAMEMASTER, false, NULL, "", honorAddCommandTable },
{ "update", SEC_GAMEMASTER, false, &HandleHonorUpdateCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "update", SEC_GAMEMASTER, false, &HandleHonorUpdateCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "honor", SEC_GAMEMASTER, false, NULL, "", honorCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

22
src/scripts/Commands/cs_instance.cpp
View File

@@ -25,23 +25,23 @@ class instance_commandscript : public CommandScript
public:
instance_commandscript() : CommandScript("instance_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand instanceCommandTable[] =
static std::vector<ChatCommand> instanceCommandTable =
{
{ "listbinds", SEC_ADMINISTRATOR, false, &HandleInstanceListBindsCommand, "", NULL },
{ "unbind", SEC_ADMINISTRATOR, false, &HandleInstanceUnbindCommand, "", NULL },
{ "stats", SEC_ADMINISTRATOR, true, &HandleInstanceStatsCommand, "", NULL },
{ "savedata", SEC_ADMINISTRATOR, false, &HandleInstanceSaveDataCommand, "", NULL },
{ "setbossstate", SEC_GAMEMASTER, true, &HandleInstanceSetBossStateCommand, "", NULL },
{ "getbossstate", SEC_GAMEMASTER, true, &HandleInstanceGetBossStateCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "listbinds", SEC_ADMINISTRATOR, false, &HandleInstanceListBindsCommand, "" },
{ "unbind", SEC_ADMINISTRATOR, false, &HandleInstanceUnbindCommand, "" },
{ "stats", SEC_ADMINISTRATOR, true, &HandleInstanceStatsCommand, "" },
{ "savedata", SEC_ADMINISTRATOR, false, &HandleInstanceSaveDataCommand, "" },
{ "setbossstate", SEC_GAMEMASTER, true, &HandleInstanceSetBossStateCommand, "" },
{ "getbossstate", SEC_GAMEMASTER, true, &HandleInstanceGetBossStateCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "instance", SEC_ADMINISTRATOR, true, NULL, "", instanceCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;

40
src/scripts/Commands/cs_learn.cpp
View File

@@ -25,40 +25,40 @@ class learn_commandscript : public CommandScript
public:
learn_commandscript() : CommandScript("learn_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand learnAllMyCommandTable[] =
static std::vector<ChatCommand> learnAllMyCommandTable =
{
{ "class", SEC_ADMINISTRATOR, false, &HandleLearnAllMyClassCommand, "", NULL },
{ "pettalents", SEC_ADMINISTRATOR, false, &HandleLearnAllMyPetTalentsCommand, "", NULL },
{ "spells", SEC_ADMINISTRATOR, false, &HandleLearnAllMySpellsCommand, "", NULL },
{ "talents", SEC_ADMINISTRATOR, false, &HandleLearnAllMyTalentsCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "class", SEC_ADMINISTRATOR, false, &HandleLearnAllMyClassCommand, "" },
{ "pettalents", SEC_ADMINISTRATOR, false, &HandleLearnAllMyPetTalentsCommand, "" },
{ "spells", SEC_ADMINISTRATOR, false, &HandleLearnAllMySpellsCommand, "" },
{ "talents", SEC_ADMINISTRATOR, false, &HandleLearnAllMyTalentsCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand learnAllCommandTable[] =
static std::vector<ChatCommand> learnAllCommandTable =
{
{ "my", SEC_ADMINISTRATOR, false, NULL, "", learnAllMyCommandTable },
{ "gm", SEC_GAMEMASTER, false, &HandleLearnAllGMCommand, "", NULL },
{ "crafts", SEC_GAMEMASTER, false, &HandleLearnAllCraftsCommand, "", NULL },
{ "default", SEC_GAMEMASTER, false, &HandleLearnAllDefaultCommand, "", NULL },
{ "lang", SEC_GAMEMASTER, false, &HandleLearnAllLangCommand, "", NULL },
{ "recipes", SEC_GAMEMASTER, false, &HandleLearnAllRecipesCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "gm", SEC_GAMEMASTER, false, &HandleLearnAllGMCommand, "" },
{ "crafts", SEC_GAMEMASTER, false, &HandleLearnAllCraftsCommand, "" },
{ "default", SEC_GAMEMASTER, false, &HandleLearnAllDefaultCommand, "" },
{ "lang", SEC_GAMEMASTER, false, &HandleLearnAllLangCommand, "" },
{ "recipes", SEC_GAMEMASTER, false, &HandleLearnAllRecipesCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand learnCommandTable[] =
static std::vector<ChatCommand> learnCommandTable =
{
{ "all", SEC_ADMINISTRATOR, false, NULL, "", learnAllCommandTable },
{ "", SEC_ADMINISTRATOR, false, &HandleLearnCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "", SEC_ADMINISTRATOR, false, &HandleLearnCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "learn", SEC_GAMEMASTER, false, NULL, "", learnCommandTable },
{ "unlearn", SEC_ADMINISTRATOR, false, &HandleUnLearnCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "unlearn", SEC_ADMINISTRATOR, false, &HandleUnLearnCommand, "" },
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

20
src/scripts/Commands/cs_lfg.cpp
View File

@@ -30,22 +30,22 @@ class lfg_commandscript : public CommandScript
public:
lfg_commandscript() : CommandScript("lfg_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand lfgCommandTable[] =
static std::vector<ChatCommand> lfgCommandTable =
{
{ "player", SEC_GAMEMASTER, false, &HandleLfgPlayerInfoCommand, "", NULL },
{ "group", SEC_GAMEMASTER, false, &HandleLfgGroupInfoCommand, "", NULL },
{ "queue", SEC_GAMEMASTER, false, &HandleLfgQueueInfoCommand, "", NULL },
{ "clean", SEC_ADMINISTRATOR, false, &HandleLfgCleanCommand, "", NULL },
{ "options", SEC_ADMINISTRATOR, false, &HandleLfgOptionsCommand, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "player", SEC_GAMEMASTER, false, &HandleLfgPlayerInfoCommand, "" },
{ "group", SEC_GAMEMASTER, false, &HandleLfgGroupInfoCommand, "" },
{ "queue", SEC_GAMEMASTER, false, &HandleLfgQueueInfoCommand, "" },
{ "clean", SEC_ADMINISTRATOR, false, &HandleLfgCleanCommand, "" },
{ "options", SEC_ADMINISTRATOR, false, &HandleLfgOptionsCommand, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "lfg", SEC_GAMEMASTER, false, NULL, "", lfgCommandTable },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ NULL, SEC_PLAYER, false, NULL, "" }
};
return commandTable;
}

18
src/scripts/Commands/cs_list.cpp
View File

@@ -24,20 +24,20 @@ class list_commandscript : public CommandScript
public:
list_commandscript() : CommandScript("list_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand listCommandTable[] =
static std::vector<ChatCommand> listCommandTable =
{
{ "creature", SEC_ADMINISTRATOR, true, &HandleListCreatureCommand, "", NULL },
{ "item", SEC_ADMINISTRATOR, true, &HandleListItemCommand, "", NULL },
{ "object", SEC_ADMINISTRATOR, true, &HandleListObjectCommand, "", NULL },
{ "auras", SEC_ADMINISTRATOR, false, &HandleListAurasCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "creature", SEC_ADMINISTRATOR, true, &HandleListCreatureCommand, "" },
{ "item", SEC_ADMINISTRATOR, true, &HandleListItemCommand, "" },
{ "object", SEC_ADMINISTRATOR, true, &HandleListObjectCommand, "" },
{ "auras", SEC_ADMINISTRATOR, false, &HandleListAurasCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "list", SEC_ADMINISTRATOR, true, NULL, "", listCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

54
src/scripts/Commands/cs_lookup.cpp
View File

@@ -26,47 +26,47 @@ class lookup_commandscript : public CommandScript
public:
lookup_commandscript() : CommandScript("lookup_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand lookupPlayerCommandTable[] =
static std::vector<ChatCommand> lookupPlayerCommandTable =
{
{ "ip", SEC_GAMEMASTER, true, &HandleLookupPlayerIpCommand, "", NULL },
{ "account", SEC_GAMEMASTER, true, &HandleLookupPlayerAccountCommand, "", NULL },
{ "email", SEC_GAMEMASTER, true, &HandleLookupPlayerEmailCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "ip", SEC_GAMEMASTER, true, &HandleLookupPlayerIpCommand, "" },
{ "account", SEC_GAMEMASTER, true, &HandleLookupPlayerAccountCommand, "" },
{ "email", SEC_GAMEMASTER, true, &HandleLookupPlayerEmailCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand lookupSpellCommandTable[] =
static std::vector<ChatCommand> lookupSpellCommandTable =
{
{ "id", SEC_ADMINISTRATOR, true, &HandleLookupSpellIdCommand, "", NULL },
{ "", SEC_ADMINISTRATOR, true, &HandleLookupSpellCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "id", SEC_ADMINISTRATOR, true, &HandleLookupSpellIdCommand, "" },
{ "", SEC_ADMINISTRATOR, true, &HandleLookupSpellCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand lookupCommandTable[] =
static std::vector<ChatCommand> lookupCommandTable =
{
{ "area", SEC_GAMEMASTER, true, &HandleLookupAreaCommand, "", NULL },
{ "creature", SEC_ADMINISTRATOR, true, &HandleLookupCreatureCommand, "", NULL },
{ "event", SEC_GAMEMASTER, true, &HandleLookupEventCommand, "", NULL },
{ "faction", SEC_ADMINISTRATOR, true, &HandleLookupFactionCommand, "", NULL },
{ "item", SEC_ADMINISTRATOR, true, &HandleLookupItemCommand, "", NULL },
{ "itemset", SEC_ADMINISTRATOR, true, &HandleLookupItemSetCommand, "", NULL },
{ "object", SEC_ADMINISTRATOR, true, &HandleLookupObjectCommand, "", NULL },
{ "quest", SEC_ADMINISTRATOR, true, &HandleLookupQuestCommand, "", NULL },
{ "area", SEC_GAMEMASTER, true, &HandleLookupAreaCommand, "" },
{ "creature", SEC_ADMINISTRATOR, true, &HandleLookupCreatureCommand, "" },
{ "event", SEC_GAMEMASTER, true, &HandleLookupEventCommand, "" },
{ "faction", SEC_ADMINISTRATOR, true, &HandleLookupFactionCommand, "" },
{ "item", SEC_ADMINISTRATOR, true, &HandleLookupItemCommand, "" },
{ "itemset", SEC_ADMINISTRATOR, true, &HandleLookupItemSetCommand, "" },
{ "object", SEC_ADMINISTRATOR, true, &HandleLookupObjectCommand, "" },
{ "quest", SEC_ADMINISTRATOR, true, &HandleLookupQuestCommand, "" },
{ "player", SEC_GAMEMASTER, true, NULL, "", lookupPlayerCommandTable },
{ "skill", SEC_ADMINISTRATOR, true, &HandleLookupSkillCommand, "", NULL },
{ "skill", SEC_ADMINISTRATOR, true, &HandleLookupSkillCommand, "" },
{ "spell", SEC_ADMINISTRATOR, true, NULL, "", lookupSpellCommandTable },
{ "taxinode", SEC_ADMINISTRATOR, true, &HandleLookupTaxiNodeCommand, "", NULL },
{ "tele", SEC_GAMEMASTER, true, &HandleLookupTeleCommand, "", NULL },
{ "title", SEC_GAMEMASTER, true, &HandleLookupTitleCommand, "", NULL },
{ "map", SEC_ADMINISTRATOR, true, &HandleLookupMapCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "taxinode", SEC_ADMINISTRATOR, true, &HandleLookupTaxiNodeCommand, "" },
{ "tele", SEC_GAMEMASTER, true, &HandleLookupTeleCommand, "" },
{ "title", SEC_GAMEMASTER, true, &HandleLookupTitleCommand, "" },
{ "map", SEC_ADMINISTRATOR, true, &HandleLookupMapCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "lookup", SEC_ADMINISTRATOR, true, NULL, "", lookupCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

20
src/scripts/Commands/cs_message.cpp
View File

@@ -22,18 +22,18 @@ class message_commandscript : public CommandScript
public:
message_commandscript() : CommandScript("message_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "nameannounce", SEC_GAMEMASTER, true, &HandleNameAnnounceCommand, "", NULL },
{ "gmnameannounce", SEC_GAMEMASTER, true, &HandleGMNameAnnounceCommand, "", NULL },
{ "announce", SEC_GAMEMASTER, true, &HandleAnnounceCommand, "", NULL },
{ "gmannounce", SEC_GAMEMASTER, true, &HandleGMAnnounceCommand, "", NULL },
{ "notify", SEC_GAMEMASTER, true, &HandleNotifyCommand, "", NULL },
{ "gmnotify", SEC_GAMEMASTER, true, &HandleGMNotifyCommand, "", NULL },
{ "whispers", SEC_GAMEMASTER, false, &HandleWhispersCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "nameannounce", SEC_GAMEMASTER, true, &HandleNameAnnounceCommand, "" },
{ "gmnameannounce", SEC_GAMEMASTER, true, &HandleGMNameAnnounceCommand, "" },
{ "announce", SEC_GAMEMASTER, true, &HandleAnnounceCommand, "" },
{ "gmannounce", SEC_GAMEMASTER, true, &HandleGMAnnounceCommand, "" },
{ "notify", SEC_GAMEMASTER, true, &HandleNotifyCommand, "" },
{ "gmnotify", SEC_GAMEMASTER, true, &HandleGMNotifyCommand, "" },
{ "whispers", SEC_GAMEMASTER, false, &HandleWhispersCommand, "" },
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

148
src/scripts/Commands/cs_misc.cpp
View File

@@ -33,91 +33,91 @@ class misc_commandscript : public CommandScript
public:
misc_commandscript() : CommandScript("misc_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand groupCommandTable[] =
static std::vector<ChatCommand> groupCommandTable =
{
{ "leader", SEC_ADMINISTRATOR, false, &HandleGroupLeaderCommand, "", NULL },
{ "disband", SEC_ADMINISTRATOR, false, &HandleGroupDisbandCommand, "", NULL },
{ "remove", SEC_ADMINISTRATOR, false, &HandleGroupRemoveCommand, "", NULL },
{ "join", SEC_ADMINISTRATOR, false, &HandleGroupJoinCommand, "", NULL },
{ "list", SEC_ADMINISTRATOR, false, &HandleGroupListCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "leader", SEC_ADMINISTRATOR, false, &HandleGroupLeaderCommand, "" },
{ "disband", SEC_ADMINISTRATOR, false, &HandleGroupDisbandCommand, "" },
{ "remove", SEC_ADMINISTRATOR, false, &HandleGroupRemoveCommand, "" },
{ "join", SEC_ADMINISTRATOR, false, &HandleGroupJoinCommand, "" },
{ "list", SEC_ADMINISTRATOR, false, &HandleGroupListCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand petCommandTable[] =
static std::vector<ChatCommand> petCommandTable =
{
{ "create", SEC_GAMEMASTER, false, &HandleCreatePetCommand, "", NULL },
{ "learn", SEC_GAMEMASTER, false, &HandlePetLearnCommand, "", NULL },
{ "unlearn", SEC_GAMEMASTER, false, &HandlePetUnlearnCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "create", SEC_GAMEMASTER, false, &HandleCreatePetCommand, "" },
{ "learn", SEC_GAMEMASTER, false, &HandlePetLearnCommand, "" },
{ "unlearn", SEC_GAMEMASTER, false, &HandlePetUnlearnCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand sendCommandTable[] =
static std::vector<ChatCommand> sendCommandTable =
{
{ "items", SEC_ADMINISTRATOR, true, &HandleSendItemsCommand, "", NULL },
{ "mail", SEC_GAMEMASTER, true, &HandleSendMailCommand, "", NULL },
{ "message", SEC_ADMINISTRATOR, true, &HandleSendMessageCommand, "", NULL },
{ "money", SEC_ADMINISTRATOR, true, &HandleSendMoneyCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "items", SEC_ADMINISTRATOR, true, &HandleSendItemsCommand, "" },
{ "mail", SEC_GAMEMASTER, true, &HandleSendMailCommand, "" },
{ "message", SEC_ADMINISTRATOR, true, &HandleSendMessageCommand, "" },
{ "money", SEC_ADMINISTRATOR, true, &HandleSendMoneyCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "dev", SEC_ADMINISTRATOR, false, &HandleDevCommand, "", NULL },
{ "gps", SEC_ADMINISTRATOR, false, &HandleGPSCommand, "", NULL },
{ "aura", SEC_ADMINISTRATOR, false, &HandleAuraCommand, "", NULL },
{ "unaura", SEC_ADMINISTRATOR, false, &HandleUnAuraCommand, "", NULL },
{ "appear", SEC_GAMEMASTER, false, &HandleAppearCommand, "", NULL },
{ "summon", SEC_GAMEMASTER, false, &HandleSummonCommand, "", NULL },
{ "groupsummon", SEC_GAMEMASTER, false, &HandleGroupSummonCommand, "", NULL },
{ "commands", SEC_PLAYER, true, &HandleCommandsCommand, "", NULL },
{ "die", SEC_ADMINISTRATOR, false, &HandleDieCommand, "", NULL },
{ "revive", SEC_ADMINISTRATOR, true, &HandleReviveCommand, "", NULL },
{ "dismount", SEC_PLAYER, false, &HandleDismountCommand, "", NULL },
{ "guid", SEC_GAMEMASTER, false, &HandleGUIDCommand, "", NULL },
{ "help", SEC_PLAYER, true, &HandleHelpCommand, "", NULL },
{ "itemmove", SEC_GAMEMASTER, false, &HandleItemMoveCommand, "", NULL },
{ "cooldown", SEC_ADMINISTRATOR, false, &HandleCooldownCommand, "", NULL },
{ "distance", SEC_ADMINISTRATOR, false, &HandleGetDistanceCommand, "", NULL },
{ "recall", SEC_GAMEMASTER, false, &HandleRecallCommand, "", NULL },
{ "save", SEC_PLAYER, false, &HandleSaveCommand, "", NULL },
{ "saveall", SEC_GAMEMASTER, true, &HandleSaveAllCommand, "", NULL },
{ "kick", SEC_GAMEMASTER, true, &HandleKickPlayerCommand, "", NULL },
{ "unstuck", SEC_GAMEMASTER, true, &HandleUnstuckCommand, "", NULL },
{ "taxicheat", SEC_GAMEMASTER, false, &HandleTaxiCheatCommand, "", NULL },
{ "linkgrave", SEC_ADMINISTRATOR, false, &HandleLinkGraveCommand, "", NULL },
{ "neargrave", SEC_ADMINISTRATOR, false, &HandleNearGraveCommand, "", NULL },
{ "explorecheat", SEC_ADMINISTRATOR, false, &HandleExploreCheatCommand, "", NULL },
{ "showarea", SEC_ADMINISTRATOR, false, &HandleShowAreaCommand, "", NULL },
{ "hidearea", SEC_ADMINISTRATOR, false, &HandleHideAreaCommand, "", NULL },
{ "additem", SEC_ADMINISTRATOR, false, &HandleAddItemCommand, "", NULL },
{ "additemset", SEC_ADMINISTRATOR, false, &HandleAddItemSetCommand, "", NULL },
{ "bank", SEC_ADMINISTRATOR, false, &HandleBankCommand, "", NULL },
{ "wchange", SEC_ADMINISTRATOR, false, &HandleChangeWeather, "", NULL },
{ "maxskill", SEC_ADMINISTRATOR, false, &HandleMaxSkillCommand, "", NULL },
{ "setskill", SEC_ADMINISTRATOR, false, &HandleSetSkillCommand, "", NULL },
{ "pinfo", SEC_GAMEMASTER, true, &HandlePInfoCommand, "", NULL },
{ "respawn", SEC_ADMINISTRATOR, false, &HandleRespawnCommand, "", NULL },
{ "dev", SEC_ADMINISTRATOR, false, &HandleDevCommand, "" },
{ "gps", SEC_ADMINISTRATOR, false, &HandleGPSCommand, "" },
{ "aura", SEC_ADMINISTRATOR, false, &HandleAuraCommand, "" },
{ "unaura", SEC_ADMINISTRATOR, false, &HandleUnAuraCommand, "" },
{ "appear", SEC_GAMEMASTER, false, &HandleAppearCommand, "" },
{ "summon", SEC_GAMEMASTER, false, &HandleSummonCommand, "" },
{ "groupsummon", SEC_GAMEMASTER, false, &HandleGroupSummonCommand, "" },
{ "commands", SEC_PLAYER, true, &HandleCommandsCommand, "" },
{ "die", SEC_ADMINISTRATOR, false, &HandleDieCommand, "" },
{ "revive", SEC_ADMINISTRATOR, true, &HandleReviveCommand, "" },
{ "dismount", SEC_PLAYER, false, &HandleDismountCommand, "" },
{ "guid", SEC_GAMEMASTER, false, &HandleGUIDCommand, "" },
{ "help", SEC_PLAYER, true, &HandleHelpCommand, "" },
{ "itemmove", SEC_GAMEMASTER, false, &HandleItemMoveCommand, "" },
{ "cooldown", SEC_ADMINISTRATOR, false, &HandleCooldownCommand, "" },
{ "distance", SEC_ADMINISTRATOR, false, &HandleGetDistanceCommand, "" },
{ "recall", SEC_GAMEMASTER, false, &HandleRecallCommand, "" },
{ "save", SEC_PLAYER, false, &HandleSaveCommand, "" },
{ "saveall", SEC_GAMEMASTER, true, &HandleSaveAllCommand, "" },
{ "kick", SEC_GAMEMASTER, true, &HandleKickPlayerCommand, "" },
{ "unstuck", SEC_GAMEMASTER, true, &HandleUnstuckCommand, "" },
{ "taxicheat", SEC_GAMEMASTER, false, &HandleTaxiCheatCommand, "" },
{ "linkgrave", SEC_ADMINISTRATOR, false, &HandleLinkGraveCommand, "" },
{ "neargrave", SEC_ADMINISTRATOR, false, &HandleNearGraveCommand, "" },
{ "explorecheat", SEC_ADMINISTRATOR, false, &HandleExploreCheatCommand, "" },
{ "showarea", SEC_ADMINISTRATOR, false, &HandleShowAreaCommand, "" },
{ "hidearea", SEC_ADMINISTRATOR, false, &HandleHideAreaCommand, "" },
{ "additem", SEC_ADMINISTRATOR, false, &HandleAddItemCommand, "" },
{ "additemset", SEC_ADMINISTRATOR, false, &HandleAddItemSetCommand, "" },
{ "bank", SEC_ADMINISTRATOR, false, &HandleBankCommand, "" },
{ "wchange", SEC_ADMINISTRATOR, false, &HandleChangeWeather, "" },
{ "maxskill", SEC_ADMINISTRATOR, false, &HandleMaxSkillCommand, "" },
{ "setskill", SEC_ADMINISTRATOR, false, &HandleSetSkillCommand, "" },
{ "pinfo", SEC_GAMEMASTER, true, &HandlePInfoCommand, "" },
{ "respawn", SEC_ADMINISTRATOR, false, &HandleRespawnCommand, "" },
{ "send", SEC_GAMEMASTER, true, NULL, "", sendCommandTable },
{ "pet", SEC_GAMEMASTER, false, NULL, "", petCommandTable },
{ "mute", SEC_GAMEMASTER, true, &HandleMuteCommand, "", NULL },
{ "unmute", SEC_GAMEMASTER, true, &HandleUnmuteCommand, "", NULL },
{ "movegens", SEC_ADMINISTRATOR, false, &HandleMovegensCommand, "", NULL },
{ "cometome", SEC_ADMINISTRATOR, false, &HandleComeToMeCommand, "", NULL },
{ "damage", SEC_ADMINISTRATOR, false, &HandleDamageCommand, "", NULL },
{ "combatstop", SEC_GAMEMASTER, true, &HandleCombatStopCommand, "", NULL },
{ "flusharenapoints", SEC_ADMINISTRATOR, false, &HandleFlushArenaPointsCommand, "", NULL },
{ "repairitems", SEC_GAMEMASTER, true, &HandleRepairitemsCommand, "", NULL },
{ "waterwalk", SEC_GAMEMASTER, false, &HandleWaterwalkCommand, "", NULL },
{ "freeze", SEC_GAMEMASTER, false, &HandleFreezeCommand, "", NULL },
{ "unfreeze", SEC_GAMEMASTER, false, &HandleUnFreezeCommand, "", NULL },
{ "mute", SEC_GAMEMASTER, true, &HandleMuteCommand, "" },
{ "unmute", SEC_GAMEMASTER, true, &HandleUnmuteCommand, "" },
{ "movegens", SEC_ADMINISTRATOR, false, &HandleMovegensCommand, "" },
{ "cometome", SEC_ADMINISTRATOR, false, &HandleComeToMeCommand, "" },
{ "damage", SEC_ADMINISTRATOR, false, &HandleDamageCommand, "" },
{ "combatstop", SEC_GAMEMASTER, true, &HandleCombatStopCommand, "" },
{ "flusharenapoints", SEC_ADMINISTRATOR, false, &HandleFlushArenaPointsCommand, "" },
{ "repairitems", SEC_GAMEMASTER, true, &HandleRepairitemsCommand, "" },
{ "waterwalk", SEC_GAMEMASTER, false, &HandleWaterwalkCommand, "" },
{ "freeze", SEC_GAMEMASTER, false, &HandleFreezeCommand, "" },
{ "unfreeze", SEC_GAMEMASTER, false, &HandleUnFreezeCommand, "" },
{ "group", SEC_ADMINISTRATOR, false, NULL, "", groupCommandTable },
{ "possess", SEC_ADMINISTRATOR, false, HandlePossessCommand, "", NULL },
{ "unpossess", SEC_ADMINISTRATOR, false, HandleUnPossessCommand, "", NULL },
{ "bindsight", SEC_ADMINISTRATOR, false, HandleBindSightCommand, "", NULL },
{ "unbindsight", SEC_ADMINISTRATOR, false, HandleUnbindSightCommand, "", NULL },
{ "playall", SEC_GAMEMASTER, false, HandlePlayAllCommand, "", NULL },
{ "skirmish", SEC_ADMINISTRATOR, false, HandleSkirmishCommand, "", NULL },
{ "mailbox", SEC_ADMINISTRATOR, false, &HandleMailBoxCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "possess", SEC_ADMINISTRATOR, false, HandlePossessCommand, "" },
{ "unpossess", SEC_ADMINISTRATOR, false, HandleUnPossessCommand, "" },
{ "bindsight", SEC_ADMINISTRATOR, false, HandleBindSightCommand, "" },
{ "unbindsight", SEC_ADMINISTRATOR, false, HandleUnbindSightCommand, "" },
{ "playall", SEC_GAMEMASTER, false, HandlePlayAllCommand, "" },
{ "skirmish", SEC_ADMINISTRATOR, false, HandleSkirmishCommand, "" },
{ "mailbox", SEC_ADMINISTRATOR, false, &HandleMailBoxCommand, "" },
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

68
src/scripts/Commands/cs_modify.cpp
View File

@@ -24,49 +24,49 @@ class modify_commandscript : public CommandScript
public:
modify_commandscript() : CommandScript("modify_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand modifyspeedCommandTable[] =
static std::vector<ChatCommand> modifyspeedCommandTable =
{
{ "fly", SEC_GAMEMASTER, false, &HandleModifyFlyCommand, "", NULL },
{ "all", SEC_GAMEMASTER, false, &HandleModifyASpeedCommand, "", NULL },
{ "walk", SEC_GAMEMASTER, false, &HandleModifySpeedCommand, "", NULL },
{ "backwalk", SEC_GAMEMASTER, false, &HandleModifyBWalkCommand, "", NULL },
{ "swim", SEC_GAMEMASTER, false, &HandleModifySwimCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleModifyASpeedCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "fly", SEC_GAMEMASTER, false, &HandleModifyFlyCommand, "" },
{ "all", SEC_GAMEMASTER, false, &HandleModifyASpeedCommand, "" },
{ "walk", SEC_GAMEMASTER, false, &HandleModifySpeedCommand, "" },
{ "backwalk", SEC_GAMEMASTER, false, &HandleModifyBWalkCommand, "" },
{ "swim", SEC_GAMEMASTER, false, &HandleModifySwimCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleModifyASpeedCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand modifyCommandTable[] =
static std::vector<ChatCommand> modifyCommandTable =
{
{ "hp", SEC_GAMEMASTER, false, &HandleModifyHPCommand, "", NULL },
{ "mana", SEC_GAMEMASTER, false, &HandleModifyManaCommand, "", NULL },
{ "rage", SEC_GAMEMASTER, false, &HandleModifyRageCommand, "", NULL },
{ "runicpower", SEC_GAMEMASTER, false, &HandleModifyRunicPowerCommand, "", NULL },
{ "energy", SEC_GAMEMASTER, false, &HandleModifyEnergyCommand, "", NULL },
{ "money", SEC_GAMEMASTER, false, &HandleModifyMoneyCommand, "", NULL },
{ "scale", SEC_GAMEMASTER, false, &HandleModifyScaleCommand, "", NULL },
{ "bit", SEC_GAMEMASTER, false, &HandleModifyBitCommand, "", NULL },
{ "faction", SEC_GAMEMASTER, false, &HandleModifyFactionCommand, "", NULL },
{ "spell", SEC_GAMEMASTER, false, &HandleModifySpellCommand, "", NULL },
{ "talentpoints", SEC_GAMEMASTER, false, &HandleModifyTalentCommand, "", NULL },
{ "mount", SEC_GAMEMASTER, false, &HandleModifyMountCommand, "", NULL },
{ "honor", SEC_GAMEMASTER, false, &HandleModifyHonorCommand, "", NULL },
{ "reputation", SEC_GAMEMASTER, false, &HandleModifyRepCommand, "", NULL },
{ "arenapoints", SEC_GAMEMASTER, false, &HandleModifyArenaCommand, "", NULL },
{ "drunk", SEC_GAMEMASTER, false, &HandleModifyDrunkCommand, "", NULL },
{ "standstate", SEC_GAMEMASTER, false, &HandleModifyStandStateCommand, "", NULL },
{ "phase", SEC_ADMINISTRATOR, false, &HandleModifyPhaseCommand, "", NULL },
{ "gender", SEC_GAMEMASTER, false, &HandleModifyGenderCommand, "", NULL },
{ "hp", SEC_GAMEMASTER, false, &HandleModifyHPCommand, "" },
{ "mana", SEC_GAMEMASTER, false, &HandleModifyManaCommand, "" },
{ "rage", SEC_GAMEMASTER, false, &HandleModifyRageCommand, "" },
{ "runicpower", SEC_GAMEMASTER, false, &HandleModifyRunicPowerCommand, "" },
{ "energy", SEC_GAMEMASTER, false, &HandleModifyEnergyCommand, "" },
{ "money", SEC_GAMEMASTER, false, &HandleModifyMoneyCommand, "" },
{ "scale", SEC_GAMEMASTER, false, &HandleModifyScaleCommand, "" },
{ "bit", SEC_GAMEMASTER, false, &HandleModifyBitCommand, "" },
{ "faction", SEC_GAMEMASTER, false, &HandleModifyFactionCommand, "" },
{ "spell", SEC_GAMEMASTER, false, &HandleModifySpellCommand, "" },
{ "talentpoints", SEC_GAMEMASTER, false, &HandleModifyTalentCommand, "" },
{ "mount", SEC_GAMEMASTER, false, &HandleModifyMountCommand, "" },
{ "honor", SEC_GAMEMASTER, false, &HandleModifyHonorCommand, "" },
{ "reputation", SEC_GAMEMASTER, false, &HandleModifyRepCommand, "" },
{ "arenapoints", SEC_GAMEMASTER, false, &HandleModifyArenaCommand, "" },
{ "drunk", SEC_GAMEMASTER, false, &HandleModifyDrunkCommand, "" },
{ "standstate", SEC_GAMEMASTER, false, &HandleModifyStandStateCommand, "" },
{ "phase", SEC_ADMINISTRATOR, false, &HandleModifyPhaseCommand, "" },
{ "gender", SEC_GAMEMASTER, false, &HandleModifyGenderCommand, "" },
{ "speed", SEC_GAMEMASTER, false, NULL, "", modifyspeedCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "morph", SEC_GAMEMASTER, false, &HandleModifyMorphCommand, "", NULL },
{ "demorph", SEC_GAMEMASTER, false, &HandleDeMorphCommand, "", NULL },
{ "morph", SEC_GAMEMASTER, false, &HandleModifyMorphCommand, "" },
{ "demorph", SEC_GAMEMASTER, false, &HandleDeMorphCommand, "" },
{ "modify", SEC_GAMEMASTER, false, NULL, "", modifyCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

92
src/scripts/Commands/cs_npc.cpp
View File

@@ -63,73 +63,73 @@ class npc_commandscript : public CommandScript
public:
npc_commandscript() : CommandScript("npc_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand npcAddCommandTable[] =
static std::vector<ChatCommand> npcAddCommandTable =
{
{ "formation", SEC_GAMEMASTER, false, &HandleNpcAddFormationCommand, "", NULL },
{ "item", SEC_GAMEMASTER, false, &HandleNpcAddVendorItemCommand, "", NULL },
{ "move", SEC_GAMEMASTER, false, &HandleNpcAddMoveCommand, "", NULL },
{ "temp", SEC_GAMEMASTER, false, &HandleNpcAddTempSpawnCommand, "", NULL },
{ "formation", SEC_GAMEMASTER, false, &HandleNpcAddFormationCommand, "" },
{ "item", SEC_GAMEMASTER, false, &HandleNpcAddVendorItemCommand, "" },
{ "move", SEC_GAMEMASTER, false, &HandleNpcAddMoveCommand, "" },
{ "temp", SEC_GAMEMASTER, false, &HandleNpcAddTempSpawnCommand, "" },
//{ TODO: fix or remove this command
{ "weapon", SEC_ADMINISTRATOR, false, &HandleNpcAddWeaponCommand, "", NULL },
{ "weapon", SEC_ADMINISTRATOR, false, &HandleNpcAddWeaponCommand, "" },
//}
{ "", SEC_GAMEMASTER, false, &HandleNpcAddCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "", SEC_GAMEMASTER, false, &HandleNpcAddCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand npcDeleteCommandTable[] =
static std::vector<ChatCommand> npcDeleteCommandTable =
{
{ "item", SEC_GAMEMASTER, false, &HandleNpcDeleteVendorItemCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleNpcDeleteCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "item", SEC_GAMEMASTER, false, &HandleNpcDeleteVendorItemCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleNpcDeleteCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand npcFollowCommandTable[] =
static std::vector<ChatCommand> npcFollowCommandTable =
{
{ "stop", SEC_GAMEMASTER, false, &HandleNpcUnFollowCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleNpcFollowCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "stop", SEC_GAMEMASTER, false, &HandleNpcUnFollowCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleNpcFollowCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand npcSetCommandTable[] =
static std::vector<ChatCommand> npcSetCommandTable =
{
{ "allowmove", SEC_ADMINISTRATOR, false, &HandleNpcSetAllowMovementCommand, "", NULL },
{ "entry", SEC_ADMINISTRATOR, false, &HandleNpcSetEntryCommand, "", NULL },
{ "factionid", SEC_GAMEMASTER, false, &HandleNpcSetFactionIdCommand, "", NULL },
{ "flag", SEC_GAMEMASTER, false, &HandleNpcSetFlagCommand, "", NULL },
{ "level", SEC_GAMEMASTER, false, &HandleNpcSetLevelCommand, "", NULL },
{ "link", SEC_GAMEMASTER, false, &HandleNpcSetLinkCommand, "", NULL },
{ "model", SEC_GAMEMASTER, false, &HandleNpcSetModelCommand, "", NULL },
{ "movetype", SEC_GAMEMASTER, false, &HandleNpcSetMoveTypeCommand, "", NULL },
{ "phase", SEC_GAMEMASTER, false, &HandleNpcSetPhaseCommand, "", NULL },
{ "spawndist", SEC_GAMEMASTER, false, &HandleNpcSetSpawnDistCommand, "", NULL },
{ "spawntime", SEC_GAMEMASTER, false, &HandleNpcSetSpawnTimeCommand, "", NULL },
{ "data", SEC_ADMINISTRATOR, false, &HandleNpcSetDataCommand, "", NULL },
{ "allowmove", SEC_ADMINISTRATOR, false, &HandleNpcSetAllowMovementCommand, "" },
{ "entry", SEC_ADMINISTRATOR, false, &HandleNpcSetEntryCommand, "" },
{ "factionid", SEC_GAMEMASTER, false, &HandleNpcSetFactionIdCommand, "" },
{ "flag", SEC_GAMEMASTER, false, &HandleNpcSetFlagCommand, "" },
{ "level", SEC_GAMEMASTER, false, &HandleNpcSetLevelCommand, "" },
{ "link", SEC_GAMEMASTER, false, &HandleNpcSetLinkCommand, "" },
{ "model", SEC_GAMEMASTER, false, &HandleNpcSetModelCommand, "" },
{ "movetype", SEC_GAMEMASTER, false, &HandleNpcSetMoveTypeCommand, "" },
{ "phase", SEC_GAMEMASTER, false, &HandleNpcSetPhaseCommand, "" },
{ "spawndist", SEC_GAMEMASTER, false, &HandleNpcSetSpawnDistCommand, "" },
{ "spawntime", SEC_GAMEMASTER, false, &HandleNpcSetSpawnTimeCommand, "" },
{ "data", SEC_ADMINISTRATOR, false, &HandleNpcSetDataCommand, "" },
//{ TODO: fix or remove these commands
{ "name", SEC_GAMEMASTER, false, &HandleNpcSetNameCommand, "", NULL },
{ "subname", SEC_GAMEMASTER, false, &HandleNpcSetSubNameCommand, "", NULL },
{ "name", SEC_GAMEMASTER, false, &HandleNpcSetNameCommand, "" },
{ "subname", SEC_GAMEMASTER, false, &HandleNpcSetSubNameCommand, "" },
//}
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
static ChatCommand npcCommandTable[] =
static std::vector<ChatCommand> npcCommandTable =
{
{ "info", SEC_ADMINISTRATOR, false, &HandleNpcInfoCommand, "", NULL },
{ "near", SEC_GAMEMASTER, false, &HandleNpcNearCommand, "", NULL },
{ "move", SEC_GAMEMASTER, false, &HandleNpcMoveCommand, "", NULL },
{ "playemote", SEC_ADMINISTRATOR, false, &HandleNpcPlayEmoteCommand, "", NULL },
{ "say", SEC_GAMEMASTER, false, &HandleNpcSayCommand, "", NULL },
{ "textemote", SEC_GAMEMASTER, false, &HandleNpcTextEmoteCommand, "", NULL },
{ "whisper", SEC_GAMEMASTER, false, &HandleNpcWhisperCommand, "", NULL },
{ "yell", SEC_GAMEMASTER, false, &HandleNpcYellCommand, "", NULL },
{ "tame", SEC_GAMEMASTER, false, &HandleNpcTameCommand, "", NULL },
{ "info", SEC_ADMINISTRATOR, false, &HandleNpcInfoCommand, "" },
{ "near", SEC_GAMEMASTER, false, &HandleNpcNearCommand, "" },
{ "move", SEC_GAMEMASTER, false, &HandleNpcMoveCommand, "" },
{ "playemote", SEC_ADMINISTRATOR, false, &HandleNpcPlayEmoteCommand, "" },
{ "say", SEC_GAMEMASTER, false, &HandleNpcSayCommand, "" },
{ "textemote", SEC_GAMEMASTER, false, &HandleNpcTextEmoteCommand, "" },
{ "whisper", SEC_GAMEMASTER, false, &HandleNpcWhisperCommand, "" },
{ "yell", SEC_GAMEMASTER, false, &HandleNpcYellCommand, "" },
{ "tame", SEC_GAMEMASTER, false, &HandleNpcTameCommand, "" },
{ "add", SEC_GAMEMASTER, false, NULL, "", npcAddCommandTable },
{ "delete", SEC_GAMEMASTER, false, NULL, "", npcDeleteCommandTable },
{ "follow", SEC_GAMEMASTER, false, NULL, "", npcFollowCommandTable },
{ "set", SEC_GAMEMASTER, false, NULL, "", npcSetCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "npc", SEC_GAMEMASTER, false, NULL, "", npcCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

18
src/scripts/Commands/cs_quest.cpp
View File

@@ -22,20 +22,20 @@ class quest_commandscript : public CommandScript
public:
quest_commandscript() : CommandScript("quest_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand questCommandTable[] =
static std::vector<ChatCommand> questCommandTable =
{
{ "add", SEC_ADMINISTRATOR, false, &HandleQuestAdd, "", NULL },
{ "complete", SEC_ADMINISTRATOR, false, &HandleQuestComplete, "", NULL },
{ "remove", SEC_ADMINISTRATOR, false, &HandleQuestRemove, "", NULL },
{ "reward", SEC_ADMINISTRATOR, false, &HandleQuestReward, "", NULL },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ "add", SEC_ADMINISTRATOR, false, &HandleQuestAdd, "" },
{ "complete", SEC_ADMINISTRATOR, false, &HandleQuestComplete, "" },
{ "remove", SEC_ADMINISTRATOR, false, &HandleQuestRemove, "" },
{ "reward", SEC_ADMINISTRATOR, false, &HandleQuestReward, "" },
{ NULL, SEC_PLAYER, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "quest", SEC_ADMINISTRATOR, false, NULL, "", questCommandTable },
{ NULL, SEC_PLAYER, false, NULL, "", NULL }
{ NULL, SEC_PLAYER, false, NULL, "" }
};
return commandTable;
}

204
src/scripts/Commands/cs_reload.cpp
View File

@@ -34,118 +34,118 @@ class reload_commandscript : public CommandScript
public:
reload_commandscript() : CommandScript("reload_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand reloadAllCommandTable[] =
static std::vector<ChatCommand> reloadAllCommandTable =
{
{ "achievement", SEC_ADMINISTRATOR, true, &HandleReloadAllAchievementCommand, "", NULL },
{ "area", SEC_ADMINISTRATOR, true, &HandleReloadAllAreaCommand, "", NULL },
{ "gossips", SEC_ADMINISTRATOR, true, &HandleReloadAllGossipsCommand, "", NULL },
{ "item", SEC_ADMINISTRATOR, true, &HandleReloadAllItemCommand, "", NULL },
{ "locales", SEC_ADMINISTRATOR, true, &HandleReloadAllLocalesCommand, "", NULL },
{ "loot", SEC_ADMINISTRATOR, true, &HandleReloadAllLootCommand, "", NULL },
{ "npc", SEC_ADMINISTRATOR, true, &HandleReloadAllNpcCommand, "", NULL },
{ "quest", SEC_ADMINISTRATOR, true, &HandleReloadAllQuestCommand, "", NULL },
{ "scripts", SEC_ADMINISTRATOR, true, &HandleReloadAllScriptsCommand, "", NULL },
{ "spell", SEC_ADMINISTRATOR, true, &HandleReloadAllSpellCommand, "", NULL },
{ "", SEC_ADMINISTRATOR, true, &HandleReloadAllCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "achievement", SEC_ADMINISTRATOR, true, &HandleReloadAllAchievementCommand, "" },
{ "area", SEC_ADMINISTRATOR, true, &HandleReloadAllAreaCommand, "" },
{ "gossips", SEC_ADMINISTRATOR, true, &HandleReloadAllGossipsCommand, "" },
{ "item", SEC_ADMINISTRATOR, true, &HandleReloadAllItemCommand, "" },
{ "locales", SEC_ADMINISTRATOR, true, &HandleReloadAllLocalesCommand, "" },
{ "loot", SEC_ADMINISTRATOR, true, &HandleReloadAllLootCommand, "" },
{ "npc", SEC_ADMINISTRATOR, true, &HandleReloadAllNpcCommand, "" },
{ "quest", SEC_ADMINISTRATOR, true, &HandleReloadAllQuestCommand, "" },
{ "scripts", SEC_ADMINISTRATOR, true, &HandleReloadAllScriptsCommand, "" },
{ "spell", SEC_ADMINISTRATOR, true, &HandleReloadAllSpellCommand, "" },
{ "", SEC_ADMINISTRATOR, true, &HandleReloadAllCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand reloadCommandTable[] =
static std::vector<ChatCommand> reloadCommandTable =
{
{ "auctions", SEC_ADMINISTRATOR, true, &HandleReloadAuctionsCommand, "", NULL },
{ "access_requirement", SEC_ADMINISTRATOR, true, &HandleReloadAccessRequirementCommand, "", NULL },
{ "achievement_criteria_data", SEC_ADMINISTRATOR, true, &HandleReloadAchievementCriteriaDataCommand, "", NULL },
{ "achievement_reward", SEC_ADMINISTRATOR, true, &HandleReloadAchievementRewardCommand, "", NULL },
{ "auctions", SEC_ADMINISTRATOR, true, &HandleReloadAuctionsCommand, "" },
{ "access_requirement", SEC_ADMINISTRATOR, true, &HandleReloadAccessRequirementCommand, "" },
{ "achievement_criteria_data", SEC_ADMINISTRATOR, true, &HandleReloadAchievementCriteriaDataCommand, "" },
{ "achievement_reward", SEC_ADMINISTRATOR, true, &HandleReloadAchievementRewardCommand, "" },
{ "all", SEC_ADMINISTRATOR, true, NULL, "", reloadAllCommandTable },
{ "areatrigger_involvedrelation", SEC_ADMINISTRATOR, true, &HandleReloadQuestAreaTriggersCommand, "", NULL },
{ "areatrigger_tavern", SEC_ADMINISTRATOR, true, &HandleReloadAreaTriggerTavernCommand, "", NULL },
{ "areatrigger_teleport", SEC_ADMINISTRATOR, true, &HandleReloadAreaTriggerTeleportCommand, "", NULL },
{ "autobroadcast", SEC_ADMINISTRATOR, true, &HandleReloadAutobroadcastCommand, "", NULL },
{ "command", SEC_ADMINISTRATOR, true, &HandleReloadCommandCommand, "", NULL },
{ "conditions", SEC_ADMINISTRATOR, true, &HandleReloadConditions, "", NULL },
{ "config", SEC_ADMINISTRATOR, true, &HandleReloadConfigCommand, "", NULL },
{ "creature_text", SEC_ADMINISTRATOR, true, &HandleReloadCreatureText, "", NULL },
{ "creature_questender", SEC_ADMINISTRATOR, true, &HandleReloadCreatureQuestEnderCommand, "", NULL },
{ "creature_linked_respawn", SEC_GAMEMASTER, true, &HandleReloadLinkedRespawnCommand, "", NULL },
{ "creature_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesCreatureCommand, "", NULL },
{ "creature_onkill_reputation", SEC_ADMINISTRATOR, true, &HandleReloadOnKillReputationCommand, "", NULL },
{ "creature_queststarter", SEC_ADMINISTRATOR, true, &HandleReloadCreatureQuestStarterCommand, "", NULL },
{ "creature_template", SEC_ADMINISTRATOR, true, &HandleReloadCreatureTemplateCommand, "", NULL },
//{ "db_script_string", SEC_ADMINISTRATOR, true, &HandleReloadDbScriptStringCommand, "", NULL },
{ "disables", SEC_ADMINISTRATOR, true, &HandleReloadDisablesCommand, "", NULL },
{ "disenchant_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesDisenchantCommand, "", NULL },
{ "event_scripts", SEC_ADMINISTRATOR, true, &HandleReloadEventScriptsCommand, "", NULL },
{ "fishing_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesFishingCommand, "", NULL },
{ "game_graveyard_zone", SEC_ADMINISTRATOR, true, &HandleReloadGameGraveyardZoneCommand, "", NULL },
{ "game_tele", SEC_ADMINISTRATOR, true, &HandleReloadGameTeleCommand, "", NULL },
{ "gameobject_questender", SEC_ADMINISTRATOR, true, &HandleReloadGOQuestEnderCommand, "", NULL },
{ "gameobject_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesGameobjectCommand, "", NULL },
{ "gameobject_queststarter", SEC_ADMINISTRATOR, true, &HandleReloadGOQuestStarterCommand, "", NULL },
{ "gm_tickets", SEC_ADMINISTRATOR, true, &HandleReloadGMTicketsCommand, "", NULL },
{ "gossip_menu", SEC_ADMINISTRATOR, true, &HandleReloadGossipMenuCommand, "", NULL },
{ "gossip_menu_option", SEC_ADMINISTRATOR, true, &HandleReloadGossipMenuOptionCommand, "", NULL },
{ "item_enchantment_template", SEC_ADMINISTRATOR, true, &HandleReloadItemEnchantementsCommand, "", NULL },
{ "item_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesItemCommand, "", NULL },
{ "item_set_names", SEC_ADMINISTRATOR, true, &HandleReloadItemSetNamesCommand, "", NULL },
{ "lfg_dungeon_rewards", SEC_ADMINISTRATOR, true, &HandleReloadLfgRewardsCommand, "", NULL },
{ "locales_achievement_reward", SEC_ADMINISTRATOR, true, &HandleReloadLocalesAchievementRewardCommand, "", NULL },
{ "locales_creature", SEC_ADMINISTRATOR, true, &HandleReloadLocalesCreatureCommand, "", NULL },
{ "locales_creature_text", SEC_ADMINISTRATOR, true, &HandleReloadLocalesCreatureTextCommand, "", NULL },
{ "locales_gameobject", SEC_ADMINISTRATOR, true, &HandleReloadLocalesGameobjectCommand, "", NULL },
{ "locales_gossip_menu_option", SEC_ADMINISTRATOR, true, &HandleReloadLocalesGossipMenuOptionCommand, "", NULL },
{ "locales_item", SEC_ADMINISTRATOR, true, &HandleReloadLocalesItemCommand, "", NULL },
{ "locales_item_set_name", SEC_ADMINISTRATOR, true, &HandleReloadLocalesItemSetNameCommand, "", NULL },
{ "locales_npc_text", SEC_ADMINISTRATOR, true, &HandleReloadLocalesNpcTextCommand, "", NULL },
{ "locales_page_text", SEC_ADMINISTRATOR, true, &HandleReloadLocalesPageTextCommand, "", NULL },
{ "locales_points_of_interest", SEC_ADMINISTRATOR, true, &HandleReloadLocalesPointsOfInterestCommand, "", NULL },
{ "locales_quest", SEC_ADMINISTRATOR, true, &HandleReloadLocalesQuestCommand, "", NULL },
{ "mail_level_reward", SEC_ADMINISTRATOR, true, &HandleReloadMailLevelRewardCommand, "", NULL },
{ "mail_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesMailCommand, "", NULL },
{ "milling_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesMillingCommand, "", NULL },
{ "areatrigger_involvedrelation", SEC_ADMINISTRATOR, true, &HandleReloadQuestAreaTriggersCommand, "" },
{ "areatrigger_tavern", SEC_ADMINISTRATOR, true, &HandleReloadAreaTriggerTavernCommand, "" },
{ "areatrigger_teleport", SEC_ADMINISTRATOR, true, &HandleReloadAreaTriggerTeleportCommand, "" },
{ "autobroadcast", SEC_ADMINISTRATOR, true, &HandleReloadAutobroadcastCommand, "" },
{ "command", SEC_ADMINISTRATOR, true, &HandleReloadCommandCommand, "" },
{ "conditions", SEC_ADMINISTRATOR, true, &HandleReloadConditions, "" },
{ "config", SEC_ADMINISTRATOR, true, &HandleReloadConfigCommand, "" },
{ "creature_text", SEC_ADMINISTRATOR, true, &HandleReloadCreatureText, "" },
{ "creature_questender", SEC_ADMINISTRATOR, true, &HandleReloadCreatureQuestEnderCommand, "" },
{ "creature_linked_respawn", SEC_GAMEMASTER, true, &HandleReloadLinkedRespawnCommand, "" },
{ "creature_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesCreatureCommand, "" },
{ "creature_onkill_reputation", SEC_ADMINISTRATOR, true, &HandleReloadOnKillReputationCommand, "" },
{ "creature_queststarter", SEC_ADMINISTRATOR, true, &HandleReloadCreatureQuestStarterCommand, "" },
{ "creature_template", SEC_ADMINISTRATOR, true, &HandleReloadCreatureTemplateCommand, "" },
//{ "db_script_string", SEC_ADMINISTRATOR, true, &HandleReloadDbScriptStringCommand, "" },
{ "disables", SEC_ADMINISTRATOR, true, &HandleReloadDisablesCommand, "" },
{ "disenchant_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesDisenchantCommand, "" },
{ "event_scripts", SEC_ADMINISTRATOR, true, &HandleReloadEventScriptsCommand, "" },
{ "fishing_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesFishingCommand, "" },
{ "game_graveyard_zone", SEC_ADMINISTRATOR, true, &HandleReloadGameGraveyardZoneCommand, "" },
{ "game_tele", SEC_ADMINISTRATOR, true, &HandleReloadGameTeleCommand, "" },
{ "gameobject_questender", SEC_ADMINISTRATOR, true, &HandleReloadGOQuestEnderCommand, "" },
{ "gameobject_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesGameobjectCommand, "" },
{ "gameobject_queststarter", SEC_ADMINISTRATOR, true, &HandleReloadGOQuestStarterCommand, "" },
{ "gm_tickets", SEC_ADMINISTRATOR, true, &HandleReloadGMTicketsCommand, "" },
{ "gossip_menu", SEC_ADMINISTRATOR, true, &HandleReloadGossipMenuCommand, "" },
{ "gossip_menu_option", SEC_ADMINISTRATOR, true, &HandleReloadGossipMenuOptionCommand, "" },
{ "item_enchantment_template", SEC_ADMINISTRATOR, true, &HandleReloadItemEnchantementsCommand, "" },
{ "item_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesItemCommand, "" },
{ "item_set_names", SEC_ADMINISTRATOR, true, &HandleReloadItemSetNamesCommand, "" },
{ "lfg_dungeon_rewards", SEC_ADMINISTRATOR, true, &HandleReloadLfgRewardsCommand, "" },
{ "locales_achievement_reward", SEC_ADMINISTRATOR, true, &HandleReloadLocalesAchievementRewardCommand, "" },
{ "locales_creature", SEC_ADMINISTRATOR, true, &HandleReloadLocalesCreatureCommand, "" },
{ "locales_creature_text", SEC_ADMINISTRATOR, true, &HandleReloadLocalesCreatureTextCommand, "" },
{ "locales_gameobject", SEC_ADMINISTRATOR, true, &HandleReloadLocalesGameobjectCommand, "" },
{ "locales_gossip_menu_option", SEC_ADMINISTRATOR, true, &HandleReloadLocalesGossipMenuOptionCommand, "" },
{ "locales_item", SEC_ADMINISTRATOR, true, &HandleReloadLocalesItemCommand, "" },
{ "locales_item_set_name", SEC_ADMINISTRATOR, true, &HandleReloadLocalesItemSetNameCommand, "" },
{ "locales_npc_text", SEC_ADMINISTRATOR, true, &HandleReloadLocalesNpcTextCommand, "" },
{ "locales_page_text", SEC_ADMINISTRATOR, true, &HandleReloadLocalesPageTextCommand, "" },
{ "locales_points_of_interest", SEC_ADMINISTRATOR, true, &HandleReloadLocalesPointsOfInterestCommand, "" },
{ "locales_quest", SEC_ADMINISTRATOR, true, &HandleReloadLocalesQuestCommand, "" },
{ "mail_level_reward", SEC_ADMINISTRATOR, true, &HandleReloadMailLevelRewardCommand, "" },
{ "mail_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesMailCommand, "" },
{ "milling_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesMillingCommand, "" },
{ "npc_spellclick_spells", SEC_ADMINISTRATOR, true, &HandleReloadSpellClickSpellsCommand, "", NULL},
{ "npc_trainer", SEC_ADMINISTRATOR, true, &HandleReloadNpcTrainerCommand, "", NULL },
{ "npc_vendor", SEC_ADMINISTRATOR, true, &HandleReloadNpcVendorCommand, "", NULL },
{ "page_text", SEC_ADMINISTRATOR, true, &HandleReloadPageTextsCommand, "", NULL },
{ "npc_trainer", SEC_ADMINISTRATOR, true, &HandleReloadNpcTrainerCommand, "" },
{ "npc_vendor", SEC_ADMINISTRATOR, true, &HandleReloadNpcVendorCommand, "" },
{ "page_text", SEC_ADMINISTRATOR, true, &HandleReloadPageTextsCommand, "" },
{ "pickpocketing_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesPickpocketingCommand, "", NULL},
{ "points_of_interest", SEC_ADMINISTRATOR, true, &HandleReloadPointsOfInterestCommand, "", NULL },
{ "prospecting_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesProspectingCommand, "", NULL },
{ "quest_poi", SEC_ADMINISTRATOR, true, &HandleReloadQuestPOICommand, "", NULL },
{ "quest_template", SEC_ADMINISTRATOR, true, &HandleReloadQuestTemplateCommand, "", NULL },
{ "reference_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesReferenceCommand, "", NULL },
{ "reserved_name", SEC_ADMINISTRATOR, true, &HandleReloadReservedNameCommand, "", NULL },
{ "reputation_reward_rate", SEC_ADMINISTRATOR, true, &HandleReloadReputationRewardRateCommand, "", NULL },
{ "reputation_spillover_template", SEC_ADMINISTRATOR, true, &HandleReloadReputationRewardRateCommand, "", NULL },
{ "skill_discovery_template", SEC_ADMINISTRATOR, true, &HandleReloadSkillDiscoveryTemplateCommand, "", NULL },
{ "skill_extra_item_template", SEC_ADMINISTRATOR, true, &HandleReloadSkillExtraItemTemplateCommand, "", NULL },
{ "skill_fishing_base_level", SEC_ADMINISTRATOR, true, &HandleReloadSkillFishingBaseLevelCommand, "", NULL },
{ "skinning_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesSkinningCommand, "", NULL },
{ "smart_scripts", SEC_ADMINISTRATOR, true, &HandleReloadSmartScripts, "", NULL },
{ "spell_required", SEC_ADMINISTRATOR, true, &HandleReloadSpellRequiredCommand, "", NULL },
{ "spell_area", SEC_ADMINISTRATOR, true, &HandleReloadSpellAreaCommand, "", NULL },
{ "spell_bonus_data", SEC_ADMINISTRATOR, true, &HandleReloadSpellBonusesCommand, "", NULL },
{ "spell_group", SEC_ADMINISTRATOR, true, &HandleReloadSpellGroupsCommand, "", NULL },
{ "spell_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesSpellCommand, "", NULL },
{ "spell_linked_spell", SEC_ADMINISTRATOR, true, &HandleReloadSpellLinkedSpellCommand, "", NULL },
{ "spell_pet_auras", SEC_ADMINISTRATOR, true, &HandleReloadSpellPetAurasCommand, "", NULL },
{ "spell_proc_event", SEC_ADMINISTRATOR, true, &HandleReloadSpellProcEventCommand, "", NULL },
{ "spell_proc", SEC_ADMINISTRATOR, true, &HandleReloadSpellProcsCommand, "", NULL },
{ "spell_scripts", SEC_ADMINISTRATOR, true, &HandleReloadSpellScriptsCommand, "", NULL },
{ "spell_target_position", SEC_ADMINISTRATOR, true, &HandleReloadSpellTargetPositionCommand, "", NULL },
{ "spell_threats", SEC_ADMINISTRATOR, true, &HandleReloadSpellThreatsCommand, "", NULL },
{ "spell_group_stack_rules", SEC_ADMINISTRATOR, true, &HandleReloadSpellGroupStackRulesCommand, "", NULL },
{ "trinity_string", SEC_ADMINISTRATOR, true, &HandleReloadTrinityStringCommand, "", NULL },
{ "warden_action", SEC_ADMINISTRATOR, true, &HandleReloadWardenactionCommand, "", NULL },
{ "waypoint_scripts", SEC_ADMINISTRATOR, true, &HandleReloadWpScriptsCommand, "", NULL },
{ "waypoint_data", SEC_ADMINISTRATOR, true, &HandleReloadWpCommand, "", NULL },
{ "vehicle_accessory", SEC_ADMINISTRATOR, true, &HandleReloadVehicleAccessoryCommand, "", NULL },
{ "vehicle_template_accessory", SEC_ADMINISTRATOR, true, &HandleReloadVehicleTemplateAccessoryCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "points_of_interest", SEC_ADMINISTRATOR, true, &HandleReloadPointsOfInterestCommand, "" },
{ "prospecting_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesProspectingCommand, "" },
{ "quest_poi", SEC_ADMINISTRATOR, true, &HandleReloadQuestPOICommand, "" },
{ "quest_template", SEC_ADMINISTRATOR, true, &HandleReloadQuestTemplateCommand, "" },
{ "reference_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesReferenceCommand, "" },
{ "reserved_name", SEC_ADMINISTRATOR, true, &HandleReloadReservedNameCommand, "" },
{ "reputation_reward_rate", SEC_ADMINISTRATOR, true, &HandleReloadReputationRewardRateCommand, "" },
{ "reputation_spillover_template", SEC_ADMINISTRATOR, true, &HandleReloadReputationRewardRateCommand, "" },
{ "skill_discovery_template", SEC_ADMINISTRATOR, true, &HandleReloadSkillDiscoveryTemplateCommand, "" },
{ "skill_extra_item_template", SEC_ADMINISTRATOR, true, &HandleReloadSkillExtraItemTemplateCommand, "" },
{ "skill_fishing_base_level", SEC_ADMINISTRATOR, true, &HandleReloadSkillFishingBaseLevelCommand, "" },
{ "skinning_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesSkinningCommand, "" },
{ "smart_scripts", SEC_ADMINISTRATOR, true, &HandleReloadSmartScripts, "" },
{ "spell_required", SEC_ADMINISTRATOR, true, &HandleReloadSpellRequiredCommand, "" },
{ "spell_area", SEC_ADMINISTRATOR, true, &HandleReloadSpellAreaCommand, "" },
{ "spell_bonus_data", SEC_ADMINISTRATOR, true, &HandleReloadSpellBonusesCommand, "" },
{ "spell_group", SEC_ADMINISTRATOR, true, &HandleReloadSpellGroupsCommand, "" },
{ "spell_loot_template", SEC_ADMINISTRATOR, true, &HandleReloadLootTemplatesSpellCommand, "" },
{ "spell_linked_spell", SEC_ADMINISTRATOR, true, &HandleReloadSpellLinkedSpellCommand, "" },
{ "spell_pet_auras", SEC_ADMINISTRATOR, true, &HandleReloadSpellPetAurasCommand, "" },
{ "spell_proc_event", SEC_ADMINISTRATOR, true, &HandleReloadSpellProcEventCommand, "" },
{ "spell_proc", SEC_ADMINISTRATOR, true, &HandleReloadSpellProcsCommand, "" },
{ "spell_scripts", SEC_ADMINISTRATOR, true, &HandleReloadSpellScriptsCommand, "" },
{ "spell_target_position", SEC_ADMINISTRATOR, true, &HandleReloadSpellTargetPositionCommand, "" },
{ "spell_threats", SEC_ADMINISTRATOR, true, &HandleReloadSpellThreatsCommand, "" },
{ "spell_group_stack_rules", SEC_ADMINISTRATOR, true, &HandleReloadSpellGroupStackRulesCommand, "" },
{ "trinity_string", SEC_ADMINISTRATOR, true, &HandleReloadTrinityStringCommand, "" },
{ "warden_action", SEC_ADMINISTRATOR, true, &HandleReloadWardenactionCommand, "" },
{ "waypoint_scripts", SEC_ADMINISTRATOR, true, &HandleReloadWpScriptsCommand, "" },
{ "waypoint_data", SEC_ADMINISTRATOR, true, &HandleReloadWpCommand, "" },
{ "vehicle_accessory", SEC_ADMINISTRATOR, true, &HandleReloadVehicleAccessoryCommand, "" },
{ "vehicle_template_accessory", SEC_ADMINISTRATOR, true, &HandleReloadVehicleTemplateAccessoryCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "reload", SEC_ADMINISTRATOR, true, NULL, "", reloadCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

24
src/scripts/Commands/cs_reset.cpp
View File

@@ -24,23 +24,23 @@ class reset_commandscript : public CommandScript
public:
reset_commandscript() : CommandScript("reset_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand resetCommandTable[] =
static std::vector<ChatCommand> resetCommandTable =
{
{ "achievements", SEC_ADMINISTRATOR, true, &HandleResetAchievementsCommand, "", NULL },
{ "honor", SEC_ADMINISTRATOR, true, &HandleResetHonorCommand, "", NULL },
{ "level", SEC_ADMINISTRATOR, true, &HandleResetLevelCommand, "", NULL },
{ "spells", SEC_ADMINISTRATOR, true, &HandleResetSpellsCommand, "", NULL },
{ "stats", SEC_ADMINISTRATOR, true, &HandleResetStatsCommand, "", NULL },
{ "talents", SEC_ADMINISTRATOR, true, &HandleResetTalentsCommand, "", NULL },
{ "all", SEC_ADMINISTRATOR, true, &HandleResetAllCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "achievements", SEC_ADMINISTRATOR, true, &HandleResetAchievementsCommand, "" },
{ "honor", SEC_ADMINISTRATOR, true, &HandleResetHonorCommand, "" },
{ "level", SEC_ADMINISTRATOR, true, &HandleResetLevelCommand, "" },
{ "spells", SEC_ADMINISTRATOR, true, &HandleResetSpellsCommand, "" },
{ "stats", SEC_ADMINISTRATOR, true, &HandleResetStatsCommand, "" },
{ "talents", SEC_ADMINISTRATOR, true, &HandleResetTalentsCommand, "" },
{ "all", SEC_ADMINISTRATOR, true, &HandleResetAllCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "reset", SEC_ADMINISTRATOR, true, NULL, "", resetCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

66
src/scripts/Commands/cs_server.cpp
View File

@@ -25,65 +25,65 @@ class server_commandscript : public CommandScript
public:
server_commandscript() : CommandScript("server_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand serverIdleRestartCommandTable[] =
static std::vector<ChatCommand> serverIdleRestartCommandTable =
{
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "", NULL },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerIdleRestartCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "" },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerIdleRestartCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand serverIdleShutdownCommandTable[] =
static std::vector<ChatCommand> serverIdleShutdownCommandTable =
{
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "", NULL },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerIdleShutDownCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "" },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerIdleShutDownCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand serverRestartCommandTable[] =
static std::vector<ChatCommand> serverRestartCommandTable =
{
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "", NULL },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerRestartCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "" },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerRestartCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand serverShutdownCommandTable[] =
static std::vector<ChatCommand> serverShutdownCommandTable =
{
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "", NULL },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerShutDownCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "cancel", SEC_ADMINISTRATOR, true, &HandleServerShutDownCancelCommand, "" },
{ "" , SEC_ADMINISTRATOR, true, &HandleServerShutDownCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand serverSetCommandTable[] =
static std::vector<ChatCommand> serverSetCommandTable =
{
{ "difftime", SEC_CONSOLE, true, &HandleServerSetDiffTimeCommand, "", NULL },
{ "loglevel", SEC_CONSOLE, true, &HandleServerSetLogLevelCommand, "", NULL },
{ "logfilelevel", SEC_CONSOLE, true, &HandleServerSetLogFileLevelCommand, "", NULL },
{ "motd", SEC_ADMINISTRATOR, true, &HandleServerSetMotdCommand, "", NULL },
{ "closed", SEC_ADMINISTRATOR, true, &HandleServerSetClosedCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "difftime", SEC_CONSOLE, true, &HandleServerSetDiffTimeCommand, "" },
{ "loglevel", SEC_CONSOLE, true, &HandleServerSetLogLevelCommand, "" },
{ "logfilelevel", SEC_CONSOLE, true, &HandleServerSetLogFileLevelCommand, "" },
{ "motd", SEC_ADMINISTRATOR, true, &HandleServerSetMotdCommand, "" },
{ "closed", SEC_ADMINISTRATOR, true, &HandleServerSetClosedCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand serverCommandTable[] =
static std::vector<ChatCommand> serverCommandTable =
{
{ "corpses", SEC_GAMEMASTER, true, &HandleServerCorpsesCommand, "", NULL },
{ "exit", SEC_CONSOLE, true, &HandleServerExitCommand, "", NULL },
{ "corpses", SEC_GAMEMASTER, true, &HandleServerCorpsesCommand, "" },
{ "exit", SEC_CONSOLE, true, &HandleServerExitCommand, "" },
{ "idlerestart", SEC_ADMINISTRATOR, true, NULL, "", serverIdleRestartCommandTable },
{ "idleshutdown", SEC_ADMINISTRATOR, true, NULL, "", serverIdleShutdownCommandTable },
{ "info", SEC_PLAYER, true, &HandleServerInfoCommand, "", NULL },
{ "motd", SEC_PLAYER, true, &HandleServerMotdCommand, "", NULL },
{ "info", SEC_PLAYER, true, &HandleServerInfoCommand, "" },
{ "motd", SEC_PLAYER, true, &HandleServerMotdCommand, "" },
{ "restart", SEC_ADMINISTRATOR, true, NULL, "", serverRestartCommandTable },
{ "shutdown", SEC_ADMINISTRATOR, true, NULL, "", serverShutdownCommandTable },
{ "set", SEC_ADMINISTRATOR, true, NULL, "", serverSetCommandTable },
{ "togglequerylog", SEC_CONSOLE, true, &HandleServerToggleQueryLogging, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "togglequerylog", SEC_CONSOLE, true, &HandleServerToggleQueryLogging, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "server", SEC_ADMINISTRATOR, true, NULL, "", serverCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

22
src/scripts/Commands/cs_spectator.cpp
View File

@@ -16,22 +16,22 @@ class spectator_commandscript : public CommandScript
public:
spectator_commandscript() : CommandScript("spectator_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand spectatorCommandTable[] =
static std::vector<ChatCommand> spectatorCommandTable =
{
{ "version", SEC_CONSOLE, false, &HandleSpectatorVersionCommand, "", NULL },
{ "reset", SEC_CONSOLE, false, &HandleSpectatorResetCommand, "", NULL },
{ "spectate", SEC_CONSOLE, false, &ArenaSpectator::HandleSpectatorSpectateCommand, "", NULL },
{ "watch", SEC_CONSOLE, false, &ArenaSpectator::HandleSpectatorWatchCommand, "", NULL },
{ "leave", SEC_CONSOLE, false, &HandleSpectatorLeaveCommand, "", NULL },
{ "", SEC_CONSOLE, false, &HandleSpectatorCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "version", SEC_CONSOLE, false, &HandleSpectatorVersionCommand, "" },
{ "reset", SEC_CONSOLE, false, &HandleSpectatorResetCommand, "" },
{ "spectate", SEC_CONSOLE, false, &ArenaSpectator::HandleSpectatorSpectateCommand, "" },
{ "watch", SEC_CONSOLE, false, &ArenaSpectator::HandleSpectatorWatchCommand, "" },
{ "leave", SEC_CONSOLE, false, &HandleSpectatorLeaveCommand, "" },
{ "", SEC_CONSOLE, false, &HandleSpectatorCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "spect", SEC_CONSOLE, false, NULL, "", spectatorCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

20
src/scripts/Commands/cs_tele.cpp
View File

@@ -24,21 +24,21 @@ class tele_commandscript : public CommandScript
public:
tele_commandscript() : CommandScript("tele_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand teleCommandTable[] =
static std::vector<ChatCommand> teleCommandTable =
{
{ "add", SEC_ADMINISTRATOR, false, &HandleTeleAddCommand, "", NULL },
{ "del", SEC_ADMINISTRATOR, true, &HandleTeleDelCommand, "", NULL },
{ "name", SEC_GAMEMASTER, true, &HandleTeleNameCommand, "", NULL },
{ "group", SEC_GAMEMASTER, false, &HandleTeleGroupCommand, "", NULL },
{ "", SEC_GAMEMASTER, false, &HandleTeleCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "add", SEC_ADMINISTRATOR, false, &HandleTeleAddCommand, "" },
{ "del", SEC_ADMINISTRATOR, true, &HandleTeleDelCommand, "" },
{ "name", SEC_GAMEMASTER, true, &HandleTeleNameCommand, "" },
{ "group", SEC_GAMEMASTER, false, &HandleTeleGroupCommand, "" },
{ "", SEC_GAMEMASTER, false, &HandleTeleCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "tele", SEC_GAMEMASTER, false, NULL, "", teleCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

48
src/scripts/Commands/cs_ticket.cpp
View File

@@ -25,38 +25,38 @@ class ticket_commandscript : public CommandScript
public:
ticket_commandscript() : CommandScript("ticket_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand ticketResponseCommandTable[] =
static std::vector<ChatCommand> ticketResponseCommandTable =
{
{ "append", SEC_GAMEMASTER, true, &HandleGMTicketResponseAppendCommand, "", NULL },
{ "appendln", SEC_GAMEMASTER, true, &HandleGMTicketResponseAppendLnCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "append", SEC_GAMEMASTER, true, &HandleGMTicketResponseAppendCommand, "" },
{ "appendln", SEC_GAMEMASTER, true, &HandleGMTicketResponseAppendLnCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand ticketCommandTable[] =
static std::vector<ChatCommand> ticketCommandTable =
{
{ "assign", SEC_GAMEMASTER, true, &HandleGMTicketAssignToCommand, "", NULL },
{ "close", SEC_GAMEMASTER, true, &HandleGMTicketCloseByIdCommand, "", NULL },
{ "closedlist", SEC_GAMEMASTER, true, &HandleGMTicketListClosedCommand, "", NULL },
{ "comment", SEC_GAMEMASTER, true, &HandleGMTicketCommentCommand, "", NULL },
{ "complete", SEC_GAMEMASTER, true, &HandleGMTicketCompleteCommand, "", NULL },
{ "delete", SEC_ADMINISTRATOR, true, &HandleGMTicketDeleteByIdCommand, "", NULL },
{ "escalate", SEC_GAMEMASTER, true, &HandleGMTicketEscalateCommand, "", NULL },
{ "escalatedlist", SEC_GAMEMASTER, true, &HandleGMTicketListEscalatedCommand, "", NULL },
{ "list", SEC_GAMEMASTER, true, &HandleGMTicketListCommand, "", NULL },
{ "onlinelist", SEC_GAMEMASTER, true, &HandleGMTicketListOnlineCommand, "", NULL },
{ "reset", SEC_ADMINISTRATOR, true, &HandleGMTicketResetCommand, "", NULL },
{ "assign", SEC_GAMEMASTER, true, &HandleGMTicketAssignToCommand, "" },
{ "close", SEC_GAMEMASTER, true, &HandleGMTicketCloseByIdCommand, "" },
{ "closedlist", SEC_GAMEMASTER, true, &HandleGMTicketListClosedCommand, "" },
{ "comment", SEC_GAMEMASTER, true, &HandleGMTicketCommentCommand, "" },
{ "complete", SEC_GAMEMASTER, true, &HandleGMTicketCompleteCommand, "" },
{ "delete", SEC_ADMINISTRATOR, true, &HandleGMTicketDeleteByIdCommand, "" },
{ "escalate", SEC_GAMEMASTER, true, &HandleGMTicketEscalateCommand, "" },
{ "escalatedlist", SEC_GAMEMASTER, true, &HandleGMTicketListEscalatedCommand, "" },
{ "list", SEC_GAMEMASTER, true, &HandleGMTicketListCommand, "" },
{ "onlinelist", SEC_GAMEMASTER, true, &HandleGMTicketListOnlineCommand, "" },
{ "reset", SEC_ADMINISTRATOR, true, &HandleGMTicketResetCommand, "" },
{ "response", SEC_GAMEMASTER, true, NULL, "", ticketResponseCommandTable },
{ "togglesystem", SEC_ADMINISTRATOR, true, &HandleToggleGMTicketSystem, "", NULL },
{ "unassign", SEC_GAMEMASTER, true, &HandleGMTicketUnAssignCommand, "", NULL },
{ "viewid", SEC_GAMEMASTER, true, &HandleGMTicketGetByIdCommand, "", NULL },
{ "viewname", SEC_GAMEMASTER, true, &HandleGMTicketGetByNameCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "togglesystem", SEC_ADMINISTRATOR, true, &HandleToggleGMTicketSystem, "" },
{ "unassign", SEC_GAMEMASTER, true, &HandleGMTicketUnAssignCommand, "" },
{ "viewid", SEC_GAMEMASTER, true, &HandleGMTicketGetByIdCommand, "" },
{ "viewname", SEC_GAMEMASTER, true, &HandleGMTicketGetByNameCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "ticket", SEC_GAMEMASTER, false, NULL, "", ticketCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

22
src/scripts/Commands/cs_titles.cpp
View File

@@ -22,25 +22,25 @@ class titles_commandscript : public CommandScript
public:
titles_commandscript() : CommandScript("titles_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand titlesSetCommandTable[] =
static std::vector<ChatCommand> titlesSetCommandTable =
{
{ "mask", SEC_GAMEMASTER, false, &HandleTitlesSetMaskCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "mask", SEC_GAMEMASTER, false, &HandleTitlesSetMaskCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand titlesCommandTable[] =
static std::vector<ChatCommand> titlesCommandTable =
{
{ "add", SEC_GAMEMASTER, false, &HandleTitlesAddCommand, "", NULL },
{ "current", SEC_GAMEMASTER, false, &HandleTitlesCurrentCommand, "", NULL },
{ "remove", SEC_GAMEMASTER, false, &HandleTitlesRemoveCommand, "", NULL },
{ "add", SEC_GAMEMASTER, false, &HandleTitlesAddCommand, "" },
{ "current", SEC_GAMEMASTER, false, &HandleTitlesCurrentCommand, "" },
{ "remove", SEC_GAMEMASTER, false, &HandleTitlesRemoveCommand, "" },
{ "set", SEC_GAMEMASTER, false, NULL, "", titlesSetCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "titles", SEC_GAMEMASTER, false, NULL, "", titlesCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

24
src/scripts/Commands/cs_wp.cpp
View File

@@ -23,23 +23,23 @@ class wp_commandscript : public CommandScript
public:
wp_commandscript() : CommandScript("wp_commandscript") { }
ChatCommand* GetCommands() const
std::vector<ChatCommand> GetCommands() const override
{
static ChatCommand wpCommandTable[] =
static std::vector<ChatCommand> wpCommandTable =
{
{ "add", SEC_GAMEMASTER, false, &HandleWpAddCommand, "", NULL },
{ "event", SEC_GAMEMASTER, false, &HandleWpEventCommand, "", NULL },
{ "load", SEC_GAMEMASTER, false, &HandleWpLoadCommand, "", NULL },
{ "modify", SEC_GAMEMASTER, false, &HandleWpModifyCommand, "", NULL },
{ "unload", SEC_GAMEMASTER, false, &HandleWpUnLoadCommand, "", NULL },
{ "reload", SEC_ADMINISTRATOR, false, &HandleWpReloadCommand, "", NULL },
{ "show", SEC_GAMEMASTER, false, &HandleWpShowCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
{ "add", SEC_GAMEMASTER, false, &HandleWpAddCommand, "" },
{ "event", SEC_GAMEMASTER, false, &HandleWpEventCommand, "" },
{ "load", SEC_GAMEMASTER, false, &HandleWpLoadCommand, "" },
{ "modify", SEC_GAMEMASTER, false, &HandleWpModifyCommand, "" },
{ "unload", SEC_GAMEMASTER, false, &HandleWpUnLoadCommand, "" },
{ "reload", SEC_ADMINISTRATOR, false, &HandleWpReloadCommand, "" },
{ "show", SEC_GAMEMASTER, false, &HandleWpShowCommand, "" },
{ NULL, 0, false, NULL, "" }
};
static ChatCommand commandTable[] =
static std::vector<ChatCommand> commandTable =
{
{ "wp", SEC_GAMEMASTER, false, NULL, "", wpCommandTable },
{ NULL, 0, false, NULL, "", NULL }
{ NULL, 0, false, NULL, "" }
};
return commandTable;
}

12
src/worldserver/CommandLine/CliRunnable.cpp
View File

@@ -29,9 +29,9 @@
char* command_finder(const char* text, int state)
{
static int idx, len;
static size_t idx, len;
const char* ret;
ChatCommand* cmd = ChatHandler::getCommandTable();
std::vector<ChatCommand> const& cmd = ChatHandler::getCommandTable();
if (!state)
{
@@ -39,20 +39,18 @@ char* command_finder(const char* text, int state)
len = strlen(text);
}
while ((ret = cmd[idx].Name))
while (idx < cmd.size())
{
if (!cmd[idx].AllowConsole)
{
idx++;
++idx;
continue;
}
idx++;
++idx;
//printf("Checking %s \n", cmd[idx].Name);
if (strncmp(ret, text, len) == 0)
return strdup(ret);
if (cmd[idx].Name == NULL)
break;
}
return ((char*)NULL);