Added defered events to standard sys

Author: Gallasko

examples/Asteroid/application.cpp

@@ -33,7 +33,7 @@ StandardSystemImpl* createPlayerSystem()
         .onEvent("OnSDLScanCode", "res/asteroid/move_player.pg")
         .onEvent("OnSDLScanCodeReleased", "res/asteroid/release_player.pg")
         .onEvent("PlayerHit", "res/asteroid/handle_player_hit.pg")
-        .onEvent("RespawnPlayer", "res/asteroid/respawn_player.pg")
+        .onProcessEvent("RespawnPlayer", "res/asteroid/respawn_player.pg")
         .onDelta("res/asteroid/update_player.pg")  // Update physics every frame
         .build();
 }
@@ -46,38 +46,11 @@ StandardSystemImpl* createAsteroidSpawnTimerSystem()
             LOG_MILE(DOM, "AsteroidSpawnTimer initialized");
             sys->setData("spawnTimer", 0.0f);
         })
-        // .onDelta([](StandardSystemHandle* sys, float deltaTime)
-        // {
-        //     float timer = sys->getData("spawnTimer").get<float>();
-        //     timer += deltaTime;
-
-        //     if (timer > 10.0f)
-        //     {
-        //         timer -= 10.0f;
-        //         // for (int i = 0; i < 10; i++)
-        //             sys->sendEvent("SpawnAsteroid");
-        //     }
-
-        //     sys->setData("spawnTimer", timer);
-        // })
         .onEvent("GameOver", "res/asteroid/clear_asteroids.pg")
         .onDelta("res/asteroid/spawn_asteroid_timer.pg")
         .build();
 }
 
-// StandardSystemImpl* createAsteroidSystem()
-// {
-//     return createStandardSystem("AsteroidSystem")
-//         .onInit([](StandardSystemHandle* sys)
-//         {
-//             LOG_MILE(DOM, "AsteroidSystem initialized");
-//         })
-//         .ownComponent("Asteroid")
-//         .onEvent("SpawnAsteroid", "res/asteroid/spawn_single_asteroid.pg")
-//         .onDelta("res/asteroid/update_asteroids.pg")
-//         .build();
-// }
-
 StandardSystemImpl* createBulletSystem()
 {
     return createStandardSystem("BulletSystem")

src/Engine/ECS/ecsnativemodule.h

@@ -280,6 +280,46 @@ namespace pg
                 return vm->retainValue(args[0]);
             });
 
+            // onProcessEvent(eventName, scriptPath) - sets a script for a specific event
+            vm->addNativeMethod(klass, "onProcessEvent", [](VM* vm, int argCount, Value* args) -> Value {
+                if (argCount < 3)
+                {
+                    throw std::runtime_error("onEvent expects 2 arguments (eventName, scriptPath)");
+                }
+
+                ObjInstance* self = vm->asInstance(args[0]);
+
+                if (not IS_STRING(args[1]))
+                {
+                    throw std::runtime_error("onEvent expects event name to be a string");
+                }
+
+                if (not IS_STRING(args[2]))
+                {
+                    throw std::runtime_error("onEvent expects a string script path");
+                }
+
+                auto eventName = vm->asString(args[1]);
+                auto scriptPath = vm->asString(args[2]);
+
+                // Get or create the event scripts vector
+                Value eventScriptsVec = self->getField("__eventDeferedScripts");
+                ObjVector* eventScripts = vm->asVector(eventScriptsVec);
+
+                // Store as a pair: [eventName, scriptPath]
+                Value pair = vm->createVector();
+                ObjVector* pairVec = vm->asVector(pair);
+                pairVec->fields.push_back(vm->createString(eventName));
+                pairVec->fields.push_back(vm->createString(scriptPath));
+
+                eventScripts->fields.push_back(pair);
+
+                LOG_MILE("StandardSysClass", "Set event script for '" << eventName << "': " << scriptPath);
+
+                // Return self for chaining
+                return vm->retainValue(args[0]);
+            });
+
             // build() - finalizes and registers the system with the ECS
             vm->addNativeMethod(klass, "build", [ecsRefCopy](VM* vm, int argCount, Value* args) -> Value {
                 if (argCount < 1)
@@ -320,6 +360,19 @@ namespace pg
                     eventScriptMap[eventName] = scriptPath;
                 }
 
+                // Build event script map
+                _S_EventScriptMap eventDeferedScriptMap;
+                ObjVector* eventDeferedScripts = vm->asVector(self->getField("__eventDeferedScripts"));
+
+                for (Value pairVal : eventDeferedScripts->fields)
+                {
+                    ObjVector* pair = vm->asVector(pairVal);
+                    std::string eventName = vm->asString(pair->fields[0]);
+                    std::string scriptPath = vm->asString(pair->fields[1]);
+
+                    eventDeferedScriptMap[eventName] = scriptPath;
+                }
+
                 // Create the StandardSystemImpl
                 auto* systemImpl = new StandardSystemImpl(
                     systemName,
@@ -330,6 +383,7 @@ namespace pg
                     initScript, // initScriptPath
                     {}, // eventCallbackMap - empty, using scripts instead
                     eventScriptMap, // eventScriptMap
+                    eventDeferedScriptMap, // deferredEventScriptMap
                     nullptr, // executeCallback
                     executeScript, // executeScriptPath
                     nullptr, // saveCallback
@@ -682,6 +736,7 @@ namespace pg
                 systemInstance->setField("__executeScript", vm->createString(""));
                 systemInstance->setField("__deltaScript", vm->createString(""));
                 systemInstance->setField("__eventScripts", vm->createVector()); // Vector of [eventName, scriptPath] pairs
+                systemInstance->setField("__eventDeferedScripts", vm->createVector()); // Vector of [eventName, scriptPath] pairs
 
                 LOG_MILE("Ecs Compiled Module", "Created system builder for '" << systemName << "'");
 

src/Engine/ECS/entitysystem.h

@@ -354,7 +354,7 @@ namespace pg
             LOG_THIS_MEMBER("ECS");
 
             _unique_id sys1Id = registry.getTypeId(sysAfter);
-            _unique_id sys2Id = registry.getTypeId(sysBefore));
+            _unique_id sys2Id = registry.getTypeId(sysBefore);
 
             _succeed(sys1Id, sys2Id);
         }

