Merge pull request #1128 from UE4SS-RE/eigtdelay

Adds comprehensive delayed action system

Author: narknon

UE4SS/include/LuaType/LuaThreadId.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <thread>
+
+#include <LuaType/LuaUObject.hpp>
+
+namespace RC::LuaType
+{
+    struct ThreadIdName
+    {
+        constexpr static const char* ToString()
+        {
+            return "ThreadId";
+        }
+    };
+    class ThreadId : public LocalObjectBase<std::thread::id, ThreadIdName>
+    {
+      private:
+        explicit ThreadId(std::thread::id object);
+
+      public:
+        ThreadId() = delete;
+        auto static construct(const LuaMadeSimple::Lua&, std::thread::id) -> const LuaMadeSimple::Lua::Table;
+        auto static construct(const LuaMadeSimple::Lua&, BaseObject&) -> const LuaMadeSimple::Lua::Table;
+
+      private:
+        auto static setup_metamethods(BaseObject&) -> void;
+
+    private:
+        template <LuaMadeSimple::Type::IsFinal is_final>
+        auto static setup_member_functions(LuaMadeSimple::Lua::Table&) -> void;
+    };
+} // namespace RC::LuaType

UE4SS/include/Mod/LuaMod.hpp

@@ -12,6 +12,7 @@
 #include <File/File.hpp>
 #include <LuaMadeSimple/LuaMadeSimple.hpp>
 #include <Mod/Mod.hpp>
+#include <SettingsManager.hpp>
 
 #include <String/StringType.hpp>
 
@@ -54,6 +55,35 @@ namespace RC
             int32_t lua_action_thread_ref{};
         };
 
+        // Status of a delayed action (mirrors UE's ETimerStatus)
+        enum class DelayedActionStatus : uint8_t
+        {
+            Pending,        // Created but not yet started
+            Active,         // Running, waiting for delay to expire
+            Paused,         // Timer paused, will resume when unpaused
+            Executing,      // Currently executing callback
+            PendingRemoval  // Marked for removal, will be cleaned up
+        };
+
+        struct DelayedGameThreadAction
+        {
+            const LuaMadeSimple::Lua* lua;
+            int32_t lua_action_function_ref{};
+            int32_t lua_action_thread_ref{};
+            GameThreadExecutionMethod method{GameThreadExecutionMethod::EngineTick};
+            DelayedActionStatus status{DelayedActionStatus::Active};
+            std::chrono::steady_clock::time_point execute_at{};  // Absolute time when action should execute
+            int64_t time_remaining_ms{0};  // Time remaining when paused (milliseconds)
+            int64_t frames_remaining{0};  // Countdown for frame-based delays
+            int64_t delay_ms{0};  // Original delay in milliseconds (for loop/reset)
+            int64_t delay_frames{0};  // Original delay in frames (0 means use time-based delay)
+            int64_t handle{0};  // Unique handle for this action
+            bool is_retriggerable{false};  // If true, can be reset by calling with same handle
+            bool is_looping{false};  // If true, re-schedule after each execution
+        };
+
+        static inline int64_t m_next_delayed_action_handle{1};
+
         struct AsyncAction
         {
             // TODO: Use LuaMadeSimple instead of lua_State*
@@ -111,6 +141,9 @@ namespace RC
         static inline std::unordered_map<File::StringType, LuaCallbackData> m_global_command_lua_callbacks;
         static inline std::unordered_map<File::StringType, LuaCallbackData> m_custom_command_lua_pre_callbacks;
         static inline std::vector<SimpleLuaAction> m_game_thread_actions{};
+        static inline std::vector<SimpleLuaAction> m_engine_tick_actions{};
+        static inline std::vector<DelayedGameThreadAction> m_delayed_game_thread_actions{};
+        static inline GameThreadExecutionMethod m_default_game_thread_method{GameThreadExecutionMethod::EngineTick};
         // This is storage that persists through hot-reloads.
         static inline std::unordered_map<std::string, SharedLuaVariable> m_shared_lua_variables{};
         static inline std::vector<FunctionHookData> m_custom_event_callbacks{};
@@ -131,9 +164,11 @@ namespace RC
 
       private:
         std::jthread m_async_thread;
+        std::thread::id m_main_thread_id{};
         bool m_processing_events{};
         bool m_pause_events_processing{};
         bool m_is_process_event_hooked{};
+        static inline bool m_is_engine_tick_hooked{};
         std::mutex m_actions_lock{};
 
       public:
@@ -147,6 +182,9 @@ namespace RC
         }
 
       private:
