// Use this for initialization void Start() { InitMinerData(); // Hay que hacer la fsm del agente fsm = new FSM(gameObject, this); // Crear los estados en que puede estar Vender vender = new Vender(this); Abastecer abastecer = new Abastecer(this); // Asignarle a cada estado los eventos que puede tener //work.AddEvent(EventList.events.imHome); // Hay que agregarlos a la FSM fsm.AddState(GlobalStateID.abastecer, abastecer); fsm.AddState(StateID.Vender, vender); // Indicar cual es el estado inicial fsm.ChangeState(StateID.Vender); // Activo la fsm fsm.Activate(); }
private void Start() { fsm.Initialize(this); fsm.AddState((int)PlayerState.PS_IDLE, new PlayIdle <Player>()); fsm.AddState((int)PlayerState.PS_MOVE, new PlayMove <Player>()); fsm.Switch2State((int)PlayerState.PS_IDLE); }
// Use this for initialization void Start() { fsm = new FSM("AITest FSM Two"); MoveLeftState = fsm.AddState("MoveLeftState"); MoveRightState = fsm.AddState("MoveRightState"); MoveLeftAction = new MoveAction(MoveLeftState); MoveRightAction = new MoveAction(MoveRightState); MoveLeftTextAction = new TextAction(MoveLeftState); MoveRightTextAction = new TextAction(MoveRightState); //This adds the actions to the state and add state to it's transition map MoveLeftState.AddAction(MoveLeftTextAction); MoveLeftState.AddAction(MoveLeftAction); MoveRightState.AddAction(MoveRightTextAction); MoveRightState.AddAction(MoveRightAction); MoveLeftState.AddTransition("ToRight", MoveRightState); MoveRightState.AddTransition("ToLeft", MoveLeftState); //this initializes the actions MoveLeftTextAction.Init("AI Moving Left", 1f, ""); MoveRightTextAction.Init("AI Moving Right", 1f, ""); MoveLeftAction.Init(this.transform, new Vector3(1, 0, 0), new Vector3(-1, 0, 0), 1.0f, "ToRight"); MoveRightAction.Init(this.transform, new Vector3(-1, 0, 0), new Vector3(1, 0, 0), 1.0f, "ToLeft"); //Starts the FSM fsm.Start("MoveLeftState"); }
// Use this for initialization void Start() { m_fsm = new FSM(); FSMState state1 = new FSMState("log", m_fsm, true); LogAction action1 = new LogAction(); action1.SetOwner(state1); state1.AddAction(action1); state1.AddTransition("calc", 2); FSMState state2 = new FSMState("calc", m_fsm); CalcAction action2 = new CalcAction(); action2.SetOwner(state2); state2.AddAction(action2); state2.AddTransition("log", state1.id); m_fsm.AddTransition("g_calc", state2.id); m_fsm.AddTransition("g_log", state1.id); m_fsm.AddState(state1); m_fsm.AddState(state2); m_fsm.Initialize(); m_fsm.EnableFSM(); StartCoroutine(SendGlobalEvent()); }
void Start() { fsm = new FSM("Tower AI"); // Create AttackState attackState = fsm.AddState("AttackState"); attackAction = new Attack(gameObject, attackState); // Create IdleState idleState = fsm.AddState("IdleState"); idleAction = new Idle(gameObject, idleState); // Add actions attackState.AddAction(attackAction); idleState.AddAction(idleAction); // Add events attackState.AddEvent("ToIdle", idleState); idleState.AddEvent("ToAttack", attackState); // Initialize actions attackAction.Start(finishEvent: "ToIdle"); idleAction.Start(finishEvent: "ToAttack"); // Start the fsm fsm.Start("IdleState"); }
public override void InitFish(NewCatchFish_FishInfo fishInfo) { base.InitFish(fishInfo); fishInfo = fishInfo; //foreach (var item in NewCatChFish_Mgr.Instance.fishConfig) //{ // if (item.fishKind == fishInfo.FishKind) // { // foreach (var path in item.fishPath) // { // if (path.Key == fishInfo.PathId) // { // fishPath = path.Value; // } // } // } //} if (fishPath == null) { Debug.LogError("找不到鱼的路线"); return; } OnEnterFishpond += EnterFishpondEvent; OnLeavaFishpond += LeaveFishpondEvent; //transform.SetParent(NewCatChFish_Mgr.Instance.fishpond.transform); fishfsm = new FSM(); fishfsm.AddState(new StateMove_Temp(), this); fishfsm.AddState(new StateFrozen_Temp(), this); fishfsm.AddState(new StateDead_Temp(), this); fishfsm.Init(); }
void initFSM() { _state.AddState(_sleep_state, onSleepEnter); _state.AddState(_searchTarget_state, onSearchTargetEnter); _state.AddState(_run_state, onRunEnter, onRunUpdate); _state.SetState(_sleep_state); }
// Use this for initialization void Start() { InitMinerData(); // Hay que hacer la fsm del agente fsm = new FSM(gameObject, this); // Crear los estados en que puede estar Cooking cook = new Cooking(this); Bathroom bath = new Bathroom(this); Housework work = new Housework(this); // Asignarle a cada estado los eventos que puede tener //work.AddEvent(EventList.events.imHome); // Hay que agregarlos a la FSM fsm.AddState(StateID.Cooking, cook); fsm.AddState(StateID.Bathroom, bath); fsm.AddState(StateID.DoHousework, work); // Indicar cual es el estado inicial fsm.ChangeState(StateID.DoHousework); // Activo la fsm fsm.Activate(); }
private void Start() { _playerState.AddState(PlayerState.Run); _playerState.AddState(PlayerState.Jump); _playerState.AddState(PlayerState.DoubleJump); _playerState.AddTranslateState(PlayerEvent.EVENT_JUMP, PlayerState.Run, PlayerState.Jump, o => { Jump(); }); _playerState.AddTranslateState(PlayerEvent.EVENT_JUMP, PlayerState.Jump, PlayerState.DoubleJump, o => { DoubleJump(); }); _playerState.AddTranslateState(PlayerEvent.EVENT_RUN, PlayerState.Jump, PlayerState.Run, o => { Run(); }); _playerState.AddTranslateState(PlayerEvent.EVENT_RUN, PlayerState.DoubleJump, PlayerState.Run, o => { Run(); }); _playerState.StartState(PlayerState.Jump); State = _playerState; }
public void NodeStateTest_CatchingToMining() { _fsm = new FSM(); int TransferFromCatching() { if (_fsm.StateEvent == StateEvent.ValidBlockHeader) { return((int)NodeState.BlockValidating); } if (_fsm.StateEvent == StateEvent.MiningStart) { return((int)NodeState.GeneratingConsensusTx); } return((int)NodeState.Catching); } _fsm.AddState((int)NodeState.Catching) .SetTransferFunction(TransferFromCatching) .OnEntering(LogWhenEntering) .OnEntering(FindMoreBlockHeadersToValidate) .OnLeaving(LogWhenLeaving); _fsm.AddState((int)NodeState.GeneratingConsensusTx); _fsm.AddState((int)NodeState.BlockValidating); _fsm.CurrentState = (int)NodeState.Catching; _fsm.ProcessWithStateEvent(StateEvent.MiningStart); Assert.Equal((int)NodeState.GeneratingConsensusTx, _fsm.CurrentState); }
public void NodeStateTest_BlockValidatingToBlockExecuting() { _fsm = new FSM(); int TransferFromBlockValidating() { if (_fsm.StateEvent == StateEvent.ValidBlock) { return((int)NodeState.BlockExecuting); } if (_fsm.StateEvent == StateEvent.InvalidBlock) { return((int)NodeState.Catching); } return((int)NodeState.BlockValidating); } _fsm.AddState((int)NodeState.BlockValidating) .SetTransferFunction(TransferFromBlockValidating) .OnEntering(LogWhenEntering) .OnLeaving(LogWhenLeaving); _fsm.AddState((int)NodeState.Catching); _fsm.AddState((int)NodeState.BlockExecuting); _fsm.CurrentState = (int)NodeState.BlockValidating; _fsm.ProcessWithStateEvent(StateEvent.ValidBlock); Assert.Equal((int)NodeState.BlockExecuting, _fsm.CurrentState); }
// Use this for initialization void Start() { fsm = new Core.FSM.FSM("PatrolDialogueNPCFSM"); moveState = fsm.AddState("MoveState"); idleState = fsm.AddState("IdleState"); dialogueState = fsm.AddState("DialogueState"); moveAction = new WaypointMoveAction(moveState); idleAction = new NPCIdleScoutAction(idleState); dialogueAction = new NPCDialogueAction(dialogueState); moveState.AddAction(moveAction); idleState.AddAction(idleAction); dialogueState.AddAction(dialogueAction); moveAction.Init(GetComponent <Rigidbody>(), gameObject.transform, movementSpeed, waypoints, "ToIdle"); idleAction.Init(3, gameObject.transform); dialogueAction.Init(this, dialogueIdentifier); idleState.AddTransition("ToDialogue", dialogueState); idleState.AddTransition("ToNextWaypoint", moveState); moveState.AddTransition("ToIdle", idleState); dialogueState.AddTransition("ToIdle", idleState); fsm.Start("MoveState"); }
//添加状态 void AddState() { fsm.AddState(idleState); fsm.AddState(runState); fsm.AddState(attackState); fsm.AddState(deadState); }
void Awake() { FSM <State, Trigger, ChangedStateEventArgs> movementFSM = new FSM <State, Trigger, ChangedStateEventArgs>(); movementFSM.AddState(new CharacterIdleState(movementFSM, State.Idle, this)); movementFSM.AddState(new MovingState(movementFSM, State.Moving, this)); movementFSM.MakeTransition(State.Idle, Trigger.Move, State.Moving); movementFSM.MakeTransition(State.Moving, Trigger.StopMoving, State.Idle); movementFSM.StartBy(State.Idle); FSM <State, Trigger, ChangedStateEventArgs> jumpingFSM = new FSM <State, Trigger, ChangedStateEventArgs>(); jumpingFSM.AddState(new GroundedState(jumpingFSM, State.Grounded, this)); jumpingFSM.AddState(new JumpingState(jumpingFSM, State.Jumping, this)); jumpingFSM.AddState(new FallingState(jumpingFSM, State.Falling, this)); jumpingFSM.MakeTransition(State.Grounded, Trigger.Jump, State.Jumping); jumpingFSM.MakeTransition(State.Jumping, Trigger.Fall, State.Falling); jumpingFSM.MakeTransition(State.Falling, Trigger.Ground, State.Grounded); jumpingFSM.StartBy(State.Falling); stateMachines = new FSM <State, Trigger, ChangedStateEventArgs> [2]; stateMachines[0] = movementFSM; stateMachines[1] = jumpingFSM; }
// Use this for initialization void Start() { InitMinerData(); // Hay que hacer la fsm del agente fsm = new FSM(gameObject, this); // Crear los estados en que puede estar Vacio vacio = new Vacio(this); Arar arar = new Arar(this); Cosechar cosechar = new Cosechar(this); // Asignarle a cada estado los eventos que puede tener //work.AddEvent(EventList.events.imHome); // Hay que agregarlos a la FSM fsm.AddState(StateID.Vacio, vacio); fsm.AddState(GlobalStateID.arar, arar); fsm.AddState(GlobalStateID.cosechar, cosechar); // Indicar cual es el estado inicial // fsm.ChangeState(GlobalStateID.abastecer); fsm.ChangeState(StateID.Vacio); // Activo la fsm fsm.Activate(); }
public GameStateController() { gameFsm = new FSM("GameFSM"); preStartState = gameFsm.AddState((byte)GameState.PreStart); idleState = gameFsm.AddState((byte)GameState.Idle); playState = gameFsm.AddState((byte)GameState.Play); pauseState = gameFsm.AddState((byte)GameState.Pause); gameOverState = gameFsm.AddState((byte)GameState.GameOver); preStartAction = new PreStartAction(preStartState); playingAction = new PlayAction(playState); pauseAction = new PauseAction(pauseState); gameOverAction = new GameOverAction(gameOverState); idleAction = new IdleAction(idleState); preStartState.AddTransition((byte)FSMTransition.ToIdle, idleState); idleState.AddTransition((byte)FSMTransition.ToPlay, playState); playState.AddTransition((byte)FSMTransition.ToPause, pauseState); playState.AddTransition((byte)FSMTransition.ToGameOver, gameOverState); gameOverState.AddTransition((byte)FSMTransition.ToIdle, idleState); preStartAction.Init(); idleAction.Init(); playingAction.Init(); pauseAction.Init(); gameOverAction.Init(); }
// Use this for initialization void Start() { InitMinerData(); // Hay que hacer la fsm del agente fsm = new FSM(gameObject, this); // Crear los estados en que puede estar Bob Mining mining = new Mining(this); DepositInBank deposit = new DepositInBank(this); Sleeping sleep = new Sleeping(this); Eating eat = new Eating(this); Drinking drink = new Drinking(this); // Agregar eventos a los estados //sleep.AddEvent(EventList.events.dinnerReady); // Hay que agregarlos a la FSM fsm.AddState(StateID.Mining, mining); fsm.AddState(StateID.DepositInBank, deposit); fsm.AddState(StateID.Sleeping, sleep); fsm.AddState(StateID.Eating, eat); fsm.AddState(StateID.Drinking, drink); // Indicar cual es el estado inicial fsm.ChangeState(StateID.Mining); // Activo la fsm fsm.Activate(); }
private void Start() { fsm = new FSM("AITest FSM Two"); MoveForwardState = fsm.AddState("MoveForwardState"); IdleState = fsm.AddState("MoveRightState"); TurnState = fsm.AddState("TurnState"); MoveForwardAction = new MoveAction(MoveForwardState); IdleAction = new MoveAction(IdleState); TurnAction = new TurnAction(TurnState); MoveForwardState.AddAction(MoveForwardAction); IdleState.AddAction(IdleAction); TurnState.AddAction(TurnAction); MoveForwardState.AddTransition("ToTurn", TurnState); TurnState.AddTransition("ToIdle", IdleState); TurnState.AddTransition("ToTurn", TurnState); IdleState.AddTransition("ToForward", MoveForwardState); IdleState.AddTransition("ToTurn", TurnState); MoveForwardAction.Init(this.transform, .1f, 2.0f, "ToTurn"); TurnAction.Init(this.transform, 2.0f, "ToIdle"); IdleAction.Init(this.transform, 0, 2.0f, "ToForward"); fsm.Start("MoveForwardState"); }
// Use this for initialization void Start() { InitGranjeroData(); // Hay que hacer la fsm del agente fsm = new FSM(gameObject, this); // Crear los estados en que puede estar Casa casa = new Casa(this); Arar arar = new Arar(this); Regar regar = new Regar(this); Cosechar cosechar = new Cosechar(this); // Hay que agregarlos a la FSM fsm.AddState(StateID.Casa, casa); fsm.AddState(StateID.Regar, regar); fsm.AddState(GlobalStateID.arar, arar); fsm.AddState(GlobalStateID.cosechar, cosechar); // Indicar cual es el estado inicial fsm.ChangeState(StateID.Casa); // Activo la fsm fsm.Activate(); }
void initFSM() { _state.AddState(fire_state, onFireEnter, onFireUpdate, onFireExit); _state.AddState(firing_state, onFiringEnter, onFiringUpdate, onFiringExit); _state.AddState(fireFinish_state, onFireFinishEnter, onFireFinishUpdate, onFireFinishExit); _state.AddState(destory_state, onDestoryEnter, onDestoryUpdate, onDestoryExit); _state.SetState(fire_state); }
void CreateFSM() { enemyFSM = new FSM(this); enemyFSM.AddState(new WalkToVillagerNode()); enemyFSM.AddState(new StealFruitNode()); enemyFSM.AddState(new WalkToHideoutNode()); }
private void CreateStates() { m_FSM.AddState(0, new Fade(m_FSM, this)); m_FSM.AddState(1, new Fade(m_FSM, this, Fade.FadeType.FADE_OUT)); m_FSM.AddState(2, new PlayAudio(m_FSM, this)); }
void CreateFSM() { villagerFSM = new FSM(this); villagerFSM.AddState(new WalkToTreeNode()); villagerFSM.AddState(new HarvestFruitNode()); villagerFSM.AddState(new WalkToVillageNode()); villagerFSM.AddState(new DropOffFruitNode()); }
void initFSM() { _state.AddState(_sleep_state, onSleepEnter); _state.AddState(_idle_state, onIdleEnter, onIdleUpdate); _state.AddState(_run_state, onRunEnter, onRunUpdate, onRunExit); _state.AddState(_waitAttack_state, onWaitAttackEnter, onWaitAttackUpdate, onWaitAttackExit); _state.AddState(_attack_state, onAttackEnter, onAttackUpdate, onAttackExit); _state.SetState(_sleep_state); }
void InitFsm() { _fsm = new FSM(); _fsm.SetCurrStateName("Idle"); float remainingTime = 0; _fsm.AddState("Idle"); _fsm.AddState("DelayToMonsterSpawn", () => { remainingTime = delayTime; }, () => { remainingTime -= Time.deltaTime; if (remainingTime <= 0) { _fsm.SendEvent("AllToMonsterSpawn"); } }, () => { }); IEnumerator enumerator = null; _fsm.AddState("MonsterSpawn", () => { int level = 1; if (GameManager.Instance != null && GameManager.Instance.Player1 != null && GameManager.Instance.Player1.RoleData != null) { level = GameManager.Instance.Player1.RoleData.level; } enumerator = Spawn(RoleGroupList[(CurrIndex++) % RoleGroupList.Count].RoleIdList, "2", level); }, () => { bool canNext = enumerator.MoveNext(); RoleController roleController = enumerator.Current as RoleController; if (roleController) { aliveMonsterCount++; roleController.OnDying += RoleDying; } if (!canNext) { _fsm.SendEvent("AllToIdle"); } }, () => { enumerator = null; }); _fsm.AddEvent("IdleToMonsterSpawn", "Idle", "DelayToMonsterSpawn", () => { return(aliveMonsterCount == 0); }); }
public Game() { fsm.AddState(FSM.MyState.init.ToString(), FSM.From_init); fsm.AddState(FSM.MyState.running.ToString(), FSM.From_running); fsm.AddState(FSM.MyState.pause.ToString(), FSM.From_pause); fsm.AddState(FSM.MyState.battle.ToString(), FSM.From_battle); Party.Add(M1); Party.Add(M2); Party.Add(M3); fsm._currentState = "running"; }
public void ShouldExecuteOnEnterWhenEnteringNextState() { var exit_here = false; var fsm = new FSM<string>(); fsm.AddState("start_here"); fsm.AddState("exit_here", input => exit_here = true); fsm.AddTransition("start_here", "exit_here", input => true); fsm.Step(); Assert.That(exit_here, Is.True); }
public void ShouldExecuteOnExitWhenLeavingCurrentState() { var was_here = false; var fsm = new FSM<string>(); fsm.AddState("start_here", null, input => was_here = true); fsm.AddState("exit_here"); fsm.AddTransition("start_here", "exit_here", input => true); fsm.Step(); Assert.That(was_here, Is.True); }
public void ShouldEvaluateTransitionCondition() { var conditionEvaluated = false; var fsm = new FSM<string>(); fsm.AddState("initial"); fsm.AddState("end"); fsm.AddTransition("initial", "end", input => { conditionEvaluated = true; return false; }); fsm.Step(); Assert.That(conditionEvaluated, Is.True); }
// Start is called before the first frame update void Awake() { damage = enemyPreset.damage; moveTime = enemyPreset.moveTime; idleTimeMin = enemyPreset.idleTimeMin; idleTimeMax = enemyPreset.idleTimeMax; wanderRadius = enemyPreset.wanderRadius; home = transform.position; trigger = GetComponentInChildren <DetectPlayer>(); trigger.GetComponent <SphereCollider>().radius = enemyPreset.detectionRadius; navMeshAgent = GetComponent <NavMeshAgent>(); navMeshAgent.speed = enemyPreset.speed; fsm = new FSM("MeleeAI FSM"); WanderState = fsm.AddState("WanderState"); IdleState = fsm.AddState("IdleState"); AlertState = fsm.AddState("AlertState"); MeleeState = fsm.AddState("MeleeState"); WanderAction = new WanderAction(WanderState); IdleAction = new TextAction(IdleState); alertAction = new AlertAction(AlertState); meleeAction = new MeleeAction(MeleeState); WanderState.AddAction(WanderAction); IdleState.AddAction(IdleAction); AlertState.AddAction(alertAction); MeleeState.AddAction(meleeAction); WanderState.AddTransition("ToIdle", IdleState); WanderState.AddTransition("PlayerDetect", AlertState); IdleState.AddTransition("ToWander", WanderState); IdleState.AddTransition("PlayerDetect", AlertState); AlertState.AddTransition("ToIdle", IdleState); AlertState.AddTransition("ToMelee", MeleeState); MeleeState.AddTransition("ToAlert", AlertState); WanderAction.Init(this.transform, home, navMeshAgent, wanderRadius, moveTime, "ToIdle"); IdleAction.Init("Idling", Random.Range(idleTimeMin, idleTimeMax), "ToWander"); alertAction.Init(trigger, navMeshAgent, "ToIdle"); meleeAction.Init(this.transform, damage, trigger, FindObjectOfType <PlayerManager>(), "ToAlert"); fsm.Start("IdleState"); }
public void ShouldEvaluateMultipleTransitionsUntilConditionIsMet() { var fsm = new FSM<string>(); fsm.AddState("one"); fsm.AddState("two"); fsm.AddState("three"); fsm.AddTransition("one", "two", input => false); fsm.AddTransition("one", "three", input => true); fsm.Step(); Assert.That(fsm.CurrentState, Is.EqualTo("three")); }
private void Awake() { manager = this; fsm = new(this); fsm.AddState <Init>(); fsm.AddState <Idle>(); fsm.AddState <AdjustCamera>(); fsm.AddState <Move>(); fsm.AddState <SwitchLevel>(); fsm.EnterState <Init>(LevelManager.MainLevel()); camera = Camera.main.GetComponent <CameraController>(); }
void Awake() { // set up the state machine with the transitions fuzStateMachine = new FSM <fuzzy>(); fuzStateMachine.AddState(new still <fuzzy>(fuzzy.still, this, 0f)); fuzStateMachine.AddState(new flee <fuzzy>(fuzzy.flee, this, 5f)); fuzStateMachine.SetInitialState(fuzzy.still); fuzStateMachine.AddTransition(fuzzy.still, fuzzy.flee); fuzStateMachine.AddTransition(fuzzy.flee, fuzzy.still); }
private void MakeFSM() { IdleState idleState = new IdleState(this, StateID.IdleState); WalkState walkState = new WalkState(this, StateID.PatrolState, walkSpeed); //IdleState idleState.AddTransition(new TimeTransition(walkState, idleTime)); //WalkState walkState.AddTransition(new TimeTransition(idleState, walkTime)); _fsm.AddState(idleState); _fsm.AddState(walkState); }
public Form1() { InitializeComponent(); phase_label.Text = GameState.init.ToString(); attack.Enabled = false; enemy_attack.Enabled = false; GAMEFSM = new FSM<GameState>(GameState.init); GAMEFSM.AddState(GameState.init); GAMEFSM.AddState(GameState.player); GAMEFSM.AddState(GameState.enemy); GAMEFSM.AddState(GameState.end); GAMEFSM.AddTransition(GameState.init, GameState.player); GAMEFSM.AddTransition(GameState.player, GameState.enemy); GAMEFSM.AddTransition(GameState.enemy, GameState.player); GAMEFSM.AddTransition(GameState.player, GameState.end); GAMEFSM.AddTransition(GameState.enemy, GameState.end); SuperSave = new SaveGameData(); }
// Use this for initialization void Start() { mFSM = new FSM(); FSM.State state = mFSM.AddState("A"); state.SetEnterMethod(delegate() { Debug.Log("Enter A " + a); }); state.SetTickMethod(delegate(float dt) { }); state.SetExitMethod(delegate() { Debug.Log("Exit A " + a); }); state = mFSM.AddState("B"); state.SetEnterMethod(delegate() { Debug.Log("Enter B" + a); }); state.SetTickMethod(delegate(float dt) { }); state.SetExitMethod(delegate() { Debug.Log("Exit B " + a); }); mFSM.addTransition("A", "B", "!(A2B1 & (A2B1 | A2B2)) & !OK"); mFSM.addTransition("B", "A", "(B2A | B2A)"); mFSM.Begin(); InvokeRepeating("Test", 3.0f, 6.0f); }
void Start() { _health = _maxHealth; _fsm = new FSM<UnitStates>(); // Add States for the FSM _fsm.AddState(UnitStates.INIT); _fsm.AddState(UnitStates.IDLE); _fsm.AddState(UnitStates.ATTACK); _fsm.AddState(UnitStates.HIT); _fsm.AddState(UnitStates.DEAD); // Add transistion for the FSM _fsm.AddTransition(UnitStates.INIT, UnitStates.IDLE); _fsm.AddTransition(UnitStates.IDLE, UnitStates.ATTACK); _fsm.AddTransition(UnitStates.ATTACK, UnitStates.IDLE); _fsm.AddTransition(UnitStates.IDLE, UnitStates.HIT); _fsm.AddTransition(UnitStates.HIT, UnitStates.IDLE); _fsm.AddTransition(UnitStates.HIT, UnitStates.DEAD); _fsm.Transition(_fsm.state, UnitStates.IDLE); }
public void ShouldFollowTransitionIfConditionIsMet() { var fsm = new FSM<string>(); fsm.AddState("start"); fsm.AddState("exit"); fsm.AddTransition("start", "exit", input => true); fsm.Step(); Assert.That(fsm.CurrentState, Is.EqualTo("exit")); }
public void ShouldExecuteTransitionAction() { var action = false; var fsm = new FSM<string>(); fsm.AddState("first"); fsm.AddState("second"); fsm.AddTransition("first", "second", input => true, input => action = true); fsm.Step(); Assert.That(action, Is.True); }
// Use this for initialization void Start () { // Console.ForegroundColor = ConsoleColor.Green; fsm = new FSM("Jave's FSM"); Debug.Log(string.Format("Start testing :{0}", fsm)); // add event show cur state changed info fsm.CurStateChangedEvent += (CurStateChangedEventHandler)((sender) => { Debug.Log(string.Format("state changed, last : {0}, cur : {1}", fsm.LastState, fsm.CurState)); }); // add event show params changed info fsm.ParamsChangedEvent += (ParamsChangedEventHandler)((sender, paramChangedArgs) => { //Debug.Log(string.Format( // "param:{1}, src:{2}, to: {3}", // fsm, paramChangedArgs.CurValue.Name, paramChangedArgs.LastValue.Value, paramChangedArgs.CurValue.Value)); }); // add some states fsm.AddState(new MyIdle(IDLE)); fsm.AddState(new MyRun(RUN)); fsm.AddState(new MyFly(FLY)); fsm.AddState(new MyDead(DEAD)); // set any state fsm.AnyState = new MyAnyState("any state"); // set cur state fsm.CurState = fsm.GetState(IDLE); // add some into fsm black board, u can add anythings for every states to calcs fsm.Blackboard.AddData("Boss", new Boss()); // add fsm some params fsm.AddParam(new ParamFunc(P_GRAVITY_FUNC_1, (FuncParamHandler)(funcArgs => // Param can be a func, handl complex logic { return fsm.GetParamValue<int>(P_SPEED) > 15 && fsm.GetParamValue<int>(P_HP) > 0 && fsm.GetParamValue<int>(P_GRAVITY) <= 0; }))); fsm.AddParam(new ParamFunc(P_GRAVITY_FUNC_2, (FuncParamHandler)(funcArgs => // Param can be a func, handl complex logic { return fsm.GetParamValue<int>(P_SPEED) < 15 && fsm.GetParamValue<int>(P_HP) > 0; }))); fsm.AddParam(new ParamValue(P_GRAVITY) { Value = 10 }); // init gravity = 10; fsm.AddParam(new ParamBoolean(P_GRAVITY_ENABLED) { Value = true }); // init gravity_enabled = true fsm.AddParam(new ParamValue(P_SPEED) { Value = 0 }); // init speed = 0; fsm.AddParam(new ParamValue(P_HP) { Value = 100 }); // init hp = 100 // idle state add some transition to run FSM.TransitionTo(fsm, IDLE, RUN, new List<Condition>() { COND_GE_10_SPEED, COND_ALIVE_HP }); // run back to idle FSM.TransitionTo(fsm, RUN, IDLE, new List<Condition>() { COND_L_10_SPEED, COND_ALIVE_HP }); // run to fly FSM.TransitionTo(fsm, RUN, FLY, new List<Condition>() { COND_GRAVITY_FUNC_1 }); // back to run FSM.TransitionTo(fsm, FLY, RUN, new List<Condition>() { COND_GRAVITY_FUNC_2, COND_E_TRUE_GRAVITY_ENABLE }); // every state to fly, except dead ToFly(fsm, IDLE); ToFly(fsm, RUN); // idle, run, fly, and so on, states add some transition to dead state's transitions. ToDead(fsm, IDLE); ToDead(fsm, RUN); ToDead(fsm, FLY); // dead back to alive(idle) FSM.TransitionTo(fsm, DEAD, IDLE, new List<Condition>() { COND_ALIVE_HP }); // dummy fsm update task // DummyFsmUpdate(fsm); Console.ReadLine(); }
public void ShouldBeFinishedWhenCurrentStateHasNoTransitions() { var fsm = new FSM<string>(); fsm.AddState("a state"); Assert.That(fsm.Finished, Is.True); }
public void ShouldStartAtFirstState() { var fsm = new FSM<string>(); fsm.AddState("initial"); fsm.AddState("end"); Assert.That(fsm.CurrentState, Is.EqualTo("initial")); }
public void ShouldNotExecuteOnEnterWhenInInitialState() { var fsm = new FSM<string>(); var onEnter = false; fsm.AddState("initial", input => onEnter = true); fsm.Step(); Assert.That(onEnter, Is.False); }
public void ShouldNotBeFinishedWhenCurrentHasTransitions() { var fsm = new FSM<string>(); fsm.AddState("one"); fsm.AddState("two"); fsm.AddTransition("one", "two", input => true); Assert.That(fsm.Finished, Is.False); }