Core/Misc: Replace string to int conversion functions from Common.h with c++17 std::from_chars based ones Trinity::StringTo

(cherry picked from commit 3260b94dd627b7b0c7114f94bb97d108b005af3e)

22 files changed, 304 insertions, 642 deletions

diff --git a/src/common/Common.h b/src/common/Common.h
index 141b163a63e..0b33af12cec 100644
--- a/src/common/Common.h
+++ b/src/common/Common.h
@@ -21,22 +21,6 @@
 #include "Define.h"
 #include <array>
 #include <string>
-#include <cstdlib>
-
-#if TRINITY_COMPILER == TRINITY_COMPILER_MICROSOFT
-
-#define atoll _atoi64
-#define llabs _abs64
-
-#else
-
-#define stricmp strcasecmp
-#define strnicmp strncasecmp
-
-#endif
-
-inline unsigned long atoul(char const* str) { return strtoul(str, nullptr, 10); }
-inline unsigned long long atoull(char const* str) { return strtoull(str, nullptr, 10); }
 
 #define STRINGIZE(a) #a
 
@@ -84,15 +68,6 @@ TC_COMMON_API extern char const* localeNames[TOTAL_LOCALES];
 
 TC_COMMON_API LocaleConstant GetLocaleByName(std::string const& name);
 
-// we always use stdlib std::max/std::min, undefine some not C++ standard defines (Win API and some other platforms)
-#ifdef max
-#undef max
-#endif
-
-#ifdef min
-#undef min
-#endif
-
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
diff --git a/src/common/IPLocation/IPLocation.cpp b/src/common/IPLocation/IPLocation.cpp
index a1717420eb4..2dfd025fc7e 100644
--- a/src/common/IPLocation/IPLocation.cpp
+++ b/src/common/IPLocation/IPLocation.cpp
@@ -16,11 +16,12 @@
  */
 
 #include "IPLocation.h"
-#include "Common.h"
 #include "Config.h"
 #include "Errors.h"
 #include "IpAddress.h"
 #include "Log.h"
+#include "StringConvert.h"
+#include "Util.h"
 #include <fstream>
 #include <iostream>
 
@@ -83,9 +84,17 @@ void IpLocationStore::Load()
         countryName.erase(std::remove(countryName.begin(), countryName.end(), '"'), countryName.end());
 
         // Convert country code to lowercase
-        std::transform(countryCode.begin(), countryCode.end(), countryCode.begin(), ::tolower);
+        strToLower(countryCode);
 
-        _ipLocationStore.emplace_back(uint32(atoul(ipFrom.c_str())), uint32(atoul(ipTo.c_str())), std::move(countryCode), std::move(countryName));
+        Optional<uint32> from = Trinity::StringTo<uint32>(ipFrom);
+        if (!from)
+            continue;
+
+        Optional<uint32> to = Trinity::StringTo<uint32>(ipTo);
+        if (!to)
+            continue;
+
+        _ipLocationStore.emplace_back(*from, *to, std::move(countryCode), std::move(countryName));
     }
 
     std::sort(_ipLocationStore.begin(), _ipLocationStore.end(), [](IpLocationRecord const& a, IpLocationRecord const& b) { return a.IpFrom < b.IpFrom; });
diff --git a/src/common/Utilities/StringFormat.h b/src/common/Utilities/StringFormat.h
index c95039efea4..9bef5516139 100644
--- a/src/common/Utilities/StringFormat.h
+++ b/src/common/Utilities/StringFormat.h
@@ -39,6 +39,19 @@ namespace Trinity
         }
     }
 
+    template<typename OutputIt, typename... Args>
+    inline OutputIt StringFormatTo(OutputIt out, FormatString<Args...> fmt, Args&&... args)
+    {
+        try
+        {
+            return fmt::format_to(out, fmt, std::forward<Args>(args)...);
+        }
+        catch (std::exception const& formatError)
+        {
+            return fmt::format_to(out, "An error occurred formatting string \"{}\" : {}", fmt, formatError.what());
+        }
+    }
+
     /// Returns true if the given char pointer is null.
     inline bool IsFormatEmptyOrNull(char const* fmt)
     {
diff --git a/src/common/Utilities/Util.cpp b/src/common/Utilities/Util.cpp
index 6763685ba70..9c77e9f9821 100644
--- a/src/common/Utilities/Util.cpp
+++ b/src/common/Utilities/Util.cpp
@@ -658,15 +658,13 @@ std::string Trinity::Impl::ByteArrayToHexStr(uint8 const* bytes, size_t arrayLen
         op = -1;
     }
 
-    std::ostringstream ss;
+    std::string result;
+    result.reserve(arrayLen * 2);
+    auto inserter = std::back_inserter(result);
     for (int32 i = init; i != end; i += op)
-    {
-        char buffer[4];
-        sprintf(buffer, "%02X", bytes[i]);
-        ss << buffer;
-    }
+        Trinity::StringFormatTo(inserter, "{:02X}", bytes[i]);
 
-    return ss.str();
+    return result;
 }
 
 void Trinity::Impl::HexStrToByteArray(std::string_view str, uint8* out, size_t outlen, bool reverse /*= false*/)
@@ -686,10 +684,7 @@ void Trinity::Impl::HexStrToByteArray(std::string_view str, uint8* out, size_t o
 
     uint32 j = 0;
     for (int32 i = init; i != end; i += 2 * op)
-    {
-        char buffer[3] = { str[i], str[i + 1], '\0' };
-        out[j++] = uint8(strtoul(buffer, nullptr, 16));
-    }
+        out[j++] = Trinity::StringTo<uint8>(str.substr(i, 2), 16).value_or(0);
 }
 
 bool StringEqualI(std::string_view a, std::string_view b)
diff --git a/src/server/database/Database/Field.cpp b/src/server/database/Database/Field.cpp
index 3713d2855d4..cdcb32c6508 100644
--- a/src/server/database/Database/Field.cpp
+++ b/src/server/database/Database/Field.cpp
@@ -18,7 +18,8 @@
 #include "Field.h"
 #include "Errors.h"
 #include "Log.h"
-#include "MySQLHacks.h"
+#include "StringConvert.h"
+#include <cstring>
 
 Field::Field()
 {
@@ -45,7 +46,7 @@ uint8 Field::GetUInt8() const
 
     if (data.raw)
         return *reinterpret_cast<uint8 const*>(data.value);
-    return static_cast<uint8>(strtoul(data.value, nullptr, 10));
+    return Trinity::StringTo<uint8>(data.value, 10).value_or(0);
 }
 
 int8 Field::GetInt8() const
@@ -63,7 +64,7 @@ int8 Field::GetInt8() const
 
     if (data.raw)
         return *reinterpret_cast<int8 const*>(data.value);
-    return static_cast<int8>(strtol(data.value, nullptr, 10));
+    return Trinity::StringTo<int8>(data.value, 10).value_or(0);
 }
 
 uint16 Field::GetUInt16() const
@@ -81,7 +82,7 @@ uint16 Field::GetUInt16() const
 
     if (data.raw)
         return *reinterpret_cast<uint16 const*>(data.value);
-    return static_cast<uint16>(strtoul(data.value, nullptr, 10));
+    return Trinity::StringTo<uint16>(data.value, 10).value_or(0);
 }
 
 int16 Field::GetInt16() const
@@ -99,7 +100,7 @@ int16 Field::GetInt16() const
 
     if (data.raw)
         return *reinterpret_cast<int16 const*>(data.value);
-    return static_cast<int16>(strtol(data.value, nullptr, 10));
+    return Trinity::StringTo<int16>(data.value, 10).value_or(0);
 }
 
 uint32 Field::GetUInt32() const
@@ -117,7 +118,7 @@ uint32 Field::GetUInt32() const
 
     if (data.raw)
         return *reinterpret_cast<uint32 const*>(data.value);
-    return static_cast<uint32>(strtoul(data.value, nullptr, 10));
+    return Trinity::StringTo<uint32>(data.value, 10).value_or(0);
 }
 
 int32 Field::GetInt32() const
@@ -135,7 +136,7 @@ int32 Field::GetInt32() const
 
     if (data.raw)
         return *reinterpret_cast<int32 const*>(data.value);
-    return static_cast<int32>(strtol(data.value, nullptr, 10));
+    return Trinity::StringTo<int32>(data.value, 10).value_or(0);
 }
 
 uint64 Field::GetUInt64() const
@@ -153,7 +154,7 @@ uint64 Field::GetUInt64() const
 
     if (data.raw)
         return *reinterpret_cast<uint64 const*>(data.value);
-    return static_cast<uint64>(strtoull(data.value, nullptr, 10));
+    return Trinity::StringTo<uint64>(data.value, 10).value_or(0);
 }
 
 int64 Field::GetInt64() const
@@ -171,7 +172,7 @@ int64 Field::GetInt64() const
 
     if (data.raw)
         return *reinterpret_cast<int64 const*>(data.value);
-    return static_cast<int64>(strtoll(data.value, nullptr, 10));
+    return Trinity::StringTo<int64>(data.value, 10).value_or(0);
 }
 
 float Field::GetFloat() const
