enable + disable commands

Author: notchyves

src/client/CMakeLists.txt

@@ -15,10 +15,14 @@ add_library(selaura_client SHARED
     memory/sdk/client/ClientInstanceScreenModel.cpp
     memory/sdk/game/ClientInstance.cpp
     memory/sdk/game/MinecraftGame.cpp
+    memory/sdk/network/LoopbackPacketSender.cpp
+    memory/sdk/client/renderer/rendergraph/Packet.cpp
     feature/impl/render/fullbright.cpp
     feature/impl/render/paperdoll.cpp
     feature/impl/render/enchant_glint.cpp
     feature/impl/render/environment.cpp
+    command/impl/enable_command.cpp
+    command/impl/disable_command.cpp
 )
 
 target_include_directories(selaura_client PRIVATE

src/client/client.cpp

@@ -17,12 +17,6 @@ namespace selaura {
             spdlog::set_pattern("[%T] [client/%^%l%$] %v");
             spdlog::flush_on(spdlog::level::info);
 
-            auto& feature_manager = this->get<selaura::feature_manager>();
-            feature_manager.for_each([]<typename T>(std::shared_ptr<T>& f) {
-                f->set_enabled(true);
-                spdlog::info("Module Loaded: {}", selaura::feature_traits<T>::name.c_str());
-            });
-
             selaura::patch_fns<
                 &MinecraftGame::update_hk,
                 &Dimension::Dimension_ctor_hk,
@@ -34,7 +28,8 @@ namespace selaura {
                 &Dimension::getTimeOfDay_hk,
                 &bgfx::d3d11::RendererContextD3D11::submit_hk,
                 &bgfx::d3d12::RendererContextD3D12::submit_hk,
-                &ClientInstanceScreenModel::executeCommand_hk
+                &ClientInstanceScreenModel::executeCommand_hk,
+                &LoopbackPacketSender::send_hk
             >();
 
             magic_enum::enum_for_each<MinecraftPacketIds>([](auto val) {

src/client/client.hpp

@@ -9,6 +9,7 @@
 
 #include "event/event_manager.hpp"
 #include "feature/feature_manager.hpp"
+#include "command/command_handler.hpp"
 #include "memory/signatures.hpp"
 
 #include "memory/sdk/game/MinecraftGame.hpp"
@@ -34,14 +35,14 @@ namespace selaura {
     };
 
 
-    struct client : public client_base<selaura::event_manager, selaura::feature_manager> {
+    struct client : public client_base<selaura::event_manager, selaura::feature_manager, selaura::command_handler> {
         void init();
         void unload();
     };
 
-    static inline std::shared_ptr<client> client_instance;
-    inline std::shared_ptr<client> get() {
-        return client_instance;
+    inline std::shared_ptr<client>& get() {
+        static std::shared_ptr<client> instance = std::make_shared<client>();
+        return instance;
     }
 
     inline MinecraftGame* minecraftGame;

src/client/command/command.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <tuple>
+#include <libhat/fixed_string.hpp>
+
+namespace selaura {
+    template <typename T>
+    struct command_traits {
+        static constexpr auto command = hat::fixed_string { "unknown" };
+    };
+
+    template <typename T>
+    struct command {
+        virtual ~command() = default;
+        using details = command_traits<T>;
+
+        virtual const std::string execute(std::vector<std::string> arguments) = 0;
+    };
+};

src/client/command/command_handler.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include <tuple>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <sstream>
+#include <algorithm>
+
+#include "impl/disable_command.hpp"
+#include "impl/enable_command.hpp"
+
+namespace selaura {
+    struct command_handler {
+        using default_commands_t = std::tuple<
+            enable_command,
+            disable_command
+        >;
+
+        inline std::string execute(std::string_view command_str) {
+            std::istringstream stream(std::string{command_str});
+            std::string verb;
+            stream >> verb;
+
+            if (verb.empty())
+                return "§cNo command entered.";
+
+            std::vector<std::string> args;
+            for (std::string arg; stream >> arg;)
+                args.emplace_back(std::move(arg));
+
+            return std::apply([&](auto&... cmds) -> std::string {
+                std::string result = "§cUnknown command: " + verb;
+                (..., (
+                    [&] {
+                        using T = std::decay_t<decltype(cmds)>;
+                        constexpr auto name = std::string_view{ command_traits<T>::command.c_str() };
+
+                        if (verb == name)
+                            result = cmds.execute(args);
+                    }()
+                ));
+                return result;
+            }, default_commands);
+        }
+
+    private:
+        default_commands_t default_commands;
+    };
+};

src/client/command/impl/disable_command.cpp

@@ -0,0 +1,50 @@
+#include "disable_command.hpp"
+
+#include <format>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include "../../client.hpp"
+
+namespace selaura {
+    const std::string disable_command::execute(std::vector<std::string> arguments) {
+        if (arguments.empty())
+            return "§cIncorrect syntax: .disable [module_name ...]";
+
+        auto& feature_manager = selaura::get()->get<selaura::feature_manager>();
+        std::vector<std::string> disabled_modules;
+
+        feature_manager.for_each([&]<typename T>(std::shared_ptr<T>& f) {
+            const std::string_view name = selaura::feature_traits<T>::name;
+
+            auto it = std::ranges::find_if(arguments, [&](const std::string& arg) {
+                return arg.size() == name.size() &&
+                    std::equal(arg.begin(), arg.end(), name.begin(), name.end(),
+                        [](char a, char b) {
+                            return std::tolower(static_cast<unsigned char>(a)) ==
+                                   std::tolower(static_cast<unsigned char>(b));
+                        });
+            });
+
+            if (it != arguments.end()) {
+                f->set_enabled(false);
+                disabled_modules.emplace_back(name);
+            }
+        });
+
+        if (disabled_modules.empty()) {
+            return "§cNo matching modules found to disable.";
+        }
+
+        std::string joined;
+        for (size_t i = 0; i < disabled_modules.size(); ++i) {
+            joined += disabled_modules[i];
+            if (i + 1 < disabled_modules.size()) {
+                joined += ", ";
+            }
+        }
+
+        return std::format("§aSuccessfully disabled modules: {}", joined);
+    }
+}

src/client/command/impl/disable_command.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "../command.hpp"
+
+namespace selaura {
+    struct disable_command;
+
+    template <>
+    struct command_traits<disable_command> {
+        static constexpr auto command = hat::fixed_string{ "disable" };
+    };
+
+    struct disable_command : command<disable_command> {
+        virtual const std::string execute(std::vector<std::string> arguments) override;
+    };
+};

src/client/command/impl/enable_command.cpp

@@ -0,0 +1,50 @@
+#include "enable_command.hpp"
+
+#include <format>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include "../../client.hpp"
+
+namespace selaura {
+    const std::string enable_command::execute(std::vector<std::string> arguments) {
+        if (arguments.empty())
+            return "§cIncorrect syntax: .enable [module_name ...]";
+
+        auto& feature_manager = selaura::get()->get<selaura::feature_manager>();
+        std::vector<std::string> enabled_modules;
+
+        feature_manager.for_each([&]<typename T>(std::shared_ptr<T>& f) {
+            const std::string_view name = selaura::feature_traits<T>::name;
+
+            auto it = std::ranges::find_if(arguments, [&](const std::string& arg) {
+                return arg.size() == name.size() &&
+                    std::equal(arg.begin(), arg.end(), name.begin(), name.end(),
+                        [](char a, char b) {
+                            return std::tolower(static_cast<unsigned char>(a)) ==
+                                   std::tolower(static_cast<unsigned char>(b));
+                        });
+            });
+
+            if (it != arguments.end()) {
+                f->set_enabled(true);
+                enabled_modules.emplace_back(name);
+            }
+        });
+
+        if (enabled_modules.empty()) {
+            return "§cNo matching modules found to enable.";
+        }
+
+        std::string joined;
+        for (size_t i = 0; i < enabled_modules.size(); ++i) {
+            joined += enabled_modules[i];
+            if (i + 1 < enabled_modules.size()) {
+                joined += ", ";
+            }
+        }
+
+        return std::format("§aSuccessfully enabled modules: {}", joined);
+    }
+}

src/client/command/impl/enable_command.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "../command.hpp"
+
+namespace selaura {
+    struct enable_command;
+
+    template <>
+    struct command_traits<enable_command> {
+        static constexpr auto command = hat::fixed_string{ "enable" };
+    };
+
+    struct enable_command : command<enable_command> {
+        virtual const std::string execute(std::vector<std::string> arguments) override;
+    };
+};

src/client/main.cpp

@@ -16,8 +16,7 @@ void init() {
     freopen_s(&fp, "CONOUT$", "w", stderr);
     freopen_s(&fp, "CONIN$", "r", stdin);
 #endif
-    selaura::client_instance = std::make_shared<selaura::client>();
-    selaura::client_instance->init();
+    selaura::get()->init();
 }
 
 #ifdef SELAURA_WINDOWS