public void StateMachine_AvailableTriggers_ConcatsModelsTransWithGlobal_ReturnsDistinctTrigsByName()
{
var model = new StubStateModel();
var machine = new StateMachine <StubStateModel>();
var trigger1 = new Trigger("t1");
var trigger2 = new Trigger("t2");
var state1 = new State <StubStateModel>("s1");
var state2 = new State <StubStateModel>("s2");
var state3 = new State <StubStateModel>("s3");
var state4 = new State <StubStateModel>("s4");
var statetrans1 = new Transition <StubStateModel>(trigger1, state1, state2);
var statetrans2 = new Transition <StubStateModel>(trigger1, state1, state3);
var statetrans3 = new Transition <StubStateModel>(trigger2, state1, state3);
var globaltrans1 = new Transition <StubStateModel>(trigger2, null, state1);
machine.AddGlobalTransition(globaltrans1);
state1.AddTransition(statetrans1);
state1.AddTransition(statetrans2);
state1.AddTransition(statetrans3);
model.CurrentState = state1;
var result = machine.AvailableTriggers(model);
Assert.Equal(2, result.Count());
Assert.Equal(trigger1, result.ToList()[0]);
Assert.Equal(trigger2, result.ToList()[1]);
}
// Start is called before the first frame update
void Start()
{
// language
getHungry = new Symbol("Get Hungry");
getsDark = new Symbol("Gets Dark");
getsBall = new Symbol("Gets Ball");
// states
eating = new State("EATING", typeof(EatingBehaviour));
playing = new State("PLAYING", typeof(PlayingBehaviour));
sleeping = new State("SLEEPING", typeof(SleepingBehaviour));
//transition function
eating.AddTransition(getHungry, eating);
eating.AddTransition(getsDark, sleeping);
eating.AddTransition(getsBall, playing);
playing.AddTransition(getHungry, playing);
playing.AddTransition(getsDark, sleeping);
playing.AddTransition(getsBall, playing);
sleeping.AddTransition(getHungry, sleeping);
sleeping.AddTransition(getsDark, eating);
sleeping.AddTransition(getsBall, eating);
// initial state
currentState = playing;
currentBehaviour = gameObject.AddComponent(currentState.Behaviour) as MonoBehaviour;
}
private void CreateRotateRight(StateMachine stateMachine)
{
State state;
Transition transition;
state = new State("RotateRight");
stateMachine.AddState(state);
state.AddBehaviour(new RotateAIBehaviour(5f));
state.AddBehaviour(new PlayAnimationBehaviour("Rotate Right", 0.1f));
transition = new Transition("Idle");
state.AddTransition(transition);
transition.AddCondition(new RangeCheckToPlayerCondition(e => e < stateMachine.User.GetComponent <EnemyController>().AI.stoppingDistance));
transition.AddCondition(new AngleCheckToPlayerCondition(e => e <0.1f && e> -0.1f));
transition = new Transition("Idle");
state.AddTransition(transition);
transition.AddCondition(new RangeCheckToPlayerCondition(e => e > stateMachine.User.GetComponent <EnemyController>().lookRadius));
transition.AddCondition(new AngleCheckToPlayerCondition(e => e <0.1f && e> -0.1f));
transition = new Transition("WalkForward");
state.AddTransition(transition);
transition.AddCondition(new RangeCheckToPlayerCondition(e => e < stateMachine.User.GetComponent <EnemyController>().lookRadius));
transition.AddCondition(new RangeCheckToPlayerCondition(e => e > stateMachine.User.GetComponent <EnemyController>().AI.stoppingDistance));
}
private void CreateWalkBackward(StateMachine stateMachine)
{
State state;
Transition transition;
state = new State("WalkBackward");
stateMachine.AddState(state);
state.AddBehaviour(new MoveBehaviour(-3f));
state.AddBehaviour(new RotateBehaviour(75f));
state.AddBehaviour(new PlayAnimationBehaviour("Walk", 0.1f));
state.AddBehaviour(new DrainEnergyBehaviour(3));
transition = new Transition("Jump");
state.AddTransition(transition);
transition.AddCondition(new ButtonCondition("Jump"));
transition.AddCondition(new IsGroundedCondition());
transition = new Transition("Idle");
state.AddTransition(transition);
transition.AddCondition(new VerticalAxisCondition(e => e == 0));
transition = new Transition("Transformation");
state.AddTransition(transition);
transition.AddCondition(new IsEnergyZeroCondition());
}
void Awake()
{
enemyType = GetComponent <Enemy>();
// States
var patrol = new State <OnCondition>("Patrol");
var persuit = new State <OnCondition>("Persuit");
var attack = new State <OnCondition>("Attack");
var escape = new State <OnCondition>("Escape");
var die = new State <OnCondition>("Die");
// States functionality
patrol.OnUpdate += () => enemyType.Patrol();
attack.OnUpdate += () => enemyType.Attack();
// Transitions
patrol.AddTransition(OnCondition.Attack, attack);
patrol.AddTransition(OnCondition.Escape, escape);
patrol.AddTransition(OnCondition.Die, die);
attack.AddTransition(OnCondition.Patrol, patrol);
attack.AddTransition(OnCondition.Escape, escape);
attack.AddTransition(OnCondition.Die, die);
escape.AddTransition(OnCondition.Patrol, patrol);
escape.AddTransition(OnCondition.Attack, attack);
escape.AddTransition(OnCondition.Die, die);
fsm = new StateMachine <OnCondition>(patrol);
}
private void CreateWalkForward(StateMachine stateMachine)
{
State state;
Transition transition;
state = new State("WalkForward");
stateMachine.AddState(state);
state.AddBehaviour(new MoveBehaviour(5f));
state.AddBehaviour(new RotateBehaviour(75f));
state.AddBehaviour(new PlayAnimationBehaviour("Run", 0.1f));
transition = new Transition("Jump");
state.AddTransition(transition);
transition.AddCondition(new ButtonCondition("Jump"));
transition.AddCondition(new IsGroundedCondition());
transition = new Transition("Idle");
state.AddTransition(transition);
transition.AddCondition(new VerticalAxisCondition(e => e == 0));
transition = new Transition("Jump");
state.AddTransition(transition);
transition.AddCondition(new ButtonCondition("Jump"));
transition.AddCondition(new IsGroundedCondition());
transition = new Transition("MeleeAttack");
state.AddTransition(transition);
transition.AddCondition(new ButtonCondition("MeleeAttack"));
transition = new Transition("RangeAttack");
state.AddTransition(transition);
transition.AddCondition(new ButtonCondition("RangeAttack"));
}
public ApplicationController(
Game game,
IGameController gameController,
IInputService inputService)
{
this.game = game;
this.gameController = gameController;
this.inputService = inputService;
var intro = new State<Action<double>>(
"Intro",
null,
delegate
{
this.introGameState = new IntroGameState(this.game);
this.gameStateManager.Push(this.introGameState);
},
() => this.gameStateManager.Pop());
var menu = new State<Action<double>>(
"Menu",
null,
delegate
{
this.menuGameState = new MenuGameState(this.game, this.inputService);
this.gameStateManager.Push(this.menuGameState);
},
() => this.gameStateManager.Pop());
var gameplay = new State<Action<double>>(
"Gameplay",
null,
delegate
{
this.gameplayGameState = new GameplayGameState(this.gameController);
this.gameStateManager.Push(this.gameplayGameState);
},
() => this.gameStateManager.Pop());
var exit = new State<Action<double>>(
"Exit",
null,
() => this.game.Exit(),
null);
intro.AddTransition(menu, () => this.introGameState.IsTransitionAllowed);
menu.AddTransition(gameplay, () => this.menuGameState.IsTransitionAllowed && (string)this.menuGameState.TransitionTag == MenuItems.StartGame);
menu.AddTransition(exit, () => this.menuGameState.IsTransitionAllowed && (string)this.menuGameState.TransitionTag == MenuItems.ExitGame);
gameplay.AddTransition(menu, () => this.gameplayGameState.IsTransitionAllowed);
this.applicationStateMachine = new StateMachine<Action<double>>(intro);
//this.applicationStateMachine = new StateMachine<Action<double>>(gameplay); // Skipping intro and menu for faster startup
}
public static Nfa Optional(Nfa nfa)
{
State startState = new State();
startState.AddTransition(new EpsilonTransition(nfa.StartState));
State endState = new State();
nfa.EndState.AddTransition(new EpsilonTransition(endState));
startState.AddTransition(new EpsilonTransition(endState));
return new Nfa(startState, endState);
}
public void State_AddTransition_TwoTransitionsWithSameTriggerFromToNoGuard_ThrowsDuplicateTransitionException()
{
var state1 = new State <StubStateModel>("s1");
var state2 = new State <StubStateModel>("s2");
var trigger1 = new Trigger("t1");
var transition1 = new Transition <StubStateModel>(trigger1, state1, state2);
var transition2 = new Transition <StubStateModel>(trigger1, state1, state2);
state1.AddTransition(transition1);
Assert.Throws <InvalidTransitionException>(() =>
state1.AddTransition(transition2));
}
// Create the FSM
private void Start()
{
// Create the states
State onGuardState = new State("On Guard",
() => Debug.Log("Enter On Guard state"),
null,
() => Debug.Log("Leave On Guard state"));
State fightState = new State("Fight",
() => Debug.Log("Enter Fight state"),
ChaseSmallEnemy,
() => Debug.Log("Leave Fight state"));
State runAwayState = new State("Runaway",
() => Debug.Log("Enter Runaway state"),
RunAway,
() => Debug.Log("Leaving Runaway state"));
// Add the transitions
onGuardState.AddTransition(
new Transition(
() =>
(smallEnemy.transform.position - transform.position).magnitude
< minDistanceToSmallEnemy,
() => Debug.Log("I just saw a small enemy!"),
fightState));
onGuardState.AddTransition(
new Transition(
() =>
(bigEnemy.transform.position - transform.position).magnitude
< minDistanceToBigEnemy,
() => Debug.Log("I just saw a big enemy!"),
runAwayState));
fightState.AddTransition(
new Transition(
() => URandom.value < 0.001f ||
(bigEnemy.transform.position - transform.position).magnitude
< minDistanceToBigEnemy,
() => Debug.Log("Losing a fight!"),
runAwayState));
runAwayState.AddTransition(
new Transition(
() => (smallEnemy.transform.position - transform.position).magnitude
> minDistanceToSmallEnemy
&&
(bigEnemy.transform.position - transform.position).magnitude
> minDistanceToBigEnemy,
() => Debug.Log("I barely escaped!"),
onGuardState));
// Create the state machine
stateMachine = new StateMachine(onGuardState);
}
public void State_AddTransition_TwoTransitionsWithSameTriggerFromToGuard_ThrowsDuplicateTransitionException()
{
var state1 = new State<StubStateModel>("s1");
var state2 = new State<StubStateModel>("s2");
Func<StubStateModel, bool> guard = m => true;
var trigger1 = new Trigger("t1");
var transition1 = new Transition<StubStateModel>(trigger1, state1, state2, guard);
var transition2 = new Transition<StubStateModel>(trigger1, state1, state2, guard);
state1.AddTransition(transition1);
Assert.Throws<InvalidTransitionException>(() =>
state1.AddTransition(transition2));
}
public void SetStateMachine()
{
var iterate = new State <TurretState>("ITERATE");
var quiet = new State <TurretState>("QUIET");
var shooting = new State <TurretState>("SHOOT");
var moving = new State <TurretState>("MOVING");
var dying = new State <TurretState>("DYING");
quiet.AddTransition(TurretState.shooting, shooting);
quiet.AddTransition(TurretState.moving, moving);
quiet.AddTransition(TurretState.iterate, iterate);
quiet.AddTransition(TurretState.dying, dying);
shooting.AddTransition(TurretState.quiet, quiet);
shooting.AddTransition(TurretState.moving, moving);
shooting.AddTransition(TurretState.iterate, iterate);
shooting.AddTransition(TurretState.dying, dying);
moving.AddTransition(TurretState.moving, shooting);
moving.AddTransition(TurretState.iterate, iterate);
moving.AddTransition(TurretState.dying, dying);
iterate.AddTransition(TurretState.moving, moving);
iterate.AddTransition(TurretState.shooting, shooting);
iterate.AddTransition(TurretState.dying, dying);
quiet.OnEnter += () => vfx.ClearAnimations();
quiet.OnUpdate += () => Quiet();
quiet.OnUpdate += () => vfx.Quiet();
shooting.OnEnter = () => vfx.ClearAnimations();
shooting.OnUpdate += () => Shoot();
shooting.OnExit = () => vfx.ClearAnimations();
moving.OnEnter = () => vfx.ClearAnimations();
moving.OnUpdate += () => navigation.MoveToNext();
moving.OnUpdate += () => vfx.OnMovement(navigation.speed);
if (hasNavigation)
{
iterate.OnEnter += () => navigation.NextNode();
iterate.OnEnter += () => vfx.ClearAnimations();
iterate.OnEnter += () => vfx.Rotate();
}
dying.OnEnter = () => StartCoroutine(Dying());
stateMachine = new EventFSM <TurretState>(quiet);
}
void Start () {
idle = new State(new Action_NoAction(), new Action_ReadyToShoot(), new Action_StartShooting(), "Idle");
firing = new State(new Action_NoAction(), new Action_Shooting(), new Action_StopShooting(), "Firing");
outOfAmmo = new State(new Action_NoAction(), new Action_EmptyClip(), new Action_ReloadTime(), "Out Of Ammo");
reload = new State(new Action_NoAction(), new Action_Reloading(), new Action_FullClip(), "Reload");
idle.AddTransition(new Transition(firing, new Action_NoAction()), "Trigger Pulled");
firing.AddTransition(new Transition(idle, new Action_NoAction()), "Trigger Released");
firing.AddTransition(new Transition(outOfAmmo, new Action_NoAction()), "Empty Clip");
outOfAmmo.AddTransition(new Transition(reload, new Action_NoAction()), "Reloading");
reload.AddTransition(new Transition(idle, new Action_NoAction()), "Reloaded");
stateMachine = ApplyStateMachine.createFSMInstance(idle, new Action_NoAction(), this.gameObject, name);
}
public static StateMachine SetupCookingHood()
{
var stateMachine = new StateMachine();
var s1 = new State("PowerOff");
var s2 = new State("PowerOn");
var s3 = new State("MaxPower");
var plus = new Event("PLUS");
var minus = new Event("MINUS");
s1.AddTransition(plus, new Transition
{
Target = s2,
Action = () => stateMachine.SetVariable("power", MIN_POWER)
});
s2.AddTransition(plus, new Transition
{
Target = s3,
Condition = () => stateMachine.GetVariable <int>("power") == MAX_POWER
});
s2.AddTransition(plus, new Transition
{
Condition = () => stateMachine.GetVariable <int>("power") < MAX_POWER,
Action = () => stateMachine.SetVariable("power", stateMachine.GetVariable <int>("power") + 1)
});
s2.AddTransition(minus, new Transition
{
Target = s1,
Condition = () => stateMachine.GetVariable <int>("power") == MIN_POWER
});
s2.AddTransition(minus, new Transition
{
Condition = () => stateMachine.GetVariable <int>("power") > MIN_POWER,
Action = () => stateMachine.SetVariable("power", stateMachine.GetVariable <int>("power") - 1)
});
s3.AddTransition(minus, new Transition
{
Target = s2,
Action = () => stateMachine.SetVariable("power", MAX_POWER)
});
stateMachine.CurrentState = s1;
return(stateMachine);
}
void Start()
{
var idleState = new State("Idle", IdleStateEnter, IdleStateExecute, IdleStateExit);
var walkingState = new State("Walking", WalkingStateEnter, WalkingStateExecute, WalkingStateExit);
var jumpingState = new State("Jumping", JumpingStateEnter, JumpingStateExecute, JumpingStateExit);
idleState
.AddTransition(walkingState, () => Mathf.Abs(playerMotor.Velocity.z) > 0.1f)
.AddTransition(jumpingState, () => !playerMotor.IsGrounded);
walkingState
.AddTransition(idleState, () => Mathf.Abs(playerMotor.Velocity.z) < 0.1f)
.AddTransition(jumpingState, () => !playerMotor.IsGrounded);
jumpingState.AddTransition(idleState, () => playerMotor.IsGrounded);
State[] states = new State[]
{
idleState,
walkingState
};
playerStateMachine = new StateMachine(states);
}
public Transition AddTransition(State source_, State target_, Func <object, bool, bool> Condition_ = null, int token_ = 0)
{
var trans = new Transition(source_, target_, Condition_, token_);
source_.AddTransition(trans);
return(trans);
}
public override CallFlow BuildCallFlow()
{
CallFlow flow = new CallFlow();
flow.AddState(ViewStateBuilder.Build("greeting", "myMenu", new Say("greeting", "Welcome to the dynamic menu example.")), true);
//This is a fake service that mimics getting meta-data for the menus from a web service or database
DynamicMenuService service = new DynamicMenuService();
VoiceMenu myMenu = service.GetMenu("myMenu");
Prompt menuOptions = new Prompt();
//Build the prompts for the menu options form the meta-data
foreach (MenuOption option in myMenu.Options)
{
menuOptions.audios.Add(new TtsMessage(option.PromptMsg + service.GetSelectionPrompt(option.Number)));
}
//Create the initial state and view model without any transitions
State myMenuState = ViewStateBuilder.Build("myMenu", new Ask("myMenu", menuOptions,
new Grammar(new BuiltinGrammar(BuiltinGrammar.GrammarType.digits, 1, 1))));
//Add the transitions to the state
foreach (MenuOption option in myMenu.Options)
{
myMenuState.AddTransition("continue", option.TransitionTarget, new Condition("result == '" + option.Number.ToString() + "'"));
}
//Add the state to the call flow
flow.AddState(myMenuState);
flow.AddState(ViewStateBuilder.Build("doThis", new Exit("doThis", "You selected to do this. Goodbye.")));
flow.AddState(ViewStateBuilder.Build("doThat", new Exit("doThat", "You selected to do that. Goodbye.")));
flow.AddState(ViewStateBuilder.Build("doWhatever", new Exit("doWhatever", "You selected to do whatever. Goodbye.")));
flow.AddState(ViewStateBuilder.Build("invalidSelect", new Exit("invalidSelect", "That was an invalid selection. Goodbye.")));
return(flow);
}
// Start is called before the first frame update
void Start()
{
idle = new State("Idle");
idle.OnEnter += (IState state) => {
Debug.Log("进入Idle状态");
};
move = new State("Move");
move.OnUpdate += (float deltaTime) => {
transform.position += transform.forward * speed;
};
idle2Move = new Transition(idle, move);
idle2Move.OnCheck += () => {
return(isMove);
};
idle.AddTransition(idle2Move);
move2idle = new Transition(move, idle);
move2idle.OnCheck += () => {
return(!isMove);
};
move.AddTransition(move2idle);
fSMMachine = new FSMMachine("Root", idle);
fSMMachine.AddState(move);
}
public void Transition_NotTransitionParent()
{
State root = new State("root");
root.Initial = "s1";
State s1 = new State("s1");
s1.Initial = "s11";
State s11 = new State("s11");
s11.AddTransition(new Transition("s2"));
s1.AddChild(s11);
root.AddChild(s1);
State s2 = new State("s2");
root.AddChild(s2);
FSMachine fsm = new FSMachine();
fsm.SetRoot(root);
fsm.Start();
Assert.AreEqual("s1", fsm.Current.Name);
}
public void Transition_Event_Cond()
{
State root = new State("root");
root.Initial = "s1";
State s1 = new State("s1");
s1.AddParamerter(new Parameter(typeof(bool), "isTrue"));
s1.AddTransition(new Transition("s2", "to.s2", Variable <int>("isTrue")));
root.AddChild(s1);
State s2 = new State("s2");
root.AddChild(s2);
FSMachine fsm = GetFSM();
fsm.SetRoot(root);
fsm.Start();
Assert.AreEqual("s1", fsm.Current.Name);
fsm.SendEvent("to.s2");
fsm.Update();
Assert.AreEqual("s1", fsm.Current.Name);
fsm.GetState("s1").SetParameter("isTrue", true);
fsm.SendEvent("to.s2");
fsm.Update();
Assert.AreEqual("s2", fsm.Current.Name);
}
public void Transition_Multi()
{
State root = new State("root");
root.Initial = "s1";
State s1 = new State("s1");
s1.AddTransition(new Transition("s2"));
root.AddChild(s1);
State s2 = new State("s2");
s2.AddTransition(new Transition("s3"));
root.AddChild(s2);
State s3 = new State("s3");
s3.AddTransition(new Transition("s4"));
root.AddChild(s3);
State s4 = new State("s4");
root.AddChild(s4);
FSMachine fsm = new FSMachine();
fsm.SetRoot(root);
fsm.Start();
Assert.AreEqual("s4", fsm.Current.Name);
}
public void State_AddTransition_TwoValidTranDiffTriggers_ReturnsOneForEachTransitionsOn()
{
var state1 = new State <StubStateModel>("s1");
var state2 = new State <StubStateModel>("s2");
var state3 = new State <StubStateModel>("s2");
var trigger1 = new Trigger("t1");
var trigger2 = new Trigger("t2");
var transition1 = new Transition <StubStateModel>(trigger1, state1, state2, m => 1 == 2);
var transition2 = new Transition <StubStateModel>(trigger2, state1, state3, m => 1 == 1);
state1.AddTransition(transition1);
state1.AddTransition(transition2);
Assert.Same(transition1, state1.TransitionsOn(trigger1).FirstOrDefault());
Assert.Same(transition2, state1.TransitionsOn(trigger2).FirstOrDefault());
}
public ComparizonDfa()
{
var s0 = new State("State 0 Inicio", 0, true);
states = new List <StateBase>
{
s0
};
s0.AddTransition(new Transition('<', s0));
s0.AddTransition(new Transition('=', s0));
s0.AddTransition(new Transition('>', s0));
s0.AddTransition(new Transition('!', s0));
States = states;
}
public static Nfa Match(int symbol)
{
State startState = new State();
State endState = new State();
startState.AddTransition(new MatchRangeTransition(endState, Interval.FromBounds(symbol, symbol)));
return new Nfa(startState, endState);
}
public static Nfa MatchRange(Interval range)
{
State startState = new State();
State endState = new State();
startState.AddTransition(new MatchRangeTransition(endState, range));
return new Nfa(startState, endState);
}
void addTransitions()
{
currentLine = sr.ReadLine();
List <string> transitionStrings = new List <string>();
while (currentLine != ls.Endline)
{
if (currentLine != null)
{
transitionStrings.Add(currentLine);
}
currentLine = sr.ReadLine();
}
foreach (string transition in transitionStrings)
{
string trimmedTransition = clearSpaces(transition);
string[] splitTransition = Regex.Split(trimmedTransition, "-->|,|//s");
//The first string in the splitTransition is the initial state, the second is the transition character and the third is the destination state
State initialState = stateSet.StoredStates.Find(state => state.StateName == splitTransition[0]);
State finalState = stateSet.StoredStates.Find(state => state.StateName == splitTransition[2]);;
Transition transitionToAdd = new Transition(splitTransition[1][0], finalState);
initialState.AddTransition(transitionToAdd);
}
}
StateMachine_Trigger_TransitionFromCurrentToSame_ConfiggedNotToRaiseExcep_DoesNotRaiseTransitionChangeEvents()
{
var config = new StateMachineConfiguration {
RaiseExceptionBeforeTransitionToSameState = false
};
var machine = new StateMachine <StubStateModel>(config);
var model = new StubStateModel();
var trigger1 = new Trigger("trigger1");
var state1 = new State <StubStateModel>("state1");
TransitionEventArgs <StubStateModel> transitioningArgs = null;
state1.Entered += (s, e) => { transitioningArgs = e; };
TransitionEventArgs <StubStateModel> transitionedArgs = null;
state1.Exiting += (s, e) => { transitionedArgs = e; };
state1.AddTransition(trigger1, state1);
model.CurrentState = state1;
// set up scenario where state would transition from current to same state.
// so no true transition would not occur
// should not throw exception and that's good enough for us
machine.Trigger(trigger1, model);
// verify that no transition events occurred
Assert.Null(transitioningArgs);
Assert.Null(transitionedArgs);
}
public void LayeringTest()
{
#region States
var active = new State <SmartPhoneScreenContext>(screen => { }).Named("Active");
var exit = new State <SmartPhoneScreenContext>(screen => { }).Named("Exit");
var paused = new State <SmartPhoneScreenContext>(screen => { }).Named("Paused");
var inactive = new State <SmartPhoneScreenContext>(screen => { }).Named("Inactive");
#endregion
#region Transitions
active.AddTransition(Transition <SmartPhoneScreenContext>
.To(() => paused)
.When(screen => screen.Command == PauseCommand)
.Named("Pausing"));
active.AddTransition(Transition <SmartPhoneScreenContext>
.To(() => inactive)
.When(screen => screen.Command == EndCommand)
.Named("Going inactive"));
inactive.AddTransition(Transition <SmartPhoneScreenContext>
.To(() => active)
.When(screen => screen.Command == BeginCommand)
.Named("Activating"));
inactive.AddTransition(Transition <SmartPhoneScreenContext>
.To(() => exit)
.When(screen => screen.Command == ExitCommand)
.Named("Exiting"));
paused.AddTransition(Transition <SmartPhoneScreenContext>
.To(() => inactive)
.When(screen => screen.Command == EndCommand)
.Named("Going inactive"));
paused.AddTransition(Transition <SmartPhoneScreenContext>
.To(() => active)
.When(screen => screen.Command == ResumeCommand)
.Named("Activating"));
#endregion
var layering = new Layering <SmartPhoneScreenContext>(active);
}
public void StateExtensions_AddTransition_NullTo_ThrowsNullex()
{
var fromState = new State <StubStateModel>("from");
var trigger = new Trigger("trigger");
Assert.Throws <ArgumentNullException>(() =>
fromState.AddTransition(trigger, null));
}
public static Nfa MatchAny(params int[] symbols)
{
State startState = new State();
State endState = new State();
foreach (var symbol in symbols)
startState.AddTransition(new MatchRangeTransition(endState, Interval.FromBounds(symbol, symbol)));
return new Nfa(startState, endState);
}
private void CreateGetHit(StateMachine stateMachine)
{
State state;
Transition transition;
state = new State("GetHit");
stateMachine.AddState(state);
state.AddBehaviour(new PlayAnimationBehaviour("GetHit", 0f));
transition = new Transition("Death");
state.AddTransition(transition);
transition.AddCondition(new IsDeadCondition());
transition = new Transition("Idle");
state.AddTransition(transition);
transition.AddCondition(new AnimationFinishedCondition());
}
public void StateExtensions_AddTransition_NullTrigger_ThrowsNullex()
{
var fromState = new State <StubStateModel>("from");
var toState = new State <StubStateModel>("to");
Assert.Throws <ArgumentNullException>(() =>
fromState.AddTransition(null, toState));
}
public void State_AddTransition_TwoValidTranSameTrigger_ReturnsBothWithTransitionsOn()
{
var state1 = new State <StubStateModel>("s1");
var state2 = new State <StubStateModel>("s2");
var state3 = new State <StubStateModel>("s2");
var trigger1 = new Trigger("t1");
var transition1 = new Transition <StubStateModel>(trigger1, state1, state2, m => 1 == 2);
var transition2 = new Transition <StubStateModel>(trigger1, state1, state3, m => 1 == 1);
state1.AddTransition(transition1);
state1.AddTransition(transition2);
var trans = state1.TransitionsOn(trigger1).ToList();
Assert.Equal(transition1, trans[0]);
Assert.Equal(transition2, trans[1]);
}
// Start is called before the first frame update
void Start()
{
rb = GetComponent <Rigidbody>();
keyController = GetComponent <KeyboardController>();
//Primero creo los estados
#region Definicion
var idlle = new State <Inputs>("IDLE");
var jump = new State <Inputs>("Jumping");
var crouched = new State <Inputs>("Crouched");
#endregion
//Ahora las Transiciones
#region Transiciones
idlle.AddTransition(Inputs.JUMP_PRESS, jump);
idlle.AddTransition(Inputs.CROUCH_PRESS, crouched);
jump.AddTransition(Inputs.FLOOR_TOUCHED, idlle);
crouched.AddTransition(Inputs.CROUCH_RELEASE, idlle);
crouched.AddTransition(Inputs.JUMP_PRESS, jump);
#endregion
//Ahora definimos los comportamientos.
#region Comportamientos
idlle.OnEnter += () => print("IDLE");
jump.OnEnter += () => rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
crouched.OnEnter += () => transform.localScale = new Vector3(1, 0.5f, 1);
crouched.OnExit += () => transform.localScale = new Vector3(1, 1, 1);
#endregion
//Luego la fsm pasandole el primer Estado.
StateMachine = new StateMachine <Inputs>(idlle);
//Relleno las funciones del keyboard controller
keyController.OnJumpPressed += () => StateMachine.Feed(Inputs.JUMP_PRESS);
keyController.OnCrouchedPressed += () => StateMachine.Feed(Inputs.CROUCH_PRESS);
keyController.OnCrouchedRelease += () => StateMachine.Feed(Inputs.CROUCH_RELEASE);
}
public void StateExtensions_AddTransition_NullTo_WithGuard_ThrowsNullex()
{
var fromState = new State <StubStateModel>("from");
var trigger = new Trigger("trigger");
Func <StubStateModel, bool> guard = s => true;
Assert.Throws <ArgumentNullException>(() =>
fromState.AddTransition(trigger, null, guard));
}
public void AddTransition(State s, Transition t)
{
s.AddTransition(t);
this.events.Add(t.Event);
foreach (var action in t.Actions)
{
this.actions.Add(action);
}
}
private void CreateGetHit(StateMachine stateMachine)
{
State state;
Transition transition;
state = new State("GetHit");
stateMachine.AddState(state);
state.AddBehaviour(new PlayAnimationBehaviour("GetHit", 0f));
state.AddBehaviour(new SpawnEffectOnEnterBehaviour(Resources.Load <GameObject>("SFX/GhoulGetHit")));
transition = new Transition("Death");
state.AddTransition(transition);
transition.AddCondition(new IsDeadCondition());
transition = new Transition("Idle");
state.AddTransition(transition);
transition.AddCondition(new AnimationFinishedCondition());
}
public void State_Addtransition_SourceDifferentThanState_ThrowsInvalidTransEx()
{
var state1 = new State<StubStateModel>("s1");
var state2 = new State<StubStateModel>("s2");
var trigger1 = new Trigger("t1");
var transition1 = new Transition<StubStateModel>(trigger1, state2, state1);
Assert.Throws<InvalidTransitionException>(() =>
state1.AddTransition(transition1));
}
/// <summary>
/// Returns a new (deterministic) automaton that accepts all strings.
/// </summary>
public static Automaton MakeAnyString()
{
Automaton a = new Automaton();
State s = new State();
a.Initial = s;
s.accept = true;
s.AddTransition(new Transition(Character.MIN_CODE_POINT, Character.MAX_CODE_POINT, s));
a.deterministic = true;
return a;
}
public override void SetUp()
{
base.SetUp();
// build an automaton matching this jvm's letter definition
State initial = new State();
State accept = new State();
accept.Accept = true;
for (int i = 0; i <= 0x10FFFF; i++)
{
if (Character.IsLetter(i))
{
initial.AddTransition(new Transition(i, i, accept));
}
}
Automaton single = new Automaton(initial);
single.Reduce();
Automaton repeat = BasicOperations.Repeat(single);
jvmLetter = new CharacterRunAutomaton(repeat);
}
private void Start(State start, State end, UTF8Sequence utf8, int upto, bool doAll)
{
if (upto == utf8.Len - 1)
{
// Done recursing
start.AddTransition(new Transition(utf8.ByteAt(upto), utf8.ByteAt(upto) | MASKS[utf8.NumBits(upto) - 1], end)); // type=start
}
else
{
State n = NewUTF8State();
start.AddTransition(new Transition(utf8.ByteAt(upto), n)); // type=start
Start(n, end, utf8, 1 + upto, true);
int endCode = utf8.ByteAt(upto) | MASKS[utf8.NumBits(upto) - 1];
if (doAll && utf8.ByteAt(upto) != endCode)
{
All(start, end, utf8.ByteAt(upto) + 1, endCode, utf8.Len - upto - 1);
}
}
}
private void End(State start, State end, UTF8Sequence utf8, int upto, bool doAll)
{
if (upto == utf8.Len - 1)
{
// Done recursing
start.AddTransition(new Transition(utf8.ByteAt(upto) & (~MASKS[utf8.NumBits(upto) - 1]), utf8.ByteAt(upto), end)); // type=end
}
else
{
int startCode;
if (utf8.NumBits(upto) == 5)
{
// special case -- avoid created unused edges (utf8
// doesn't accept certain byte sequences) -- there
// are other cases we could optimize too:
startCode = 194;
}
else
{
startCode = utf8.ByteAt(upto) & (~MASKS[utf8.NumBits(upto) - 1]);
}
if (doAll && utf8.ByteAt(upto) != startCode)
{
All(start, end, startCode, utf8.ByteAt(upto) - 1, utf8.Len - upto - 1);
}
State n = NewUTF8State();
start.AddTransition(new Transition(utf8.ByteAt(upto), n)); // type=end
End(n, end, utf8, 1 + upto, true);
}
}
private void All(State start, State end, int startCode, int endCode, int left)
{
if (left == 0)
{
start.AddTransition(new Transition(startCode, endCode, end)); // type=all
}
else
{
State lastN = NewUTF8State();
start.AddTransition(new Transition(startCode, endCode, lastN)); // type=all
while (left > 1)
{
State n = NewUTF8State();
lastN.AddTransition(new Transition(128, 191, n)); // type=all*
left--;
lastN = n;
}
lastN.AddTransition(new Transition(128, 191, end)); // type = all*
}
}
/// <summary>
/// Returns a new (deterministic) automaton that accepts a single codepoint whose
/// value is in the given interval (including both end points).
/// </summary>
public static Automaton MakeCharRange(int min, int max)
{
if (min == max)
{
return MakeChar(min);
}
Automaton a = new Automaton();
State s1 = new State();
State s2 = new State();
a.Initial = s1;
s2.accept = true;
if (min <= max)
{
s1.AddTransition(new Transition(min, max, s2));
}
a.deterministic = true;
return a;
}
public void StateMachine_Trigger_ValidlyTransitions_RaisesAllEventsInCorrectOrder()
{
var calls = new List<string>();
var model = new TrackableStateModel();
var state1 = new State<TrackableStateModel>("s1");
var state2 = new State<TrackableStateModel>("s2");
var trigger = new Trigger("t1");
var transition = new Transition<TrackableStateModel>(trigger, state1, state2);
state1.AddTransition(transition);
model.CurrentState = state1;
var stateMachine = new StateMachine<TrackableStateModel>();
Action<object, TransitionEventArgs<TrackableStateModel>> entering = (s, e) => calls.Add(String.Format("entering {0} from {1} on {2}", e.To, e.From, e.Trigger));
Action<object, TransitionEventArgs<TrackableStateModel>> entered = (s, e) => calls.Add(String.Format("entered {0} from {1} on {2}", e.To, e.From, e.Trigger));
Action<object, TransitionEventArgs<TrackableStateModel>> exiting = (s, e) => calls.Add(String.Format("exiting {0} to {1} on {2}", e.From, e.To, e.Trigger));
Action<object, TransitionEventArgs<TrackableStateModel>> exited = (s, e) => calls.Add(String.Format("exited {0} to {1} on {2}", e.From, e.To, e.Trigger));
model.Setting += (s, e) => calls.Add("setting new current state on model");
state1.Entering += (s, e) => entering(s, e);
state1.Entered += (s, e) => entered(s, e);
state1.Exiting += (s, e) => exiting(s, e);
state1.Exited += (s, e) => exited(s, e);
state2.Entering += (s, e) => entering(s, e);
state2.Entered += (s, e) => entered(s, e);
state2.Exiting += (s, e) => exiting(s, e);
state2.Exited += (s, e) => exited(s, e);
stateMachine.Transitioning += (s, e) => calls.Add(String.Format("transitioning from {0} to {1} on {2}", e.From, e.To, e.Trigger));
stateMachine.Transitioned += (s, e) => calls.Add(String.Format("transitioned from {0} to {1} on {2}", e.From, e.To, e.Trigger));
stateMachine.Trigger(trigger, model);
Assert.Equal(7, calls.Count);
Assert.Equal("transitioning from s1 to s2 on t1", calls[0]);
Assert.Equal("exiting s1 to s2 on t1", calls[1]);
Assert.Equal("entering s2 from s1 on t1", calls[2]);
Assert.Equal("setting new current state on model", calls[3]);
Assert.Equal("exited s1 to s2 on t1", calls[4]);
Assert.Equal("entered s2 from s1 on t1", calls[5]);
Assert.Equal("transitioned from s1 to s2 on t1", calls[6]);
}
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of value at most x.Substring(n)
/// and length x.Substring(n).Length.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="n">The n.</param>
/// <returns></returns>
private static State AtMost(string x, int n)
{
var s = new State();
if (x.Length == n)
{
s.Accept = true;
}
else
{
char c = x[n];
s.AddTransition(new Transition(c, AtMost(x, (char)n + 1)));
if (c > '0')
{
s.AddTransition(new Transition('0', (char)(c - 1), AnyOfRightLength(x, n + 1)));
}
}
return s;
}
/// <summary>
/// Minimizes the given automaton using Hopcroft's algorithm.
/// </summary>
public static void MinimizeHopcroft(Automaton a)
{
a.Determinize();
if (a.Initial.numTransitions == 1)
{
Transition t = a.Initial.TransitionsArray[0];
if (t.To == a.Initial && t.Min_Renamed == Character.MIN_CODE_POINT && t.Max_Renamed == Character.MAX_CODE_POINT)
{
return;
}
}
a.Totalize();
// initialize data structures
int[] sigma = a.StartPoints;
State[] states = a.NumberedStates;
int sigmaLen = sigma.Length, statesLen = states.Length;
List<State>[,] reverse = new List<State>[statesLen, sigmaLen];
HashSet<State>[] partition = new HashSet<State>[statesLen];
List<State>[] splitblock = new List<State>[statesLen];
int[] block = new int[statesLen];
StateList[,] active = new StateList[statesLen, sigmaLen];
StateListNode[,] active2 = new StateListNode[statesLen, sigmaLen];
LinkedList<IntPair> pending = new LinkedList<IntPair>();
BitArray pending2 = new BitArray(sigmaLen * statesLen);
BitArray split = new BitArray(statesLen), refine = new BitArray(statesLen), refine2 = new BitArray(statesLen);
for (int q = 0; q < statesLen; q++)
{
splitblock[q] = new List<State>();
partition[q] = new HashSet<State>();
for (int x = 0; x < sigmaLen; x++)
{
active[q, x] = new StateList();
}
}
// find initial partition and reverse edges
for (int q = 0; q < statesLen; q++)
{
State qq = states[q];
int j = qq.accept ? 0 : 1;
partition[j].Add(qq);
block[q] = j;
for (int x = 0; x < sigmaLen; x++)
{
//List<State>[] r = reverse[qq.Step(sigma[x]).number];
var r = qq.Step(sigma[x]).number;
if (reverse[r, x] == null)
{
reverse[r, x] = new List<State>();
}
reverse[r, x].Add(qq);
}
}
// initialize active sets
for (int j = 0; j <= 1; j++)
{
for (int x = 0; x < sigmaLen; x++)
{
foreach (State qq in partition[j])
{
if (reverse[qq.number, x] != null)
{
active2[qq.number, x] = active[j, x].Add(qq);
}
}
}
}
// initialize pending
for (int x = 0; x < sigmaLen; x++)
{
int j = (active[0, x].Size <= active[1, x].Size) ? 0 : 1;
pending.AddLast(new IntPair(j, x));
pending2.Set(x * statesLen + j, true);
}
// process pending until fixed point
int k = 2;
while (pending.Count > 0)
{
IntPair ip = pending.First.Value;
pending.RemoveFirst();
int p = ip.N1;
int x = ip.N2;
pending2.Set(x * statesLen + p, false);
// find states that need to be split off their blocks
for (StateListNode m = active[p, x].First; m != null; m = m.Next)
{
List<State> r = reverse[m.q.number, x];
if (r != null)
{
foreach (State s in r)
{
int i = s.number;
if (!split.Get(i))
{
split.Set(i, true);
int j = block[i];
splitblock[j].Add(s);
if (!refine2.Get(j))
{
refine2.Set(j, true);
refine.Set(j, true);
}
}
}
}
}
// refine blocks
for (int j = Number.NextSetBit(refine, 0); j >= 0; j = Number.NextSetBit(refine, j + 1))
{
List<State> sb = splitblock[j];
if (sb.Count < partition[j].Count)
{
HashSet<State> b1 = partition[j];
HashSet<State> b2 = partition[k];
foreach (State s in sb)
{
b1.Remove(s);
b2.Add(s);
block[s.number] = k;
for (int c = 0; c < sigmaLen; c++)
{
StateListNode sn = active2[s.number, c];
if (sn != null && sn.Sl == active[j, c])
{
sn.Remove();
active2[s.number, c] = active[k, c].Add(s);
}
}
}
// update pending
for (int c = 0; c < sigmaLen; c++)
{
int aj = active[j, c].Size, ak = active[k, c].Size, ofs = c * statesLen;
if (!pending2.Get(ofs + j) && 0 < aj && aj <= ak)
{
pending2.Set(ofs + j, true);
pending.AddLast(new IntPair(j, c));
}
else
{
pending2.Set(ofs + k, true);
pending.AddLast(new IntPair(k, c));
}
}
k++;
}
refine2.Set(j, false);
foreach (State s in sb)
{
split.Set(s.number, false);
}
sb.Clear();
}
refine.SetAll(false);
}
// make a new state for each equivalence class, set initial state
State[] newstates = new State[k];
for (int n = 0; n < newstates.Length; n++)
{
State s = new State();
newstates[n] = s;
foreach (State q in partition[n])
{
if (q == a.Initial)
{
a.Initial = s;
}
s.accept = q.accept;
s.number = q.number; // select representative
q.number = n;
}
}
// build transitions and set acceptance
for (int n = 0; n < newstates.Length; n++)
{
State s = newstates[n];
s.accept = states[s.number].accept;
foreach (Transition t in states[s.number].Transitions)
{
s.AddTransition(new Transition(t.Min_Renamed, t.Max_Renamed, newstates[t.To.number]));
}
}
a.ClearNumberedStates();
a.RemoveDeadTransitions();
}
private void SetupStateEngine()
{
var idle = new State<Action<double>>(
"Idle",
null,
null,
null);
var starting = new State<Action<double>>(
"Starting",
null,
this.FadeIn,
null);
var started = new State<Action<double>>(
"Started",
null,
null,
null);
var ending = new State<Action<double>>(
"Ending",
null,
delegate
{
this.elapsedTimeSinceEndingTransition = this.elapsedTime;
this.FadeOut();
},
null);
var ended = new State<Action<double>>(
"Ended",
null,
delegate
{
this.elapsedTime = 0;
this.elapsedTimeSinceEndingTransition = 0;
// Todo: Restarting only for development purposes, otherwise next level or game finished.
this.EndGame();
this.StartGame();
},
null);
var paused = new State<Action<double>>(
"Paused",
null,
this.PauseGame,
this.ResumeGame);
var gameOver = new State<Action<double>>(
"GameOver",
null,
this.EndGame,
null);
idle.AddTransition(
starting,
() => this.IsGameRunning);
starting.AddTransition(
started,
() => this.elapsedTime > FadeEffectDuration);
started.AddTransition(
ending,
() => this.enemyService.IsBossEliminated || this.playerService.Player.Lives <= 0);
started.AddTransition(
paused,
() => this.isGamePaused == true);
paused.AddTransition(
started,
() => this.isGamePaused == false);
ending.AddTransition(
ended,
() => this.elapsedTime - this.elapsedTimeSinceEndingTransition > FadeEffectDuration && this.enemyService.IsBossEliminated);
ending.AddTransition(
gameOver,
() => this.elapsedTime - this.elapsedTimeSinceEndingTransition > FadeEffectDuration && this.playerService.Player.Lives == 0);
ended.AddTransition(starting, () => true);
gameOver.AddTransition(idle, () => true);
this.gameStateMachine = new StateMachine<Action<double>>(idle);
}
public static Nfa Rule(RuleBinding ruleBinding)
{
State startState = new State();
State endState = new State();
PushContextTransition push = new PushContextTransition(ruleBinding.StartState, startState.Id);
PopContextTransition pop = new PopContextTransition(endState, startState.Id);
startState.AddTransition(push);
ruleBinding.EndState.AddTransition(pop);
return new Nfa(startState, endState);
}
public static Nfa MatchComplement(params Interval[] excludedIntervals)
{
State startState = new State();
State endState = new State();
IntervalSet set = new IntervalSet(excludedIntervals).Complement(IntervalSet.CompleteInterval);
foreach (var interval in set.Intervals)
startState.AddTransition(new MatchRangeTransition(endState, interval));
return new Nfa(startState, endState);
}
/// <summary>
/// Adds transitions to explicit crash state to ensure that transition function
/// is total.
/// </summary>
internal virtual void Totalize()
{
State s = new State();
s.AddTransition(new Transition(Character.MIN_CODE_POINT, Character.MAX_CODE_POINT, s));
foreach (State p in NumberedStates)
{
int maxi = Character.MIN_CODE_POINT;
p.SortTransitions(Transition.CompareByMinMaxThenDest);
foreach (Transition t in p.Transitions)
{
if (t.Min_Renamed > maxi)
{
p.AddTransition(new Transition(maxi, (t.Min_Renamed - 1), s));
}
if (t.Max_Renamed + 1 > maxi)
{
maxi = t.Max_Renamed + 1;
}
}
if (maxi <= Character.MAX_CODE_POINT)
{
p.AddTransition(new Transition(maxi, Character.MAX_CODE_POINT, s));
}
}
ClearNumberedStates();
}
private void Build(State start, State end, UTF8Sequence startUTF8, UTF8Sequence endUTF8, int upto)
{
// Break into start, middle, end:
if (startUTF8.ByteAt(upto) == endUTF8.ByteAt(upto))
{
// Degen case: lead with the same byte:
if (upto == startUTF8.Len - 1 && upto == endUTF8.Len - 1)
{
// Super degen: just single edge, one UTF8 byte:
start.AddTransition(new Transition(startUTF8.ByteAt(upto), endUTF8.ByteAt(upto), end));
return;
}
else
{
Debug.Assert(startUTF8.Len > upto + 1);
Debug.Assert(endUTF8.Len > upto + 1);
State n = NewUTF8State();
// Single value leading edge
start.AddTransition(new Transition(startUTF8.ByteAt(upto), n)); // type=single
// Recurse for the rest
Build(n, end, startUTF8, endUTF8, 1 + upto);
}
}
else if (startUTF8.Len == endUTF8.Len)
{
if (upto == startUTF8.Len - 1)
{
start.AddTransition(new Transition(startUTF8.ByteAt(upto), endUTF8.ByteAt(upto), end)); // type=startend
}
else
{
Start(start, end, startUTF8, upto, false);
if (endUTF8.ByteAt(upto) - startUTF8.ByteAt(upto) > 1)
{
// There is a middle
All(start, end, startUTF8.ByteAt(upto) + 1, endUTF8.ByteAt(upto) - 1, startUTF8.Len - upto - 1);
}
End(start, end, endUTF8, upto, false);
}
}
else
{
// start
Start(start, end, startUTF8, upto, true);
// possibly middle, spanning multiple num bytes
int byteCount = 1 + startUTF8.Len - upto;
int limit = endUTF8.Len - upto;
while (byteCount < limit)
{
// wasteful: we only need first byte, and, we should
// statically encode this first byte:
TmpUTF8a.Set(StartCodes[byteCount - 1]);
TmpUTF8b.Set(EndCodes[byteCount - 1]);
All(start, end, TmpUTF8a.ByteAt(0), TmpUTF8b.ByteAt(0), TmpUTF8a.Len - 1);
byteCount++;
}
// end
End(start, end, endUTF8, upto, true);
}
}
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of value between x.Substring(n)
/// and y.Substring(n) and of length x.Substring(n).Length (which must be equal to
/// y.Substring(n).Length).
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <param name="n">The n.</param>
/// <param name="initials">The initials.</param>
/// <param name="zeros">if set to <c>true</c> [zeros].</param>
/// <returns></returns>
private static State Between(string x, string y, int n, ICollection<State> initials, bool zeros)
{
var s = new State();
if (x.Length == n)
{
s.Accept = true;
}
else
{
if (zeros)
{
initials.Add(s);
}
char cx = x[n];
char cy = y[n];
if (cx == cy)
{
s.AddTransition(new Transition(cx, Between(x, y, n + 1, initials, zeros && cx == '0')));
}
else
{
// cx < cy
s.AddTransition(new Transition(cx, BasicAutomata.AtLeast(x, n + 1, initials, zeros && cx == '0')));
s.AddTransition(new Transition(cy, BasicAutomata.AtMost(y, n + 1)));
if (cx + 1 < cy)
{
s.AddTransition(new Transition((char)(cx + 1), (char)(cy - 1), BasicAutomata.AnyOfRightLength(x, n + 1)));
}
}
}
return s;
}
private void InitializeStateMachine()
{
var dying = new State<Action<double>>(
PlayerState.Dying,
null,
delegate
{
this.Lives--;
if (this.ShipExploding != null)
{
this.ShipExploding(this, new StateChangedEventArgs(PlayerState.Alive, PlayerState.Dying));
}
},
null);
var dead = new State<Action<double>>(
PlayerState.Dead,
elapsedTime => this.deadToRespawnTimer += elapsedTime,
null,
() => this.deadToRespawnTimer = 0);
var respawn = new State<Action<double>>(
PlayerState.Respawn,
elapsedTime =>
{
this.healthReplenishCounter++;
if(this.healthReplenishCounter % 2 == 0)
{
this.Health++;
}
},
delegate
{
if (this.ShipRespawning != null)
{
this.ShipRespawning(this, new StateChangedEventArgs(PlayerState.Dead, PlayerState.Respawn));
}
},
() => { this.healthReplenishCounter = 0; });
var alive = new State<Action<double>>(
PlayerState.Alive,
null,
delegate
{
if (this.ShipReady != null)
{
this.ShipReady(this, new StateChangedEventArgs(PlayerState.Respawn, PlayerState.Alive));
}
},
null);
alive.AddTransition(dying, () => this.Health <= 0);
dying.AddTransition(dead, () => this.spriteManager.IsAnimationDone(this.stateMachine.CurrentState.Name));
dead.AddTransition(respawn, () => this.deadToRespawnTimer > 1000); // eventually add -> && lives >= 0
respawn.AddTransition(alive, () => this.Health == 100);
this.stateMachine = new StateMachine<Action<double>>(respawn);
}
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of length x.Substring(n).Length.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="n">The n.</param>
/// <returns></returns>
private static State AnyOfRightLength(string x, int n)
{
var s = new State();
if (x.Length == n)
{
s.Accept = true;
}
else
{
s.AddTransition(new Transition('0', '9', AnyOfRightLength(x, n + 1)));
}
return s;
}
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of value at least x.Substring(n)
/// and length x.Substring(n).Length.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="n">The n.</param>
/// <param name="initials">The initials.</param>
/// <param name="zeros">if set to <c>true</c> [zeros].</param>
/// <returns></returns>
private static State AtLeast(string x, int n, ICollection<State> initials, bool zeros)
{
var s = new State();
if (x.Length == n)
{
s.Accept = true;
}
else
{
if (zeros)
{
initials.Add(s);
}
char c = x[n];
s.AddTransition(new Transition(c, AtLeast(x, n + 1, initials, zeros && c == '0')));
if (c < '9')
{
s.AddTransition(new Transition((char)(c + 1), '9', AnyOfRightLength(x, n + 1)));
}
}
return s;
}
public static Automaton MakeString(int[] word, int offset, int length)
{
Automaton a = new Automaton();
a.Deterministic = true;
State s = new State();
a.Initial = s;
for (int i = offset; i < offset + length; i++)
{
State s2 = new State();
s.AddTransition(new Transition(word[i], s2));
s = s2;
}
s.accept = true;
return a;
}
public StateMachine(GenericRCOLResource jazzResource)
: this("")
{
if (jazzResource == null)
{
throw new ArgumentNullException("jazzResource");
}
GenericRCOLResource.ChunkEntryList chunkEntries
= jazzResource.ChunkEntries;
if (chunkEntries == null || chunkEntries.Count == 0)
{
throw new ArgumentException(
"RCOL Resource is empty", "jazzResource");
}
KeyNameReg.RefreshKeyNameMaps();
uint hash;
string name;
int i, j, index = -1;
State state;
ActorDefinition ad;
ParamDefinition pd;
DecisionGraphNode dgn;
JazzStateMachine jazzSM = null;
GenericRCOLResource.ChunkEntry ce;
AChunkObject[] chunks = new AChunkObject[chunkEntries.Count];
List<ActorDefinition> actorDefs = new List<ActorDefinition>();
List<ParamDefinition> paramDefs = new List<ParamDefinition>();
#region Phase 1: Instantiate Chunks and Copy over value fields
for (i = 0; i < chunkEntries.Count; i++)
{
ce = chunkEntries[i];
hash = ce.TGIBlock.ResourceType;
switch (hash)
{
case PlayAnimationNode.ResourceType:
JazzPlayAnimationNode jpan
= ce.RCOLBlock as JazzPlayAnimationNode;
PlayAnimationNode lan = new PlayAnimationNode();
lan.ClipKey = new RK(jpan.ClipResource);
lan.TrackMaskKey = new RK(jpan.TkmkResource);
// lan.SlotSetup copied over later
lan.AdditiveClipKey
= new RK(jpan.AdditiveClipResource);
lan.ClipPattern = jpan.Animation;
lan.AdditiveClipPattern = jpan.AdditiveAnimation;
lan.Flags = jpan.AnimationNodeFlags;
lan.Priority = jpan.AnimationPriority1;
lan.BlendInTime = jpan.BlendInTime;
lan.BlendOutTime = jpan.BlendOutTime;
lan.Speed = jpan.Speed;
// lan.Actor set later
lan.TimingPriority = jpan.TimingPriority;
chunks[i] = lan;
break;
case StopAnimationNode.ResourceType:
JazzStopAnimationNode jsan
= ce.RCOLBlock as JazzStopAnimationNode;
StopAnimationNode san = new StopAnimationNode();
san.Flags = jsan.AnimationFlags;
san.Priority = jsan.AnimationPriority1;
san.BlendInTime = jsan.BlendInTime;
san.BlendOutTime = jsan.BlendOutTime;
san.Speed = jsan.Speed;
// san.Actor set later
san.TimingPriority = jsan.TimingPriority;
chunks[i] = san;
break;
case ActorOperationNode.ResourceType:
JazzActorOperationNode jaon
= ce.RCOLBlock as JazzActorOperationNode;
ActorOperationNode aon
= new ActorOperationNode(jaon.ActorOp);
// aon.Target set later
aon.Operand = jaon.Operand != 0;
chunks[i] = aon;
break;
case CreatePropNode.ResourceType:
JazzCreatePropNode jcpn
= ce.RCOLBlock as JazzCreatePropNode;
CreatePropNode cpn = new CreatePropNode();
// cpn.PropActor set later
// cpn.PropParameter set later
cpn.PropKey = new RK(jcpn.PropResource);
chunks[i] = cpn;
break;
case RandomNode.ResourceType:
JazzRandomNode jrand
= ce.RCOLBlock as JazzRandomNode;
RandomNode rand = new RandomNode();
// rand.Slices set later
rand.Flags = jrand.Properties;
chunks[i] = rand;
break;
case SelectOnParameterNode.ResourceType:
// sopn.Parameter set later
// sopn.Cases set later
chunks[i] = new SelectOnParameterNode();
break;
case SelectOnDestinationNode.ResourceType:
// sodn.Cases set later
chunks[i] = new SelectOnDestinationNode();
break;
case NextStateNode.ResourceType:
// nsn.NextState set later
chunks[i] = new NextStateNode();
break;
case DecisionGraph.ResourceType:
// dg.State set later
// dg.DecisionMakers set later
// dg.EntryPoints set later
chunks[i] = new DecisionGraph();
break;
case State.ResourceType:
JazzState js = ce.RCOLBlock as JazzState;
hash = js.NameHash;
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
state = new State(name);
state.Flags = js.Properties;
// state.DecisionGraph set later
// state.Transitions set later
state.AwarenessOverlayLevel
= js.AwarenessOverlayLevel;
chunks[i] = state;
break;
case ParamDefinition.ResourceType:
JazzParameterDefinition jpd
= ce.RCOLBlock as JazzParameterDefinition;
hash = jpd.NameHash;
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
pd = new ParamDefinition(name);
hash = jpd.DefaultValue;
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
pd.DefaultValue = name;
chunks[i] = pd;
paramDefs.Add(pd);
break;
case ActorDefinition.ResourceType:
JazzActorDefinition jad
= ce.RCOLBlock as JazzActorDefinition;
hash = jad.NameHash;
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
ad = new ActorDefinition(name);
chunks[i] = ad;
actorDefs.Add(ad);
break;
case StateMachine.ResourceType:
if (index != -1)
{
throw new Exception(
"More than one State Machine in RCOL");
}
index = i;
jazzSM = ce.RCOLBlock as JazzStateMachine;
hash = jazzSM.NameHash;
if (hash == 0)
{
name = null;
this.bNameIsHash = true;
}
else if (!KeyNameReg.TryFindName(hash, out name))
{
name = KeyNameReg.UnhashName(hash);
this.bNameIsHash = true;
}
else
{
this.bNameIsHash = false;
}
this.mName = name;
this.mNameHash = hash;
// this.mActorDefinitions set later
// this.mParameterDefinitions set later
// this.mStates set later
this.mFlags = jazzSM.Properties;
this.mDefaultPriority = jazzSM.AutomationPriority;
this.mAwarenessOverlayLevel
= jazzSM.AwarenessOverlayLevel;
chunks[i] = this;
break;
}
}
if (index == -1)
{
throw new Exception("RCOL does not contain a Jazz Graph");
}
#endregion
#region Phase 2: Copy over fields referencing other chunks
for (i = 0; i < chunkEntries.Count; i++)
{
ce = chunkEntries[i];
switch (ce.TGIBlock.ResourceType)
{
case PlayAnimationNode.ResourceType:
JazzPlayAnimationNode jpan
= ce.RCOLBlock as JazzPlayAnimationNode;
PlayAnimationNode lan
= chunks[i] as PlayAnimationNode;
index = jpan.ActorDefinitionIndex.TGIBlockIndex;
lan.Actor = index < 0
? null : chunks[index + 1] as ActorDefinition;
break;
case StopAnimationNode.ResourceType:
JazzStopAnimationNode jsan
= ce.RCOLBlock as JazzStopAnimationNode;
StopAnimationNode san
= chunks[i] as StopAnimationNode;
index = jsan.ActorDefinitionIndex.TGIBlockIndex;
san.Actor = index < 0
? null : chunks[index + 1] as ActorDefinition;
break;
case ActorOperationNode.ResourceType:
JazzActorOperationNode jaon
= ce.RCOLBlock as JazzActorOperationNode;
ActorOperationNode aon
= chunks[i] as ActorOperationNode;
index = jaon.ActorDefinitionIndex.TGIBlockIndex;
aon.Actor = index < 0
? null : chunks[index + 1] as ActorDefinition;
break;
case CreatePropNode.ResourceType:
JazzCreatePropNode jcpn
= ce.RCOLBlock as JazzCreatePropNode;
CreatePropNode cpn = chunks[i] as CreatePropNode;
index = jcpn.ActorDefinitionIndex.TGIBlockIndex;
cpn.PropActor = index < 0
? null : chunks[index + 1] as ActorDefinition;
index = jcpn.ParameterDefinitionIndex.TGIBlockIndex;
cpn.PropParam = index < 0
? null : chunks[index + 1] as ParamDefinition;
break;
case RandomNode.ResourceType:
JazzRandomNode jrand = ce.RCOLBlock as JazzRandomNode;
RandomNode rand = chunks[i] as RandomNode;
RandomNode.Slice slice;
List<RandomNode.Slice> slices = rand.Slices;
foreach (JazzRandomNode.Outcome oc in jrand.Outcomes)
{
slice = new RandomNode.Slice(oc.Weight);
foreach (GenericRCOLResource.ChunkReference cr
in oc.DecisionGraphIndexes)
{
index = cr.TGIBlockIndex;
dgn = index < 0 ? null
: chunks[index + 1] as DecisionGraphNode;
slice.Targets.Add(dgn);
}
slices.Add(slice);
}
break;
case SelectOnParameterNode.ResourceType:
JazzSelectOnParameterNode jsopn
= ce.RCOLBlock as JazzSelectOnParameterNode;
SelectOnParameterNode sopn
= chunks[i] as SelectOnParameterNode;
index = jsopn.ParameterDefinitionIndex.TGIBlockIndex;
sopn.Parameter = index < 0 ? null
: chunks[index + 1] as ParamDefinition;
foreach (JazzSelectOnParameterNode.Match mp
in jsopn.Matches)
{
hash = mp.TestValue;
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
foreach (GenericRCOLResource.ChunkReference cr
in mp.DecisionGraphIndexes)
{
index = cr.TGIBlockIndex;
dgn = index < 0 ? null
: chunks[index + 1] as DecisionGraphNode;
sopn.AddCaseTarget(name, dgn);
}
}
break;
case SelectOnDestinationNode.ResourceType:
JazzSelectOnDestinationNode jsodn
= ce.RCOLBlock as JazzSelectOnDestinationNode;
SelectOnDestinationNode sodn
= chunks[i] as SelectOnDestinationNode;
foreach (JazzSelectOnDestinationNode.Match md
in jsodn.Matches)
{
index = md.StateIndex.TGIBlockIndex;
state = index < 0 ? null
: chunks[index + 1] as State;
foreach (GenericRCOLResource.ChunkReference cr
in md.DecisionGraphIndexes)
{
index = cr.TGIBlockIndex;
dgn = index < 0 ? null
: chunks[index + 1] as DecisionGraphNode;
sodn.AddCaseTarget(state, dgn);
}
}
break;
case NextStateNode.ResourceType:
JazzNextStateNode jnsn
= ce.RCOLBlock as JazzNextStateNode;
NextStateNode nsn = chunks[i] as NextStateNode;
index = jnsn.StateIndex.TGIBlockIndex;
nsn.NextState = index < 0 ? null
: chunks[index + 1] as State;
break;
case DecisionGraph.ResourceType:
JazzDecisionGraph jdg
= ce.RCOLBlock as JazzDecisionGraph;
DecisionGraph dg = chunks[i] as DecisionGraph;
foreach (GenericRCOLResource.ChunkReference dm
in jdg.OutboundDecisionGraphIndexes)
{
index = dm.TGIBlockIndex;
dgn = index < 0 ? null
: chunks[index + 1] as DecisionGraphNode;
dg.AddDecisionMaker(dgn);
}
foreach (GenericRCOLResource.ChunkReference ep
in jdg.InboundDecisionGraphIndexes)
{
index = ep.TGIBlockIndex;
dgn = index < 0 ? null
: chunks[index + 1] as DecisionGraphNode;
dg.AddEntryPoint(dgn);
}
break;
case State.ResourceType:
State transition;
JazzState js = ce.RCOLBlock as JazzState;
state = chunks[i] as State;
index = js.DecisionGraphIndex.TGIBlockIndex;
state.DecisionGraph = index < 0 ? null
: chunks[index + 1] as DecisionGraph;
foreach (GenericRCOLResource.ChunkReference trans
in js.OutboundStateIndexes)
{
index = trans.TGIBlockIndex;
transition = index < 0 ? null
: chunks[index + 1] as State;
state.AddTransition(transition);
}
break;
case ParamDefinition.ResourceType:
case ActorDefinition.ResourceType:
break;
case StateMachine.ResourceType:
jazzSM = ce.RCOLBlock as JazzStateMachine;
foreach (GenericRCOLResource.ChunkReference jad
in jazzSM.ActorDefinitionIndexes)
{
index = jad.TGIBlockIndex;
ad = index < 0 ? null
: chunks[index + 1] as ActorDefinition;
this.AddActorDefinition(ad);
}
foreach (GenericRCOLResource.ChunkReference jpd
in jazzSM.PropertyDefinitionIndexes)
{
index = jpd.TGIBlockIndex;
pd = index < 0 ? null
: chunks[index + 1] as ParamDefinition;
this.AddParamDefinition(pd);
}
foreach (GenericRCOLResource.ChunkReference jst
in jazzSM.StateIndexes)
{
index = jst.TGIBlockIndex;
state = index < 0 ? null
: chunks[index + 1] as State;
this.AddState(state);
}
break;
}
}
#endregion
#region Phase 3: Copy over animation slots and Find "Extras"
for (i = 0; i < chunkEntries.Count; i++)
{
ce = chunkEntries[i];
switch (ce.TGIBlock.ResourceType)
{
case PlayAnimationNode.ResourceType:
JazzPlayAnimationNode jpan
= ce.RCOLBlock as JazzPlayAnimationNode;
PlayAnimationNode lan
= chunks[i] as PlayAnimationNode;
SlotSetupBuilder ssb = lan.SlotSetup;
foreach (JazzPlayAnimationNode.ActorSlot slot
in jpan.ActorSlots)
{
ssb.AddSlotAssignment(slot.ChainId, slot.SlotId,
slot.ActorNameHash, slot.SlotNameHash);
}
foreach (JazzPlayAnimationNode.ActorSuffix suffix
in jpan.ActorSuffixes)
{
hash = suffix.ActorNameHash;
ad = null;
if (hash != 0)
{
index = -1;
for (i = actorDefs.Count - 1;
i >= 0 && index == -1; i--)
{
ad = actorDefs[i];
if (ad.NameHash == hash)
{
index = i;
}
}
if (index < 0)
{
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
ad = new ActorDefinition(name);
actorDefs.Add(ad);
this.mExtraActors.Add(ad);
}
}
hash = suffix.SuffixHash;
pd = null;
if (hash != 0)
{
index = -1;
for (i = paramDefs.Count - 1;
i >= 0 && index == -1; i--)
{
pd = paramDefs[i];
if (pd.NameHash == hash)
{
index = i;
}
}
if (index < 0)
{
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
pd = new ParamDefinition(name);
paramDefs.Add(pd);
this.mExtraParams.Add(pd);
}
}
ssb.AddNamespaceSlotSuffix(ad, pd);
}
break;
case State.ResourceType:
state = chunks[i] as State;
index = this.mStates.IndexOf(state);
if (index < 0)
{
this.mExtraStates.Add(state);
}
break;
case ParamDefinition.ResourceType:
pd = chunks[i] as ParamDefinition;
index = this.mParamDefinitions.IndexOf(pd);
if (index < 0)
{
this.mExtraParams.Add(pd);
}
break;
case ActorDefinition.ResourceType:
ad = chunks[i] as ActorDefinition;
index = this.mActorDefinitions.IndexOf(ad);
if (index < 0)
{
this.mExtraActors.Add(ad);
}
break;
}
}
#endregion
#region Phase 4: Copy over Animation CLIP Namespace Map
RK rk;
List<RK> rks = this.SlurpReferencedRKs();
List<uint> foldedClipInstances = new List<uint>(rks.Count);
for (i = rks.Count - 1; i >= 0; i--)
{
rk = rks[i];
if (rk.TID == 0x6b20c4f3)
{
hash = (uint)((rk.IID >> 0x20) ^ (rk.IID & 0xffffffff));
foldedClipInstances.Add(hash);
}
else
{
rks.RemoveAt(i);
}
}
index = 0;
Anim animation;
Anim[] animations = new Anim[jazzSM.Animations.Count];
foreach (JazzStateMachine.Animation anim in jazzSM.Animations)
{
hash = anim.NameHash;
if (!foldedClipInstances.Contains(hash))
{
animation = new Anim();
animation.SrcFileHash = hash;
if (KeyNameReg.TryFindName(hash, out name))
{
animation.SrcFileName = name;
animation.SrcFileIsValid = true;
}
else
{
animation.SrcFileName
= KeyNameReg.UnhashName(hash);
animation.SrcFileIsValid = false;
}
hash = anim.Actor1Hash;
if (KeyNameReg.TryFindName(hash, out name))
{
animation.Namespace = name;
}
else
{
animation.Namespace
= string.Concat("0x", hash.ToString("X8"));
}
hash = anim.Actor2Hash;
ad = null;
if (hash != 0)
{
j = -1;
for (i = actorDefs.Count - 1; i >= 0 && j < 0; i--)
{
ad = actorDefs[i];
if (ad.NameHash == hash)
{
j = i;
}
}
if (j < 0)
{
if (!KeyNameReg.TryFindName(hash, out name))
name = KeyNameReg.UnhashName(hash);
ad = new ActorDefinition(name);
actorDefs.Add(ad);
this.mExtraActors.Add(ad);
}
}
animation.Actor = ad;
animations[index++] = animation;
}
}
ulong clipHash;
Dictionary<ulong, string> keyNameMap
= new Dictionary<ulong, string>();
for (i = index - 1; i >= 0; i--)
{
animation = animations[i];
this.mNamespaceMap.SetNamespaceMap(
animation.SrcFileName,
animation.Namespace,
animation.Actor);
if (animation.SrcFileIsValid)
{
clipHash = FNVHash.HashString64(animation.SrcFileName);
keyNameMap[clipHash] = animation.SrcFileName;
}
}
// Update the Key to Filename Map of the Namespace Map
SortedDictionary<RK, string> k2fn
= this.mNamespaceMap.KeyToFilenameMap;
k2fn.Clear();
for (i = rks.Count - 1; i >= 0; i--)
{
rk = rks[i];
if (keyNameMap.TryGetValue(rk.IID, out name) ||
KeyNameReg.TryFindName(rk.IID, out name))
{
k2fn[rk] = name;
}
}
#endregion
}
/// <summary>
/// Expands singleton representation to normal representation. Does nothing if
/// not in singleton representation.
/// </summary>
public virtual void ExpandSingleton()
{
if (IsSingleton)
{
State p = new State();
Initial = p;
for (int i = 0, cp = 0; i < singleton.Length; i += Character.CharCount(cp))
{
State q = new State();
p.AddTransition(new Transition(cp = Character.CodePointAt(singleton, i), q));
p = q;
}
p.accept = true;
deterministic = true;
singleton = null;
}
}
public static Nfa Choice(params Nfa[] alternatives)
{
State startState = new State();
State endState = new State();
foreach (var alternative in alternatives)
{
startState.AddTransition(new EpsilonTransition(alternative.StartState));
alternative.EndState.AddTransition(new EpsilonTransition(endState));
}
return new Nfa(startState, endState);
}