@@ -189,25 +190,25 @@ float Field::GetFloat() const
 
     if (data.raw)
         return *reinterpret_cast<float const*>(data.value);
-    return static_cast<float>(atof(data.value));
+    return Trinity::StringTo<float>(data.value, 10).value_or(0);
 }
 
 double Field::GetDouble() const
 {
     if (!data.value)
-        return 0.0f;
+        return 0.0;
 
 #ifdef TRINITY_STRICT_DATABASE_TYPE_CHECKS
     if (!IsType(DatabaseFieldTypes::Double) && !IsType(DatabaseFieldTypes::Decimal))
     {
         LogWrongType(__FUNCTION__);
-        return 0.0f;
+        return 0.0;
     }
 #endif
 
     if (data.raw && !IsType(DatabaseFieldTypes::Decimal))
         return *reinterpret_cast<double const*>(data.value);
-    return static_cast<double>(atof(data.value));
+    return Trinity::StringTo<double>(data.value, 10).value_or(0);
 }
 
 char const* Field::GetCString() const
diff --git a/src/server/game/Chat/Chat.cpp b/src/server/game/Chat/Chat.cpp
index 5b462589164..427619d0533 100644
--- a/src/server/game/Chat/Chat.cpp
+++ b/src/server/game/Chat/Chat.cpp
@@ -19,17 +19,14 @@
 #include "AccountMgr.h"
 #include "CellImpl.h"
 #include "CharacterCache.h"
-#include "DatabaseEnv.h"
-#include "DBCStores.h"
 #include "GridNotifiersImpl.h"
 #include "Language.h"
-#include "Log.h"
 #include "ObjectAccessor.h"
 #include "ObjectMgr.h"
 #include "Optional.h"
 #include "Player.h"
 #include "Realm.h"
-#include "ScriptMgr.h"
+#include "StringConvert.h"
 #include "World.h"
 #include "WorldSession.h"
 #include <boost/algorithm/string/replace.hpp>
@@ -510,76 +507,6 @@ Creature* ChatHandler::GetCreatureFromPlayerMapByDbGuid(ObjectGuid::LowType lowg
     return creature;
 }
 
-enum SpellLinkType
-{
-    SPELL_LINK_SPELL   = 0,
-    SPELL_LINK_TALENT  = 1,
-    SPELL_LINK_ENCHANT = 2,
-    SPELL_LINK_TRADE   = 3,
-    SPELL_LINK_GLYPH   = 4
-};
-
-static char const* const spellKeys[] =
-{
-    "Hspell",                                               // normal spell
-    "Htalent",                                              // talent spell
-    "Henchant",                                             // enchanting recipe spell
-    "Htrade",                                               // profession/skill spell
-    "Hglyph",                                               // glyph
-    nullptr
-};
-
-uint32 ChatHandler::extractSpellIdFromLink(char* text)
-{
-    // number or [name] Shift-click form |color|Henchant:recipe_spell_id|h[prof_name: recipe_name]|h|r
-    // number or [name] Shift-click form |color|Hglyph:glyph_slot_id:glyph_prop_id|h[%s]|h|r
-    // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
-    // number or [name] Shift-click form |color|Htalent:talent_id, rank|h[name]|h|r
-    // number or [name] Shift-click form |color|Htrade:spell_id, skill_id, max_value, cur_value|h[name]|h|r
-    int type = 0;
-    char* param1_str = nullptr;
-    char* idS = extractKeyFromLink(text, spellKeys, &type, &param1_str);
-    if (!idS)
-        return 0;
-
-    uint32 id = atoul(idS);
-
-    switch (type)
-    {
-        case SPELL_LINK_SPELL:
-            return id;
-        case SPELL_LINK_TALENT:
-        {
-            // talent
-            TalentEntry const* talentEntry = sTalentStore.LookupEntry(id);
-            if (!talentEntry)
-                return 0;
-
-            uint32 rank = param1_str ? atol(param1_str) : 0u;
-            if (rank >= MAX_TALENT_RANK)
-                return 0;
-
-            return talentEntry->SpellRank[rank];
-        }
-        case SPELL_LINK_ENCHANT:
-        case SPELL_LINK_TRADE:
-            return id;
-        case SPELL_LINK_GLYPH:
-        {
-            uint32 glyph_prop_id = param1_str ? atoul(param1_str) : 0;
-
-            GlyphPropertiesEntry const* glyphPropEntry = sGlyphPropertiesStore.LookupEntry(glyph_prop_id);
-            if (!glyphPropEntry)
-                return 0;
-
-            return glyphPropEntry->SpellID;
-        }
-    }
-
-    // unknown type?
-    return 0;
-}
-
 enum GuidLinkType
 {
     GUID_LINK_PLAYER     = 0,                              // must be first for selection in not link case
@@ -625,13 +552,13 @@ ObjectGuid::LowType ChatHandler::extractLowGuidFromLink(char* text, HighGuid& gu
         case GUID_LINK_CREATURE:
         {
             guidHigh = HighGuid::Unit;
-            ObjectGuid::LowType lowguid = atoul(idS);
+            ObjectGuid::LowType lowguid = Trinity::StringTo<ObjectGuid::LowType>(idS).value_or(0);
             return lowguid;
         }
         case GUID_LINK_GAMEOBJECT:
         {
             guidHigh = HighGuid::GameObject;
-            ObjectGuid::LowType lowguid = atoul(idS);
+            ObjectGuid::LowType lowguid = Trinity::StringTo<ObjectGuid::LowType>(idS).value_or(0);
             return lowguid;
         }
     }
diff --git a/src/server/game/Chat/Chat.h b/src/server/game/Chat/Chat.h
index b527ab12eea..10412099edf 100644
--- a/src/server/game/Chat/Chat.h
+++ b/src/server/game/Chat/Chat.h
@@ -110,7 +110,6 @@ class TC_GAME_API ChatHandler
         char* extractKeyFromLink(char* text, char const* linkType, char** something1 = nullptr);
         char* extractKeyFromLink(char* text, char const* const* linkTypes, int* found_idx, char** something1 = nullptr);
         char* extractQuotedArg(char* args);
-        uint32 extractSpellIdFromLink(char* text);
         ObjectGuid::LowType extractLowGuidFromLink(char* text, HighGuid& guidHigh);
         bool GetPlayerGroupAndGUIDByName(char const* cname, Player*& player, Group*& group, ObjectGuid& guid, bool offline = false);
         std::string extractPlayerNameFromLink(char* text);
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp b/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp
index 9a5f45b6c07..a19f9571d0e 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp
+++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.cpp
@@ -77,6 +77,23 @@ ChatCommandResult Trinity::Impl::ChatCommands::ArgInfo<ItemTemplate const*>::Try
     return std::nullopt;
 }
 
+struct QuestVisitor
+{
+    using value_type = Quest const*;
+    value_type operator()(Hyperlink<quest> quest) const { return quest->Quest; }
+    value_type operator()(uint32 questId) const { return sObjectMgr->GetQuestTemplate(questId); }
+};
+ChatCommandResult Trinity::Impl::ChatCommands::ArgInfo<Quest const*, void>::TryConsume(Quest const*& data, ChatHandler const* handler, std::string_view args)
+{
+    Variant<Hyperlink<quest>, uint32> val;
+    ChatCommandResult result = ArgInfo<decltype(val)>::TryConsume(val, handler, args);
+    if (!result || (data = val.visit(QuestVisitor())))
+        return result;
+    if (uint32* id = std::get_if<uint32>(&val))
+        return FormatTrinityString(handler, LANG_CMDPARSER_QUEST_NO_EXIST, *id);
+    return std::nullopt;
+}
+
 struct SpellInfoVisitor
 {
     using value_type = SpellInfo const*;
diff --git a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
index 770f67b3485..79a74e35582 100644
--- a/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
+++ b/src/server/game/Chat/ChatCommands/ChatCommandArgs.h
@@ -312,6 +312,13 @@ namespace Trinity::Impl::ChatCommands
         static ChatCommandResult TryConsume(ItemTemplate const*&, ChatHandler const*, std::string_view);
     };
 
+    // Quest* from numeric id or link
+    template <>
+    struct TC_GAME_API ArgInfo<Quest const*>
+    {
+        static ChatCommandResult TryConsume(Quest const*&, ChatHandler const*, std::string_view);
+    };
+
     // SpellInfo const* from spell id or link
     template <>
     struct TC_GAME_API ArgInfo<SpellInfo const*>
