From 05d6c60b56be03ddd0b2164584dc31899b5b7854 Mon Sep 17 00:00:00 2001
From: Mikko Rasa <tdb@tdb.fi>
Date: Sat, 15 Mar 2025 17:15:45 +0200
Subject: [PATCH] Add utilities for keeping track of entities with specific
 components

---
 source/game/archetype.h | 147 ++++++++++++++++++++++++++++++++++++++++
 source/game/handle.h    |   3 +
 2 files changed, 150 insertions(+)
 create mode 100644 source/game/archetype.h

diff --git a/source/game/archetype.h b/source/game/archetype.h
new file mode 100644
index 0000000..f6fef8c
--- /dev/null
+++ b/source/game/archetype.h
@@ -0,0 +1,147 @@
+#ifndef MSP_GAME_ARCHETYPE_H_
+#define MSP_GAME_ARCHETYPE_H_
+
+#include <vector>
+#include <msp/core/algorithm.h>
+#include <msp/core/meta.h>
+#include "eventobserver.h"
+#include "events.h"
+#include "handle.h"
+
+namespace Msp::Game {
+
+template<auto first, auto... rest>
+	requires (std::is_same_v<typename PointerToMemberTraits<decltype(first)>::Class, typename PointerToMemberTraits<decltype(rest)>::Class> && ...)
+struct CommonClassOfMembers
+{
+	using Type = typename PointerToMemberTraits<decltype(first)>::Class;
+};
+
+template<auto first, auto... rest>
+struct ArchetypeComponents
+{
+	using Wrapper = typename CommonClassOfMembers<first, rest...>::Type;
+
+	template<typename F>
+	static void dispatch(const F &, Handle<Component>);
+
+	static bool all_null(const Wrapper &);
+};
+
+
+template<typename T>
+concept ValidArchetype =
+	std::is_same_v<typename T::Components::Wrapper, T> &&
+		requires(T t) { { t.entity } -> std::convertible_to<Handle<Entity>>; };
+
+
+template<typename T>
+	requires ValidArchetype<T>
+class ArchetypeMonitor
+{
+private:
+	EventObserver &event_observer;
+	std::vector<T> &entities;
+	std::function<void(T &)> changed_callback;
+
+public:
+	ArchetypeMonitor(EventObserver &, std::vector<T> &);
+
+	void set_changed_callback(std::function<void(T &)>);
+
+private:
+	void component_created(const Events::ComponentCreated &);
+	void component_destroyed(const Events::ComponentDestroyed &);
+
+	T &get_or_create_wrapper(Handle<Entity>);
+};
+
+
+template<auto first, auto... rest>
+template<typename F>
+void ArchetypeComponents<first, rest...>::dispatch(const F &func, Handle<Component> comp)
+{
+	if(auto cast_comp = dynamic_handle_cast<typename PointerToMemberTraits<decltype(first)>::Type::element_type>(comp))
+		func(cast_comp, first);
+	else if constexpr(sizeof...(rest)>0)
+		ArchetypeComponents<rest...>::dispatch(func, comp);
+}
+
+template<auto first, auto... rest>
+bool ArchetypeComponents<first, rest...>::all_null(const Wrapper &wrapper)
+{
+	return (!(wrapper.*first) && ... && !(wrapper.*rest));
+}
+
+
+template<typename T>
+	requires ValidArchetype<T>
+ArchetypeMonitor<T>::ArchetypeMonitor(EventObserver &o, std::vector<T> &v):
+	event_observer(o),
+	entities(v)
+{
+	event_observer.observe<Events::ComponentCreated>([this](auto &e){ component_created(e); });
+	event_observer.observe<Events::ComponentDestroyed>([this](auto &e){ component_destroyed(e); });
+}
+
+template<typename T>
+	requires ValidArchetype<T>
+void ArchetypeMonitor<T>::set_changed_callback(std::function<void(T &)> cb)
+{
+	changed_callback = cb;
+}
+
+template<typename T>
+	requires ValidArchetype<T>
+void ArchetypeMonitor<T>::component_created(const Events::ComponentCreated &event)
+{
+	T::Components::dispatch([this]<typename C>(Handle<C> comp, Handle<C> T::*member){
+		Handle<Entity> entity = comp->get_entity();
+		T &wrapper = get_or_create_wrapper(entity);
+		wrapper.*member = comp;
+
+		if(changed_callback)
+			changed_callback(wrapper);
+	}, event.component);
+}
+
+template<typename T>
+	requires ValidArchetype<T>
+void ArchetypeMonitor<T>::component_destroyed(const Events::ComponentDestroyed &event)
+{
+	T::Components::dispatch([this]<typename C>(Handle<C> comp, Handle<C> T::*member){
+		Handle<Entity> entity = comp->get_entity();
+		auto i = lower_bound_member(entities, entity, &T::entity);
+		if(i!=entities.end() && i->entity==entity)
+		{
+			(*i).*member = nullptr;
+			if(changed_callback)
+				changed_callback(*i);
+		}
+
+		if(T::Components::all_null(*i))
+			entities.erase(i);
+	}, event.component);
+}
+
+template<typename T>
+	requires ValidArchetype<T>
+T &ArchetypeMonitor<T>::get_or_create_wrapper(Handle<Entity> entity)
+{
+	auto i = lower_bound_member(entities, entity, &T::entity);
+	if(i!=entities.end() && i->entity==entity)
+		return *i;
+
+	if constexpr(std::is_constructible_v<T, Handle<Entity>>)
+		return *entities.emplace(i, entity);
+	else
+	{
+		auto &e = entities.emplace(i);
+		e.entity = entity;
+		return e;
+	}
+}
+
+} // namespace Msp::Game
+
+#endif
diff --git a/source/game/handle.h b/source/game/handle.h
index 183fc41..73d4d11 100644
--- a/source/game/handle.h
+++ b/source/game/handle.h
@@ -18,6 +18,9 @@ class Handle
 	template<typename U>
 	friend class Handle;
 
+public:
+	using element_type = T;
+
 protected:
 	T *ptr = nullptr;
 
-- 
2.45.2