- Implemented EntityTemplate feature

- Build fix

Author: Watcher3056

Entity System/Unity Layer/Actor.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using TriInspector;
-using UnityEditor;
 using UnityEngine;
 
 namespace EasyCS
@@ -84,6 +83,9 @@ public Actor Root
         private Dictionary<Type, ActorComponent> _actorComponents = new Dictionary<Type, ActorComponent>();
         private readonly Dictionary<Type, object> _actorComponentsAndData = new();
 
+        [field: SerializeField]
+        public EntityTemplateAsset EntityTemplate { get; private set; }
+
         [SerializeField, ReadOnly]
         private List<ActorComponent> _allComponents = new List<ActorComponent>();
 
@@ -96,7 +98,8 @@ public Actor Root
         [ShowInInspector, ReadOnly, ShowIf("EditorHasMissingEntityComponentsDependencies"),
             LabelText("Missing Entity Dependencies"),
          ListDrawerSettings(AlwaysExpanded = true),
-         InfoBox("Entity Dependencies is not resolved! Default instances will be created.", TriMessageType.Warning, "EditorHasMissingEntityComponentsDependencies")]
+         InfoBox("Entity Dependencies is not resolved! Default instances will be created.", TriMessageType.Warning, "EditorHasMissingEntityComponentsDependencies"),
+            MaxDrawDepth(2)]
         private List<IEntityComponent> EditorEntityComponentsMissingRequired
         {
             get
@@ -566,6 +569,7 @@ int GetPriority(Component c)
             foreach (var component in _allComponents)
                 component.SetActor(this);
 
+            EditorApplyEntityTemplate();
             EditorValidateAllComponentDependencies();
             ValidateSetup();
             EditorUpdateUnusedDependencies();
@@ -685,6 +689,45 @@ private void EditorValidateActorComponentsDependencies()
             EditorUpdateMissingActorDependenciesList();
         }
 
+        private void EditorApplyEntityTemplate()
+        {
+            if (EntityTemplate == null)
+                return;
+
+            var componentTypes = EntityTemplate.GetComponentTypes();
+
+            List<Type> providersToAdd = new List<Type>();
+
+            foreach (var type in componentTypes)
+            {
+                Type providerType = EntityComponentProviderFinder.FindEntityComponentProviderMatching(type);
+
+                if (providerType != null)
+                {
+                    if (_allComponents.Exists(c => c.GetType() == providerType))
+                        continue;
+                    if (_entityComponentsMissing.Exists(c => c.GetType() == type))
+                        continue;
+
+                    providersToAdd.Add(providerType);
+                }
+            }
+
+            if (providersToAdd.Count > 0)
+            {
+                UnityEditor.EditorApplication.delayCall += () =>
+                {
+                    if (this == null) return;
+
+                    foreach (var provider in providersToAdd)
+                        if (gameObject.GetComponent(provider) == null)
+                            UnityEditor.Undo.AddComponent(gameObject, provider);
+
+                    UnityEditor.EditorUtility.SetDirty(gameObject);
+                };
+            }
+        }
+
         public List<string> EditorGetMissingDependenciesNamesForAllComponents(EditorDependenciesType dependenciesType)
         {
             List<string> missingList = EditorGetMissingDependenciesForAllComponents(dependenciesType)
@@ -833,6 +876,12 @@ public List<ActorComponent> EditorGetUnusedActorComponentsForComponent(ActorComp
         }
 
         public bool EditorHasUnusedDependencies() => _editorUnusedDependencies.Count > 0;
+
+        public void EditorSetEntityTemplate(EntityTemplateAsset entityTemplateAsset)
+        {
+            EntityTemplate = entityTemplateAsset;
+            EditorApplyEntityTemplate();
+        }
 #endif
     }
 }

Factory System/Editor/EntityPrefabBuilder.cs

@@ -131,7 +131,7 @@ public static GameObject BuildEntityObject(EntityData entityData, Transform curr
         {
             GameObject entityGO = current == null ? new GameObject() : current.gameObject;
             entityGO.AddComponent<EntityEditorComponentFlag>().hideFlags = HideFlags.HideInInspector;
-            entityGO.AddComponent<Actor>();
+            Actor actor= entityGO.AddComponent<Actor>();
 
             if (string.IsNullOrEmpty(entityData.Name) == false)
                 entityGO.name = entityData.Name;
@@ -186,6 +186,8 @@ public static GameObject BuildEntityObject(EntityData entityData, Transform curr
                 }
             }
 
+            actor.EditorSetEntityTemplate(entityData.Template);
+
             return entityGO;
         }
 