diff --git a/src/server/game/Scripting/ScriptReloadMgr.cpp b/src/server/game/Scripting/ScriptReloadMgr.cpp
index d3e051f6cd1..47c44358da1 100644
--- a/src/server/game/Scripting/ScriptReloadMgr.cpp
+++ b/src/server/game/Scripting/ScriptReloadMgr.cpp
@@ -389,8 +389,7 @@ static std::shared_ptr<Trinity::AsyncProcessResult> InvokeAsyncCMakeCommand(T&&.
 static std::string CalculateScriptModuleProjectName(std::string const& module)
 {
     std::string module_project = "scripts_" + module;
-    std::transform(module_project.begin(), module_project.end(),
-                   module_project.begin(), ::tolower);
+    strToLower(module_project);
 
     return module_project;
 }
diff --git a/src/server/game/Server/WorldSocket.cpp b/src/server/game/Server/WorldSocket.cpp
index 43ccd9e261d..4603e619be5 100644
--- a/src/server/game/Server/WorldSocket.cpp
+++ b/src/server/game/Server/WorldSocket.cpp
@@ -557,7 +557,7 @@ void WorldSocket::HandleAuthSessionCallback(std::shared_ptr<AuthSession> authSes
     //! Negative mutetime indicates amount of seconds to be muted effective on next login - which is now.
     if (mutetime < 0)
     {
-        mutetime = GameTime::GetGameTime() + llabs(mutetime);
+        mutetime = GameTime::GetGameTime() + std::llabs(mutetime);
 
         stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME_LOGIN);
         stmt->setInt64(0, mutetime);
diff --git a/src/server/game/Tools/PlayerDump.cpp b/src/server/game/Tools/PlayerDump.cpp
index ffe70f76863..d9e78dadf4c 100644
--- a/src/server/game/Tools/PlayerDump.cpp
+++ b/src/server/game/Tools/PlayerDump.cpp
@@ -23,6 +23,7 @@
 #include "Log.h"
 #include "ObjectMgr.h"
 #include "Player.h"
+#include "StringConvert.h"
 #include "World.h"
 #include <fstream>
 #include <sstream>
@@ -503,7 +504,7 @@ inline T RegisterNewGuid(T oldGuid, MapType<T, T, Rest...>& guidMap, T guidOffse
 template <typename T, template<class, class, class...> class MapType, class... Rest>
 inline bool ChangeGuid(TableStruct const& ts, std::string& str, std::string const& column, MapType<T, T, Rest...>& guidMap, T guidOffset, bool allowZero = false)
 {
-    T oldGuid(atoull(GetColumn(ts, str, column).c_str()));
+    T oldGuid = Trinity::StringTo<T>(GetColumn(ts, str, column)).template value_or<T>(0);
     if (allowZero && !oldGuid)
         return true;                                        // not an error
 
@@ -915,10 +916,10 @@ DumpReturn PlayerDumpReader::LoadDump(std::istream& input, uint32 account, std::
         {
             case DTT_CHARACTER:
             {
-                race = uint8(atoul(GetColumn(ts, line, "race").c_str()));
-                playerClass = uint8(atoul(GetColumn(ts, line, "class").c_str()));
-                gender = uint8(atoul(GetColumn(ts, line, "gender").c_str()));
-                level = uint8(atoul(GetColumn(ts, line, "level").c_str()));
+                race = Trinity::StringTo<uint8>(GetColumn(ts, line, "race")).value_or<uint8>(0);
+                playerClass = Trinity::StringTo<uint8>(GetColumn(ts, line, "class")).value_or<uint8>(0);
+                gender = Trinity::StringTo<uint8>(GetColumn(ts, line, "gender")).value_or<uint8>(0);
+                level = Trinity::StringTo<uint8>(GetColumn(ts, line, "level")).value_or<uint8>(0);
                 if (name.empty())
                 {
                     // generate a temporary name
diff --git a/src/server/scripts/Commands/cs_character.cpp b/src/server/scripts/Commands/cs_character.cpp
index 4ebe7e0f9b6..108df9fa4f0 100644
--- a/src/server/scripts/Commands/cs_character.cpp
+++ b/src/server/scripts/Commands/cs_character.cpp
@@ -109,10 +109,10 @@ public:
         if (!searchString.empty())
         {
             // search by GUID
-            if (isNumeric(searchString.c_str()))
+            if (Optional<uint32> guidValue = Trinity::StringTo<uint64>(searchString))
             {
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_DEL_INFO_BY_GUID);
-                stmt->setUInt32(0, uint32(atoi(searchString.c_str())));
+                stmt->setUInt32(0, *guidValue);
                 result = CharacterDatabase.Query(stmt);
             }
             // search by name
diff --git a/src/server/scripts/Commands/cs_disable.cpp b/src/server/scripts/Commands/cs_disable.cpp
index 132f7af3cc9..25a2b4463c8 100644
--- a/src/server/scripts/Commands/cs_disable.cpp
+++ b/src/server/scripts/Commands/cs_disable.cpp
@@ -34,10 +34,6 @@ 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
@@ -81,23 +77,9 @@ public:
         return commandTable;
     }
 
-    static bool HandleAddDisables(ChatHandler* handler, char const* args, uint8 disableType)
+    static bool HandleAddDisables(ChatHandler* handler, DisableType disableType, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        char* entryStr = strtok((char*)args, " ");
-        if (!entryStr || !atoi(entryStr))
-            return false;
-
-        char* flagsStr = strtok(nullptr, " ");
-        uint8 flags = flagsStr ? uint8(atoi(flagsStr)) : 0;
-
-        char* commentStr = strtok(nullptr, "");
-        if (!commentStr)
-            return false;
-
-        std::string disableComment = commentStr;
-        uint32 entry = uint32(atoi(entryStr));
-
-        std::string disableTypeStr = "";
+        char const* disableTypeStr = "";
 
         switch (disableType)
         {
@@ -189,6 +171,17 @@ public:
                 disableTypeStr = "mmap";
                 break;
             }
+            case DISABLE_TYPE_LFG_MAP:
+            {
+                if (!sMapStore.LookupEntry(entry))
+                {
+                    handler->PSendSysMessage(LANG_COMMAND_NOMAPFOUND);
+                    handler->SetSentErrorMessage(true);
+                    return false;
+                }
+                disableTypeStr = "lfg map";
+                break;
+            }
             default:
                 break;
         }
@@ -199,7 +192,7 @@ public:
         PreparedQueryResult result = WorldDatabase.Query(stmt);
         if (result)
         {
-            handler->PSendSysMessage("This %s (Id: %u) is already disabled.", disableTypeStr.c_str(), entry);
+            handler->PSendSysMessage("This %s (Id: %u) is already disabled.", disableTypeStr, entry);
             handler->SetSentErrorMessage(true);
             return false;
         }
@@ -207,87 +200,56 @@ public:
         stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_DISABLES);
         stmt->setUInt32(0, entry);
         stmt->setUInt8(1, disableType);
-        stmt->setUInt16(2, flags);
-        stmt->setString(3, disableComment);
+        stmt->setUInt16(2, flags.value_or<uint16>(0));
+        stmt->setStringView(3, disableComment);
         WorldDatabase.Execute(stmt);
 
-        handler->PSendSysMessage("Add Disabled %s (Id: %u) for reason %s", disableTypeStr.c_str(), entry, disableComment.c_str());
+        handler->PSendSysMessage("Add Disabled %s (Id: %u) for reason " STRING_VIEW_FMT, disableTypeStr, entry, STRING_VIEW_FMT_ARG(disableComment));
         return true;
     }
 
-    static bool HandleAddDisableSpellCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableSpellCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_SPELL);
+        return HandleAddDisables(handler, DISABLE_TYPE_SPELL, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableQuestCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableQuestCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_QUEST);
+        return HandleAddDisables(handler, DISABLE_TYPE_QUEST, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableMapCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableMapCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_MAP);
+        return HandleAddDisables(handler, DISABLE_TYPE_MAP, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableBattlegroundCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableBattlegroundCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_BATTLEGROUND);
+        return HandleAddDisables(handler, DISABLE_TYPE_BATTLEGROUND, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableAchievementCriteriaCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableAchievementCriteriaCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_ACHIEVEMENT_CRITERIA);
+        return HandleAddDisables(handler, DISABLE_TYPE_ACHIEVEMENT_CRITERIA, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableOutdoorPvPCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableOutdoorPvPCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        HandleAddDisables(handler, args, DISABLE_TYPE_OUTDOORPVP);
-        return true;
+        return HandleAddDisables(handler, DISABLE_TYPE_OUTDOORPVP, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableVmapCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableVmapCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_VMAP);
+        return HandleAddDisables(handler, DISABLE_TYPE_VMAP, entry, flags, disableComment);
     }
 
-    static bool HandleAddDisableMMapCommand(ChatHandler* handler, char const* args)
+    static bool HandleAddDisableMMapCommand(ChatHandler* handler, uint32 entry, Optional<uint16> flags, Tail disableComment)
     {
-        if (!*args)
-            return false;
-
-        return HandleAddDisables(handler, args, DISABLE_TYPE_MMAP);
+        return HandleAddDisables(handler, DISABLE_TYPE_MMAP, entry, flags, disableComment);
     }
 
-    static bool HandleRemoveDisables(ChatHandler* handler, char const* args, uint8 disableType)
+    static bool HandleRemoveDisables(ChatHandler* handler, DisableType disableType, uint32 entry)
     {
-        char* entryStr = strtok((char*)args, " ");
-        if (!entryStr || !atoi(entryStr))
-            return false;
-
-        uint32 entry = uint32(atoi(entryStr));
-
         std::string disableTypeStr = "";
 
         switch (disableType)
@@ -316,6 +278,11 @@ public:
             case DISABLE_TYPE_MMAP:
                 disableTypeStr = "mmap";
                 break;
+            case DISABLE_TYPE_LFG_MAP:
+                disableTypeStr = "lfg map";
+                break;
+            default:
+                break;
         }
 
         WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_DISABLES);
@@ -338,68 +305,44 @@ public:
         return true;
     }
 
-    static bool HandleRemoveDisableSpellCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableSpellCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_SPELL);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_SPELL, entry);
     }
 
-    static bool HandleRemoveDisableQuestCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableQuestCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_QUEST);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_QUEST, entry);
     }
 
-    static bool HandleRemoveDisableMapCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableMapCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_MAP);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_MAP, entry);
     }
 
-    static bool HandleRemoveDisableBattlegroundCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableBattlegroundCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_BATTLEGROUND);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_BATTLEGROUND, entry);
     }
 
-    static bool HandleRemoveDisableAchievementCriteriaCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableAchievementCriteriaCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_ACHIEVEMENT_CRITERIA);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_ACHIEVEMENT_CRITERIA, entry);
     }
 
-    static bool HandleRemoveDisableOutdoorPvPCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableOutdoorPvPCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_OUTDOORPVP);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_OUTDOORPVP, entry);
     }
 
-    static bool HandleRemoveDisableVmapCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableVmapCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_VMAP);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_VMAP, entry);
     }
 
-    static bool HandleRemoveDisableMMapCommand(ChatHandler* handler, char const* args)
+    static bool HandleRemoveDisableMMapCommand(ChatHandler* handler, uint32 entry)
     {
-        if (!*args)
-            return false;
-
-        return HandleRemoveDisables(handler, args, DISABLE_TYPE_MMAP);
+        return HandleRemoveDisables(handler, DISABLE_TYPE_MMAP, entry);
     }
 };
 
diff --git a/src/server/scripts/Commands/cs_group.cpp b/src/server/scripts/Commands/cs_group.cpp
index 056bac9df2f..731521ef0d7 100644
--- a/src/server/scripts/Commands/cs_group.cpp
+++ b/src/server/scripts/Commands/cs_group.cpp
@@ -428,41 +428,22 @@ public:
         return true;
     }
 
-    static bool HandleGroupListCommand(ChatHandler* handler, char const* args)
+    static bool HandleGroupListCommand(ChatHandler* handler, PlayerIdentifier const& target)
     {
-        // Get ALL the variables!
-        Player* playerTarget;
-        uint32 phase = 0;
-        ObjectGuid guidTarget;
-        std::string nameTarget;
-        std::string zoneName;
-        char const* onlineState = "";
-
-        // Parse the guid to uint32...
-        ObjectGuid parseGUID(HighGuid::Player, uint32(atoul(args)));
-
-        // ... and try to extract a player out of it.
-        if (sCharacterCache->GetCharacterNameByGuid(parseGUID, nameTarget))
-        {
-            playerTarget = ObjectAccessor::FindPlayer(parseGUID);
-            guidTarget = parseGUID;
-        }
-        // If not, we return false and end right away.
-        else if (!handler->extractPlayerTarget((char*)args, &playerTarget, &guidTarget, &nameTarget))
-            return false;
+        char const* zoneName = "<ERROR>";
+        char const* onlineState = "Offline";
 
         // Next, we need a group. So we define a group variable.
         Group* groupTarget = nullptr;
 
         // We try to extract a group from an online player.
-        if (playerTarget)
-            groupTarget = playerTarget->GetGroup();
-
-        // If not, we extract it from the SQL.
-        if (!groupTarget)
+        if (target.IsConnected())
+            groupTarget = target.GetConnectedPlayer()->GetGroup();
+        else
         {
+            // If not, we extract it from the SQL.
             CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
-            stmt->setUInt32(0, guidTarget.GetCounter());
+            stmt->setUInt32(0, target.GetGUID().GetCounter());
             PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
             if (resultGroup)
                 groupTarget = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32());
@@ -471,7 +452,7 @@ public:
         // If both fails, players simply has no party. Return false.
         if (!groupTarget)
         {
-            handler->PSendSysMessage(LANG_GROUP_NOT_IN_GROUP, nameTarget.c_str());
+            handler->PSendSysMessage(LANG_GROUP_NOT_IN_GROUP, target.GetName().c_str());
             handler->SetSentErrorMessage(true);
             return false;
         }
@@ -513,6 +494,7 @@ public:
 
             // Check if iterator is online. If is...
             Player* p = ObjectAccessor::FindPlayer((*itr).guid);
+            uint32 phase = 0;
             if (p)
             {
                 // ... than, it prints information like "is online", where he is, etc...
@@ -528,17 +510,10 @@ public:
                         zoneName = zone->AreaName[locale];
                 }
             }
-            else
-            {
-                // ... else, everything is set to offline or neutral values.
-                zoneName    = "<ERROR>";
-                onlineState = "Offline";
-                phase       = 0;
-            }
 
             // Now we can print those informations for every single member of each group!
             handler->PSendSysMessage(LANG_GROUP_PLAYER_NAME_GUID, slot.name.c_str(), onlineState,
-                zoneName.c_str(), phase, slot.guid.GetCounter(), flags.c_str(),
+                zoneName, phase, slot.guid.GetCounter(), flags.c_str(),
                 lfg::GetRolesString(slot.roles).c_str());
         }
 
diff --git a/src/server/scripts/Commands/cs_guild.cpp b/src/server/scripts/Commands/cs_guild.cpp
index cfe09772caf..73255185c67 100644
--- a/src/server/scripts/Commands/cs_guild.cpp
+++ b/src/server/scripts/Commands/cs_guild.cpp
@@ -261,25 +261,19 @@ public:
         return true;
     }
 
-    static bool HandleGuildInfoCommand(ChatHandler* handler, char const* args)
+    static bool HandleGuildInfoCommand(ChatHandler* handler, Optional<Variant<ObjectGuid::LowType, std::string_view>> const& guildIdentifier)
     {
         Guild* guild = nullptr;
 
-        if (args && args[0] != '\0')
+        if (guildIdentifier)
         {
-            if (isNumeric(args))
-            {
-                uint32 guildId = uint32(atoi(args));
-                guild = sGuildMgr->GetGuildById(guildId);
-            }
+            if (ObjectGuid::LowType const* guid = std::get_if<ObjectGuid::LowType>(&*guildIdentifier))
+                guild = sGuildMgr->GetGuildById(*guid);
             else
-            {
-                std::string guildName = args;
-                guild = sGuildMgr->GetGuildByName(guildName);
-            }
+                guild = sGuildMgr->GetGuildByName(guildIdentifier->get<std::string_view>());
         }
-        else if (Player* target = handler->getSelectedPlayerOrSelf())
-            guild = target->GetGuild();
+        else if (Optional<PlayerIdentifier> target = PlayerIdentifier::FromTargetOrSelf(handler); target && target->IsConnected())
+            guild = target->GetConnectedPlayer()->GetGuild();
 
         if (!guild)
             return false;
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index 956877c2c08..670efaea221 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -84,6 +84,7 @@ public:
             { "commands",         HandleCommandsCommand,         rbac::RBAC_PERM_COMMAND_COMMANDS,         Console::Yes },
             { "cooldown",         HandleCooldownCommand,         rbac::RBAC_PERM_COMMAND_COOLDOWN,         Console::No },
             { "damage",           HandleDamageCommand,           rbac::RBAC_PERM_COMMAND_DAMAGE,           Console::No },
+            { "damage go",        HandleDamageGoCommand,         rbac::RBAC_PERM_COMMAND_DAMAGE,           Console::No },
             { "dev",              HandleDevCommand,              rbac::RBAC_PERM_COMMAND_DEV,              Console::No },
             { "die",              HandleDieCommand,              rbac::RBAC_PERM_COMMAND_DIE,              Console::No },
             { "dismount",         HandleDismountCommand,         rbac::RBAC_PERM_COMMAND_DISMOUNT,         Console::No },
@@ -1181,7 +1182,8 @@ public:
             char const* id = handler->extractKeyFromLink((char*)args, "Hitem");
             if (!id)
                 return false;
-            itemId = atoul(id);
+
+            itemId = Trinity::StringTo<uint32>(id).value_or(0);
         }
 
         char const* ccount = strtok(nullptr, " ");
@@ -1320,7 +1322,8 @@ public:
             char const* id = handler->extractKeyFromLink(tailArgs, "Hitem");
             if (!id)
                 return false;
-            itemId = atoul(id);
+
+            itemId = Trinity::StringTo<uint32>(id).value_or(0);
         }
 
         char const* ccount = strtok(nullptr, " ");
@@ -1558,27 +1561,20 @@ public:
     *
     * @return Several pieces of information about the character and the account
     **/
