// 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);
}
