feat: Implement account name/command as config

Author: Nyeriah

conf/conf.sh.dist

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+## CUSTOM SQL - Important file used by the db_assembler.sh
+## Keep only the required variables (base sql files or updates, depending on the DB)
+
+## BASE SQL
+
+DB_AUTH_CUSTOM_PATHS+=(
+	"$MOD_SKELETON_ROOT/sql/auth/base/"
+)
+
+DB_CHARACTERS_CUSTOM_PATHS+=(
+	"$MOD_SKELETON_ROOT/sql/characters/base/"
+)
+
+DB_WORLD_CUSTOM_PATHS+=(
+	"$MOD_SKELETON_ROOT/sql/world/base/"
+)
+
+## UPDATES
+
+DB_AUTH_UPDATES_PATHS+=(
+	"$MOD_SKELETON_ROOT/sql/auth/updates/"
+)
+
+DB_CHARACTERS_UPDATES_PATHS+=(
+	"$MOD_SKELETON_ROOT/sql/characters/updates/"
+)
+
+DB_WORLD_UPDATES_PATHS+=(
+	"$MOD_SKELETON_ROOT/sql/world/updates/"
+)

conf/my_custom.conf.dist conf/mod_gm_commands.conf.distconf/my_custom.conf.dist renamed to conf/mod_gm_commands.conf.dist

@@ -15,3 +15,20 @@
 #
 
 GmCommandsModule.Enable = 1
+
+#
+#    GmCommandsModule.AccountIds
+#        Description: Allow the specified accounts to use commands. Separated by comma
+#
+#
+
+GmCommandsModule.AccountIds = ""
+
+#
+#
+#    GmCommandsModule.AllowedCommands
+#        Description: Allow the specified commands to be used. Separated by comma.
+#
+#
+
+GmCommandsModule.AllowedCommands = ""

src/GmCommands.cpp

@@ -3,6 +3,48 @@
 #include "Chat.h"
 #include "ChatCommand.h"
 #include "Config.h"
+#include "GmCommands.h"
+#include "Tokenize.h"
+
+GMCommands* GMCommands::instance()
+{
+    static GMCommands instance;
+    return &instance;
+}
+
+void GMCommands::LoadAccountIds()
+{
+    std::string accountIds = sConfigMgr->GetOption<std::string>("GmCommandsModule.AccountIds", "");
+    for (auto& itr : Acore::Tokenize(accountIds, ',', false))
+    {
+        uint32 accountId = Acore::StringTo<uint32>(itr).value();
+        accountIDs.push_back(accountId);
+    }
+}
+
+void GMCommands::LoadAllowedCommands()
+{
+    std::string allowedCommandsList = sConfigMgr->GetOption<std::string>("GmCommandsModule.AllowedCommands", "");
+    for (auto& itr : Acore::Tokenize(allowedCommandsList, ',', false))
+    {
+        std::string command(itr);
+        allowedCommands.push_back(command);
+    }
+}
+
+bool GMCommands::IsAccountAllowed(uint32 accountId) const
+{
+    for (auto& itr : accountIDs)
+    {
+        LOG_ERROR("sql.sql", "AccountId {}", itr);
+    }
+    return std::find(accountIDs.begin(), accountIDs.end(), accountId) != accountIDs.end();
+}
+
+bool GMCommands::IsCommandAllowed(std::string command) const
+{
+    return std::find(allowedCommands.begin(), allowedCommands.end(), command) != allowedCommands.end();
+}
 
 class GmCommands : public AllCommandScript
 {
@@ -21,28 +63,30 @@ class GmCommands : public AllCommandScript
 
         uint32 accountID = player->GetSession()->GetAccountId();
 
-        if (!std::count(eligibleAccounts.begin(), eligibleAccounts.end(), accountID))
-            return true; // Account is not eligible
+        if (!sGMCommands->IsAccountAllowed(accountID))
+            return true;
 
-        if (std::count(eligibleCommands.begin(), eligibleCommands.end(), name))
-            return false; // Command is eligible
+        if (!sGMCommands->IsCommandAllowed(name))
+            return true;
 
-        return true; // Command is not eligible
+        return false;
     }
+};
 
-private:
-    std::vector<uint32> eligibleAccounts =
-    {
-        94143, // HEYITSGMCH
-    };
+class mod_gm_commands_worldscript : public WorldScript
+{
+public:
+    mod_gm_commands_worldscript() : WorldScript("mod_gm_commands_worldscript") {}
 
-    std::vector<std::string> eligibleCommands =
+    void OnAfterConfigLoad(bool /*reload*/) override
     {
-        "gm fly",
-    };
+        sGMCommands->LoadAccountIds();
+        sGMCommands->LoadAllowedCommands();
+    }
 };
 
 void AddGmCommandScripts()
 {
     new GmCommands();
+    new mod_gm_commands_worldscript();
 }

src/GmCommands.h

@@ -0,0 +1,25 @@
+#ifndef DEF_GMCOMMANDS_H
+#define DEF_GMCOMMANDS_H
+
+#include "Player.h"
+#include "Config.h"
+
+class GMCommands
+{
+public:
+    static GMCommands* instance();
+
+    void LoadAccountIds();
+    void LoadAllowedCommands();
+
+    [[nodiscard]] bool IsAccountAllowed(uint32 accountId) const;
+    [[nodiscard]] bool IsCommandAllowed(std::string command) const;
+
+private:
+    std::vector<uint32> accountIDs;
+    std::vector<std::string> allowedCommands;
+};
+
+#define sGMCommands GMCommands::instance()
+
+#endif