-    static bool HandlePInfoCommand(ChatHandler* handler, char const* args)
+    static bool HandlePInfoCommand(ChatHandler* handler, Optional<PlayerIdentifier> arg)
     {
-        // Define ALL the player variables!
-        Player* target;
-        ObjectGuid targetGuid;
-        std::string targetName;
-        CharacterDatabasePreparedStatement* stmt = nullptr;
-
-        // To make sure we get a target, we convert our guid to an omniversal...
-        ObjectGuid parseGUID(HighGuid::Player, uint32(atoul(args)));
+        if (!arg)
+            arg = PlayerIdentifier::FromTargetOrSelf(handler);
 
-        // ... and make sure we get a target, somehow.
-        if (sCharacterCache->GetCharacterNameByGuid(parseGUID, targetName))
-        {
-            target = ObjectAccessor::FindPlayer(parseGUID);
-            targetGuid = parseGUID;
-        }
-        // if not, then return false. Which shouldn't happen, now should it ?
-        else if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
+        if (!arg)
             return false;
 
+        // Define ALL the player variables!
+        Player* target = arg->GetConnectedPlayer();
+        ObjectGuid targetGuid = arg->GetGUID();
+        std::string targetName = arg->GetName();
+        CharacterDatabasePreparedStatement* stmt = nullptr;
+
         /* The variables we extract for the command. They are
          * default as "does not exist" to prevent problems
          * The output is printed in the follow manner:
@@ -2245,71 +2241,8 @@ public:
         return true;
     }
 
-    static bool HandleDamageCommand(ChatHandler* handler, char const* args)
+    static bool HandleDamageCommand(ChatHandler* handler, uint32 damage, Optional<SpellSchools> school, Optional<SpellInfo const*> spellInfo)
     {
-        if (!*args)
-            return false;
-
-        char* str = strtok((char*)args, " ");
-
-        if (strcmp(str, "go") == 0)
-        {
-            char* guidStr = strtok(nullptr, " ");
-            if (!guidStr)
-            {
-                handler->SendSysMessage(LANG_BAD_VALUE);
-                handler->SetSentErrorMessage(true);
-                return false;
-            }
-
-            ObjectGuid::LowType guidLow = atoul(guidStr);
-            if (!guidLow)
-            {
-                handler->SendSysMessage(LANG_BAD_VALUE);
-                handler->SetSentErrorMessage(true);
-                return false;
-            }
-
-            char* damageStr = strtok(nullptr, " ");
-            if (!damageStr)
-            {
-                handler->SendSysMessage(LANG_BAD_VALUE);
-                handler->SetSentErrorMessage(true);
-                return false;
-            }
-
-            int32 damage = atoi(damageStr);
-            if (!damage)
-            {
-                handler->SendSysMessage(LANG_BAD_VALUE);
-                handler->SetSentErrorMessage(true);
-                return false;
-            }
-
-            if (Player* player = handler->GetSession()->GetPlayer())
-            {
-                GameObject* go = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
-                if (!go)
-                {
-                    handler->PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, guidLow);
-                    handler->SetSentErrorMessage(true);
-                    return false;
-                }
-
-                if (!go->IsDestructibleBuilding())
-                {
-                    handler->SendSysMessage(LANG_INVALID_GAMEOBJECT_TYPE);
-                    handler->SetSentErrorMessage(true);
-                    return false;
-                }
-
-                go->ModifyHealth(-damage, player);
-                handler->PSendSysMessage(LANG_GAMEOBJECT_DAMAGED, go->GetName().c_str(), guidLow, -damage, go->GetGOValue()->Building.Health);
-            }
-
-            return true;
-        }
-
         Unit* target = handler->getSelectedUnit();
         if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
         {
@@ -2325,16 +2258,8 @@ public:
         if (!target->IsAlive())
             return true;
 
-        int32 damage_int = atoi((char*)str);
-        if (damage_int <= 0)
-            return true;
-
-        uint32 damage = damage_int;
-
-        char* schoolStr = strtok((char*)nullptr, " ");
-
         // flat melee damage without resistence/etc reduction
-        if (!schoolStr)
+        if (!school)
         {
             Unit::DealDamage(handler->GetSession()->GetPlayer(), target, damage, nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false);
             if (target != handler->GetSession()->GetPlayer())
@@ -2342,21 +2267,16 @@ public:
             return true;
         }
 
-        uint32 school = atoi((char*)schoolStr);
-        if (school >= MAX_SPELL_SCHOOL)
-            return false;
-
-        SpellSchoolMask schoolmask = SpellSchoolMask(1 << school);
+        SpellSchoolMask schoolmask = SpellSchoolMask(1 << *school);
 
         if (Unit::IsDamageReducedByArmor(schoolmask))
             damage = Unit::CalcArmorReducedDamage(handler->GetSession()->GetPlayer(), target, damage, nullptr, BASE_ATTACK);
 
-        char* spellStr = strtok((char*)nullptr, " ");
+        Player* attacker = handler->GetSession()->GetPlayer();
 
         // melee damage by specific school
-        if (!spellStr)
+        if (!spellInfo)
         {
-            Player* attacker = handler->GetSession()->GetPlayer();
             DamageInfo dmgInfo(attacker, target, damage, nullptr, schoolmask, SPELL_DIRECT_DAMAGE, BASE_ATTACK);
             Unit::CalcAbsorbResist(dmgInfo);
 
@@ -2375,20 +2295,33 @@ public:
 
         // non-melee damage
 
-        // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
-        uint32 spellid = handler->extractSpellIdFromLink((char*)args);
-        if (!spellid)
+        SpellNonMeleeDamage damageInfo(attacker, target, (*spellInfo)->Id, (*spellInfo)->SchoolMask);
+        damageInfo.damage = damage;
+        Unit::DealDamageMods(damageInfo.target, damageInfo.damage, &damageInfo.absorb);
+        target->DealSpellDamage(&damageInfo, true);
+        target->SendSpellNonMeleeDamageLog(&damageInfo);
+        return true;
+    }
+
+    static bool HandleDamageGoCommand(ChatHandler* handler, Variant<Hyperlink<gameobject>, ObjectGuid::LowType> spawnId, int32 damage)
+    {
+        GameObject* go = handler->GetObjectFromPlayerMapByDbGuid(*spawnId);
+        if (!go)
+        {
+            handler->PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, *spawnId);
+            handler->SetSentErrorMessage(true);
             return false;
+        }
 
-        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellid);
-        if (!spellInfo)
+        if (!go->IsDestructibleBuilding())
+        {
+            handler->SendSysMessage(LANG_INVALID_GAMEOBJECT_TYPE);
+            handler->SetSentErrorMessage(true);
             return false;
+        }
 
-        Player* attacker = handler->GetSession()->GetPlayer();
-        SpellNonMeleeDamage dmgInfo(attacker, target, spellid, spellInfo->GetSchoolMask());
-        Unit::DealDamageMods(dmgInfo.target, dmgInfo.damage, &dmgInfo.absorb);
-        attacker->SendSpellNonMeleeDamageLog(&dmgInfo);
-        attacker->DealSpellDamage(&dmgInfo, true);
+        go->ModifyHealth(-damage, handler->GetSession()->GetPlayer());
+        handler->PSendSysMessage(LANG_GAMEOBJECT_DAMAGED, go->GetName().c_str(), *spawnId, -damage, go->GetGOValue()->Building.Health);
         return true;
     }
 
diff --git a/src/server/scripts/Commands/cs_modify.cpp b/src/server/scripts/Commands/cs_modify.cpp
index bfbda9be376..158be69baa2 100644
--- a/src/server/scripts/Commands/cs_modify.cpp
+++ b/src/server/scripts/Commands/cs_modify.cpp
@@ -32,6 +32,7 @@ EndScriptData */
 #include "Player.h"
 #include "RBAC.h"
 #include "ReputationMgr.h"
+#include "Util.h"
 #include "WorldSession.h"
 
 #if TRINITY_COMPILER == TRINITY_COMPILER_GNU
@@ -206,13 +207,8 @@ public:
     }
 
     //Edit Player Faction
