features and events instead system priorities

README.md

@@ -41,73 +41,113 @@ target_link_libraries(your_project_target ecs.hpp)
 ## Basic usage
 
 ```cpp
-
 #include <ecs.hpp/ecs.hpp>
 namespace ecs = ecs_hpp;
 
+// events
+
+struct update_event {
+    float dt{};
+};
+
+struct render_event {
+    std::string camera;
+};
+
+// components
+
 struct movable {};
 struct disabled {};
 
+struct sprite {
+    std::string name;
+};
+
 struct position {
     float x{};
     float y{};
 };
 
 struct velocity {
-    float dx{};
+    float x{};
-    float dy{};
+    float y{};
 };
 
-class movement_system : public ecs::system {
+// systems
-public:
-    void process(ecs::registry& owner) override {
-        owner.for_joined_components<
-            position,
-            velocity
-        >([](ecs::entity, position& p, const velocity& v) {
-            p.x += v.dx;
-            p.y += v.dy;
-        }, ecs::exists<movable>{} && !ecs::exists<disabled>{});
-    }
-};
 
-class gravity_system : public ecs::system {
+class gravity_system : public ecs::system<update_event> {
 public:
     gravity_system(float gravity)
     : gravity_(gravity) {}
 
-    void process(ecs::registry& owner) override {
+    void process(ecs::registry& world, const update_event& evt) override {
-        owner.for_each_component<
+        world.for_each_component<velocity>(
-            velocity
+        [this, &evt](ecs::entity, velocity& vel) {
-        >([this](ecs::entity e, velocity& v) {
+            vel.x += gravity_ * evt.dt;
-            v.dx += gravity_;
+            vel.y += gravity_ * evt.dt;
-            v.dy += gravity_;
+        }, ecs::exists<movable>{} && !ecs::exists<disabled>{});
-        }, !ecs::exists<disabled>{});
     }
 private:
     float gravity_{};
 };
 
+class movement_system : public ecs::system<update_event> {
+public:
+    void process(ecs::registry& world, const update_event& evt) override {
+        world.for_joined_components<position, velocity>(
+        [&evt](ecs::entity, position& pos, const velocity& vel) {
+            pos.x += vel.x * evt.dt;
+            pos.y += vel.y * evt.dt;
+        }, ecs::exists<movable>{} && !ecs::exists<disabled>{});
+    }
+};
+
+class render_system : public ecs::system<render_event> {
+public:
+    void process(ecs::registry& world, const render_event& evt) override {
+        world.for_joined_components<sprite, position>(
+        [&evt](ecs::entity, const sprite& s, const position& p) {
+            std::cout << "Render sprite:" << std::endl;
+            std::cout << "--> pos: " << p.x << "," << p.y << std::endl;
+            std::cout << "--> sprite: " << s.name << std::endl;
+            std::cout << "--> camera: " << evt.camera << std::endl;
+        }, !ecs::exists<disabled>{});
+    }
+};
+
+// world
+
 ecs::registry world;
 
-ecs::registry_filler(world)
+struct physics_feature {};
-    .system<movement_system>(0)
+world.assign_feature<physics_feature>()
-    .system<gravity_system>(1, 9.8f);
+    .add_system<movement_system>()
+    .add_system<gravity_system>(9.8f);
+
+struct rendering_feature {};
+world.assign_feature<rendering_feature>()
+    .add_system<render_system>();
+
+// entities
 
 auto entity_one = world.create_entity();
 ecs::entity_filler(entity_one)
     .component<movable>()
+    .component<sprite>("ship")
     .component<position>(4.f, 2.f)
     .component<velocity>(10.f, 20.f);
 
 auto entity_two = world.create_entity();
 ecs::entity_filler(entity_two)
     .component<movable>()
-    .component<disabled>()
+    .component<sprite>("player")
     .component<position>(4.f, 2.f)
     .component<velocity>(10.f, 20.f);
 
-world.process_all_systems();
+// processing
+
+world.process_event(update_event{0.1f});
+world.process_event(render_event{"main"});
 ```
 
 ## API

headers/ecs.hpp/ecs.hpp