Factory System/Editor/PrefabEditSessionManager.cs

@@ -122,6 +122,8 @@ private static EntityFactory.EntityData BuildEntityDataRecursive(Transform trans
                 entityData.ChildEntities.Add(childEntityData);
             }
 
+            entityData.Template = transform.GetComponent<Actor>().EntityTemplate;
+
             return entityData;
         }
     }

Factory System/EntityFactory.cs

@@ -23,6 +23,7 @@ public class EntityData
 
             [ListDrawerSettings(AlwaysExpanded = true), OnValueChanged("EditorValidate")]
             public List<ComponentData> Components = new List<ComponentData>();
+            public EntityTemplateAsset Template;
             [Required]
             public List<EntityFactory> NestedFactories = new List<EntityFactory>();
 

Factory System/Helpers/EntityComponentProviderFinder.cs

@@ -0,0 +1,25 @@
+using System;
+using UnityEngine;
+
+namespace EasyCS
+{
+    public static class EntityComponentProviderFinder
+    {
+        public static Type FindEntityComponentProviderMatching(Type targetType)
+        {
+            if (typeof(IEntityData).IsAssignableFrom(targetType))
+            {
+                return EntityDataProviderFinder.FindEntityDataProviderMatching(targetType);
+            }
+            else if (typeof(IEntityBehavior).IsAssignableFrom(targetType))
+            {
+                return EntityBehaviorProviderFinder.FindEntityBehaviorProviderMatching(targetType);
+            }
+            else
+            {
+                Debug.LogError(string.Format("Not found provider for type {type}", targetType));
+                return null;
+            }
+        }
+    }
+}

Factory System/Helpers/EntityComponentProviderFinder.cs.meta

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace EasyCS
+{
+    public static class EntityDependencyHelper
+    {
+        public static List<Type> EditorGetMissingEntityBehaviorDependencies(IEnumerable<IEntityComponent> allComponents)
+        {
+            List<Type> missingBehaviors = new List<Type>();
+
+            // Collect all existing IEntityBehavior types from the provided components
+            HashSet<Type> existingBehaviorTypes = new HashSet<Type>(
+                allComponents
+                    .OfType<IEntityBehavior>() // Directly existing behaviors
+                    .Select(c => c.GetType())
+            );
+
+            // Also consider types provided by IEntityBehaviorProvider
+            foreach (var comp in allComponents.OfType<IEntityBehaviorProvider>())
+            {
+                existingBehaviorTypes.Add(comp.GetEntityComponentType());
+            }
+
+            // Iterate through all components to find what they require
+            foreach (var component in allComponents)
+            {
+                if (component == null) continue;
+
+                Type componentType = null;
+                // Determine the type to get dependencies for.
+                // If it's an IEntityBehaviorProvider, use its provided type.
+                // Otherwise, use the component's own type.
+                if (component is IEntityBehaviorProvider entityBehaviorProvider)
+                    componentType = entityBehaviorProvider.GetEntityComponentType();
+                else
+                    componentType = component.GetType();
+
+                var requiredTypes = Injector.GetRequiredInjectionTypes(componentType);
+
+                foreach (var depType in requiredTypes)
+                {
+                    // Check if the dependency is an IEntityBehavior
+                    if (typeof(IEntityBehavior).IsAssignableFrom(depType))
+                    {
+                        // Ignore runtime-only components for editor-time missing checks
+                        if (Attribute.IsDefined(depType, typeof(RuntimeOnlyAttribute)))
+                            continue;
+
+                        // If the required behavior type is not already existing
+                        if (!existingBehaviorTypes.Contains(depType))
+                        {
+                            // And it's not already in our missing list (to avoid duplicates)
+                            if (!missingBehaviors.Contains(depType))
+                            {
+                                missingBehaviors.Add(depType);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return missingBehaviors;
+        }
+    }
+}