private IEnumerator ChangeToNewStateRoutine(StateMapping i_NewState)
        {
            m_DestinationState = i_NewState;             // Chache this so that we can overwrite it and hijack a transition.

            if (m_CurrentState != null)
            {
                if (m_CurrentState.hasExitRoutine)
                {
                    m_ExitRoutine = m_CurrentState.ExitRoutine();

                    if (m_ExitRoutine != null)
                    {
                        yield return(m_StateMachineRunner.StartCoroutine(m_ExitRoutine));
                    }

                    m_ExitRoutine = null;
                }
                else
                {
                    m_CurrentState.ExitCall();
                }

                m_CurrentState.Finally();
            }

            m_PrevState    = m_CurrentState;
            m_CurrentState = m_DestinationState;

            if (m_CurrentState != null)
            {
                if (m_CurrentState.hasEnterRoutine)
                {
                    m_EnterRoutine = m_CurrentState.EnterRoutine();

                    if (m_EnterRoutine != null)
                    {
                        yield return(m_StateMachineRunner.StartCoroutine(m_EnterRoutine));
                    }

                    m_EnterRoutine = null;
                }
                else
                {
                    m_CurrentState.EnterCall();
                }

                // Broadcast change only after enter transition has begun.

                if (m_OnStateChanged != null)
                {
                    m_OnStateChanged((T)m_CurrentState.state);
                }
            }

            m_IsInTransition = false;
        }
        private IEnumerator ChangeToNewStateRoutine(StateMapping newState, StateTransition transition)
        {
            destinationState = newState;             //Chache this so that we can overwrite it and hijack a transition

            if (currentState != null)
            {
                if (currentState.hasExitRoutine)
                {
                    exitRoutine = currentState.ExitRoutine();

                    if (exitRoutine != null && transition != StateTransition.Overwrite)                     //Don't wait for exit if we are overwriting
                    {
                        yield return(engine.StartCoroutine(exitRoutine));
                    }

                    exitRoutine = null;
                }
                else
                {
                    currentState.ExitCall();
                }

                currentState.Finally();
            }

            lastState    = currentState;
            currentState = destinationState;

            if (currentState != null)
            {
                if (currentState.hasEnterRoutine)
                {
                    enterRoutine = currentState.EnterRoutine();

                    if (enterRoutine != null)
                    {
                        yield return(engine.StartCoroutine(enterRoutine));
                    }

                    enterRoutine = null;
                }
                else
                {
                    currentState.EnterCall();
                }

                //Broadcast change only after enter transition has begun.
                if (Changed != null)
                {
                    Changed((T)currentState.state);
                }
            }

            isInTransition = false;
        }
        public void ChangeState(T newState, StateTransition transition)
        {
            if (stateLookup == null)
            {
                throw new Exception("States have not been configured, please call initialized before trying to set state");
            }

            if (!stateLookup.ContainsKey(newState))
            {
                throw new Exception("No state with the name " + newState.ToString() + " can be found. Please make sure you are called the correct type the statemachine was initialized with");
            }

            var nextState = stateLookup[newState];

            if (currentState == nextState)
            {
                return;
            }

            //Cancel any queued changes.
            if (queuedChange != null)
            {
                engine.StopCoroutine(queuedChange);
                queuedChange = null;
            }

            switch (transition)
            {
            //case StateMachineTransition.Blend:
            //Do nothing - allows the state transitions to overlap each other. This is a dumb idea, as previous state might trigger new changes.
            //A better way would be to start the two couroutines at the same time. IE don't wait for exit before starting start.
            //How does this work in terms of overwrite?
            //Is there a way to make this safe, I don't think so?
            //break;
            case StateTransition.Safe:
                if (isInTransition)
                {
                    if (exitRoutine != null)                             //We are already exiting current state on our way to our previous target state
                    {
                        //Overwrite with our new target
                        destinationState = nextState;
                        return;
                    }

                    if (enterRoutine != null)                             //We are already entering our previous target state. Need to wait for that to finish and call the exit routine.
                    {
                        //Damn, I need to test this hard
                        queuedChange = WaitForPreviousTransition(nextState);
                        engine.StartCoroutine(queuedChange);
                        return;
                    }
                }
                break;

            case StateTransition.Overwrite:
                if (currentTransition != null)
                {
                    engine.StopCoroutine(currentTransition);
                }
                if (exitRoutine != null)
                {
                    engine.StopCoroutine(exitRoutine);
                }
                if (enterRoutine != null)
                {
                    engine.StopCoroutine(enterRoutine);
                }

                //Note: if we are currently in an EnterRoutine and Exit is also a routine, this will be skipped in ChangeToNewStateRoutine()
                break;
            }


            if ((currentState != null && currentState.hasExitRoutine) || nextState.hasEnterRoutine)
            {
                isInTransition    = true;
                currentTransition = ChangeToNewStateRoutine(nextState, transition);
                engine.StartCoroutine(currentTransition);
            }
            else             //Same frame transition, no coroutines are present
            {
                if (currentState != null)
                {
                    currentState.ExitCall();
                    currentState.Finally();
                }

                lastState    = currentState;
                currentState = nextState;
                if (currentState != null)
                {
                    currentState.EnterCall();
                    if (Changed != null)
                    {
                        Changed((T)currentState.state);
                    }
                }
                isInTransition = false;
            }
        }
        private void ChangeToNewState(T i_NewState)
        {
            if (m_StateLookup == null)
            {
                throw new Exception("States have not been configured, please call initialized before trying to set state.");
            }

            if (!m_StateLookup.ContainsKey(i_NewState))
            {
                throw new Exception("No state with the name " + i_NewState.ToString() + " can be found. Please make sure you are called the correct type the statemachine was initialized with.");
            }

            StateMapping nextState = m_StateLookup[i_NewState];

            if (m_CurrentState == nextState)
            {
                return;
            }

            // Cancel any queued changes.

            if (m_QueuedChange != null)
            {
                m_StateMachineRunner.StopCoroutine(m_QueuedChange);
                m_QueuedChange = null;
            }

            if (m_IsInTransition)
            {
                if (m_ExitRoutine != null)          // We are already exiting current state on our way to our previous target state.
                {
                    m_DestinationState = nextState; // Overwrite with our new target.
                    return;
                }

                if (m_EnterRoutine != null) // We are already entering our previous target state. Need to wait for that to finish and call the exit routine.
                {
                    m_QueuedChange = WaitForPreviousTransition(nextState);
                    m_StateMachineRunner.StartCoroutine(m_QueuedChange);
                    return;
                }
            }

            if ((m_CurrentState != null && m_CurrentState.hasExitRoutine) || nextState.hasEnterRoutine)
            {
                m_IsInTransition = true;

                m_CurrentTransition = ChangeToNewStateRoutine(nextState);
                m_StateMachineRunner.StartCoroutine(m_CurrentTransition);
            }
            else // Same frame transition, no coroutines are present.
            {
                if (m_CurrentState != null)
                {
                    m_CurrentState.ExitCall();
                    m_CurrentState.Finally();
                }

                m_PrevState    = m_CurrentState;
                m_CurrentState = nextState;

                if (m_CurrentState != null)
                {
                    m_CurrentState.EnterCall();

                    if (m_OnStateChanged != null)
                    {
                        m_OnStateChanged((T)m_CurrentState.state);
                    }
                }

                m_IsInTransition = false;
            }
        }