@@ -39,7 +39,9 @@ namespace ecs_hpp
 
     class prototype;
 
+    template < typename Event >
     class system;
+    class feature;
     class registry;
 
     template < typename T >
@@ -61,14 +63,12 @@ namespace ecs_hpp
     class aspect;
 
     class entity_filler;
-    class registry_filler;
 }
 
 namespace ecs_hpp
 {
     using family_id = std::uint16_t;
     using entity_id = std::uint32_t;
-    using priority_t = std::int32_t;
 
     constexpr std::size_t entity_id_index_bits = 22u;
     constexpr std::size_t entity_id_version_bits = 10u;
@@ -1244,10 +1244,55 @@ namespace ecs_hpp
 
 namespace ecs_hpp
 {
-    class system {
+    namespace detail
+    {
+        class system_base {
+        public:
+            virtual ~system_base() = default;
+        };
+    }
+
+    template < typename Event >
+    class system : public detail::system_base {
     public:
-        virtual ~system() = default;
+        using event_type = Event;
-        virtual void process(registry& owner) = 0;
+        virtual void process(registry& owner, const Event& event) = 0;
+    };
+}
+
+// -----------------------------------------------------------------------------
+//
+// feature
+//
+// -----------------------------------------------------------------------------
+
+namespace ecs_hpp
+{
+    class feature final {
+    public:
+        feature() = default;
+
+        feature(const feature&) = delete;
+        feature& operator=(const feature&) = delete;
+
+        feature(feature&&) noexcept = default;
+        feature& operator=(feature&&) noexcept = default;
+
+        feature& enable() noexcept;
+        feature& disable() noexcept;
+
+        bool is_enabled() const noexcept;
+        bool is_disabled() const noexcept;
+
+        template < typename T, typename... Args >
+        feature& add_system(Args&&... args);
+        template < typename Event >
+        feature& process_event(registry& owner, const Event& event);
+    private:
+        bool disabled_{false};
+        mutable detail::incremental_locker base_systems_locker_;
+        using system_uptr = std::unique_ptr<detail::system_base>;
+        std::vector<std::pair<family_id, system_uptr>> base_systems_;
     };
 }
 
@@ -1383,13 +1428,23 @@ namespace ecs_hpp
         template < typename... Ts, typename F, typename... Opts >
         void for_joined_components(F&& f, Opts&&... opts) const;
 
-        template < typename T, typename... Args >
+        template < typename Tag, typename... Args >
-        void add_system(priority_t priority, Args&&... args);
+        feature& assign_feature(Args&&... args);
 
-        void process_all_systems();
+        template < typename Tag, typename... Args >
-        void process_systems_above(priority_t min);
+        feature& ensure_feature(Args&&... args);
-        void process_systems_below(priority_t max);
+
-        void process_systems_in_range(priority_t min, priority_t max);
+        template < typename Tag >
+        bool has_feature() const noexcept;
+
+        template < typename Tag >
+        feature& get_feature();
+
+        template < typename Tag >
+        const feature& get_feature() const;
+
+        template < typename Event >
+        registry& process_event(const Event& event);
 
         struct memory_usage_info {
             std::size_t entities{0u};
@@ -1481,14 +1536,15 @@ namespace ecs_hpp
     private:
         entity_id last_entity_id_{0u};
         std::vector<entity_id> free_entity_ids_;
+
         mutable detail::incremental_locker entity_ids_locker_;
         detail::sparse_set<entity_id, detail::entity_id_indexer> entity_ids_;
 
         using storage_uptr = std::unique_ptr<detail::component_storage_base>;
         detail::sparse_map<family_id, storage_uptr> storages_;
 
-        using system_uptr = std::unique_ptr<system>;
+        mutable detail::incremental_locker features_locker_;
-        std::vector<std::pair<priority_t, system_uptr>> systems_;
+        detail::sparse_map<family_id, feature> features_;
     };
 }
 
@@ -1729,22 +1785,6 @@ namespace ecs_hpp
     private:
         entity& entity_;
     };
