public void TestAnyTransitionEvents() { int event1Count = 0; State?event1From = null; State?event1To = null; FiniteStateMachine <State> fsm = new FiniteStateMachine <State>(); fsm.AddTransition(State.A, State.B); fsm.AddTransition(State.B, State.C); fsm.AddEventOnAnyTransition((from, to) => { event1From = from; event1To = to; event1Count++; }); fsm.Start(State.A); Assert.IsTrue(event1Count == 0); fsm.TransitionTo(State.B); Assert.IsTrue(event1Count == 1); Assert.IsTrue(event1From == State.A); Assert.IsTrue(event1To == State.B); fsm.TransitionTo(State.C); Assert.IsTrue(event1Count == 2); Assert.IsTrue(event1From == State.B); Assert.IsTrue(event1To == State.C); }
void Awake() { mainFSM = new FiniteStateMachine<State>(); mainFSM.AddTransition(State.Initialize, State.SetupNewGame, null, InitializeNewGame, OnSettingUpNewGame); mainFSM.AddTransition(State.SetupNewGame, State.Game, null, () => StartCoroutine(InitializeGameLogicStuff()), null); mainFSM.AddTransition(State.Game, State.GameOver, OnGameIsOver); mainFSM.AddTransition(State.GameOver, State.Restart, null); mainFSM.AddTransition(State.Restart, State.SetupNewGame, null, InitializeNewGame, null); mainFSM.AddTransition(State.Restart, State.Quit, null); mainFSM.StateChanged += (object s, EventArgs e) => { Debug.Log("state: " + mainFSM.CurrentState.ToString() + " | game state: " + gameFSM.CurrentState.ToString()); }; gameFSM = new FiniteStateMachine<GameState>(); gameFSM.AddTransition(GameState.Idle, GameState.InGameMenu, OnInGameMenuOpened); gameFSM.AddTransition(GameState.InGameMenu, GameState.Idle, OnInGameMenuClosed); gameFSM.StateChanged += (object s, EventArgs e) => { Debug.Log("state: " + mainFSM.CurrentState.ToString() + " | game state: " + gameFSM.CurrentState.ToString()); }; GameIsOver += (object s, EventArgs e) => { Debug.Log("oh no!"); }; InGameMenuOpened += (object s, EventArgs e) => { Time.timeScale = 0f; Debug.Log("PAUSED"); }; InGameMenuClosed += (object s, EventArgs e) => { Time.timeScale = 1f; Debug.Log("UNPAUSED"); }; igm = GetComponent<InGameMenu>(); mainFSM.ChangeState(State.SetupNewGame); }
public void TestTransitions() { FiniteStateMachine <State> fsm = new FiniteStateMachine <State>(); fsm.AddTransition(State.A, State.B, State.C); fsm.AddTransition(State.B, State.C); fsm.AddTransition(State.C, State.A); fsm.Start(State.A); Assert.IsTrue(fsm.CurrentState == State.A); fsm.TransitionTo(State.B); Assert.IsTrue(fsm.CurrentState == State.B); Assert.That(() => fsm.TransitionTo(State.A), Throws.ArgumentException); fsm.TransitionToIfExists(State.A); Assert.IsTrue(fsm.CurrentState == State.B); fsm.TransitionTo(State.C); Assert.IsTrue(fsm.CurrentState == State.C); fsm.TransitionTo(State.A); Assert.IsTrue(fsm.CurrentState == State.A); fsm.TransitionTo(State.C); Assert.IsTrue(fsm.CurrentState == State.C); Assert.That(() => fsm.TransitionTo(State.B), Throws.ArgumentException); }
public void TestMultiStateEnterExitTransitionEvents() { int abEnterCount = 0; int abExitCount = 0; int bcEnterCount = 0; int bcExitCount = 0; FiniteStateMachine <State> fsm = new FiniteStateMachine <State>(); fsm.AddTransition(State.A, State.B, State.C); fsm.AddTransition(State.B, State.A, State.C); fsm.AddTransition(State.C, State.A, State.B); fsm.AddEventOnGroupEnter(new[] { State.A, State.B }, (from, to) => { Assert.IsTrue(from != State.A && from != State.B); Assert.IsTrue(to == State.A || to == State.B); abEnterCount++; }); fsm.AddEventOnGroupExit(new[] { State.A, State.B }, (from, to) => { Assert.IsTrue(from == State.A || from == State.B); Assert.IsTrue(to != State.A && to != State.B); abExitCount++; }); fsm.AddEventOnGroupEnter(new[] { State.B, State.C }, (from, to) => { Assert.IsTrue(from != State.B && from != State.C); Assert.IsTrue(to == State.B || to == State.C); bcEnterCount++; }); fsm.AddEventOnGroupExit(new[] { State.B, State.C }, (from, to) => { Assert.IsTrue(from == State.B || from == State.C); Assert.IsTrue(to != State.B && to != State.C); bcExitCount++; }); fsm.Start(State.A); Assert.AreEqual(0, abEnterCount); Assert.AreEqual(0, abExitCount); Assert.AreEqual(0, bcEnterCount); Assert.AreEqual(0, bcExitCount); fsm.TransitionTo(State.B); Assert.AreEqual(0, abEnterCount); Assert.AreEqual(0, abExitCount); Assert.AreEqual(1, bcEnterCount); Assert.AreEqual(0, bcExitCount); fsm.TransitionTo(State.C); Assert.AreEqual(0, abEnterCount); Assert.AreEqual(1, abExitCount); Assert.AreEqual(1, bcEnterCount); Assert.AreEqual(0, bcExitCount); fsm.TransitionTo(State.A); Assert.AreEqual(1, abEnterCount); Assert.AreEqual(1, abExitCount); Assert.AreEqual(1, bcEnterCount); Assert.AreEqual(1, bcExitCount); }
// Use this for initialization void Start() { counter = new Counter(); AddState addState = new AddState(counter); MultiplyState multiplyState = new MultiplyState(counter); fsm = new FiniteStateMachine <States>(addState); fsm.AddTransition(new ITransition <States>(States.ADD, States.MULTIPLY), multiplyState); fsm.AddTransition(new ITransition <States>(States.MULTIPLY, States.ADD), addState); }
public void SetUp() { fsm = ScriptableObject.CreateInstance <FiniteStateMachine>(); LoggerFsmState state1 = ScriptableObject.CreateInstance <LoggerFsmState>(); state1.name = "State1"; AssetDatabase.CreateAsset(state1, ASSET_PATH + "State1.asset"); LoggerFsmState state2 = ScriptableObject.CreateInstance <LoggerFsmState>(); state2.name = "State2"; AssetDatabase.CreateAsset(state2, ASSET_PATH + "State2.asset"); AssetDatabase.SaveAssets(); fsm.AddStateInstance("One", state1); fsm.AddStateInstance("Two", state2); fsm.AddStateInstance("Three", state1); fsm.AddStateInstance("Four", state2); FsmParameter triggerParameter = FsmParameter.NewBoolean("testTrigger"); FsmParameter booleanParameter = FsmParameter.NewBoolean("testBool"); FsmParameter integerParameter = FsmParameter.NewInteger("testInt"); FsmParameter floatParameter = FsmParameter.NewFloat("testFloat"); fsm.AddParameter(triggerParameter); fsm.AddParameter(booleanParameter); fsm.AddParameter(integerParameter); fsm.AddParameter(floatParameter); FsmTransition transition1to2 = new FsmTransition(); transition1to2.AddCondition(FsmCondition.NewTrigger(triggerParameter)); FsmTransition transition2to3 = new FsmTransition(); transition2to3.AddCondition(FsmCondition.NewEquals(booleanParameter, true)); FsmTransition transition3to4 = new FsmTransition(); transition3to4.AddCondition(FsmCondition.NewGreaterThan(integerParameter, 3)); FsmTransition transition4to1 = new FsmTransition(); transition4to1.AddCondition(FsmCondition.NewSmallerThan(floatParameter, -1f)); fsm.AddTransition("One", "Two", transition1to2); fsm.AddTransition("Two", "Three", transition2to3); fsm.AddTransition("Three", "Four", transition3to4); fsm.AddTransition("Four", "One", transition4to1); // Clean up if asset already exists AssetDatabase.DeleteAsset(ASSET_PATH); }
public void Test1() { var fsm = new FiniteStateMachine <State, Event>(State.Stoped); State?eventState = null; Func <State, Event, ValidateTransitionResult> callback = (s, e) => { return(ValidateTransitionResult.FinishAccept); }; // fsm.AddTransition(State.Disconnected, Event.Connect, callbackTrue, State.Connecting); fsm.AddTransition(State.Stoped, Event.Start, callback, State.Starting); fsm.AddTransition(State.Starting, Event.Run, callback, State.Running); fsm.AddTransition(State.Starting, Event.Stop, callback, State.Stoped); fsm.AddTransition(State.Running, Event.Stop, callback, State.Stoped); fsm.OnChangeState += (s, state) => { eventState = state; }; Assert.Null(eventState); Assert.AreEqual(State.Stoped, fsm.State); fsm.ProcessEvent(Event.Start); Assert.AreEqual(State.Starting, fsm.State); Assert.AreEqual(State.Starting, eventState); fsm.ProcessEvent(Event.Stop); Assert.AreEqual(State.Stoped, fsm.State); Assert.AreEqual(State.Stoped, eventState); fsm.ProcessEvent(Event.Run); Assert.AreEqual(State.Stoped, fsm.State); Assert.AreEqual(State.Stoped, eventState); fsm.ProcessEvent(Event.Start); Assert.AreEqual(State.Starting, fsm.State); Assert.AreEqual(State.Starting, eventState); fsm.ProcessEvent(Event.Run); Assert.AreEqual(State.Running, fsm.State); Assert.AreEqual(State.Running, eventState); fsm.ProcessEvent(Event.Start); Assert.AreEqual(State.Running, fsm.State); Assert.AreEqual(State.Running, eventState); fsm.ProcessEvent(Event.Stop); Assert.AreEqual(State.Stoped, fsm.State); Assert.AreEqual(State.Stoped, eventState); }
public AIProperty() { IsActive = true; StateMachine = new FiniteStateMachine(); // basic behaviors! StateMachine.AddState("idle", 2, 3); StateMachine.AddState("move", 2, 2); StateMachine.AddTransition("idle", "move", .5); StateMachine.AddTransition("move", "idle", .5); // Pick our first state. StateMachine.SetState("idle"); }
public void TestTransitionExists() { FiniteStateMachine <State> fsm = new FiniteStateMachine <State>(); fsm.AddTransition(State.A, State.B, State.C); fsm.AddTransition(State.B, State.C); fsm.AddTransition(State.C, State.A); Assert.IsTrue(fsm.TransitionExists(State.A, State.B)); Assert.IsTrue(fsm.TransitionExists(State.A, State.C)); Assert.IsFalse(fsm.TransitionExists(State.B, State.A)); Assert.IsTrue(fsm.TransitionExists(State.B, State.C)); Assert.IsTrue(fsm.TransitionExists(State.C, State.A)); Assert.IsFalse(fsm.TransitionExists(State.C, State.B)); }
public void Init() { fsm = new FiniteStateMachine <GameState>(); fsm.AddTransition(GameState.INIT, GameState.START, onStart); onStart += StartHandler; fsm.AddTransition(GameState.START, GameState.RUNNING, RunningHandler); // onRunning += RunningHandler; fsm.AddTransition(GameState.PAUSED, GameState.RUNNING, RunningHandler); // onRunning += RunningHandler; fsm.AddTransition(GameState.RUNNING, GameState.PAUSED, PausedHandler); // onPaused += PausedHandler; fsm.AddTransition(GameState.PAUSED, GameState.EXIT, ExitHandler); // onExit += ExitHandler; fsm.Start(GameState.INIT); fsm.ChangeState(GameState.START); }
public void SetUp() { fsm = ScriptableObject.CreateInstance <FiniteStateMachine>(); state1 = ScriptableObject.CreateInstance <TestFsmState>(); state1.name = "State1"; state2 = ScriptableObject.CreateInstance <TestFsmState>(); state2.name = "State2"; fsm.AddStateInstance("One", state1); fsm.AddStateInstance("Two", state2); fsm.AddStateInstance("Three", state1); fsm.AddStateInstance("Four", state2); triggerParameter = FsmParameter.NewBoolean("testTrig"); booleanParameter = FsmParameter.NewBoolean("testBool"); integerParameter = FsmParameter.NewInteger("testInt"); floatParameter = FsmParameter.NewFloat("testFloat"); fsm.AddParameter(triggerParameter); fsm.AddParameter(booleanParameter); fsm.AddParameter(integerParameter); fsm.AddParameter(floatParameter); transition1to2 = new FsmTransition(); transition1to2.AddCondition(FsmCondition.NewTrigger(triggerParameter)); transition2to3 = new FsmTransition(); FsmCondition equalsCondition = FsmCondition.NewEquals(booleanParameter, true); transition2to3.AddCondition(equalsCondition); transition3to4 = new FsmTransition(); FsmCondition greaterCondition = FsmCondition.NewGreaterThan(integerParameter, 3); transition3to4.AddCondition(greaterCondition); transition4to1 = new FsmTransition(); FsmCondition smallerCondition = FsmCondition.NewSmallerThan(floatParameter, -1f); transition4to1.AddCondition(smallerCondition); fsm.AddTransition("One", "Two", transition1to2); fsm.AddTransition("Two", "Three", transition2to3); fsm.AddTransition("Three", "Four", transition3to4); fsm.AddTransition("Four", "One", transition4to1); }
static void DebugClickTimedToggle(FiniteStateMachine fsm) { FiniteState start_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState red_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState green_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); start_state.StateName = "Start"; red_state.StateName = "Red"; green_state.StateName = "Green"; { red_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = red_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.red; } { green_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = green_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.green; } { Transitions.OnMouseClick t = fsm.AddTransition(start_state,typeof(Transitions.OnMouseClick),red_state) as Transitions.OnMouseClick; t.Name = "click_start"; } { Transitions.OnMouseClick t = fsm.AddTransition(red_state,typeof(Transitions.OnMouseClick),green_state) as Transitions.OnMouseClick; t.Name = "click_red"; } { Transitions.OnMouseClick t = fsm.AddTransition(green_state,typeof(Transitions.OnMouseClick),red_state) as Transitions.OnMouseClick; t.Name = "click_green"; } { Transitions.OnTimer2 t = fsm.AddTransition(green_state,typeof(Transitions.OnTimer2),red_state) as Transitions.OnTimer2; t.Name = "click_green"; t.Delay = 2; } fsm.ChangeState(start_state); }
void ConstructStateMachine() { // States. _fsm.AddState(States.Playing, new State() { enter = () => { Cursor.visible = false; Cursor.lockState = CursorLockMode.Locked; _ambiance.FadeIn(_fadeTime); Time.timeScale = 1f; }, exit = () => { Cursor.visible = true; Cursor.lockState = CursorLockMode.None; } }); _fsm.AddState(States.Paused, new State() { enter = () => { Time.timeScale = 0f; _gameUI.ShowPause(); _ambiance.FadeTo(0.4f, _fadeTime); }, exit = () => { _gameUI.HidePause(); _ambiance.FadeIn(_fadeTime); }, }); _fsm.AddState(States.End, new State() { enter = () => { _gameUI.DropInWinScren(); _ambiance.FadeTo(0.7f, _fadeTime); }, }); _fsm.AddTransition(States.Playing, States.Paused, Triggers.PausePressed); _fsm.AddTransition(States.Playing, States.End, Triggers.EndHappened); _fsm.AddTransition(States.Paused, States.Playing, Triggers.PausePressed); _fsm.AddTransition(States.Paused, States.End, Triggers.EndHappened); }
/// <summary> /// Fsm wird über Enums angelegt /// </summary> void InitFsm() { //string[] stateNames = Enum.GetNames(typeof(State)); //string[] inputNames = Enum.GetNames(typeof(Input)); Enum[] stateEnums = Enum.GetValues <State>().Select(e => (Enum)e).ToArray(); Enum[] inputEnums = Enum.GetValues <Input>().Select(e => (Enum)e).ToArray(); Fsm = new FiniteStateMachine(nameof(OilBurner), stateEnums, inputEnums); try { // Triggermethoden bei Inputs definieren Fsm.GetInput(Input.IsNeededOilBurner).TriggerMethod = IsNeededOilBurner; Fsm.GetInput(Input.IsntNeededOilBurner).TriggerMethod = IsntNeededOilBurner; Fsm.GetInput(Input.IsCold).TriggerMethod = IsCold; Fsm.GetInput(Input.IsCooledDown).TriggerMethod = IsCooledDown; Fsm.GetInput(Input.IsReady).TriggerMethod = IsReady; Fsm.GetInput(Input.IsTooHot).TriggerMethod = IsTooHot; // Übergänge definieren Fsm.AddTransition(State.Off, State.Cold, Input.IsNeededOilBurner); Fsm.AddTransition(State.Cold, State.Ready, Input.IsReady); Fsm.AddTransition(State.Cold, State.Off, Input.IsntNeededOilBurner); Fsm.AddTransition(State.Ready, State.Cold, Input.IsCold); Fsm.AddTransition(State.Ready, State.TooHot, Input.IsTooHot); Fsm.AddTransition(State.Ready, State.Off, Input.IsntNeededOilBurner); Fsm.AddTransition(State.TooHot, State.Ready, Input.IsCooledDown); // Aktionen festlegen Fsm.GetState(State.Off).OnLeave += DoBurnerOn; Fsm.GetState(State.Off).OnEnter += DoBurnerOff; } catch (Exception ex) { Log.Error($"Fehler bei Init FsmOilBurner, ex: {ex.Message}"); } }
void Awake() { _fsm.AddState(States.Idle, new State() { enter = () => _animator.Play("Idle") }); _fsm.AddState(States.Walking, new State() { enter = () => _animator.Play("Walking") }); _fsm.AddState(States.Jumping, new State() { enter = () => _animator.Play("Jumping") }); _fsm.AddState(States.Falling, new State() { enter = () => _animator.Play("Jumping") }); _fsm.AddTransition(States.Idle, States.Jumping, Triggers.Airborne); _fsm.AddTransition(States.Idle, States.Walking, Triggers.Movement); _fsm.AddTransition(States.Walking, States.Jumping, Triggers.Airborne); _fsm.AddTransition(States.Walking, States.Idle, Triggers.NoMovement); _fsm.AddTransition(States.Jumping, States.Falling, Triggers.NovVerticalMovement); _fsm.AddTransition(States.Jumping, States.Walking, Triggers.Grounded); _fsm.AddTransition(States.Falling, States.Walking, Triggers.Grounded); }
void InitFSM() { fsm = new FiniteStateMachine(); State wanderingState = fsm.AddState(true); wanderingState.OnUpdate += wander.Execute; wanderingState.OnUpdate += CheckWordBound; State detectingState = fsm.AddState(); detectingState.OnEnter += () => { isDetecting = false; }; detectingState.OnEnter += () => { animator.SetBool(detectingHashCode, true); }; detectingState.OnExit += () => { animator.SetBool(detectingHashCode, false); }; detectingState.OnUpdate += Detecting; State targetingState = fsm.AddState(); targetingState.OnUpdate += flowFieldPathfinder.Execute; //targetingState.OnUpdate += seek.Execute; targetingState.OnUpdate += flock.Execute; State returnState = fsm.AddState(); returnState.OnUpdate += flowFieldPathfinder.Execute; returnState.OnUpdate += flock.Execute; State scaredState = fsm.AddState(); scaredState.OnUpdate += flee.Execute; fsm.AddTransition(wanderingState, detectingState, () => { return(isDetecting); }); fsm.AddTransition(detectingState, targetingState, () => { return(detectionTimer >= detectionDuration); }); fsm.AddTransition(wanderingState, scaredState, () => { return(isScare); }); fsm.AddTransition(returnState, scaredState, () => { return(isScare); }); fsm.AddTransition(targetingState, scaredState, () => { return(isScare); }); fsm.AddTransition(targetingState, returnState, () => { return(state == States.Return); }); fsm.AddTransition(returnState, wanderingState, () => { return((brain.target.transform.position - transform.position).magnitude <= 0.5f); }); fsm.AddTransition(scaredState, wanderingState, () => { return(!isScare && state == States.Wandering); }); fsm.AddTransition(scaredState, targetingState, () => { return(!isScare && state == States.Targeting); }); fsm.AddTransition(scaredState, returnState, () => { return(!isScare && state == States.Return); }); fsm.Start(); }
void Start() { //Get Initial References _target = FindObjectOfType <Target>(); _rotatingBase.Rotate(Vector3.up, Random.Range(0f, 355f)); _stateMachine = new FiniteStateMachine <ShootingTowerFSM>(this); //STATES State patrolState = new TowerPatrolState("Patrol", this); State attackState = new TowerAttackState("Attack", this); //TRANSITIONS _stateMachine.AddTransition(patrolState, attackState, IsTargetInSight); _stateMachine.AddTransition(attackState, patrolState, () => !IsTargetInSight()); //START STATE _stateMachine.SetState(patrolState); }
/// <summary> /// Adds the transition. /// </summary> /// <param name="fsmTransition">The FSM transition.</param> internal void AddTransition(FsmTransition fsmTransition) { var transition = new Transition <IDomainEvent <TEntity> >(fsmTransition.SourceState, fsmTransition.TargetState, @event => @event.GetType() == fsmTransition.DomainEvent && @event.CanApply(Root)); transition.OnTransition += InvokeOnTransition; transition.Description = fsmTransition.Weight.ToString(CultureInfo.InvariantCulture); _finiteStateMachine.AddTransition(transition); _fsmTransitions.Add(transition, fsmTransition); }
public void TestTransitionEvents() { int eventCount = 0; FiniteStateMachine <State> fsm = new FiniteStateMachine <State>(); fsm.AddTransition(State.A, State.B); fsm.AddTransition(State.B, State.C); fsm.AddEventOnTransition(State.A, State.B, (from, to) => { Assert.IsTrue(from == State.A); Assert.IsTrue(to == State.B); eventCount++; }); fsm.Start(State.A); Assert.IsTrue(eventCount == 0); fsm.TransitionTo(State.B); Assert.IsTrue(eventCount == 1); fsm.TransitionTo(State.C); Assert.IsTrue(eventCount == 1); }
protected virtual void Awake() { if (m_NavMeshAgent == null) { m_NavMeshAgent = GetComponent <NavMeshAgent>(); } if (m_Nameplate != null) { UnitNameplate nameplate = Instantiate(m_Nameplate); nameplate.parent = this; } if (m_Skills == null) { m_Skills = new List <Skill>(); } else { foreach (GameObject skillPrefab in m_SkillPrefabs) { if (skillPrefab.GetComponent <ICastable <IUsesSkills> >() == null) { m_SkillPrefabs.Remove(skillPrefab); } } for (int i = 0, j = 0; i < m_SkillPrefabs.Count; ++i) { m_Skills.Add(new Skill()); m_Skills[j].skillIndex = j; m_Skills[j].skillData = m_SkillPrefabs[i].GetComponent <ICastable <IUsesSkills> >().skillData.Clone(); m_Skills[j].skillData.skillIndex = j; m_Skills[j].skillPrefab = m_SkillPrefabs[i].gameObject; m_Skills[j].parent = this; ++j; } } //GetComponent<NavMeshAgent>().updateRotation = false; m_MovementFSM = new FiniteStateMachine <MovementState>(); m_DamageFSM = new FiniteStateMachine <DamageState>(); m_DamageFSM.AddTransition(DamageState.Init, DamageState.Idle); m_DamageFSM.AddTransitionFromAny(DamageState.Dead); m_MovementFSM.Transition(MovementState.Idle); m_DamageFSM.Transition(DamageState.Idle); Publisher.self.Subscribe(Event.UpgradeSkill, OnUpgradeSkill); Publisher.self.Subscribe(Event.UseSkill, OnUseSkill); }
public static void Main(String[] Args) { var FSM1 = new FiniteStateMachine<State, Signal>("FSM1"); FSM1.AddTransition(State.Start, Signal.Hello, () => Console.WriteLine("Hello received!"), State.Middle); FSM1.AddTransition(State.Middle, Signal.World, () => Console.WriteLine("World received!"), State.End); Console.WriteLine(FSM1.CurrentState); FSM1.ProcessSignal(Signal.Hello); Console.WriteLine(FSM1.CurrentState); FSM1.ProcessSignal(Signal.GoToHell); Console.WriteLine(FSM1.CurrentState); FSM1.ProcessSignal(Signal.Hello); Console.WriteLine(FSM1.CurrentState); }
public void TestEnterExitTransitionEvents() { int aEnterCount = 0; int aExitCount = 0; State?aExitToState = null; int bEnterCount = 0; State?bEnterFromState = null; FiniteStateMachine <State> fsm = new FiniteStateMachine <State>(); fsm.AddTransition(State.A, State.B); fsm.AddTransition(State.B, State.C); fsm.AddEventOnEnter(State.A, (from, to) => { Assert.IsTrue(to == State.A); aEnterCount++; }); fsm.AddEventOnExit(State.A, (from, to) => { Assert.IsTrue(from == State.A); aExitToState = to; aExitCount++; }); fsm.AddEventOnEnter(State.B, (from, to) => { bEnterFromState = from; Assert.IsTrue(to == State.B); bEnterCount++; }); // Start does not trigger enter event fsm.Start(State.A); Assert.IsTrue(aEnterCount == 0); Assert.IsTrue(aExitCount == 0); Assert.IsTrue(bEnterCount == 0); fsm.TransitionTo(State.B); Assert.IsTrue(aEnterCount == 0); Assert.IsTrue(aExitCount == 1); Assert.IsTrue(aExitToState == State.B); Assert.IsTrue(bEnterCount == 1); Assert.IsTrue(bEnterFromState == State.A); }
/// <summary> /// Fsm wird über Enums angelegt /// </summary> void InitFsm() { Enum[] stateEnums = Enum.GetValues <State>().Select(e => (Enum)e).ToArray(); Enum[] inputEnums = Enum.GetValues <Input>().Select(e => (Enum)e).ToArray(); Fsm = new FiniteStateMachine(nameof(HotWater), stateEnums, inputEnums); try { // Triggermethoden bei Inputs definieren Fsm.GetInput(Input.IsntBoilerToHeatByBurner).TriggerMethod = IsntBoilerToHeatByBurner; Fsm.GetInput(Input.IsBoilerToHeatByBurner).TriggerMethod = IsBoilerToHeatByBurner; Fsm.GetInput(Input.IsBoilerHot).TriggerMethod = IsBoilerHot; Fsm.GetInput(Input.IsBurnerToCool).TriggerMethod = IsBurnerToCool; Fsm.GetInput(Input.IsntBurnerToCool).TriggerMethod = IsntBurnerToCool; Fsm.GetInput(Input.IsBoilerToHeatBySolar).TriggerMethod = IsBoilerToHeatBySolar; Fsm.GetInput(Input.IsntBoilerToHeatBySolar).TriggerMethod = IsntBoilerToHeatBySolar; Fsm.GetInput(Input.IsBoilerVeryHot).TriggerMethod = IsBoilerVeryHot; Fsm.GetInput(Input.IsntBufferToHeatBySolar).TriggerMethod = IsntBufferToHeatBySolar; // Übergänge definieren Fsm.AddTransition(State.AllOff, State.HeatBoilerByBurner, Input.IsBoilerToHeatByBurner); Fsm.AddTransition(State.HeatBoilerByBurner, State.AllOff, Input.IsntBoilerToHeatByBurner); Fsm.AddTransition(State.AllOff, State.HeatBoilerBySolar, Input.IsBoilerToHeatBySolar); Fsm.AddTransition(State.AllOff, State.CoolBurner, Input.IsBurnerToCool); Fsm.AddTransition(State.HeatBoilerByBurner, State.AllOff, Input.IsBoilerHot); Fsm.AddTransition(State.HeatBoilerByBurner, State.HeatBoilerBySolar, Input.IsBoilerToHeatBySolar); Fsm.AddTransition(State.HeatBoilerBySolar, State.AllOff, Input.IsntBoilerToHeatBySolar); Fsm.AddTransition(State.HeatBoilerBySolar, State.HeatBufferBySolar, Input.IsBoilerVeryHot); Fsm.AddTransition(State.HeatBufferBySolar, State.AllOff, Input.IsntBufferToHeatBySolar); Fsm.AddTransition(State.CoolBurner, State.AllOff, Input.IsntBurnerToCool); // Aktionen festlegen Fsm.GetState(State.HeatBoilerByBurner).OnEnter += DoHeatBoilerByBurner; Fsm.GetState(State.HeatBoilerBySolar).OnEnter += DoHeatBoilerBySolar; Fsm.GetState(State.HeatBufferBySolar).OnEnter += DoHeatBufferBySolar; Fsm.GetState(State.CoolBurner).OnEnter += DoCoolBurnerByBoiler; Fsm.GetState(State.AllOff).OnEnter += DoAllOff; } catch (Exception ex) { Log.Error($"HotWater;Fehler bei Init FsmHeatingCircuit, ex: {ex.Message}"); } }
/// <summary> /// Caso a máquina(FSM) Não estejas totalmente especificado /// este método faz que a mpaquina fique totalemte especificado. /// </summary> /// <param name="fsm"></param> public void FullySpecified(FiniteStateMachine fsm) { foreach (State s in fsm.States) { List <Transition> listTransition = GetTransitionFSM(s, fsm); List <String> listInput = ContainsInput(listTransition, fsm.InputAlphabet); foreach (String input in listInput) { Transition tError = new Transition(listTransition[0].SourceState, listTransition[0].SourceState, input, "Falha"); fsm.AddTransition(tError); } } }
void Start() { _navMeshAgent = GetComponent <NavMeshAgent>(); _renderer = GetComponent <Renderer>(); _originalColor = _renderer.material.color; _stateMachine = new FiniteStateMachine <TowerGuardFSM>(this); //STATES State patrolState = new TowerGuardPatrolState("Patrol", this); State chaseState = new TowerGuardChaseState("Chase", this); State attackState = new TowerGuardAttackState("Attack", this); //TRANSITIONS _stateMachine.AddTransition(patrolState, chaseState, () => DistanceFromTarget() <= _minChaseDistance); _stateMachine.AddTransition(chaseState, patrolState, () => DistanceFromTarget() > _minChaseDistance); _stateMachine.AddTransition(chaseState, attackState, () => DistanceFromTarget() <= _minAttackDistance); _stateMachine.AddTransition(attackState, chaseState, () => DistanceFromTarget() >= _minAttackDistance); //START STATE _stateMachine.SetState(patrolState); }
void Start() { _navMeshAgent = GetComponent <NavMeshAgent>(); _renderer = GetComponent <Renderer>(); _originalColor = _renderer.material.color; _stateMachine = new FiniteStateMachine <GuardFSM>(this); //STATES State patrolState = new PatrolState("Patrol", this); State chaseState = new ChaseState("Chase", this); State stopState = new StopState("Stop", this); //TRANSITIONS _stateMachine.AddTransition(patrolState, chaseState, () => DistanceFromTarget() <= _minChaseDistance); _stateMachine.AddTransition(chaseState, patrolState, () => DistanceFromTarget() > _minChaseDistance); _stateMachine.AddTransition(chaseState, stopState, () => DistanceFromTarget() <= _stoppingDistance); _stateMachine.AddTransition(stopState, chaseState, () => DistanceFromTarget() > _stoppingDistance); //START STATE _stateMachine.SetState(patrolState); }
private void Start() { _timerAttack = 0; int rndSign = UnityEngine.Random.Range(0, 100) % 2 == 0 ? 1 : -1; _rndMedium = UnityEngine.Random.Range(10f, 30f) * rndSign; InitialRotation = transform.rotation; _fsm = FiniteStateMachine <Playable.FSMCommon.State> .FromEnum(); _fsm.AddTransition(Playable.FSMCommon.State.Idle, Playable.FSMCommon.State.Attack, Playable.FSMCommon.ATTACK_COMMAND); _fsm.AddTransition(Playable.FSMCommon.State.Attack, Playable.FSMCommon.State.Idle, Playable.FSMCommon.IDLE_COMMAND); _fsm.AddTransition(Playable.FSMCommon.State.Move, Playable.FSMCommon.State.Idle, Playable.FSMCommon.IDLE_COMMAND); _fsm.AddTransition(Playable.FSMCommon.State.Idle, Playable.FSMCommon.State.Move, Playable.FSMCommon.MOVE_COMMAND); _fsm.AddTransition(Playable.FSMCommon.State.Attack, Playable.FSMCommon.State.Move, Playable.FSMCommon.MOVE_COMMAND); _fsm.OnEnter(Playable.FSMCommon.State.Attack, () => { Invoke(nameof(BackToIdle), 0.3f); Fire(); }); _fsm.OnExit(Playable.FSMCommon.State.Idle, () => { RotationOnLostIdle = transform.rotation; }); _fsm.Begin(Playable.FSMCommon.State.Idle); InitNPC(); }
/// <summary> /// Fsm wird über Enums angelegt /// </summary> void InitFsm() { Enum[] stateEnums = Enum.GetValues <State>().Select(e => (Enum)e).ToArray(); Enum[] inputEnums = Enum.GetValues <Input>().Select(e => (Enum)e).ToArray(); Fsm = new FiniteStateMachine(nameof(HeatingCircuit), stateEnums, inputEnums); try { // Triggermethoden bei Inputs definieren Fsm.GetInput(Input.IsInHeatingTime).TriggerMethod = IsInHeatingTime; Fsm.GetInput(Input.IsntInHeatingTime).TriggerMethod = IsntInHeatingTime; Fsm.GetInput(Input.IsBurnerToCool).TriggerMethod = IsBurnerTooHot; Fsm.GetInput(Input.IsntBurnerToCool).TriggerMethod = IsCooledDown; Fsm.GetInput(Input.IsBurnerReadyToHeat).TriggerMethod = IsBurnerReady; Fsm.GetInput(Input.IsntBurnerReadyToHeat).TriggerMethod = IsBurnerCold; Fsm.GetInput(Input.IsHot).TriggerMethod = IsHot; Fsm.GetInput(Input.IsCold).TriggerMethod = IsCold; Fsm.GetInput(Input.IsAllResidualHeatUsed).TriggerMethod = IsAllResidualHeatUsed; // Übergänge definieren Fsm.AddTransition(State.Off, State.PumpIsOff, Input.IsInHeatingTime); Fsm.AddTransition(State.Off, State.CoolBurnerByCircuit, Input.IsBurnerToCool); Fsm.AddTransition(State.CoolBurnerByCircuit, State.PumpIsOff, Input.IsntBurnerToCool); Fsm.AddTransition(State.PumpIsOff, State.Off, Input.IsntInHeatingTime); Fsm.AddTransition(State.PumpIsOff, State.PumpIsOn, Input.IsCold) .OnSelect += SwitchOilBurnerOn; Fsm.AddTransition(State.PumpIsOff, State.CoolBurnerByCircuit, Input.IsBurnerToCool); //Fsm.AddTransition(State.WaitBurnerReadyToHeat, State.PumpIsOn, Input.IsBurnerReadyToHeat); Fsm.AddTransition(State.PumpIsOn, State.PumpIsOff, Input.IsntInHeatingTime) .OnSelect += SwitchOilBurnerOff;; Fsm.AddTransition(State.PumpIsOn, State.UseResidualHeat, Input.IsHot) .OnSelect += SwitchOilBurnerOff;; Fsm.AddTransition(State.UseResidualHeat, State.PumpIsOff, Input.IsAllResidualHeatUsed); // Aktionen festlegen Fsm.GetState(State.PumpIsOn).OnEnter += DoPumpOn; Fsm.GetState(State.CoolBurnerByCircuit).OnEnter += DoPumpOn; Fsm.GetState(State.PumpIsOff).OnEnter += DoPumpOff; } catch (Exception ex) { Log.Error($"HeatingCircuit;Fehler bei Init FsmHeatingCircuit, ex: {ex.Message}"); } }
void Awake() { Screen.showCursor = false; Screen.lockCursor = true; foreach (var value in System.Enum.GetValues(typeof(ClockState))) { clockMachine.AddState((int)value); } foreach (var value in System.Enum.GetValues(typeof(ClockCommand))) { clockMachine.AddCommand((int)value); } clockMachine.AddTransition((int)ClockState.SPAWNING, (int)ClockCommand.NEXT, (int)ClockState.SPAWNED); clockMachine.AddTransition((int)ClockState.SPAWNED, (int)ClockCommand.NEXT, (int)ClockState.DESPAWNING); clockMachine.AddTransition((int)ClockState.DESPAWNING, (int)ClockCommand.NEXT, (int)ClockState.DESPAWNED); clockMachine.AddTransition((int)ClockState.DESPAWNED, (int)ClockCommand.NEXT, (int)ClockState.SPAWNING); clockMachine.SetStateProcessOnEnter((int)ClockState.SPAWNING, MapSpawn); clockMachine.SetStateProcessOnEnter((int)ClockState.DESPAWNING, MapDespawn); clockMachine.Begin((int)ClockState.SPAWNING); MapSpawn(); Countdown(); }
protected override void Start() { base.Start(); brain = new FiniteStateMachine <States>(); // This calls the Run() function while on run state. // I will probably replace it with with a state callback or something similar sometime in the future to avoid calling TryGetValue all the time. brain.AddTransition(States.Idle, States.Patrol, StartPatrol); brain.AddTransition(States.Seek, States.Patrol, StartPatrol); brain.AddTransition(States.Patrol, States.Patrol, DoPatrol); brain.AddTransition(States.Idle, States.Seek, StartSeek); brain.AddTransition(States.Patrol, States.Seek, StartSeek); brain.AddTransition(States.Seek, States.Seek, DoSeek); brain.AddTransition(States.Patrol, States.Idle, StartIdle); brain.AddTransition(States.Seek, States.Idle, StartIdle); brain.AddTransition(States.Idle, States.Idle, null); brain.Initialise(States.Idle); }
public static FiniteStateMachine ConfigureFSM(IEnumerable <GOAPAction> plan, Func <IEnumerator, Coroutine> startCoroutine) { var prevState = plan.First().linkedState; var fsm = new FiniteStateMachine(prevState, startCoroutine); foreach (var action in plan.Skip(1)) { if (prevState == action.linkedState) { continue; } fsm.AddTransition("On" + action.linkedState.Name, prevState, action.linkedState); prevState = action.linkedState; } return(fsm); }
void ConstructStateMachine() { _fsm.AddState(States.Idle, new State() { enter = () => { // get some offset in the animation. _animator.Play("Idle", -1, Random.value); }, update = () => { DoMovementStuff(); }, }); _fsm.AddState(States.Walking, new State() { enter = () => _animator.Play("Walking"), update = () => { UpdateAnimatorSpeed(); DoMovementStuff(); }, exit = () => _animator.speed = 1f, }); _fsm.AddState(States.Flying, new State() { enter = () => _animator.Play("FlyingWalking"), update = () => { UpdateAnimatorSpeed(); DoMovementStuff(); }, exit = () => _animator.speed = 1f, }); _fsm.AddState(States.FollowingIdle, new State() { enter = () => { // Tell the bird set that we've been got! _birdSet.Add(_channel); // Disable the offset driver! _driveChannelByOffset.enabled = false; // Tell the fader to fade in all the way. StartCoroutine(_channel.FadeIn(_fadeInTime)); _animator.Play("Idle"); }, update = () => DoFollowStuff(), }); _fsm.AddState(States.FollowingWalking, new State() { enter = () => _animator.Play("Walking"), update = () => { UpdateAnimatorSpeed(); DoFollowStuff(); }, exit = () => _animator.speed = 1f, }); _fsm.AddState(States.FollowingFlying, new State() { enter = () => _animator.Play("FlyingWalking"), update = () => { UpdateAnimatorSpeed(); DoFollowStuff(); }, exit = () => _animator.speed = 1f, }); _fsm.AddState(States.Disabled, new State()); _fsm.AddTransition(States.Idle, States.Walking, Triggers.Moving); _fsm.AddTransition(States.Idle, States.Flying, Triggers.Airborne); _fsm.AddTransition(States.Idle, States.FollowingIdle, Triggers.FollowingTarget); _fsm.AddTransition(States.Walking, States.Idle, Triggers.NotMoving); _fsm.AddTransition(States.Walking, States.Flying, Triggers.Airborne); _fsm.AddTransition(States.Walking, States.FollowingIdle, Triggers.FollowingTarget); _fsm.AddTransition(States.Flying, States.Idle, Triggers.Grounded); _fsm.AddTransition(States.Flying, States.FollowingIdle, Triggers.FollowingTarget); _fsm.AddTransition(States.FollowingIdle, States.FollowingWalking, Triggers.Moving); _fsm.AddTransition(States.FollowingIdle, States.FollowingFlying, Triggers.Airborne); _fsm.AddTransition(States.FollowingWalking, States.FollowingIdle, Triggers.NotMoving); _fsm.AddTransition(States.FollowingWalking, States.FollowingFlying, Triggers.Airborne); _fsm.AddTransition(States.FollowingFlying, States.FollowingIdle, Triggers.Grounded); _fsm.AddTransitionAll(States.Disabled, Triggers.Disable, false); }
/// <summary> /// Converts an activity diagram to a finite state machine. /// </summary> /// <param name="diagram">Diagram to be converted</param> /// <param name="model">Parent model of diagram, used to get sub-diagrams</param> /// <returns>a FSM of diagram</returns> public static FiniteStateMachine ActivityDiagramToFsm(UmlActivityDiagram diagram, UmlModel model) { List <UmlTransition> transitions = diagram.UmlObjects.OfType <UmlTransition>().ToList(); FiniteStateMachine fsm = new FiniteStateMachine(diagram.Name); State source = null; State target = null; String input = ""; String output = ""; Boolean haveHyperlinks = true; List <UmlTransition> newTransitions; while (haveHyperlinks) { newTransitions = new List <UmlTransition>(); foreach (UmlTransition t in transitions) { UmlTransition aux = t; if (t.Source.TaggedValues.ContainsKey("jude.hyperlink")) { newTransitions.AddRange(GetTransitionsOfDiagram(model, ref aux, hyperLinkType.Source)); } if (t.Target.TaggedValues.ContainsKey("jude.hyperlink")) { newTransitions.AddRange(GetTransitionsOfDiagram(model, ref aux, hyperLinkType.Target)); } } transitions.AddRange(newTransitions); transitions = transitions.Distinct().ToList(); haveHyperlinks = transitions.Where(x => x.Source.TaggedValues.ContainsKey("jude.hyperlink") || x.Target.TaggedValues.ContainsKey("jude.hyperlink")).Count() > 0; } RemoveForks(ref diagram, ref transitions); RemoveDecisions(ref diagram, ref transitions); foreach (UmlTransition t in transitions) { input = t.GetTaggedValue("TDACTION"); source = new State(t.Source.Name); source.Id = t.Source.Id; if (input != null) { target = new State(t.Target.Name); target.Id = t.Target.Id; output = ""; if (t.GetTaggedValue("TDPARAMETERS") != null) { output = t.GetTaggedValue("TDPARAMETERS"); } fsm.AddTransition(new Transition(source, target, input, output)); } if (t.Target is UmlFinalState) { fsm.CheckAsFinal(source); } } foreach (Transition t in fsm.Transitions) { State s = fsm.States .Where(x => x.Name.Equals(t.SourceState.Name)) .FirstOrDefault(); s.Transitions.Add(t); } fsm = WipeOutOutermost(diagram, fsm); fsm.InitialState = getInitial(fsm); return(fsm); }
static void DebugToggleMultiColor(FiniteStateMachine fsm) { FiniteState start_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState red_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState green_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState blue_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState yellow_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState magenta_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); start_state.StateName = "Start"; red_state.StateName = "Red"; green_state.StateName = "Green"; blue_state.StateName = "blue"; yellow_state.StateName = "yellow"; magenta_state.StateName = "magenta"; { red_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = red_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.red; } { green_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = green_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.green; } { blue_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = blue_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.blue; } { yellow_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = yellow_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.yellow; } { magenta_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = magenta_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.magenta; } { Transitions.OnTimer2 t = fsm.AddTransition(start_state,typeof(Transitions.OnTimer2),red_state) as Transitions.OnTimer2; t.Name = "timer_start"; t.Delay = 1.0f; } { Transitions.OnTimer2 t = fsm.AddTransition(red_state,typeof(Transitions.OnTimer2),green_state) as Transitions.OnTimer2; t.Name = "timer_red"; t.Delay = Random.value * 10.0f; } { Transitions.OnTimer2 t = fsm.AddTransition(green_state,typeof(Transitions.OnTimer2),blue_state) as Transitions.OnTimer2; t.Name = "timer_green"; t.Delay = Random.value * 10.0f; } { Transitions.OnTimer2 t = fsm.AddTransition(blue_state,typeof(Transitions.OnTimer2),yellow_state) as Transitions.OnTimer2; t.Name = "timer_blue"; t.Delay = Random.value * 10.0f; } { Transitions.OnTimer2 t = fsm.AddTransition(yellow_state,typeof(Transitions.OnTimer2),magenta_state) as Transitions.OnTimer2; t.Name = "timer_yellow"; t.Delay = Random.value * 10.0f; } { Transitions.OnTimer2 t = fsm.AddTransition(magenta_state,typeof(Transitions.OnTimer2),red_state) as Transitions.OnTimer2; t.Name = "timer_magenta"; t.Delay = Random.value * 10.0f; } fsm.ChangeState(start_state); }
static void DebugTest(FiniteStateMachine fsm) { FiniteState start_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState red_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState green_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); start_state.StateName = "Start"; red_state.StateName = "Red"; green_state.StateName = "Green"; { red_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = red_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.red; } { red_state.ExitAction = fsm.gameObject.AddComponent<StateActions.SA_SetVariable>() as IStateAction; StateActions.SA_SetVariable sa = red_state.ExitAction as StateActions.SA_SetVariable; sa.Value = new Vector3(1,2,3); } { green_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_ChangeColor>() as IStateAction; StateActions.SA_ChangeColor sa = green_state.EnterAction as StateActions.SA_ChangeColor; sa.NewColor = Color.green; } { green_state.ExitAction = fsm.gameObject.AddComponent<StateActions.SA_SetScriptVariable>() as IStateAction; StateActions.SA_SetScriptVariable sa = green_state.ExitAction as StateActions.SA_SetScriptVariable; sa.ScriptName = "SimpleScript"; sa.ValueName = "Position"; sa.Value = new Vector3(42,43,44); } { Transitions.OnMouseClick t = fsm.AddTransition(start_state,typeof(Transitions.OnMouseClick),red_state) as Transitions.OnMouseClick; t.Name = "click_start"; } { Transitions.OnMouseClick t = fsm.AddTransition(red_state,typeof(Transitions.OnMouseClick),green_state) as Transitions.OnMouseClick; t.Name = "click_red"; } { Transitions.OnMouseClick t = fsm.AddTransition(green_state,typeof(Transitions.OnMouseClick),red_state) as Transitions.OnMouseClick; t.Name = "click_green"; } fsm.ChangeState(start_state); }
static void DebugPressurePlateLight(FiniteStateMachine fsm) { FiniteState unpressed_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState pressed_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); { //unpressed_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_PressurePlateLight>() as IStateAction; //StateActions.SA_PressurePlateLight sa = unpressed_state.EnterAction as StateActions.SA_PressurePlateLight; //sa.State = false; } { pressed_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_PressurePlateLight>() as IStateAction; StateActions.SA_PressurePlateLight sa = pressed_state.EnterAction as StateActions.SA_PressurePlateLight; sa.State = true; } { Transitions.OnTriggerEnterTransition t = fsm.AddTransition(unpressed_state,typeof(Transitions.OnTriggerEnterTransition),pressed_state) as Transitions.OnTriggerEnterTransition; t.Name = "trigger_enter"; } { Transitions.OnTriggerExitTransition t = fsm.AddTransition(pressed_state,typeof(Transitions.OnTriggerExitTransition),unpressed_state) as Transitions.OnTriggerExitTransition; t.Name = "trigger_exit"; } fsm.ChangeState(unpressed_state); }
static void DebugPressurePlate(FiniteStateMachine fsm) { FiniteState unpressed_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); FiniteState pressed_state = new FiniteState();//ScriptableObject.CreateInstance<FiniteState>(); { unpressed_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_PressurePlateColor>() as IStateAction; StateActions.SA_PressurePlateColor sa = unpressed_state.EnterAction as StateActions.SA_PressurePlateColor; sa.NewColor = Color.red; } { pressed_state.EnterAction = fsm.gameObject.AddComponent<StateActions.SA_PressurePlateColor>() as IStateAction; StateActions.SA_PressurePlateColor sa = pressed_state.EnterAction as StateActions.SA_PressurePlateColor; sa.NewColor = Color.green; } { Transitions.OnTriggerEnterTransition t = fsm.AddTransition(unpressed_state,typeof(Transitions.OnTriggerEnterTransition),pressed_state) as Transitions.OnTriggerEnterTransition; t.Name = "trigger_enter"; } { Transitions.OnTriggerExitTransition t = fsm.AddTransition(pressed_state,typeof(Transitions.OnTriggerExitTransition),unpressed_state) as Transitions.OnTriggerExitTransition; t.Name = "trigger_exit"; } fsm.ChangeState(unpressed_state); }
void Start() { _myTransform = transform; Text.renderer.enabled = false; _fsm = new FiniteStateMachine("start state", StartState); _fsm.AddState("say hello", SayHello); _fsm.AddEvent("go and say hello", "start state", "say hello"); _fsm.AddEvent("say goodbye and go away", "say hello", "start state"); _fsm.AddTransition("start state", "say hello", ()=> MoveTo(Target)); _fsm.AddTransition("say hello", "start state", ()=> MoveTo(End)); }
/// <summary> /// Converts an activity diagram to a finite state machine. /// </summary> /// <param name="diagram">Diagram to be converted</param> /// <param name="model">Parent model of diagram, used to get sub-diagrams</param> /// <returns>a FSM of diagram</returns> public FiniteStateMachine ActivityDiagramToFsm(UmlActivityDiagram diagram, UmlModel model) { List <UmlTransition> transitions = diagram.UmlObjects.OfType <UmlTransition> ().ToList(); List <UmlTransition> newTransitions; //FiniteStateMachine fsm = new FiniteStateMachine(diagram.Name); FiniteStateMachine fsm = new FiniteStateMachine(); State source = null; State target = null; String input = ""; String output = ""; Boolean haveHiperlinks = true; while (haveHiperlinks) { newTransitions = new List <UmlTransition> (); foreach (UmlTransition t in transitions) { UmlTransition aux = new UmlTransition(); aux = t; List <UmlTransition> hyperlinkTrans = null; if (t.Source.TaggedValues.ContainsKey("jude.hyperlink")) { hyperlinkTrans = GetTransitionsOfDiagram(model, ref aux, hyperLinkType.Source); } if (hyperlinkTrans != null) { newTransitions.AddRange(hyperlinkTrans); } hyperlinkTrans = null; if (t.Target.TaggedValues.ContainsKey("jude.hyperlink")) { hyperlinkTrans = GetTransitionsOfDiagram(model, ref aux, hyperLinkType.Target); } if (hyperlinkTrans != null) { newTransitions.AddRange(hyperlinkTrans); } } #region new UmlDecision ID - unsuccessful List <UmlDecision> ignoreList = new List <UmlDecision> (); foreach (UmlTransition newT in newTransitions) { UmlElement src = newT.Source; UmlElement trg = newT.Target; if (src is UmlDecision) { if (!ignoreList.Contains(src)) { List <UmlDecision> decs = (from t in newTransitions where t.Source.Name.Equals(src.Name) select(UmlDecision) t.Source).Distinct().ToList(); decs.AddRange((from t in newTransitions where t.Target.Name.Equals(src.Name) select(UmlDecision) t.Target).Distinct().ToList()); String decID = Guid.NewGuid().ToString(); foreach (UmlDecision d in decs) { d.Id = decID; } ignoreList.AddRange(decs); } } if (trg is UmlDecision) { if (!ignoreList.Contains(trg)) { List <UmlDecision> decs = (from t in newTransitions where t.Target.Name.Equals(trg.Name) select(UmlDecision) t.Target).Distinct().ToList(); decs.AddRange((from t in newTransitions where t.Source.Name.Equals(trg.Name) select(UmlDecision) t.Source).Distinct().ToList()); String decID = Guid.NewGuid().ToString(); foreach (UmlDecision d in decs) { d.Id = decID; } ignoreList.AddRange(decs); } } } #endregion transitions.AddRange(newTransitions); transitions = transitions.Distinct().ToList(); haveHiperlinks = transitions.Where(x => x.Source.TaggedValues.ContainsKey("jude.hyperlink") || x.Target.TaggedValues.ContainsKey("jude.hyperlink")).Count() > 0; } RemoveForks(ref diagram, ref transitions); RemoveDecisions(ref diagram, ref transitions); UmlTransition auxTran = transitions.Where(x => x.Source is UmlInitialState).FirstOrDefault(); List <UmlTransition> auxList = new List <UmlTransition> (); auxList.Add(auxTran); for (int i = 0; i < transitions.Count; i++) { auxTran = transitions.Where(x => x.Source.Equals(auxTran.Target)).FirstOrDefault(); if (auxTran != null) { auxList.Add(auxTran); } } transitions.Clear(); transitions.AddRange(auxList); foreach (UmlTransition t in transitions) { input = t.GetTaggedValue("TDACTION"); source = new State(t.Source.Name); source.Id = t.Source.Id; if (input != null) { target = new State(t.Target.Name); target.Id = t.Target.Id; if ((((UmlActionState)t.Target).ParentLane != null) && !String.IsNullOrEmpty(((UmlActionState)t.Target).ParentLane.Name)) { target.TaggedValues.Add("Lane", ((UmlActionState)t.Target).ParentLane.Name); } output = ""; if (t.GetTaggedValue("TDEXPECTEDRESULT") != null) { output = t.GetTaggedValue("TDEXPECTEDRESULT"); } #region Cycles bool cycleTran = false; if (t.GetTaggedValue("TDCYCLETRAN") != null) { cycleTran = (t.GetTaggedValue("TDCYCLETRAN").Equals("true") ? true : false); } bool lastCycleTrans = false; if (t.GetTaggedValue("TDLASTCYCLETRANS") != null) { //lastCycleTrans = (t.GetTaggedValue("TDCYCLETRAN").Equals("true") ? true : false); lastCycleTrans = (t.GetTaggedValue("TDLASTCYCLETRANS").Equals("true") ? true : false); } Transition trans = new Transition(source, target, input, output, cycleTran, lastCycleTrans); if (t.GetTaggedValue("TDLASTCYCLETRANS") != null) { trans.TaggedValues.Add("TDCYCLETRAN", t.GetTaggedValue("TDCYCLETRAN")); } #endregion foreach (KeyValuePair <String, String> pair in t.TaggedValues) { trans.TaggedValues.Add(pair.Key, pair.Value); } //trans.TaggedValues.Add("TDACTION", t.GetTaggedValue("TDACTION")); //trans.TaggedValues.Add("TDEXPECTEDRESULT", t.GetTaggedValue("TDEXPECTEDRESULT") + ""); fsm.AddTransition(trans); } if (t.Target is UmlFinalState) { fsm.CheckAsFinal(source); } } fsm = WipeOutOutermost(diagram, fsm); fsm.InitialState = GetFsmInitialState(fsm); fsm.Name = diagram.Name; return(fsm); }