Fixed missing instigator calls + Inspector Logic fixes for Play From Here +

Editor/PlayFromHere.cs

             EditorPrefs.SetFloat("PlayFromHere.forward.y", forward.y);
             EditorPrefs.SetFloat("PlayFromHere.forward.z", forward.z);
 
+            EditorUtility.DisplayProgressBar("Play From Here", "Entering Play From here mode...", 1.0f);
+
             EditorApplication.isPlaying = true;
         }
 
 
             if (state == PlayModeStateChange.EnteredPlayMode && (PlayerPrefs.GetInt("PlayFromHere") == 1))
             {
+                EditorUtility.ClearProgressBar();
+
                 if (OnPlayFromHere != null)
                 {
                     Vector3 position = new Vector3(

Runtime/Hooks/OnAwakeHook.cs

 
         private void Awake()
         {
-            Callable.Call(onAwake);
+            Callable.Call(onAwake, gameObject);
         }
     }
 }

Runtime/Hooks/OnDestroyHook.cs

 
         private void OnDestroy()
         {
-            Callable.Call(onDestroy);
+            Callable.Call(onDestroy, gameObject);
         }
         
     }

Runtime/Hooks/OnEnableDisableHook.cs

 
         private void OnEnable()
         {
-            Callable.Call(OnEnableEvent);
+            Callable.Call(OnEnableEvent, gameObject);
-            Callable.Call(OnDisableEvent);
+            Callable.Call(OnDisableEvent, gameObject);
         }
     }
 }

Runtime/Hooks/OnKeyDownHook.cs

         void Update()
         {
             if (Input.GetKeyDown(Key))
-                Callable.Call(OnKeyDownEvent);
+                Callable.Call(OnKeyDownEvent, gameObject);
-                Callable.Call(OnKeyUpEvent);
+                Callable.Call(OnKeyUpEvent, gameObject);
         }
     }
 }

Runtime/Hooks/OnMessageHook.cs

 
         void Execute()
         {
-            Callable.Call(OnMessageRecieved);
+            Callable.Call(OnMessageRecieved, gameObject);
         }
 
 

Runtime/Hooks/OnStartHook.cs

 
         private void Start()
         {
-            Callable.Call(OnStart); 
+            Callable.Call(OnStart, gameObject); 
         }
     }
 }

Runtime/Logic/ConditionalLogic.cs

         public override void Execute(GameObject instigator = null)
         {
             if (GetCondition())
-                Callable.Call(OnConditionValid);
+                Callable.Call(OnConditionValid, instigator);
-                Callable.Call(OnConditionInvalid);
+                Callable.Call(OnConditionInvalid, instigator);
         }
 
         public abstract bool GetCondition();

Runtime/Logic/DelayedLogic.cs

 
         IEnumerator m_Coroutine;
 
-        public void Cancel()
+        public void Cancel(GameObject instigator = null)
-                Callable.Call(OnCanceled);
+                Callable.Call(OnCanceled, instigator);
                 m_Coroutine = null;
             }
         }
             if (m_Coroutine != null) Cancel();
 
-            m_Coroutine = RunDelay(Delay);
+            m_Coroutine = RunDelay(Delay, instigator);
-        IEnumerator RunDelay(float Seconds)
+        IEnumerator RunDelay(float Seconds, GameObject instigator = null)
-            Callable.Call(OnDelayComplete);
+            Callable.Call(OnDelayComplete, instigator);
             m_Coroutine = null;
         }
     }

Runtime/Logic/EditorOnlyLogic.cs

     {
         public enum Mode
         {
+            PlayerAndEditor,
             EditorOnly,
             PlayerOnly
         }
 
-        public Mode ExecutionPath;
+        public Mode ExecutionPath = Mode.PlayerAndEditor;
 
         [ReorderableList]
         public Callable[] OnExecute;
+            bool acceptPlayFromHere = !(DisableOnPlayFromHere && (PlayerPrefs.GetInt("PlayFromHere") == 1));
+
-
+                case Mode.PlayerAndEditor:
+                    if (acceptPlayFromHere)
+                        Callable.Call(OnExecute, instigator);
+                    break;
-                    if (Application.isEditor && !(DisableOnPlayFromHere && (PlayerPrefs.GetInt("PlayFromHere") == 1)))
-                        Callable.Call(OnExecute);
+                    if (Application.isEditor && acceptPlayFromHere)
+                        Callable.Call(OnExecute, instigator);
-                    if (!Application.isEditor) Callable.Call(OnExecute);
+                    if (!Application.isEditor && acceptPlayFromHere)
+                        Callable.Call(OnExecute, instigator);
                     break;
             }
         }

Runtime/Logic/NextFrameLogic.cs

 
         public override void Execute(GameObject instigator = null)
         {
-            m_Coroutine = RunDelay();
+            m_Coroutine = RunDelay(instigator);
-        IEnumerator RunDelay()
+        IEnumerator RunDelay(GameObject instigator = null)
-            Callable.Call(OnComplete);
+            Callable.Call(OnComplete, instigator);
             m_Coroutine = null;
         }
     }