-
-    class registry_filler final {
-    public:
-        registry_filler(registry& registry) noexcept
-        : registry_(registry) {}
-
-        template < typename T, typename... Args >
-        registry_filler& system(priority_t priority, Args&&... args) {
-            registry_.add_system<T>(
-                priority,
-                std::forward<Args>(args)...);
-            return *this;
-        }
-    private:
-        registry& registry_;
-    };
 }
 
 // -----------------------------------------------------------------------------
@@ -2310,6 +2350,55 @@ namespace ecs_hpp
     }
 }
 
+// -----------------------------------------------------------------------------
+//
+// feature impl
+//
+// -----------------------------------------------------------------------------
+
+namespace ecs_hpp
+{
+    inline feature& feature::enable() noexcept {
+        disabled_ = false;
+        return *this;
+    }
+
+    inline feature& feature::disable() noexcept {
+        disabled_ = true;
+        return *this;
+    }
+
+    inline bool feature::is_enabled() const noexcept {
+        return !disabled_;
+    }
+
+    inline bool feature::is_disabled() const noexcept {
+        return disabled_;
+    }
+
+    template < typename T, typename... Args >
+    feature& feature::add_system(Args&&... args) {
+        assert(!base_systems_locker_.is_locked());
+        base_systems_.push_back({
+            detail::type_family<typename T::event_type>::id(),
+            std::make_unique<T>(std::forward<Args>(args)...)});
+        return *this;
+    }
+
+    template < typename Event >
+    feature& feature::process_event(registry& owner, const Event& event) {
+        const auto event_id = detail::type_family<Event>::id();
+        detail::incremental_lock_guard lock(base_systems_locker_);
+        for ( const auto& [system_event_id, base_system] : base_systems_ ) {
+            if ( event_id == system_event_id ) {
+                auto system_ptr = static_cast<system<Event>*>(base_system.get());
+                system_ptr->process(owner, event);
+            }
+        }
+        return *this;
+    }
+}
+
 // -----------------------------------------------------------------------------
 //
 // registry impl
@@ -2691,45 +2780,59 @@ namespace ecs_hpp
             std::forward<Opts>(opts)...);
     }
 
