Command manager

src/network/protocols/command_manager.hpp

@@ -0,0 +1,213 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2021 kimden
+//
+//  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 3
+//  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, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef COMMAND_MANAGER_HPP
+#define COMMAND_MANAGER_HPP
+
+#include "irrString.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <deque>
+#include <vector>
+#include <queue>
+
+
+#ifdef ENABLE_SQLITE3
+#include <sqlite3.h>
+#endif
+
+#include "network/protocols/command_voting.hpp"
+#include "utils/set_typo_fixer.hpp"
+
+class ServerLobby;
+class Event;
+class STKPeer;
+
+class CommandManager
+{
+    enum CommandScope: int {
+        CS_ALWAYS = 1,
+        CS_SOCCER_TOURNAMENT = 2
+        // add more powers of two if needed
+    };
+
+    struct Context
+    {
+        Event* m_event;
+
+        std::shared_ptr<STKPeer> m_peer;
+
+        std::vector<std::string> m_argv;
+
+        std::string m_cmd;
+
+        int m_user_permissions;
+
+        bool m_voting;
+
+        Context(Event* event, std::shared_ptr<STKPeer> peer,
+            std::vector<std::string>& argv, std::string& cmd,
+            int user_permissions, bool voting):
+                m_event(event), m_peer(peer), m_argv(argv),
+                m_cmd(cmd), m_user_permissions(user_permissions), m_voting(voting) {}
+    };
+
+    struct Command
+    {
+        std::string m_name;
+
+        int m_permissions;
+
+        void (CommandManager::*m_action)(Context& context);
+
+        int m_scope;
+
+        std::string m_usage;
+
+        std::string m_description;
+
+        std::string m_verbose_permissions;
+
+        Command() {}
+
+        Command(std::string name,
+            void (CommandManager::*f)(Context& context), int permissions, int scope = CS_ALWAYS,
+            std::string usage = "", std::string verbose_permissions = "", std::string description = ""):
+                m_name(name), m_permissions(permissions), m_action(f), m_scope(scope),
+                m_usage(usage), m_description(description),
+                m_verbose_permissions(verbose_permissions) {}
+
+        std::string getUsage() { return "Usage: " + m_usage; }
+
+        std::string getHelp() { return "Usage: " + m_usage + "\nAvailable to: " + m_verbose_permissions + "\n" + m_description; }
+    };
+
+private:
+
+    ServerLobby* m_lobby;
+
+    std::vector<Command> m_commands;
+
+    std::map<std::string, Command> m_name_to_command;
+
+    std::multiset<std::string> m_users;
+
+    std::map<std::string, std::string> m_text_response;
+
+    std::map<std::string, CommandVoting> m_votables;
+
+    std::queue<std::string> m_triggered_votables;
+
+    std::map<std::string, std::vector<std::string>> m_user_command_replacements;
+
+    SetTypoFixer m_stf_command_names;
+
+    SetTypoFixer m_stf_present_users;
+
+    SetTypoFixer m_stf_maps;
+
+    void initCommands();
+
+    int getCurrentScope();
+
+    bool isAvailable(const Command& c);
+
+    void vote(Context& context, std::string category, std::string value);
+    void update();
+    void error(Context& context);
+
+    void process_help(Context& context);
+    void process_text(Context& context);
+    void process_commands(Context& context);
+    void process_replay(Context& context);
+    void process_start(Context& context);
+    void process_config(Context& context);
+    void process_spectate(Context& context);
+    void process_addons(Context& context);
+    void process_lsa(Context& context);
+    void process_pha(Context& context);
+    void process_kick(Context& context);
+    void process_unban(Context& context);
+    void process_ban(Context& context);
+    void process_pas(Context& context);
+    void process_sha(Context& context);
+    void process_mute(Context& context);
+    void process_unmute(Context& context);
+    void process_listmute(Context& context);
+    void process_gnu(Context& context);
+    void process_tell(Context& context);
+    void process_standings(Context& context);
+    void process_teamchat(Context& context);
+    void process_to(Context& context);
+    void process_public(Context& context);
+    void process_record(Context& context);
+    void process_power(Context& context);
+    void process_length(Context& context);
+    void process_queue(Context& context);
+    void process_adminstart(Context& context);
+    void process_shuffle(Context& context);
+    void process_timeout(Context& context);
+    void process_team(Context& context);
+    void process_cat(Context& context);
+    void process_troll(Context& context);
+    void process_hitmsg(Context& context);
+    void process_teamhit(Context& context);
+    void process_register(Context& context);
+#ifdef ENABLE_WEB_SUPPORT
+    void process_token(Context& context);
+#endif
+    // soccer tournament commands
+    void process_muteall(Context& context);
+    void process_game(Context& context);
+    void process_role(Context& context);
+    void process_stop(Context& context);
+    void process_go(Context& context);
+    void process_lobby(Context& context);
+    void process_init(Context& context);
+    void process_mimiz(Context& context);
+    void process_test(Context& context);
+    void process_slots(Context& context);
+    void special(Context& context);
+
+public:
+
+    CommandManager(ServerLobby* lobby = nullptr);
+
+    void handleCommand(Event* event, std::shared_ptr<STKPeer> peer);
+
+    bool isInitialized() { return m_lobby != nullptr; }
+
+    template<typename T>
+    void addTextResponse(std::string key, T&& value)
+                                              { m_text_response[key] = value; }
+
+    void addUser(std::string& s);
+
+    void deleteUser(std::string& s);
+
+    static void restoreCmdByArgv(std::string& cmd, std::vector<std::string>& argv, char c, char d, char e, char f);
+};
+
+#endif // COMMAND_MANAGER_HPP

