Basic Functional Interactions + Refactors

Runtime/Managers/Manager.cs

-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using System;

Runtime/StateMachine/SetStateAction.cs

     {
         [NonNullCheck]
         public StateMachine StateMachine;
-        public string State = "State";
+
+        public string state
+        {
+            get { return m_State; }
+            set { m_State = value; }
+        }
+
+        [SerializeField]
+        protected string m_State = "State";
-                StateMachine.SetState(State);
+                StateMachine.SetState(m_State);
         }
     }
 }

Runtime/Interactions/BasicInteractive.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameplayIngredients.Interactions
+{
+    public class BasicInteractive : Interactive
+    {
+        [Header("Settings")]
+        public float Distance = 1.0f;
+
+        public override bool CanInteract(InteractiveUser user)
+        {
+            return Vector3.Distance(user.transform.position, this.transform.position) < Distance;
+        }
+    }
+}

Runtime/Interactions/BasicInteractiveUser.cs

+using System.Linq;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameplayIngredients.Interactions
+{
+    public class BasicInteractiveUser : InteractiveUser
+    {
+        public Camera Camera;
+        public float InteractionAngle = 60.0f;
+
+        public override bool CanInteract(Interactive interactive)
+        {
+            Vector3 toInteractive = (interactive.transform.position - Camera.transform.position).normalized;
+            return Mathf.Acos(Vector3.Dot(toInteractive, Camera.transform.forward)) < InteractionAngle;
+        }
+
+        public override Interactive[] SortCandidates(IEnumerable<Interactive> candidates)
+        {
+            return candidates.OrderBy(a => Vector3.Distance(a.gameObject.transform.position, this.transform.position)).ToArray();
+        }
+    }
+}
+

Runtime/Interactions/Interaction.cs

+using GameplayIngredients.Actions;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameplayIngredients.Interactions
+{
+    public class Interaction : ActionBase
+    {
+        public InteractiveUser InteractiveUser;
+
+        public override void Execute(GameObject instigator = null)
+        {
+            if (InteractiveUser != null)
+                InteractiveUser.Interact();
+        }
+    }
+}

Runtime/Interactions/Interaction.cs.meta

+fileFormatVersion: 2
+guid: 4401de233d589a14cbba6dffc6dbc8d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Interactions/InteractionManager.cs

+using System.Collections.Generic;
+
+namespace GameplayIngredients.Interactions
+{
+    public static class InteractionManager
+    {
+        static List<Interactive> s_Interactives = new List<Interactive>();
+        
+        public static void RegisterInteractive(Interactive interactive)
+        {
+            s_Interactives.Add(interactive);
+        }
+
+        public static void RemoveInteractive(Interactive interactive)
+        {
+            s_Interactives.Remove(interactive);
+        }
+
+        public static void Interact(InteractiveUser user)
+        {
+            foreach(var interactive in GetCandidates(user))
+            {
+                if (interactive.Interact(user))
+                    break;
+            }
+        }
+
+        private static Interactive[] GetCandidates(InteractiveUser user)
+        {
+            List<Interactive> candidates = new List<Interactive>();
+
+            foreach(var interactive in s_Interactives) 
+            {
+                // Filter interactives at user's reach
+
+                if (interactive.CanInteract(user))
+                    candidates.Add(interactive);
+            }
+
+            return user.SortCandidates(candidates.ToArray());
+        }
+    }
+}

Runtime/Interactions/Interactive.cs

+using GameplayIngredients.Events;
+using NaughtyAttributes;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameplayIngredients.Interactions
+{
+    public abstract class Interactive : EventBase
+    {
+        [Header("Events")]
+        [SerializeField, ReorderableList]
+        protected Callable[] OnInteract;
+
+        protected virtual void OnEnable()
+        {
+            InteractionManager.RegisterInteractive(this);
+        }
+
+        protected virtual void OnDisable()
+        {
+            InteractionManager.RemoveInteractive(this);
+        }
+
+        public bool Interact(InteractiveUser user)
+        {
+            if (user.CanInteract(this) && CanInteract(user))
+            {
+                Callable.Call(OnInteract, user.gameObject);
+                return true;
+            }
+            else
+                return false;
+        }
+
+        public abstract bool CanInteract(InteractiveUser user);
+
+    }
+}

Runtime/Interactions/InteractiveUser.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameplayIngredients.Interactions
+{
+    public abstract class InteractiveUser : MonoBehaviour
+    {
+        public abstract bool CanInteract(Interactive interactive);
+
+        public abstract Interactive[] SortCandidates(IEnumerable<Interactive> candidates);
+
+        public void Interact()
+        {
+            InteractionManager.Interact(this);
+        }
+    }
+}