From c18c4e4804da3b36d44daaa6e70d2ceb242839fb Mon Sep 17 00:00:00 2001
From: mlangkabel <malte.langkabel@gmail.com>
Date: Fri, 22 May 2026 07:55:43 +0200
Subject: [PATCH] implement claude feedback for EntityAdmin

---
 src/lib/core/EntityAdmin.cpp |  32 +++----
 src/lib/core/EntityAdmin.h   | 158 ++++++++---------------------------
 2 files changed, 44 insertions(+), 146 deletions(-)

diff --git a/src/lib/core/EntityAdmin.cpp b/src/lib/core/EntityAdmin.cpp
index e7fecac..29bda65 100644
--- a/src/lib/core/EntityAdmin.cpp
+++ b/src/lib/core/EntityAdmin.cpp
@@ -1,33 +1,21 @@
 #include "EntityAdmin.h"
 
-std::shared_ptr<EntityAdmin> EntityAdmin::getInstance()
+entt::entity EntityAdmin::createEntity()
 {
-	if (!s_instance)
-	{
-		s_instance = std::shared_ptr<EntityAdmin>(new EntityAdmin());
-	}
-	return s_instance;
+    return m_registry.create();
 }
 
-std::shared_ptr<EntityAdmin> EntityAdmin::s_instance;
-
-bool EntityAdmin::isValid(const entt::entity &entity)
+bool EntityAdmin::isValid(entt::entity entity)
 {
-	return m_registry->valid(entity);
+    return m_registry.valid(entity);
+}
+
+void EntityAdmin::destroy(entt::entity entity)
+{
+    m_registry.destroy(entity);
 }
 
 void EntityAdmin::clear()
 {
-	m_registry->clear();
+    m_registry.clear();
 }
-
-void EntityAdmin::destroy(entt::entity &entity)
-{
-	m_registry->destroy(entity);
-}
-
-EntityAdmin::EntityAdmin()
-	: m_registry(std::make_shared<entt::registry>())
-{
-}
-
diff --git a/src/lib/core/EntityAdmin.h b/src/lib/core/EntityAdmin.h
index 572e26c..973a5fb 100644
--- a/src/lib/core/EntityAdmin.h
+++ b/src/lib/core/EntityAdmin.h
@@ -3,151 +3,61 @@
 
 #include "entt/entity/registry.hpp"
 
-#include <QVector2D>
-
 class EntityAdmin
 {
 public:
-	static std::shared_ptr<EntityAdmin> getInstance();
-private:
-	static std::shared_ptr<EntityAdmin> s_instance;
+    EntityAdmin() = default;
+    EntityAdmin(const EntityAdmin&) = delete;
+    EntityAdmin& operator=(const EntityAdmin&) = delete;
 
-public:
-	template <typename T1>
-	T1 &add(const entt::entity &entity);
-	void clear();
+    template <typename... Ts, typename Func>
+    void forEach(Func&& f);
 
-	template <typename T1>
-	void forEach(std::function<void(entt::entity &pe, T1 &p1)> f);
-	template <typename T1, typename T2>
-	void forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2)> f);
-	template <typename T1, typename T2, typename T3>
-	void forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2, T3 &p3)> f);
-	template <typename T1, typename T2, typename T3, typename T4>
-	void forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2, T3 &p3, T4 &p4)> f);
-	template <typename T1, typename T2, typename T3, typename T4, typename T5>
-	void forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5)> f);
+    template <typename... Ts>
+    bool hasAll(entt::entity entity);
 
-	template <typename T1>
-	bool hasAll(const entt::entity &entity);
-	template <typename T1, typename T2>
-	bool hasAll(const entt::entity &entity);
-	template <typename T1, typename T2, typename T3>
-	bool hasAll(const entt::entity &entity);
-	template <typename T1, typename T2, typename T3, typename T4>
-	bool hasAll(const entt::entity &entity);
+    template <typename T>
+    T& get(entt::entity entity);
 
-	template <typename T>
-	T &get(const entt::entity &entity);
+    bool isValid(entt::entity entity);
+    void destroy(entt::entity entity);
+    void clear();
 
