public static void StateMachine_TransitionEventTests()
{
var stateMachine = new Dictionary <MyStates, HashSet <MyStates> >();
stateMachine.AddToValues(MyStates.MyState1, MyStates.MyState2);
MyStates currentState = MyStates.MyState1;
var listenerForAllTransitionsTriggered = false;
var listenerForSpecificTransitionTriggered = false;
var listenerForExitingState1Triggered = false;
var listenerForEnteringState2Triggered = false;
StateMachine.SubscribeToAllTransitions <MyStates>(new object(), (passedMachine, oldState, newState) => {
listenerForAllTransitionsTriggered = true;
Assert.Equal(stateMachine, passedMachine);
});
StateMachine.SubscribeToTransition(new object(), MyStates.MyState1, MyStates.MyState2, (passedMachine) => {
listenerForSpecificTransitionTriggered = true;
Assert.Equal(stateMachine, passedMachine);
});
StateMachine.SubscribeToStateExited(new object(), MyStates.MyState1, (passedMachine) => {
listenerForExitingState1Triggered = true;
Assert.Equal(stateMachine, passedMachine);
});
StateMachine.SubscribeToStateEntered(new object(), MyStates.MyState2, (passedMachine) => {
listenerForEnteringState2Triggered = true;
Assert.Equal(stateMachine, passedMachine);
});
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState2);
Assert.True(listenerForAllTransitionsTriggered);
Assert.True(listenerForSpecificTransitionTriggered);
Assert.True(listenerForExitingState1Triggered);
Assert.True(listenerForEnteringState2Triggered);
}
public static void StateMachine_ExampleUsage1()
{
// First define a set of allowed transitions to define the state machine:
var stateMachine = new Dictionary <MyStates, HashSet <MyStates> >();
stateMachine.AddToValues(MyStates.MyState1, MyStates.MyState2); // 1 => 2 allowed
stateMachine.AddToValues(MyStates.MyState2, MyStates.MyState3); // 2 => 3 allowed
// Initialize a state-machine:
MyStates currentState = MyStates.MyState1;
// It is possible to listen to state machine transitions:
StateMachine.SubscribeToAllTransitions <MyStates>(new object(), (machine, oldState, newState) => {
Log.d("Transitioned from " + oldState + " to " + newState);
});
// And its possible to listen only to specific transitions:
StateMachine.SubscribeToTransition(new object(), MyStates.MyState1, MyStates.MyState2, delegate {
Log.d("Transitioned from 1 => 2");
});
// Transition the state-machine from state 1 to 2:
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState2);
Assert.Equal(MyStates.MyState2, currentState);
// Invalid transitions throw exceptions (current state is 2):
Assert.Throws <InvalidOperationException>(() => {
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState1);
});
}
// In the constructor the allowed transitions and the initial state are set:
public MyStateMachineForExample2()
{
// First define a set of allowed transitions to define the state machine:
allowedTransitions = new Dictionary <MyStates, HashSet <MyStates> >();
allowedTransitions.AddToValues(MyStates.MyState1, MyStates.MyState2);
allowedTransitions.AddToValues(MyStates.MyState2, MyStates.MyState3);
// Initialize the state-machine:
currentState = MyStates.MyState1;
}
public ScanResultsControl()
{
Opacity = 0;
State = MyStates.ResultsDisplaying;
InitializeComponent();
AnimationsInit();
AgainButton.Click += AgainButton_Click;
IpListButton.Click += IpListButton_Click;
BackButton.Click += BackButton_Click;
}
//新增一個容器
void AddNewStateCT()
{
GameObject container = Instantiate(myStatesPrefab);
GoHideArea(container);
MyStates newStateCT = new MyStates();
newStateCT.stateImg = container.GetComponent <Image>();
newStateCT.cdBar = container.transform.GetChild(1).GetComponent <Image>();
newStateCT.nowAmount = container.transform.GetChild(2).GetComponent <Text>();
newStateCT.statePrefab = container;
newStateCT.listNum = myStatesCT.Count;
myStatesCT.Add(newStateCT);
}
private void SwapIpListYMove_Completed(object sender, EventArgs e)
{
if (State == MyStates.ResultsDisplaying)
{
ScanResults.Visibility = Visibility.Hidden;
State = MyStates.IpListDisplaying;
OpenIpListButtonBar();
}
else if (State == MyStates.IpListDisplaying)
{
IpList.Visibility = Visibility.Hidden;
State = MyStates.ResultsDisplaying;
OpenButtonBar();
}
}
public static void StateMachine_TransitionEventTests2()
{
var stateMachine = new Dictionary <MyStates, HashSet <MyStates> >();
stateMachine.AddToValues(MyStates.MyState1, MyStates.MyState1);
stateMachine.AddToValues(MyStates.MyState1, MyStates.MyState2);
stateMachine.AddToValues(MyStates.MyState2, MyStates.MyState2);
stateMachine.AddToValues(MyStates.MyState2, MyStates.MyState1);
MyStates currentState = MyStates.MyState1;
var state1To1Counter = 0;
StateMachine.SubscribeToTransition <MyStates>(new object(), MyStates.MyState1, MyStates.MyState1, delegate { state1To1Counter++; });
var state1To2Counter = 0;
StateMachine.SubscribeToTransition <MyStates>(new object(), MyStates.MyState1, MyStates.MyState2, delegate { state1To2Counter++; });
var state2To2Counter = 0;
StateMachine.SubscribeToTransition <MyStates>(new object(), MyStates.MyState2, MyStates.MyState2, delegate { state2To2Counter++; });
var state2To1Counter = 0;
StateMachine.SubscribeToTransition <MyStates>(new object(), MyStates.MyState2, MyStates.MyState1, delegate { state2To1Counter++; });
{ // Transition from 1 => 1 => 2 => 2 => 1 :
currentState = Transition_1_2_2_1(stateMachine, currentState);
var c = 1; // All listeners should have counted one time:
Assert.Equal(c, state1To1Counter);
Assert.Equal(c, state1To2Counter);
Assert.Equal(c, state2To2Counter);
Assert.Equal(c, state2To1Counter);
}
{ // AGAIN Transition from 1 => 1 => 2 => 2 => 1 :
currentState = Transition_1_2_2_1(stateMachine, currentState);
var c = 2; // All listeners should have counted AGAIN one time:
Assert.Equal(c, state1To1Counter);
Assert.Equal(c, state1To2Counter);
Assert.Equal(c, state2To2Counter);
Assert.Equal(c, state2To1Counter);
}
}
/// <summary>
/// Raises the GU event.
/// </summary>
void OnGUI()
{
GUI.skin = null;
if (EditorApplication.isPlaying == false)
{
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUI.skin = myState == MyStates.Pointer ? null : tilesGuiSkin;
if (GUILayout.Button(contents.pointer) == true)
{
myState = MyStates.Pointer;
UpdateTemp();
tileIdx = -1;
environmentIdx = -1;
}
GUI.skin = null;
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
GUILayout.Space(20);
if (GUILayout.Button("Choose background") == true)
{
ShowPicker <Sprite>(PickerState.Map, mapSpriteLabel);
}
GUI.skin = tilesGuiSkin;
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label("------------Environment------------");
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("In game sorting");
inGameSorting = EditorGUILayout.Toggle(inGameSorting);
EditorGUILayout.EndHorizontal();
environmentScrollPos = EditorGUILayout.BeginScrollView(environmentScrollPos, GUILayout.MaxHeight(120));
int environmentNewIdx = GUILayout.SelectionGrid(environmentIdx, environmentTextures, 4);
if (environmentNewIdx != environmentIdx)
{
environmentIdx = environmentNewIdx;
if (environmentIdx >= 0)
{
myState = MyStates.EnvironmentPlacement;
UpdateTemp();
tileIdx = -1;
SetEnvironment(environmentPrefabs[environmentIdx]);
}
}
EditorGUILayout.EndScrollView();
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label("---------------Tiles---------------");
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Snap step");
snapStep = EditorGUILayout.FloatField(snapStep);
EditorGUILayout.EndHorizontal();
tilesScrollPos = EditorGUILayout.BeginScrollView(tilesScrollPos, GUILayout.MaxHeight(140));
int tileNewIdx = GUILayout.SelectionGrid(tileIdx, tileTextures, 4);
if (tileNewIdx != tileIdx)
{
tileIdx = tileNewIdx;
if (tileIdx >= 0)
{
myState = MyStates.TilePlacement;
UpdateTemp();
environmentIdx = -1;
SetTile(tilePrefabs[tileIdx]);
}
}
EditorGUILayout.EndScrollView();
GUI.skin = null;
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button(contents.rotateLeft) == true)
{
RotateTile(90f);
}
GUILayout.FlexibleSpace();
if (GUILayout.Button(contents.rotateRight) == true)
{
RotateTile(-90f);
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
if (myState == MyStates.Pointer)
{
GUILayout.Space(20);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Map name");
mapName = EditorGUILayout.TextField(mapName);
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("Save map") == true)
{
if (mapFolderInspector != null)
{
if (mapFolderInspector.map != null)
{
mapFolderInspector.map.gameObject.name = mapName;
GameObject newMapPrefab = PrefabUtility.CreatePrefab("Assets/TD2D/Prefabs/Map/LevelMaps/" + mapName + ".prefab", mapFolderInspector.map.gameObject, ReplacePrefabOptions.ConnectToPrefab);
AssetDatabase.Refresh();
Selection.activeObject = newMapPrefab;
EditorUtility.FocusProjectWindow();
}
}
}
}
// New object selected in picker window
if (Event.current.commandName == "ObjectSelectorUpdated" && EditorGUIUtility.GetObjectPickerControlID() == currentPickerWindow)
{
pickedObject = EditorGUIUtility.GetObjectPickerObject();
}
// Picker window closed
if (Event.current.commandName == "ObjectSelectorClosed" && EditorGUIUtility.GetObjectPickerControlID() == currentPickerWindow)
{
switch (pickerState)
{
case PickerState.Map:
if (pickedObject != null && pickedObject is Sprite && mapFolderInspector != null)
{
mapFolderInspector.ChangeMapSprite(pickedObject as Sprite);
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
}
break;
}
pickedObject = null;
pickerState = PickerState.None;
}
}
else
{
EditorGUILayout.HelpBox("Editor disabled in play mode", MessageType.Info);
}
}
private void UpdateStuff()
{
mapFolderInspector = FindObjectOfType <MapFolderInspector>();
List <Texture> tilesList = new List <Texture>();
string[] paths = AssetDatabase.FindAssets("t:Prefab", new string[] { "Assets/TD2D/Prefabs/Tiles" });
foreach (string str in paths)
{
GameObject tilePrefab = AssetDatabase.LoadAssetAtPath <GameObject>(AssetDatabase.GUIDToAssetPath(str));
if (tilePrefab != null)
{
SpriteRenderer sprite = tilePrefab.GetComponent <SpriteRenderer>();
if (sprite != null && sprite.sprite != null)
{
tilePrefabs.Add(tilePrefab);
tilesList.Add(sprite.sprite.texture);
}
}
}
tileTextures = tilesList.ToArray();
List <Texture> environmentList = new List <Texture>();
paths = AssetDatabase.FindAssets("t:Prefab", new string[] { "Assets/TD2D/Prefabs/Environment" });
foreach (string str in paths)
{
GameObject environmentPrefab = AssetDatabase.LoadAssetAtPath <GameObject>(AssetDatabase.GUIDToAssetPath(str));
if (environmentPrefab != null)
{
SpriteRenderer sprite = environmentPrefab.GetComponent <SpriteRenderer>();
if (sprite != null && sprite.sprite != null)
{
environmentPrefabs.Add(environmentPrefab);
environmentList.Add(sprite.sprite.texture);
}
}
}
environmentTextures = environmentList.ToArray();
tileIdx = -1;
environmentIdx = -1;
Tools.lockedLayers |= 1 << LayerMask.NameToLayer(mapLayer);
Tools.lockedLayers &= ~(1 << LayerMask.NameToLayer(tilesLayer));
myState = MyStates.Pointer;
tilesGuiSkin = (GUISkin)AssetDatabase.LoadAssetAtPath("Assets/TD2D/Sprites/Editor/TilesGuiSkin.guiskin", typeof(GUISkin));
// Set labels for prebas. Label will use in picker window
string[] prefabs;
prefabs = AssetDatabase.FindAssets("t:Sprite", new string[] { "Assets/TD2D/Sprites/Maps/Backgrounds" });
foreach (string str in prefabs)
{
Object obj = AssetDatabase.LoadAssetAtPath <Object>(AssetDatabase.GUIDToAssetPath(str));
AssetDatabase.SetLabels(obj, new string[] { mapSpriteLabel });
}
contents.rotateLeft = new GUIContent((Texture)AssetDatabase.LoadAssetAtPath("Assets/TD2D/Sprites/Editor/RotateLeft.png", typeof(Texture)));
contents.rotateRight = new GUIContent((Texture)AssetDatabase.LoadAssetAtPath("Assets/TD2D/Sprites/Editor/RotateRight.png", typeof(Texture)));
contents.pointer = new GUIContent((Texture)AssetDatabase.LoadAssetAtPath("Assets/TD2D/Sprites/Editor/Pointer.png", typeof(Texture)));
}
private void SwitchToState(MyStates newState)
{
currentState = allowedTransitions.TransitionTo(currentState, newState);
}
private static MyStates Transition_1_2_2_1(Dictionary <MyStates, HashSet <MyStates> > stateMachine, MyStates currentState)
{
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState1);
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState2);
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState2);
currentState = stateMachine.TransitionTo(currentState, MyStates.MyState1);
return(currentState);
}
/// <summary>
/// TODO This is where you are supposed to implement your pose/gesture recognition
/// </summary>
/// <param name="trackedBody">Tracked body data</param>
private void RecognizeGestures(Body trackedBody)
{
// TODO Add your pose/gesture recognition code here!
var leftState = trackedBody.HandLeftState;
var rightState = trackedBody.HandRightState;
if (currentState != MyStates.NOGESTURE)
{
switch (currentState)
{
case MyStates.NEUTRAL:
// Transition condition for right arm stretched out
if (LeftHandIn && LeftHandAboveElbow && leftState == HandState.Closed)
{
Trace.WriteLine("StartingNext");
currentState = MyStates.LEFT_HAND_IN;
}
else if (RightHandIn && RightHandAboveElbow && rightState == HandState.Closed)
{
Trace.WriteLine("StartingPrev");
currentState = MyStates.RIGHT_HAND_IN;
}
else if (Clap)
{
Trace.WriteLine("Clapping");
currentState = MyStates.CLAP;
}
else if (FacePalm)
{
Trace.WriteLine("Face Palm start");
lastFacePalm = DateTime.Now;
currentState = MyStates.FACE_PALM;
}
//else if (ToggleGesture)
//{
// Trace.WriteLine("Disabling");
// currentState = MyStates.NOGESTURE;
//}
break;
case MyStates.LEFT_HAND_IN:
if (!LeftHandIn && LeftHandAboveElbow && leftState == HandState.Open)
{
nextSlide();
currentState = MyStates.NEUTRAL;
Trace.WriteLine("Next");
}
else if ((LeftHandIn && leftState == HandState.Open) || !LeftHandAboveElbow)
{
Trace.WriteLine("Aborting Next");
currentState = MyStates.NEUTRAL;
}
else if (Clap)
{
Trace.WriteLine("Clapping");
currentState = MyStates.CLAP;
}
else if (FacePalm)
{
Trace.WriteLine("Face Palm start");
lastFacePalm = DateTime.Now;
currentState = MyStates.FACE_PALM;
}
break;
case MyStates.RIGHT_HAND_IN:
if (!RightHandIn && RightHandAboveElbow && rightState == HandState.Open)
{
previousSlide();
currentState = MyStates.NEUTRAL;
Trace.WriteLine("Previous");
}
else if ((RightHandIn && rightState == HandState.Open) || !RightHandAboveElbow)
{
Trace.WriteLine("Aborting Previous");
currentState = MyStates.NEUTRAL;
}
else if (Clap)
{
Trace.WriteLine("Clapping");
currentState = MyStates.CLAP;
}
break;
case MyStates.CLAP:
if (NotClap)
{
currentState = MyStates.NEUTRAL;
Trace.WriteLine("End Clapping");
if (DateTime.Now - lastClap < TimeSpan.FromSeconds(1) && lastClap != DateTime.MinValue)
{
endPresentation();
}
else
{
startPresentation();
}
lastClap = DateTime.Now;
}
break;
case MyStates.FACE_PALM:
if (!FacePalm)
{
currentState = MyStates.NEUTRAL;
Trace.WriteLine("Aborting Face Palm");
}
if (DateTime.Now - lastFacePalm > TimeSpan.FromSeconds(0.5) && lastFacePalm != DateTime.MinValue)
{
toggleBlackScreen();
currentState = MyStates.BLACK;
Trace.WriteLine("Face Palm!");
}
break;
case MyStates.BLACK:
if (!FacePalm)
{
Trace.WriteLine("Ending Face Palm");
currentState = MyStates.NEUTRAL;
lastFacePalm = DateTime.MinValue;
toggleBlackScreen();
}
break;
}
}
else
{
if (ToggleGesture)
{
currentState = MyStates.NEUTRAL;
Trace.WriteLine("Gesture enabling");
}
}
}
