Add actions to options, update all tests with execution_options. Tests are all working!

Author: Kelwan

ecsact/runtime/core.hh

@@ -159,6 +159,10 @@ public:
 		destroy_entities.push_back(entity_id);
 	}
 
+	inline void push_action(const ecsact_action& action) {
+		actions.push_back(action);
+	}
+
 	inline void clear() {
 		options = {};
 
@@ -176,6 +180,8 @@ public:
 
 		create_entities.clear();
 		destroy_entities.clear();
+
+		actions.clear();
 	}
 
 	inline ecsact_execution_options c() {
@@ -204,6 +210,9 @@ public:
 		options.destroy_entities = destroy_entities.data();
 		options.destroy_entities_length = destroy_entities.size();
 
+		options.actions = actions.data();
+		options.actions_length = actions.size();
+
 		return options;
 	}
 
@@ -223,6 +232,8 @@ private:
 	std::vector<int>               entities_component_lengths;
 	std::vector<ecsact_component*> entities_components;
 
+	std::vector<ecsact_action> actions;
+
 	ecsact_execution_options options;
 };
 

tests/async/async_ref_test.cc

@@ -400,21 +400,15 @@ TEST(AsyncRef, ReceiveMultipleEntities) {
 
 	auto connect_req_id = ecsact_async_connect("good?tick_rate=25");
 
-	auto entity_options = ecsact_execution_options{};
+	auto options = ecsact::core::execution_options{};
 
-	entity_options.create_entities_components = {nullptr};
-	entity_options.create_entities_length = 0;
-	entity_options.create_entities_components_length = nullptr;
+	options.create_entity();
 
 	for(int i = 0; i < 10; i++) {
-		ecsact_async_enqueue_execution_options(entity_options);
+		ecsact_async_enqueue_execution_options(options.c());
 	}
 
-	int              counter = 0;
-	ecsact_entity_id entity;
-
 	struct entity_cb_info {
-		ecsact_entity_id&   entity;
 		std::array<int, 10> entity_request_ids;
 		int&                counter;
 	};
@@ -431,17 +425,14 @@ TEST(AsyncRef, ReceiveMultipleEntities) {
 			entity_info.counter++;
 		};
 
-	entity_cb_info entity_info{
-		.entity = entity,
-		.entity_request_ids = {},
-		.counter = counter};
+	int counter = 0;
+
+	entity_cb_info entity_info{.entity_request_ids = {}, .counter = counter};
 
 	auto evc = ecsact_execution_events_collector{};
 	evc.entity_created_callback = entity_cb;
 	evc.entity_created_callback_user_data = &entity_info;
 
-	ecsact_async_enqueue_execution_options(entity_options);
-
 	auto start_tick = ecsact_async_get_current_tick();
 	while(counter < 10) {
 		ecsact_async_flush_events(&evc, nullptr);
@@ -488,31 +479,13 @@ TEST(AsyncRef, TryAction) {
 
 	async_test::ComponentUpdate my_update_component{.value_to_update = 1};
 
-	auto needed_component = ecsact_component{
-		.component_id = async_test::NeededComponent::id,
-		.component_data = &my_needed_component,
-	};
-	auto update_component = ecsact_component{
-		.component_id = async_test::ComponentUpdate::id,
-		.component_data = &my_update_component,
-	};
-
-	// Add components to an array
-	std::array<ecsact_component*, 2> add_components{
-		&needed_component,
-		&update_component,
-	};
-
-	int  component_length = 2;
-	int* component_length_ptr = &component_length;
-
-	auto options = ecsact_execution_options{};
+	auto options = ecsact::core::execution_options{};
 
-	options.create_entities_components = {add_components.data()};
-	options.create_entities_length = 2;
-	options.create_entities_components_length = component_length_ptr;
+	options.create_entity()
+		.add_component(&my_needed_component)
+		.add_component(&my_update_component);
 
-	ecsact_async_enqueue_execution_options(options);
+	ecsact_async_enqueue_execution_options(options.c());
 
 	auto evc = ecsact_execution_events_collector{};
 	evc.entity_created_callback = entity_cb;
@@ -526,6 +499,8 @@ TEST(AsyncRef, TryAction) {
 		ASSERT_LT(tick_diff, 10);
 	}
 
+	options.clear();
+
 	async_test::TryEntity my_try_entity;
 
 	my_try_entity.my_entity = cb_info.entity;
@@ -542,20 +517,14 @@ TEST(AsyncRef, TryAction) {
 		}
 	);
 
-	std::vector<ecsact_action> actions{};
-
 	ecsact_action my_action{
 		.action_id = async_test::TryEntity::id,
 		.action_data = &my_try_entity,
 	};
 
-	actions.push_back(my_action);
-	options = {};
+	options.push_action(my_action);
 
-	options.actions = actions.data();
-	options.actions_length = actions.size();
-
-	ecsact_async_enqueue_execution_options(options);
+	ecsact_async_enqueue_execution_options(options.c());
 
 	start_tick = ecsact_async_get_current_tick();
 	while(reached_system != true) {