feat(ecs): add repeat while condition and groups

core/include/cubos/core/ecs/cubos.hpp

@@ -72,6 +72,11 @@ namespace cubos::core::ecs
         /// @return Reference to this object, for chaining.
         TagBuilder& after(const std::string& tag);
 
+        /// @brief Makes the current tag inherit from given tag.
+        /// @param tag Tag to be inherited from.
+        /// @return Reference to this object, for chaining.
+        TagBuilder& tagged(const std::string& tag);
+
         /// @brief Adds a condition to the current tag. If this condition returns false, systems
         /// with this tag will not be executed. For the tagged systems to run, all conditions must
         /// return true.
@@ -80,6 +85,12 @@ namespace cubos::core::ecs
         template <typename F>
         TagBuilder& runIf(F func);
 
+        /// @brief Adds a repeat condition to the current tag, also making it a group.
+        /// @param func Condition function.
+        /// @return Reference to this object, for chaining.
+        template <typename F>
+        TagBuilder& repeatWhile(F func);
+
     private:
         World& mWorld;
         core::ecs::Dispatcher& mDispatcher;
@@ -316,6 +327,13 @@ namespace cubos::core::ecs
         return *this;
     }
 
+    template <typename F>
+    TagBuilder& TagBuilder::repeatWhile(F func)
+    {
+        mDispatcher.tagRepeatWhile(System<bool>::make(mWorld, std::move(func), {}));
+        return *this;
+    }
+
     template <typename R, typename... TArgs>
     Cubos& Cubos::addResource(TArgs... args)
     {

core/include/cubos/core/ecs/system/dispatcher.hpp

@@ -78,6 +78,13 @@ namespace cubos::core::ecs
         /// @param condition Condition to add.
         void tagAddCondition(ecs::System<bool> condition);
 
+        /// @brief Adds a repeat condition to the current tag.
+        /// @param func Condition to add.
+        void tagRepeatWhile(ecs::System<bool> condition);
+
+        /// @brief Adds a (sub)group to the current group.
+        void groupAddGroup();
+
         /// @brief Adds a system, and sets it as the current system for further configuration.
         /// @param system System to add.
         void addSystem(ecs::System<void> system);
@@ -86,6 +93,10 @@ namespace cubos::core::ecs
         /// @param tag Tag to run under.
         void systemAddTag(const std::string& tag);
 
+        /// @brief Links a system to a certain group.
+        /// @param grouptag Tag of the group.
+        void systemAddGroup(const std::string& grouptag);
+
         /// @brief Sets the current system to run after the tag.
         /// @param tag Tag to run after.
         void systemSetAfterTag(const std::string& tag);
@@ -108,7 +119,6 @@ namespace cubos::core::ecs
         /// @param cmds Command buffer.
         void callSystems(CommandBuffer& cmds);
 
-    private:
         struct Dependency;
         struct SystemSettings;
         struct System;
@@ -137,8 +147,128 @@ namespace cubos::core::ecs
             std::shared_ptr<SystemSettings> settings;
             ecs::System<void> system;
             std::unordered_set<std::string> tags;
+            std::string grouptag = "main";
+        };
+
+        class Step
+        {
+        public:
+            virtual ~Step() = default;
+            virtual void call(CommandBuffer& cmds, std::vector<ecs::System<bool>>& mConditions,
+                              std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> mRunConditions,
+                              std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> mRetConditions) = 0;
+        };
+
+        class SystemStep : public Step
+        {
+        public:
+            SystemStep(System* system)
+                : system(system)
+            {
+            }
+            void call(CommandBuffer& cmds, std::vector<ecs::System<bool>>& mConditions,
+                      std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> mRunConditions,
+                      std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> mRetConditions);
+
+            System* getSystem()
+            {
+                return system;
+            }
+
+        private:
+            System* system;
         };
 
