Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-16 07:30:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

[3.3.5] ChatCommands, the other half: chat command resolution refactor (PR #25463)

Browse Source 
(cherry picked from commit 1eca51b417)
This commit is contained in:
Treeston
2020-09-20 02:50:38 +02:00
committed by Shauren
parent 7a2c3af988
commit 3fd2eb126c
57 changed files with 1360 additions and 1294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
sql/updates/world/master/2022_02_27_06_world_2020_09_20_00_world.sql Normal file
View File

@@ -0,0 +1,10 @@
--
DELETE FROM `trinity_string` WHERE `entry` IN (6,7,8,191,192,193,194);
INSERT INTO `trinity_string` (`entry`,`content_default`) VALUES
(6, 'Command \'%.*s\' does not exist'),
(7, 'Subcommand \'%.*s\' is ambiguous:'),
(8, 'Possible subcommands:'),
(191, '|- %.*s'),
(192, '|- %.*s ...'),
(193, 'Subcommand \'%.*s\' does not exist.'),
(194, 'Command \'%.*s\' is ambiguous:');

10
src/server/game/Accounts/BattlenetAccountMgr.cpp
View File

@@ -90,7 +90,7 @@ bool Battlenet::AccountMgr::CheckPassword(uint32 accountId, std::string password
return LoginDatabase.Query(stmt) != nullptr;
}
AccountOpResult Battlenet::AccountMgr::LinkWithGameAccount(std::string const& email, std::string const& gameAccountName)
AccountOpResult Battlenet::AccountMgr::LinkWithGameAccount(std::string_view email, std::string_view gameAccountName)
{
uint32 bnetAccountId = GetId(email);
if (!bnetAccountId)
@@ -111,7 +111,7 @@ AccountOpResult Battlenet::AccountMgr::LinkWithGameAccount(std::string const& em
return AccountOpResult::AOR_OK;
}
AccountOpResult Battlenet::AccountMgr::UnlinkGameAccount(std::string const& gameAccountName)
AccountOpResult Battlenet::AccountMgr::UnlinkGameAccount(std::string_view gameAccountName)
{
uint32 gameAccountId = GameAccountMgr::GetId(gameAccountName);
if (!gameAccountId)
@@ -128,10 +128,10 @@ AccountOpResult Battlenet::AccountMgr::UnlinkGameAccount(std::string const& game
return AccountOpResult::AOR_OK;
}
uint32 Battlenet::AccountMgr::GetId(std::string const& username)
uint32 Battlenet::AccountMgr::GetId(std::string_view username)
{
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_ACCOUNT_ID_BY_EMAIL);
stmt->setString(0, username);
stmt->setStringView(0, username);
if (PreparedQueryResult result = LoginDatabase.Query(stmt))
return (*result)[0].GetUInt32();
@@ -172,7 +172,7 @@ uint8 Battlenet::AccountMgr::GetMaxIndex(uint32 accountId)
return 0;
}
std::string Battlenet::AccountMgr::CalculateShaPassHash(std::string const& name, std::string const& password)
std::string Battlenet::AccountMgr::CalculateShaPassHash(std::string_view name, std::string_view password)
{
Trinity::Crypto::SHA256 email;
email.UpdateData(name);

8
src/server/game/Accounts/BattlenetAccountMgr.h
View File

@@ -32,15 +32,15 @@ namespace Battlenet
TC_GAME_API AccountOpResult CreateBattlenetAccount(std::string email, std::string password, bool withGameAccount, std::string* gameAccountName);
TC_GAME_API AccountOpResult ChangePassword(uint32 accountId, std::string newPassword);
TC_GAME_API bool CheckPassword(uint32 accountId, std::string password);
TC_GAME_API AccountOpResult LinkWithGameAccount(std::string const& email, std::string const& gameAccountName);
TC_GAME_API AccountOpResult UnlinkGameAccount(std::string const& gameAccountName);
TC_GAME_API AccountOpResult LinkWithGameAccount(std::string_view email, std::string_view gameAccountName);
TC_GAME_API AccountOpResult UnlinkGameAccount(std::string_view gameAccountName);
TC_GAME_API uint32 GetId(std::string const& username);
TC_GAME_API uint32 GetId(std::string_view username);
TC_GAME_API bool GetName(uint32 accountId, std::string& name);
TC_GAME_API uint32 GetIdByGameAccount(uint32 gameAccountId);
TC_GAME_API uint8 GetMaxIndex(uint32 accountId);
TC_GAME_API std::string CalculateShaPassHash(std::string const& name, std::string const& password);
TC_GAME_API std::string CalculateShaPassHash(std::string_view name, std::string_view password);
}
}

122
src/server/game/Accounts/RBAC.h
View File

@@ -105,6 +105,12 @@ enum RBACPermissions
// Free space for core permissions (till 149)
// Roles (Permissions with delegated permissions) use 199 and descending
RBAC_ROLE_ADMINISTRATOR = 196,
RBAC_ROLE_GAMEMASTER = 197,
RBAC_ROLE_MODERATOR = 198,
RBAC_ROLE_PLAYER = 199,
RBAC_PERM_COMMAND_RBAC = 200,
RBAC_PERM_COMMAND_RBAC_ACC = 201,
RBAC_PERM_COMMAND_RBAC_ACC_PERM_LIST = 202,
@@ -117,7 +123,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_COUNTRY = 209,
RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_IP = 210,
RBAC_PERM_COMMAND_BNET_ACCOUNT_PASSWORD = 211,
RBAC_PERM_COMMAND_BNET_ACCOUNT_SET = 212,
// 212 previously used, do not reuse
RBAC_PERM_COMMAND_BNET_ACCOUNT_SET_PASSWORD = 213,
RBAC_PERM_COMMAND_BNET_ACCOUNT_LINK = 214,
RBAC_PERM_COMMAND_BNET_ACCOUNT_UNLINK = 215,
@@ -135,41 +141,41 @@ enum RBACPermissions
RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON = 227,
RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL = 228,
RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD = 229,
RBAC_PERM_COMMAND_ACHIEVEMENT = 230,
// 230 previously used, do not reuse
RBAC_PERM_COMMAND_ACHIEVEMENT_ADD = 231,
RBAC_PERM_COMMAND_ARENA = 232,
// 232 previously used, do not reuse
RBAC_PERM_COMMAND_ARENA_CAPTAIN = 233,
RBAC_PERM_COMMAND_ARENA_CREATE = 234,
RBAC_PERM_COMMAND_ARENA_DISBAND = 235,
RBAC_PERM_COMMAND_ARENA_INFO = 236,
RBAC_PERM_COMMAND_ARENA_LOOKUP = 237,
RBAC_PERM_COMMAND_ARENA_RENAME = 238,
RBAC_PERM_COMMAND_BAN = 239,
// 239 previously used, do not reuse
RBAC_PERM_COMMAND_BAN_ACCOUNT = 240,
RBAC_PERM_COMMAND_BAN_CHARACTER = 241,
RBAC_PERM_COMMAND_BAN_IP = 242,
RBAC_PERM_COMMAND_BAN_PLAYERACCOUNT = 243,
RBAC_PERM_COMMAND_BANINFO = 244,
// 244 previously used, do not reuse
RBAC_PERM_COMMAND_BANINFO_ACCOUNT = 245,
RBAC_PERM_COMMAND_BANINFO_CHARACTER = 246,
RBAC_PERM_COMMAND_BANINFO_IP = 247,
RBAC_PERM_COMMAND_BANLIST = 248,
// 248 previously used, do not reuse
RBAC_PERM_COMMAND_BANLIST_ACCOUNT = 249,
RBAC_PERM_COMMAND_BANLIST_CHARACTER = 250,
RBAC_PERM_COMMAND_BANLIST_IP = 251,
RBAC_PERM_COMMAND_UNBAN = 252,
// 252 previously used, do not reuse
RBAC_PERM_COMMAND_UNBAN_ACCOUNT = 253,
RBAC_PERM_COMMAND_UNBAN_CHARACTER = 254,
RBAC_PERM_COMMAND_UNBAN_IP = 255,
RBAC_PERM_COMMAND_UNBAN_PLAYERACCOUNT = 256,
RBAC_PERM_COMMAND_BF = 257,
// 257 previously used, do not reuse
RBAC_PERM_COMMAND_BF_START = 258,
RBAC_PERM_COMMAND_BF_STOP = 259,
RBAC_PERM_COMMAND_BF_SWITCH = 260,
RBAC_PERM_COMMAND_BF_TIMER = 261,
RBAC_PERM_COMMAND_BF_ENABLE = 262,
RBAC_PERM_COMMAND_ACCOUNT_EMAIL = 263,
RBAC_PERM_COMMAND_ACCOUNT_SET_SEC = 264,
// 264 previously used, do not reuse
RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL = 265,
RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_REGMAIL = 266,
RBAC_PERM_COMMAND_CAST = 267,
@@ -178,11 +184,11 @@ enum RBACPermissions
RBAC_PERM_COMMAND_CAST_SELF = 270,
RBAC_PERM_COMMAND_CAST_TARGET = 271,
RBAC_PERM_COMMAND_CAST_DEST = 272,
RBAC_PERM_COMMAND_CHARACTER = 273,
// 273 previously used, do not reuse
RBAC_PERM_COMMAND_CHARACTER_CUSTOMIZE = 274,
RBAC_PERM_COMMAND_CHARACTER_CHANGEFACTION = 275,
RBAC_PERM_COMMAND_CHARACTER_CHANGERACE = 276,
RBAC_PERM_COMMAND_CHARACTER_DELETED = 277,
// 277 previously used, do not reuse
RBAC_PERM_COMMAND_CHARACTER_DELETED_DELETE = 278,
RBAC_PERM_COMMAND_CHARACTER_DELETED_LIST = 279,
RBAC_PERM_COMMAND_CHARACTER_DELETED_RESTORE = 280,
@@ -193,10 +199,10 @@ enum RBACPermissions
RBAC_PERM_COMMAND_CHARACTER_REPUTATION = 285,
RBAC_PERM_COMMAND_CHARACTER_TITLES = 286,
RBAC_PERM_COMMAND_LEVELUP = 287,
RBAC_PERM_COMMAND_PDUMP = 288,
// 288 previously used, do not reuse
RBAC_PERM_COMMAND_PDUMP_LOAD = 289,
RBAC_PERM_COMMAND_PDUMP_WRITE = 290,
RBAC_PERM_COMMAND_CHEAT = 291,
// 291 previously used, do not reuse
RBAC_PERM_COMMAND_CHEAT_CASTTIME = 292,
RBAC_PERM_COMMAND_CHEAT_COOLDOWN = 293,
RBAC_PERM_COMMAND_CHEAT_EXPLORE = 294,
@@ -206,55 +212,13 @@ enum RBACPermissions
RBAC_PERM_COMMAND_CHEAT_TAXI = 298,
RBAC_PERM_COMMAND_CHEAT_WATERWALK = 299,
RBAC_PERM_COMMAND_DEBUG = 300,
RBAC_PERM_COMMAND_DEBUG_ANIM = 301,
RBAC_PERM_COMMAND_DEBUG_AREATRIGGERS = 302,
RBAC_PERM_COMMAND_DEBUG_ARENA = 303,
RBAC_PERM_COMMAND_DEBUG_BG = 304,
RBAC_PERM_COMMAND_DEBUG_ENTERVEHICLE = 305,
RBAC_PERM_COMMAND_DEBUG_GETITEMSTATE = 306,
RBAC_PERM_COMMAND_DEBUG_GETITEMVALUE = 307, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_GETVALUE = 308, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_COMBAT = 309,
RBAC_PERM_COMMAND_DEBUG_ITEMEXPIRE = 310,
RBAC_PERM_COMMAND_DEBUG_LOOTRECIPIENT = 311,
RBAC_PERM_COMMAND_DEBUG_LOS = 312,
RBAC_PERM_COMMAND_DEBUG_MOD32VALUE = 313, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_MOVEFLAGS = 314,
RBAC_PERM_COMMAND_DEBUG_PLAY = 315,
RBAC_PERM_COMMAND_DEBUG_PLAY_CINEMATIC = 316,
RBAC_PERM_COMMAND_DEBUG_PLAY_MOVIE = 317,
RBAC_PERM_COMMAND_DEBUG_PLAY_SOUND = 318,
RBAC_PERM_COMMAND_DEBUG_SEND = 319,
RBAC_PERM_COMMAND_DEBUG_SEND_BUYERROR = 320,
RBAC_PERM_COMMAND_DEBUG_SEND_CHANNELNOTIFY = 321,
RBAC_PERM_COMMAND_DEBUG_SEND_CHATMESSAGE = 322,
RBAC_PERM_COMMAND_DEBUG_SEND_EQUIPERROR = 323,
RBAC_PERM_COMMAND_DEBUG_SEND_LARGEPACKET = 324,
RBAC_PERM_COMMAND_DEBUG_SEND_OPCODE = 325,
RBAC_PERM_COMMAND_DEBUG_SEND_QINVALIDMSG = 326,
RBAC_PERM_COMMAND_DEBUG_SEND_QPARTYMSG = 327,
RBAC_PERM_COMMAND_DEBUG_SEND_SELLERROR = 328,
RBAC_PERM_COMMAND_DEBUG_SEND_SETPHASESHIFT = 329,
RBAC_PERM_COMMAND_DEBUG_SEND_SPELLFAIL = 330,
RBAC_PERM_COMMAND_DEBUG_SETAURASTATE = 331,
RBAC_PERM_COMMAND_DEBUG_SETBIT = 332, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_SETITEMVALUE = 333, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_SETVALUE = 334, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_SETVID = 335,
RBAC_PERM_COMMAND_DEBUG_SPAWNVEHICLE = 336,
RBAC_PERM_COMMAND_DEBUG_THREAT = 337,
RBAC_PERM_COMMAND_DEBUG_UPDATE = 338, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_WORLDSTATE = 339,
RBAC_PERM_COMMAND_WPGPS = 340,
RBAC_PERM_COMMAND_DESERTER = 341,
RBAC_PERM_COMMAND_DESERTER_BG = 342,
// 301-342 previously used, do not reuse
RBAC_PERM_COMMAND_DESERTER_BG_ADD = 343,
RBAC_PERM_COMMAND_DESERTER_BG_REMOVE = 344,
RBAC_PERM_COMMAND_DESERTER_INSTANCE = 345,
// 345 previously used, do not reuse
RBAC_PERM_COMMAND_DESERTER_INSTANCE_ADD = 346,
RBAC_PERM_COMMAND_DESERTER_INSTANCE_REMOVE = 347,
RBAC_PERM_COMMAND_DISABLE = 348,
RBAC_PERM_COMMAND_DISABLE_ADD = 349,
// 348-349 previously used, do not reuse
RBAC_PERM_COMMAND_DISABLE_ADD_CRITERIA = 350,
RBAC_PERM_COMMAND_DISABLE_ADD_BATTLEGROUND = 351,
RBAC_PERM_COMMAND_DISABLE_ADD_MAP = 352,
@@ -263,7 +227,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_DISABLE_ADD_QUEST = 355,
RBAC_PERM_COMMAND_DISABLE_ADD_SPELL = 356,
RBAC_PERM_COMMAND_DISABLE_ADD_VMAP = 357,
RBAC_PERM_COMMAND_DISABLE_REMOVE = 358,
// 358 previously used, do not reuse
RBAC_PERM_COMMAND_DISABLE_REMOVE_CRITERIA = 359,
RBAC_PERM_COMMAND_DISABLE_REMOVE_BATTLEGROUND = 360,
RBAC_PERM_COMMAND_DISABLE_REMOVE_MAP = 361,
@@ -272,7 +236,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_DISABLE_REMOVE_QUEST = 364,
RBAC_PERM_COMMAND_DISABLE_REMOVE_SPELL = 365,
RBAC_PERM_COMMAND_DISABLE_REMOVE_VMAP = 366,
RBAC_PERM_COMMAND_EVENT = 367,
RBAC_PERM_COMMAND_EVENT_INFO = 367,
RBAC_PERM_COMMAND_EVENT_ACTIVELIST = 368,
RBAC_PERM_COMMAND_EVENT_START = 369,
RBAC_PERM_COMMAND_EVENT_STOP = 370,
@@ -292,7 +256,7 @@ enum RBACPermissions
// = 384, // DEPRECATED: DON'T REUSE
// = 385, // DEPRECATED: DON'T REUSE
// = 386, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_GOBJECT = 387,
// 387 previously used, do not reuse
RBAC_PERM_COMMAND_GOBJECT_ACTIVATE = 388,
RBAC_PERM_COMMAND_GOBJECT_ADD = 389,
RBAC_PERM_COMMAND_GOBJECT_ADD_TEMP = 390,
@@ -300,12 +264,12 @@ enum RBACPermissions
RBAC_PERM_COMMAND_GOBJECT_INFO = 392,
RBAC_PERM_COMMAND_GOBJECT_MOVE = 393,
RBAC_PERM_COMMAND_GOBJECT_NEAR = 394,
RBAC_PERM_COMMAND_GOBJECT_SET = 395,
// 395 previously used, do not reuse
RBAC_PERM_COMMAND_GOBJECT_SET_PHASE = 396,
RBAC_PERM_COMMAND_GOBJECT_SET_STATE = 397,
RBAC_PERM_COMMAND_GOBJECT_TARGET = 398,
RBAC_PERM_COMMAND_GOBJECT_TURN = 399,
RBAC_PERM_COMMAND_DEBUG_TRANSPORT = 400,
// 400 previously used, do not reuse
RBAC_PERM_COMMAND_GUILD = 401,
RBAC_PERM_COMMAND_GUILD_CREATE = 402,
RBAC_PERM_COMMAND_GUILD_DELETE = 403,
@@ -323,7 +287,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_INSTANCE_STATS = 415,
RBAC_PERM_COMMAND_INSTANCE_SAVEDATA = 416,
RBAC_PERM_COMMAND_LEARN = 417,
RBAC_PERM_COMMAND_LEARN_ALL = 418,
// 418 previously used, do not reuse
RBAC_PERM_COMMAND_LEARN_ALL_MY = 419,
RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS = 420,
RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS = 421,
@@ -335,13 +299,13 @@ enum RBACPermissions
RBAC_PERM_COMMAND_LEARN_ALL_LANG = 427,
RBAC_PERM_COMMAND_LEARN_ALL_RECIPES = 428,
RBAC_PERM_COMMAND_UNLEARN = 429,
RBAC_PERM_COMMAND_LFG = 430,
// 430 previously used, do not reuse
RBAC_PERM_COMMAND_LFG_PLAYER = 431,
RBAC_PERM_COMMAND_LFG_GROUP = 432,
RBAC_PERM_COMMAND_LFG_QUEUE = 433,
RBAC_PERM_COMMAND_LFG_CLEAN = 434,
RBAC_PERM_COMMAND_LFG_OPTIONS = 435,
RBAC_PERM_COMMAND_LIST = 436,
// 436 previously used, do not reuse
RBAC_PERM_COMMAND_LIST_CREATURE = 437,
RBAC_PERM_COMMAND_LIST_ITEM = 438,
RBAC_PERM_COMMAND_LIST_OBJECT = 439,
@@ -475,7 +439,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_MODIFY_SPELL = 567,
RBAC_PERM_COMMAND_MODIFY_STANDSTATE = 568,
RBAC_PERM_COMMAND_MODIFY_TALENTPOINTS = 569,
RBAC_PERM_COMMAND_NPC = 570,
// 570 previously used, do not reuse
RBAC_PERM_COMMAND_NPC_ADD = 571,
RBAC_PERM_COMMAND_NPC_ADD_FORMATION = 572,
RBAC_PERM_COMMAND_NPC_ADD_ITEM = 573,
@@ -610,7 +574,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_RELOAD_SPELL_THREATS = 702,
RBAC_PERM_COMMAND_RELOAD_SPELL_GROUP_STACK_RULES = 703,
RBAC_PERM_COMMAND_RELOAD_TRINITY_STRING = 704,
// 705 unused
// 705 previously used, do not reuse
RBAC_PERM_COMMAND_RELOAD_WAYPOINT_SCRIPTS = 706,
RBAC_PERM_COMMAND_RELOAD_WAYPOINT_DATA = 707,
RBAC_PERM_COMMAND_RELOAD_VEHICLE_ACCESORY = 708,
@@ -681,9 +645,9 @@ enum RBACPermissions
RBAC_PERM_COMMAND_WP_RELOAD = 773,
RBAC_PERM_COMMAND_WP_SHOW = 774,
RBAC_PERM_COMMAND_MODIFY_CURRENCY = 775,
RBAC_PERM_COMMAND_DEBUG_PHASE = 776,
// 776 previously used, do not reuse
RBAC_PERM_COMMAND_MAILBOX = 777,
RBAC_PERM_COMMAND_AHBOT = 778,
// 778 previously used, do not reuse
RBAC_PERM_COMMAND_AHBOT_ITEMS = 779,
RBAC_PERM_COMMAND_AHBOT_ITEMS_GRAY = 780,
RBAC_PERM_COMMAND_AHBOT_ITEMS_WHITE = 781,
@@ -740,8 +704,7 @@ enum RBACPermissions
RBAC_PERM_COMMAND_TICKET_RESET_COMPLAINT = 832,
RBAC_PERM_COMMAND_TICKET_RESET_SUGGESTION = 833,
// = 834, // DEPRECATED: DON'T REUSE
RBAC_PERM_COMMAND_DEBUG_LOADCELLS = 835,
RBAC_PERM_COMMAND_DEBUG_BOUNDARY = 836,
// 835-836 previously used, do not reuse
RBAC_PERM_COMMAND_NPC_EVADE = 837,
RBAC_PERM_COMMAND_PET_LEVEL = 838,
RBAC_PERM_COMMAND_SERVER_SHUTDOWN_FORCE = 839,
@@ -757,10 +720,9 @@ enum RBACPermissions
RBAC_PERM_COMMAND_LIST_SCENES = 849,
RBAC_PERM_COMMAND_RELOAD_SCENE_TEMPLATE = 850,
RBAC_PERM_COMMAND_RELOAD_AREATRIGGER_TEMPLATE = 851,
RBAC_PERM_COMMAND_DEBUG_DUMMY = 852,
// 852 previously used, do not reuse
RBAC_PERM_COMMAND_RELOAD_CONVERSATION_TEMPLATE = 853,
RBAC_PERM_COMMAND_DEBUG_CONVERSATION = 854,
RBAC_PERM_COMMAND_DEBUG_PLAY_MUSIC = 855,
// 854-855 previously used, do not reuse
RBAC_PERM_COMMAND_NPC_SPAWNGROUP = 856,
RBAC_PERM_COMMAND_NPC_DESPAWNGROUP = 857,
RBAC_PERM_COMMAND_GOBJECT_SPAWNGROUP = 858,
@@ -774,17 +736,15 @@ enum RBACPermissions
RBAC_PERM_COMMAND_LIST_SPAWNPOINTS = 866,
RBAC_PERM_COMMAND_RELOAD_QUEST_GREETING_LOCALE = 867, // reserved
RBAC_PERM_COMMAND_MODIFY_POWER = 868,
RBAC_PERM_COMMAND_DEBUG_SEND_PLAYER_CHOICE = 869,
RBAC_PERM_COMMAND_DEBUG_THREATINFO = 870,
RBAC_PERM_COMMAND_DEBUG_INSTANCESPAWN = 871,
// 869 previously used, do not reuse
// 870-871 previously used, do not reuse
RBAC_PERM_COMMAND_SERVER_DEBUG = 872,
RBAC_PERM_COMMAND_RELOAD_CREATURE_MOVEMENT_OVERRIDE = 873,
RBAC_PERM_COMMAND_DEBUG_ASAN = 874,
// 874 previously used, do not reuse
RBAC_PERM_COMMAND_LOOKUP_MAP_ID = 875,
RBAC_PERM_COMMAND_LOOKUP_ITEM_ID = 876,
RBAC_PERM_COMMAND_LOOKUP_QUEST_ID = 877,
RBAC_PERM_COMMAND_DEBUG_QUESTRESET = 878,
RBAC_PERM_COMMAND_DEBUG_POOLSTATUS = 879,
// 878-879 previously used, do not reuse
RBAC_PERM_COMMAND_PDUMP_COPY = 880,
RBAC_PERM_COMMAND_RELOAD_VEHICLE_TEMPLATE = 881,
RBAC_PERM_COMMAND_RELOAD_SPELL_SCRIPT_NAMES = 882,

385
src/server/game/Chat/Chat.cpp
View File

@@ -39,7 +39,7 @@
#include <boost/algorithm/string/replace.hpp>
#include <sstream>
Player* ChatHandler::GetPlayer() { return m_session ? m_session->GetPlayer() : nullptr; }
Player* ChatHandler::GetPlayer() const { return m_session ? m_session->GetPlayer() : nullptr; }
char* ChatHandler::LineFromMessage(char*& pos)
{
@@ -48,56 +48,11 @@ char* ChatHandler::LineFromMessage(char*& pos)
return start;
}
// Lazy loading of the command table cache from commands and the
// ScriptMgr should be thread safe since the player commands,
// cli commands and ScriptMgr updates are all dispatched one after
// one inside the world update loop.
static Optional<std::vector<ChatCommand>> commandTableCache;
std::vector<ChatCommand> const& ChatHandler::getCommandTable()
{
if (!commandTableCache)
InitializeCommandTable();
return *commandTableCache;
}
void ChatHandler::InitializeCommandTable()
{
// We need to initialize this at top since SetDataForCommandInTable
// calls getCommandTable() recursively.
commandTableCache = sScriptMgr->GetChatCommands();
WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS);
PreparedQueryResult result = WorldDatabase.Query(stmt);
if (result)
{
do
{
Field* fields = result->Fetch();
std::string name = fields[0].GetString();
SetDataForCommandInTable(*commandTableCache, name.c_str(), fields[1].GetUInt16(), fields[2].GetString(), name);
}
while (result->NextRow());
}
}
void ChatHandler::invalidateCommandTable()
{
commandTableCache.reset();
}
char const* ChatHandler::GetTrinityString(uint32 entry) const
{
return m_session->GetTrinityString(entry);
}
bool ChatHandler::isAvailable(ChatCommand const& cmd) const
{
return HasPermission(cmd.Permission);
}
bool ChatHandler::HasPermission(uint32 permission) const
{
return m_session->HasPermission(permission);
@@ -158,31 +113,6 @@ bool ChatHandler::HasLowerSecurityAccount(WorldSession* target, uint32 target_ac
return false;
}
bool ChatHandler::hasStringAbbr(const char* name, const char* part)
{
// non "" command
if (*name)
{
// "" part from non-"" command
if (!*part)
return false;
while (true)
{
if (!*part || *part == ' ')
return true;
else if (!*name)
return false;
else if (tolower(*name) != tolower(*part))
return false;
++name; ++part;
}
}
// allow with any for ""
return true;
}
void ChatHandler::SendSysMessage(std::string_view str, bool escapeCharacters)
{
std::string msg{ str };
@@ -232,171 +162,9 @@ void ChatHandler::SendSysMessage(uint32 entry)
SendSysMessage(GetTrinityString(entry));
}
bool ChatHandler::ExecuteCommandInTable(std::vector<ChatCommand> const& table, const char* text, std::string const& fullcmd)
bool ChatHandler::_ParseCommands(std::string_view text)
{
char const* oldtext = text;
std::string cmd = "";
while (*text != ' ' && *text != '\0')
{
cmd += *text;
++text;
}
while (*text == ' ') ++text;
for (uint32 i = 0; i < table.size(); ++i)
{
if (!hasStringAbbr(table[i].Name, cmd.c_str()))
continue;
bool match = false;
if (strlen(table[i].Name) > cmd.length())
{
for (uint32 j = 0; j < table.size(); ++j)
{
if (!hasStringAbbr(table[j].Name, cmd.c_str()))
continue;
if (strcmp(table[j].Name, cmd.c_str()) == 0)
{
match = true;
break;
}
}
}
if (match)
continue;
// select subcommand from child commands list
if (!table[i].ChildCommands.empty())
{
if (!ExecuteCommandInTable(table[i].ChildCommands, text, fullcmd))
{
if (m_session && !m_session->HasPermission(rbac::RBAC_PERM_COMMANDS_NOTIFY_COMMAND_NOT_FOUND_ERROR))
return false;
if (text[0] != '\0')
SendSysMessage(LANG_NO_SUBCMD);
else
SendSysMessage(LANG_CMD_SYNTAX);
ShowHelpForCommand(table[i].ChildCommands, text);
}
return true;
}
// must be available and have handler
if (!table[i].HasHandler() || !isAvailable(table[i]))
continue;
SetSentErrorMessage(false);
// table[i].Name == "" is special case: send original command to handler
if (table[i](this, table[i].Name[0] != '\0' ? text : oldtext))
{
if (!m_session) // ignore console
return true;
Player* player = m_session->GetPlayer();
if (!AccountMgr::IsPlayerAccount(m_session->GetSecurity()))
{
ObjectGuid guid = player->GetTarget();
uint32 areaId = player->GetAreaId();
std::string areaName = "Unknown";
std::string zoneName = "Unknown";
if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
{
LocaleConstant locale = GetSessionDbcLocale();
areaName = area->AreaName[locale];
if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
zoneName = zone->AreaName[locale];
}
sLog->outCommand(m_session->GetAccountId(), "Command: %s [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
fullcmd.c_str(), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
m_session->GetAccountId(), player->GetPositionX(), player->GetPositionY(),
player->GetPositionZ(), player->GetMapId(),
player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
areaId, areaName.c_str(), zoneName.c_str(),
(player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
guid.ToString().c_str());
}
}
// some commands have custom error messages. Don't send the default one in these cases.
else if (!HasSentErrorMessage())
{
if (!table[i].Help.empty())
SendSysMessage(table[i].Help.c_str());
else
SendSysMessage(LANG_CMD_SYNTAX);
SetSentErrorMessage(true);
}
return true;
}
return false;
}
bool ChatHandler::SetDataForCommandInTable(std::vector<ChatCommand>& table, char const* text, uint32 permission, std::string const& help, std::string const& fullcommand)
{
std::string cmd = "";
while (*text != ' ' && *text != '\0')
{
cmd += *text;
++text;
}
while (*text == ' ') ++text;
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.empty())
{
if (SetDataForCommandInTable(table[i].ChildCommands, text, permission, help, fullcommand))
return true;
else if (*text)
return false;
// fail with "" subcommands, then use normal level up command instead
}
// expected subcommand by full name DB content
else if (*text)
{
TC_LOG_ERROR("sql.sql", "Table `command` contains an unexpected subcommand '%s' in command '%s', skipped.", text, fullcommand.c_str());
return false;
}
if (table[i].Permission != permission)
TC_LOG_INFO("misc", "Table `command` overwrite for command '%s' default permission (%u) by %u", fullcommand.c_str(), table[i].Permission, permission);
table[i].Permission = permission;
table[i].Help = help;
return true;
}
// in case "" command let process by caller
if (!cmd.empty())
{
if (&table == &getCommandTable())
TC_LOG_ERROR("sql.sql", "Table `command` contains a non-existing command '%s', skipped.", cmd.c_str());
else
TC_LOG_ERROR("sql.sql", "Table `command` contains a non-existing subcommand '%s' in command '%s', skipped.", cmd.c_str(), fullcommand.c_str());
}
return false;
}
bool ChatHandler::_ParseCommands(char const* text)
{
if (ExecuteCommandInTable(getCommandTable(), text, text))
if (Trinity::ChatCommands::TryExecuteCommand(*this, text))
return true;
// Pretend commands don't exist for regular players
@@ -404,126 +172,32 @@ bool ChatHandler::_ParseCommands(char const* text)
return false;
// Send error message for GMs
SendSysMessage(LANG_NO_CMD);
PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(text));
SetSentErrorMessage(true);
return true;
}
bool ChatHandler::ParseCommands(char const* text)
bool ChatHandler::ParseCommands(std::string_view text)
{
ASSERT(text);
ASSERT(*text);
ASSERT(!text.empty());
/// chat case (.command or !command format)
if (text[0] != '!' && text[0] != '.')
// chat case (.command or !command format)
if ((text[0] != '!') && (text[0] != '.'))
return false;
/// ignore single . and ! in line
if (!text[1])
// ignore single . and ! in line
if (text.length() < 2)
return false;
/// ignore messages staring from many dots.
if (text[1] == '!' || text[1] == '.')
// ignore messages staring from many dots.
if (text[1] == text[0])
return false;
return _ParseCommands(text+1);
}
bool ChatHandler::ShowHelpForSubCommands(std::vector<ChatCommand> const& table, char const* cmd, char const* subcmd)
{
std::string list;
for (uint32 i = 0; i < table.size(); ++i)
{
// must be available (ignore handler existence to show command with possible available subcommands)
if (!isAvailable(table[i]))
continue;
// for empty subcmd show all available
if (*subcmd && !hasStringAbbr(table[i].Name, subcmd))
continue;
if (m_session)
list += "\n ";
else
list += "\n\r ";
list += table[i].Name;
if (!table[i].ChildCommands.empty())
list += " ...";
}
if (list.empty())
// ignore messages with separator after .
if (text[1] == Trinity::Impl::ChatCommands::COMMAND_DELIMITER)
return false;
if (&table == &getCommandTable())
{
SendSysMessage(LANG_AVIABLE_CMD);
PSendSysMessage("%s", list.c_str());
}
else
PSendSysMessage(LANG_SUBCMDS_LIST, cmd, list.c_str());
return true;
}
bool ChatHandler::ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd)
{
if (*cmd)
{
std::string subcmd;
if (size_t n = std::string_view(cmd).find(' '); n != std::string_view::npos)
subcmd.assign(cmd+n+1);
for (uint32 i = 0; i < table.size(); ++i)
{
// must be available (ignore handler existence to show command with possible available subcommands)
if (!isAvailable(table[i]))
continue;
if (!hasStringAbbr(table[i].Name, cmd))
continue;
// have subcommand
if (!table[i].ChildCommands.empty() && !subcmd.empty())
{
if (ShowHelpForCommand(table[i].ChildCommands, subcmd.c_str()))
return true;
}
if (!table[i].Help.empty())
SendSysMessage(table[i].Help.c_str());
if (!table[i].ChildCommands.empty())
if (ShowHelpForSubCommands(table[i].ChildCommands, table[i].Name, subcmd.c_str()))
return true;
return !table[i].Help.empty();
}
}
else
{
for (uint32 i = 0; i < table.size(); ++i)
{
// must be available (ignore handler existence to show command with possible available subcommands)
if (!isAvailable(table[i]))
continue;
if (strlen(table[i].Name))
continue;
if (!table[i].Help.empty())
SendSysMessage(table[i].Help.c_str());
if (!table[i].ChildCommands.empty())
if (ShowHelpForSubCommands(table[i].ChildCommands, "", ""))
return true;
return !table[i].Help.empty();
}
}
return ShowHelpForSubCommands(table, "", cmd);
return _ParseCommands(text.substr(1));
}
Player* ChatHandler::getSelectedPlayer()
@@ -1005,25 +679,19 @@ char const* CliHandler::GetTrinityString(uint32 entry) const
return sObjectMgr->GetTrinityStringForDBCLocale(entry);
}
bool CliHandler::isAvailable(ChatCommand const& cmd) const
{
// skip non-console commands in console case
return cmd.AllowConsole;
}
void CliHandler::SendSysMessage(std::string_view str, bool /*escapeCharacters*/)
{
m_print(m_callbackArg, str);
m_print(m_callbackArg, "\r\n");
}
bool CliHandler::ParseCommands(char const* str)
bool CliHandler::ParseCommands(std::string_view str)
{
if (!str[0])
if (str.empty())
return false;
// Console allows using commands both with and without leading indicator
if (str[0] == '.' || str[0] == '!')
++str;
str = str.substr(1);
return _ParseCommands(str);
}
@@ -1093,14 +761,12 @@ LocaleConstant CliHandler::GetSessionDbLocaleIndex() const
std::string const AddonChannelCommandHandler::PREFIX = "TrinityCore";
bool AddonChannelCommandHandler::ParseCommands(char const* str)
bool AddonChannelCommandHandler::ParseCommands(std::string_view str)
{
if (str.length() < 5)
return false;
char opcode = str[0];
if (!opcode) // str[0] is opcode
return false;
if (!str[1] || !str[2] || !str[3] || !str[4]) // str[1] through str[4] is 4-character command counter
return false;
echo = str+1;
echo = &str[1];
switch (opcode)
{
@@ -1109,10 +775,12 @@ bool AddonChannelCommandHandler::ParseCommands(char const* str)
return true;
case 'h': // h Issue human-readable command
case 'i': // i Issue command
{
if (!str[5])
return false;
humanReadable = (opcode == 'h');
if (_ParseCommands(str + 5)) // actual command starts at str[5]
std::string_view cmd = str.substr(5);
if (_ParseCommands(cmd)) // actual command starts at str[5]
{
if (!hadAck)
SendAck();
@@ -1123,10 +791,11 @@ bool AddonChannelCommandHandler::ParseCommands(char const* str)
}
else
{
SendSysMessage(LANG_NO_CMD);
PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(cmd));
SendFailed();
}
return true;
}
default:
return false;
}

