Esempio n. 1
0
        public static StateMachineDebugger Create <TTrigger, TState>(GameObject gameObject,
                                                                     StateMachine <TState> stateMachine,
                                                                     TransitionManager <TTrigger, TState> transitionManager)
            where TState : struct, IConvertible, IComparable
            where TTrigger : struct, IConvertible, IComparable
        {
            var debugger = gameObject.AddComponent <StateMachineDebugger>();

            debugger.Register(stateMachine, transitionManager);
            return(debugger);
        }
Esempio n. 2
0
        public void Register <TTrigger, TState>(StateMachine <TState> stateMachine, TransitionManager <TTrigger, TState> transitionManager)
            where TState : struct, IConvertible, IComparable
            where TTrigger : struct, IConvertible, IComparable
        {
            this.stateMachine      = stateMachine;
            this.transitionManager = transitionManager;
            states = transitionManager.states;
            changeToStateAction = s => stateMachine.ChangeState((TState)s);

            if (transitionManager != null)
            {
                triggers            = Enum.GetValues(typeof(TTrigger));
                invokeTriggerAction = t => transitionManager.Fire((TTrigger)t);

                transitionManager.BeforeTriggered += (t => previousActiveTransition = t);
                transitionManager.BeforeTriggered += AddTransitionRecord;
            }
        }
Esempio n. 3
0
        public void TestGetString()
        {
            var fsm = StateMachine <States> .Initialize(this);

            fsm.ChangeState(States.idle);

            var tm = new TransitionManager <Triggers, States>(fsm);

            tm.Configure(States.idle).Permit(Triggers.startWalk, States.walk).
            Permit(Triggers.startRun, States.run);
            tm.Configure(States.walk).Permit(Triggers.stop, States.idle);
            tm.Configure(States.run).Permit(Triggers.stop, States.idle);
            tm.Configure(States.fight).PermitIf(Triggers.stop, States.idle, () => true);

            Register(fsm, tm);

            Debug.Log("States: ");
            foreach (object s in states)
            {
                Debug.Log(s.ToString());
            }

            Debug.Log("Transitions:");
            foreach (IStateConfiguration sc in transitionManager.ConfigurationList)
            {
                foreach (ITransition t in sc.Transitions)
                {
                    Debug.Log("from: " + t.FromStateName);
                    Debug.Log("to: " + t.ToStateName);
                    Debug.Log("trigger: " + t.TriggerName);
                    Debug.Log("has guard: " + t.HasGuard);
                }
            }

            testFsm = fsm;
        }
Esempio n. 4
0
 public StateConfiguration(TransitionManager <TTrigger, TState> transitionManager, TState state)
 {
     this.state  = state;
     transitions = new List <Transition <TTrigger, TState> >();
     fsm         = transitionManager.fsm;
 }