Add custom state actions

Fixes #3

Implement custom state actions to enhance the flexibility and functionality of the state machine.

* **Custom Action Interface**:
  - Add `IStateAction` interface with `OnEnter`, `OnExit`, and `OnTransition` methods in `StateMachine/Assets/StateMachine/IStateAction.cs`.
* **State Class Modifications**:
  - Add a list of `IStateAction` to `NewState` class in `StateMachine/Assets/StateMachine/NewState.cs`.
  - Modify `NewState` constructor to initialize the list of `IStateAction`.
* **State Machine Modifications**:
  - Add methods to execute custom actions on state enter, exit, and transition in `StateMachine/Assets/StateMachine/NewestStateMachine.cs`.
  - Modify `SetState` method to call custom actions.
* **Custom Action Implementation**:
  - Implement `CustomAction` class inheriting from `MonoBehaviour` and `IStateAction` in `StateMachine/Assets/StateMachine/CustomAction.cs`.
  - Define `OnEnter`, `OnExit`, and `OnTransition` methods with custom behaviors.
* **UI Integration**:
  - Create a UI script to attach custom actions to states in `StateMachine/Assets/StateMachine/StateMachineUI.cs`.
  - Provide methods to define specific behaviors for each action.
* **Exception Handling**:
  - Add exception handling in `SetData` method in `StateMachine/Assets/Tool Box #2/Data/BoolData.cs`.

---

For more details, open the [Copilot Workspace session](https://copilot-workspace.githubnext.com/MarquisMc/StateMachine/issues/3?shareId=XXXX-XXXX-XXXX-XXXX).

StateMachine/Assets/StateMachine/CustomAction.cs

@@ -0,0 +1,21 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CustomAction : MonoBehaviour, IStateAction
+{
+    public void OnEnter()
+    {
+        Debug.Log("Entering state...");
+    }
+
+    public void OnExit()
+    {
+        Debug.Log("Exiting state...");
+    }
+
+    public void OnTransition()
+    {
+        Debug.Log("Transitioning state...");
+    }
+}

StateMachine/Assets/StateMachine/IStateAction.cs

@@ -0,0 +1,10 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public interface IStateAction
+{
+    void OnEnter();
+    void OnExit();
+    void OnTransition();
+}

StateMachine/Assets/StateMachine/NewState.cs

@@ -13,10 +13,13 @@ public class NewState
 
     public List<StateTransition> stateTransitions = new List<StateTransition>();
 
+    public List<IStateAction> actions = new List<IStateAction>();
+
     public NewState(string stateName, StateExtension stateScript)
     {
         this.stateName = stateName;
         this.stateScript = stateScript;
+        this.actions = new List<IStateAction>();
     }
 }
 
@@ -25,4 +28,4 @@ public class StateTransition
 {
     public string stateTransitionName;
     public BoolData boolData;
-}
+}

StateMachine/Assets/StateMachine/NewestStateMachine.cs

@@ -34,6 +34,7 @@ void Start()
             currentState = states.Contains(states[0]) ? states[0] : null;
             orginalState = currentState;
             stateDictionary[currentState].enabled = true;
+            ExecuteOnEnterActions(currentState);
         }
     }
 
@@ -72,12 +73,14 @@ public void SetState(NewState newState)
 
         if (newState != currentState)
         {
+            ExecuteOnExitActions(currentState);
             previousState = currentState;
             currentState = newState;
 
             stateDictionary[previousState].enabled = false;
             stateDictionary[orginalState].enabled = false;
             stateDictionary[currentState].enabled = true;
+            ExecuteOnEnterActions(currentState);
         }
     }
 
@@ -113,6 +116,7 @@ void StateTransition()
             {
                 if (stateTransition.boolData.GetData())
                 {
+                    ExecuteOnTransitionActions(currentState);
                     SetState(states.Find(state => state.stateName == stateTransition.stateTransitionName));
                     stateTransition.boolData.SetData(false);
                 }
@@ -121,6 +125,51 @@ void StateTransition()
 
     }
 
+    void ExecuteOnEnterActions(NewState state)
+    {
+        foreach (var action in state.actions)
+        {
+            try
+            {
+                action.OnEnter();
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogError($"Error executing OnEnter action: {ex.Message}");
+            }
+        }
+    }
+
+    void ExecuteOnExitActions(NewState state)
+    {
+        foreach (var action in state.actions)
+        {
+            try
+            {
+                action.OnExit();
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogError($"Error executing OnExit action: {ex.Message}");
+            }
+        }
+    }
+
+    void ExecuteOnTransitionActions(NewState state)
+    {
+        foreach (var action in state.actions)
+        {
+            try
+            {
+                action.OnTransition();
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogError($"Error executing OnTransition action: {ex.Message}");
+            }
+        }
+    }
+
     // Update is called once per frame
     void Update()
     {
@@ -175,4 +224,4 @@ void Update()
 //             EditorUtility.SetDirty(stateMachine);
 //         }
 //     }
-// }
+// }

StateMachine/Assets/StateMachine/StateMachineUI.cs

@@ -0,0 +1,59 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class StateMachineUI : MonoBehaviour
+{
+    public Dropdown stateDropdown;
+    public Button addActionButton;
+    public InputField actionInputField;
+    public NewestStateMachine stateMachine;
+
+    void Start()
+    {
+        PopulateStateDropdown();
+        addActionButton.onClick.AddListener(AddActionToState);
+    }
+
+    void PopulateStateDropdown()
+    {
+        stateDropdown.ClearOptions();
+        List<string> stateNames = new List<string>();
+        foreach (var state in stateMachine.states)
+        {
+            stateNames.Add(state.stateName);
+        }
+        stateDropdown.AddOptions(stateNames);
+    }
+
+    void AddActionToState()
+    {
+        string selectedStateName = stateDropdown.options[stateDropdown.value].text;
+        NewState selectedState = stateMachine.states.Find(state => state.stateName == selectedStateName);
+
+        if (selectedState != null)
+        {
+            string actionName = actionInputField.text;
+            IStateAction newAction = CreateAction(actionName);
+            if (newAction != null)
+            {
+                selectedState.actions.Add(newAction);
+                Debug.Log($"Action {actionName} added to state {selectedStateName}");
+            }
+            else
+            {
+                Debug.LogError($"Failed to create action: {actionName}");
+            }
+        }
+    }
+
+    IStateAction CreateAction(string actionName)
+    {
+        // Here you can implement logic to create different types of actions based on the actionName
+        // For simplicity, we will just create a CustomAction
+        GameObject actionObject = new GameObject(actionName);
+        CustomAction customAction = actionObject.AddComponent<CustomAction>();
+        return customAction;
+    }
+}

StateMachine/Assets/Tool Box #2/Data/BoolData.cs

@@ -13,8 +13,15 @@ public class BoolData : DataBase
     // Set the bool
     public void SetData(bool newData)
     {
-        data = newData;
-        //Debug.Log(data);
+        try
+        {
+            data = newData;
+            //Debug.Log(data);
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError($"Error setting data: {ex.Message}");
+        }
     }
 
     // when a bool is true turn another bool false