27
src/server/game/Chat/Chat.h
View File

@@ -20,9 +20,7 @@
#include "ObjectGuid.h"
#include "StringFormat.h"
#include <vector>
class ChatCommand;
class ChatHandler;
class Creature;
class GameObject;
@@ -39,8 +37,10 @@ enum LocaleConstant : uint8;
class TC_GAME_API ChatHandler
{
public:
bool IsConsole() const { return (m_session == nullptr); }
WorldSession* GetSession() { return m_session; }
Player* GetPlayer();
WorldSession const* GetSession() const { return m_session; }
Player* GetPlayer() const;
explicit ChatHandler(WorldSession* session) : m_session(session), sentErrorMessage(false) { }
virtual ~ChatHandler() { }
@@ -70,19 +70,12 @@ class TC_GAME_API ChatHandler
return Trinity::StringFormat(GetTrinityString(entry), std::forward<Args>(args)...);
}
bool _ParseCommands(char const* text);
virtual bool ParseCommands(char const* text);
static std::vector<ChatCommand> const& getCommandTable();
static void InitializeCommandTable();
static void invalidateCommandTable();
bool _ParseCommands(std::string_view text);
virtual bool ParseCommands(std::string_view text);
void SendGlobalSysMessage(const char *str);
bool hasStringAbbr(const char* name, const char* part);
// function with different implementation for chat/console
virtual bool isAvailable(ChatCommand const& cmd) const;
virtual bool IsHumanReadable() const { return true; }
virtual bool HasPermission(uint32 permission) const;
virtual std::string GetNameLink() const;
@@ -119,13 +112,8 @@ class TC_GAME_API ChatHandler
Creature* GetCreatureFromPlayerMapByDbGuid(ObjectGuid::LowType lowguid);
bool HasSentErrorMessage() const { return sentErrorMessage; }
void SetSentErrorMessage(bool val){ sentErrorMessage = val; }
bool ShowHelpForCommand(std::vector<ChatCommand> const& table, const char* cmd);
protected:
explicit ChatHandler() : m_session(nullptr), sentErrorMessage(false) { } // for CLI subclass
static bool SetDataForCommandInTable(std::vector<ChatCommand>& table, const char* text, uint32 permission, 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:
WorldSession* m_session; // != nullptr for chat command call and nullptr for CLI command
@@ -142,10 +130,9 @@ class TC_GAME_API CliHandler : public ChatHandler
// overwrite functions
char const* GetTrinityString(uint32 entry) const override;
bool isAvailable(ChatCommand const& cmd) const override;
bool HasPermission(uint32 /*permission*/) const override { return true; }
void SendSysMessage(std::string_view, bool escapeCharacters) override;
bool ParseCommands(char const* str) override;
bool ParseCommands(std::string_view str) override;
std::string GetNameLink() const override;
bool needReportToTarget(Player* chr) const override;
LocaleConstant GetSessionDbcLocale() const override;
@@ -162,7 +149,7 @@ class TC_GAME_API AddonChannelCommandHandler : public ChatHandler
static std::string const PREFIX;
using ChatHandler::ChatHandler;
bool ParseCommands(char const* str) override;
bool ParseCommands(std::string_view str) override;
void SendSysMessage(std::string_view, bool escapeCharacters) override;
using ChatHandler::SendSysMessage;
bool IsHumanReadable() const override { return humanReadable; }

466
src/server/game/Chat/ChatCommands/ChatCommand.cpp Normal file
View File

@@ -0,0 +1,466 @@
/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ChatCommand.h"
#include "AccountMgr.h"
#include "Chat.h"
#include "DatabaseEnv.h"
#include "DB2Stores.h"
#include "Log.h"
#include "Map.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "WorldSession.h"
using ChatSubCommandMap = std::map<std::string_view, Trinity::Impl::ChatCommands::ChatCommandNode, StringCompareLessI_T>;
void Trinity::Impl::ChatCommands::ChatCommandNode::LoadFromBuilder(ChatCommandBuilder const& builder)
{
if (std::holds_alternative<ChatCommandBuilder::InvokerEntry>(builder._data))
{
ASSERT(!_invoker, "Duplicate blank sub-command.");
std::tie(_invoker, _permission) = std::get<ChatCommandBuilder::InvokerEntry>(builder._data);
}
else
LoadCommandsIntoMap(this, _subCommands, std::get<ChatCommandBuilder::SubCommandEntry>(builder._data));
}
/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandsIntoMap(ChatCommandNode* blank, ChatSubCommandMap& map, Trinity::ChatCommands::ChatCommandTable const& commands)
{
for (ChatCommandBuilder const& builder : commands)
{
if (builder._name.empty())
{
ASSERT(blank, "Empty name command at top level is not permitted.");
blank->LoadFromBuilder(builder);
}
else
{
std::vector<std::string_view> const tokens = Trinity::Tokenize(builder._name, COMMAND_DELIMITER, false);
ASSERT(!tokens.empty(), "Invalid command name '" STRING_VIEW_FMT "'.", STRING_VIEW_FMT_ARG(builder._name));
ChatSubCommandMap* subMap = &map;
for (size_t i = 0, n = (tokens.size() - 1); i < n; ++i)
subMap = &((*subMap)[tokens[i]]._subCommands);
((*subMap)[tokens.back()]).LoadFromBuilder(builder);
}
}
}
static ChatSubCommandMap COMMAND_MAP;
/*static*/ ChatSubCommandMap const& Trinity::Impl::ChatCommands::ChatCommandNode::GetTopLevelMap()
{
if (COMMAND_MAP.empty())
LoadCommandMap();
return COMMAND_MAP;
}
/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap() { COMMAND_MAP.clear(); }
/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandMap()
{
InvalidateCommandMap();
LoadCommandsIntoMap(nullptr, COMMAND_MAP, sScriptMgr->GetChatCommands());
if (PreparedQueryResult result = WorldDatabase.Query(WorldDatabase.GetPreparedStatement(WORLD_SEL_COMMANDS)))
{
do
{
Field* fields = result->Fetch();
std::string_view const name = fields[0].GetStringView();
uint16 const permission = fields[1].GetUInt16();
std::string_view const help = fields[2].GetStringView();
ChatCommandNode* cmd = nullptr;
ChatSubCommandMap* map = &COMMAND_MAP;
for (std::string_view key : Trinity::Tokenize(name, COMMAND_DELIMITER, false))
{
auto it = map->find(key);
if (it != map->end())
{
cmd = &it->second;
map = &cmd->_subCommands;
}
else
{
TC_LOG_ERROR("sql.sql", "Table `command` contains data for non-existant command '" STRING_VIEW_FMT "'. Skipped.", STRING_VIEW_FMT_ARG(name));
cmd = nullptr;
break;
}
}
if (!cmd)
continue;
if (cmd->_invoker && (cmd->_permission.RequiredPermission != permission))
{
TC_LOG_WARN("sql.sql", "Table `command` has permission %u for '" STRING_VIEW_FMT "' which does not match the core (%u). Overriding.",
permission, STRING_VIEW_FMT_ARG(name), cmd->_permission.RequiredPermission);
cmd->_permission.RequiredPermission = static_cast<rbac::RBACPermissions>(permission);
}
cmd->_help.assign(help);
} while (result->NextRow());
}
for (auto const& [name, cmd] : COMMAND_MAP)
cmd.AssertCommandHelp(name);
}
void Trinity::Impl::ChatCommands::ChatCommandNode::AssertCommandHelp(std::string_view name) const
{
if (_invoker && _help.empty())
TC_LOG_WARN("sql.sql", "Table `command` is missing help text for (sub-)command '" STRING_VIEW_FMT "'.", STRING_VIEW_FMT_ARG(name));
for (auto const& [name, cmd] : _subCommands)
cmd.AssertCommandHelp(name);
}
static void LogCommandUsage(WorldSession const& session, uint32 permission, std::string_view cmdStr)
{
if (AccountMgr::IsPlayerAccount(session.GetSecurity()))
return;
if (sAccountMgr->GetRBACPermission(rbac::RBAC_ROLE_PLAYER)->GetLinkedPermissions().count(permission))
return;
Player* player = session.GetPlayer();
ObjectGuid targetGuid = player->GetTarget();
uint32 areaId = player->GetAreaId();
std::string areaName = "Unknown";
std::string zoneName = "Unknown";
if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId))
{
LocaleConstant locale = session.GetSessionDbcLocale();
areaName = area->AreaName[locale];
if (AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID))
zoneName = zone->AreaName[locale];
}
sLog->outCommand(session.GetAccountId(), "Command: " STRING_VIEW_FMT " [Player: %s (%s) (Account: %u) X: %f Y: %f Z: %f Map: %u (%s) Area: %u (%s) Zone: %s Selected: %s (%s)]",
STRING_VIEW_FMT_ARG(cmdStr), player->GetName().c_str(), player->GetGUID().ToString().c_str(),
session.GetAccountId(), player->GetPositionX(), player->GetPositionY(),
player->GetPositionZ(), player->GetMapId(),
player->FindMap() ? player->FindMap()->GetMapName() : "Unknown",
areaId, areaName.c_str(), zoneName.c_str(),
(player->GetSelectedUnit()) ? player->GetSelectedUnit()->GetName().c_str() : "",
targetGuid.ToString().c_str());
}
void Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelp(ChatHandler& handler) const
{
if (IsInvokerVisible(handler))
handler.SendSysMessage(_help);
bool header = false;
for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
{
bool const subCommandHasSubCommand = it->second.HasVisibleSubCommands(handler);
if (!subCommandHasSubCommand && !it->second.IsInvokerVisible(handler))
continue;
if (!header)
{
handler.SendSysMessage(LANG_SUBCMDS_LIST);
header = true;
}
handler.PSendSysMessage(subCommandHasSubCommand ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it->first));
}
}
namespace Trinity::Impl::ChatCommands
{
struct FilteredCommandListIterator
{
public:
FilteredCommandListIterator(ChatSubCommandMap const& map, ChatHandler const& handler, std::string_view token)
: _handler{ handler }, _token{ token }, _it{ map.lower_bound(token) }, _end{ map.end() }
{
_skip();
}
decltype(auto) operator*() const { return _it.operator*(); }
decltype(auto) operator->() const { return _it.operator->(); }
FilteredCommandListIterator& operator++()
{
++_it;
_skip();
return *this;
}
explicit operator bool() const { return (_it != _end); }
bool operator!() const { return !static_cast<bool>(*this); }
private:
void _skip()
{
if ((_it != _end) && !StringStartsWithI(_it->first, _token))
_it = _end;
while ((_it != _end) && !_it->second.IsVisible(_handler))
{
++_it;
if ((_it != _end) && !StringStartsWithI(_it->first, _token))
_it = _end;
}
}
ChatHandler const& _handler;
std::string_view const _token;
ChatSubCommandMap::const_iterator _it, _end;
};
}
/*static*/ bool Trinity::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand(ChatHandler& handler, std::string_view cmdStr)
{
ChatCommandNode const* cmd = nullptr;
ChatSubCommandMap const* map = &GetTopLevelMap();
while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
cmdStr.remove_prefix(1);
while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
cmdStr.remove_suffix(1);
std::string_view oldTail = cmdStr;
while (!oldTail.empty())
{
/* oldTail = token DELIMITER newTail */
auto [token, newTail] = tokenize(oldTail);
ASSERT(!token.empty());
FilteredCommandListIterator it1(*map, handler, token);
if (!it1)
break; /* no matching subcommands found */
if (!StringEqualI(it1->first, token))
{ /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
auto it2 = it1;
++it2;
if (it2)
{ /* there are multiple matching subcommands - print possibilities and return */
if (cmd)
handler.PSendSysMessage(LANG_SUBCMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
else
handler.PSendSysMessage(LANG_CMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it1->first));
do
{
handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it2->first));
} while (++it2);
return true;
}
}
/* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
cmd = &it1->second;
map = &cmd->_subCommands;
oldTail = newTail;
}
if (cmd)
{ /* if we matched a command at some point, invoke it */
handler.SetSentErrorMessage(false);
if (cmd->IsInvokerVisible(handler) && cmd->_invoker(&handler, oldTail))
{ /* invocation succeeded, log this */
if (!handler.IsConsole())
LogCommandUsage(*handler.GetSession(), cmd->_permission.RequiredPermission, cmdStr);
}
else if (!handler.HasSentErrorMessage())
{ /* invocation failed, we should show usage */
cmd->SendCommandHelp(handler);
handler.SetSentErrorMessage(true);
}
return true;
}
return false;
}
/*static*/ void Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(ChatHandler& handler, std::string_view cmdStr)
{
ChatCommandNode const* cmd = nullptr;
ChatSubCommandMap const* map = &GetTopLevelMap();
for (std::string_view token : Trinity::Tokenize(cmdStr, COMMAND_DELIMITER, false))
{
FilteredCommandListIterator it1(*map, handler, token);
if (!it1)
{ /* no matching subcommands found */
if (cmd)
{
cmd->SendCommandHelp(handler);
handler.PSendSysMessage(LANG_SUBCMD_INVALID, STRING_VIEW_FMT_ARG(token));
}
else
handler.PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(token));
return;
}
if (!StringEqualI(it1->first, token))
{ /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
auto it2 = it1;
++it2;
if (it2)
{ /* there are multiple matching subcommands - print possibilities and return */
handler.PSendSysMessage(cmd ? LANG_SUBCMD_AMBIGUOUS : LANG_CMD_AMBIGUOUS, STRING_VIEW_FMT_ARG(token));
handler.PSendSysMessage(it1->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it1->first));
do
{
handler.PSendSysMessage(it2->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it2->first));
} while (++it2);
return;
}
}
cmd = &it1->second;
map = &cmd->_subCommands;
}
if (cmd)
cmd->SendCommandHelp(handler);
else if (cmdStr.empty())
{
FilteredCommandListIterator it(*map, handler, "");
if (!it)
return;
handler.SendSysMessage(LANG_AVAILABLE_CMDS);
do
{
handler.PSendSysMessage(it->second.HasVisibleSubCommands(handler) ? LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS : LANG_SUBCMDS_LIST_ENTRY, STRING_VIEW_FMT_ARG(it->first));
} while (++it);
}
else
handler.PSendSysMessage(LANG_CMD_INVALID, STRING_VIEW_FMT_ARG(cmdStr));
}
/*static*/ std::vector<std::string> Trinity::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmdStr)
{
std::string path;
ChatCommandNode const* cmd = nullptr;
ChatSubCommandMap const* map = &GetTopLevelMap();
while (!cmdStr.empty() && (cmdStr.front() == COMMAND_DELIMITER))
cmdStr.remove_prefix(1);
while (!cmdStr.empty() && (cmdStr.back() == COMMAND_DELIMITER))
cmdStr.remove_suffix(1);
std::string_view oldTail = cmdStr;
while (!oldTail.empty())
{
/* oldTail = token DELIMITER newTail */
auto [token, newTail] = tokenize(oldTail);
ASSERT(!token.empty());
FilteredCommandListIterator it1(*map, handler, token);
if (!it1)
break; /* no matching subcommands found */
if (!StringEqualI(it1->first, token))
{ /* ok, so it1 points at a partially matching subcommand - let's see if there are others */
auto it2 = it1;
++it2;
if (it2)
{ /* there are multiple matching subcommands - terminate here and show possibilities */
std::vector<std::string> vec;
auto possibility = ([prefix = std::string_view(path), suffix = std::string_view(newTail)](std::string_view match)
{
if (prefix.empty())
{
return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
STRING_VIEW_FMT_ARG(match), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(suffix));
}
else
{
return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
STRING_VIEW_FMT_ARG(prefix), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(match), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(suffix));
}
});
vec.emplace_back(possibility(it1->first));
do vec.emplace_back(possibility(it2->first));
while (++it2);
return vec;
}
}
/* now we matched exactly one subcommand, and it1 points to it; go down the rabbit hole */
if (path.empty())
path.assign(it1->first);
else
{
path = Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
STRING_VIEW_FMT_ARG(path), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(it1->first));
}
cmd = &it1->second;
map = &cmd->_subCommands;
oldTail = newTail;
}
if (!oldTail.empty())
{ /* there is some trailing text, leave it as is */
if (cmd)
{ /* if we matched a command at some point, auto-complete it */
return {
Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
STRING_VIEW_FMT_ARG(path), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(oldTail))
};
}
else
return {};
}
else
{ /* offer all subcommands */
auto possibility = ([prefix = std::string_view(path)](std::string_view match)
{
if (prefix.empty())
return std::string(match);
else
{
return Trinity::StringFormat(STRING_VIEW_FMT "%c" STRING_VIEW_FMT,
STRING_VIEW_FMT_ARG(prefix), COMMAND_DELIMITER, STRING_VIEW_FMT_ARG(match));
}
});
std::vector<std::string> vec;
for (FilteredCommandListIterator it(*map, handler, ""); it; ++it)
vec.emplace_back(possibility(it->first));
return vec;
}
}
bool Trinity::Impl::ChatCommands::ChatCommandNode::IsInvokerVisible(ChatHandler const& who) const
{
if (!_invoker)
return false;
if (who.IsConsole() && (_permission.AllowConsole == Trinity::ChatCommands::Console::No))
return false;
return who.HasPermission(_permission.RequiredPermission);
}
bool Trinity::Impl::ChatCommands::ChatCommandNode::HasVisibleSubCommands(ChatHandler const& who) const
{
for (auto it = _subCommands.begin(); it != _subCommands.end(); ++it)
if (it->second.IsVisible(who))
return true;
return false;
}
void Trinity::ChatCommands::LoadCommandMap() { Trinity::Impl::ChatCommands::ChatCommandNode::LoadCommandMap(); }
void Trinity::ChatCommands::InvalidateCommandMap() { Trinity::Impl::ChatCommands::ChatCommandNode::InvalidateCommandMap(); }
bool Trinity::ChatCommands::TryExecuteCommand(ChatHandler& handler, std::string_view cmd) { return Trinity::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand(handler, cmd); }
void Trinity::ChatCommands::SendCommandHelpFor(ChatHandler& handler, std::string_view cmd) { Trinity::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(handler, cmd); }
std::vector<std::string> Trinity::ChatCommands::GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd) { return Trinity::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(handler, cmd); }

