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