Using memory arena in the game that supports hot reload

Game/Entity/Entity.h

@@ -18,57 +18,53 @@
     constexpr Juliet::Class entityKind##entity(#entity, sizeof(#entity) / sizeof(char));                               \
     const Juliet::Class*    entity::Kind = &entityKind##entity;
 
-namespace Game
+using DerivedType = void*;
+
+struct Entity final
 {
-    using DerivedType = void*;
+    EntityID             ID;
+    const Juliet::Class* Kind;
+    DerivedType          Derived;
+    float                X, Y;
+};
 
-    struct Entity final
-    {
-        EntityID             ID;
-        const Juliet::Class* Kind;
-        DerivedType          Derived;
-        float                X, Y;
-    };
+template <typename EntityType>
+concept EntityConcept = requires(EntityType entity) {
+    requires std::same_as<decltype(entity.Kind), const Juliet::Class*>;
+    requires std::same_as<decltype(entity.Base), Entity*>;
+};
 
-    template <typename EntityType>
-    concept EntityConcept = requires(EntityType entity) {
-        requires std::same_as<decltype(entity.Kind), const Juliet::Class*>;
-        requires std::same_as<decltype(entity.Base), Entity*>;
-    };
+template <typename EntityType>
+    requires EntityConcept<EntityType>
+bool IsA(const Entity* entity)
+{
+    return entity->Kind == EntityType::Kind;
+}
 
-    template <typename EntityType>
-        requires EntityConcept<EntityType>
-    bool IsA(const Entity* entity)
-    {
-        return entity->Kind == EntityType::Kind;
-    }
+template <typename EntityType>
+    requires EntityConcept<EntityType>
+EntityType* MakeEntity(EntityManager& manager, float x, float y)
+{
+    auto*       arena  = manager.Arena;
+    EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
+    Entity      base;
+    base.X       = x;
+    base.Y       = y;
+    base.Derived = result;
+    base.Kind    = EntityType::Kind;
+    manager.Entities.PushBack(base);
 
-    template <typename EntityType>
-        requires EntityConcept<EntityType>
-    EntityType* MakeEntity(EntityManager& manager, float x, float y)
-    {
-        auto*       arena  = manager.Arena;
-        EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
-        Entity      base;
-        base.X       = x;
-        base.Y       = y;
-        base.Derived = result;
-        base.Kind    = EntityType::Kind;
-        manager.Entities.PushBack(base);
+    result->Base = manager.Entities.Back();
 
-        result->Base = manager.Entities.Back();
+    RegisterEntity(manager, &base);
 
-        RegisterEntity(manager, &base);
+    return result;
+}
 
-        return result;
-    }
-
-    template <typename EntityType>
-        requires EntityConcept<EntityType>
-    EntityType* DownCast(Entity* entity)
-    {
-        Assert(IsA<EntityType>(entity));
-        return static_cast<EntityType*>(entity->Derived);
-    }
-
-} // namespace Game
+template <typename EntityType>
+    requires EntityConcept<EntityType>
+EntityType* DownCast(Entity* entity)
+{
+    Assert(IsA<EntityType>(entity));
+    return static_cast<EntityType*>(entity->Derived);
+}

Game/Entity/EntityManager.cpp

@@ -2,33 +2,30 @@
 
 #include <Entity/Entity.h>
 
-namespace Game
+EntityID EntityManager::ID = 0;
+
+void InitEntityManager(Juliet::NonNullPtr<World> world)
 {
-    namespace
-    {
-        EntityManager Manager;
-    }
+    EntityManager* newManager = Juliet::ArenaPushStruct<EntityManager>(world->WorldArena);
+    world->EntityManager      = newManager;
 
-    EntityID EntityManager::ID = 0;
+    newManager->Entities.Create(world->WorldArena JULIET_DEBUG_PARAM("Entities"));
 
-    void InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena)
-    {
-        Manager.Arena = arena.Get();
-        Manager.Entities.Create(arena JULIET_DEBUG_PARAM("Entities"));
-    }
+    newManager->Arena = Juliet::ArenaAllocate({} JULIET_DEBUG_PARAM("Entity Arena"));
+}
 
-    void ShutdownEntityManager()
-    {
-        Manager.Entities.Destroy();
-    }
+void ShutdownEntityManager()
+{
+    GetEntityManager().Entities.Destroy();
+}
 
-    EntityManager& GetEntityManager()
-    {
-        return Manager;
-    }
+EntityManager& GetEntityManager()
+{
+    Juliet::NonNullPtr entityManager = GetGameState()->World->EntityManager;
+    return *entityManager;
+}
 
-    void RegisterEntity(EntityManager& /*manager*/, Entity* entity)
-    {
-        entity->ID = EntityManager::ID++;
-    }
-} // namespace Game
+void RegisterEntity(EntityManager& /*manager*/, Entity* entity)
+{
+    entity->ID = EntityManager::ID++;
+}

Game/Entity/EntityManager.h

@@ -2,23 +2,22 @@
 
 #include <Core/Common/CoreTypes.h>
 #include <Core/Container/Vector.h>
+#include <game.h>
 
-namespace Game
+using EntityID = uint64_t;
+
+struct Entity;
+struct EntityManager
 {
-    using EntityID = uint64_t;
+    static EntityID ID;
 
-    struct Entity;
-    struct EntityManager
-    {
-        static EntityID ID;
+    Juliet::Arena* Arena;
 
-        Juliet::Arena* Arena;
-        // TODO: Should be a pool
-        Juliet::VectorArena<Entity, 1024> Entities;
-    };
+    // TODO: Should be a pool
+    Juliet::VectorArena<Entity, 1024> Entities;
+};
 
-    void           InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena);
-    void           ShutdownEntityManager();
-    EntityManager& GetEntityManager();
-    void           RegisterEntity(EntityManager& manager, Entity* entity);
-} // namespace Game
+void           InitEntityManager(Juliet::NonNullPtr<World> world);
+void           ShutdownEntityManager();
+EntityManager& GetEntityManager();
+void           RegisterEntity(EntityManager& manager, Entity* entity);