src/network/protocols/command_permissions.hpp

@@ -0,0 +1,36 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2021 kimden
+//
+//  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 3
+//  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, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef COMMAND_PERMISSIONS_HPP
+#define COMMAND_PERMISSIONS_HPP
+
+enum CommandPermissions : unsigned int
+{
+    PE_NONE = 0,
+    PE_USUAL = 1,
+    PE_VOTED = 2,
+    PE_CROWNED = 4,
+    PE_SINGLE = 8,
+    PE_HAMMER = 16,
+    UP_HAMMER = PE_HAMMER,
+    UP_SINGLE = UP_HAMMER | PE_SINGLE,
+    UP_CROWNED = UP_SINGLE | PE_CROWNED,
+    UP_EVERYONE = UP_CROWNED | PE_USUAL
+};
+
+#endif // COMMAND_PERMISSIONS_HPP

src/network/protocols/command_voting.cpp

@@ -0,0 +1,141 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2021 kimden
+//
+//  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 3
+//  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, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "network/protocols/command_voting.hpp"
+#include "utils/random_generator.hpp"
+
+CommandVoting::CommandVoting(double threshold): m_threshold(threshold)
+{
+
+} // CommandVoting
+// ========================================================================
+
+void CommandVoting::castVote(std::string player, std::string category, std::string vote)
+{
+    uncastVote(player, category);
+    m_votes_by_player[player][category] = vote;
+    m_votes_by_poll[category][vote].insert(player);
+    m_need_check = true;
+    m_selected_category = category;
+    m_selected_option = vote;
+} // castVote
+// ========================================================================
+
+void CommandVoting::uncastVote(std::string player, std::string category)
+{
+    auto it = m_votes_by_player[player].find(category);
+    if (it != m_votes_by_player[player].end())
+    {
+        std::string previous_vote = it->second;
+        m_votes_by_poll[category][previous_vote].erase(player);
+    }
+    m_need_check = true;
+    m_selected_category = "";
+    m_selected_option = "";
+} // uncastVote
+// ========================================================================
+
+std::pair<int, std::map<std::string, std::string>> CommandVoting::process(std::multiset<std::string>& all_users)
+{
+    std::map<std::string, std::string> result;
+    int num_votes = 0;
+    int required_number;
+    for (const auto& p: m_votes_by_poll)
+    {
+        std::string category = p.first;
+        double category_threshold = m_threshold;
+        auto it = m_custom_thresholds.find(category);
+        if (it != m_custom_thresholds.end())
+            category_threshold = it->second;
+        required_number = std::max<int>(1, (int)ceil((double)all_users.size() * category_threshold));
+        std::map<std::string, int> category_results;
+        for (const std::string& user: all_users)
+        {
+            auto it = m_votes_by_player.find(user);
+            if (it == m_votes_by_player.end())
+                continue;
+            auto it2 = it->second.find(category);
+            if (it2 == it->second.end())
+                continue;
+            ++category_results[it2->second];
+        }
+        for (const auto& q: category_results)
+        {
+            if (category == m_selected_category && q.first == m_selected_option)
+                num_votes = q.second;
+            if (q.second >= required_number)
+            {
+                result[category] = q.first;
+                break;
+            }
+        }
+    }
+    m_need_check = false;
+    m_selected_category = "";
+    m_selected_option = "";
+    for (const auto& p: result)
+    {
+        std::string category = p.first;
+        reset(category);
+    }
+    return make_pair(num_votes, result);
+} // process
+// ========================================================================
+
+std::string CommandVoting::getAnyBest(std::string category)
+{
+    int best = 0;
+    std::vector<std::string> best_options;
+    for (auto& vote_to_set: m_votes_by_poll[category])
+    {
+        unsigned int count = vote_to_set.second.size();
+        std::string option = vote_to_set.first;
+        if (count > best)
+        {
+            best_options.clear();
+            best_options.push_back(option);
+        }
+        else if (count == best)
+        {
+            best_options.push_back(option);
+        }
+    }
+    if (best_options.empty())
+        return ""; // shouldn't happen mainly
+    RandomGenerator rg;
+    std::vector<std::string>::iterator it = best_options.begin();
+    std::advance(it, rg.get((int)best_options.size()));
+    return *it;
+} // getAnyBest
+// ========================================================================
+
+void CommandVoting::reset(std::string category)
+{
+    for (auto& vote_to_set: m_votes_by_poll[category])
+    {
+        std::string vote = vote_to_set.first;
+        auto& players = vote_to_set.second;
+        for (const std::string& player: players)
+        {
+            m_votes_by_player[player].erase(category);
+        }
+    }
+    m_votes_by_poll[category].clear();
+} // reset
+// ========================================================================
+