-    static bool HandleModifyFactionCommand(ChatHandler* handler, char const* args)
+    static bool HandleModifyFactionCommand(ChatHandler* handler, Optional<uint32> factionid, Optional<uint32> flag, Optional<uint32> npcflag, Optional<uint32> dyflag)
     {
-        if (!*args)
-            return false;
-
-        char* pfactionid = handler->extractKeyFromLink((char*)args, "Hfaction");
-
         Creature* target = handler->getSelectedCreature();
         if (!target)
         {
@@ -221,54 +217,34 @@ public:
             return false;
         }
 
-        if (!pfactionid)
-        {
-            uint32 factionid = target->GetFaction();
-            uint32 flag      = target->GetUnitFlags();
-            uint32 npcflag   = target->GetNpcFlags();
-            uint32 dyflag    = target->GetDynamicFlags();
-            handler->PSendSysMessage(LANG_CURRENT_FACTION, target->GetGUID().GetCounter(), factionid, flag, npcflag, dyflag);
-            return true;
-        }
-
-        uint32 factionid = atoi(pfactionid);
-        UnitFlags flag;
-
-        char *pflag = strtok(nullptr, " ");
-        if (!pflag)
+        if (!flag)
             flag = target->GetUnitFlags();
-        else
-            flag = UnitFlags(atoi(pflag));
-
-        char* pnpcflag = strtok(nullptr, " ");
 
-        NPCFlags npcflag;
-        if (!pnpcflag)
+        if (!npcflag)
             npcflag = target->GetNpcFlags();
-        else
-            npcflag = NPCFlags(atoi(pnpcflag));
 
-        char* pdyflag = strtok(nullptr, " ");
-
-        uint32  dyflag;
-        if (!pdyflag)
+        if (!dyflag)
             dyflag = target->GetDynamicFlags();
-        else
-            dyflag = atoi(pdyflag);
 
-        if (!sFactionTemplateStore.LookupEntry(factionid))
+        if (!factionid)
+        {
+            handler->PSendSysMessage(LANG_CURRENT_FACTION, target->GetGUID().GetCounter(), *factionid, *flag, *npcflag, *dyflag);
+            return true;
+        }
+
+        if (!sFactionTemplateStore.LookupEntry(*factionid))
         {
-            handler->PSendSysMessage(LANG_WRONG_FACTION, factionid);
+            handler->PSendSysMessage(LANG_WRONG_FACTION, *factionid);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
-        handler->PSendSysMessage(LANG_YOU_CHANGE_FACTION, target->GetGUID().GetCounter(), factionid, flag, npcflag, dyflag);
+        handler->PSendSysMessage(LANG_YOU_CHANGE_FACTION, target->GetGUID().GetCounter(), *factionid, *flag, *npcflag, *dyflag);
 
-        target->SetFaction(factionid);
-        target->ReplaceAllUnitFlags(flag);
-        target->ReplaceAllNpcFlags(npcflag);
-        target->ReplaceAllDynamicFlags(dyflag);
+        target->SetFaction(*factionid);
+        target->ReplaceAllUnitFlags(UnitFlags(*flag));
+        target->ReplaceAllNpcFlags(NPCFlags(*npcflag));
+        target->ReplaceAllDynamicFlags(*dyflag);
 
         return true;
     }
@@ -375,13 +351,8 @@ public:
         return false;
     }
 
-    static bool CheckModifySpeed(ChatHandler* handler, char const* args, Unit* target, float& speed, float minimumBound, float maximumBound, bool checkInFlight = true)
+    static bool CheckModifySpeed(ChatHandler* handler, Unit* target, float speed, float minimumBound, float maximumBound, bool checkInFlight = true)
     {
-        if (!*args)
-            return false;
-
-        speed = (float)atof((char*)args);
-
         if (speed > maximumBound || speed < minimumBound)
         {
             handler->SendSysMessage(LANG_BAD_VALUE);
@@ -412,6 +383,15 @@ public:
         return true;
     }
 
+    static bool CheckModifySpeed(ChatHandler* handler, char const* args, Unit* target, float& speed, float minimumBound, float maximumBound, bool checkInFlight = true)
+    {
+        if (!*args)
+            return false;
+
+        speed = (float)atof((char*)args);
+        return CheckModifySpeed(handler, target, speed, minimumBound, maximumBound, checkInFlight);
+    }
+
     //Edit Player Aspeed
     static bool HandleModifyASpeedCommand(ChatHandler* handler, char const* args)
     {
@@ -500,18 +480,8 @@ public:
     }
 
     //Enable Player mount
-    static bool HandleModifyMountCommand(ChatHandler* handler, char const* args)
+    static bool HandleModifyMountCommand(ChatHandler* handler, uint32 mount, float speed)
     {
-        if (!*args)
-            return false;
-
-        char const* mount_cstr = strtok(const_cast<char*>(args), " ");
-        char const* speed_cstr = strtok(nullptr, " ");
-
-        if (!mount_cstr || !speed_cstr)
-            return false;
-
-        uint32 mount = atoul(mount_cstr);
         if (!sCreatureDisplayInfoStore.LookupEntry(mount))
         {
             handler->SendSysMessage(LANG_NO_MOUNT);
@@ -531,8 +501,7 @@ public:
         if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
             return false;
 
-        float speed;
-        if (!CheckModifySpeed(handler, speed_cstr, target, speed, 0.1f, 50.0f))
+        if (!CheckModifySpeed(handler, target, speed, 0.1f, 50.0f))
             return false;
 
         NotifyModification(handler, target, LANG_YOU_GIVE_MOUNT, LANG_MOUNT_GIVED);
@@ -808,13 +777,8 @@ public:
     }
 
     //morph creature or player
-    static bool HandleModifyMorphCommand(ChatHandler* handler, char const* args)
+    static bool HandleModifyMorphCommand(ChatHandler* handler, uint32 display_id)
     {
-        if (!*args)
-            return false;
-
-        uint32 display_id = (uint32)atoi((char*)args);
-
         Unit* target = handler->getSelectedUnit();
         if (!target)
             target = handler->GetSession()->GetPlayer();
@@ -829,13 +793,8 @@ public:
     }
 
     //set temporary phase mask for player
-    static bool HandleModifyPhaseCommand(ChatHandler* handler, char const* args)
+    static bool HandleModifyPhaseCommand(ChatHandler* handler, uint32 phasemask)
     {
-        if (!*args)
-            return false;
-
-        uint32 phasemask = (uint32)atoi((char*)args);
-
         Unit* target = handler->getSelectedUnit();
         if (!target)
             target = handler->GetSession()->GetPlayer();
@@ -845,7 +804,6 @@ public:
             return false;
 
         target->SetPhaseMask(phasemask, true);
-
         return true;
     }
 
diff --git a/src/server/scripts/Commands/cs_pet.cpp b/src/server/scripts/Commands/cs_pet.cpp
index a8c71b6b380..1dfc4bfdeb8 100644
--- a/src/server/scripts/Commands/cs_pet.cpp
+++ b/src/server/scripts/Commands/cs_pet.cpp
@@ -24,12 +24,11 @@
 #include "Pet.h"
 #include "Player.h"
 #include "RBAC.h"
+#include "SpellInfo.h"
 #include "SpellMgr.h"
 #include "WorldSession.h"
 
-#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+using namespace Trinity::ChatCommands;
 
 inline Pet* GetSelectedPlayerPetOrOwn(ChatHandler* handler)
 {
@@ -50,23 +49,23 @@ class pet_commandscript : public CommandScript
 public:
     pet_commandscript() : CommandScript("pet_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> petCommandTable =
+        static ChatCommandTable petCommandTable =
         {
-            { "create",  rbac::RBAC_PERM_COMMAND_PET_CREATE,  false, &HandlePetCreateCommand,  "" },
-            { "learn",   rbac::RBAC_PERM_COMMAND_PET_LEARN,   false, &HandlePetLearnCommand,   "" },
-            { "unlearn", rbac::RBAC_PERM_COMMAND_PET_UNLEARN, false, &HandlePetUnlearnCommand, "" },
-            { "level",   rbac::RBAC_PERM_COMMAND_PET_LEVEL,   false, &HandlePetLevelCommand,   "" },
+            { "create",  HandlePetCreateCommand,  rbac::RBAC_PERM_COMMAND_PET_CREATE,  Console::No },
+            { "learn",   HandlePetLearnCommand,   rbac::RBAC_PERM_COMMAND_PET_LEARN,   Console::No },
+            { "unlearn", HandlePetUnlearnCommand, rbac::RBAC_PERM_COMMAND_PET_UNLEARN, Console::No },
+            { "level",   HandlePetLevelCommand,   rbac::RBAC_PERM_COMMAND_PET_LEVEL,   Console::No },
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "pet", rbac::RBAC_PERM_COMMAND_PET, false, nullptr, "", petCommandTable },
+            { "pet", petCommandTable },
         };
         return commandTable;
     }
-    static bool HandlePetCreateCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandlePetCreateCommand(ChatHandler* handler)
     {
         Player* player = handler->GetSession()->GetPlayer();
         Creature* creatureTarget = handler->getSelectedCreature();
@@ -122,11 +121,8 @@ public:
         return true;
     }
 
-    static bool HandlePetLearnCommand(ChatHandler* handler, char const* args)
+    static bool HandlePetLearnCommand(ChatHandler* handler, SpellInfo const* spellInfo)
     {
-        if (!*args)
-            return false;
-
         Pet* pet = GetSelectedPlayerPetOrOwn(handler);
 
         if (!pet)
@@ -136,10 +132,7 @@ public:
             return false;
         }
 
-        uint32 spellId = handler->extractSpellIdFromLink((char*)args);
-
-        if (!spellId || !sSpellMgr->GetSpellInfo(spellId))
-            return false;
+        uint32 spellId = spellInfo->Id;
 
         // Check if pet already has it
         if (pet->HasSpell(spellId))
@@ -150,8 +143,7 @@ public:
         }
 
         // Check if spell is valid
-        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
-        if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
+        if (!SpellMgr::IsSpellValid(spellInfo))
         {
             handler->PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spellId);
             handler->SetSentErrorMessage(true);
@@ -164,11 +156,8 @@ public:
         return true;
     }
 