+        static auto ensure_engine_tick_hooked() -> void;
+        static auto ensure_process_event_hooked(LuaMod* mod) -> void;
+
         static auto custom_module_searcher(lua_State* L) -> int;
         auto setup_custom_module_loader(const LuaMadeSimple::Lua* lua_state) -> void;
         auto load_and_execute_script(const std::filesystem::path& script_path) -> bool;
@@ -179,6 +217,16 @@ namespace RC
             m_actions_lock.unlock();
         }
 
+        [[nodiscard]] RC_UE4SS_API auto get_async_thread_id() const -> std::thread::id
+        {
+            return m_async_thread.get_id();
+        }
+
+        [[nodiscard]] RC_UE4SS_API auto get_main_thread_id() const -> std::thread::id
+        {
+            return m_main_thread_id;
+        }
+
       public:
         // Called once when the program is starting, after mods are setup but before any mods have been started
         auto static on_program_start() -> void;

UE4SS/include/SettingsManager.hpp

@@ -7,9 +7,17 @@
 #include <File/File.hpp>
 #include <GUI/GUI.hpp>
 #include <Input/KeyDef.hpp>
+#include <Unreal/UnrealInitializer.hpp>
 
 namespace RC
 {
+    // Method for executing callbacks in game thread
+    enum class GameThreadExecutionMethod
+    {
+        ProcessEvent, // Use ProcessEvent hook
+        EngineTick    // Use Engine Tick hook (once per frame)
+    };
+
     class RC_UE4SS_API SettingsManager
     {
       public:
@@ -31,6 +39,7 @@ namespace RC
             StringType InputSource{STR("Default")};
             bool DoEarlyScan{false};
             bool SearchByAddress{false};
+            GameThreadExecutionMethod DefaultExecuteInGameThreadMethod{GameThreadExecutionMethod::EngineTick};
         } General;
 
         struct SectionEngineVersionOverride
@@ -102,6 +111,7 @@ namespace RC
             bool HookLocalPlayerExec{true};
             bool HookAActorTick{true};
             bool HookEngineTick{true};
+            Unreal::UnrealInitializer::FunctionResolveMethod EngineTickResolveMethod{Unreal::UnrealInitializer::FunctionResolveMethod::Scan};
             bool HookGameViewportClientTick{true};
             bool HookUObjectProcessEvent{true};
             bool HookProcessConsoleExec{true};

UE4SS/include/UE4SSProgram.hpp

@@ -272,6 +272,10 @@ namespace RC
         {
             return m_processing_events;
         }
+        [[nodiscard]] RC_UE4SS_API auto get_event_loop_thread_id() const -> std::thread::id
+        {
+            return m_event_loop_thread_id;
+        }
         RC_UE4SS_API auto is_event_loop_thread() -> bool
         {
             return std::this_thread::get_id() == m_event_loop_thread_id;

UE4SS/include/UE4SSRuntime.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <Common.hpp>
+
+namespace RC
+{
+    /**
+     * UE4SS Runtime Information
+     *
+     * This struct provides static functions to query UE4SS runtime state.
+     * These can be used by both C++ mods and Lua scripts to gracefully
+     * handle missing functionality or adapt behavior based on user configuration.
+     *
+     * Categories:
+     * - Hook availability: Whether AOB scans succeeded for various hooks
+     * - User preferences: Configuration choices that affect behavior
+     * - Feature availability: Whether certain engine features were found
+     */
+    struct RC_UE4SS_API UE4SSRuntime
+    {
+        // ========== Hook Availability ==========
+        // These check if the underlying functions were found during AOB scan.
+        // The actual detours are created lazily when callbacks are registered.
+
+        /**
+         * Check if the EngineTick function is available for hooking.
+         * This checks if the AOB scan found UEngine::Tick.
+         * Required for:
+         * - Frame-based delays (ExecuteInGameThreadAfterFrames, LoopInGameThreadAfterFrames)
+         * - ExecuteInGameThread with EGameThreadMethod.EngineTick
+         * @return true if EngineTick function was found and can be hooked
+         */
+        static auto IsEngineTickAvailable() -> bool;
+
+        /**
+         * Check if the ProcessEvent function is available for hooking.
+         * This checks if the AOB scan found UObject::ProcessEvent.
+         * Required for:
+         * - ExecuteInGameThread with EGameThreadMethod.ProcessEvent
+         * - RegisterHook functionality
+         * @return true if ProcessEvent function was found and can be hooked
+         */
+        static auto IsProcessEventAvailable() -> bool;
+
+        // Add more runtime checks here as needed, e.g.,:
+        // - User preferences (FavorVirtualWrappers vs FavorExplicitImplementation, etc.)
+        // - Feature availability (FText constructor found, specific UE version features, etc.)
+    };
+} // namespace RC

UE4SS/src/LuaType/LuaThreadId.cpp

@@ -0,0 +1,85 @@
+#include <limits>
+
+#include <fmt/std.h>
+#include <DynamicOutput/DynamicOutput.hpp>
+#include <Helpers/String.hpp>
+#include <LuaType/LuaThreadId.hpp>
+
+namespace RC::LuaType
+{
+    ThreadId::ThreadId(std::thread::id object) : LocalObjectBase<std::thread::id, ThreadIdName>(std::move(object))
+    {
+    }
+
+    auto ThreadId::construct(const LuaMadeSimple::Lua& lua, std::thread::id unreal_object) -> const LuaMadeSimple::Lua::Table
+    {
+        LuaType::ThreadId lua_object{unreal_object};
+
+        auto metatable_name = "ThreadIdUserdata";
+
+        LuaMadeSimple::Lua::Table table = lua.get_metatable(metatable_name);
+        if (lua.is_nil(-1))
+        {
+            lua.discard_value(-1);
+            lua.prepare_new_table();
+            setup_metamethods(lua_object);
+            setup_member_functions<LuaMadeSimple::Type::IsFinal::Yes>(table);
+            lua.new_metatable<LuaType::ThreadId>(metatable_name, lua_object.get_metamethods());
+        }
+
+        // Create object & surrender ownership to Lua
+        lua.transfer_stack_object(std::move(lua_object), metatable_name, lua_object.get_metamethods());
+
+        return table;
+    }
+
+    auto ThreadId::construct(const LuaMadeSimple::Lua& lua, BaseObject& construct_to) -> const LuaMadeSimple::Lua::Table
+    {
+        LuaMadeSimple::Lua::Table table = lua.prepare_new_table();
+
+        setup_member_functions<LuaMadeSimple::Type::IsFinal::No>(table);
+
+        setup_metamethods(construct_to);
+
+        return table;
+    }
+
+    auto ThreadId::setup_metamethods(BaseObject& base_object) -> void
+    {
+        base_object.get_metamethods().create(LuaMadeSimple::Lua::MetaMethod::Equal, []([[maybe_unused]] const LuaMadeSimple::Lua& lua) -> int {
+            if (!lua.is_userdata(1) || !lua.is_userdata(2))
+            {
+                lua.throw_error("ThreadId __eq metamethod called but there was not two userdata to compare");
+            }
+
+            auto a = lua.get_userdata<LuaType::ThreadId>();
+            auto b = lua.get_userdata<LuaType::ThreadId>();
+
+            return a.get_local_cpp_object() == b.get_local_cpp_object();
+        });
+    }
+
+    template <LuaMadeSimple::Type::IsFinal is_final>
+    auto ThreadId::setup_member_functions(LuaMadeSimple::Lua::Table& table) -> void
+    {
+        table.add_pair("ToString", [](const LuaMadeSimple::Lua& lua) -> int {
+            auto& lua_object = lua.get_userdata<ThreadId>();
+
+            lua.set_string(fmt::format("{}", lua_object.get_local_cpp_object()));
+
+            return 1;
+        });
+
+        if constexpr (is_final == LuaMadeSimple::Type::IsFinal::Yes)
+        {
+            table.add_pair("type", [](const LuaMadeSimple::Lua& lua) -> int {
+                lua.set_string(ClassName::ToString());
+                return 1;
+            });
+
+            // If this is the final object then we also want to finalize creating the table
+            // If not then it's the responsibility of the overriding object to call 'make_global()'
+            // table.make_global("ThreadIdUserdata");
+        }
+    }
+} // namespace RC::LuaType