fix: execute systems from other packages (#44)

Author: zaucy

ecsact/entt/detail/meta_util.hh

@@ -26,8 +26,26 @@ void mp_for_each_available_action(Callback&& cb) {
 
 	mp_for_each<actions>([&]<typename A>(const A& a) { cb(a); });
 	mp_for_each<dependencies>([&]<typename D>(const D& d) {
-		mp_for_each_available_components<D>(cb);
+		mp_for_each_available_action<D>(cb);
 	});
 }
 
+template<typename Package, typename Callback>
+void mp_for_each_available_system(Callback&& cb) {
+	using boost::mp11::mp_for_each;
+	using systems = typename Package::systems;
+	using dependencies = typename Package::dependencies;
+
+	mp_for_each<systems>([&]<typename S>(const S& s) { cb(s); });
+	mp_for_each<dependencies>([&]<typename D>(const D& d) {
+		mp_for_each_available_system<D>(cb);
+	});
+}
+
+template<typename Package, typename Callback>
+void mp_for_each_available_system_like(Callback&& cb) {
+	mp_for_each_available_system<Package>(cb);
+	mp_for_each_available_action<Package>(cb);
+}
+
 } // namespace ecsact::entt::detail

ecsact/entt/runtime.hh

@@ -961,10 +961,16 @@ private:
 		}
 	}
 
-	void _execute_systems(registry_info& info, actions_span_t& actions) {
+	template<typename TargetPackage>
+	void _execute_package_systems(registry_info& info, actions_span_t& actions) {
 		using boost::mp11::mp_for_each;
+		using dependencies = typename TargetPackage::dependencies;
+
+		mp_for_each<dependencies>([&]<typename D>(const D&) {
+			_execute_package_systems<D>(info, actions);
+		});
 
-		mp_for_each<typename package::execution_order>(
+		mp_for_each<typename TargetPackage::execution_order>(
 			[&]<typename SystemPair>(SystemPair) {
 				using boost::mp11::mp_first;
 				using boost::mp11::mp_second;
@@ -976,6 +982,10 @@ private:
 		);
 	}
 
+	void _execute_systems(registry_info& info, actions_span_t& actions) {
+		_execute_package_systems<package>(info, actions);
+	}
+
 	template<typename C>
 		requires(!std::is_empty_v<C>)
 	void _pre_exec_add_component(

runtime/dynamic.template.cc

@@ -1,6 +1,7 @@
 #include <boost/mp11.hpp>
 #include "ecsact/runtime/dynamic.h"
 #include "ecsact/entt/detail/system_execution_context.hh"
+#include "ecsact/entt/detail/meta_util.hh"
 
 #include "common.template.hh"
 
@@ -12,15 +13,9 @@ using package = typename decltype(ecsact_entt_rt::runtime)::package;
 
 template<typename Fn>
 static void cast_and_use_ctx(ecsact_system_execution_context* ctx, Fn&& fn) {
-	using boost::mp11::mp_flatten;
-	using boost::mp11::mp_for_each;
-	using boost::mp11::mp_push_back;
-	using boost::mp11::mp_transform;
-
-	using all_systems = mp_flatten<
-		mp_push_back<typename package::actions, typename package::systems>>;
+	using ecsact::entt::detail::mp_for_each_available_system_like;
 
-	mp_for_each<all_systems>([&]<typename S>(S) {
+	mp_for_each_available_system_like<package>([&]<typename S>(S) {
 		if(ecsact_id_cast<ecsact_system_like_id>(S::id) == ctx->system_id) {
 			using boost::mp11::mp_size;
 			using caps_info = ecsact::system_capabilities_info<S>;

runtime/test/imported_pkg.ecsact

@@ -4,3 +4,11 @@ component ImportedComponent {
 	i32 num;
 }
 
+component SomeLocalComponent {
+	i32 local_num;
+}
+
+system ImportedSystem {
+	readwrite SomeLocalComponent;
+}
+

runtime/test/runtime_test.cc

@@ -1,6 +1,8 @@
 #include "gtest/gtest.h"
 
 #include <array>
+#include <set>
+#include <typeindex>
 #include <unordered_set>
 #include <version>
 #include <ranges>
@@ -56,6 +58,12 @@ void runtime_test::SimpleIncrementImportedComp::impl(context& ctx) {
 	ctx.update(comp);
 }
 
+void imported::test_pkg::ImportedSystem::impl(context& ctx) {
+	auto comp = ctx.get<SomeLocalComponent>();
+	comp.local_num += 1;
+	ctx.update(comp);
+}
+
 static std::atomic_bool AssocTestAction_ran = false;
 
 void runtime_test::AssocTestAction::impl(context& ctx) {
@@ -742,22 +750,50 @@ TEST(Core, CreateAndDestroyEntity) {
 
 TEST(Core, MultiPkgUpdate) {
 	using imported::test_pkg::ImportedComponent;
+	using imported::test_pkg::SomeLocalComponent;
 
-	ecsact_set_system_execution_impl(
+	ASSERT_TRUE(ecsact_set_system_execution_impl(
 		ecsact_id_cast<ecsact_system_like_id>(
 			runtime_test::SimpleIncrementImportedComp::id
 		),
 		&runtime_test__SimpleIncrementImportedComp
-	);
+	));
+
+	ASSERT_TRUE(ecsact_set_system_execution_impl(
+		ecsact_id_cast<ecsact_system_like_id>(imported::test_pkg::ImportedSystem::id
+		),
+		&imported__test_pkg__ImportedSystem
+	));
 
 	auto reg = ecsact::core::registry("MultiPkgUpdate");
 	auto test_entity = reg.create_entity();
 	reg.add_component(test_entity, ImportedComponent{});
+	reg.add_component(test_entity, SomeLocalComponent{});
 
 	for(int i = 0; 10 > i; ++i) {
-		reg.execute_systems();
-		auto c = reg.get_component<ImportedComponent>(test_entity);
-		EXPECT_EQ(c.num, i + 1);
+		auto event_happened = std::set<std::type_index>{};
+		auto evc = ecsact::core::execution_events_collector<>{};
+		evc.set_update_callback<ImportedComponent>([&](auto entity, auto comp) {
+			event_happened.insert(typeid(ImportedComponent));
+			EXPECT_EQ(comp.num, i + 1);
+		});
+		evc.set_update_callback<SomeLocalComponent>([&](auto entity, auto comp) {
+			event_happened.insert(typeid(SomeLocalComponent));
+			EXPECT_EQ(comp.local_num, i + 1);
+		});
+
+		reg.execute_systems(1, evc);
+		{
+			auto c = reg.get_component<ImportedComponent>(test_entity);
+			EXPECT_EQ(c.num, i + 1);
+			EXPECT_TRUE(event_happened.contains(typeid(ImportedComponent)));
+		}
+
+		{
+			auto c = reg.get_component<SomeLocalComponent>(test_entity);
+			EXPECT_EQ(c.local_num, i + 1);
+			EXPECT_TRUE(event_happened.contains(typeid(SomeLocalComponent)));
+		}
 	}
 }