Set multiple components at once

tests/zecsy.cpp

@@ -1,10 +1,8 @@
 #include <catch2/catch_test_macros.hpp>
-#include <catch2/internal/catch_test_spec_parser.hpp>
 #include <string>
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch_all.hpp>
 
-//#define MAX_ZECSY_ENTITIES 4
 #include "../zecsy.hpp"
 
 using namespace zecsy;
@@ -168,3 +166,19 @@ TEST_CASE("Addresses of removed components should be reused")
         entities.clear();
     }
 }
+
+TEST_CASE("Attach multiple components to an entity and verify all are correctly stored and retrievable")
+{
+    world w;
+
+    auto e = w.make_entity();
+    e.set(ChoosenOne{}, Name{"zecsy"});
+
+    REQUIRE(e.has<ChoosenOne, Name>());
+    REQUIRE(w.has<ChoosenOne, Name>(e));
+
+    e.remove<ChoosenOne>();
+
+    REQUIRE_FALSE(e.has<ChoosenOne, Name>());
+    REQUIRE_FALSE(w.has<ChoosenOne, Name>(e));
+}

zecsy.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <catch2/internal/catch_console_colour.hpp>
 #include <cstdint>
 #include <bitset>
 #include <format>
@@ -22,22 +23,21 @@ namespace zecsy
         entity(class world* w, entity_id id);
 
         entity() = default;
-        entity(const entity &) = default;
-        entity(entity &&) = default;
-        entity &operator=(const entity &) = default;
-        entity &operator=(entity &&) = default;
         operator entity_id() const;
 
         bool is_alive() const;
 
-        template<typename T>
+        template<typename... T>
         bool has() const;
 
         template<typename T>
         T& get();
 
-        template<typename T>
+        template<typename... T>
-        void set(const T& comp = T{});
+        void set();
+
+        template<typename... T>
+        void set(const T&... comps);
 
         template<typename T>
         void remove();
@@ -54,12 +54,28 @@ namespace zecsy
         template<typename T>
         bool has(entity_id e) const;
 
+        template<typename First, typename Second, typename... Rest>
+        requires(sizeof...(Rest) >= 0)
+        bool has(entity_id e) const;
+
         template<typename T>
         T& get(entity_id e);
 
         template<typename T>
-        void set(entity_id e, const T& comp = T{});
+        void set(entity_id e);
+        
+        template<typename T>
+        void set(entity_id e, const T& comp);
+ 
+        template<typename First, typename Second, typename... Rest>
+        requires(sizeof...(Rest) >= 0)
+        void set(entity_id e);
 
+        template<typename First, typename Second, typename... Rest>
+        requires(sizeof...(Rest) >= 0)
+        void set(entity_id e, const First& comp0, const Second& comp1, 
+                const Rest&... rest_comps);
+        
         template<typename T>
         void remove(entity_id e);
     private:
@@ -85,24 +101,21 @@ namespace zecsy
     class world final
     {
     public:
-        world() = default;
-        world(const world &) = default;
-        world(world &&) = default;
-        world &operator=(const world &) = default;
-        world &operator=(world &&) = default;
-   
         entity make_entity();
         void destroy_entity(entity_id e);
         bool is_alive(entity_id e) const; 
 
-        template<typename T>
+        template<typename... T>
         bool has(entity_id e) const;
 
         template<typename T>
         T& get(entity_id e);
 
-        template<typename T>
+        template<typename... T>
-        void set(entity_id e, const T& comp = T{});
+        void set(entity_id e);
+        
+        template<typename... T>
+        void set(entity_id e, const T&... comps);
 
         template<typename T>
         void remove(entity_id e);
@@ -151,12 +164,6 @@ namespace zecsy
         return entities_bitset.test(e);
     }
 
-    template<typename T>
-    inline bool world::has(entity_id e) const
-    {
-        return storage.has<T>(e);
-    }
-
     template<typename T>
     inline bool component_storage::has(entity_id e) const
     {
@@ -184,10 +191,10 @@ namespace zecsy
         return *ptr;
     }
 
-    template<typename T>
+    template<typename... T>
     inline bool entity::has() const
     {
-        return w->has<T>(id);    
+        return w->has<T...>(id);    
     }
 
     template<typename T>
@@ -202,6 +209,12 @@ namespace zecsy
         return w->get<T>(id);
     }
 
+    template<typename... T>
+    inline void entity::set()
+    {
+        (set(T{}), ...);
+    }
+
     template<typename T>
     inline void component_storage::set(entity_id e, const T& comp)
     {
@@ -232,17 +245,23 @@ namespace zecsy
 
         entity_dict[typeid(T)][e] = index;
     }
-
+    
-    template<typename T>
+    template<typename... T>
-    inline void world::set(entity_id e, const T& comp)
+    inline void world::set(entity_id e)
     {
-        storage.set(e, comp);
+        storage.set<T...>(e);
     }
 
-    template<typename T>
+    template<typename... T>
-    inline void entity::set(const T& comp)
+    inline void world::set(entity_id e, const T&... comps)
     {
-        w->set(id, comp);
+        storage.set(e, comps...);
+    }
+
+    template<typename... T>
+    inline void entity::set(const T&... comps)
+    {
+        w->set(id, comps...);
     }
 
     template<typename T>
@@ -269,4 +288,36 @@ namespace zecsy
     {
         w->remove<T>(id);
     }
+
+    template<typename... T>
+    inline bool world::has(entity_id e) const
+    {
+        return storage.has<T...>(e);
+    }
+
+    template<typename First, typename Second, typename... Rest>
+    requires(sizeof...(Rest) >= 0)
+    inline bool component_storage::has(entity_id e) const
+    {
+        return has<First>(e) && has<Second>(e) && (has<Rest>(e) && ...);
+    }
+    
+    template<typename First, typename Second, typename... Rest>
+    requires(sizeof...(Rest) >= 0)
+    inline void component_storage::set(entity_id e)
+    {
+        set(e, First{});
+        set(e, Second{});
+        (set(e, Rest{}), ...);
+    }
+
+    template<typename First, typename Second, typename... Rest>
+    requires(sizeof...(Rest) >= 0)
+    inline void component_storage::set(entity_id e, const First& comp0, const Second& comp1, 
+            const Rest&... rest_comps)
+    {
+        set(e, comp0);
+        set(e, comp1);
+        (set(e, rest_comps), ...);
+    }
 };