1

Src/Core/StateMachine/AsyncStateMachine.cs

@@ -1,9 +1,9 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
 using Cysharp.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
+using Random = UnityEngine.Random;
 
 namespace BITKit.StateMachine
 {
@@ -11,15 +11,8 @@ namespace BITKit.StateMachine
     /// 动态异步状态机
     /// </summary>
     /// <typeparam name="T">异步状态</typeparam>
-    public class AsyncStateMachine<T>:IStateMachine<T> ,IDisposable where T  : IStateAsync
+    public class AsyncStateMachine<T>:IStateMachine<T> ,IDisposable where T  : class, IStateAsync
     {
-        private enum AsyncState
-        {
-            Initializing,
-            InEntering,
-            InExiting,
-        }
-
         private readonly IServiceProvider _serviceProvider;
         public AsyncStateMachine(IServiceProvider serviceProvider)
         {
@@ -31,113 +24,153 @@ namespace BITKit.StateMachine
         }
 
         public bool Enabled { get; set; } = true;
-        public T CurrentState { get; set; }
+        public T CurrentState { get;private set; }
+        public T NextOrCurrentState => _nextTargetState.IfNotAllow(CurrentState);
         private T _nextState;
         public event Action<T, T> OnStateChanging;
         public event Action<T, T> OnStateChanged;
         public event Action<T> OnStateRegistered;
+        public IReadOnlyDictionary<int, T> Dictionary => _dictionary;
         public event Action<T> OnStateUnRegistered;
         public IDictionary<Type, T> StateDictionary { get; } = new Dictionary<Type, T>();
+        public readonly ValidHandle IsBusy=new();
         private readonly CancellationTokenSource _cancellationTokenSource=new();
-        private readonly ValidHandle _isBusy=new();
-        private readonly ConcurrentQueue<(UniTask task,AsyncState state,T value)> _taskQueue=new(); 
-        public void Initialize()
+        private readonly Dictionary<int, T> _dictionary = new();
+        private readonly Optional<T> _nextTargetState = new();
+        public async void Initialize()
         {
+            await IsBusy;
+            if(_cancellationTokenSource.IsCancellationRequested)return;
+            using var _ = IsBusy.GetHandle();
             foreach (var (_,value) in StateDictionary)
             {
-                _taskQueue.Enqueue(new (value.InitializeAsync(),AsyncState.Initializing,value));
+                await value.InitializeAsync();
+                value.Initialize();
             }
         }
 
+
         public async void UpdateState(float deltaTime)
         {
-            if(Enabled is false)return;
-            CurrentState?.OnStateUpdate(deltaTime);
-            if(_isBusy)return;
-            using var _ = _isBusy.GetHandle();
-            if (!_taskQueue.TryDequeue(out var task))
-            {
-                if(Enabled is false)return;
-                if (CurrentState is not null)
-                {
-                    await CurrentState.OnStateUpdateAsync(deltaTime);
-                }
-                return;
-            }
-            await task.task;
-            if(_cancellationTokenSource.IsCancellationRequested|| Enabled is false)return;
-            switch (task.state)
-            {
-                case AsyncState.Initializing:
-                    task.value.Initialize();
-                    OnStateRegistered?.Invoke(task.value);
-                    break;
-                case AsyncState.InEntering:
-                    if (_nextState is not null)
-                    {
-                        _nextState.OnStateEntry(_nextState);
-                        OnStateChanged?.Invoke(CurrentState,_nextState);
-                    }
-                    else
-                    {
-                        OnStateChanged?.Invoke(CurrentState,default);
-                    }
-                    CurrentState = _nextState;
-                    break;
-                case AsyncState.InExiting:
-                    CurrentState?.OnStateExit(CurrentState,_nextState);
-                    break;
-            }
-
-  
-            
+            if (CurrentState is null) return;
+            using var _ = IsBusy.GetHandle();
+            await CurrentState.OnStateUpdateAsync(deltaTime);
+            CurrentState.OnStateUpdate(deltaTime);
         }
 
-        public void DisposeState()
+
+        public async void DisposeState()
         {
-            _taskQueue.Clear();
-            if (CurrentState is not null)
-            {
-                _taskQueue.Enqueue(new(CurrentState.OnStateExitAsync(CurrentState,null),AsyncState.InExiting,CurrentState));
-            }
+            await IsBusy;
+            if(_cancellationTokenSource.IsCancellationRequested)return;
+            if (CurrentState is null) return;
+            using var _ = IsBusy.GetHandle();
+            await CurrentState.OnStateExitAsync(CurrentState, null);
+            if(_cancellationTokenSource.IsCancellationRequested)return;
+            CurrentState.OnStateExit(CurrentState, null);
+            CurrentState = null;
         }
 
         public T TransitionState<TState>() where TState : T
         {
             T nextState;
-            foreach (var (type, value) in StateDictionary)
+            foreach (var (type, value) in Dictionary)
             {
-                if (!type.IsAssignableFrom(typeof(TState))) continue;
+                if ((typeof(TState) == value.GetType()) is false) continue;
+                
                 nextState = value;
                 
                 TransitionState(nextState);
                 return nextState;
             }
             nextState = _serviceProvider.GetRequiredService<TState>();
-            _taskQueue.Enqueue(new(nextState.InitializeAsync(),AsyncState.Initializing,nextState));
+
             return  TransitionState(nextState);;
         }
+
+        public async UniTask TransitionStateAsync(T nextState)
+        {
+            if (nextState is not null)
+            {
+                if (nextState.Identifier == 0)
+                {
+                    nextState.Identifier = nextState.GetHashCode();
+                }
+            }
+            if (Equals(nextState, CurrentState)) return;
+            if(_nextTargetState.Allow && Equals(_nextTargetState.Value,nextState))return;
+            if (_nextTargetState.Allow)
+            {
+                _nextTargetState.Value = nextState;
+                return;
+            }
+            _nextTargetState.SetValueThenAllow(nextState);
+            await IsBusy;
+            if(_cancellationTokenSource.IsCancellationRequested)return;
+            using var _ = IsBusy.GetHandle();
+            OnStateChanging?.Invoke(CurrentState,nextState);
+            if (_dictionary.TryAdd(nextState.Identifier, nextState))
+            {
+                await nextState.InitializeAsync();
+                if(_cancellationTokenSource.IsCancellationRequested)return;
+                nextState.Initialize();
+            }
+            if (CurrentState is not null)
+            {
+                CurrentState.Enabled = false;
+                await CurrentState.OnStateExitAsync(CurrentState, nextState);
+                if(_cancellationTokenSource.IsCancellationRequested)return;
+                CurrentState.OnStateExit(CurrentState,nextState);
+            }
+
+            var tempState = CurrentState;
+            CurrentState = _nextTargetState.Value;
+            _nextTargetState.Clear();
+            nextState.Enabled = true;
+            await nextState.OnStateEntryAsync(tempState);
+            if(_cancellationTokenSource.IsCancellationRequested)return;
+            nextState.OnStateEntry(tempState);
+           OnStateChanged?.Invoke(tempState,nextState);
+    
+        }
         public T TransitionState(T nextState)
         {
-            if(Equals(CurrentState,nextState))return nextState;
-            OnStateChanging?.Invoke(CurrentState,nextState);
-            if (CurrentState is not null)
-            {
-                _taskQueue.Enqueue(new(CurrentState.OnStateExitAsync(CurrentState,nextState),AsyncState.InExiting,CurrentState));
-            }
-
-            if (nextState is not null)
-            {
-                _taskQueue.Enqueue(new(nextState.OnStateEntryAsync(nextState),AsyncState.InEntering,nextState));
-            }
-            return _nextState= nextState;
+            TransitionStateAsync(nextState).Forget();
+            return nextState;
         }
 
+        public async void UnRegister(T newState)
+        {
+            if (newState is null) return;
+            if (Dictionary.ContainsKey(newState.Identifier) is false) return;
+            _dictionary.Remove(newState.Identifier);
+
+            if (Equals(CurrentState, newState))
+            {
+                await CurrentState.OnStateExitAsync(CurrentState, null);
+                CurrentState.OnStateExit(CurrentState, null);
+                if (CurrentState is IAsyncDisposable asyncDisposable)
+                {
+                    await asyncDisposable.DisposeAsync();
+                }
+                if (CurrentState is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+                CurrentState = null;
+            }
+            
+            OnStateUnRegistered?.Invoke(newState);
+        }
         public void Dispose()
         {
+            if(_isDisposed)return;
             _cancellationTokenSource.Cancel();
             _cancellationTokenSource.Dispose();
+            _isDisposed = true;
         }
+
+        private bool _isDisposed;
     }
 
 }

Src/Core/StateMachine/IStateMachine.cs

@@ -47,7 +47,7 @@ namespace BITKit.StateMachine
     public interface IStateMachine<T> where T:IState
     {
         bool Enabled { get; set; }
-        T CurrentState { get; set; }
+        T CurrentState { get; }
         event Action<T,T> OnStateChanged;
         event Action<T> OnStateRegistered;
         event Action<T> OnStateUnRegistered;