-    static bool HandlePetUnlearnCommand(ChatHandler* handler, char const* args)
+    static bool HandlePetUnlearnCommand(ChatHandler* handler, SpellInfo const* spellInfo)
     {
-        if (!*args)
-            return false;
-
         Pet* pet = GetSelectedPlayerPetOrOwn(handler);
         if (!pet)
         {
@@ -177,7 +166,7 @@ public:
             return false;
         }
 
-        uint32 spellId = handler->extractSpellIdFromLink((char*)args);
+        uint32 spellId = spellInfo->Id;
 
         if (pet->HasSpell(spellId))
             pet->removeSpell(spellId, false);
@@ -187,7 +176,7 @@ public:
         return true;
     }
 
-    static bool HandlePetLevelCommand(ChatHandler* handler, char const* args)
+    static bool HandlePetLevelCommand(ChatHandler* handler, Optional<int32> level)
     {
         Pet* pet = GetSelectedPlayerPetOrOwn(handler);
         Player* owner = pet ? pet->GetOwner() : nullptr;
@@ -198,9 +187,9 @@ public:
             return false;
         }
 
-        int32 level = args ? atoi(args) : 0;
-        if (level == 0)
+        if (!level)
             level = owner->GetLevel() - pet->GetLevel();
+
         if (level == 0 || level < -STRONG_MAX_LEVEL || level > STRONG_MAX_LEVEL)
         {
             handler->SendSysMessage(LANG_BAD_VALUE);
@@ -208,7 +197,7 @@ public:
             return false;
         }
 
-        int32 newLevel = pet->GetLevel() + level;
+        int32 newLevel = pet->GetLevel() + *level;
         if (newLevel < 1)
             newLevel = 1;
         else if (newLevel > owner->GetLevel())
diff --git a/src/server/scripts/Commands/cs_quest.cpp b/src/server/scripts/Commands/cs_quest.cpp
index 4c090a5f836..5e15e615a6b 100644
--- a/src/server/scripts/Commands/cs_quest.cpp
+++ b/src/server/scripts/Commands/cs_quest.cpp
@@ -58,7 +58,7 @@ public:
         return commandTable;
     }
 
-    static bool HandleQuestAdd(ChatHandler* handler, char const* args)
+    static bool HandleQuestAdd(ChatHandler* handler, Quest const* quest)
     {
         Player* player = handler->getSelectedPlayerOrSelf();
         if (!player)
@@ -68,19 +68,9 @@ public:
             return false;
         }
 
-        // .addquest #entry'
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
-        char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
-        if (!cId)
-            return false;
-
-        uint32 entry = atoul(cId);
-
-        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
-
-        if (!quest || DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, entry, nullptr))
+        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), nullptr))
         {
-            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
+            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, quest->GetQuestId());
             handler->SetSentErrorMessage(true);
             return false;
         }
@@ -94,12 +84,12 @@ public:
 
         if (itr != std::end(itc))
         {
-            handler->PSendSysMessage(LANG_COMMAND_QUEST_STARTFROMITEM, entry, itr->first);
+            handler->PSendSysMessage(LANG_COMMAND_QUEST_STARTFROMITEM, quest->GetQuestId(), itr->first);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
-        if (player->IsActiveQuest(entry))
+        if (player->IsActiveQuest(quest->GetQuestId()))
             return false;
 
         // ok, normal (creature/GO starting) quest
@@ -109,7 +99,7 @@ public:
         return true;
     }
 
-    static bool HandleQuestRemove(ChatHandler* handler, char const* args)
+    static bool HandleQuestRemove(ChatHandler* handler, Quest const* quest)
     {
         Player* player = handler->getSelectedPlayer();
         if (!player)
@@ -119,30 +109,20 @@ public:
             return false;
         }
 
-        // .removequest #entry'
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
-        char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
-        if (!cId)
-            return false;
-
-        uint32 entry = atoul(cId);
-
-        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
-
         if (!quest)
         {
-            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
+            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, quest->GetQuestId());
             handler->SetSentErrorMessage(true);
             return false;
         }
 
-        if (player->GetQuestStatus(entry) != QUEST_STATUS_NONE)
+        if (player->GetQuestStatus(quest->GetQuestId()) != QUEST_STATUS_NONE)
         {
             // remove all quest entries for 'entry' from quest log
             for (uint8 slot = 0; slot < MAX_QUEST_LOG_SIZE; ++slot)
             {
                 uint32 logQuest = player->GetQuestSlotQuestId(slot);
-                if (logQuest == entry)
+                if (logQuest == quest->GetQuestId())
                 {
                     player->SetQuestSlot(slot, 0);
 
@@ -156,23 +136,23 @@ public:
                     }
                 }
             }
-            player->RemoveActiveQuest(entry, false);
-            player->RemoveRewardedQuest(entry);
+            player->RemoveActiveQuest(quest->GetQuestId(), false);
+            player->RemoveRewardedQuest(quest->GetQuestId());
 
-            sScriptMgr->OnQuestStatusChange(player, entry);
+            sScriptMgr->OnQuestStatusChange(player, quest->GetQuestId());
 
             handler->SendSysMessage(LANG_COMMAND_QUEST_REMOVED);
             return true;
         }
         else
         {
-            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
+            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, quest->GetQuestId());
             handler->SetSentErrorMessage(true);
             return false;
         }
     }
 
-    static bool HandleQuestComplete(ChatHandler* handler, char const* args)
+    static bool HandleQuestComplete(ChatHandler* handler, Quest const* quest)
     {
         Player* player = handler->getSelectedPlayerOrSelf();
         if (!player)
@@ -182,21 +162,11 @@ public:
             return false;
         }
 
-        // .quest complete #entry
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
-        char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
-        if (!cId)
-            return false;
-
-        uint32 entry = atoul(cId);
-
-        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
-
         // If player doesn't have the quest
-        if (!quest || player->GetQuestStatus(entry) == QUEST_STATUS_NONE
-            || DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, entry, nullptr))
+        if (player->GetQuestStatus(quest->GetQuestId()) == QUEST_STATUS_NONE
+            || DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), nullptr))
         {
-            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
+            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, quest->GetQuestId());
             handler->SetSentErrorMessage(true);
             return false;
         }
@@ -278,11 +248,11 @@ public:
             CharacterDatabase.Execute(stmt);
         }
 
-        player->CompleteQuest(entry);
+        player->CompleteQuest(quest->GetQuestId());
         return true;
     }
 
-    static bool HandleQuestReward(ChatHandler* handler, char const* args)
+    static bool HandleQuestReward(ChatHandler* handler, Quest const* quest)
     {
         Player* player = handler->getSelectedPlayer();
         if (!player)
@@ -292,21 +262,11 @@ public:
             return false;
         }
 
-        // .quest reward #entry
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
-        char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
-        if (!cId)
-            return false;
-
-        uint32 entry = atoul(cId);
-
-        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
-
         // If player doesn't have the quest
-        if (!quest || player->GetQuestStatus(entry) != QUEST_STATUS_COMPLETE
-            || DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, entry, nullptr))
+        if (player->GetQuestStatus(quest->GetQuestId()) != QUEST_STATUS_COMPLETE
+            || DisableMgr::IsDisabledFor(DISABLE_TYPE_QUEST, quest->GetQuestId(), nullptr))
         {
-            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, entry);
+            handler->PSendSysMessage(LANG_COMMAND_QUEST_NOTFOUND, quest->GetQuestId());
             handler->SetSentErrorMessage(true);
             return false;
         }
