diff --git a/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs b/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs
index e1a358b6e..e03ccb331 100644
--- a/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs
+++ b/Source/Editor/CustomEditors/Dedicated/ScriptsEditor.cs
@@ -224,16 +224,67 @@ namespace FlaxEditor.CustomEditors.Dedicated
 
         private void AddScripts(List<ScriptType> items)
         {
-            var actions = new List<IUndoAction>(4);
+            var actions = new List<IUndoAction>();
 
             for (int i = 0; i < items.Count; i++)
             {
                 var scriptType = items[i];
+                RequireScriptAttribute scriptAttribute = null;
+                if (scriptType.HasAttribute(typeof(RequireScriptAttribute), false))
+                {
+                    foreach (var e in scriptType.GetAttributes(false))
+                    {
+                        if (e is not RequireScriptAttribute requireScriptAttribute)
+                            continue;
+                        scriptAttribute = requireScriptAttribute;
+                        break;
+                    }
+                }
+
+                // See if script requires a specific actor type
+                RequireActorAttribute actorAttribute = null;
+                if (scriptType.HasAttribute(typeof(RequireActorAttribute), false))
+                {
+                    foreach (var e in scriptType.GetAttributes(false))
+                    {
+                        if (e is not RequireActorAttribute requireActorAttribute)
+                            continue;
+                        actorAttribute = requireActorAttribute;
+                        break;
+                    }
+                }
+
                 var actors = ScriptsEditor.ParentEditor.Values;
                 for (int j = 0; j < actors.Count; j++)
                 {
                     var actor = (Actor)actors[j];
+
+                    // If required actor exists but is not this actor type then skip adding to actor 
+                    if (actorAttribute != null)
+                    {
+                        if (actor.GetType() != actorAttribute.RequiredType && !actor.GetType().IsSubclassOf(actorAttribute.RequiredType))
+                        {
+                            Editor.LogWarning($"`{Utilities.Utils.GetPropertyNameUI(scriptType.Name)}` not added to `{actor}` due to script requiring an Actor type of `{actorAttribute.RequiredType}`.");
+                            continue;
+                        }
+                    }
+
                     actions.Add(AddRemoveScript.Add(actor, scriptType));
+                    // Check if actor has required scripts and add them if the actor does not.
+                    if (scriptAttribute != null)
+                    {
+                        foreach (var type in scriptAttribute.RequiredTypes)
+                        {
+                            if (!type.IsSubclassOf(typeof(Script)))
+                            {
+                                Editor.LogWarning($"`{Utilities.Utils.GetPropertyNameUI(type.Name)}` not added to `{actor}` due to the class not being a subclass of Script.");
+                                continue;
+                            }
+                            if (actor.GetScript(type) != null)
+                                continue;
+                            actions.Add(AddRemoveScript.Add(actor, new ScriptType(type)));
+                        }
+                    }
                 }
             }
 
@@ -585,10 +636,62 @@ namespace FlaxEditor.CustomEditors.Dedicated
                 var values = new ScriptsContainer(elementType, i, Values);
                 var scriptType = TypeUtils.GetObjectType(script);
                 var editor = CustomEditorsUtil.CreateEditor(scriptType, false);
+                
+                // Check if actor has all the required scripts
+                bool hasAllRequirements = true;
+                if (scriptType.HasAttribute(typeof(RequireScriptAttribute), false))
+                {
+                    RequireScriptAttribute scriptAttribute = null;
+                    foreach (var e in scriptType.GetAttributes(false))
+                    {
+                        if (e is not RequireScriptAttribute requireScriptAttribute)
+                            continue;
+                        scriptAttribute = requireScriptAttribute;
+                    }
+
+                    if (scriptAttribute != null)
+                    {
+                        foreach (var type in scriptAttribute.RequiredTypes)
+                        {
+                            if (!type.IsSubclassOf(typeof(Script)))
+                                continue;
+                            var requiredScript = script.Actor.GetScript(type);
+                            if (requiredScript == null)
+                            {
+                                Editor.LogWarning($"`{Utilities.Utils.GetPropertyNameUI(scriptType.Name)}` on `{script.Actor}` is missing a required Script of type `{type}`.");
+                                hasAllRequirements = false;
+                            }
+                        }
+                    }
+                }
+                if (scriptType.HasAttribute(typeof(RequireActorAttribute), false))
+                {
+                    RequireActorAttribute attribute = null;
+                    foreach (var e in scriptType.GetAttributes(false))
+                    {
+                        if (e is not RequireActorAttribute requireActorAttribute)
+                            continue;
+                        attribute = requireActorAttribute;
+                        break;
+                    }
+
+                    if (attribute != null)
+                    {
+                        var actor = script.Actor;
+                        if (actor.GetType() != attribute.RequiredType && !actor.GetType().IsSubclassOf(attribute.RequiredType))
+                        {
+                            Editor.LogWarning($"`{Utilities.Utils.GetPropertyNameUI(scriptType.Name)}` on `{script.Actor}` is missing a required Actor of type `{attribute.RequiredType}`.");
+                            hasAllRequirements = false;
+                            // Maybe call to remove script here?
+                        }
+                    }
+                }
 
                 // Create group
                 var title = Utilities.Utils.GetPropertyNameUI(scriptType.Name);
                 var group = layout.Group(title, editor);
+                if (!hasAllRequirements)
+                    group.Panel.HeaderTextColor = FlaxEngine.GUI.Style.Current.Statusbar.Failed;
                 if ((Presenter.Features & FeatureFlags.CacheExpandedGroups) != 0)
                 {
                     if (Editor.Instance.ProjectCache.IsGroupToggled(title))
diff --git a/Source/Engine/Scripting/Attributes/Editor/RequireActorAttribute.cs b/Source/Engine/Scripting/Attributes/Editor/RequireActorAttribute.cs
new file mode 100644
index 000000000..6e08217bf
--- /dev/null
+++ b/Source/Engine/Scripting/Attributes/Editor/RequireActorAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace FlaxEngine;
+
+/// <summary>
+/// This attribute is used to check for if a script requires an Actor type.
+/// </summary>
+[Serializable]
+[AttributeUsage(AttributeTargets.Class)]
+public class RequireActorAttribute : Attribute
+{
+    /// <summary>
+    /// The required type.
+    /// </summary>
+    public Type RequiredType;
+
+    /// <summary>
+    /// Initializes a new instance of the  <see cref="RequireActorAttribute"/> class.
+    /// </summary>
+    /// <param name="type">The required type.</param>
+    public RequireActorAttribute(Type type)
+    {
+        RequiredType = type;
+    }
+}
diff --git a/Source/Engine/Scripting/Attributes/Editor/RequireScriptAttribute.cs b/Source/Engine/Scripting/Attributes/Editor/RequireScriptAttribute.cs
new file mode 100644
index 000000000..414a13aeb
--- /dev/null
+++ b/Source/Engine/Scripting/Attributes/Editor/RequireScriptAttribute.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace FlaxEngine;
+
+/// <summary>
+/// This attribute is used to check for if a script requires other script types.
+/// </summary>
+[Serializable]
+[AttributeUsage(AttributeTargets.Class)]
+public class RequireScriptAttribute : Attribute
+{
+    /// <summary>
+    /// The required types.
+    /// </summary>
+    public Type[] RequiredTypes;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RequireScriptAttribute"/> class.
+    /// </summary>
+    /// <param name="type">The required type.</param>
+    public RequireScriptAttribute(Type type)
+    {
+        RequiredTypes = new[] { type };
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RequireScriptAttribute"/> class.
+    /// </summary>
+    /// <param name="types">The required types.</param>
+    public RequireScriptAttribute(Type[] types)
+    {
+        RequiredTypes = types;
+    }
+}