feat: Game::preventDefault

Author: MiemieMethod

src/mod/PrimordialCore.cpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <algorithm>
 #include <any>
 #include <functional>
@@ -86,7 +88,19 @@ class CallbackManager {
         register_impl<Args...>(name, std::move(f), p);
     }
 
+    CallbackManager()                                  = default;
+    ~CallbackManager()                                 = default;
+    CallbackManager(const CallbackManager&)            = delete;
+    CallbackManager& operator=(const CallbackManager&) = delete;
+    CallbackManager(CallbackManager&&)                 = delete;
+    CallbackManager& operator=(CallbackManager&&)      = delete;
+
 public:
+    static CallbackManager& getInstance() {
+        static CallbackManager instance;
+        return instance;
+    }
+
     template <typename Callable>
     void addCallback(const std::string& name, Callable&& cb, int priority = 0) {
         using traits = function_traits<std::decay_t<Callable>>;

src/callback/CallbackManager.hpp src/pc/callback/CallbackManager.hppsrc/callback/CallbackManager.hpp renamed to src/pc/callback/CallbackManager.hpp

@@ -0,0 +1,131 @@
+#include "pc/mod/PrimordialCore.h"
+#include "pc/callback/CallbackManager.hpp"
+#include "pc/world/Game.h"
+
+#include "ll/api/mod/RegisterHelper.h"
+
+namespace primordial_core {
+
+void Hooked_OriginalFunction(CallbackManager& mgr, int damage) {
+    Game::EventScope scope;
+
+    mgr.invokeCallback("OnTakeDamage", damage);
+
+    if (scope.isPrevented()) {
+        std::cout << "Original default functionality was prevented by a callback!" << std::endl;
+        return; // 直接返回，从而阻止原函数的默认行为
+    }
+
+    std::cout << "Executing default original functionality. Damage: " << damage << std::endl;
+}
+
+PrimordialCore& PrimordialCore::getInstance() {
+    static PrimordialCore instance;
+    return instance;
+}
+
+bool PrimordialCore::load() {
+    getSelf().getLogger().debug("Loading...");
+    // Code for loading the mod goes here.
+
+    CallbackManager& mgr = CallbackManager::getInstance();
+
+    // 添加不同签名的事件
+    mgr.addCallback(
+        "OnLogin",
+        [](std::string user, int age) { std::cout << "[User] " << user << " logged in. Age: " << age << "\n"; },
+        10
+    );
+
+    mgr.addCallback("OnSystem", [](int code) { std::cout << "Code: " << code << "\n"; });
+
+    // 高优先级测试
+    mgr.addCallback(
+        "OnLogin",
+        [](std::string user, int) { std::cout << "[Admin] Priority check for " << user << "\n"; },
+        100
+    );
+
+    // 调用
+    std::cout << "--- Triggering Login ---\n";
+    // 注意：必须显式构造std::string，否则推导为const char*导致类型不匹配
+    mgr.invokeCallback("OnLogin", std::string("Alice"), 25);
+
+    std::cout << "\n--- Triggering System ---\n";
+    mgr.invokeCallback("OnSystem", 404);
+
+    // 回调 A：不阻止默认行为
+    mgr.addCallback("OnTakeDamage", [](int damage) { std::cout << "Callback A saw damage: " << damage << "\n"; }, 10);
+
+    // 回调 B：满足特定条件时阻止默认行为
+    mgr.addCallback(
+        "OnTakeDamage",
+        [](int damage) {
+            if (damage > 100) {
+                std::cout << "Callback B: Damage too high! Preventing default.\n";
+                Game::getInstance().preventDefault(); // 直接调用，无需返回特定类型
+            }
+        },
+        20
+    );
+
+    std::cout << "=== 测试1：不会被阻止（damage=50） ===\n";
+    Hooked_OriginalFunction(mgr, 50);
+
+    std::cout << "\n=== 测试2：会被回调 B 阻止（damage=150） ===\n";
+    Hooked_OriginalFunction(mgr, 150);
+
+    // 测试嵌套调用
+    std::cout << "\n=== 测试3：嵌套调用测试 ===\n";
+    mgr.addCallback(
+        "OnTakeDamage",
+        [&mgr](int damage) {
+            std::cout << "Callback C: Triggering nested event\n";
+            Game::EventScope scope;
+            mgr.invokeCallback("OnNestedEvent", damage);
+        },
+        30
+    );
+
+    mgr.addCallback("OnNestedEvent", [](int damage) {
+        std::cout << "Nested callback: Damage = " << damage << "\n";
+        // 这里调用 preventDefault 不会影响外层 OnTakeDamage 的状态
+        Game::getInstance().preventDefault();
+    });
+
+    {
+        Game::EventScope scope;
+        mgr.invokeCallback("OnTakeDamage", 200);
+        std::cout << "Outer scope prevented: " << (scope.isPrevented() ? "Yes" : "No") << std::endl;
+    }
+
+    {
+        Game::EventScope scope;
+        mgr.invokeCallback("OnTakeDamage", 20);
+        std::cout << "Outer scope prevented: " << (scope.isPrevented() ? "Yes" : "No") << std::endl;
+    }
+
+    return true;
+}
+
+bool PrimordialCore::enable() {
+    getSelf().getLogger().debug("Enabling...");
+    // Code for enabling the mod goes here.
+    return true;
+}
+
+bool PrimordialCore::disable() {
+    getSelf().getLogger().debug("Disabling...");
+    // Code for disabling the mod goes here.
+    return true;
+}
+
+bool PrimordialCore::unload() {
+    getSelf().getLogger().debug("Unloading...");
+    // Code for unloading the mod goes here.
+    return true;
+}
+
+} // namespace primordial_core
+
+LL_REGISTER_MOD(primordial_core::PrimordialCore, primordial_core::PrimordialCore::getInstance());

src/mod/MemoryOperators.cpp src/pc/mod/MemoryOperators.cppsrc/mod/MemoryOperators.cpp renamed to src/pc/mod/MemoryOperators.cpp

@@ -0,0 +1,29 @@
+#include "pc/world/Game.h"
+
+namespace primordial_core {
+
+thread_local std::vector<bool> Game::prevent_stack;
+
+Game& Game::getInstance() {
+    static Game instance;
+    return instance;
+}
+
+void Game::preventDefault() {
+    if (!prevent_stack.empty()) {
+        prevent_stack.back() = true;
+    }
+}
+
+bool Game::_isDefaultPrevented() const {
+    if (prevent_stack.empty()) return false;
+    return prevent_stack.back();
+}
+
+Game::EventScope::EventScope() { Game::prevent_stack.push_back(false); }
+
+Game::EventScope::~EventScope() { Game::prevent_stack.pop_back(); }
+
+bool Game::EventScope::isPrevented() const { return Game::getInstance()._isDefaultPrevented(); }
+
+} // namespace primordial_core

src/pc/mod/PrimordialCore.cpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <vector>
+
+namespace primordial_core {
+
+class Game {
+private:
+    Game()                       = default;
+    ~Game()                      = default;
+    Game(const Game&)            = delete;
+    Game& operator=(const Game&) = delete;
+    Game(Game&&)                 = delete;
+    Game& operator=(Game&&)      = delete;
+
+    static thread_local std::vector<bool> prevent_stack;
+
+public:
+    static Game& getInstance();
+
+    void preventDefault();
+    bool _isDefaultPrevented() const;
+
+    class EventScope {
+    public:
+        EventScope();
+        ~EventScope();
+
+        bool isPrevented() const;
+    };
+};
+
+} // namespace primordial_core

src/mod/PrimordialCore.h src/pc/mod/PrimordialCore.hsrc/mod/PrimordialCore.h renamed to src/pc/mod/PrimordialCore.h

@@ -29,7 +29,7 @@ target("primordial-core") -- Change this to your mod name.
     set_kind("shared")
     set_languages("c++20")
     set_symbols("debug")
-    add_headerfiles("src/**.h")
+    add_headerfiles("src/**.h", "src/**.hpp")
     add_files("src/**.cpp")
     add_includedirs("src")
     if is_config("target_type", "server") then