mlangkabel/dota_factory
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement claude feedback for EntityAdmin

Browse Source
This commit is contained in:
mlangkabel
2026-05-22 07:55:43 +02:00
parent cc2cca2442
commit c18c4e4804
2 changed files with 44 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/lib/core/EntityAdmin.cpp
View File

@@ -1,33 +1,21 @@
#include "EntityAdmin.h" #include "EntityAdmin.h"
std::shared_ptr<EntityAdmin> EntityAdmin::getInstance() entt::entity EntityAdmin::createEntity()
{ {
if (!s_instance) return m_registry.create();
{
s_instance = std::shared_ptr<EntityAdmin>(new EntityAdmin());
}
return s_instance;
} }
std::shared_ptr<EntityAdmin> EntityAdmin::s_instance; bool EntityAdmin::isValid(entt::entity entity)
bool EntityAdmin::isValid(const 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() 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>())
{
}

150
src/lib/core/EntityAdmin.h
View File

@@ -3,151 +3,61 @@
#include "entt/entity/registry.hpp" #include "entt/entity/registry.hpp"
#include <QVector2D>
class EntityAdmin class EntityAdmin
{ {
public: public:
static std::shared_ptr<EntityAdmin> getInstance(); EntityAdmin() = default;
private: EntityAdmin(const EntityAdmin&) = delete;
static std::shared_ptr<EntityAdmin> s_instance; EntityAdmin& operator=(const EntityAdmin&) = delete;
public: template <typename... Ts, typename Func>
template <typename T1> void forEach(Func&& f);
T1 &add(const entt::entity &entity);
void clear();
template <typename T1> template <typename... Ts>
void forEach(std::function<void(entt::entity &pe, T1 &p1)> f); bool hasAll(entt::entity entity);
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 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> template <typename T>
T &get(const entt::entity &entity); T& get(entt::entity entity);
bool isValid(const entt::entity &entity); bool isValid(entt::entity entity);
void destroy(entt::entity entity);
void clear();
/* /*
factory methods (like spawnShip, spawnScrap, etc shall go here) factory methods (like spawnShip, spawnScrap, etc shall go here)
*/ */
void destroy(entt::entity &entity);
private: private:
EntityAdmin(); entt::entity createEntity();
EntityAdmin(const EntityAdmin&) = delete;
EntityAdmin& operator=(const EntityAdmin&) = delete;
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> template <typename... Ts, typename Func>
T1 &EntityAdmin::add(const entt::entity &entity) void EntityAdmin::forEach(Func&& f)
{ {
return m_registry->emplace<T1>(entity); m_registry.view<Ts...>().each(std::forward<Func>(f));
} }
template <typename T1> template <typename... Ts>
void EntityAdmin::forEach(std::function<void(entt::entity &pe, T1 &p1)> f) bool EntityAdmin::hasAll(entt::entity entity)
{ {
auto view = m_registry->view<T1>(); return m_registry.all_of<Ts...>(entity);
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;
} }
template <typename T> 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 #endif // ENTITY_ADMIN_H