152
src/server/game/Chat/ChatCommands/ChatCommand.h
View File

@@ -24,14 +24,31 @@
#include "Define.h"
#include "Errors.h"
#include "Optional.h"
#include "RBAC.h"
#include "StringFormat.h"
#include "Util.h"
#include <cstddef>
#include <map>
#include <utility>
#include <tuple>
#include <type_traits>
#include <variant>
#include <vector>
class ChatHandler;
namespace Trinity::ChatCommands
{
enum class Console : bool
{
No = false,
Yes = true
};
struct ChatCommandBuilder;
using ChatCommandTable = std::vector<ChatCommandBuilder>;
}
namespace Trinity::Impl::ChatCommands
{
// forward declaration
@@ -97,63 +114,134 @@ namespace Trinity::Impl::ChatCommands
}
template <typename T> struct HandlerToTuple { static_assert(Trinity::dependant_false_v<T>, "Invalid command handler signature"); };
template <typename... Ts> struct HandlerToTuple<bool(*)(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
template <typename... Ts> struct HandlerToTuple<bool(ChatHandler*, Ts...)> { using type = std::tuple<ChatHandler*, advstd::remove_cvref_t<Ts>...>; };
template <typename T> using TupleType = typename HandlerToTuple<T>::type;
}
class TC_GAME_API ChatCommand
{
using wrapper_func = bool(void*, ChatHandler*, char const*);
public:
struct CommandInvoker
{
CommandInvoker() : _wrapper(nullptr), _handler(nullptr) {}
template <typename TypedHandler>
ChatCommand(char const* name, uint32 permission, bool allowConsole, TypedHandler handler, std::string help)
: Name(ASSERT_NOTNULL(name)), Permission(permission), AllowConsole(allowConsole), Help(std::move(help)), ChildCommands({})
CommandInvoker(TypedHandler& handler)
{
_wrapper = [](void* handler, ChatHandler* chatHandler, char const* argsStr)
_wrapper = [](void* handler, ChatHandler* chatHandler, std::string_view argsStr)
{
using Tuple = Trinity::Impl::ChatCommands::TupleType<TypedHandler>;
using Tuple = TupleType<TypedHandler>;
Tuple arguments;
std::get<0>(arguments) = chatHandler;
Trinity::Impl::ChatCommands::ChatCommandResult result = Trinity::Impl::ChatCommands::ConsumeFromOffset<Tuple, 1>(arguments, chatHandler, argsStr);
ChatCommandResult result = ConsumeFromOffset<Tuple, 1>(arguments, chatHandler, argsStr);
if (result)
return std::apply(reinterpret_cast<TypedHandler>(handler), std::move(arguments));
return std::apply(reinterpret_cast<TypedHandler*>(handler), std::move(arguments));
else
{
if (result.HasErrorMessage())
Trinity::Impl::ChatCommands::SendErrorMessageToHandler(chatHandler, result.GetErrorMessage());
SendErrorMessageToHandler(chatHandler, result.GetErrorMessage());
return false;
}
};
_handler = reinterpret_cast<void*>(handler);
}
ChatCommand(char const* name, uint32 permission, bool allowConsole, std::nullptr_t, std::string help, std::vector<ChatCommand> childCommands = {})
: Name(ASSERT_NOTNULL(name)), Permission(permission), AllowConsole(allowConsole), Help(std::move(help)), ChildCommands(std::move(childCommands))
{
_wrapper = nullptr;
_handler = nullptr;
}
bool operator()(ChatHandler* chatHandler, char const* args) const
explicit operator bool() const { return (_wrapper != nullptr); }
bool operator()(ChatHandler* chatHandler, std::string_view args) const
{
ASSERT(_wrapper && _handler);
return _wrapper(_handler, chatHandler, args);
}
bool HasHandler() const { return !!_handler; }
char const* Name;
uint32 Permission;
bool AllowConsole;
std::string Help;
std::vector<ChatCommand> ChildCommands;
private:
using wrapper_func = bool(void*, ChatHandler*, std::string_view);
wrapper_func* _wrapper;
void* _handler;
};
};
struct CommandPermissions
{
CommandPermissions() : RequiredPermission{}, AllowConsole{} {}
CommandPermissions(rbac::RBACPermissions perm, Trinity::ChatCommands::Console console) : RequiredPermission{ perm }, AllowConsole{ console } {}
rbac::RBACPermissions RequiredPermission;
Trinity::ChatCommands::Console AllowConsole;
};
class ChatCommandNode
{
friend struct FilteredCommandListIterator;
using ChatCommandBuilder = Trinity::ChatCommands::ChatCommandBuilder;
public:
static void LoadCommandMap();
static void InvalidateCommandMap();
static bool TryExecuteCommand(ChatHandler& handler, std::string_view cmd);
static void SendCommandHelpFor(ChatHandler& handler, std::string_view cmd);
static std::vector<std::string> GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd);
ChatCommandNode() : _invoker{}, _permission{}, _help{}, _subCommands{} {}
private:
static std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> const& GetTopLevelMap();
static void LoadCommandsIntoMap(ChatCommandNode* blank, std::map<std::string_view, ChatCommandNode, StringCompareLessI_T>& map, Trinity::ChatCommands::ChatCommandTable const& commands);
void LoadFromBuilder(ChatCommandBuilder const& builder);
ChatCommandNode(ChatCommandNode&& other) = default;
void AssertCommandHelp(std::string_view name) const;
void SendCommandHelp(ChatHandler& handler) const;
bool IsVisible(ChatHandler const& who) const { return (IsInvokerVisible(who) || HasVisibleSubCommands(who)); }
bool IsInvokerVisible(ChatHandler const& who) const;
bool HasVisibleSubCommands(ChatHandler const& who) const;
CommandInvoker _invoker;
CommandPermissions _permission;
std::string _help;
std::map<std::string_view, ChatCommandNode, StringCompareLessI_T> _subCommands;
};
}
namespace Trinity::ChatCommands
{
struct ChatCommandBuilder
{
friend class Trinity::Impl::ChatCommands::ChatCommandNode;
using InvokerEntry = std::pair<Trinity::Impl::ChatCommands::CommandInvoker, Trinity::Impl::ChatCommands::CommandPermissions>;
using SubCommandEntry = std::reference_wrapper<std::vector<ChatCommandBuilder> const>;
template <typename TypedHandler>
ChatCommandBuilder(char const* name, TypedHandler& handler, rbac::RBACPermissions permission, Trinity::ChatCommands::Console allowConsole)
: _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(handler), std::forward_as_tuple(permission, allowConsole) }
{}
ChatCommandBuilder(char const* name, std::vector<ChatCommandBuilder> const& subCommands)
: _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<SubCommandEntry>, subCommands }
{}
ChatCommandBuilder(ChatCommandBuilder const&) = default;
/* deprecated: char const* parameters to command handlers */
[[deprecated]] ChatCommandBuilder(char const* name, bool(&handler)(ChatHandler*, char const*), rbac::RBACPermissions permission, Trinity::ChatCommands::Console allowConsole)
: _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(handler), std::forward_as_tuple(permission, allowConsole) }
{}
/* deprecated: old-style command table format */
template <typename TypedHandler>
[[deprecated]] ChatCommandBuilder(char const* name, rbac::RBACPermissions permission, bool console, TypedHandler* handler, char const*)
: _name{ ASSERT_NOTNULL(name) }, _data{ std::in_place_type<InvokerEntry>, std::piecewise_construct, std::forward_as_tuple(*handler), std::forward_as_tuple(permission, static_cast<Trinity::ChatCommands::Console>(console)) }
{}
[[deprecated]] ChatCommandBuilder(char const* name, rbac::RBACPermissions, bool, std::nullptr_t, char const*, std::vector <ChatCommandBuilder> const& sub)
: _name{ ASSERT_NOTNULL(name) }, _data { std::in_place_type<SubCommandEntry>, sub }
{}
private:
std::string_view _name;
std::variant<InvokerEntry, SubCommandEntry> _data;
};
TC_GAME_API void LoadCommandMap();
TC_GAME_API void InvalidateCommandMap();
TC_GAME_API bool TryExecuteCommand(ChatHandler& handler, std::string_view cmd);
TC_GAME_API void SendCommandHelpFor(ChatHandler& handler, std::string_view cmd);
TC_GAME_API std::vector<std::string> GetAutoCompletionsFor(ChatHandler const& handler, std::string_view cmd);
}
// backwards compatibility with old patches
using ChatCommand [[deprecated]] = Trinity::ChatCommands::ChatCommandBuilder;
#endif

2
src/server/game/Chat/ChatCommands/ChatCommandArgs.h
View File

@@ -81,7 +81,7 @@ namespace Trinity::Impl::ChatCommands
template <>
struct ArgInfo<char const*, void>
{
static ChatCommandResult TryConsume(char const*& arg, ChatHandler const*, std::string_view args) { arg = args.data(); return std::string_view(); }
static ChatCommandResult TryConsume(char const*& arg, ChatHandler const*, std::string_view args) { arg = (args.empty() ? "" : args.data()); return std::string_view(); }
};
// string_view

14
src/server/game/Miscellaneous/Language.h
View File

@@ -35,10 +35,10 @@ enum TrinityStrings
LANG_SYSTEMMESSAGE = 3,
LANG_EVENTMESSAGE = 4,
LANG_NO_HELP_CMD = 5,
LANG_NO_CMD = 6,
LANG_NO_SUBCMD = 7,
LANG_CMD_INVALID = 6,
LANG_SUBCMD_AMBIGUOUS = 7,
LANG_SUBCMDS_LIST = 8,
LANG_AVIABLE_CMD = 9,
LANG_AVAILABLE_CMDS = 9,
LANG_CMD_SYNTAX = 10,
LANG_ACCOUNT_LEVEL = 11,
LANG_CONNECTED_USERS = 12,
@@ -232,10 +232,10 @@ enum TrinityStrings
LANG_2FA_SECRET_TOO_LONG = 188,
LANG_2FA_SECRET_INVALID = 189,
LANG_2FA_SECRET_SET_COMPLETE = 190,
LANG_SUBCMDS_LIST_ENTRY = 191, // 3.3.5 RESERVED
LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS = 192, // 3.3.5 RESERVED
LANG_SUBCMD_INVALID = 193, // 3.3.5 RESERVED
LANG_CMD_AMBIGUOUS = 194, // 3.3.5 RESERVED
LANG_SUBCMDS_LIST_ENTRY = 191,
LANG_SUBCMDS_LIST_ENTRY_ELLIPSIS = 192,
LANG_SUBCMD_INVALID = 193,
LANG_CMD_AMBIGUOUS = 194,
LANG_CMD_HELP_GENERIC = 195, // 3.3.5 RESERVED
LANG_CMD_NO_HELP_AVAILABLE = 196, // 3.3.5 RESERVED
// Room for more level 1 197-199 not used

21
src/server/game/Scripting/ScriptMgr.cpp
View File

