1

Unity/Scripts/StateMachine/MonoProxy.cs

@@ -0,0 +1,40 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+namespace BITKit
+{
+    public interface IMonoProxy
+    {
+
+    }
+    public class MonoProxy : Mono
+    {
+        [SerializeReference, SubclassSelector] public IMonoProxy proxy;
+        BehaviorUpdater updater = new();
+        protected override void Awake()
+        {
+            updater.Init(proxy);
+            updater.OnAwake();
+        }
+        protected override void Start()
+        {
+            updater.OnStart();
+        }
+        protected override void Update()
+        {
+            updater.OnUpdate(Time.deltaTime);
+        }
+        protected override void FixedUpdate()
+        {
+            updater.OnFixedUpdate(Time.fixedDeltaTime);
+        }
+        protected override void LateUpdate()
+        {
+            updater.OnLateUpdate(Time.deltaTime);
+        }
+        protected override void OnDestroy()
+        {
+            updater.OnDestroy();
+        }
+    }
+}

Unity/Scripts/StateMachine/MonoStateMachine.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+namespace BITKit.StateMachine
+{
+    [System.Serializable]
+    public abstract class MonoStateMachine<TState> : IStateMachine<TState>, IMonoProxy, IStart, IUpdate
+    where TState : IState
+    {
+        [Header(Constant.Header.Settings)]
+        public string name;
+        [Header(Constant.Header.Settings)]
+        [SerializeField, SerializeReference, SubclassSelector]
+        TState currentState;
+        public TState CurrentState
+        {
+            get => currentState;
+            set => currentState = value;
+        }
+        [Header(Constant.Header.Components)]
+        [SerializeReference, SubclassSelector] public List<TState> states = new();
+        public IDictionary<Type, TState> StateDictonary { get; } = new Dictionary<Type, TState>();
+        public IStateMachine<TState> StateMachine => this as IStateMachine<TState>;
+        TState tempState;
+        public virtual void OnStart()
+        {
+            foreach (var state in states)
+            {
+                //state.TransitionState = InternalTransitionState;
+                state.Initialize();
+                StateDictonary.Add(state.GetType(), state);
+            }
+            if (states.Count > 0)
+            {
+                var index = states[0];
+                StateMachine.TransitionState(index);
+            }
+        }
+        public virtual void ExitState()
+        {
+            CurrentState?.OnStateExit(CurrentState, null);
+            CurrentState = default;
+        }
+        public virtual void RecoveryState()
+        {
+            if (tempState is not null)
+            {
+                StateMachine.TransitionState(tempState);
+            }
+            else
+            {
+                StateMachine.TransitionState(states[0]);
+            }
+        }
+        public virtual void OnUpdate(float deltaTime)
+        {
+            CurrentState?.OnStateUpdate();
+        }
+        void InternalTransitionState(IState state)
+        {
+            if (state is TState tState)
+            {
+                StateMachine.TransitionState(tState);
+            }
+        }
+    }
+}

Unity/Scripts/StateMachine/Tests/TestMonoStateMachine.cs

@@ -0,0 +1,39 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using BITKit;
+using BITKit.StateMachine;
+namespace BITKit.StateMachine.Tests
+{
+    public interface ITestState : IState { }
+    [System.Serializable]
+    public class TestState : ITestState
+    {
+        public void Initialize()
+        {
+        }
+
+        public void OnStateEnter(IState old)
+        {
+        }
+
+        public void OnStateExit(IState old, IState newState)
+        {
+        }
+
+        public void OnStateUpdate()
+        {
+        }
+    }
+    [System.Serializable]
+    public class TestState1 : TestState { }
+    [System.Serializable]
+    public class TestState2 : TestState { }
+    [System.Serializable]
+    public class TestState3 : TestState { }
+    [System.Serializable]
+    public class TestMonoStateMachine : MonoStateMachine<ITestState>
+    {
+
+    }
+}