Use create entity execution options in dynamic entity (#74)

Author: Kelwan

Runtime/DynamicEntity.cs

@@ -57,6 +57,10 @@ public class DynamicEntity : MonoBehaviour {
 	public global::System.Int32              entityId { get; private set; } = -1;
 	public List<SerializableEcsactComponent> ecsactComponents = new();
 
+	public List<global::System.Action> pending_callbacks = new();
+
+	bool callbackPending = false;
+
 	public void AddEcsactCompnent<C>(C component)
 		where     C : Ecsact.Component {
     if(Application.isPlaying) {
@@ -87,12 +91,29 @@ object               componentData
 		});
 	}
 
-	private void CreateEntityIfNeeded() {
-		if(entityId == -1) {
-			entityId = Ecsact.Defaults.Registry.CreateEntity();
-			if(Ecsact.Defaults.Pool != null) {
-				Ecsact.Defaults.Pool.SetPreferredEntityGameObject(entityId, gameObject);
-			}
+	private void CreateEntityIfNeeded(global::System.Action callback) {
+		if(entityId == -1 && callbackPending == false) {
+			var runtimeSettings = EcsactRuntimeSettings.Get();
+			callbackPending = true;
+			Ecsact.Defaults.Runner!.executionOptions.CreateEntity((id) => {
+				Debug.Log("CreateEntityIfNeeded", this);
+				entityId = id;
+				if(Ecsact.Defaults.Pool != null) {
+					Ecsact.Defaults.Pool.SetPreferredEntityGameObject(
+						entityId,
+						gameObject
+					);
+				}
+				callback();
+				foreach(var callback in pending_callbacks) {
+					callback();
+				}
+				pending_callbacks.Clear();
+			});
+		} else if(entityId == -1 && callbackPending == true) {
+			pending_callbacks.Add(callback);
+		} else {
+			callback();
 		}
 	}
 
@@ -101,12 +122,14 @@ private void AddInitialEcsactComponents() {
 			for(int i = 0; ecsactComp.otherEntities.Count > i; ++i) {
 				var otherEntity = ecsactComp.otherEntities[i];
 				if(otherEntity != null && otherEntity.entityId == -1) {
-					otherEntity.CreateEntityIfNeeded();
-					var fieldName = ecsactComp.entityFieldNames[i];
-					var compType = ecsactComp.data!.GetType();
-					var field = compType.GetField(fieldName);
-					Debug.Assert(field != null, this);
-					field!.SetValue(ecsactComp.data, otherEntity.entityId);
+					otherEntity.CreateEntityIfNeeded(() => {
+						var fieldName = ecsactComp.entityFieldNames[i];
+						var compType = ecsactComp.data!.GetType();
+						var field = compType.GetField(fieldName);
+						Debug.Log("Add components");
+						Debug.Assert(field != null, this);
+						field!.SetValue(ecsactComp.data, otherEntity.entityId);
+					});
 				}
 			}
 		}
@@ -119,8 +142,7 @@ private void AddInitialEcsactComponents() {
 
 	void OnEnable() {
 		Ecsact.Defaults.WhenReady(() => {
-			CreateEntityIfNeeded();
-			AddInitialEcsactComponents();
+			CreateEntityIfNeeded(() => { AddInitialEcsactComponents(); });
 		});
 	}
 

Runtime/EcsactRunner.cs

@@ -24,8 +24,13 @@ public class EcsactRunner : MonoBehaviour {
 
 	void Start() {
 		Ecsact.Defaults.Runtime.OnEntityCreated((entityId, placeholderId) => {
-			var callback = entityCallbacks.GetAndClearCallback(placeholderId);
-			callback(entityId);
+			EcsactRuntime.EntityIdCallback callback;
+
+			var hasCallback =
+				entityCallbacks.GetAndClearCallback(placeholderId, out callback);
+			if(hasCallback) {
+				callback(entityId);
+			}
 		});
 	}
 
@@ -59,33 +64,33 @@ protected void Execute() {
 			executionOptions.Alloc();
 		}
 
+		var localExecutionOptions = executionOptions;
 		try {
-			LoadEntityCallbacks();
+			executionOptions = new();
+			LoadEntityCallbacks(localExecutionOptions);
 			// NOTE: Temporary, this should be abstracted out
-			executionOptions.executionOptions.createEntities =
-				executionOptions.create_entities_placeholders.ToArray();
-			Ecsact.Defaults.Registry.ExecuteSystems(executionOptions);
+			localExecutionOptions.executionOptions.createEntities =
+				localExecutionOptions.create_entities_placeholders.ToArray();
+			Ecsact.Defaults.Registry.ExecuteSystems(localExecutionOptions);
 		} finally {
-			executionOptions.Free();
+			localExecutionOptions.Free();
 #if UNITY_EDITOR
 			executionTimeWatch.Stop();
-			executionOptions.create_entities_placeholders = new();
+			localExecutionOptions.create_entities_placeholders = new();
 			debugExecutionTimeMs = (int)executionTimeWatch.ElapsedMilliseconds;
 			debugExecutionCountTotal += 1;
 #endif
-
-			executionOptions.executionOptions = new EcsactRuntime.CExecutionOptions();
 		}
 
 		Ecsact.Defaults.Runtime.wasm.PrintAndConsumeLogs();
 	}
 
-	protected void LoadEntityCallbacks() {
-		for(int i = 0; i < executionOptions.create_entities.Count; i++) {
-			var builder = executionOptions.create_entities[i];
+	protected void LoadEntityCallbacks(ExecutionOptions localExecutionOptions) {
+		for(int i = 0; i < localExecutionOptions.create_entities.Count; i++) {
+			var builder = localExecutionOptions.create_entities[i];
 			var id = entityCallbacks.AddCallback(builder.callback);
 			// NOTE: Temporary, this should be abstracted out
-			executionOptions.create_entities_placeholders.Add(id);
+			localExecutionOptions.create_entities_placeholders.Add(id);
 		}
 	}
 }

Runtime/ExecutionEntityCallbacks.cs

@@ -10,13 +10,18 @@ public Int32 AddCallback(EcsactRuntime.EntityIdCallback callback) {
 		return entity_id_counter++;
 	}
 
-	public EcsactRuntime.EntityIdCallback GetAndClearCallback(Int32 placeholderId
+	public bool GetAndClearCallback(
+		Int32 placeholderId,
+		out EcsactRuntime.EntityIdCallback callback
 	) {
-		EcsactRuntime.EntityIdCallback callback;
 		var hasCallback = callbacks.TryGetValue(placeholderId, out callback);
 
-		callbacks.Remove(placeholderId);
-		return callback;
+		if(hasCallback) {
+			callbacks.Remove(placeholderId);
+			return true;
+		}
+
+		return false;
 	}
 
 	private Int32 entity_id_counter = 0;