-    template < typename T, typename... Args >
+    template < typename Tag, typename... Args >
-    void registry::add_system(priority_t priority, Args&&... args) {
+    feature& registry::assign_feature(Args&&... args) {
-        auto iter = std::upper_bound(
+        const auto feature_id = detail::type_family<Tag>::id();
-            systems_.begin(), systems_.end(), priority,
+        if ( feature* f = features_.find(feature_id) ) {
-            [](priority_t pr, const auto& r){
+            return *f = feature{std::forward<Args>(args)...};
-                return pr < r.first;
-            });
-        systems_.insert(
-            iter,
-            std::make_pair(priority, std::make_unique<T>(std::forward<Args>(args)...)));
-    }
-
-    inline void registry::process_all_systems() {
-        process_systems_in_range(
-            std::numeric_limits<priority_t>::min(),
-            std::numeric_limits<priority_t>::max());
-    }
-
-    inline void registry::process_systems_above(priority_t min) {
-        process_systems_in_range(
-            min,
-            std::numeric_limits<priority_t>::max());
-    }
-
-    inline void registry::process_systems_below(priority_t max) {
-        process_systems_in_range(
-            std::numeric_limits<priority_t>::min(),
-            max);
-    }
-
-    inline void registry::process_systems_in_range(priority_t min, priority_t max) {
-        const auto first = std::lower_bound(
-            systems_.begin(), systems_.end(), min,
-            [](const auto& p, priority_t pr) noexcept {
-                return p.first < pr;
-            });
-        for ( auto iter = first; iter != systems_.end() && iter->first <= max; ++iter ) {
-            iter->second->process(*this);
         }
+        assert(!features_locker_.is_locked());
+        return *features_.insert(feature_id, feature()).first;
+    }
+
+    template < typename Tag, typename... Args >
+    feature& registry::ensure_feature(Args&&... args) {
+        const auto feature_id = detail::type_family<Tag>::id();
+        if ( feature* f = features_.find(feature_id) ) {
+            return *f;
+        }
+        assert(!features_locker_.is_locked());
+        return *features_.insert(feature_id, feature{std::forward<Args>(args)...}).first;
+    }
+
+    template < typename Tag >
+    bool registry::has_feature() const noexcept {
+        const auto feature_id = detail::type_family<Tag>::id();
+        return features_.has(feature_id);
+    }
+
+    template < typename Tag >
+    feature& registry::get_feature() {
+        const auto feature_id = detail::type_family<Tag>::id();
+        if ( feature* f = features_.find(feature_id) ) {
+            return *f;
+        }
+        throw std::logic_error("ecs_hpp::registry (feature not found)");
+    }
+
+    template < typename Tag >
+    const feature& registry::get_feature() const {
+        const auto feature_id = detail::type_family<Tag>::id();
+        if ( const feature* f = features_.find(feature_id) ) {
+            return *f;
+        }
+        throw std::logic_error("ecs_hpp::registry (feature not found)");
+    }
+
+    template < typename Event >
+    registry& registry::process_event(const Event& event) {
+        detail::incremental_lock_guard lock(features_locker_);
+        for ( const auto family : features_ ) {
+            if ( feature& f = features_.get(family); f.is_enabled() ) {
+                f.process_event(*this, event);
+            }
+        }
+        return *this;
     }
 
     inline registry::memory_usage_info registry::memory_usage() const noexcept {

untests/ecs_readme.cpp

@@ -0,0 +1,121 @@
+/*******************************************************************************
+ * This file is part of the "https://github.com/blackmatov/ecs.hpp"
+ * For conditions of distribution and use, see copyright notice in LICENSE.md
+ * Copyright (C) 2018-2019, by Matvey Cherevko (blackmatov@gmail.com)
+ ******************************************************************************/
+
+#include <catch2/catch.hpp>
+
+#include <ecs.hpp/ecs.hpp>
+namespace ecs = ecs_hpp;
+
+#include <string>
+#include <iostream>
+
+TEST_CASE("example") {
+
+    // events
+
+    struct update_event {
+        float dt{};
+    };
+
+    struct render_event {
+        std::string camera;
+    };
+
+    // components
+
+    struct movable {};
+    struct disabled {};
+
+    struct sprite {
+        std::string name;
+    };
+
+    struct position {
+        float x{};
+        float y{};
+    };
+
+    struct velocity {
+        float x{};
+        float y{};
+    };
+
+    // systems
+
+    class gravity_system : public ecs::system<update_event> {
+    public:
+        gravity_system(float gravity)
+        : gravity_(gravity) {}
+
+        void process(ecs::registry& world, const update_event& evt) override {
+            world.for_each_component<velocity>(
+            [this, &evt](ecs::entity, velocity& vel) {
+                vel.x += gravity_ * evt.dt;
+                vel.y += gravity_ * evt.dt;
+            }, ecs::exists<movable>{} && !ecs::exists<disabled>{});
+        }
+    private:
+        float gravity_{};
+    };
+
+    class movement_system : public ecs::system<update_event> {
+    public:
+        void process(ecs::registry& world, const update_event& evt) override {
+            world.for_joined_components<position, velocity>(
+            [&evt](ecs::entity, position& pos, const velocity& vel) {
+                pos.x += vel.x * evt.dt;
+                pos.y += vel.y * evt.dt;
+            }, ecs::exists<movable>{} && !ecs::exists<disabled>{});
+        }
+    };
+
+    class render_system : public ecs::system<render_event> {
+    public:
+        void process(ecs::registry& world, const render_event& evt) override {
+            world.for_joined_components<sprite, position>(
+            [&evt](ecs::entity, const sprite& s, const position& p) {
+                std::cout << "Render sprite:" << std::endl;
+                std::cout << "--> pos: " << p.x << "," << p.y << std::endl;
+                std::cout << "--> sprite: " << s.name << std::endl;
+                std::cout << "--> camera: " << evt.camera << std::endl;
+            }, !ecs::exists<disabled>{});
+        }
+    };
+
+    // world
+
+    ecs::registry world;
+
+    struct physics_feature {};
+    world.assign_feature<physics_feature>()
+        .add_system<movement_system>()
+        .add_system<gravity_system>(9.8f);
+
+    struct rendering_feature {};
+    world.assign_feature<rendering_feature>()
+        .add_system<render_system>();
+
+    // entities
+
+    auto entity_one = world.create_entity();
+    ecs::entity_filler(entity_one)
+        .component<movable>()
+        .component<sprite>("ship")
+        .component<position>(4.f, 2.f)
+        .component<velocity>(10.f, 20.f);
+
+    auto entity_two = world.create_entity();
+    ecs::entity_filler(entity_two)
+        .component<movable>()
+        .component<sprite>("player")
+        .component<position>(4.f, 2.f)
+        .component<velocity>(10.f, 20.f);
+
+    // processing
+
+    world.process_event(update_event{0.1f});
+    world.process_event(render_event{"main"});
+}

untests/ecs_tests.cpp

@@ -60,14 +60,19 @@ namespace
 TEST_CASE("detail") {
     SECTION("get_type_id") {
         using namespace ecs::detail;
-        REQUIRE(type_family<position_c>::id() == 1u);
-        REQUIRE(type_family<position_c>::id() == 1u);
 
-        REQUIRE(type_family<velocity_c>::id() == 2u);
+        const auto p_id = type_family<position_c>::id();
-        REQUIRE(type_family<velocity_c>::id() == 2u);
+        REQUIRE(p_id == type_family<position_c>::id());
 
-        REQUIRE(type_family<position_c>::id() == 1u);
+        const auto v_id = type_family<velocity_c>::id();
-        REQUIRE(type_family<velocity_c>::id() == 2u);
+        REQUIRE(v_id == type_family<velocity_c>::id());
+
+        REQUIRE(type_family<position_c>::id() == type_family<position_c>::id());
+        REQUIRE(type_family<velocity_c>::id() == type_family<velocity_c>::id());
+        REQUIRE_FALSE(type_family<position_c>::id() == type_family<velocity_c>::id());
+
+        REQUIRE(p_id == type_family<position_c>::id());
+        REQUIRE(v_id == type_family<velocity_c>::id());
     }
     SECTION("tuple_tail") {
         using namespace ecs::detail;
@@ -1463,88 +1468,128 @@ TEST_CASE("registry") {
         }
     }
     SECTION("systems") {
-        {
+        struct update_evt {
-            class movement_system : public ecs::system {
+            int dt{};
-            public:
+        };
-                void process(ecs::registry& owner) override {
-                    owner.for_joined_components<position_c, velocity_c>([](
-                        ecs::entity, position_c& p, const velocity_c& v)
-                    {
-                        p.x += v.x;
-                        p.y += v.y;
-                    });
-                }
-            };
 
-            ecs::registry w;
+        class gravity_system : public ecs::system<update_evt> {
-            w.add_system<movement_system>(0);
+        public:
+            gravity_system(int g)
+            : g_(g) {}
 
-            auto e1 = w.create_entity();
+            void process(ecs::registry& owner, const update_evt& evt) override {
-            auto e2 = w.create_entity();
+                owner.for_each_component<
+                    velocity_c
+                >([this, &evt](ecs::entity, velocity_c& v) {
+                    v.x += g_ * evt.dt;
+                    v.y += g_ * evt.dt;
+                }, !ecs::exists<disabled_c>{});
+            }
+        private:
+            int g_{};
+        };
 
-            e1.assign_component<position_c>(1, 2);
+        class movement_system : public ecs::system<update_evt> {
-            e1.assign_component<velocity_c>(3, 4);
+        public:
-            e2.assign_component<position_c>(5, 6);
+            void process(ecs::registry& owner, const update_evt& evt) override {
-            e2.assign_component<velocity_c>(7, 8);
+                owner.for_joined_components<position_c, velocity_c>([&evt](
+                    ecs::entity, position_c& p, const velocity_c& v)
+                {
+                    p.x += v.x * evt.dt;
+                    p.y += v.y * evt.dt;
+                }, !ecs::exists<disabled_c>{});
+            }
+        };
 
-            w.process_all_systems();
+        ecs::registry w;
+        REQUIRE_FALSE(w.has_feature<struct physics>());
 
-            REQUIRE(e1.get_component<position_c>().x == 1 + 3);
+        w.assign_feature<struct physics>()
-            REQUIRE(e1.get_component<position_c>().y == 2 + 4);
+            .add_system<gravity_system>(9);
 
-            REQUIRE(e2.get_component<position_c>().x == 5 + 7);
+        REQUIRE(w.has_feature<struct physics>());
-            REQUIRE(e2.get_component<position_c>().y == 6 + 8);
-        }
-        {
-            class system_n : public ecs::system {
-            public:
-                system_n(int& i, int n) : i_(i), n_(n) {}
-                void process(ecs::registry&) override {
-                    i_ += n_;
-                }
-            private:
-                int& i_;
-                int n_;
-            };
 
-            int i = 0;
+        w.ensure_feature<struct physics>()
-            ecs::registry w;
+            .add_system<movement_system>();
-            w.add_system<system_n>(20, std::ref(i), 2);
-            w.add_system<system_n>(10, std::ref(i), 1);
-            REQUIRE(i == 0);
-            w.process_all_systems();
-            REQUIRE(i == 3);
-            w.process_systems_below(10);
-            REQUIRE(i == 4);
-            w.process_systems_above(20);
-            REQUIRE(i == 6);
-            w.process_systems_below(20);
-            REQUIRE(i == 9);
-            w.process_systems_above(10);
-            REQUIRE(i == 12);
 
-            w.process_systems_below(9);
+        REQUIRE(w.has_feature<struct physics>());
-            w.process_systems_above(21);
-            REQUIRE(i == 12);
 
-            w.process_systems_in_range(0, 9);
+        ecs::entity e = w.create_entity();
-            w.process_systems_in_range(11, 19);
+        e.assign_component<position_c>(1,2);
-            w.process_systems_in_range(21, 30);
+        e.assign_component<velocity_c>(3,4);
-            REQUIRE(i == 12);
 
-            w.process_systems_in_range(0, 10);
+        w.get_feature<struct physics>().disable();
-            REQUIRE(i == 13);
+        w.process_event(update_evt{2});
-            w.process_systems_in_range(10, 19);
+
-            REQUIRE(i == 14);
+        REQUIRE(e.get_component<position_c>().x == 1);
-            w.process_systems_in_range(10, 20);
+        REQUIRE(e.get_component<position_c>().y == 2);
-            REQUIRE(i == 17);
+
-            w.process_systems_in_range(20, 30);
+        w.get_feature<struct physics>().enable();
-            REQUIRE(i == 19);
+        w.process_event(update_evt{2});
-            w.process_systems_in_range(10, 20);
+
-            REQUIRE(i == 22);
+        REQUIRE(e.get_component<position_c>().x == 1 + (3 + 9 * 2) * 2);
-            w.process_systems_in_range(0, 30);
+        REQUIRE(e.get_component<position_c>().y == 2 + (4 + 9 * 2) * 2);
-            REQUIRE(i == 25);
+    }
-        }
+    SECTION("recursive_systems") {
+        struct update_evt {
+            int dt{};
+        };
+
+        struct physics_evt {
+            update_evt parent_evt{};
+        };
+
+        class gravity_system : public ecs::system<physics_evt> {
+        public:
+            gravity_system(int g)
+            : g_(g) {}
+
+            void process(ecs::registry& owner, const physics_evt& evt) override {
+                owner.for_each_component<
+                    velocity_c
+                >([this, &evt](ecs::entity, velocity_c& v) {
+                    v.x += g_ * evt.parent_evt.dt;
+                    v.y += g_ * evt.parent_evt.dt;
+                }, !ecs::exists<disabled_c>{});
+            }
+        private:
+            int g_{};
+        };
+
+        class movement_system : public ecs::system<physics_evt> {
+        public:
+            void process(ecs::registry& owner, const physics_evt& evt) override {
+                owner.for_joined_components<position_c, velocity_c>([&evt](
+                    ecs::entity, position_c& p, const velocity_c& v)
+                {
+                    p.x += v.x * evt.parent_evt.dt;
+                    p.y += v.y * evt.parent_evt.dt;
+                }, !ecs::exists<disabled_c>{});
+            }
+        };
+
+        class physics_system : public ecs::system<update_evt> {
+        public:
+            void process(ecs::registry& owner, const update_evt& evt) override {
+                owner.process_event(physics_evt{evt});
+            }
+        };
+
+        ecs::registry w;
+
+        w.assign_feature<struct physics>()
+            .add_system<gravity_system>(9)
+            .add_system<movement_system>()
+            .add_system<physics_system>();
+
+        ecs::entity e = w.create_entity();
+        e.assign_component<position_c>(1,2);
+        e.assign_component<velocity_c>(3,4);
+
+        w.process_event(update_evt{2});
+
+        REQUIRE(e.get_component<position_c>().x == 1 + (3 + 9 * 2) * 2);
+        REQUIRE(e.get_component<position_c>().y == 2 + (4 + 9 * 2) * 2);
     }
     SECTION("fillers") {
         struct component_n {
@@ -1552,10 +1597,12 @@ TEST_CASE("registry") {
             component_n(int ni) : i(ni) {}
         };
 
-        class system_n : public ecs::system {
+        struct update_evt {};
+
+        class system_n : public ecs::system<update_evt> {
         public:
             system_n(int n) : n_(n) {}
-            void process(ecs::registry& owner) override {
+            void process(ecs::registry& owner, const update_evt&) override {
                 owner.for_each_component<component_n>(
                     [this](const ecs::const_entity&, component_n& c) noexcept {
                         c.i += n_;
@@ -1566,9 +1613,9 @@ TEST_CASE("registry") {
         };
         {
             ecs::registry w;
-            ecs::registry_filler(w)
+            w.assign_feature<struct physics>()
-                .system<system_n>(0, 1)
+                .add_system<system_n>(1)
-                .system<system_n>(0, 2);
+                .add_system<system_n>(2);
 
             ecs::entity e1 = w.create_entity();
             ecs::entity_filler(e1)
@@ -1579,7 +1626,7 @@ TEST_CASE("registry") {
             ecs::entity_filler(e2)
                 .component<component_n>(2);
 
-            w.process_all_systems();
+            w.process_event(update_evt{});
 
             REQUIRE(e1.get_component<component_n>().i == 4);
             REQUIRE(e2.get_component<component_n>().i == 5);
@@ -1682,69 +1729,3 @@ TEST_CASE("registry") {
         });
     }
 }
-
-TEST_CASE("example") {
-    struct movable {};
-    struct disabled {};
-
-    struct position {
-        float x{};
-        float y{};
-    };
-
-    struct velocity {
-        float dx{};
-        float dy{};
-    };
-
-    class movement_system : public ecs::system {
-    public:
-        void process(ecs::registry& owner) override {
-            owner.for_joined_components<
-                position,
-                velocity
-            >([](ecs::entity, position& p, const velocity& v) {
-                p.x += v.dx;
-                p.y += v.dy;
-            }, ecs::exists<movable>{} && !ecs::exists<disabled>{});
-        }
-    };
-
-    class gravity_system : public ecs::system {
-    public:
-        gravity_system(float gravity)
-        : gravity_(gravity) {}
-
-        void process(ecs::registry& owner) override {
-            owner.for_each_component<
-                velocity
-            >([this](ecs::entity, velocity& v) {
-                v.dx += gravity_;
-                v.dy += gravity_;
-            }, !ecs::exists<disabled>{});
-        }
-    private:
-        float gravity_{};
-    };
-
-    ecs::registry world;
-
-    ecs::registry_filler(world)
-        .system<movement_system>(0)
-        .system<gravity_system>(1, 9.8f);
-
-    auto entity_one = world.create_entity();
-    ecs::entity_filler(entity_one)
-        .component<movable>()
-        .component<position>(4.f, 2.f)
-        .component<velocity>(10.f, 20.f);
-
-    auto entity_two = world.create_entity();
-    ecs::entity_filler(entity_two)
-        .component<movable>()
-        .component<disabled>()
-        .component<position>(4.f, 2.f)
-        .component<velocity>(10.f, 20.f);
-
-    world.process_all_systems();
-}