+        class GroupStep : public Step, public std::enable_shared_from_this<Step>
+        {
+        public:
+            GroupStep(const std::string& grouptag, const std::shared_ptr<GroupStep> parent_step)
+                : grouptag(grouptag)
+                , parent_step(parent_step)
+            {
+            }
+            void call(CommandBuffer& cmds, std::vector<ecs::System<bool>>& mConditions,
+                      std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> mRunConditions,
+                      std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> mRetConditions);
+
+            void addSystemStep(System* system)
+            {
+                steps.insert(steps.begin(), std::make_shared<SystemStep>(system));
+            }
+
+            std::shared_ptr<GroupStep> addGroupStep(const std::string& grouptag,
+                                                    const std::shared_ptr<GroupStep>& parent)
+            {
+                std::shared_ptr<GroupStep> newStep = std::make_shared<GroupStep>(grouptag, parent);
+                steps.insert(steps.begin(), newStep);
+                return std::dynamic_pointer_cast<GroupStep>(steps[0]);
+            }
+
+            void moveToFront(const std::shared_ptr<Step>& step)
+            {
+                auto it = std::find(steps.begin(), steps.end(), step);
+                if (it != steps.end())
+                {
+                    std::rotate(steps.begin(), it, it + 1);
+                }
+            }
+
+            std::shared_ptr<GroupStep> FindGroup(const std::string& tag)
+            {
+                if (tag == grouptag)
+                {
+                    return std::dynamic_pointer_cast<GroupStep>(shared_from_this());
+                }
+                else
+                {
+                    for (const auto& step : this->steps)
+                    {
+                        if (auto groupStepPtr = std::dynamic_pointer_cast<GroupStep>(step))
+                        {
+                            return groupStepPtr->FindGroup(tag);
+                        }
+                    }
+                }
+                return nullptr;
+            }
+
+            void QueueSystem(const std::string& system_grouptag, System* system)
+            {
+                if (system_grouptag == this->grouptag)
+                {
+                    addSystemStep(system);
+
+                    if (this->grouptag != "main")
+                    {
+                        this->parent_step->moveToFront(shared_from_this());
+                    }
+                    return;
+                }
+                else
+                {
+                    for (const auto& step : this->steps)
+                    {
+                        if (auto groupStepPtr = std::dynamic_pointer_cast<GroupStep>(step))
+                        {
+                            groupStepPtr->QueueSystem(system_grouptag, system);
+                        }
+                    }
+                }
+            }
+
+            const std::string& getGroupTag()
+            {
+                return grouptag;
+            }
+            std::bitset<CUBOS_CORE_DISPATCHER_MAX_CONDITIONS> conditions;
+
+        private:
+            const std::string grouptag;
+            std::shared_ptr<GroupStep> parent_step;
+            std::vector<std::shared_ptr<Step>> steps;
+        };
+
+    private:
         /// @brief Internal class used to implement a DFS algorithm for call chain compilation
         struct DFSNode
         {
@@ -183,6 +313,8 @@ namespace cubos::core::ecs
         // Variables for holding information after call chain is compiled.
 
         std::vector<System*> mSystems; ///< Compiled order of running systems.
+        std::shared_ptr<GroupStep> mMainStep = std::make_shared<GroupStep>("main", nullptr);
+        std::shared_ptr<GroupStep> mCurrGroup = mMainStep;
     };
 
     inline void Dispatcher::tagAddCondition(ecs::System<bool> condition)
@@ -192,6 +324,14 @@ namespace cubos::core::ecs
         mTagSettings[mCurrTag]->conditions |= bit;
     }
 
+    inline void Dispatcher::tagRepeatWhile(ecs::System<bool> condition)
+    {
+        ENSURE_CURR_TAG();
+        groupAddGroup();
+        auto bit = assignConditionBit(std::move(condition));
+        mCurrGroup->conditions |= bit;
+    }
+
     inline void Dispatcher::addSystem(ecs::System<void> system)
     {
         // Wrap the system and put it in the pending queue

core/src/ecs/cubos.cpp

@@ -47,6 +47,12 @@ TagBuilder& TagBuilder::after(const std::string& tag)
     return *this;
 }
 
+TagBuilder& TagBuilder::tagged(const std::string& tag)
+{
+    mDispatcher.tagInheritTag(tag);
+    return *this;
+}
+
 Cubos& Cubos::addPlugin(void (*func)(Cubos&))
 {
     if (!mPlugins.contains(func))