Exemplo n.º 1
0
        public static void RunSimple()
        {
            StateBase initialState = new StateA()
            {
                A = 1
            };
            IReadOnlyCollection <ITaskBase <StateBase, StateBase> > tasks = new ITaskBase <StateBase, StateBase>[]
            {
                new DeterministicTask(),
                new DryTask(),
                new GenericInputTask()
            };

            Logger.Message($"InitialState: {initialState}");
            var terminationState = SimpleExecutor.Run(initialState, tasks);

            Logger.Message($"FinalState: {terminationState}");

            initialState = new StateA()
            {
                A = 2
            };

            Logger.Message($"InitialState: {initialState}");
            terminationState = SimpleExecutor.Run(initialState, tasks);
            Logger.Message($"FinalState: {terminationState}");
        }
Exemplo n.º 2
0
    private void Start()
    {
        _fsmSystem = new FSMSystem();

        IFSMState stateA = new StateA(_fsmSystem);

        IFSMState stateB = new StateB();

        IFSMState stateC = new StateC(_fsmSystem);

        stateA[(int)State.B] = stateB;

        stateA[(int)State.C] = stateC;

        stateB[(int)State.C] = stateC;

        stateC[(int)State.A] = stateA;

        stateC[(int)State.B] = stateB;

        _fsmSystem.AddState(stateA, true);

        _fsmSystem.AddState(stateB);

        _fsmSystem.AddState(stateC);
    }
Exemplo n.º 3
0
        public void Test_demo()
        {
            Record record = new Record();

            StateA stateA = new StateA();
            StateB stateB = new StateB();

            DemoContext context = new DemoContext(stateA);

            {
                context.RequestA(record);
                Assert.That(record.HandlerType, Is.EqualTo(HandlerType.A));
                Assert.That(record.StateType, Is.EqualTo(StateType.A));
            }
            {
                context.RequestB(record);
                Assert.That(record.HandlerType, Is.EqualTo(HandlerType.B));
                Assert.That(record.StateType, Is.EqualTo(StateType.A));
            }

            context.TransitorTo(stateB);

            {
                context.RequestA(record);
                Assert.That(record.HandlerType, Is.EqualTo(HandlerType.A));
                Assert.That(record.StateType, Is.EqualTo(StateType.B));
            }
            {
                context.RequestB(record);
                Assert.That(record.HandlerType, Is.EqualTo(HandlerType.B));
                Assert.That(record.StateType, Is.EqualTo(StateType.B));
            }
        }
Exemplo n.º 4
0
 public static StateA getInstance()
 {
     if (instance == null)
     {
         instance = new StateA();
     }
     return(instance);
 }
Exemplo n.º 5
0
        //   <---Hold---
        //Idle         Run
        //   ---Push--->
        static void Main(string[] args)
        {
            /*StateMachine<DummyState, DummyEvent> sm = StateMachine<DummyState, DummyEvent>.getInstance();
             *
             * //sm.pushRule(DummyState.Idle, DummyEvent.Push, DummyState.Run, (DummyState last, DummyState curr) => { System.Console.WriteLine("idle--->push:"+last+","+curr); });
             * //sm.pushRule(DummyState.Run, DummyEvent.Hold, DummyState.Idle, (DummyState last, DummyState curr) => { System.Console.WriteLine("run--->hold:" + last + "," + curr); });
             *
             *
             * sm.pushRule(DummyState.Idle, DummyEvent.Push, (DummyState state, DummyEvent evt) => { DummyState result = DummyState.Run; System.Console.WriteLine(state + "," + evt + "->" + result); return result; });
             * sm.pushRule(DummyState.Run, DummyEvent.Hold, (DummyState state, DummyEvent evt) => { DummyState result = DummyState.Idle; System.Console.WriteLine(state + "," + evt + "->" + result); return result; });
             *
             * sm.sendEvent(DummyEvent.Push);
             * sm.sendEvent(DummyEvent.Hold);
             * sm.sendEvent(DummyEvent.Hold);*/

            StateMachine <BaseState, Event> sm2 = StateMachine <BaseState, Event> .getInstance();

            sm2.pushRule(null, Event.Enter, (BaseState from, Event evt) =>
            {
                BaseState to = StateA.getInstance();
                if (from != null)
                {
                    from.exit(to);
                }
                to.enter(from);
                return(to);
            });
            sm2.pushRule(StateA.getInstance(), Event.Enter, (BaseState from, Event evt) => {
                BaseState to = StateB.getInstance();
                if (from != null)
                {
                    from.exit(to);
                }
                to.enter(from);
                return(to);
            });
            sm2.pushRule(StateB.getInstance(), Event.Enter, (BaseState from, Event evt) =>
            {
                BaseState to = StateA.getInstance();
                if (from != null)
                {
                    from.exit(to);
                }
                to.enter(from);
                return(to);
            });

            sm2.sendEvent(Event.Enter);
            sm2.sendEvent(Event.Enter);
            sm2.sendEvent(Event.Enter);

            System.Console.ReadKey();
        }
Exemplo n.º 6
0
    void Start()
    {
        StateA stateA = new StateA();
        StateB stateB = new StateB();

        ReactiveStateMachine <Triggers, IState> rsm;

        rsm = new ReactiveStateMachine <Triggers, IState>();

        rsm.OnEnter(stateA).Subscribe(e => Debug.Log(((StateA)e).aString)).AddTo(this);
        rsm.OnEnter(stateB).Subscribe(e => Debug.Log(((StateB)e).anInt)).AddTo(this);

        rsm.AddTransition(stateA, Triggers.TriggerB, stateB);
        rsm.AddTransition(stateB, Triggers.TriggerA, stateA);

        rsm.Start(stateA);

        rsm.Trigger(Triggers.TriggerA);
        rsm.Trigger(Triggers.TriggerB);
        rsm.Trigger(Triggers.TriggerC); //should not do anything
        rsm.Trigger(Triggers.TriggerB); //should not do anything
        rsm.Trigger(Triggers.TriggerA);



        /*
         * ReactiveStateMachine<Triggers, States> rsm2;
         * rsm2 = new ReactiveStateMachine<Triggers, States>();
         *
         * rsm2.AddTransition(States.StateA, Triggers.TriggerB, States.StateB);
         * rsm2.AddTransition(States.StateB, Triggers.TriggerA, States.StateA);
         *
         * rsm2.OnEnter(States.StateA).Subscribe(e => Debug.Log(e + " OnEnter"));
         * rsm2.OnExit(States.StateA).Subscribe(e => Debug.Log(e + " OnExit"));
         *
         * rsm2.OnEnter(States.StateB).Subscribe(e => Debug.Log(e + " OnEnter"));
         * rsm2.OnExit(States.StateB).Subscribe(e => Debug.Log(e + " OnExit"));
         *
         * rsm2.Start(States.StateB);
         *
         * rsm2.Trigger(Triggers.TriggerA);
         * rsm2.Trigger(Triggers.TriggerB);
         * rsm2.Trigger(Triggers.TriggerC); //should not do anything
         * rsm2.Trigger(Triggers.TriggerB); //should not do anything
         * rsm2.Trigger(Triggers.TriggerA);
         */
    }
 public ItemA()
 {
     //read from somewhere else, pass it in, etc.
     state = new StateA();
 }