protected override void Awake()
{
base.Awake();
_renderer = GetComponent <MeshRenderer>();
_tasks = new MTaskStack();
_red = new SimpleState(FSM, "red");
_green = new SimpleState(FSM, "green");
_blue = new SimpleState(FSM, "blue");
FSM.SetInitialState(_red);
_red.OnEnter += state =>
{
_renderer.sharedMaterial.color = Color.red;
current = "red";
};
_red.OnUpdate += state => { transform.Rotate(0, 45 * Time.deltaTime, 0); };
_green.OnEnter += state =>
{
_renderer.sharedMaterial.color = Color.green;
current = "green";
};
_green.OnUpdate += state => { transform.Rotate(45 * Time.deltaTime, 0, 0); };
_blue.OnEnter += state =>
{
_renderer.sharedMaterial.color = Color.blue;
current = "blue";
};
_blue.OnUpdate += state => { transform.Rotate(0, 0, 45 * Time.deltaTime); };
}
public void EpsilonTransitions()
{
TestSequentialTrigger trigger = new TestSequentialTrigger(1);
TestAction action = new TestAction();
StateMachine stateMachine = new StateMachine();
for (int i = 0; i < 4; i++)
{
var state = new SimpleState();
action.Monitor(state);
stateMachine.AddState(state);
}
action.Monitor(stateMachine);
stateMachine.AddEntryTransition(0, null);
stateMachine.AddExitTransition(3, null);
stateMachine.AddTransition(0, 1, null);
stateMachine.AddTransition(1, 2, trigger[0]);
stateMachine.AddTransition(2, 3, null);
stateMachine.Run();
Assert.AreEqual(1, stateMachine.ActiveStateId);
trigger.Run(0);
action.CompareResults(new List <string>()
{
"enter: 0",
"enter: 0", "leave: 0",
"enter: 1", "leave: 1",
"enter: 2", "leave: 2",
"enter: 3", "leave: 3",
});
Assert.AreEqual(State.ExitStateId, stateMachine.ActiveStateId);
}
public void TestCreateStatesWithTransitions()
{
var elevator = new SimpleStateMachine();
var floor = 0;
elevator["UP"] = new SimpleState()
{
OnEnter = () => { Console.WriteLine("Elevator is going up!"); },
OnUpdate = () => { floor++; },
transitions =
{
new SimpleStateTransition(() => floor == 25, "TOP")
}
};
elevator["TOP"] = new SimpleState()
{
OnEnter = () => { Console.WriteLine("Elevator is at the top!"); },
};
elevator.Change("UP");
while (elevator.state.name != "TOP")
{
elevator.Update();
}
Assert.AreEqual(25, floor);
}
public static void Test()
{
var machine = new Region( "history" );
var initial = new PseudoState( "initial", PseudoStateKind.Initial, machine );
var shallow = new CompositeState( "shallow", machine );
var deep = new SimpleState( "deep", machine );
var final = new FinalState( "final", machine );
var s1 = new SimpleState( "s1", shallow );
var s2 = new SimpleState( "s2", shallow );
new Transition( initial, shallow );
new Transition( new PseudoState( "shallow", PseudoStateKind.ShallowHistory, shallow ), s1 );
new Transition<String>( s1, s2, c => c.Equals( "move" ) );
new Transition<String>( shallow, deep, c => c.Equals( "go deep" ) );
new Transition<String>( deep, shallow, c => c.Equals( "go shallow" ) );
new Transition<String>( s2, final, c => c.Equals( "end" ) );
var state = new State();
machine.Initialise( state );
Trace.Assert( machine.Process( state, "move" ) );
Trace.Assert( machine.Process( state, "go deep" ) );
Trace.Assert( machine.Process( state, "go shallow" ) );
Trace.Assert( !machine.Process( state, "go shallow" ) );
Trace.Assert( machine.Process( state, "end" ) );
Trace.Assert( machine.IsComplete( state ) );
}
public override void Start()
{
setupState = new SimpleState(SetupEnter, SetupUpdate, SetupExit, "SETUP");
rideState = new SimpleState(RideEnter, RideUpdate, RideExit, "RIDE");
jumpState = new SimpleState(JumpEnter, JumpUpdate, JumpExit, "JUMP");
deathState = new SimpleState(DeathEnter, DeathUpdate, DeathExit, "DEATH");
finishedState = new SimpleState(null, null, null, "FINISHED");
}
public SimpleState GetState()
{
var state = new SimpleState(Owner.OwnerDraw, Util.ScaleRectangle(Rectangle, Owner.Transform));
state.Name = Text[1];
Owner.OwnerDraw.AddObject(state);
return(state);
}
public void ButtonsPanelBaseCreationTest()
{
StateMachineContextMoc _sm = new StateMachineContextMoc();
ButtonsPanelBase _bpb = new ViewModel.Wizard.ButtonsPanelBase(_sm);
Assert.IsNotNull(_bpb);
SimpleState _ss = _sm.EnterState <SimpleState>(new SimpleViewModel());
}
public static IState Create(string name)
{
IState state = new SimpleState
{
stateName = name
};
return(state);
}
public void TestCreateInitialStates()
{
var statemachine = new SimpleStateMachine();
statemachine["BOOT"] = new SimpleState();
statemachine.Change("BOOT");
Assert.AreEqual("BOOT", statemachine.state.name);
}
public SimpleState get_state(string state)
{
SimpleState ret = new SimpleState(CoolPropPINVOKE.AbstractState_get_state(swigCPtr, state), false);
if (CoolPropPINVOKE.SWIGPendingException.Pending)
{
throw CoolPropPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
void Start()
{
//DEFINE STATES
menuState = new SimpleState(MenuEnter, MenuUpdate, MenuExit, "[MENU]");
gameState = new SimpleState(GameEnter, GameUpdate, GameExit, "[GAME]");
winState = new SimpleState(WinEnter, WinUpdate, WinExit, "[WIN]");
// this is how you switch states!
stateMachine.SwitchStates(menuState);
}
void Start ()
{
//DEFINE STATES
menuState = new SimpleState(MenuEnter, MenuUpdate, MenuExit, "[MENU]");
playState = new SimpleState(PlayEnter, PlayUpdate, PlayExit, "[PLAY]");
endState = new SimpleState(EndEnter, EndUpdate, EndExit, "[END]");
// this is how you switch states!
stateMachine.SwitchStates(menuState);
}
private void CreateSimpleStatesAndMonitor(TestAction action, StateMachine m, int n)
{
for (int i = 0; i < n; i++)
{
var state = new SimpleState();
action.Monitor(state);
m.AddState(state);
}
action.Monitor(m);
}
public virtual SimpleState get_reducing_state()
{
SimpleState ret = new SimpleState(CoolPropPINVOKE.AbstractState_get_reducing_state(swigCPtr), false);
if (CoolPropPINVOKE.SWIGPendingException.Pending)
{
throw CoolPropPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
void Start()
{
//DEFINE STATES
menuState = new SimpleState(MenuEnter, MenuUpdate, MenuExit, "[MENU]");
gameState = new SimpleState(GameEnter, GameUpdate, GameExit, "[GAME]");
endState = new SimpleState(EndEnter, EndUpdate, EndExit, "[END]");
Setup();
stateMachine.SwitchStates(gameState); //TEMPORARY
}
public void PrintSimpleState(string devicename, SimpleState state)
{
switch (state)
{
case SimpleState.On:
Console.WriteLine("{0} {1}", devicename, On);
break;
case SimpleState.Off:
Console.WriteLine("{0} {1}", devicename, Off);
break;
}
}
public void PrintSimpleState(string devicename, SimpleState state)
{
switch (state)
{
case SimpleState.On:
Console.WriteLine("{0} {1}", devicename, On);
break;
case SimpleState.Off:
Console.WriteLine("{0} {1}", devicename, Off);
break;
}
}
public static void Test()
{
try
{
var main = new Region<State>( "muximise1" );
var initial = new PseudoState<State>( "initial", PseudoStateKind.Initial, main );
var ortho = new OrthogonalState<State>( "ortho", main );
var simple = new SimpleState<State>( "simple", main );
var final = new FinalState<State>( "final", main );
var r1 = new Region<State>( "r1", ortho );
var r2 = new Region<State>( "r2", ortho );
var i1 = new PseudoState<State>( "initial", PseudoStateKind.ShallowHistory, r1 );
var i2 = new PseudoState<State>( "initial", PseudoStateKind.ShallowHistory, r2 );
var s1 = new SimpleState<State>( "s1", r1 );
var s2 = new SimpleState<State>( "s2", r2 );
var f1 = new FinalState<State>( "f1", r1 );
var f2 = new FinalState<State>( "f2", r2 );
new Transition<State>( initial, ortho );
new Transition<State>( i1, s1 );
new Transition<State>( i2, s2 );
new Transition<State>( ortho, final ); // This should happen once all regions in ortho are complete?
new Transition<State, String>( s1, f1, ( s, c ) => c == "complete1" );
new Transition<State, String>( s2, f2, ( s, c ) => c == "complete2" );
new Transition<State, String>( ortho, simple, ( s, c ) => c == "jump" );
new Transition<State, String>( simple, ortho, ( s, c ) => c == "back" );
var state = new State();
main.Initialise( state );
main.Process( state, "complete1" );
main.Process( state, "complete2" );
Trace.Assert( main.IsComplete( state ) );
}
catch( Exception x )
{
Trace.Fail( x.Message );
}
}
private void Awake()
{
stateMachine = new StateMachine();
State greenState = new SimpleState(() =>
{
Debug.Log("Entered GreenState");
stateImage.color = Color.green;
},
null,
() =>
{
Debug.Log("Exit GreenState");
});
State redState = new SimpleState(() =>
{
Debug.Log("Exited GreenState");
stateImage.color = Color.red;
},
null,
() =>
{
Debug.Log("Entered RedState");
});
State blueState = new SimpleState(() =>
{
Debug.Log("Entered BlueState");
stateImage.color = Color.blue;
},
null,
() =>
{
Debug.Log("Exited BlueState");
});
greenState.Transitions.Add(new Transition(redState, () => !greenToggle.isOn && redToggle.isOn));
greenState.Transitions.Add(new Transition(blueState, 1, () => !greenToggle.isOn && blueToggle.isOn));
redState.Transitions.Add(new Transition(greenState, () => greenToggle.isOn));
redState.Transitions.Add(new Transition(blueState, () => !redToggle.isOn && blueToggle.isOn));
blueState.Transitions.Add(new Transition(greenState, () => greenToggle.isOn));
blueState.Transitions.Add(new Transition(redState, () => !blueToggle.isOn && redToggle.isOn));
stateMachine.CurrentState = greenState;
}
public void SimpleStatesOnly()
{
TestSequentialTrigger trigger = new TestSequentialTrigger(8);
TestAction action = new TestAction();
StateMachine stateMachine = new StateMachine();
for (int i = 0; i < 4; i++)
{
var state = new SimpleState();
action.Monitor(state);
stateMachine.AddState(state);
}
action.Monitor(stateMachine);
stateMachine.AddEntryTransition(0, trigger[7]);
stateMachine.AddExitTransition(1, trigger[6]);
stateMachine.AddTransition(0, 1, trigger[0]);
stateMachine.AddTransition(0, 3, trigger[1]);
stateMachine.AddTransition(1, 2, trigger[4]);
stateMachine.AddTransition(2, 0, trigger[3]);
stateMachine.AddTransition(3, 1, trigger[5]);
stateMachine.AddTransition(3, 2, trigger[2]);
Assert.AreEqual(State.InvalidStateId, stateMachine.ActiveStateId);
Assert.AreEqual("-3", stateMachine.GenerateActiveStateDescriptor());
stateMachine.Run();
Assert.AreEqual(State.EntryStateId, stateMachine.ActiveStateId);
Assert.AreEqual("-2", stateMachine.GenerateActiveStateDescriptor());
trigger.Run(7, 1, 2, 3, 0, 4, 3, 1, 5); // loop around
Assert.AreEqual("1.-1", stateMachine.GenerateActiveStateDescriptor());
trigger.Run(0, 1, 2, 3, 5); // invalid triggers
Assert.AreEqual("1.-1", stateMachine.GenerateActiveStateDescriptor());
trigger.Run(6); // to the end
Assert.AreEqual("-1", stateMachine.GenerateActiveStateDescriptor());
action.CompareResults(new List <string>()
{
"enter: 0", // outer state machine
"enter: 0", "leave: 0", // state 0
"enter: 3", "leave: 3",
"enter: 2", "leave: 2",
"enter: 0", "leave: 0",
"enter: 1", "leave: 1",
"enter: 2", "leave: 2",
"enter: 0", "leave: 0",
"enter: 3", "leave: 3",
"enter: 1", "leave: 1",
});
Assert.AreEqual(State.ExitStateId, stateMachine.ActiveStateId);
}
public async Task SimpleState_BuildRuntimeStateAndExecute()
{
var tracker = new TestTracker();
var state = new SimpleState("test")
{
OnEnterAction = tracker.StateEnterAction,
OnExecuteAction = tracker.StateExecutionAction,
OnExitAction = tracker.StateExitAction,
OnCanceledAction = tracker.StateCanceledAction,
};
await state
.BuildRuntimeState()
.ExecuteAsync(CancellationToken.None);
Assert.Equal(">test;*test;<test;", tracker.ToString());
}
public void TransitionEvents()
{
StateMachine stateMachine = new StateMachine();
SimpleState s0 = new SimpleState(), s1 = new SimpleState();
stateMachine.AddState(s0);
stateMachine.AddState(s1);
stateMachine.AddEntryTransition(0, null);
stateMachine.AddExitTransition(1, null);
TransitionTrigger trigger = new TransitionTrigger();
stateMachine.AddTransition(0, 1, trigger);
List <string> result = new List <string>();
s0.StateLeave += () => result.Add("leave: 0");
s1.StateEnter += () => result.Add("enter: 1");
trigger.BeforeTransition += () =>
{
result.Add("before transition");
Assert.AreEqual("0.-1", stateMachine.GenerateActiveStateDescriptor());
};
trigger.AfterTransition += () =>
{
result.Add("after transition");
Assert.AreEqual("-1", stateMachine.GenerateActiveStateDescriptor());
};
stateMachine.Run();
trigger.Fire();
Assert.AreEqual(4, result.Count);
Assert.AreEqual("before transition", result[0]);
Assert.AreEqual("leave: 0", result[1]);
Assert.AreEqual("enter: 1", result[2]);
Assert.AreEqual("after transition", result[3]);
trigger.BeforeTransition += () => trigger.StopTransition();
result.Clear();
stateMachine.Reset();
stateMachine.Run();
trigger.Fire();
Assert.AreEqual(1, result.Count);
Assert.AreEqual("before transition", result[0]);
}
void Start()
{
starttimer = false;
selected = null;
InitialSelect = null;
FinalSelect = null;
hitResults = new List <ARRaycastHit>();
if (AR_camera == null)
{
AR_camera = Camera.main;
}
if (aRRaycastManager == null)
{
aRRaycastManager = GetComponent <ARRaycastManager>();
}
currentState = SimpleState.init;
if (timeout <= 0)
{
timeout = timer;
}
}
public void MultiEdges()
{
StateMachine stateMachine = new StateMachine();
SimpleState s0 = new SimpleState(), s1 = new SimpleState();
stateMachine.AddState(s0);
stateMachine.AddState(s1);
stateMachine.AddEntryTransition(0, null);
stateMachine.AddExitTransition(1, null);
TransitionTrigger trigger0 = new TransitionTrigger();
TransitionTrigger trigger1 = new TransitionTrigger();
stateMachine.AddTransition(0, 1, trigger0);
stateMachine.AddTransition(0, 1, trigger1);
stateMachine.Run();
trigger0.Fire();
Assert.AreEqual("-1", stateMachine.GenerateActiveStateDescriptor());
stateMachine.Reset();
stateMachine.Run();
trigger1.Fire();
Assert.AreEqual("-1", stateMachine.GenerateActiveStateDescriptor());
}
public void EasyAction(SimpleState state)
{
Thread.Sleep(1000);
state.StateFullVariable = 1;
}
// Update is called once per frame
void Update()
{
if (Input.touchCount > 0)
{
if (touchcount < Input.touchCount)
{
touchcount = Input.touchCount;
}
Touch touch = Input.GetTouch(0);
if ((Input.touchCount >= 2 || touchcount >= 2))
{
//this prevents spawning/selection and enables update during
//as selection and spawning is updated after touch
manipulated = true;
currentState = SimpleState.Manipulate;
//scaling conditions
if (Input.touchCount >= 2 && selected)
{
if (Input.GetTouch(1).phase == TouchPhase.Began)
{
currentScale = selected.transform.localScale;
scaleSize = Mathf.Abs(Vector2.Distance(Input.GetTouch(0).position, Input.GetTouch(1).position));
}
else if (Input.GetTouch(1).phase == TouchPhase.Moved || Input.GetTouch(0).phase == TouchPhase.Moved)
{
float factor = Mathf.Abs(Vector2.Distance(Input.GetTouch(0).position, Input.GetTouch(1).position)) / scaleSize;
selected.transform.localScale = currentScale * factor;
}
}
}
//Update Variables for operation
else if (touchcount == 1 && !manipulated)
{
switch (touch.phase)
{
case TouchPhase.Began:
{
timer = timeout;
starttimer = true;
Ray ray = AR_camera.ScreenPointToRay(touch.position);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, layerMask))
{
InitialSelect = hit.transform.gameObject;
}
else
{
InitialSelect = null;
}
}
break;
case TouchPhase.Moved:
{
manipulated = true;
}
break;
case TouchPhase.Ended:
{
finalTouchPose = touch.position;
Ray ray = AR_camera.ScreenPointToRay(finalTouchPose);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, layerMask))
{
FinalSelect = hit.transform.gameObject;
}
else
{
FinalSelect = null;
}
}
break;
}
}
//real time updates if touchcount>1 or manipulated
//as rotation transilation should be visible inscerrn during interaction
else if (touchcount == 1 && manipulated)
{
//rotate or transilate if selected not null
if (selected != null)
{
//rotate
if (selected != InitialSelect)
{
if (Input.GetTouch(0).phase == TouchPhase.Moved)
{
currentState = SimpleState.Manipulate;
selected.transform.Rotate((new Vector3(0, 1, 0)) * RotateFactor * Input.GetTouch(0).deltaPosition.x);
}
}
//transilate
else if (selected == InitialSelect)
{
if (aRRaycastManager.Raycast(Input.GetTouch(0).position, hitResults, TrackableType.PlaneWithinPolygon))
{
currentState = SimpleState.Manipulate;
var pose = hitResults[0].pose;
selected.transform.position = pose.position;
}
}
}
// if no selected object go to init
else if (selected == null)
{
currentState = SimpleState.init;
}
}
}
else if (Input.touchCount == 0 && touchcount != 0)
{
if (!manipulated)
{
//spawnSelectCycle
if (InitialSelect == FinalSelect && InitialSelect != null && selected == null)
{
//selected
selected = InitialSelect;
currentState = SimpleState.Select;
}
else if (InitialSelect == FinalSelect && InitialSelect != null && selected != null && InitialSelect == FinalSelect)
{
//deselected
selected = null;
currentState = SimpleState.init;
}
else if (InitialSelect == null && FinalSelect == null)
{
//spawned
if (aRRaycastManager.Raycast(finalTouchPose, hitResults, TrackableType.PlaneWithinPolygon))
{
selected = null;
var pose = hitResults[0].pose;
var tmp = Instantiate(placement, pose.position, pose.rotation);
tmp.layer = layerMask;
currentState = SimpleState.Spawn;
}
}
}
debugprint();
starttimer = false;
touchcount = 0;
manipulated = false;
InitialSelect = null;
FinalSelect = null;
}
if (timer > 0 && starttimer)
{
timer = timer - Time.deltaTime;
if (tmr != null)
{
tmr.text = timer.ToString();
}
}
else if (!manipulated && starttimer)
{
currentState = SimpleState.Manipulate;
manipulated = true;
if (tmr != null)
{
tmr.text = timer.ToString();
}
debugprint();
}
}
public override void Update(HomeOS.Hub.Platform.Views.VModuleState s)
{
this.state = (SimpleState)s.GetSimpleState();
this.timestamp = s.GetTimestamp();
}
public ModuleState(SimpleState s, DateTime t)
{
this.state = s;
this.timestamp = t;
}
public void TurnOn()
{
State = SimpleState.On;
}
public void TurnOff()
{
State = SimpleState.Off;
}
public void ActionIfTrue(SimpleState state)
{
state.StateFullVariable = 2;
}
public void EasyActionParallel2(SimpleState state)
{
Thread.Sleep(700);
state.StateFullVariableAsynch2 = 20;
}
public void EasyActionParallel3(SimpleState state)
{
Thread.Sleep(1000);
state.StateFullVariableAsynch3 = 30;
}
void Awake()
{
//Lazy Singleton
Instance = this;
// DontDestroyOnLoad(PauseMenuCanvas);
//Initialize State Machine
paused = new SimpleState(PausedEnter, PausedUpdate, PausedExit, "[GAME-STATE] : PAUSED");
running = new SimpleState(RunningEnter, RunningUpdate, RunningExit, "[GAME-STATE] : RUNNING");
mainMenu = new SimpleState(MainMenuEnter, MainMenuUpdate, MainMenuExit, "[GAME-STATE] : MAINMENU");
ended = new SimpleState(EndedEnter, EndedUpdate, EndedExit, "[GAME-STATE] : ENDED");
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SimpleState obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public void ParallelTestValidation(SimpleState state)
{
Assert.AreEqual(10, state.StateFullVariableAsynch1);
Assert.AreEqual(20, state.StateFullVariableAsynch2);
Assert.AreEqual(30, state.StateFullVariableAsynch3);
}
public void EasyParallelTestValidation(SimpleState state)
{
Assert.AreEqual(1, state.StateFullVariable);
}
public void ActionIfFalse(SimpleState state)
{
state.StateFullVariable = 3;
}
public void EasyActionParallel1(SimpleState state)
{
Thread.Sleep(1200);
state.StateFullVariableAsynch1 = 10;
}
public void SwitchStates(SimpleState state) {
SwitchStates(state.enter, state.update, state.exit, state.name);
}