-	bool isValid(const entt::entity &entity);
-
-	/*
-	factory methods (like spawnShip, spawnScrap, etc shall go here)
-	*/
-
-	void destroy(entt::entity &entity);
+    /*
+    factory methods (like spawnShip, spawnScrap, etc shall go here)
+    */
 
 private:
-	EntityAdmin();
-	EntityAdmin(const EntityAdmin&) = delete;
-	EntityAdmin& operator=(const EntityAdmin&) = delete;
+    entt::entity createEntity();
 
-	std::shared_ptr<entt::registry> m_registry;
+    template <typename T, typename... Args>
+    T& add(entt::entity entity, Args&&... args);
+
+    entt::registry m_registry;
 };
 
-template <typename T1>
-T1 &EntityAdmin::add(const entt::entity &entity)
+template <typename... Ts, typename Func>
+void EntityAdmin::forEach(Func&& f)
 {
-	return m_registry->emplace<T1>(entity);
+    m_registry.view<Ts...>().each(std::forward<Func>(f));
 }
 
-template <typename T1>
-void EntityAdmin::forEach(std::function<void(entt::entity &pe, T1 &p1)> f)
+template <typename... Ts>
+bool EntityAdmin::hasAll(entt::entity entity)
 {
-	auto view = m_registry->view<T1>();
-	for (auto ae : view) 
-	{
-		f(ae, view.get<T1>(ae));
-	}
-}
-
-template <typename T1, typename T2>
-void EntityAdmin::forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2)> f)
-{
-	auto view = m_registry->view<T1, T2>();
-	for (auto[ae, a1, a2] : view.each())
-	{
-		f(ae, a1, a2);
-	}
-}
-
-template <typename T1, typename T2, typename T3>
-void EntityAdmin::forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2, T3 &p3)> f)
-{
-	auto view = m_registry->view<T1, T2, T3>();
-	for (auto[ae, a1, a2, a3] : view.each())
-	{
-		f(ae, a1, a2, a3);
-	}
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-void EntityAdmin::forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2, T3 &p3, T4 &p4)> f)
-{
-	auto view = m_registry->view<T1, T2, T3, T4>();
-	for (auto[ae, a1, a2, a3, a4] : view.each())
-	{
-		f(ae, a1, a2, a3, a4);
-	}
-}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-void EntityAdmin::forEach(std::function<void(entt::entity &pe, T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5)> f)
-{
-	auto view = m_registry->view<T1, T2, T3, T4, T5>();
-	for (auto[ae, a1, a2, a3, a4, a5] : view.each())
-	{
-		f(ae, a1, a2, a3, a4, a5);
-	}
-}
-
-template <typename T1>
-bool EntityAdmin::hasAll(const entt::entity &entity)
-{
-	if (m_registry->all_of<T1>(entity))
-		return true;
-	return false;
-}
-
-template <typename T1, typename T2>
-bool EntityAdmin::hasAll(const entt::entity &entity)
-{
-	if (m_registry->all_of<T1, T2>(entity))
-		return true;
-	return false;
-}
-
-template <typename T1, typename T2, typename T3>
-bool EntityAdmin::hasAll(const entt::entity &entity)
-{
-	if (m_registry->all_of<T1, T2, T3>(entity))
-		return true;
-	return false;
-}
-
-template <typename T1, typename T2, typename T3, typename T4>
-bool EntityAdmin::hasAll(const entt::entity &entity)
-{
-	if (m_registry->all_of<T1, T2, T3, T4>(entity))
-		return true;
-	return false;
+    return m_registry.all_of<Ts...>(entity);
 }
 
 template <typename T>
-T &EntityAdmin::get(const entt::entity &entity)
+T& EntityAdmin::get(entt::entity entity)
 {
-	return m_registry->get<T>(entity);
+    return m_registry.get<T>(entity);
+}
+
+template <typename T, typename... Args>
+T& EntityAdmin::add(entt::entity entity, Args&&... args)
+{
+    return m_registry.emplace<T>(entity, std::forward<Args>(args)...);
 }
 
 #endif // ENTITY_ADMIN_H