src/Engine/ECS/standardsystem.cpp

@@ -254,6 +254,13 @@ namespace pg
         return *this;
     }
 
+    StandardSystemBuilder& StandardSystemBuilder::onProcessEvent(const std::string& eventName, const std::string& scriptName)
+    {
+        data.deferredScriptEventCallbackList[eventName] = scriptName;
+
+        return *this;
+    }
+
     StandardSystemBuilder& StandardSystemBuilder::onExecute(const std::string& scriptName)
     {
         data.executeScript = scriptName;
@@ -280,6 +287,7 @@ namespace pg
             data.initScript,
             data.eventCallbackList,
             data.scriptEventCallbackList,
+            data.deferredScriptEventCallbackList,
             data.executeCallback,
             data.executeScript,
             data.saveCallback,

src/Engine/ECS/standardsystem.h

@@ -115,6 +115,7 @@ namespace pg
         // Scripts overload
         StandardSystemBuilder& onInit(const std::string& scriptName);
         StandardSystemBuilder& onEvent(const std::string& eventName, const std::string& scriptName);
+        StandardSystemBuilder& onProcessEvent(const std::string& eventName, const std::string& scriptName);
         StandardSystemBuilder& onExecute(const std::string& scriptName);
         StandardSystemBuilder& onDelta(const std::string& scriptName);
 
@@ -135,6 +136,7 @@ namespace pg
 
             _S_EventMap eventCallbackList;
             _S_EventScriptMap scriptEventCallbackList;
+            _S_EventScriptMap deferredScriptEventCallbackList;
 
             _S_ExecuteCallback executeCallback;
             std::string executeScript;

src/Engine/ECS/system.cpp

@@ -320,12 +320,64 @@ namespace pg
             registry->addEventListener<TickEvent>(this);
         }
 
-        // Register event listeners
+        for (auto [eventName, scriptName] : deferredEventScriptCallbackList)
+        {
+            auto cachedBytecode = getCachedScript(ecsRef, scriptName, this);
+
+            if (cachedBytecode.empty())
+                continue;
+
+            std::string capturedScriptName = scriptName;
+
+            deferredEventCompiledScriptCallbackList.emplace(eventName, [this, cachedBytecode, capturedScriptName](StandardSystemHandle* sys, const StandardEvent& event) {
+                auto ecsRef = sys->getWorld();
+
+                VM vm;
+                ecsRef->setupVm(vm);
+
+                vm.addNativeModule("sys", SystemModule{this});
+
+                auto value = serializeToTable(&vm, event);
+                vm.globals["event"] = value;
+
+                auto result = interpretWithSysData(sys, vm, cachedBytecode);
+
+                if (result != InterpretResult::OK)
+                {
+                    LOG_ERROR("StandardSystemImpl", "Deferred event script handler error for: " << capturedScriptName);
+                    LOG_ERROR("StandardSystemImpl", "Interpret result: " << (result == InterpretResult::COMPILE_ERROR ? "COMPILE_ERROR" : "RUNTIME_ERROR"));
+                    LOG_ERROR("StandardSystemImpl", "Check VM error messages above for details");
+                }
+            });
+        }
+
+        // Register immediate event listeners
         for (const auto& eventName : listenedEvents)
         {
             registry->addStandardEventListener(eventName, this);
         }
 