diff --git a/src/server/scripts/Commands/cs_send.cpp b/src/server/scripts/Commands/cs_send.cpp
index 8b44a4a7677..d718a4b3c7f 100644
--- a/src/server/scripts/Commands/cs_send.cpp
+++ b/src/server/scripts/Commands/cs_send.cpp
@@ -31,24 +31,26 @@
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
+using namespace Trinity::ChatCommands;
+
 class send_commandscript : public CommandScript
 {
 public:
     send_commandscript() : CommandScript("send_commandscript") { }
 
-    std::vector<ChatCommand> GetCommands() const override
+    ChatCommandTable GetCommands() const override
     {
-        static std::vector<ChatCommand> sendCommandTable =
+        static ChatCommandTable sendCommandTable =
         {
-            { "items",   rbac::RBAC_PERM_COMMAND_SEND_ITEMS,   true, &HandleSendItemsCommand,   "" },
-            { "mail",    rbac::RBAC_PERM_COMMAND_SEND_MAIL,    true, &HandleSendMailCommand,    "" },
-            { "message", rbac::RBAC_PERM_COMMAND_SEND_MESSAGE, true, &HandleSendMessageCommand, "" },
-            { "money",   rbac::RBAC_PERM_COMMAND_SEND_MONEY,   true, &HandleSendMoneyCommand,   "" },
+            { "items",   HandleSendItemsCommand,   rbac::RBAC_PERM_COMMAND_SEND_ITEMS,   Console::Yes },
+            { "mail",    HandleSendMailCommand,    rbac::RBAC_PERM_COMMAND_SEND_MAIL,    Console::Yes },
+            { "message", HandleSendMessageCommand, rbac::RBAC_PERM_COMMAND_SEND_MESSAGE, Console::Yes },
+            { "money",   HandleSendMoneyCommand,   rbac::RBAC_PERM_COMMAND_SEND_MONEY,   Console::Yes },
         };
 
-        static std::vector<ChatCommand> commandTable =
+        static ChatCommandTable commandTable =
         {
-            { "send", rbac::RBAC_PERM_COMMAND_SEND, false, nullptr, "", sendCommandTable },
+            { "send", sendCommandTable },
         };
         return commandTable;
     }
@@ -146,14 +148,14 @@ public:
             char const* itemIdStr = strtok(itemStr, ":");
             char const* itemCountStr = strtok(nullptr, " ");
 
-            uint32 itemId = atoi(itemIdStr);
+            Optional<uint32> itemId = Trinity::StringTo<uint32>(itemIdStr);
             if (!itemId)
                 return false;
 
-            ItemTemplate const* item_proto = sObjectMgr->GetItemTemplate(itemId);
+            ItemTemplate const* item_proto = sObjectMgr->GetItemTemplate(*itemId);
             if (!item_proto)
             {
-                handler->PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, itemId);
+                handler->PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, *itemId);
                 handler->SetSentErrorMessage(true);
                 return false;
             }
@@ -161,18 +163,18 @@ public:
             uint32 itemCount = itemCountStr ? atoi(itemCountStr) : 1;
             if (itemCount < 1 || (item_proto->MaxCount > 0 && itemCount > uint32(item_proto->MaxCount)))
             {
-                handler->PSendSysMessage(LANG_COMMAND_INVALID_ITEM_COUNT, itemCount, itemId);
+                handler->PSendSysMessage(LANG_COMMAND_INVALID_ITEM_COUNT, itemCount, *itemId);
                 handler->SetSentErrorMessage(true);
                 return false;
             }
 
             while (itemCount > item_proto->GetMaxStackSize())
             {
-                items.push_back(ItemPair(itemId, item_proto->GetMaxStackSize()));
+                items.push_back(ItemPair(*itemId, item_proto->GetMaxStackSize()));
                 itemCount -= item_proto->GetMaxStackSize();
             }
 
-            items.push_back(ItemPair(itemId, itemCount));
+            items.push_back(ItemPair(*itemId, itemCount));
 
             if (items.size() > MAX_MAIL_ITEMS)
             {
@@ -207,41 +209,10 @@ public:
         return true;
     }
     /// Send money by mail
-    static bool HandleSendMoneyCommand(ChatHandler* handler, char const* args)
+    static bool HandleSendMoneyCommand(ChatHandler* handler, PlayerIdentifier const& receiver, QuotedString const& subject, QuotedString const& text, uint32 money)
     {
         /// format: name "subject text" "mail text" money
 
-        Player* receiver;
-        ObjectGuid receiverGuid;
-        std::string receiverName;
-        if (!handler->extractPlayerTarget((char*)args, &receiver, &receiverGuid, &receiverName))
-            return false;
-
-        char* tail1 = strtok(nullptr, "");
-        if (!tail1)
-            return false;
-
-        char* msgSubject = handler->extractQuotedArg(tail1);
-        if (!msgSubject)
-            return false;
-
-        char* tail2 = strtok(nullptr, "");
-        if (!tail2)
-            return false;
-
-        char* msgText = handler->extractQuotedArg(tail2);
-        if (!msgText)
-            return false;
-
-        char* moneyStr = strtok(nullptr, "");
-        int32 money = moneyStr ? atoi(moneyStr) : 0;
-        if (money <= 0)
-            return false;
-
-        // msgSubject, msgText isn't NUL after prev. check
-        std::string subject = msgSubject;
-        std::string text    = msgText;
-
         // from console show nonexisting sender
         MailSender sender(MAIL_NORMAL, handler->GetSession() ? handler->GetSession()->GetPlayer()->GetGUID().GetCounter() : 0, MAIL_STATIONERY_GM);
 
@@ -249,11 +220,11 @@ public:
 
         MailDraft(subject, text)
             .AddMoney(money)
-            .SendMailTo(trans, MailReceiver(receiver, receiverGuid.GetCounter()), sender);
+            .SendMailTo(trans, MailReceiver(receiver.GetConnectedPlayer(), receiver.GetGUID().GetCounter()), sender);
 
         CharacterDatabase.CommitTransaction(trans);
 
-        std::string nameLink = handler->playerLink(receiverName);
+        std::string nameLink = handler->playerLink(receiver.GetName());
         handler->PSendSysMessage(LANG_MAIL_SENT, nameLink.c_str());
         return true;
     }
diff --git a/src/server/scripts/Commands/cs_wp.cpp b/src/server/scripts/Commands/cs_wp.cpp
index d987d054bc6..6b64aa8b12d 100644
--- a/src/server/scripts/Commands/cs_wp.cpp
+++ b/src/server/scripts/Commands/cs_wp.cpp
@@ -299,29 +299,25 @@ public:
             return false;
 
         char* arg_id = strtok(nullptr, " ");
-        uint32 id = 0;
 
         if (show == "add")
         {
-            if (arg_id)
-                id = atoi(arg_id);
-
-            if (id)
+            if (Optional<uint32> id = Trinity::StringTo<uint32>(arg_id))
             {
                 stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID);
-                stmt->setUInt32(0, id);
+                stmt->setUInt32(0, *id);
                 PreparedQueryResult result = WorldDatabase.Query(stmt);
 
                 if (!result)
                 {
                     stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_WAYPOINT_SCRIPT);
-                    stmt->setUInt32(0, id);
+                    stmt->setUInt32(0, *id);
                     WorldDatabase.Execute(stmt);
 
-                    handler->PSendSysMessage("%s%s%u|r", "|cff00ff00", "Wp Event: New waypoint event added: ", id);
+                    handler->PSendSysMessage("%s%s%u|r", "|cff00ff00", "Wp Event: New waypoint event added: ", *id);
                 }
                 else
-                    handler->PSendSysMessage("|cff00ff00Wp Event: You have choosed an existing waypoint script guid: %u|r", id);
+                    handler->PSendSysMessage("|cff00ff00Wp Event: You have choosed an existing waypoint script guid: %u|r", *id);
             }
             else
             {
@@ -329,10 +325,10 @@ public:
                 PreparedQueryResult result = WorldDatabase.Query(stmt);
                 id = result->Fetch()->GetUInt32();
                 stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_WAYPOINT_SCRIPT);
-                stmt->setUInt32(0, id + 1);
+                stmt->setUInt32(0, *id + 1);
                 WorldDatabase.Execute(stmt);
 
-                handler->PSendSysMessage("%s%s%u|r", "|cff00ff00", "Wp Event: New waypoint event added: |r|cff00ffff", id+1);
+                handler->PSendSysMessage("%s%s%u|r", "|cff00ff00", "Wp Event: New waypoint event added: |r|cff00ffff", *id+1);
             }
 
             return true;
@@ -346,7 +342,7 @@ public:
                 return true;
             }
 
-            id = atoi(arg_id);
+            uint32 id = Trinity::StringTo<uint32>(arg_id).value_or(0);
 
             uint32 a2, a3, a4, a5, a6;
             float a8, a9, a10, a11;
@@ -391,7 +387,7 @@ public:
                 return true;
             }
 
-            id = atoi(arg_id);
+            uint32 id = Trinity::StringTo<uint32>(arg_id).value_or(0);
 
             stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID);
             stmt->setUInt32(0, id);
@@ -419,7 +415,7 @@ public:
                 return true;
             }
 
-            id = atoi(arg_id);
+            uint32 id = Trinity::StringTo<uint32>(arg_id).value_or(0);
 
             if (!id)
             {
@@ -457,8 +453,8 @@ public:
 
             if (arg_str_2 == "setid")
             {
-                uint32 newid = atoi(arg_3);
-                handler->PSendSysMessage("%s%s|r|cff00ffff%u|r|cff00ff00%s|r|cff00ffff%u|r", "|cff00ff00", "Wp Event: Wypoint scipt guid: ", newid, " id changed: ", id);
+                uint32 newid = Trinity::StringTo<uint32>(arg_3).value_or(0);
+                handler->PSendSysMessage("%s%s|r|cff00ffff%u|r|cff00ff00%s|r|cff00ffff%u|r", "|cff00ff00", "Wp Event: Waypoint script guid: ", newid, " id changed: ", id);
 
                 stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_SCRIPT_ID);
                 stmt->setUInt32(0, newid);
@@ -767,7 +763,7 @@ public:
             if (target)
                 handler->SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
 
-            pathid = atoul(guid_str);
+            pathid = Trinity::StringTo<uint32>(guid_str).value_or(0);
         }
 
         std::string show = show_str;