@@ -19,7 +19,6 @@
#include "AchievementMgr.h"
#include "AreaTrigger.h"
#include "AreaTriggerAI.h"
#include "Chat.h"
#include "ChatCommand.h"
#include "Conversation.h"
#include "Creature.h"
@@ -1057,17 +1056,17 @@ class ScriptRegistrySwapHooks<CommandScript, Base>
public:
void BeforeReleaseContext(std::string const& /*context*/) final override
{
ChatHandler::invalidateCommandTable();
Trinity::ChatCommands::InvalidateCommandMap();
}
void BeforeSwapContext(bool /*initialize*/) override
{
ChatHandler::invalidateCommandTable();
Trinity::ChatCommands::InvalidateCommandMap();
}
void BeforeUnload() final override
{
ChatHandler::invalidateCommandTable();
Trinity::ChatCommands::InvalidateCommandMap();
}
};
@@ -1753,22 +1752,16 @@ OutdoorPvP* ScriptMgr::CreateOutdoorPvP(uint32 scriptId)
return tmpscript->GetOutdoorPvP();
}
std::vector<ChatCommand> ScriptMgr::GetChatCommands()
Trinity::ChatCommands::ChatCommandTable ScriptMgr::GetChatCommands()
{
std::vector<ChatCommand> table;
Trinity::ChatCommands::ChatCommandTable table;
FOR_SCRIPTS_RET(CommandScript, itr, end, table)
{
std::vector<ChatCommand> cmds = itr->second->GetCommands();
table.insert(table.end(), cmds.begin(), cmds.end());
Trinity::ChatCommands::ChatCommandTable cmds = itr->second->GetCommands();
std::move(cmds.begin(), cmds.end(), std::back_inserter(table));
}
// Sort commands in alphabetical order
std::sort(table.begin(), table.end(), [](ChatCommand const& a, ChatCommand const& b)
{
return strcmp(a.Name, b.Name) < 0;
});
return table;
}

7
src/server/game/Scripting/ScriptMgr.h
View File

@@ -34,7 +34,6 @@ class Battlefield;
class Battleground;
class BattlegroundMap;
class Channel;
class ChatCommand;
class Conversation;
class Creature;
class CreatureAI;
@@ -79,6 +78,8 @@ struct Position;
struct QuestObjective;
struct SceneTemplate;
namespace Trinity::ChatCommands { struct ChatCommandBuilder; }
enum BattlegroundTypeId : uint32;
enum Difficulty : uint8;
enum DuelCompleteType : uint8;
@@ -569,7 +570,7 @@ class TC_GAME_API CommandScript : public ScriptObject
~CommandScript();
// Should return a pointer to a valid command table (ChatCommand array) to be used by ChatHandler.
virtual std::vector<ChatCommand> GetCommands() const = 0;
virtual std::vector<Trinity::ChatCommands::ChatCommandBuilder> GetCommands() const = 0;
};
class TC_GAME_API WeatherScript : public ScriptObject, public UpdatableScript<Weather>
@@ -1149,7 +1150,7 @@ class TC_GAME_API ScriptMgr
public: /* CommandScript */
std::vector<ChatCommand> GetChatCommands();
std::vector<Trinity::ChatCommands::ChatCommandBuilder> GetChatCommands();
public: /* WeatherScript */

3
src/server/game/World/World.cpp
View File

@@ -38,6 +38,7 @@
#include "CharacterDatabaseCleaner.h"
#include "CharacterTemplateDataStore.h"
#include "Chat.h"
#include "ChatCommand.h"
#include "ChatPackets.h"
#include "Config.h"
#include "ConversationDataStore.h"
@@ -2314,7 +2315,7 @@ void World::SetInitialWorldSettings()
sObjectMgr->InitializeQueriesData(QUERY_DATA_ALL);
TC_LOG_INFO("server.loading", "Initialize commands...");
ChatHandler::InitializeCommandTable();
Trinity::ChatCommands::LoadCommandMap();
///- Initialize game time and timers
TC_LOG_INFO("server.loading", "Initialize game time and timers");

60
src/server/scripts/Commands/cs_account.cpp
View File

@@ -49,48 +49,36 @@ class account_commandscript : public CommandScript
public:
account_commandscript() : CommandScript("account_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> accountSetSecTable =
static ChatCommandTable accountSetCommandTable =
{
{ "regmail", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_REGMAIL, true, &HandleAccountSetRegEmailCommand, "" },
{ "email", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL, true, &HandleAccountSetEmailCommand, "" },
{ "addon", HandleAccountSetAddonCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON, Console::Yes },
{ "sec regmail", HandleAccountSetRegEmailCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_REGMAIL, Console::Yes },
{ "sec email", HandleAccountSetEmailCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC_EMAIL, Console::Yes },
{ "gmlevel", HandleAccountSetSecLevelCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL, Console::Yes }, // temp for a transition period
{ "seclevel", HandleAccountSetSecLevelCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL, Console::Yes },
{ "password", HandleAccountSetPasswordCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD, Console::Yes },
{ "2fa", HandleAccountSet2FACommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_2FA, Console::Yes },
};
static std::vector<ChatCommand> accountSetCommandTable =
static ChatCommandTable accountCommandTable =
{
{ "addon", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_ADDON, true, &HandleAccountSetAddonCommand, "" },
{ "sec", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SEC, true, nullptr, "", accountSetSecTable },
{ "gmlevel", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL, true, &HandleAccountSetSecLevelCommand, "" }, // temp for a transition period
{ "seclevel", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_SECLEVEL, true, &HandleAccountSetSecLevelCommand, "" },
{ "password", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_PASSWORD, true, &HandleAccountSetPasswordCommand, "" },
{ "2fa", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET_2FA, true, &HandleAccountSet2FACommand, "" },
{ "2fa setup", HandleAccount2FASetupCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_SETUP, Console::No },
{ "2fa remove", HandleAccount2FARemoveCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_REMOVE, Console::No },
{ "addon", HandleAccountAddonCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_ADDON, Console::No },
{ "create", HandleAccountCreateCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_CREATE, Console::Yes },
{ "delete", HandleAccountDeleteCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_DELETE, Console::Yes },
{ "email", HandleAccountEmailCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_EMAIL, Console::No },
{ "onlinelist", HandleAccountOnlineListCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_ONLINE_LIST, Console::Yes },
{ "lock country", HandleAccountLockCountryCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY, Console::No },
{ "lock ip", HandleAccountLockIpCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_IP, Console::No },
{ "set", accountSetCommandTable },
{ "password", HandleAccountPasswordCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT_PASSWORD, Console::No },
{ "", HandleAccountCommand, rbac::RBAC_PERM_COMMAND_ACCOUNT, Console::No },
};
static std::vector<ChatCommand> account2FACommandTable =
static ChatCommandTable commandTable =
{
{ "setup", rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_SETUP, false, &HandleAccount2FASetupCommand, "" },
{ "remove", rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA_REMOVE, false, &HandleAccount2FARemoveCommand, "" },
};
static std::vector<ChatCommand> accountLockCommandTable =
{
{ "country", rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_COUNTRY, false, &HandleAccountLockCountryCommand, "" },
{ "ip", rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK_IP, false, &HandleAccountLockIpCommand, "" },
};
static std::vector<ChatCommand> accountCommandTable =
{
{ "2fa", rbac::RBAC_PERM_COMMAND_ACCOUNT_2FA, false, nullptr, "", account2FACommandTable },
{ "addon", rbac::RBAC_PERM_COMMAND_ACCOUNT_ADDON, false, &HandleAccountAddonCommand, "" },
{ "create", rbac::RBAC_PERM_COMMAND_ACCOUNT_CREATE, true, &HandleAccountCreateCommand, "" },
{ "delete", rbac::RBAC_PERM_COMMAND_ACCOUNT_DELETE, true, &HandleAccountDeleteCommand, "" },
{ "email", rbac::RBAC_PERM_COMMAND_ACCOUNT_EMAIL, false, &HandleAccountEmailCommand, "" },
{ "onlinelist", rbac::RBAC_PERM_COMMAND_ACCOUNT_ONLINE_LIST, true, &HandleAccountOnlineListCommand, "" },
{ "lock", rbac::RBAC_PERM_COMMAND_ACCOUNT_LOCK, false, nullptr, "", accountLockCommandTable },
{ "set", rbac::RBAC_PERM_COMMAND_ACCOUNT_SET, true, nullptr, "", accountSetCommandTable },
{ "password", rbac::RBAC_PERM_COMMAND_ACCOUNT_PASSWORD, false, &HandleAccountPasswordCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_ACCOUNT, false, &HandleAccountCommand, "" },
};
static std::vector<ChatCommand> commandTable =
{
{ "account", rbac::RBAC_PERM_COMMAND_ACCOUNT, true, nullptr, "", accountCommandTable },
{ "account", accountCommandTable },
};
return commandTable;
}

12
src/server/scripts/Commands/cs_achievement.cpp
View File