+        // Register deferred event listeners via the same standard path.
+        // onEvent() will push them onto _deferredEventQueue instead of processing immediately.
+        for (const auto& eventName : listenedDeferredEvents)
+        {
+            registry->addStandardEventListener(eventName, this);
+        }
+
+        // Drain the deferred queue during _execute(), after cmdDispatcher has committed entity changes.
+        if (not listenedDeferredEvents.empty())
+        {
+            _executionQueue.emplace_back([this]()
+            {
+                while (not _deferredEventQueue.empty())
+                {
+                    auto event = _deferredEventQueue.front();
+                    _deferredEventQueue.pop();
+                    onProcessEvent(event);
+                }
+            });
+        }
+
         LOG_INFO("StandardSystemImpl", "System fully registered with " << componentOwners.size() << " components and " << listenedEvents.size() << " events");
 
         // Call onRegisterFinished to trigger init callbacks and scripts

src/Engine/ECS/system.h

@@ -176,6 +176,7 @@ namespace pg
                           const std::string& initScriptPath,
                           _S_EventMap eventMap,
                           _S_EventScriptMap eventScriptMap,
+                          _S_EventScriptMap deferredEventScriptMap,
                           _S_ExecuteCallback executeCb,
                           const std::string& executeScriptPath,
                           _S_SaveCallback saveCb,
@@ -186,6 +187,7 @@ namespace pg
                           systemName(name), ownedComponents(componentNames), defaultComponentValues(defaultComponentValues),
                           initCallback(initCb), initScript(initScriptPath),
                           eventCallbackList(eventMap), eventScriptCallbackList(eventScriptMap),
+                          deferredEventScriptCallbackList(deferredEventScriptMap),
                           executeCallback(executeCb), executeScript(executeScriptPath),
                           saveCallback(saveCb), loadCallback(loadCb), firstLoadCallback(firstLoadCb),
                           deltaCallback(deltaCb), deltaScript(deltaScriptPath)
@@ -200,6 +202,11 @@ namespace pg
                 listenedEvents.insert(key);
             }
 
+            for (auto [key, _] : deferredEventScriptMap)
+            {
+                listenedDeferredEvents.insert(key);
+            }
+
             handle._internalSystemPtr = this;
             if (saveLoadEnabled)
             {
@@ -225,6 +232,13 @@ namespace pg
         {
             LOG_THIS_MEMBER("StandardSystemImpl");
 
+            // Deferred events are queued and processed later during _execute()
+            if (listenedDeferredEvents.count(event.name))
+            {
+                _deferredEventQueue.push(event);
+                return;
+            }
+
             // Call user event callback
             auto it = eventCallbackList.find(event.name);
 
@@ -241,6 +255,18 @@ namespace pg
             }
         }
 
+        void onProcessEvent(const StandardEvent& event)
+        {
+            LOG_THIS_MEMBER("StandardSystemImpl");
+
+            auto it = deferredEventCompiledScriptCallbackList.find(event.name);
+
+            if (it != deferredEventCompiledScriptCallbackList.end())
+            {
+                it->second(&handle, event);
+            }
+        }
+
         void onEvent(const TickEvent& event);
 
         virtual void onRegisterFinished() override
@@ -375,6 +401,7 @@ namespace pg
     private:
         std::string systemName;
         std::set<std::string> listenedEvents;
+        std::set<std::string> listenedDeferredEvents;
         std::vector<std::string> ownedComponents;
         std::unordered_map<std::string, ElementMap> defaultComponentValues;
         std::unordered_map<std::string, Own<StandardComponent>*> componentOwners;
@@ -391,6 +418,10 @@ namespace pg
         _S_EventScriptMap eventScriptCallbackList;
         _S_EventMap eventCompiledScriptCallbackList;
 
+        _S_EventScriptMap deferredEventScriptCallbackList;
+        _S_EventMap deferredEventCompiledScriptCallbackList;
+        std::queue<StandardEvent> _deferredEventQueue;
+
         _S_ExecuteCallback executeCallback;
         std::string executeScript;
         _S_ExecuteCallback compiledExecuteScriptCallback;