Merge pull request #37 from bazyleu/bugfix/go-back-fix

Bugfix/go back fix

Assets/UniState/Runtime/Core/StateMachine/StateMachine.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Threading;
 using Cysharp.Threading.Tasks;
-using UniState;
 
 namespace UniState
 {
@@ -32,15 +31,15 @@ private async UniTask ExecuteInternal(StateTransitionInfo initialTransition, Can
             var activeStateMetadata = new StateWithMetadata();
             var nextStateMetadata = new StateWithMetadata();
 
-            activeStateMetadata.SetData(initialTransition.Creator.Create(), initialTransition.StateBehaviourData);
+            activeStateMetadata.BuildState(initialTransition, initialTransition.StateBehaviourData);
 
             try
             {
                 await InitializeSafe(activeStateMetadata.State, token);
 
                 var transitionInfo = await ExecuteSafe(activeStateMetadata.State, token);
 
-                ProcessTransitionInfo(transitionInfo, ref nextStateMetadata);
+                ProcessTransitionInfo(transitionInfo, activeStateMetadata.TransitionInfo, nextStateMetadata);
 
                 while (!nextStateMetadata.IsEmpty && !token.IsCancellationRequested)
                 {
@@ -55,11 +54,11 @@ private async UniTask ExecuteInternal(StateTransitionInfo initialTransition, Can
                         await InitializeSafe(nextStateMetadata.State, token);
                     }
 
-                    activeStateMetadata.SetData(nextStateMetadata);
+                    activeStateMetadata.CopyData(nextStateMetadata);
 
                     transitionInfo = await ExecuteSafe(activeStateMetadata.State, token);
 
-                    ProcessTransitionInfo(transitionInfo, ref nextStateMetadata);
+                    ProcessTransitionInfo(transitionInfo, activeStateMetadata.TransitionInfo, nextStateMetadata);
                 }
 
                 await ExitAndDisposeSafe(activeStateMetadata.State, token);
@@ -90,20 +89,29 @@ private void OnError(Exception exception, StateMachineErrorType phase)
             //Call Handler
         }
 
-        private void ProcessTransitionInfo(StateTransitionInfo transitionInfo, ref StateWithMetadata stateWithMetadata)
+        private void ProcessTransitionInfo(StateTransitionInfo nextTransition,
+            StateTransitionInfo previousTransition,
+            StateWithMetadata stateWithMetadata)
         {
             stateWithMetadata.Clear();
 
-            if (transitionInfo.Transition != TransitionType.Exit)
+            if (nextTransition.Transition == TransitionType.Exit)
             {
-                var item = transitionInfo.Transition == TransitionType.State
-                    ? _history.Push(transitionInfo)
-                    : GetInfoFromHistory();
+                return;
+            }
 
-                if (item != null)
-                {
-                    stateWithMetadata.SetData(item.Creator.Create(), item.StateBehaviourData);
-                }
+            var transitionToState = nextTransition.Transition == TransitionType.State;
+
+            var item = transitionToState ? nextTransition : GetInfoFromHistory();
+
+            if (transitionToState && previousTransition != null)
+            {
+                _history.Push(previousTransition);
+            }
+
+            if (item != null)
+            {
+                stateWithMetadata.BuildState(item, item.StateBehaviourData);
             }
         }
 

Assets/UniState/Runtime/Core/StateMachine/StateWithMetadata.cs

@@ -5,36 +5,42 @@ namespace UniState
 {
     public class StateWithMetadata : IDisposable
     {
+        public StateTransitionInfo TransitionInfo { get; private set; }
         public IExecutableState State { get; private set; }
         public StateBehaviourData BehaviourData { get; private set; }
 
-        private bool _disposed = false;
+        private bool _disposed;
 
         public bool IsEmpty => State == null;
 
-        public void SetData(IExecutableState state, StateBehaviourData behaviourData)
+        public void BuildState(StateTransitionInfo transitionInfo, StateBehaviourData behaviourData)
         {
-            State = state;
+            TransitionInfo = transitionInfo;
+            State = transitionInfo.Creator.Create();
             BehaviourData = behaviourData;
+
             _disposed = false;
         }
 
-        public void SetData(StateWithMetadata data)
+        public void CopyData(StateWithMetadata data)
         {
             if (data != null)
             {
+                TransitionInfo = data.TransitionInfo;
                 State = data.State;
                 BehaviourData = data.BehaviourData;
             }
             else
             {
                 Clear();
             }
+
             _disposed = false;
         }
 
         public void Clear()
         {
+            TransitionInfo = null;
             State = null;
             BehaviourData = null;
             _disposed = false;

Assets/UniStateTests/PlayMode/Common/IStateLogger.cs

@@ -0,0 +1,9 @@
+namespace UniStateTests.PlayMode.Common
+{
+    //TODO: Refactor to more complex logger
+    public interface IStateLogger
+    {
+        void LogLine(string line);
+        string GetFullLog();
+    }
+}

Assets/UniStateTests/PlayMode/Common/StateLogger.cs

@@ -0,0 +1,11 @@
+using System.Text;
+
+namespace UniStateTests.PlayMode.Common
+{
+    public class StateLogger : IStateLogger
+    {
+        private readonly StringBuilder _stringBuilder = new(500);
+        public void LogLine(string line) => _stringBuilder.AppendLine(line);
+        public string GetFullLog() => _stringBuilder.ToString();
+    }
+}

Assets/UniStateTests/PlayMode/GoBack/GoBackTestFlags.cs

@@ -0,0 +1,8 @@
+namespace UniStateTests.PlayMode.GoBack
+{
+    public class GoBackTestFlags
+    {
+        public bool ExecutedState1 = false;
+        public bool ExecutedState2 = false;
+    }
+}

Assets/UniStateTests/PlayMode/GoBack/StateGoBack1.cs

@@ -0,0 +1,35 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UniState;
+using UniStateTests.PlayMode.Common;
+
+namespace UniStateTests.PlayMode.GoBack
+{
+    public class StateGoBack1 : StateBase
+    {
+        private readonly IStateLogger _stateLogger;
+        private readonly GoBackTestFlags _flags;
+
+        public StateGoBack1(IStateLogger stateLogger, GoBackTestFlags flags)
+        {
+            _stateLogger = stateLogger;
+            _flags = flags;
+        }
+
+        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        {
+            _stateLogger.LogLine("StateGoBack1 - Execute");
+
+            await UniTask.Yield();
+
+            if (_flags.ExecutedState1)
+            {
+                return Transition.GoBack();
+            }
+
+            _flags.ExecutedState1 = true;
+
+            return Transition.GoTo<StateGoBack2>();
+        }
+    }
+}

Assets/UniStateTests/PlayMode/GoBack/StateGoBack2.cs

@@ -0,0 +1,35 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UniState;
+using UniStateTests.PlayMode.Common;
+
+namespace UniStateTests.PlayMode.GoBack
+{
+    public class StateGoBack2 : StateBase
+    {
+        private readonly IStateLogger _stateLogger;
+        private readonly GoBackTestFlags _flags;
+
+        public StateGoBack2(IStateLogger stateLogger, GoBackTestFlags flags)
+        {
+            _stateLogger = stateLogger;
+            _flags = flags;
+        }
+
+        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        {
+            _stateLogger.LogLine("StateGoBack2 - Execute");
+
+            await UniTask.Yield();
+
+            if (_flags.ExecutedState2)
+            {
+                return Transition.GoBack();
+            }
+
+            _flags.ExecutedState2 = true;
+
+            return Transition.GoTo<StateGoBack3>();
+        }
+    }
+}

Assets/UniStateTests/PlayMode/GoBack/StateGoBack3.cs

@@ -0,0 +1,28 @@
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using UniState;
+using UniStateTests.PlayMode.Common;
+
+namespace UniStateTests.PlayMode.GoBack
+{
+    public class StateGoBack3 : StateBase
+    {
+        private readonly IStateLogger _stateLogger;
+        private readonly GoBackTestFlags _flags;
+
+        public StateGoBack3(IStateLogger stateLogger, GoBackTestFlags flags)
+        {
+            _stateLogger = stateLogger;
+            _flags = flags;
+        }
+
+        public override async UniTask<StateTransitionInfo> Execute(CancellationToken token)
+        {
+            _stateLogger.LogLine("StateGoBack3 - Execute");
+
+            await UniTask.Yield();
+
+            return Transition.GoBack();
+        }
+    }
+}

Assets/UniStateTests/PlayMode/GoBackTests.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections;
+using System.Threading;
+using Cysharp.Threading.Tasks;
+using NUnit.Framework;
+using UniState;
+using UniStateTests.PlayMode.Common;
+using UniStateTests.PlayMode.GoBack;
+using UnityEngine.TestTools;
+using Zenject;
+
+namespace UniStateTests.PlayMode
+{
+    [TestFixture]
+    public class GoBackTests
+    {
+        [UnityTest]
+        public IEnumerator RunChaneOfState_GoBackFromTheChain_ExitFromStateMachineWithCorrectOrderOfStates() => UniTask.ToCoroutine(async () =>
+        {
+            //TODO: Refactor this test
+
+            const string expectedLog = @"Create and execute State Machine
+StateGoBack1 - Execute
+StateGoBack2 - Execute
+StateGoBack3 - Execute
+StateGoBack2 - Execute
+StateGoBack1 - Execute
+State Machine is finished
+";
+
+            var container = new DiContainer(StaticContext.Container);
+
+            container.BindInterfacesTo<StateLogger>().AsSingle();
+            container.Bind<GoBackTestFlags>().ToSelf().AsSingle();
+
+            container.Bind<StateMachine>().ToSelf().AsTransient();
+            container.Bind<StateGoBack1>().ToSelf().AsTransient();
+            container.Bind<StateGoBack2>().ToSelf().AsTransient();
+            container.Bind<StateGoBack3>().ToSelf().AsTransient();
+
+            CancellationTokenSource cts = new CancellationTokenSource();
+
+            //TODO: Move to base class
+            using var slim = cts.CancelAfterSlim(TimeSpan.FromSeconds(5), DelayType.UnscaledDeltaTime);
+
+            var logger = container.Resolve<IStateLogger>();
+
+            logger.LogLine("Create and execute State Machine");
+            var stateMachine =  StateMachineHelper.CreateStateMachine<StateMachine>(container.ToTypeResolver());
+            await stateMachine.Execute<StateGoBack1>(cts.Token);
+
+            logger.LogLine("State Machine is finished");
+
+            var actualLog = logger.GetFullLog();
+
+            //TODO: Move to base class
+            StaticContext.Clear();
+
+            Assert.AreEqual(actualLog, expectedLog);
+        });
+    }
+}

Assets/UniStateTests/PlayMode/VContainerIntegrationTest.cs → Assets/UniStateTests/PlayMode/VContainerIntegrationTests.cs

@@ -14,7 +14,7 @@
 namespace UniStateTests.PlayMode
 {
     [TestFixture]
-    public class VContainerIntegrationTest
+    public class VContainerIntegrationTests
     {
         private GameObject _containerHolder;
         private IObjectResolver _objectResolver;

Assets/UniStateTests/PlayMode/ZenjectIntegrationTest.cs → Assets/UniStateTests/PlayMode/ZenjectIntegrationTests.cs

@@ -12,7 +12,7 @@
 namespace UniStateTests.PlayMode
 {
     [TestFixture]
-    public class ZenjectIntegrationTest
+    public class ZenjectIntegrationTests
     {
         [UnityTest]
         public IEnumerator SimpleRun() => UniTask.ToCoroutine(async () =>