@@ -30,20 +30,18 @@ EndScriptData */
#include "Player.h"
#include "RBAC.h"
using namespace Trinity::ChatCommands;
class achievement_commandscript : public CommandScript
{
public:
achievement_commandscript() : CommandScript("achievement_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> achievementCommandTable =
static ChatCommandTable commandTable =
{
{ "add", rbac::RBAC_PERM_COMMAND_ACHIEVEMENT_ADD, false, &HandleAchievementAddCommand, "" },
};
static std::vector<ChatCommand> commandTable =
{
{ "achievement", rbac::RBAC_PERM_COMMAND_ACHIEVEMENT, false, nullptr, "", achievementCommandTable },
{ "achievement add", HandleAchievementAddCommand, rbac::RBAC_PERM_COMMAND_ACHIEVEMENT_ADD, Console::No },
};
return commandTable;
}

68
src/server/scripts/Commands/cs_ahbot.cpp
View File

@@ -22,58 +22,58 @@
#include "Language.h"
#include "RBAC.h"
static std::unordered_map<AuctionQuality, uint32> const ahbotQualityLangIds =
{
{ AUCTION_QUALITY_GRAY, LANG_AHBOT_QUALITY_GRAY },
{ AUCTION_QUALITY_WHITE, LANG_AHBOT_QUALITY_WHITE },
{ AUCTION_QUALITY_GREEN, LANG_AHBOT_QUALITY_GREEN },
{ AUCTION_QUALITY_BLUE, LANG_AHBOT_QUALITY_BLUE },
{ AUCTION_QUALITY_PURPLE, LANG_AHBOT_QUALITY_PURPLE },
{ AUCTION_QUALITY_ORANGE, LANG_AHBOT_QUALITY_ORANGE },
{ AUCTION_QUALITY_YELLOW, LANG_AHBOT_QUALITY_YELLOW }
};
using namespace Trinity::ChatCommands;
static std::unordered_map<AuctionQuality, uint32> const ahbotQualityLangIds =
{
{ AUCTION_QUALITY_GRAY, LANG_AHBOT_QUALITY_GRAY },
{ AUCTION_QUALITY_WHITE, LANG_AHBOT_QUALITY_WHITE },
{ AUCTION_QUALITY_GREEN, LANG_AHBOT_QUALITY_GREEN },
{ AUCTION_QUALITY_BLUE, LANG_AHBOT_QUALITY_BLUE },
{ AUCTION_QUALITY_PURPLE, LANG_AHBOT_QUALITY_PURPLE },
{ AUCTION_QUALITY_ORANGE, LANG_AHBOT_QUALITY_ORANGE },
{ AUCTION_QUALITY_YELLOW, LANG_AHBOT_QUALITY_YELLOW }
};
class ahbot_commandscript : public CommandScript
{
public:
ahbot_commandscript(): CommandScript("ahbot_commandscript") {}
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> ahbotItemsAmountCommandTable =
static ChatCommandTable ahbotItemsAmountCommandTable =
{
{ "gray", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GRAY, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GRAY>, "" },
{ "white", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_WHITE, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_WHITE>, "" },
{ "green", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GREEN, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GREEN>, "" },
{ "blue", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_BLUE, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_BLUE>, "" },
{ "purple", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_PURPLE, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_PURPLE>, "" },
{ "orange", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_ORANGE, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_ORANGE>, "" },
{ "yellow", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_YELLOW, true, &HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_YELLOW>, "" },
{ "", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS, true, &HandleAHBotItemsAmountCommand, "" },
{ "gray", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GRAY>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GRAY, Console::Yes },
{ "white", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_WHITE>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_WHITE, Console::Yes },
{ "green", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_GREEN>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_GREEN, Console::Yes },
{ "blue", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_BLUE>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_BLUE, Console::Yes },
{ "purple", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_PURPLE>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_PURPLE, Console::Yes },
{ "orange", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_ORANGE>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_ORANGE, Console::Yes },
{ "yellow", HandleAHBotItemsAmountQualityCommand<AUCTION_QUALITY_YELLOW>, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS_YELLOW, Console::Yes },
{ "", HandleAHBotItemsAmountCommand, rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS, Console::Yes },
};
static std::vector<ChatCommand> ahbotItemsRatioCommandTable =
static ChatCommandTable ahbotItemsRatioCommandTable =
{
{ "alliance", rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_ALLIANCE, true, &HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_ALLIANCE>, "" },
{ "horde", rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_HORDE, true, &HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_HORDE>, "" },
{ "neutral", rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_NEUTRAL, true, &HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_NEUTRAL>, "" },
{ "", rbac::RBAC_PERM_COMMAND_AHBOT_RATIO, true, &HandleAHBotItemsRatioCommand, "" },
{ "alliance", HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_ALLIANCE>, rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_ALLIANCE, Console::Yes },
{ "horde", HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_HORDE>, rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_HORDE, Console::Yes },
{ "neutral", HandleAHBotItemsRatioHouseCommand<AUCTION_HOUSE_NEUTRAL>, rbac::RBAC_PERM_COMMAND_AHBOT_RATIO_NEUTRAL, Console::Yes },
{ "", HandleAHBotItemsRatioCommand, rbac::RBAC_PERM_COMMAND_AHBOT_RATIO, Console::Yes },
};
static std::vector<ChatCommand> ahbotCommandTable =
static ChatCommandTable ahbotCommandTable =
{
{ "items", rbac::RBAC_PERM_COMMAND_AHBOT_ITEMS, true, nullptr, "", ahbotItemsAmountCommandTable },
{ "ratio", rbac::RBAC_PERM_COMMAND_AHBOT_RATIO, true, nullptr, "", ahbotItemsRatioCommandTable },
{ "rebuild", rbac::RBAC_PERM_COMMAND_AHBOT_REBUILD, true, &HandleAHBotRebuildCommand, "" },
{ "reload", rbac::RBAC_PERM_COMMAND_AHBOT_RELOAD, true, &HandleAHBotReloadCommand, "" },
{ "status", rbac::RBAC_PERM_COMMAND_AHBOT_STATUS, true, &HandleAHBotStatusCommand, "" },
{ "items", ahbotItemsAmountCommandTable },
{ "ratio", ahbotItemsRatioCommandTable },
{ "rebuild", HandleAHBotRebuildCommand, rbac::RBAC_PERM_COMMAND_AHBOT_REBUILD, Console::Yes },
{ "reload", HandleAHBotReloadCommand, rbac::RBAC_PERM_COMMAND_AHBOT_RELOAD, Console::Yes },
{ "status", HandleAHBotStatusCommand, rbac::RBAC_PERM_COMMAND_AHBOT_STATUS, Console::Yes },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "ahbot", rbac::RBAC_PERM_COMMAND_AHBOT, false, nullptr, "", ahbotCommandTable },
{ "ahbot", ahbotCommandTable },
};
return commandTable;

21
src/server/scripts/Commands/cs_arena.cpp
View File

@@ -32,25 +32,26 @@ EndScriptData */
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
class arena_commandscript : public CommandScript
{
public:
arena_commandscript() : CommandScript("arena_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> arenaCommandTable =
static ChatCommandTable arenaCommandTable =
{
{ "create", rbac::RBAC_PERM_COMMAND_ARENA_CREATE, true, &HandleArenaCreateCommand, "" },
{ "disband", rbac::RBAC_PERM_COMMAND_ARENA_DISBAND, true, &HandleArenaDisbandCommand, "" },
{ "rename", rbac::RBAC_PERM_COMMAND_ARENA_RENAME, true, &HandleArenaRenameCommand, "" },
{ "captain", rbac::RBAC_PERM_COMMAND_ARENA_CAPTAIN, false, &HandleArenaCaptainCommand, "" },
{ "info", rbac::RBAC_PERM_COMMAND_ARENA_INFO, true, &HandleArenaInfoCommand, "" },
{ "lookup", rbac::RBAC_PERM_COMMAND_ARENA_LOOKUP, false, &HandleArenaLookupCommand, "" },
{ "create", HandleArenaCreateCommand, rbac::RBAC_PERM_COMMAND_ARENA_CREATE, Console::Yes },
{ "disband", HandleArenaDisbandCommand, rbac::RBAC_PERM_COMMAND_ARENA_DISBAND, Console::Yes },
{ "rename", HandleArenaRenameCommand, rbac::RBAC_PERM_COMMAND_ARENA_RENAME, Console::Yes },
{ "captain", HandleArenaCaptainCommand, rbac::RBAC_PERM_COMMAND_ARENA_CAPTAIN, Console::No },
{ "info", HandleArenaInfoCommand, rbac::RBAC_PERM_COMMAND_ARENA_INFO, Console::Yes },
{ "lookup", HandleArenaLookupCommand, rbac::RBAC_PERM_COMMAND_ARENA_LOOKUP, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "arena", rbac::RBAC_PERM_COMMAND_ARENA, false, nullptr, "", arenaCommandTable },
{ "arena", arenaCommandTable },
};
return commandTable;
}

54
src/server/scripts/Commands/cs_ban.cpp
View File

@@ -36,45 +36,51 @@ EndScriptData */
#include "World.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
using namespace Trinity::ChatCommands;
class ban_commandscript : public CommandScript
{
public:
ban_commandscript() : CommandScript("ban_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> unbanCommandTable =
static ChatCommandTable unbanCommandTable =
{
{ "account", rbac::RBAC_PERM_COMMAND_UNBAN_ACCOUNT, true, &HandleUnBanAccountCommand, "" },
{ "character", rbac::RBAC_PERM_COMMAND_UNBAN_CHARACTER, true, &HandleUnBanCharacterCommand, "" },
{ "playeraccount", rbac::RBAC_PERM_COMMAND_UNBAN_PLAYERACCOUNT, true, &HandleUnBanAccountByCharCommand, "" },
{ "ip", rbac::RBAC_PERM_COMMAND_UNBAN_IP, true, &HandleUnBanIPCommand, "" },
{ "account", HandleUnBanAccountCommand, rbac::RBAC_PERM_COMMAND_UNBAN_ACCOUNT, Console::Yes },
{ "character", HandleUnBanCharacterCommand, rbac::RBAC_PERM_COMMAND_UNBAN_CHARACTER, Console::Yes },
{ "playeraccount", HandleUnBanAccountByCharCommand, rbac::RBAC_PERM_COMMAND_UNBAN_PLAYERACCOUNT, Console::Yes },
{ "ip", HandleUnBanIPCommand, rbac::RBAC_PERM_COMMAND_UNBAN_IP, Console::Yes },
};
static std::vector<ChatCommand> banlistCommandTable =
static ChatCommandTable banlistCommandTable =
{
{ "account", rbac::RBAC_PERM_COMMAND_BANLIST_ACCOUNT, true, &HandleBanListAccountCommand, "" },
{ "character", rbac::RBAC_PERM_COMMAND_BANLIST_CHARACTER, true, &HandleBanListCharacterCommand, "" },
{ "ip", rbac::RBAC_PERM_COMMAND_BANLIST_IP, true, &HandleBanListIPCommand, "" },
{ "account", HandleBanListAccountCommand, rbac::RBAC_PERM_COMMAND_BANLIST_ACCOUNT, Console::Yes },
{ "character", HandleBanListCharacterCommand, rbac::RBAC_PERM_COMMAND_BANLIST_CHARACTER, Console::Yes },
{ "ip", HandleBanListIPCommand, rbac::RBAC_PERM_COMMAND_BANLIST_IP, Console::Yes },
};
static std::vector<ChatCommand> baninfoCommandTable =
static ChatCommandTable baninfoCommandTable =
{
{ "account", rbac::RBAC_PERM_COMMAND_BANINFO_ACCOUNT, true, &HandleBanInfoAccountCommand, "" },
{ "character", rbac::RBAC_PERM_COMMAND_BANINFO_CHARACTER, true, &HandleBanInfoCharacterCommand, "" },
{ "ip", rbac::RBAC_PERM_COMMAND_BANINFO_IP, true, &HandleBanInfoIPCommand, "" },
{ "account", HandleBanInfoAccountCommand, rbac::RBAC_PERM_COMMAND_BANINFO_ACCOUNT, Console::Yes },
{ "character", HandleBanInfoCharacterCommand, rbac::RBAC_PERM_COMMAND_BANINFO_CHARACTER, Console::Yes },
{ "ip", HandleBanInfoIPCommand, rbac::RBAC_PERM_COMMAND_BANINFO_IP, Console::Yes },
};
static std::vector<ChatCommand> banCommandTable =
static ChatCommandTable banCommandTable =
{
{ "account", rbac::RBAC_PERM_COMMAND_BAN_ACCOUNT, true, &HandleBanAccountCommand, "" },
{ "character", rbac::RBAC_PERM_COMMAND_BAN_CHARACTER, true, &HandleBanCharacterCommand, "" },
{ "playeraccount", rbac::RBAC_PERM_COMMAND_BAN_PLAYERACCOUNT, true, &HandleBanAccountByCharCommand, "" },
{ "ip", rbac::RBAC_PERM_COMMAND_BAN_IP, true, &HandleBanIPCommand, "" },
{ "account", HandleBanAccountCommand, rbac::RBAC_PERM_COMMAND_BAN_ACCOUNT, Console::Yes },
{ "character", HandleBanCharacterCommand, rbac::RBAC_PERM_COMMAND_BAN_CHARACTER, Console::Yes },
{ "playeraccount", HandleBanAccountByCharCommand, rbac::RBAC_PERM_COMMAND_BAN_PLAYERACCOUNT, Console::Yes },
{ "ip", HandleBanIPCommand, rbac::RBAC_PERM_COMMAND_BAN_IP, Console::Yes },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "ban", rbac::RBAC_PERM_COMMAND_BAN, true, nullptr, "", banCommandTable },
{ "baninfo", rbac::RBAC_PERM_COMMAND_BANINFO, true, nullptr, "", baninfoCommandTable },
{ "banlist", rbac::RBAC_PERM_COMMAND_BANLIST, true, nullptr, "", banlistCommandTable },
{ "unban", rbac::RBAC_PERM_COMMAND_UNBAN, true, nullptr, "", unbanCommandTable },
{ "ban", banCommandTable },
{ "baninfo", baninfoCommandTable },
{ "banlist", banlistCommandTable },
{ "unban", unbanCommandTable },
};
return commandTable;
}

211
src/server/scripts/Commands/cs_battlenet_account.cpp
View File

@@ -30,39 +30,38 @@
#include "Util.h"
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
class battlenet_account_commandscript : public CommandScript
{
public:
battlenet_account_commandscript() : CommandScript("battlenet_account_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> accountSetCommandTable =
static ChatCommandTable accountSetCommandTable =
{
{ "password", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_SET_PASSWORD, true, &HandleAccountSetPasswordCommand, "" },
{ "password", HandleAccountSetPasswordCommand,rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_SET_PASSWORD, Console::Yes },
};
static std::vector<ChatCommand> accountLockCommandTable =
static ChatCommandTable accountLockCommandTable =
{
{ "country", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_COUNTRY, true, &HandleAccountLockCountryCommand, "" },
{ "ip", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_IP, true, &HandleAccountLockIpCommand, "" },
{ "country", HandleAccountLockCountryCommand,rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_COUNTRY, Console::Yes },
{ "ip", HandleAccountLockIpCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LOCK_IP, Console::Yes },
};
static std::vector<ChatCommand> accountCommandTable =
static ChatCommandTable accountCommandTable =
{
{ "create", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE, true, &HandleAccountCreateCommand, "" },
{ "gameaccountcreate", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE_GAME, true, &HandleGameAccountCreateCommand, "" },
{ "lock", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT, false, nullptr, "", accountLockCommandTable },
{ "set", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_SET, true, nullptr, "", accountSetCommandTable },
{ "password", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_PASSWORD, false, &HandleAccountPasswordCommand, "" },
{ "link", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LINK, true, &HandleAccountLinkCommand, "" },
{ "unlink", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_UNLINK, true, &HandleAccountUnlinkCommand, "" },
{ "listgameaccounts", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LIST_GAME_ACCOUTNS, true, &HandleListGameAccountsCommand, "" }
{ "create", HandleAccountCreateCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE, Console::Yes },
{ "gameaccountcreate", HandleGameAccountCreateCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_CREATE_GAME, Console::Yes },
{ "lock", accountLockCommandTable },
{ "set", accountSetCommandTable },
{ "password", HandleAccountPasswordCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_PASSWORD, Console::No },
{ "link", HandleAccountLinkCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LINK, Console::Yes },
{ "unlink", HandleAccountUnlinkCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_UNLINK, Console::Yes },
{ "listgameaccounts", HandleListGameAccountsCommand, rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT_LIST_GAME_ACCOUTNS, Console::Yes }
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "bnetaccount", rbac::RBAC_PERM_COMMAND_BNET_ACCOUNT, true, nullptr, "", accountCommandTable },
{ "bnetaccount", accountCommandTable },
};
return commandTable;
@@ -117,111 +116,59 @@ public:
}
// Sets country lock on own account
static bool HandleAccountLockCountryCommand(ChatHandler* handler, char const* args)
static bool HandleAccountLockCountryCommand(ChatHandler* handler, bool state)
{
if (!*args)
if (state)
{
handler->SendSysMessage(LANG_USE_BOL);
handler->SetSentErrorMessage(true);
return false;
}
std::string param = (char*)args;
if (!param.empty())
{
if (param == "on")
{
if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(handler->GetSession()->GetRemoteAddress()))
{
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK_CONTRY);
stmt->setString(0, location->CountryCode);
stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
LoginDatabase.Execute(stmt);
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
}
else
{
handler->PSendSysMessage("IP2Location] No information");
TC_LOG_DEBUG("server.bnetserver", "IP2Location] No information");
}
}
else if (param == "off")
if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(handler->GetSession()->GetRemoteAddress()))
{
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK_CONTRY);
stmt->setString(0, "00");
stmt->setString(0, location->CountryCode);
stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
LoginDatabase.Execute(stmt);
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
}
else
{
handler->PSendSysMessage("IP2Location] No information");
TC_LOG_DEBUG("server.bnetserver", "IP2Location] No information");
}
return true;
}
handler->SendSysMessage(LANG_USE_BOL);
handler->SetSentErrorMessage(true);
return false;
else
{
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK_CONTRY);
stmt->setString(0, "00");
stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
LoginDatabase.Execute(stmt);
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
}
return true;
}
// Sets ip lock on own account
static bool HandleAccountLockIpCommand(ChatHandler* handler, char const* args)
static bool HandleAccountLockIpCommand(ChatHandler* handler, bool state)
{
if (!*args)
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK);
if (state)
{
handler->SendSysMessage(LANG_USE_BOL);
handler->SetSentErrorMessage(true);
return false;
stmt->setBool(0, true); // locked
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
}
else
{
stmt->setBool(0, false); // unlocked
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
}
std::string param = (char*)args;
stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
if (!param.empty())
{
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_ACCOUNT_LOCK);
if (param == "on")
{
stmt->setBool(0, true); // locked
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKLOCKED);
}
else if (param == "off")
{
stmt->setBool(0, false); // unlocked
handler->PSendSysMessage(LANG_COMMAND_ACCLOCKUNLOCKED);
}
stmt->setUInt32(1, handler->GetSession()->GetBattlenetAccountId());
LoginDatabase.Execute(stmt);
return true;
}
handler->SendSysMessage(LANG_USE_BOL);
handler->SetSentErrorMessage(true);
return false;
LoginDatabase.Execute(stmt);
return true;
}
static bool HandleAccountPasswordCommand(ChatHandler* handler, char const* args)
static bool HandleAccountPasswordCommand(ChatHandler* handler, std::string const& oldPassword, std::string const& newPassword, std::string const& passwordConfirmation)
{
// If no args are given at all, we can return false right away.
if (!*args)
{
handler->SendSysMessage(LANG_CMD_SYNTAX);
handler->SetSentErrorMessage(true);
return false;
}
// Command is supposed to be: .account password [$oldpassword] [$newpassword] [$newpasswordconfirmation] [$emailconfirmation]
char* oldPassword = strtok((char*)args, " "); // This extracts [$oldpassword]
char* newPassword = strtok(nullptr, " "); // This extracts [$newpassword]
char* passwordConfirmation = strtok(nullptr, " "); // This extracts [$newpasswordconfirmation]
//Is any of those variables missing for any reason ? We return false.
if (!oldPassword || !newPassword || !passwordConfirmation)
{
handler->SendSysMessage(LANG_CMD_SYNTAX);
handler->SetSentErrorMessage(true);
return false;
}
// We compare the old, saved password to the entered old password - no chance for the unauthorized.
if (!Battlenet::AccountMgr::CheckPassword(handler->GetSession()->GetBattlenetAccountId(), std::string(oldPassword)))
{
@@ -234,7 +181,7 @@ public:
}
// Making sure that newly entered password is correctly entered.
if (strcmp(newPassword, passwordConfirmation) != 0)
if (newPassword != passwordConfirmation)
{
handler->SendSysMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
handler->SetSentErrorMessage(true);
@@ -265,24 +212,8 @@ public:
}
/// Set password for account
static bool HandleAccountSetPasswordCommand(ChatHandler* handler, char const* args)
static bool HandleAccountSetPasswordCommand(ChatHandler* handler, std::string accountName, std::string const& password, std::string const& passwordConfirmation)
{
if (!*args)
{
handler->SendSysMessage(LANG_CMD_SYNTAX);
handler->SetSentErrorMessage(true);
return false;
}
///- Get the command line arguments
char* account = strtok((char*)args, " ");
char* password = strtok(nullptr, " ");
char* passwordConfirmation = strtok(nullptr, " ");
if (!account || !password || !passwordConfirmation)
return false;
std::string accountName = account;
if (!Utf8ToUpperOnlyLatin(accountName))
{
handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
@@ -298,7 +229,7 @@ public:
return false;
}
if (strcmp(password, passwordConfirmation))
if (password != passwordConfirmation)
{
handler->SendSysMessage(LANG_NEW_PASSWORDS_NOT_MATCH);
handler->SetSentErrorMessage(true);
@@ -306,7 +237,6 @@ public:
}
AccountOpResult result = Battlenet::AccountMgr::ChangePassword(targetAccountId, password);
switch (result)
{
case AccountOpResult::AOR_OK:
@@ -348,17 +278,8 @@ public:
return true;
}
static bool HandleAccountUnlinkCommand(ChatHandler* handler, char const* args)
static bool HandleAccountUnlinkCommand(ChatHandler* handler, std::string const& gameAccountName)
{
if (!*args)
{
handler->SendSysMessage(LANG_CMD_SYNTAX);
handler->SetSentErrorMessage(true);
return false;
}
std::string gameAccountName = args;
switch (Battlenet::AccountMgr::UnlinkGameAccount(gameAccountName))
{
case AccountOpResult::AOR_OK:
@@ -379,16 +300,8 @@ public:
return true;
}
static bool HandleGameAccountCreateCommand(ChatHandler* handler, char const* args)
static bool HandleGameAccountCreateCommand(ChatHandler* handler, std::string const& bnetAccountName)
{
if (!*args)
{
handler->SendSysMessage(LANG_CMD_SYNTAX);
handler->SetSentErrorMessage(true);
return false;
}
std::string bnetAccountName = args;
uint32 accountId = Battlenet::AccountMgr::GetId(bnetAccountName);
if (!accountId)
{
@@ -440,14 +353,10 @@ public:
return true;
}
static bool HandleListGameAccountsCommand(ChatHandler* handler, char const* args)
static bool HandleListGameAccountsCommand(ChatHandler* handler, std::string const& battlenetAccountName)
{
if (!*args)
return false;
char* battlenetAccountName = strtok((char*)args, " ");
LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_GAME_ACCOUNT_LIST_SMALL);
stmt->setString(0, battlenetAccountName);
stmt->setStringView(0, battlenetAccountName);
if (PreparedQueryResult accountList = LoginDatabase.Query(stmt))
{
auto formatDisplayName = [](char const* name) -> std::string

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

@@ -28,24 +28,26 @@ EndScriptData */
#include "ChatCommand.h"
#include "RBAC.h"
using namespace Trinity::ChatCommands;
class bf_commandscript : public CommandScript
{
public:
bf_commandscript() : CommandScript("bf_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> battlefieldcommandTable =
static ChatCommandTable battlefieldcommandTable =
{
{ "start", rbac::RBAC_PERM_COMMAND_BF_START, false, &HandleBattlefieldStart, "" },
{ "stop", rbac::RBAC_PERM_COMMAND_BF_STOP, false, &HandleBattlefieldEnd, "" },
{ "switch", rbac::RBAC_PERM_COMMAND_BF_SWITCH, false, &HandleBattlefieldSwitch, "" },
{ "timer", rbac::RBAC_PERM_COMMAND_BF_TIMER, false, &HandleBattlefieldTimer, "" },
{ "enable", rbac::RBAC_PERM_COMMAND_BF_ENABLE, false, &HandleBattlefieldEnable, "" },
{ "start", HandleBattlefieldStart, rbac::RBAC_PERM_COMMAND_BF_START, Console::No },
{ "stop", HandleBattlefieldEnd, rbac::RBAC_PERM_COMMAND_BF_STOP, Console::No },
{ "switch", HandleBattlefieldSwitch, rbac::RBAC_PERM_COMMAND_BF_SWITCH, Console::No },
{ "timer", HandleBattlefieldTimer, rbac::RBAC_PERM_COMMAND_BF_TIMER, Console::No },
{ "enable", HandleBattlefieldEnable, rbac::RBAC_PERM_COMMAND_BF_ENABLE, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "bf", rbac::RBAC_PERM_COMMAND_BF, false, nullptr, "", battlefieldcommandTable },
{ "bf", battlefieldcommandTable },
};
return commandTable;
}

21
src/server/scripts/Commands/cs_cast.cpp
View File

@@ -34,25 +34,26 @@ EndScriptData */
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
class cast_commandscript : public CommandScript
{
public:
cast_commandscript() : CommandScript("cast_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> castCommandTable =
static ChatCommandTable castCommandTable =
{
{ "back", rbac::RBAC_PERM_COMMAND_CAST_BACK, false, &HandleCastBackCommand, "" },
{ "dist", rbac::RBAC_PERM_COMMAND_CAST_DIST, false, &HandleCastDistCommand, "" },
{ "self", rbac::RBAC_PERM_COMMAND_CAST_SELF, false, &HandleCastSelfCommand, "" },
{ "target", rbac::RBAC_PERM_COMMAND_CAST_TARGET, false, &HandleCastTargetCommad, "" },
{ "dest", rbac::RBAC_PERM_COMMAND_CAST_DEST, false, &HandleCastDestCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_CAST, false, &HandleCastCommand, "" },
{ "back", HandleCastBackCommand, rbac::RBAC_PERM_COMMAND_CAST_BACK, Console::No },
{ "dist", HandleCastDistCommand, rbac::RBAC_PERM_COMMAND_CAST_DIST, Console::No },
{ "self", HandleCastSelfCommand, rbac::RBAC_PERM_COMMAND_CAST_SELF, Console::No },
{ "target", HandleCastTargetCommad, rbac::RBAC_PERM_COMMAND_CAST_TARGET, Console::No },
{ "dest", HandleCastDestCommand, rbac::RBAC_PERM_COMMAND_CAST_DEST, Console::No },
{ "", HandleCastCommand, rbac::RBAC_PERM_COMMAND_CAST, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "cast", rbac::RBAC_PERM_COMMAND_CAST, false, nullptr, "", castCommandTable },
{ "cast", castCommandTable },
};
return commandTable;
}

51
src/server/scripts/Commands/cs_character.cpp
View File

@@ -39,46 +39,47 @@ EndScriptData */
#include <sstream>
using namespace Trinity::ChatCommands;
class character_commandscript : public CommandScript
{
public:
character_commandscript() : CommandScript("character_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> pdumpCommandTable =
static ChatCommandTable pdumpCommandTable =
{
{ "copy", rbac::RBAC_PERM_COMMAND_PDUMP_COPY, true, &HandlePDumpCopyCommand, "" },
{ "load", rbac::RBAC_PERM_COMMAND_PDUMP_LOAD, true, &HandlePDumpLoadCommand, "" },
{ "write", rbac::RBAC_PERM_COMMAND_PDUMP_WRITE, true, &HandlePDumpWriteCommand, "" },
{ "copy", HandlePDumpCopyCommand, rbac::RBAC_PERM_COMMAND_PDUMP_COPY, Console::Yes },
{ "load", HandlePDumpLoadCommand, rbac::RBAC_PERM_COMMAND_PDUMP_LOAD, Console::Yes },
{ "write", HandlePDumpWriteCommand, rbac::RBAC_PERM_COMMAND_PDUMP_WRITE, Console::Yes },
};
static std::vector<ChatCommand> characterDeletedCommandTable =
static ChatCommandTable characterDeletedCommandTable =
{
{ "delete", rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_DELETE, true, &HandleCharacterDeletedDeleteCommand, "" },
{ "list", rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_LIST, true, &HandleCharacterDeletedListCommand, "" },
{ "restore", rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_RESTORE, true, &HandleCharacterDeletedRestoreCommand, "" },
{ "old", rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_OLD, true, &HandleCharacterDeletedOldCommand, "" },
{ "delete", HandleCharacterDeletedDeleteCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_DELETE, Console::Yes },
{ "list", HandleCharacterDeletedListCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_LIST, Console::Yes },
{ "restore", HandleCharacterDeletedRestoreCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_RESTORE, Console::Yes },
{ "old", HandleCharacterDeletedOldCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED_OLD, Console::Yes },
};
static std::vector<ChatCommand> characterCommandTable =
static ChatCommandTable characterCommandTable =
{
{ "customize", rbac::RBAC_PERM_COMMAND_CHARACTER_CUSTOMIZE, true, &HandleCharacterCustomizeCommand, "", },
{ "changefaction", rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEFACTION, true, &HandleCharacterChangeFactionCommand, "", },
{ "changerace", rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGERACE, true, &HandleCharacterChangeRaceCommand, "", },
{ "changeaccount", rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEACCOUNT, true, &HandleCharacterChangeAccountCommand, "", },
{ "deleted", rbac::RBAC_PERM_COMMAND_CHARACTER_DELETED, true, nullptr, "", characterDeletedCommandTable },
{ "erase", rbac::RBAC_PERM_COMMAND_CHARACTER_ERASE, true, &HandleCharacterEraseCommand, "", },
{ "level", rbac::RBAC_PERM_COMMAND_CHARACTER_LEVEL, true, &HandleLevelUpCommand, "", },
{ "rename", rbac::RBAC_PERM_COMMAND_CHARACTER_RENAME, true, &HandleCharacterRenameCommand, "", },
{ "reputation", rbac::RBAC_PERM_COMMAND_CHARACTER_REPUTATION, true, &HandleCharacterReputationCommand, "", },
{ "titles", rbac::RBAC_PERM_COMMAND_CHARACTER_TITLES, true, &HandleCharacterTitlesCommand, "", },
{ "customize", HandleCharacterCustomizeCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_CUSTOMIZE, Console::Yes },
{ "changefaction", HandleCharacterChangeFactionCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEFACTION, Console::Yes },
{ "changerace", HandleCharacterChangeRaceCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGERACE, Console::Yes },
{ "changeaccount", HandleCharacterChangeAccountCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_CHANGEACCOUNT, Console::Yes },
{ "deleted", characterDeletedCommandTable },
{ "erase", HandleCharacterEraseCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_ERASE, Console::Yes },
{ "level", HandleLevelUpCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_LEVEL, Console::Yes },
{ "rename", HandleCharacterRenameCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_RENAME, Console::Yes },
{ "reputation", HandleCharacterReputationCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_REPUTATION, Console::Yes },
{ "titles", HandleCharacterTitlesCommand, rbac::RBAC_PERM_COMMAND_CHARACTER_TITLES, Console::Yes },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "character", rbac::RBAC_PERM_COMMAND_CHARACTER, true, nullptr, "", characterCommandTable },
{ "levelup", rbac::RBAC_PERM_COMMAND_LEVELUP, false, &HandleLevelUpCommand, "" },
{ "pdump", rbac::RBAC_PERM_COMMAND_PDUMP, true, nullptr, "", pdumpCommandTable },
{ "character", characterCommandTable },
{ "levelup", HandleLevelUpCommand, rbac::RBAC_PERM_COMMAND_LEVELUP, Console::No },
{ "pdump", pdumpCommandTable },
};
return commandTable;
}

26
src/server/scripts/Commands/cs_cheat.cpp
View File

@@ -30,29 +30,31 @@ EndScriptData */
#include "RBAC.h"
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
class cheat_commandscript : public CommandScript
{
public:
cheat_commandscript() : CommandScript("cheat_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> cheatCommandTable =
static ChatCommandTable cheatCommandTable =
{
{ "god", rbac::RBAC_PERM_COMMAND_CHEAT_GOD, false, &HandleGodModeCheatCommand, "" },
{ "casttime", rbac::RBAC_PERM_COMMAND_CHEAT_CASTTIME, false, &HandleCasttimeCheatCommand, "" },
{ "cooldown", rbac::RBAC_PERM_COMMAND_CHEAT_COOLDOWN, false, &HandleCoolDownCheatCommand, "" },
{ "power", rbac::RBAC_PERM_COMMAND_CHEAT_POWER, false, &HandlePowerCheatCommand, "" },
{ "waterwalk", rbac::RBAC_PERM_COMMAND_CHEAT_WATERWALK, false, &HandleWaterWalkCheatCommand, "" },
{ "status", rbac::RBAC_PERM_COMMAND_CHEAT_STATUS, false, &HandleCheatStatusCommand, "" },
{ "taxi", rbac::RBAC_PERM_COMMAND_CHEAT_TAXI, false, &HandleTaxiCheatCommand, "" },
{ "explore", rbac::RBAC_PERM_COMMAND_CHEAT_EXPLORE, false, &HandleExploreCheatCommand, "" },
{ "god", HandleGodModeCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_GOD, Console::No },
{ "casttime", HandleCasttimeCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_CASTTIME, Console::No },
{ "cooldown", HandleCoolDownCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_COOLDOWN, Console::No },
{ "power", HandlePowerCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_POWER, Console::No },
{ "waterwalk", HandleWaterWalkCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_WATERWALK, Console::No },
{ "status", HandleCheatStatusCommand, rbac::RBAC_PERM_COMMAND_CHEAT_STATUS, Console::No },
{ "taxi", HandleTaxiCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_TAXI, Console::No },
{ "explore", HandleExploreCheatCommand, rbac::RBAC_PERM_COMMAND_CHEAT_EXPLORE, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "cheat", rbac::RBAC_PERM_COMMAND_CHEAT, false, nullptr, "", cheatCommandTable },
{ "cheat", cheatCommandTable },
};
return commandTable;
}

156
src/server/scripts/Commands/cs_debug.cpp
View File

@@ -61,91 +61,79 @@ EndScriptData */
#include <sstream>
using namespace Trinity::ChatCommands;
class debug_commandscript : public CommandScript
{
public:
debug_commandscript() : CommandScript("debug_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> debugPlayCommandTable =
static ChatCommandTable debugPlayCommandTable =
{
{ "cinematic", rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_CINEMATIC, false, &HandleDebugPlayCinematicCommand, "" },
{ "movie", rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_MOVIE, false, &HandleDebugPlayMovieCommand, "" },
{ "sound", rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_SOUND, false, &HandleDebugPlaySoundCommand, "" },
{ "music", rbac::RBAC_PERM_COMMAND_DEBUG_PLAY_MUSIC, false, &HandleDebugPlayMusicCommand, "" },
{ "cinematic", HandleDebugPlayCinematicCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "movie", HandleDebugPlayMovieCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "sound", HandleDebugPlaySoundCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "music", HandleDebugPlayMusicCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
};
static std::vector<ChatCommand> debugSendCommandTable =
static ChatCommandTable debugSendCommandTable =
{
{ "buyerror", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_BUYERROR, false, &HandleDebugSendBuyErrorCommand, "" },
{ "channelnotify", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_CHANNELNOTIFY, false, &HandleDebugSendChannelNotifyCommand, "" },
{ "chatmessage", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_CHATMESSAGE, false, &HandleDebugSendChatMsgCommand, "" },
{ "equiperror", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_EQUIPERROR, false, &HandleDebugSendEquipErrorCommand, "" },
{ "largepacket", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_LARGEPACKET, false, &HandleDebugSendLargePacketCommand, "" },
{ "opcode", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_OPCODE, false, &HandleDebugSendOpcodeCommand, "" },
{ "qpartymsg", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_QPARTYMSG, false, &HandleDebugSendQuestPartyMsgCommand, "" },
{ "qinvalidmsg", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_QINVALIDMSG, false, &HandleDebugSendQuestInvalidMsgCommand, "" },
{ "sellerror", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_SELLERROR, false, &HandleDebugSendSellErrorCommand, "" },
{ "setphaseshift", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_SETPHASESHIFT, false, &HandleDebugSendSetPhaseShiftCommand, "" },
{ "spellfail", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_SPELLFAIL, false, &HandleDebugSendSpellFailCommand, "" },
{ "playerchoice", rbac::RBAC_PERM_COMMAND_DEBUG_SEND_PLAYER_CHOICE, false, &HandleDebugSendPlayerChoiceCommand, "" },
{ "buyerror", HandleDebugSendBuyErrorCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "channelnotify", HandleDebugSendChannelNotifyCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "chatmessage", HandleDebugSendChatMsgCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "equiperror", HandleDebugSendEquipErrorCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "largepacket", HandleDebugSendLargePacketCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "opcode", HandleDebugSendOpcodeCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "qpartymsg", HandleDebugSendQuestPartyMsgCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "qinvalidmsg", HandleDebugSendQuestInvalidMsgCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "sellerror", HandleDebugSendSellErrorCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "setphaseshift", HandleDebugSendSetPhaseShiftCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "spellfail", HandleDebugSendSpellFailCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "playerchoice", HandleDebugSendPlayerChoiceCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
};
static std::vector<ChatCommand> debugPvpCommandTable =
static ChatCommandTable debugCommandTable =
{
{ "warmode", rbac::RBAC_PERM_COMMAND_DEBUG, false, &HandleDebugWarModeFactionBalanceCommand, "" },
{ "threat", HandleDebugThreatListCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "threatinfo", HandleDebugThreatInfoCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "combat", HandleDebugCombatListCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "anim", HandleDebugAnimCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "arena", HandleDebugArenaCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "bg", HandleDebugBattlegroundCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "getitemstate", HandleDebugGetItemStateCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "lootrecipient", HandleDebugGetLootRecipientCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "play", debugPlayCommandTable },
{ "send", debugSendCommandTable },
{ "setaurastate", HandleDebugSetAuraStateCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "spawnvehicle", HandleDebugSpawnVehicleCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "entervehicle", HandleDebugEnterVehicleCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "worldstate" , HandleDebugUpdateWorldStateCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "itemexpire", HandleDebugItemExpireCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "areatriggers", HandleDebugAreaTriggersCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "los", HandleDebugLoSCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "moveflags", HandleDebugMoveflagsCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "transport", HandleDebugTransportCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "loadcells", HandleDebugLoadCellsCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "phase", HandleDebugPhaseCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "boundary", HandleDebugBoundaryCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "raidreset", HandleDebugRaidResetCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "neargraveyard", HandleDebugNearGraveyard, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "instancespawn", HandleDebugInstanceSpawns, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "conversation" , HandleDebugConversationCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "wsexpression" , HandleDebugWSExpressionCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "pvp warmode", HandleDebugWarModeBalanceCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "dummy", HandleDebugDummyCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
{ "asan memoryleak", HandleDebugMemoryLeak, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "asan outofbounds", HandleDebugOutOfBounds, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "guidlimits", HandleDebugGuidLimitsCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "objectcount", HandleDebugObjectCountCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "questreset", HandleDebugQuestResetCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "warden force", HandleDebugWardenForce, rbac::RBAC_PERM_COMMAND_DEBUG, Console::Yes },
{ "personalclone", HandleDebugBecomePersonalClone, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No }
};
static std::vector<ChatCommand> debugAsanCommandTable =
static ChatCommandTable commandTable =
{
{ "memoryleak", rbac::RBAC_PERM_COMMAND_DEBUG_ASAN, true, &HandleDebugMemoryLeak, "" },
{ "outofbounds", rbac::RBAC_PERM_COMMAND_DEBUG_ASAN, true, &HandleDebugOutOfBounds, "" },
};
static std::vector<ChatCommand> debugWardenCommandTable =
{
{ "force", rbac::RBAC_PERM_COMMAND_DEBUG, true, &HandleDebugWardenForce, "" }
};
static std::vector<ChatCommand> debugCommandTable =
{
{ "threat", rbac::RBAC_PERM_COMMAND_DEBUG_THREAT, false, &HandleDebugThreatListCommand, "" },
{ "threatinfo", rbac::RBAC_PERM_COMMAND_DEBUG_THREATINFO, false, &HandleDebugThreatInfoCommand, "" },
{ "combat", rbac::RBAC_PERM_COMMAND_DEBUG_COMBAT, false, &HandleDebugCombatListCommand, "" },
{ "anim", rbac::RBAC_PERM_COMMAND_DEBUG_ANIM, false, &HandleDebugAnimCommand, "" },
{ "arena", rbac::RBAC_PERM_COMMAND_DEBUG_ARENA, true, &HandleDebugArenaCommand, "" },
{ "bg", rbac::RBAC_PERM_COMMAND_DEBUG_BG, true, &HandleDebugBattlegroundCommand, "" },
{ "getitemstate", rbac::RBAC_PERM_COMMAND_DEBUG_GETITEMSTATE, false, &HandleDebugGetItemStateCommand, "" },
{ "lootrecipient", rbac::RBAC_PERM_COMMAND_DEBUG_LOOTRECIPIENT, false, &HandleDebugGetLootRecipientCommand, "" },
{ "play", rbac::RBAC_PERM_COMMAND_DEBUG_PLAY, false, nullptr, "", debugPlayCommandTable },
{ "send", rbac::RBAC_PERM_COMMAND_DEBUG_SEND, false, nullptr, "", debugSendCommandTable },
{ "setaurastate", rbac::RBAC_PERM_COMMAND_DEBUG_SETAURASTATE, false, &HandleDebugSetAuraStateCommand, "" },
{ "spawnvehicle", rbac::RBAC_PERM_COMMAND_DEBUG_SPAWNVEHICLE, false, &HandleDebugSpawnVehicleCommand, "" },
{ "entervehicle", rbac::RBAC_PERM_COMMAND_DEBUG_ENTERVEHICLE, false, &HandleDebugEnterVehicleCommand, "" },
{ "worldstate", rbac::RBAC_PERM_COMMAND_DEBUG_WORLDSTATE, false, &HandleDebugUpdateWorldStateCommand, "" },
{ "itemexpire", rbac::RBAC_PERM_COMMAND_DEBUG_ITEMEXPIRE, false, &HandleDebugItemExpireCommand, "" },
{ "areatriggers", rbac::RBAC_PERM_COMMAND_DEBUG_AREATRIGGERS, false, &HandleDebugAreaTriggersCommand, "" },
{ "los", rbac::RBAC_PERM_COMMAND_DEBUG_LOS, false, &HandleDebugLoSCommand, "" },
{ "moveflags", rbac::RBAC_PERM_COMMAND_DEBUG_MOVEFLAGS, false, &HandleDebugMoveflagsCommand, "" },
{ "transport", rbac::RBAC_PERM_COMMAND_DEBUG_TRANSPORT, false, &HandleDebugTransportCommand, "" },
{ "loadcells", rbac::RBAC_PERM_COMMAND_DEBUG_LOADCELLS, false, &HandleDebugLoadCellsCommand, "",},
{ "phase", rbac::RBAC_PERM_COMMAND_DEBUG_PHASE, false, &HandleDebugPhaseCommand, "" },
{ "boundary", rbac::RBAC_PERM_COMMAND_DEBUG_BOUNDARY, false, &HandleDebugBoundaryCommand, "" },
{ "raidreset", rbac::RBAC_PERM_COMMAND_INSTANCE_UNBIND, false, &HandleDebugRaidResetCommand, "" },
{ "neargraveyard", rbac::RBAC_PERM_COMMAND_NEARGRAVEYARD, false, &HandleDebugNearGraveyard, "" },
{ "instancespawn", rbac::RBAC_PERM_COMMAND_DEBUG_INSTANCESPAWN, false, &HandleDebugInstanceSpawns, "" },
{ "conversation" , rbac::RBAC_PERM_COMMAND_DEBUG_CONVERSATION, false, &HandleDebugConversationCommand, "" },
{ "worldstate" , rbac::RBAC_PERM_COMMAND_DEBUG, false, &HandleDebugWorldStateCommand, "" },
{ "wsexpression" , rbac::RBAC_PERM_COMMAND_DEBUG, false, &HandleDebugWSExpressionCommand, "" },
{ "pvp", rbac::RBAC_PERM_COMMAND_DEBUG, false, nullptr, "", debugPvpCommandTable },
{ "dummy", rbac::RBAC_PERM_COMMAND_DEBUG_DUMMY, false, &HandleDebugDummyCommand, "" },
{ "asan", rbac::RBAC_PERM_COMMAND_DEBUG_ASAN, true, nullptr, "", debugAsanCommandTable },
{ "guidlimits", rbac::RBAC_PERM_COMMAND_DEBUG, true, &HandleDebugGuidLimitsCommand, "" },
{ "objectcount", rbac::RBAC_PERM_COMMAND_DEBUG, true, &HandleDebugObjectCountCommand, "" },
{ "questreset", rbac::RBAC_PERM_COMMAND_DEBUG_QUESTRESET, true, &HandleDebugQuestResetCommand, "" },
{ "warden", rbac::RBAC_PERM_COMMAND_DEBUG, true, nullptr, "", debugWardenCommandTable },
{ "personalclone", rbac::RBAC_PERM_COMMAND_DEBUG, false, &HandleDebugBecomePersonalClone, "" }
};
static std::vector<ChatCommand> commandTable =
{
{ "debug", rbac::RBAC_PERM_COMMAND_DEBUG, true, nullptr, "", debugCommandTable },
{ "wpgps", rbac::RBAC_PERM_COMMAND_WPGPS, false, &HandleWPGPSCommand, "" },
{ "debug", debugCommandTable },
{ "wpgps", HandleWPGPSCommand, rbac::RBAC_PERM_COMMAND_DEBUG, Console::No },
};
return commandTable;
}
@@ -164,7 +152,7 @@ public:
return true;
}
static bool HandleDebugWarModeFactionBalanceCommand(ChatHandler* handler, Variant<uint32, EXACT_SEQUENCE("alliance"), EXACT_SEQUENCE("horde"), EXACT_SEQUENCE("neutral"), EXACT_SEQUENCE("off")> command, Optional<int32> rewardValue)
static bool HandleDebugWarModeBalanceCommand(ChatHandler* handler, Variant<uint32, EXACT_SEQUENCE("alliance"), EXACT_SEQUENCE("horde"), EXACT_SEQUENCE("neutral"), EXACT_SEQUENCE("off")> command, Optional<int32> rewardValue)
{
// USAGE: .debug pvp fb <alliance|horde|neutral|off> [pct]
// neutral Sets faction balance off.
@@ -1522,28 +1510,6 @@ public:
return Conversation::CreateConversation(conversationEntry, target, *target, target->GetGUID()) != nullptr;
}
static bool HandleDebugWorldStateCommand(ChatHandler* handler, uint32 worldStateId, Optional<uint32> value)
{
Player* target = handler->getSelectedPlayerOrSelf();
if (!target)
{
handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
handler->SetSentErrorMessage(true);
return false;
}
if (value)
{
sWorld->setWorldState(worldStateId, *value);
target->SendUpdateWorldState(worldStateId, *value);
}
else
handler->PSendSysMessage("Worldstate %u actual value : %u", worldStateId, sWorld->getWorldState(worldStateId));
return true;
}
static bool HandleDebugWSExpressionCommand(ChatHandler* handler, uint32 expressionId)
{
Player* target = handler->getSelectedPlayerOrSelf();

26
src/server/scripts/Commands/cs_deserter.cpp
View File

@@ -30,6 +30,8 @@
#include "RBAC.h"
#include "SpellAuras.h"
using namespace Trinity::ChatCommands;
enum Spells
{
LFG_SPELL_DUNGEON_DESERTER = 71041,
@@ -45,27 +47,27 @@ public:
* @brief Returns the command structure for the system.
*/
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> deserterInstanceCommandTable =
static ChatCommandTable deserterInstanceCommandTable =
{
{ "add", rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_ADD, false, &HandleDeserterInstanceAdd, "" },
{ "remove", rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_REMOVE, false, &HandleDeserterInstanceRemove, "" },
{ "add", HandleDeserterInstanceAdd, rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_ADD, Console::No },
{ "remove", HandleDeserterInstanceRemove, rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE_REMOVE, Console::No },
};
static std::vector<ChatCommand> deserterBGCommandTable =
static ChatCommandTable deserterBGCommandTable =
{
{ "add", rbac::RBAC_PERM_COMMAND_DESERTER_BG_ADD, false, &HandleDeserterBGAdd, "" },
{ "remove", rbac::RBAC_PERM_COMMAND_DESERTER_BG_REMOVE, false, &HandleDeserterBGRemove, "" },
{ "add", HandleDeserterBGAdd, rbac::RBAC_PERM_COMMAND_DESERTER_BG_ADD, Console::No },
{ "remove", HandleDeserterBGRemove, rbac::RBAC_PERM_COMMAND_DESERTER_BG_REMOVE, Console::No },
};
static std::vector<ChatCommand> deserterCommandTable =
static ChatCommandTable deserterCommandTable =
{
{ "instance", rbac::RBAC_PERM_COMMAND_DESERTER_INSTANCE, false, nullptr, "", deserterInstanceCommandTable },
{ "bg", rbac::RBAC_PERM_COMMAND_DESERTER_BG, false, nullptr, "", deserterBGCommandTable },
{ "instance", deserterInstanceCommandTable },
{ "bg", deserterBGCommandTable },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "deserter", rbac::RBAC_PERM_COMMAND_DESERTER, false, nullptr, "", deserterCommandTable },
{ "deserter", deserterCommandTable },
};
return commandTable;
}

54
src/server/scripts/Commands/cs_disable.cpp
View File

@@ -36,43 +36,49 @@ EndScriptData */
#include "RBAC.h"
#include "SpellMgr.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
using namespace Trinity::ChatCommands;
class disable_commandscript : public CommandScript
{
public:
disable_commandscript() : CommandScript("disable_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> removeDisableCommandTable =
static ChatCommandTable removeDisableCommandTable =
{
{ "spell", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_SPELL, true, &HandleRemoveDisableSpellCommand, "" },
{ "quest", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_QUEST, true, &HandleRemoveDisableQuestCommand, "" },
{ "map", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MAP, true, &HandleRemoveDisableMapCommand, "" },
{ "battleground", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_BATTLEGROUND, true, &HandleRemoveDisableBattlegroundCommand, "" },
{ "criteria", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_CRITERIA, true, &HandleRemoveDisableCriteriaCommand, "" },
{ "outdoorpvp", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_OUTDOORPVP, true, &HandleRemoveDisableOutdoorPvPCommand, "" },
{ "vmap", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_VMAP, true, &HandleRemoveDisableVmapCommand, "" },
{ "mmap", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MMAP, true, &HandleRemoveDisableMMapCommand, "" },
{ "spell", HandleRemoveDisableSpellCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_SPELL, Console::Yes },
{ "quest", HandleRemoveDisableQuestCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_QUEST, Console::Yes },
{ "map", HandleRemoveDisableMapCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MAP, Console::Yes },
{ "battleground", HandleRemoveDisableBattlegroundCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_BATTLEGROUND, Console::Yes },
{ "criteria", HandleRemoveDisableCriteriaCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_CRITERIA, Console::Yes },
{ "outdoorpvp", HandleRemoveDisableOutdoorPvPCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_OUTDOORPVP, Console::Yes },
{ "vmap", HandleRemoveDisableVmapCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_VMAP, Console::Yes },
{ "mmap", HandleRemoveDisableMMapCommand, rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE_MMAP, Console::Yes },
};
static std::vector<ChatCommand> addDisableCommandTable =
static ChatCommandTable addDisableCommandTable =
{
{ "spell", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_SPELL, true, &HandleAddDisableSpellCommand, "" },
{ "quest", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_QUEST, true, &HandleAddDisableQuestCommand, "" },
{ "map", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MAP, true, &HandleAddDisableMapCommand, "" },
{ "battleground", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_BATTLEGROUND, true, &HandleAddDisableBattlegroundCommand, "" },
{ "criteria", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_CRITERIA, true, &HandleAddDisableCriteriaCommand, "" },
{ "outdoorpvp", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_OUTDOORPVP, true, &HandleAddDisableOutdoorPvPCommand, "" },
{ "vmap", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_VMAP, true, &HandleAddDisableVmapCommand, "" },
{ "mmap", rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MMAP, true, &HandleAddDisableMMapCommand, "" },
{ "spell", HandleAddDisableSpellCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_SPELL, Console::Yes },
{ "quest", HandleAddDisableQuestCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_QUEST, Console::Yes },
{ "map", HandleAddDisableMapCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MAP, Console::Yes },
{ "battleground", HandleAddDisableBattlegroundCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_BATTLEGROUND, Console::Yes },
{ "criteria", HandleAddDisableCriteriaCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_CRITERIA, Console::Yes },
{ "outdoorpvp", HandleAddDisableOutdoorPvPCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_OUTDOORPVP, Console::Yes },
{ "vmap", HandleAddDisableVmapCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_VMAP, Console::Yes },
{ "mmap", HandleAddDisableMMapCommand, rbac::RBAC_PERM_COMMAND_DISABLE_ADD_MMAP, Console::Yes },
};
static std::vector<ChatCommand> disableCommandTable =
static ChatCommandTable disableCommandTable =
{
{ "add", rbac::RBAC_PERM_COMMAND_DISABLE_ADD, true, nullptr, "", addDisableCommandTable },
{ "remove", rbac::RBAC_PERM_COMMAND_DISABLE_REMOVE, true, nullptr, "", removeDisableCommandTable },
{ "add", addDisableCommandTable },
{ "remove", removeDisableCommandTable },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "disable", rbac::RBAC_PERM_COMMAND_DISABLE, false, nullptr, "", disableCommandTable },
{ "disable", disableCommandTable },
};
return commandTable;
}

16
src/server/scripts/Commands/cs_event.cpp
View File

@@ -37,18 +37,18 @@ class event_commandscript : public CommandScript
public:
event_commandscript() : CommandScript("event_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> eventCommandTable =
static ChatCommandTable eventCommandTable =
{
{ "activelist", rbac::RBAC_PERM_COMMAND_EVENT_ACTIVELIST, true, &HandleEventActiveListCommand, "" },
{ "start", rbac::RBAC_PERM_COMMAND_EVENT_START, true, &HandleEventStartCommand, "" },
{ "stop", rbac::RBAC_PERM_COMMAND_EVENT_STOP, true, &HandleEventStopCommand, "" },
{ "info", rbac::RBAC_PERM_COMMAND_EVENT, true, &HandleEventInfoCommand, "" },
{ "activelist", HandleEventActiveListCommand, rbac::RBAC_PERM_COMMAND_EVENT_ACTIVELIST, Console::Yes },
{ "start", HandleEventStartCommand, rbac::RBAC_PERM_COMMAND_EVENT_START, Console::Yes },
{ "stop", HandleEventStopCommand, rbac::RBAC_PERM_COMMAND_EVENT_STOP, Console::Yes },
{ "info", HandleEventInfoCommand, rbac::RBAC_PERM_COMMAND_EVENT_INFO, Console::Yes },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "event", rbac::RBAC_PERM_COMMAND_EVENT, false, nullptr, "", eventCommandTable },
{ "event", eventCommandTable },
};
return commandTable;
}

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

@@ -34,25 +34,27 @@ EndScriptData */
#include "World.h"
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
class gm_commandscript : public CommandScript
{
public:
gm_commandscript() : CommandScript("gm_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> gmCommandTable =
static ChatCommandTable gmCommandTable =
{
{ "chat", rbac::RBAC_PERM_COMMAND_GM_CHAT, false, &HandleGMChatCommand, "" },
{ "fly", rbac::RBAC_PERM_COMMAND_GM_FLY, false, &HandleGMFlyCommand, "" },
{ "ingame", rbac::RBAC_PERM_COMMAND_GM_INGAME, true, &HandleGMListIngameCommand, "" },
{ "list", rbac::RBAC_PERM_COMMAND_GM_LIST, true, &HandleGMListFullCommand, "" },
{ "visible", rbac::RBAC_PERM_COMMAND_GM_VISIBLE, false, &HandleGMVisibleCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_GM, false, &HandleGMCommand, "" },
{ "chat", HandleGMChatCommand, rbac::RBAC_PERM_COMMAND_GM_CHAT, Console::No },
{ "fly", HandleGMFlyCommand, rbac::RBAC_PERM_COMMAND_GM_FLY, Console::No },
{ "ingame", HandleGMListIngameCommand, rbac::RBAC_PERM_COMMAND_GM_INGAME, Console::Yes },
{ "list", HandleGMListFullCommand, rbac::RBAC_PERM_COMMAND_GM_LIST, Console::Yes },
{ "visible", HandleGMVisibleCommand, rbac::RBAC_PERM_COMMAND_GM_VISIBLE, Console::No },
{ "", HandleGMCommand, rbac::RBAC_PERM_COMMAND_GM, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "gm", rbac::RBAC_PERM_COMMAND_GM, false, nullptr, "", gmCommandTable },
{ "gm", gmCommandTable },
};
return commandTable;
}

53
src/server/scripts/Commands/cs_go.cpp
View File

@@ -40,47 +40,38 @@ EndScriptData */
#include <sstream>
using namespace Trinity::ChatCommands;
class go_commandscript : public CommandScript
{
public:
go_commandscript() : CommandScript("go_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> goCreatureCommandTable =
static ChatCommandTable goCommandTable =
{
{ "id", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoCreatureCIdCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoCreatureSpawnIdCommand, "" }
{ "creature", HandleGoCreatureSpawnIdCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "creature id", HandleGoCreatureCIdCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "gameobject", HandleGoGameObjectSpawnIdCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "gameobject id", HandleGoGameObjectGOIdCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "graveyard", HandleGoGraveyardCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "grid", HandleGoGridCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "quest", HandleGoQuestCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "taxinode", HandleGoTaxinodeCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "areatrigger", HandleGoAreaTriggerCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "zonexy", HandleGoZoneXYCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "xyz", HandleGoXYZCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "bugticket", HandleGoTicketCommand<BugTicket>, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "complaintticket", HandleGoTicketCommand<ComplaintTicket>, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "suggestionticket", HandleGoTicketCommand<SuggestionTicket>,rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "offset", HandleGoOffsetCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "instance", HandleGoInstanceCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No },
{ "boss", HandleGoBossCommand, rbac::RBAC_PERM_COMMAND_GO, Console::No }
};
static std::vector<ChatCommand> goGameObjectCommandTable =
static ChatCommandTable commandTable =
{
{ "id", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoGameObjectGOIdCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoGameObjectSpawnIdCommand, "" }
};
static std::vector<ChatCommand> goCommandTable =
{
{ "creature", rbac::RBAC_PERM_COMMAND_GO, false, nullptr, "", goCreatureCommandTable },
{ "gameobject", rbac::RBAC_PERM_COMMAND_GO, false, nullptr, "", goGameObjectCommandTable },
{ "graveyard", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoGraveyardCommand, "" },
{ "grid", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoGridCommand, "" },
{ "quest", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoQuestCommand, "" },
{ "taxinode", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoTaxinodeCommand, "" },
{ "areatrigger", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoAreaTriggerCommand, "" },
{ "zonexy", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoZoneXYCommand, "" },
{ "xyz", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoXYZCommand, "" },
{ "bugticket", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoTicketCommand<BugTicket>, "" },
{ "complaintticket", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoTicketCommand<ComplaintTicket>, "" },
{ "suggestionticket", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoTicketCommand<SuggestionTicket>, "" },
{ "offset", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoOffsetCommand, "" },
{ "instance", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoInstanceCommand, "" },
{ "boss", rbac::RBAC_PERM_COMMAND_GO, false, &HandleGoBossCommand, "" }
};
static std::vector<ChatCommand> commandTable =
{
{ "go", rbac::RBAC_PERM_COMMAND_GO, false, nullptr, "", goCommandTable },
{ "go", goCommandTable },
};
return commandTable;
}

44
src/server/scripts/Commands/cs_gobject.cpp
View File

@@ -43,8 +43,8 @@ EndScriptData */
#include "WorldSession.h"
#include <sstream>
using namespace Trinity::ChatCommands;
using GameObjectSpawnId = Variant<Hyperlink<gameobject>, ObjectGuid::LowType>;
using GameObjectEntry = Variant<Hyperlink<gameobject_entry>, uint32>;
@@ -57,35 +57,27 @@ class gobject_commandscript : public CommandScript
public:
gobject_commandscript() : CommandScript("gobject_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> gobjectAddCommandTable =
static ChatCommandTable gobjectCommandTable =
{
{ "temp", rbac::RBAC_PERM_COMMAND_GOBJECT_ADD_TEMP, false, &HandleGameObjectAddTempCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_GOBJECT_ADD, false, &HandleGameObjectAddCommand, "" },
{ "activate", HandleGameObjectActivateCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_ACTIVATE, Console::No },
{ "delete", HandleGameObjectDeleteCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_DELETE, Console::No },
{ "info", HandleGameObjectInfoCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_INFO, Console::No },
{ "move", HandleGameObjectMoveCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_MOVE, Console::No },
{ "near", HandleGameObjectNearCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_NEAR, Console::No },
{ "target", HandleGameObjectTargetCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_TARGET, Console::No },
{ "turn", HandleGameObjectTurnCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_TURN, Console::No },
{ "spawngroup", HandleNpcSpawnGroup, rbac::RBAC_PERM_COMMAND_GOBJECT_SPAWNGROUP, Console::No },
{ "despawngroup", HandleNpcDespawnGroup, rbac::RBAC_PERM_COMMAND_GOBJECT_DESPAWNGROUP, Console::No },
{ "add temp", HandleGameObjectAddTempCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_ADD_TEMP, Console::No },
{ "add", HandleGameObjectAddCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_ADD, Console::No },
{ "set phase", HandleGameObjectSetPhaseCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_SET_PHASE, Console::No },
{ "set state", HandleGameObjectSetStateCommand, rbac::RBAC_PERM_COMMAND_GOBJECT_SET_STATE, Console::No },
};
static std::vector<ChatCommand> gobjectSetCommandTable =
static ChatCommandTable commandTable =
{
{ "phase", rbac::RBAC_PERM_COMMAND_GOBJECT_SET_PHASE, false, &HandleGameObjectSetPhaseCommand, "" },
{ "state", rbac::RBAC_PERM_COMMAND_GOBJECT_SET_STATE, false, &HandleGameObjectSetStateCommand, "" },
};
static std::vector<ChatCommand> gobjectCommandTable =
{
{ "activate", rbac::RBAC_PERM_COMMAND_GOBJECT_ACTIVATE, false, &HandleGameObjectActivateCommand, "" },
{ "delete", rbac::RBAC_PERM_COMMAND_GOBJECT_DELETE, false, &HandleGameObjectDeleteCommand, "" },
{ "info", rbac::RBAC_PERM_COMMAND_GOBJECT_INFO, false, &HandleGameObjectInfoCommand, "" },
{ "move", rbac::RBAC_PERM_COMMAND_GOBJECT_MOVE, false, &HandleGameObjectMoveCommand, "" },
{ "near", rbac::RBAC_PERM_COMMAND_GOBJECT_NEAR, false, &HandleGameObjectNearCommand, "" },
{ "target", rbac::RBAC_PERM_COMMAND_GOBJECT_TARGET, false, &HandleGameObjectTargetCommand, "" },
{ "turn", rbac::RBAC_PERM_COMMAND_GOBJECT_TURN, false, &HandleGameObjectTurnCommand, "" },
{ "spawngroup", rbac::RBAC_PERM_COMMAND_GOBJECT_SPAWNGROUP, false, &HandleNpcSpawnGroup, "" },
{ "despawngroup", rbac::RBAC_PERM_COMMAND_GOBJECT_DESPAWNGROUP, false, &HandleNpcDespawnGroup, "" },
{ "add", rbac::RBAC_PERM_COMMAND_GOBJECT_ADD, false, nullptr, "", gobjectAddCommandTable },
{ "set", rbac::RBAC_PERM_COMMAND_GOBJECT_SET, false, nullptr, "", gobjectSetCommandTable },
};
static std::vector<ChatCommand> commandTable =
{
{ "gobject", rbac::RBAC_PERM_COMMAND_GOBJECT, false, nullptr, "", gobjectCommandTable },
{ "gobject", gobjectCommandTable },
};
return commandTable;
}

4
src/server/scripts/Commands/cs_group.cpp
View File

@@ -31,6 +31,10 @@
#include "RBAC.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class group_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_guild.cpp
View File

@@ -35,6 +35,10 @@ EndScriptData */
#include "RBAC.h"
#include <iomanip>
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
using namespace Trinity::ChatCommands;
class guild_commandscript : public CommandScript
{

4
src/server/scripts/Commands/cs_honor.cpp
View File

@@ -30,6 +30,10 @@ EndScriptData */
#include "RBAC.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class honor_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_instance.cpp
View File

@@ -39,6 +39,10 @@ EndScriptData */
#include "WorldSession.h"
#include <sstream>
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class instance_commandscript : public CommandScript
{
public:

43
src/server/scripts/Commands/cs_learn.cpp
View File

@@ -34,41 +34,46 @@ EndScriptData */
#include "SpellMgr.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
using namespace Trinity::ChatCommands;
class learn_commandscript : public CommandScript
{
public:
learn_commandscript() : CommandScript("learn_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> learnAllMyCommandTable =
static ChatCommandTable learnAllMyCommandTable =
{
{ "class", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS, false, &HandleLearnAllMyClassCommand, "" },
{ "pettalents", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS, false, &HandleLearnAllMyPetTalentsCommand, "" },
{ "spells", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, false, &HandleLearnAllMySpellsCommand, "" },
{ "talents", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_TALENTS, false, &HandleLearnAllMyTalentsCommand, "" },
{ "class", HandleLearnAllMyClassCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS, Console::No },
{ "pettalents", HandleLearnAllMyPetTalentsCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS, Console::No },
{ "spells", HandleLearnAllMySpellsCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, Console::No },
{ "talents", HandleLearnAllMyTalentsCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_TALENTS, Console::No },
};
static std::vector<ChatCommand> learnAllCommandTable =
static ChatCommandTable learnAllCommandTable =
{
{ "my", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY, false, nullptr, "", learnAllMyCommandTable },
{ "gm", rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM, false, &HandleLearnAllGMCommand, "" },
{ "crafts", rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS, false, &HandleLearnAllCraftsCommand, "" },
{ "default", rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT, false, &HandleLearnAllDefaultCommand, "" },
{ "lang", rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG, false, &HandleLearnAllLangCommand, "" },
{ "recipes", rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES, false, &HandleLearnAllRecipesCommand, "" },
{ "my", learnAllMyCommandTable },
{ "gm", HandleLearnAllGMCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM, Console::No },
{ "crafts", HandleLearnAllCraftsCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS, Console::No },
{ "default", HandleLearnAllDefaultCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT, Console::No },
{ "lang", HandleLearnAllLangCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG, Console::No },
{ "recipes", HandleLearnAllRecipesCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES, Console::No },
};
static std::vector<ChatCommand> learnCommandTable =
static ChatCommandTable learnCommandTable =
{
{ "all", rbac::RBAC_PERM_COMMAND_LEARN_ALL, false, nullptr, "", learnAllCommandTable },
{ "", rbac::RBAC_PERM_COMMAND_LEARN, false, &HandleLearnCommand, "" },
{ "", HandleLearnCommand, rbac::RBAC_PERM_COMMAND_LEARN, Console::No },
{ "all", learnAllCommandTable },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "learn", rbac::RBAC_PERM_COMMAND_LEARN, false, nullptr, "", learnCommandTable },
{ "unlearn", rbac::RBAC_PERM_COMMAND_UNLEARN, false, &HandleUnLearnCommand, "" },
{ "learn", learnCommandTable },
{ "unlearn", HandleUnLearnCommand, rbac::RBAC_PERM_COMMAND_UNLEARN, Console::No },
};
return commandTable;
}

18
src/server/scripts/Commands/cs_lfg.cpp
View File

@@ -49,20 +49,20 @@ class lfg_commandscript : public CommandScript
public:
lfg_commandscript() : CommandScript("lfg_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> lfgCommandTable =
static ChatCommandTable lfgCommandTable =
{
{ "player", rbac::RBAC_PERM_COMMAND_LFG_PLAYER, false, &HandleLfgPlayerInfoCommand, "" },
{ "group", rbac::RBAC_PERM_COMMAND_LFG_GROUP, false, &HandleLfgGroupInfoCommand, "" },
{ "queue", rbac::RBAC_PERM_COMMAND_LFG_QUEUE, true, &HandleLfgQueueInfoCommand, "" },
{ "clean", rbac::RBAC_PERM_COMMAND_LFG_CLEAN, true, &HandleLfgCleanCommand, "" },
{ "options", rbac::RBAC_PERM_COMMAND_LFG_OPTIONS, true, &HandleLfgOptionsCommand, "" },
{ "player", HandleLfgPlayerInfoCommand, rbac::RBAC_PERM_COMMAND_LFG_PLAYER, Console::No },
{ "group", HandleLfgGroupInfoCommand, rbac::RBAC_PERM_COMMAND_LFG_GROUP, Console::No },
{ "queue", HandleLfgQueueInfoCommand, rbac::RBAC_PERM_COMMAND_LFG_QUEUE, Console::Yes },
{ "clean", HandleLfgCleanCommand, rbac::RBAC_PERM_COMMAND_LFG_CLEAN, Console::Yes },
{ "options", HandleLfgOptionsCommand, rbac::RBAC_PERM_COMMAND_LFG_OPTIONS, Console::Yes },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "lfg", rbac::RBAC_PERM_COMMAND_LFG, true, nullptr, "", lfgCommandTable },
{ "lfg", lfgCommandTable },
};
return commandTable;
}

56
src/server/scripts/Commands/cs_list.cpp
View File

@@ -33,7 +33,6 @@ EndScriptData */
#include "GameTime.h"
#include "Language.h"
#include "MapManager.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "PhasingHandler.h"
#include "Player.h"
@@ -49,22 +48,22 @@ class list_commandscript : public CommandScript
public:
list_commandscript() : CommandScript("list_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> listCommandTable =
static ChatCommandTable listCommandTable =
{
{ "creature", rbac::RBAC_PERM_COMMAND_LIST_CREATURE, true, &HandleListCreatureCommand, "" },
{ "item", rbac::RBAC_PERM_COMMAND_LIST_ITEM, true, &HandleListItemCommand, "" },
{ "object", rbac::RBAC_PERM_COMMAND_LIST_OBJECT, true, &HandleListObjectCommand, "" },
{ "auras", rbac::RBAC_PERM_COMMAND_LIST_AURAS, false, &HandleListAurasCommand, "" },
{ "mail", rbac::RBAC_PERM_COMMAND_LIST_MAIL, true, &HandleListMailCommand, "" },
{ "spawnpoints", rbac::RBAC_PERM_COMMAND_LIST_SPAWNPOINTS, false, &HandleListSpawnPointsCommand, "" },
{ "respawns", rbac::RBAC_PERM_COMMAND_LIST_RESPAWNS, false, &HandleListRespawnsCommand, "" },
{ "scenes", rbac::RBAC_PERM_COMMAND_LIST_SCENES, false, &HandleListScenesCommand, "" },
{ "creature", HandleListCreatureCommand, rbac::RBAC_PERM_COMMAND_LIST_CREATURE, Console::Yes },
{ "item", HandleListItemCommand, rbac::RBAC_PERM_COMMAND_LIST_ITEM, Console::Yes },
{ "object", HandleListObjectCommand, rbac::RBAC_PERM_COMMAND_LIST_OBJECT, Console::Yes },
{ "auras", HandleListAurasCommand, rbac::RBAC_PERM_COMMAND_LIST_AURAS, Console::No },
{ "mail", HandleListMailCommand, rbac::RBAC_PERM_COMMAND_LIST_MAIL, Console::Yes },
{ "spawnpoints", HandleListSpawnPointsCommand, rbac::RBAC_PERM_COMMAND_LIST_SPAWNPOINTS, Console::No },
{ "respawns", HandleListRespawnsCommand, rbac::RBAC_PERM_COMMAND_LIST_RESPAWNS, Console::No },
{ "scenes", HandleListScenesCommand, rbac::RBAC_PERM_COMMAND_LIST_SCENES, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "list", rbac::RBAC_PERM_COMMAND_LIST,true, nullptr, "", listCommandTable },
{ "list", listCommandTable },
};
return commandTable;
}
@@ -482,40 +481,27 @@ public:
return true;
}
// handle list mail command
static bool HandleListMailCommand(ChatHandler* handler, char const* args)
static bool HandleListMailCommand(ChatHandler* handler, Optional<PlayerIdentifier> player)
{
Player* target;
ObjectGuid targetGuid;
std::string targetName;
CharacterDatabasePreparedStatement* stmt = nullptr;
if (!*args)
if (!player)
player = PlayerIdentifier::FromTargetOrSelf(handler);
if (!player)
return false;
ObjectGuid parseGUID = ObjectGuid::Create<HighGuid::Player>(strtoull(args, nullptr, 10));
if (sCharacterCache->GetCharacterNameByGuid(parseGUID, targetName))
{
target = ObjectAccessor::FindPlayer(parseGUID);
targetGuid = parseGUID;
}
else if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
return false;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_LIST_COUNT);
stmt->setUInt64(0, targetGuid.GetCounter());
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_LIST_COUNT);
stmt->setUInt64(0, player->GetGUID().GetCounter());
PreparedQueryResult queryResult = CharacterDatabase.Query(stmt);
if (queryResult)
{
Field* fields = queryResult->Fetch();
uint32 countMail = fields[0].GetUInt64();
std::string nameLink = handler->playerLink(targetName);
handler->PSendSysMessage(LANG_LIST_MAIL_HEADER, countMail, nameLink.c_str(), targetGuid.ToString().c_str());
std::string nameLink = handler->playerLink(player->GetName());
handler->PSendSysMessage(LANG_LIST_MAIL_HEADER, countMail, nameLink.c_str(), player->GetGUID().ToString().c_str());
handler->PSendSysMessage(LANG_ACCOUNT_LIST_BAR);
stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAIL_LIST_INFO);
stmt->setUInt64(0, targetGuid.GetCounter());
stmt->setUInt64(0, player->GetGUID().GetCounter());
queryResult = CharacterDatabase.Query(stmt);
if (queryResult)

4
src/server/scripts/Commands/cs_lookup.cpp
View File

@@ -38,6 +38,10 @@ EndScriptData */
#include "WorldSession.h"
#include <sstream>
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class lookup_commandscript : public CommandScript
{
public:

28
src/server/scripts/Commands/cs_message.cpp
View File

@@ -45,26 +45,18 @@ class message_commandscript : public CommandScript
public:
message_commandscript() : CommandScript("message_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> channelSetCommandTable =
static ChatCommandTable commandTable =
{
{ "ownership", rbac::RBAC_PERM_COMMAND_CHANNEL_SET_OWNERSHIP, false, &HandleChannelSetOwnership, "" },
};
static std::vector<ChatCommand> channelCommandTable =
{
{ "set", rbac::RBAC_PERM_COMMAND_CHANNEL_SET, true, nullptr, "", channelSetCommandTable },
};
static std::vector<ChatCommand> commandTable =
{
{ "channel", rbac::RBAC_PERM_COMMAND_CHANNEL, true, nullptr, "", channelCommandTable },
{ "nameannounce", rbac::RBAC_PERM_COMMAND_NAMEANNOUNCE, true, &HandleNameAnnounceCommand, "" },
{ "gmnameannounce", rbac::RBAC_PERM_COMMAND_GMNAMEANNOUNCE, true, &HandleGMNameAnnounceCommand, "" },
{ "announce", rbac::RBAC_PERM_COMMAND_ANNOUNCE, true, &HandleAnnounceCommand, "" },
{ "gmannounce", rbac::RBAC_PERM_COMMAND_GMANNOUNCE, true, &HandleGMAnnounceCommand, "" },
{ "notify", rbac::RBAC_PERM_COMMAND_NOTIFY, true, &HandleNotifyCommand, "" },
{ "gmnotify", rbac::RBAC_PERM_COMMAND_GMNOTIFY, true, &HandleGMNotifyCommand, "" },
{ "whispers", rbac::RBAC_PERM_COMMAND_WHISPERS, false, &HandleWhispersCommand, "" },
{ "channel set ownership", HandleChannelSetOwnership, rbac::RBAC_PERM_COMMAND_CHANNEL_SET_OWNERSHIP, Console::No },
{ "nameannounce", HandleNameAnnounceCommand, rbac::RBAC_PERM_COMMAND_NAMEANNOUNCE, Console::Yes },
{ "gmnameannounce", HandleGMNameAnnounceCommand, rbac::RBAC_PERM_COMMAND_GMNAMEANNOUNCE, Console::Yes },
{ "announce", HandleAnnounceCommand, rbac::RBAC_PERM_COMMAND_ANNOUNCE, Console::Yes },
{ "gmannounce", HandleGMAnnounceCommand, rbac::RBAC_PERM_COMMAND_GMANNOUNCE, Console::Yes },
{ "notify", HandleNotifyCommand, rbac::RBAC_PERM_COMMAND_NOTIFY, Console::Yes },
{ "gmnotify", HandleGMNotifyCommand, rbac::RBAC_PERM_COMMAND_GMNOTIFY, Console::Yes },
{ "whispers", HandleWhispersCommand, rbac::RBAC_PERM_COMMAND_WHISPERS, Console::No },
};
return commandTable;
}

20
src/server/scripts/Commands/cs_misc.cpp
View File

@@ -56,6 +56,10 @@
#undef GetClassName
#endif
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
using namespace Trinity::ChatCommands;
class misc_commandscript : public CommandScript
@@ -603,7 +607,7 @@ public:
static bool HandleCommandsCommand(ChatHandler* handler)
{
handler->ShowHelpForCommand(ChatHandler::getCommandTable(), "");
Trinity::ChatCommands::SendCommandHelpFor(*handler, "");
return true;
}
@@ -694,19 +698,9 @@ public:
return true;
}
static bool HandleHelpCommand(ChatHandler* handler, Tail cmdArg)
static bool HandleHelpCommand(ChatHandler* handler, Tail cmd)
{
if (cmdArg.empty())
{
handler->ShowHelpForCommand(ChatHandler::getCommandTable(), "help");
handler->ShowHelpForCommand(ChatHandler::getCommandTable(), "");
}
else
{
if (!handler->ShowHelpForCommand(ChatHandler::getCommandTable(), std::string(cmdArg).c_str()))
handler->SendSysMessage(LANG_NO_HELP_CMD);
}
Trinity::ChatCommands::SendCommandHelpFor(*handler, cmd);
return true;
}

4
src/server/scripts/Commands/cs_mmaps.cpp
View File

@@ -37,6 +37,10 @@
#include "RBAC.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class mmaps_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_modify.cpp
View File

@@ -38,6 +38,10 @@ EndScriptData */
#include "UpdateFields.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class modify_commandscript : public CommandScript
{
public:

96
src/server/scripts/Commands/cs_npc.cpp
View File

@@ -47,6 +47,7 @@ EndScriptData */
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
using CreatureSpawnId = Variant<Hyperlink<creature>, ObjectGuid::LowType>;
using CreatureEntry = Variant<Hyperlink<creature_entry>, uint32>;
@@ -59,66 +60,57 @@ class npc_commandscript : public CommandScript
public:
npc_commandscript() : CommandScript("npc_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> npcAddCommandTable =
static ChatCommandTable npcAddCommandTable =
{
{ "formation", rbac::RBAC_PERM_COMMAND_NPC_ADD_FORMATION, false, &HandleNpcAddFormationCommand, "" },
{ "item", rbac::RBAC_PERM_COMMAND_NPC_ADD_ITEM, false, &HandleNpcAddVendorItemCommand, "" },
{ "move", rbac::RBAC_PERM_COMMAND_NPC_ADD_MOVE, false, &HandleNpcAddMoveCommand, "" },
{ "temp", rbac::RBAC_PERM_COMMAND_NPC_ADD_TEMP, false, &HandleNpcAddTempSpawnCommand, "" },
//{ "weapon", rbac::RBAC_PERM_COMMAND_NPC_ADD_WEAPON, false, &HandleNpcAddWeaponCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_NPC_ADD, false, &HandleNpcAddCommand, "" },
{ "formation", HandleNpcAddFormationCommand, rbac::RBAC_PERM_COMMAND_NPC_ADD_FORMATION, Console::No },
{ "item", HandleNpcAddVendorItemCommand, rbac::RBAC_PERM_COMMAND_NPC_ADD_ITEM, Console::No },
{ "move", HandleNpcAddMoveCommand, rbac::RBAC_PERM_COMMAND_NPC_ADD_MOVE, Console::No },
{ "temp", HandleNpcAddTempSpawnCommand, rbac::RBAC_PERM_COMMAND_NPC_ADD_TEMP, Console::No },
// { "weapon", HandleNpcAddWeaponCommand, rbac::RBAC_PERM_COMMAND_NPC_ADD_WEAPON, Console::No },
{ "", HandleNpcAddCommand, rbac::RBAC_PERM_COMMAND_NPC_ADD, Console::No },
};
static std::vector<ChatCommand> npcDeleteCommandTable =
static ChatCommandTable npcSetCommandTable =
{
{ "item", rbac::RBAC_PERM_COMMAND_NPC_DELETE_ITEM, false, &HandleNpcDeleteVendorItemCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_NPC_DELETE, false, &HandleNpcDeleteCommand, "" },
{ "allowmove", HandleNpcSetAllowMovementCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_ALLOWMOVE, Console::No },
{ "entry", HandleNpcSetEntryCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_ENTRY, Console::No },
{ "factionid", HandleNpcSetFactionIdCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_FACTIONID, Console::No },
{ "flag", HandleNpcSetFlagCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_FLAG, Console::No },
{ "level", HandleNpcSetLevelCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_LEVEL, Console::No },
{ "link", HandleNpcSetLinkCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_LINK, Console::No },
{ "model", HandleNpcSetModelCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_MODEL, Console::No },
{ "movetype", HandleNpcSetMoveTypeCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_MOVETYPE, Console::No },
{ "phase", HandleNpcSetPhaseCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE, Console::No },
{ "wanderdistance", HandleNpcSetWanderDistanceCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNDIST, Console::No },
{ "spawntime", HandleNpcSetSpawnTimeCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNTIME, Console::No },
{ "data", HandleNpcSetDataCommand, rbac::RBAC_PERM_COMMAND_NPC_SET_DATA, Console::No },
};
static std::vector<ChatCommand> npcFollowCommandTable =
static ChatCommandTable npcCommandTable =
{
{ "stop", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW_STOP, false, &HandleNpcUnFollowCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW, false, &HandleNpcFollowCommand, "" },
{ "add", npcAddCommandTable },
{ "set", npcSetCommandTable },
{ "info", HandleNpcInfoCommand, rbac::RBAC_PERM_COMMAND_NPC_INFO, Console::No },
{ "near", HandleNpcNearCommand, rbac::RBAC_PERM_COMMAND_NPC_NEAR, Console::No },
{ "move", HandleNpcMoveCommand, rbac::RBAC_PERM_COMMAND_NPC_MOVE, Console::No },
{ "playemote", HandleNpcPlayEmoteCommand, rbac::RBAC_PERM_COMMAND_NPC_PLAYEMOTE, Console::No },
{ "say", HandleNpcSayCommand, rbac::RBAC_PERM_COMMAND_NPC_SAY, Console::No },
{ "textemote", HandleNpcTextEmoteCommand, rbac::RBAC_PERM_COMMAND_NPC_TEXTEMOTE, Console::No },
{ "whisper", HandleNpcWhisperCommand, rbac::RBAC_PERM_COMMAND_NPC_WHISPER, Console::No },
{ "yell", HandleNpcYellCommand, rbac::RBAC_PERM_COMMAND_NPC_YELL, Console::No },
{ "tame", HandleNpcTameCommand, rbac::RBAC_PERM_COMMAND_NPC_TAME, Console::No },
{ "spawngroup", HandleNpcSpawnGroup, rbac::RBAC_PERM_COMMAND_NPC_SPAWNGROUP, Console::No },
{ "despawngroup", HandleNpcDespawnGroup, rbac::RBAC_PERM_COMMAND_NPC_DESPAWNGROUP, Console::No },
{ "delete", HandleNpcDeleteCommand, rbac::RBAC_PERM_COMMAND_NPC_DELETE, Console::No },
{ "delete item", HandleNpcDeleteVendorItemCommand, rbac::RBAC_PERM_COMMAND_NPC_DELETE_ITEM, Console::No },
{ "follow", HandleNpcFollowCommand, rbac::RBAC_PERM_COMMAND_NPC_FOLLOW, Console::No },
{ "follow stop", HandleNpcUnFollowCommand, rbac::RBAC_PERM_COMMAND_NPC_FOLLOW, Console::No },
{ "evade", HandleNpcEvadeCommand, rbac::RBAC_PERM_COMMAND_NPC_EVADE, Console::No },
{ "showloot", HandleNpcShowLootCommand, rbac::RBAC_PERM_COMMAND_NPC_SHOWLOOT, Console::No },
};
static std::vector<ChatCommand> npcSetCommandTable =
static ChatCommandTable commandTable =
{
{ "allowmove", rbac::RBAC_PERM_COMMAND_NPC_SET_ALLOWMOVE, false, &HandleNpcSetAllowMovementCommand, "" },
{ "entry", rbac::RBAC_PERM_COMMAND_NPC_SET_ENTRY, false, &HandleNpcSetEntryCommand, "" },
{ "factionid", rbac::RBAC_PERM_COMMAND_NPC_SET_FACTIONID, false, &HandleNpcSetFactionIdCommand, "" },
{ "flag", rbac::RBAC_PERM_COMMAND_NPC_SET_FLAG, false, &HandleNpcSetFlagCommand, "" },
{ "level", rbac::RBAC_PERM_COMMAND_NPC_SET_LEVEL, false, &HandleNpcSetLevelCommand, "" },
{ "link", rbac::RBAC_PERM_COMMAND_NPC_SET_LINK, false, &HandleNpcSetLinkCommand, "" },
{ "model", rbac::RBAC_PERM_COMMAND_NPC_SET_MODEL, false, &HandleNpcSetModelCommand, "" },
{ "movetype", rbac::RBAC_PERM_COMMAND_NPC_SET_MOVETYPE, false, &HandleNpcSetMoveTypeCommand, "" },
{ "phase", rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE, false, &HandleNpcSetPhaseCommand, "" },
{ "phasegroup", rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE, false, &HandleNpcSetPhaseGroup, "" },
{ "wanderdistance", rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNDIST, false, &HandleNpcSetWanderDistanceCommand, "" },
{ "spawntime", rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNTIME, false, &HandleNpcSetSpawnTimeCommand, "" },
{ "data", rbac::RBAC_PERM_COMMAND_NPC_SET_DATA, false, &HandleNpcSetDataCommand, "" },
};
static std::vector<ChatCommand> npcCommandTable =
{
{ "info", rbac::RBAC_PERM_COMMAND_NPC_INFO, false, &HandleNpcInfoCommand, "" },
{ "near", rbac::RBAC_PERM_COMMAND_NPC_NEAR, false, &HandleNpcNearCommand, "" },
{ "move", rbac::RBAC_PERM_COMMAND_NPC_MOVE, false, &HandleNpcMoveCommand, "" },
{ "playemote", rbac::RBAC_PERM_COMMAND_NPC_PLAYEMOTE, false, &HandleNpcPlayEmoteCommand, "" },
{ "say", rbac::RBAC_PERM_COMMAND_NPC_SAY, false, &HandleNpcSayCommand, "" },
{ "textemote", rbac::RBAC_PERM_COMMAND_NPC_TEXTEMOTE, false, &HandleNpcTextEmoteCommand, "" },
{ "whisper", rbac::RBAC_PERM_COMMAND_NPC_WHISPER, false, &HandleNpcWhisperCommand, "" },
{ "yell", rbac::RBAC_PERM_COMMAND_NPC_YELL, false, &HandleNpcYellCommand, "" },
{ "tame", rbac::RBAC_PERM_COMMAND_NPC_TAME, false, &HandleNpcTameCommand, "" },
{ "spawngroup", rbac::RBAC_PERM_COMMAND_NPC_SPAWNGROUP, false, &HandleNpcSpawnGroup, "" },
{ "despawngroup", rbac::RBAC_PERM_COMMAND_NPC_DESPAWNGROUP, false, &HandleNpcDespawnGroup, "" },
{ "add", rbac::RBAC_PERM_COMMAND_NPC_ADD, false, nullptr, "", npcAddCommandTable },
{ "delete", rbac::RBAC_PERM_COMMAND_NPC_DELETE, false, nullptr, "", npcDeleteCommandTable },
{ "follow", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW, false, nullptr, "", npcFollowCommandTable },
{ "set", rbac::RBAC_PERM_COMMAND_NPC_SET, false, nullptr, "", npcSetCommandTable },
{ "evade", rbac::RBAC_PERM_COMMAND_NPC_EVADE, false, &HandleNpcEvadeCommand, "" },
{ "showloot", rbac::RBAC_PERM_COMMAND_NPC_SHOWLOOT, false, &HandleNpcShowLootCommand, "" },
};
static std::vector<ChatCommand> commandTable =
{
{ "npc", rbac::RBAC_PERM_COMMAND_NPC, false, nullptr, "", npcCommandTable },
{ "npc", npcCommandTable },
};
return commandTable;
}

4
src/server/scripts/Commands/cs_pet.cpp
View File

@@ -26,6 +26,10 @@
#include "SpellMgr.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
inline Pet* GetSelectedPlayerPetOrOwn(ChatHandler* handler)
{
if (Unit* target = handler->getSelectedUnit())

4
src/server/scripts/Commands/cs_quest.cpp
View File

@@ -34,6 +34,10 @@ EndScriptData */
#include "ReputationMgr.h"
#include "World.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class quest_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_rbac.cpp
View File

@@ -33,6 +33,10 @@ EndScriptData */
#include "World.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
struct RBACCommandData
{
RBACCommandData(): id(0), realmId(0), rbac(nullptr), needDelete(false) { }

14
src/server/scripts/Commands/cs_reload.cpp
View File

@@ -51,6 +51,10 @@ EndScriptData */
#include "WaypointManager.h"
#include "World.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class reload_commandscript : public CommandScript
{
public:
@@ -408,9 +412,13 @@ public:
static bool HandleReloadCommandCommand(ChatHandler* handler, char const* /*args*/)
{
ChatHandler::invalidateCommandTable();
handler->SendGlobalGMSysMessage("DB table `command` will be reloaded at next chat command use.");
return true;
TC_LOG_INFO("misc", "Reloading .command information...");
Trinity::ChatCommands::LoadCommandMap();
handler->SendGlobalGMSysMessage("DB table `command` reloaded.");
// do not log this invocation, otherwise we might crash (the command table we used to get here is no longer valid!)
handler->SetSentErrorMessage(true);
return false;
}
static bool HandleReloadOnKillReputationCommand(ChatHandler* handler, char const* /*args*/)

4
src/server/scripts/Commands/cs_reset.cpp
View File

@@ -37,6 +37,10 @@ EndScriptData */
#include "World.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class reset_commandscript : public CommandScript
{
public:

59
src/server/scripts/Commands/cs_scene.cpp
View File

@@ -25,28 +25,30 @@
#include "RBAC.h"
#include "WorldSession.h"
using namespace Trinity::ChatCommands;
class scene_commandscript : public CommandScript
{
public:
scene_commandscript() : CommandScript("scene_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> sceneCommandTable =
static ChatCommandTable sceneCommandTable =
{
{ "debug", rbac::RBAC_PERM_COMMAND_SCENE_DEBUG, false, &HandleDebugSceneCommand, "" },
{ "play", rbac::RBAC_PERM_COMMAND_SCENE_PLAY, false, &HandlePlaySceneCommand, "" },
{ "playpackage", rbac::RBAC_PERM_COMMAND_SCENE_PLAY_PACKAGE, false, &HandlePlayScenePackageCommand, "" },
{ "cancel", rbac::RBAC_PERM_COMMAND_SCENE_CANCEL, false, &HandleCancelSceneCommand, "" }
{ "debug", HandleDebugSceneCommand, rbac::RBAC_PERM_COMMAND_SCENE_DEBUG, Console::No },
{ "play", HandlePlaySceneCommand, rbac::RBAC_PERM_COMMAND_SCENE_PLAY, Console::No },
{ "playpackage", HandlePlayScenePackageCommand, rbac::RBAC_PERM_COMMAND_SCENE_PLAY_PACKAGE, Console::No },
{ "cancel", HandleCancelSceneCommand, rbac::RBAC_PERM_COMMAND_SCENE_CANCEL, Console::No }
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "scene", rbac::RBAC_PERM_COMMAND_SCENE, true, nullptr, "", sceneCommandTable }
{ "scene", sceneCommandTable }
};
return commandTable;
}
static bool HandleDebugSceneCommand(ChatHandler* handler, char const* /*args*/)
static bool HandleDebugSceneCommand(ChatHandler* handler)
{
if (Player* player = handler->GetSession()->GetPlayer())
{
@@ -57,17 +59,8 @@ public:
return true;
}
static bool HandlePlaySceneCommand(ChatHandler* handler, char const* args)
static bool HandlePlaySceneCommand(ChatHandler* handler, uint32 sceneId)
{
if (!*args)
return false;
char const* sceneIdStr = strtok((char*)args, " ");
if (!sceneIdStr)
return false;
uint32 sceneId = atoi(sceneIdStr);
Player* target = handler->getSelectedPlayerOrSelf();
if (!target)
@@ -84,19 +77,8 @@ public:
return true;
}
static bool HandlePlayScenePackageCommand(ChatHandler* handler, char const* args)
static bool HandlePlayScenePackageCommand(ChatHandler* handler, uint32 sceneScriptPackageId, Optional<uint32> flags)
{
if (!*args)
return false;
char const* scenePackageIdStr = strtok((char*)args, " ");
char const* flagsStr = strtok(nullptr, "");
if (!scenePackageIdStr)
return false;
uint32 scenePackageId = atoi(scenePackageIdStr);
EnumFlag<SceneFlag> flags = flagsStr ? static_cast<SceneFlag>(atoi(flagsStr)) : SceneFlag::None;
Player* target = handler->getSelectedPlayerOrSelf();
if (!target)
@@ -106,18 +88,15 @@ public:
return false;
}
if (!sSceneScriptPackageStore.HasRecord(scenePackageId))
if (!sSceneScriptPackageStore.HasRecord(sceneScriptPackageId))
return false;
target->GetSceneMgr().PlaySceneByPackageId(scenePackageId, flags);
target->GetSceneMgr().PlaySceneByPackageId(sceneScriptPackageId, static_cast<SceneFlag>(flags.value_or(0)));
return true;
}
static bool HandleCancelSceneCommand(ChatHandler* handler, char const* args)
static bool HandleCancelSceneCommand(ChatHandler* handler, uint32 sceneScriptPackageId)
{
if (!*args)
return false;
Player* target = handler->getSelectedPlayerOrSelf();
if (!target)
@@ -127,12 +106,10 @@ public:
return false;
}
uint32 id = atoi((char*)args);
if (!sSceneScriptPackageStore.HasRecord(id))
if (!sSceneScriptPackageStore.HasRecord(sceneScriptPackageId))
return false;
target->GetSceneMgr().CancelSceneByPackageId(id);
target->GetSceneMgr().CancelSceneByPackageId(sceneScriptPackageId);
return true;
}
};

4
src/server/scripts/Commands/cs_send.cpp
View File

@@ -27,6 +27,10 @@
#include "RBAC.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class send_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_server.cpp
View File

@@ -46,6 +46,10 @@ EndScriptData */
#include <openssl/opensslv.h>
#include <numeric>
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class server_commandscript : public CommandScript
{
public:

18
src/server/scripts/Commands/cs_tele.cpp
View File

@@ -43,19 +43,19 @@ class tele_commandscript : public CommandScript
public:
tele_commandscript() : CommandScript("tele_commandscript") { }
std::vector<ChatCommand> GetCommands() const override
ChatCommandTable GetCommands() const override
{
static std::vector<ChatCommand> teleCommandTable =
static ChatCommandTable teleCommandTable =
{
{ "add", rbac::RBAC_PERM_COMMAND_TELE_ADD, false, &HandleTeleAddCommand, "" },
{ "del", rbac::RBAC_PERM_COMMAND_TELE_DEL, true, &HandleTeleDelCommand, "" },
{ "name", rbac::RBAC_PERM_COMMAND_TELE_NAME, true, &HandleTeleNameCommand, "" },
{ "group", rbac::RBAC_PERM_COMMAND_TELE_GROUP, false, &HandleTeleGroupCommand, "" },
{ "", rbac::RBAC_PERM_COMMAND_TELE, false, &HandleTeleCommand, "" },
{ "add", HandleTeleAddCommand, rbac::RBAC_PERM_COMMAND_TELE_ADD, Console::No },
{ "del", HandleTeleDelCommand, rbac::RBAC_PERM_COMMAND_TELE_DEL, Console::Yes },
{ "name", HandleTeleNameCommand, rbac::RBAC_PERM_COMMAND_TELE_NAME, Console::Yes },
{ "group", HandleTeleGroupCommand, rbac::RBAC_PERM_COMMAND_TELE_GROUP, Console::No },
{ "", HandleTeleCommand, rbac::RBAC_PERM_COMMAND_TELE, Console::No },
};
static std::vector<ChatCommand> commandTable =
static ChatCommandTable commandTable =
{
{ "tele", rbac::RBAC_PERM_COMMAND_TELE, false, nullptr, "", teleCommandTable },
{ "tele", teleCommandTable },
};
return commandTable;
}

4
src/server/scripts/Commands/cs_ticket.cpp
View File

@@ -35,6 +35,10 @@ EndScriptData */
#include "World.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class ticket_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_titles.cpp
View File

@@ -30,6 +30,10 @@ EndScriptData */
#include "Player.h"
#include "RBAC.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class titles_commandscript : public CommandScript
{
public:

4
src/server/scripts/Commands/cs_wp.cpp
View File

@@ -37,6 +37,10 @@ EndScriptData */
#include "WaypointManager.h"
#include "WorldSession.h"
#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
class wp_commandscript : public CommandScript
{
public:

70
src/server/worldserver/CommandLine/CliRunnable.cpp
View File

@@ -39,54 +39,34 @@ static inline void PrintCliPrefix()
}
#if TRINITY_PLATFORM != TRINITY_PLATFORM_WINDOWS
char* command_finder(char const* text, int state)
namespace Trinity::Impl::Readline
{
static size_t idx, len;
char const* ret;
std::vector<ChatCommand> const& cmd = ChatHandler::getCommandTable();
if (!state)
static std::vector<std::string> vec;
char* cli_unpack_vector(char const*, int state)
{
idx = 0;
len = strlen(text);
static size_t i=0;
if (!state)
i = 0;
if (i < vec.size())
return strdup(vec[i++].c_str());
else
return nullptr;
}
while (idx < cmd.size())
char** cli_completion(char const* text, int /*start*/, int /*end*/)
{
ret = cmd[idx].Name;
if (!cmd[idx].AllowConsole)
{
++idx;
continue;
}
++idx;
//printf("Checking %s \n", cmd[idx].Name);
if (strncmp(ret, text, len) == 0)
return strdup(ret);
::rl_attempted_completion_over = 1;
vec = Trinity::ChatCommands::GetAutoCompletionsFor(CliHandler(nullptr,nullptr), text);
return ::rl_completion_matches(text, &cli_unpack_vector);
}
return nullptr;
int cli_hook_func()
{
if (World::IsStopped())
::rl_done = 1;
return 0;
}
}
char** cli_completion(char const* text, int start, int /*end*/)
{
char** matches = nullptr;
if (start)
rl_bind_key('\t', rl_abort);
else
matches = rl_completion_matches((char*)text, &command_finder);
return matches;
}
int cli_hook_func()
{
if (World::IsStopped())
rl_done = 1;
return 0;
}
#endif
void utf8print(void* /*arg*/, std::string_view str)
@@ -134,8 +114,12 @@ void CliThread()
// later it will be printed after command queue updates
PrintCliPrefix();
#else
rl_attempted_completion_function = cli_completion;
rl_event_hook = cli_hook_func;
::rl_attempted_completion_function = &Trinity::Impl::Readline::cli_completion;
{
static char BLANK = '\0';
::rl_completer_word_break_characters = &BLANK;
}
::rl_event_hook = &Trinity::Impl::Readline::cli_hook_func;
#endif
if (sConfigMgr->GetBoolDefault("BeepAtStart", true))
@@ -160,7 +144,7 @@ void CliThread()
}
#else
char* command_str = readline(CLI_PREFIX);
rl_bind_key('\t', rl_complete);
::rl_bind_key('\t', ::rl_complete);
if (command_str != nullptr)
{
command = command_str;

26
tests/game/ChatCommand.cpp
View File

@@ -31,10 +31,10 @@ struct DummyChatHandler : ChatHandler
};
template <typename F>
static void TestChatCommand(char const* c, F f, Optional<bool> expected = true)
static void TestChatCommand(std::string_view c, F f, Optional<bool> expected = true)
{
DummyChatHandler handler;
bool r = ChatCommand("", 0, false, +f, "")(&handler, c);
bool r = Trinity::Impl::ChatCommands::CommandInvoker(*+f)(&handler, c);
if (expected)
REQUIRE(r == *expected);
}
@@ -111,4 +111,26 @@ TEST_CASE("Command argument parsing", "[ChatCommand]")
return true;
});
}
SECTION("Variant<>")
{
TestChatCommand("0x1ffff", [](ChatHandler*, Variant<uint16, uint32> v)
{
REQUIRE(v.holds_alternative<uint32>());
REQUIRE(v.get<uint32>() == 0x1ffff);
return true;
});
TestChatCommand("0xffff", [](ChatHandler*, Variant<uint16, uint32> v)
{
REQUIRE(v.holds_alternative<uint16>());
REQUIRE(v.get<uint16>() == 0xffff);
return true;
});
TestChatCommand("0x1ffff", [](ChatHandler*, Variant<uint32, uint16> v)
{
REQUIRE(v.holds_alternative<uint32>());
REQUIRE(v.get<uint32>() == 0x1ffff);
return true;
});
}
}