No entity_id reusage yet

tests/zecsy.cpp

@@ -1,6 +1,8 @@
 #include <catch2/catch_test_macros.hpp>
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch_all.hpp>
+
+#define MAX_ZECSY_ENTITIES 4
 #include "../zecsy.hpp"
 
 using namespace zecsy;
@@ -10,7 +12,9 @@ TEST_CASE("Create a single entity and verify its existence")
     world w;
  
     auto e = w.make_entity();
+    
     REQUIRE(w.is_alive(e));
+    REQUIRE(e.is_alive());
 }
 
 TEST_CASE("Destroy an entity and ensure it no longer exists in the world")
@@ -19,5 +23,30 @@ TEST_CASE("Destroy an entity and ensure it no longer exists in the world")
     
     auto e = w.make_entity();
     w.destroy_entity(e);
+    
     REQUIRE_FALSE(w.is_alive(e));
+    REQUIRE_FALSE(e.is_alive());
+}
+
+TEST_CASE("Entity #0 should be reserved and never used")
+{
+    world w;
+    
+    auto e = w.make_entity();
+
+    REQUIRE(e != 0);
+    REQUIRE(entity() == 0);
+    REQUIRE_FALSE(entity().is_alive());
+}
+
+TEST_CASE("World should throw on id overflow")
+{
+    world w;
+
+    for(int i = 0; i < MAX_ZECSY_ENTITIES; ++i)
+    {
+        REQUIRE_NOTHROW(w.make_entity());
+    }
+
+    REQUIRE_THROWS(w.make_entity());
 }

zecsy.hpp

@@ -1,7 +1,8 @@
 #pragma once
 #include <cstdint>
 #include <bitset>
-#include <numeric>
+#include <format>
+#include <stdexcept>
 
 #ifndef MAX_ZECSY_ENTITIES
     #define MAX_ZECSY_ENTITIES 65536
@@ -12,6 +13,24 @@ namespace zecsy
 {
     using entity_id = uint64_t;
 
+    class entity final
+    {
+    public:
+        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;
+    private:
+        entity_id id = 0;
+        class world* w = nullptr;
+    };
+
     class world final
     {
     public:
@@ -21,24 +40,43 @@ namespace zecsy
         world &operator=(const world &) = default;
         world &operator=(world &&) = default;
    
-        entity_id make_entity();
+        entity make_entity();
         void destroy_entity(entity_id e);
         bool is_alive(entity_id e) const; 
     private:
-        std::bitset<MAX_ZECSY_ENTITIES> entities_bitset;
+        std::bitset<MAX_ZECSY_ENTITIES + 1> entities_bitset;
         entity_id entity_counter = 0;
     };
 
-    inline entity_id world::make_entity()
+    inline entity::entity(class world* w, entity_id id): w(w), id(id)
     {
-        auto id = entity_counter;
-        entities_bitset.set(id);
 
-        entity_counter++;
+    }
 
+    inline entity::operator entity_id() const 
+    {
         return id;
     }
 
+    inline bool entity::is_alive() const
+    {
+        return w && w->is_alive(id);
+    }
+
+    inline entity world::make_entity()
+    {
+        auto id = ++entity_counter;
+        
+        if(id > MAX_ZECSY_ENTITIES)
+        {
+            throw std::runtime_error(std::format("Entity id {} exceeds " 
+                        "MAX_ZECSY_ENTITIES ({})", id, MAX_ZECSY_ENTITIES));
+        }
+
+        entities_bitset.set(id);
+        return entity(this, id);
+    }
+
     inline void world::destroy_entity(entity_id e)
     {
         entities_bitset.reset(e);