private void OnTransitionContextClick(int index) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Remove"), false, delegate() { FsmEditorUtility.DestroyImmediate(node.Transitions[index]); node.Transitions = ArrayUtility.Remove(node.Transitions, transitions [index]); this.ResetTransitionList(); }); menu.ShowAsContext(); }
public static void DeleteNode(Node node) { FsmEditorUtility.DestroyImmediate(node); node.Parent.Nodes = ArrayUtility.Remove <Node> (node.Parent.Nodes, node); foreach (Transition transition in node.InTransitions) { FsmEditorUtility.DestroyImmediate(transition); transition.FromNode.Transitions = ArrayUtility.Remove(transition.FromNode.Transitions, transition); } ErrorChecker.CheckForErrors(); }
public override void OnGUI(SerializedProperty property, GUIContent label) { SerializedProperty componentProperty = property.serializedObject.FindProperty("component"); SerializedProperty propProperty = property.serializedObject.FindProperty("property"); SerializedProperty parameterProperty = property.serializedObject.FindProperty("parameter"); GUILayout.BeginHorizontal(); EditorGUILayout.PropertyField(componentProperty); ComponentHint(componentProperty, propProperty); GUILayout.EndHorizontal(); if (!string.IsNullOrEmpty(componentProperty.stringValue)) { Type componentType = TypeUtility.GetType(componentProperty.stringValue); if (componentType != null) { GUILayout.BeginHorizontal(); EditorGUILayout.PropertyField(propProperty); PropertyHint(propProperty, componentType); GUILayout.EndHorizontal(); if (!string.IsNullOrEmpty(propProperty.stringValue)) { Type variableType = FsmUtility.GetVariableType(TypeUtility.GetMemberType(componentType, propProperty.stringValue)); Debug.Log(variableType); if (variableType != null) { fieldInfo = property.serializedObject.targetObject.GetType().GetField("parameter"); if (parameterProperty.objectReferenceValue == null || parameterProperty.objectReferenceValue.GetType() != variableType) { FsmEditorUtility.DestroyImmediate(parameterProperty.objectReferenceValue as FsmVariable); FsmVariable variable = ScriptableObject.CreateInstance(variableType) as FsmVariable; variable.hideFlags = HideFlags.HideInHierarchy; if (EditorUtility.IsPersistent(parameterProperty.serializedObject.targetObject)) { AssetDatabase.AddObjectToAsset(variable, property.serializedObject.targetObject); AssetDatabase.SaveAssets(); } variable.IsShared = fieldInfo.HasAttribute(typeof(SharedAttribute)) || EditorUtility.IsPersistent(variable) && fieldInfo.HasAttribute(typeof(SharedPersistentAttribute)) || variable is FsmArray; parameterProperty.serializedObject.Update(); parameterProperty.objectReferenceValue = variable; parameterProperty.serializedObject.ApplyModifiedProperties(); } base.OnGUI(parameterProperty, new GUIContent("Parameter")); } } } } }
protected override void OnGUI() { mainToolbar.OnGUI(); EventType eventType = FsmEditorUtility.ReserveEvent(variableEditorRect, fsmSelectionRect, preferencesRect); ZoomableArea.Begin(new Rect(0f, 0f, scaledCanvasSize.width, scaledCanvasSize.height + 21), scale, IsDocked); Begin(); shortcutEditor.HandleKeyEvents(); if (FsmEditor.Active != null) { DoNodes(); } else { ZoomableArea.End(); } AcceptDragAndDrop(); End(); FsmEditorUtility.ReleaseEvent(eventType); PreferencesEditor.DoGUI(preferencesRect); shortcutEditor.DoGUI(shortcutRect); DoFsmSelection(fsmSelectionRect); variableEditor.DoGUI(variableEditorRect); if (centerView) { CenterView(); centerView = false; } if (FsmEditor.Active != null) { GUI.Label(new Rect(5, 20, 300, 200), FsmEditor.Active.comment, FsmEditorStyles.instructionLabel); } else { GUI.Label(new Rect(5, 20, 300, 200), "Right click to create a state machine.", FsmEditorStyles.instructionLabel); } Event ev = Event.current; if (SelectedNodes.Count == 1 && ev.rawType == EventType.KeyDown && ev.keyCode == KeyCode.Delete && FsmEditor.SelectedTransition != null && EditorUtility.DisplayDialog("Delete selected transition?", FsmEditor.SelectedTransition.FromNode.Name + " -> " + FsmEditor.SelectedTransition.ToNode.Name + "\r\n\r\nYou cannot undo this action.", "Delete", "Cancel")) { Node node = SelectedTransition.FromNode; node.Transitions = ArrayUtility.Remove(node.Transitions, FsmEditor.SelectedTransition); FsmEditorUtility.DestroyImmediate(FsmEditor.SelectedTransition); ErrorChecker.CheckForErrors(); EditorUtility.SetDirty(node); } }
public override void CreateVariable(SerializedProperty property) { FsmVariable variable = property.objectReferenceValue as FsmVariable; if (parameterTypeNames == null) { parameterTypeNames = TypeUtility.GetSubTypeNames(typeof(FsmVariable)); parameterTypeNames = ArrayUtility.Insert <string> (parameterTypeNames, "None", 0); } int index = parameterTypeNames.ToList().FindIndex(x => x == (variable != null?variable.GetType().ToString().Split('.').Last():"")); index = Mathf.Clamp(index, 0, int.MaxValue); index = EditorGUILayout.Popup("Parameter Type", index, parameterTypeNames); string typeName = parameterTypeNames [index]; string variableTypeName = (variable == null ? "None" : variable.GetType().Name); if (typeName != variableTypeName) { FsmEditorUtility.DestroyImmediate(property.objectReferenceValue as FsmVariable); if (typeName != "None") { variable = ScriptableObject.CreateInstance(TypeUtility.GetTypeByName(typeName)[0]) as FsmVariable; variable.hideFlags = HideFlags.HideInHierarchy; if (EditorUtility.IsPersistent(property.serializedObject.targetObject)) { AssetDatabase.AddObjectToAsset(variable, property.serializedObject.targetObject); AssetDatabase.SaveAssets(); } variable.IsShared = fieldInfo.HasAttribute(typeof(SharedAttribute)) || EditorUtility.IsPersistent(variable) && fieldInfo.HasAttribute(typeof(SharedPersistentAttribute)) || variable is FsmArray || !variable.GetType().GetProperty("Value").PropertyType.IsSerializable; property.serializedObject.Update(); property.objectReferenceValue = variable; property.serializedObject.ApplyModifiedProperties(); } ErrorChecker.CheckForErrors(); } }
public void OnInspectorGUI() { int index = node.Transitions.ToList().FindIndex(x => x == FsmEditor.SelectedTransition); if (index != transitionList.index && index != -1) { transitionList.index = index; } transitionList.DoLayoutList(); GUILayout.Space(10f); conditionList.DoLayoutList(); Event ev = Event.current; if (ev.rawType == EventType.KeyDown && ev.keyCode == KeyCode.Delete && FsmEditor.SelectedTransition != null && EditorUtility.DisplayDialog("Delete selected transition?", FsmEditor.SelectedTransition.FromNode.Name + " -> " + FsmEditor.SelectedTransition.ToNode.Name + "\r\n\r\nYou cannot undo this action.", "Delete", "Cancel")) { node.Transitions = ArrayUtility.Remove(node.Transitions, FsmEditor.SelectedTransition); FsmEditorUtility.DestroyImmediate(FsmEditor.SelectedTransition); ErrorChecker.CheckForErrors(); EditorUtility.SetDirty(node); } }
public static void Paste(Vector2 position, StateMachine stateMachine) { List <Node> copiedNodes = new List <Node> (); Vector2 center = GetCenter(nodes); for (int i = 0; i < nodes.Count; i++) { Node origNode = nodes[i]; List <FsmVariable> sharedVariables = new List <FsmVariable>(); GetSharedVariables(origNode, ref sharedVariables); if (sharedVariables.Count > 0) { string variableNames = string.Empty; sharedVariables.Select(x => x.Name).ToList().ForEach(y => variableNames = (variableNames + (string.IsNullOrEmpty(variableNames)?"":",") + y)); if (EditorUtility.DisplayDialog("Paste Variables", "Copied states have reference to shared variables, do you want to paste those variables? (" + variableNames + ")", "Yes", "No")) { for (int j = 0; j < sharedVariables.Count; j++) { FsmVariable variable = sharedVariables[j]; stateMachine.SetVariable(variable.Name, variable.GetValue()); } } } Node mNode = (Node)FsmUtility.Copy(origNode); mNode.Parent = stateMachine; mNode.hideFlags = HideFlags.HideInHierarchy; if (mNode.IsStartNode && stateMachine.GetStartNode() != null) { mNode.IsStartNode = false; } //mNode.Name = FsmEditorUtility.GenerateUniqueNodeName(mNode.GetType(),stateMachine); stateMachine.Nodes = ArrayUtility.Add <Node> (stateMachine.Nodes, mNode); mNode.position = new Rect(-(center.x - origNode.position.x) + position.x, -(center.y - origNode.position.y) + position.y, FsmEditorStyles.StateWidth, FsmEditorStyles.StateHeight); if (mNode.GetType() == typeof(StateMachine)) { mNode.position.width = FsmEditorStyles.StateMachineWidth; mNode.position.height = FsmEditorStyles.StateMachineHeight; } FsmEditorUtility.UpdateNodeColor(mNode); copiedNodes.Add(mNode); } for (int i = 0; i < copiedNodes.Count; i++) { Node mNode = copiedNodes [i]; if (mNode is AnyState) { bool mOverride = EditorUtility.DisplayDialog("Override AnyState", "AnyState can only exist once per state machine. Do you want to override it?", "Yes", "No"); AnyState anyState = stateMachine.Nodes.ToList().Find(x => x.GetType() == typeof(AnyState) && (mOverride && x != mNode || !mOverride && x == mNode)) as AnyState; stateMachine.Nodes = ArrayUtility.Remove(stateMachine.Nodes, anyState); FsmEditorUtility.DestroyImmediate(anyState); FsmEditor.SelectedNodes.Clear(); } } for (int i = 0; i < copiedNodes.Count; i++) { Node mNode = copiedNodes[i]; foreach (Transition transition in mNode.Transitions) { Node toNode = copiedNodes.Find(x => x.Name == transition.ToNode.Name) ?? stateMachine.Nodes.ToList().Find(x => x.Name == transition.ToNode.Name); if (toNode != null) { transition.ToNode = toNode; } else { FsmEditorUtility.DestroyImmediate(transition); mNode.Transitions = ArrayUtility.Remove(mNode.Transitions, transition); } } } for (int i = 0; i < copiedNodes.Count; i++) { Node mNode = stateMachine.Nodes.ToList().Find(x => x.Name == copiedNodes[i].Name && x != copiedNodes[i]); if (mNode != null) { copiedNodes[i].Name = FsmEditorUtility.GenerateUniqueNodeName(copiedNodes[i].GetType(), stateMachine); } } FsmEditorUtility.ParentChilds(stateMachine); nodes.Clear(); EditorUtility.SetDirty(stateMachine); ErrorChecker.CheckForErrors(); }
private void ResetConditionList() { if (transition == null) { return; } this.conditions = this.transition.Conditions; this.conditionList = new ReorderableList(this.conditions, "Condition", true, true) { drawElementCallback = new ReorderableList.ElementCallbackDelegate(this.OnConditionElement), onReorderCallback = new ReorderableList.ReorderCallbackDelegate(this.OnReorderConditionList), onAddCallback = new ReorderableList.AddCallbackDelegate(delegate(){ FsmGUIUtility.SubclassMenu <Condition> (CreateCondition); }), onContextClick = new ReorderableList.ContextCallbackDelegate(delegate(int index){ FsmGUIUtility.ExecutableContextMenu(conditions[index], node).ShowAsContext(); }), onHeaderClick = new ReorderableList.OnHeaderClick(delegate(){ GenericMenu menu = new GenericMenu(); if (conditions.Length > 0) { menu.AddItem(new GUIContent("Copy"), false, delegate { copy = transition; }); } else { menu.AddDisabledItem(new GUIContent("Copy")); } if (copy != null && copy.Conditions.Length > 0) { menu.AddItem(new GUIContent("Paste After"), false, delegate() { for (int i = 0; i < copy.Conditions.Length; i++) { ExecutableNode dest = FsmUtility.Copy(copy.Conditions[i]); transition.Conditions = ArrayUtility.Add <Condition>(transition.Conditions, (Condition)dest); FsmEditorUtility.ParentChilds(transition); NodeInspector.Dirty(); } }); menu.AddItem(new GUIContent("Paste Before"), false, delegate() { for (int i = 0; i < copy.Conditions.Length; i++) { ExecutableNode dest = FsmUtility.Copy(copy.Conditions[i]); transition.Conditions = ArrayUtility.Insert <Condition>(transition.Conditions, (Condition)dest, 0); FsmEditorUtility.ParentChilds(transition); NodeInspector.Dirty(); } }); if (copy != transition) { menu.AddItem(new GUIContent("Replace"), false, delegate() { for (int i = 0; i < transition.Conditions.Length; i++) { FsmEditorUtility.DestroyImmediate(transition.Conditions[i]); } transition.Conditions = new Condition[0]; ResetConditionList(); for (int i = 0; i < copy.Conditions.Length; i++) { ExecutableNode dest = FsmUtility.Copy(copy.Conditions[i]); transition.Conditions = ArrayUtility.Add <Condition>(transition.Conditions, (Condition)dest); FsmEditorUtility.ParentChilds(transition); NodeInspector.Dirty(); } }); } else { menu.AddDisabledItem(new GUIContent("Replace")); } } else { menu.AddDisabledItem(new GUIContent("Paste After")); menu.AddDisabledItem(new GUIContent("Paste Before")); menu.AddDisabledItem(new GUIContent("Replace")); } menu.ShowAsContext(); }), }; this.host.Repaint(); if (FsmEditor.instance != null) { FsmEditor.instance.Repaint(); } }
public static GenericMenu ExecutableContextMenu(ExecutableNode executable, Node node) { GenericMenu menu = new GenericMenu(); if (executable == null) { return(menu); } menu.AddItem(new GUIContent("Enable"), executable.IsEnabled, delegate() { executable.IsEnabled = !executable.IsEnabled; }); menu.AddSeparator(""); menu.AddItem(new GUIContent("Find Script"), false, delegate() { MonoScript[] monoScriptArray = (MonoScript[])Resources.FindObjectsOfTypeAll(typeof(MonoScript)); Selection.activeObject = monoScriptArray.ToList().Find(x => x.GetClass() == executable.GetType()); }); menu.AddItem(new GUIContent("Edit Script"), false, delegate() { MonoScript[] monoScriptArray = (MonoScript[])Resources.FindObjectsOfTypeAll(typeof(MonoScript)); Selection.activeObject = monoScriptArray.ToList().Find(x => x.GetClass() == executable.GetType()); AssetDatabase.OpenAsset(Selection.activeObject); }); menu.AddSeparator(""); bool moveDown = false; int currentIndex = -1; if (executable.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; currentIndex = Array.IndexOf(state.Actions, executable); moveDown = currentIndex + 1 < state.Actions.Length; } else { currentIndex = Array.IndexOf(FsmEditor.SelectedTransition.Conditions, executable); moveDown = currentIndex + 1 < FsmEditor.SelectedTransition.Conditions.Length; } if (currentIndex - 1 >= 0) { menu.AddItem(new GUIContent("Move Up"), false, delegate() { if (executable.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; state.Actions = ArrayUtility.MoveItem(state.Actions, currentIndex, currentIndex - 1); } else { FsmEditor.SelectedTransition.Conditions = ArrayUtility.MoveItem(FsmEditor.SelectedTransition.Conditions, currentIndex, currentIndex - 1); } NodeInspector.Dirty(); }); } else { menu.AddDisabledItem(new GUIContent("Move Up")); } if (moveDown) { menu.AddItem(new GUIContent("Move Down"), false, delegate() { if (executable.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; state.Actions = ArrayUtility.MoveItem(state.Actions, currentIndex, currentIndex + 1); } else { FsmEditor.SelectedTransition.Conditions = ArrayUtility.MoveItem(FsmEditor.SelectedTransition.Conditions, currentIndex, currentIndex + 1); } NodeInspector.Dirty(); }); } else { menu.AddDisabledItem(new GUIContent("Move Down")); } menu.AddSeparator(""); menu.AddItem(new GUIContent("Copy"), false, delegate() { executableCopy = executable; }); if (executableCopy != null) { menu.AddItem(new GUIContent("Paste After"), false, delegate() { ExecutableNode dest = FsmUtility.Copy(executableCopy); if (dest.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; state.Actions = ArrayUtility.Insert <StateAction>(state.Actions, (StateAction)dest, currentIndex + 1); } else { FsmEditor.SelectedTransition.Conditions = ArrayUtility.Insert <Condition>(FsmEditor.SelectedTransition.Conditions, (Condition)dest, currentIndex + 1); } FsmEditorUtility.ParentChilds(node); NodeInspector.Dirty(); }); menu.AddItem(new GUIContent("Paste Before"), false, delegate() { ExecutableNode dest = FsmUtility.Copy(executableCopy); if (dest.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; state.Actions = ArrayUtility.Insert <StateAction>(state.Actions, (StateAction)dest, currentIndex); } else { FsmEditor.SelectedTransition.Conditions = ArrayUtility.Insert <Condition>(FsmEditor.SelectedTransition.Conditions, (Condition)dest, currentIndex); } FsmEditorUtility.ParentChilds(node); NodeInspector.Dirty(); }); menu.AddItem(new GUIContent("Replace"), false, delegate() { ExecutableNode dest = FsmUtility.Copy(executableCopy); if (dest.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; FsmEditorUtility.DestroyImmediate(state.Actions[currentIndex]); state.Actions = ArrayUtility.RemoveAt <StateAction>(state.Actions, currentIndex); state.Actions = ArrayUtility.Insert <StateAction>(state.Actions, (StateAction)dest, currentIndex); } else { FsmEditorUtility.DestroyImmediate(FsmEditor.SelectedTransition.Conditions[currentIndex]); FsmEditor.SelectedTransition.Conditions = ArrayUtility.RemoveAt <Condition>(FsmEditor.SelectedTransition.Conditions, currentIndex); FsmEditor.SelectedTransition.Conditions = ArrayUtility.Insert <Condition>(FsmEditor.SelectedTransition.Conditions, (Condition)dest, currentIndex); } FsmEditorUtility.ParentChilds(node); NodeInspector.Dirty(); }); } else { menu.AddDisabledItem(new GUIContent("Paste After")); menu.AddDisabledItem(new GUIContent("Paste Before")); menu.AddDisabledItem(new GUIContent("Replace")); } menu.AddSeparator(""); menu.AddItem(new GUIContent("Remove"), false, delegate() { if (executable.GetType().IsSubclassOf(typeof(StateAction))) { State state = node as State; state.Actions = ArrayUtility.Remove <StateAction> (state.Actions, (StateAction)executable); } else { FsmEditor.SelectedTransition.Conditions = ArrayUtility.Remove <Condition>(FsmEditor.SelectedTransition.Conditions, (Condition)executable); } FsmEditorUtility.DestroyImmediate(executable); NodeInspector.Dirty(); }); return(menu); }
private void ResetActionList() { SerializedObject obj = new SerializedObject(state); SerializedProperty elements = obj.FindProperty("actions"); actionList = new ReorderableObjectList(obj, elements); actionList.drawHeaderCallback = delegate(Rect rect) { EditorGUI.LabelField(rect, "Actions"); }; actionList.onAddCallback = delegate(ReorderableObjectList list) { FsmGUIUtility.SubclassMenu <StateAction> (delegate(Type type){ StateAction action = (StateAction)ScriptableObject.CreateInstance(type); action.name = type.GetCategory() + "." + type.Name; action.hideFlags = HideFlags.HideInHierarchy; state.Actions = ArrayUtility.Add <StateAction> (state.Actions, action); if (EditorUtility.IsPersistent(state)) { AssetDatabase.AddObjectToAsset(action, state); AssetDatabase.SaveAssets(); } list.index = list.count; EditorUtility.SetDirty(state); }); }; actionList.drawElementCallback = delegate(int index, bool selected) { StateAction action = state.Actions [index]; bool enabled = action.IsEnabled; if (selected) { GUIStyle selectBackground = new GUIStyle("MeTransitionSelectHead") { stretchHeight = false, }; selectBackground.overflow = new RectOffset(-1, -2, -2, 2); GUILayout.BeginVertical(selectBackground); } action.IsOpen = GUIDrawer.ObjectTitlebar(action, action.IsOpen, ref enabled, FsmGUIUtility.ExecutableContextMenu(action, state)); if (selected) { GUILayout.EndVertical(); } action.IsEnabled = enabled; if (action.IsOpen) { GUIDrawer.OnGUI(action); } }; actionList.onRemoveCallback = delegate(ReorderableObjectList list) { StateAction action = state.Actions[list.index]; state.Actions = ArrayUtility.Remove <StateAction> (state.Actions, action); FsmEditorUtility.DestroyImmediate(action); list.index = list.index - 1; ErrorChecker.CheckForErrors(); EditorUtility.SetDirty(state); }; actionList.onContextClick = delegate(int index) { FsmGUIUtility.ExecutableContextMenu(state.Actions [index], state).ShowAsContext(); }; actionList.onHeaderContextClick = delegate() { GenericMenu menu = new GenericMenu(); if (state.Actions.Length > 0) { menu.AddItem(new GUIContent("Copy"), false, delegate { copy = new List <StateAction>(state.Actions); copyState = state; }); } else { menu.AddDisabledItem(new GUIContent("Copy")); } if (copy == null) { copy = new List <StateAction>(); } copy.RemoveAll(x => x == null); if (copy.Count > 0) { menu.AddItem(new GUIContent("Paste After"), false, delegate() { for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Add <StateAction>(state.Actions, (StateAction)dest); FsmEditorUtility.ParentChilds(state); EditorUtility.SetDirty(state); // NodeInspector.Dirty(); ErrorChecker.CheckForErrors(); } }); menu.AddItem(new GUIContent("Paste Before"), false, delegate() { for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Insert <StateAction>(state.Actions, (StateAction)dest, 0); FsmEditorUtility.ParentChilds(state); EditorUtility.SetDirty(state); // NodeInspector.Dirty(); ErrorChecker.CheckForErrors(); } }); if (copyState != state) { menu.AddItem(new GUIContent("Replace"), false, delegate() { for (int i = 0; i < state.Actions.Length; i++) { FsmEditorUtility.DestroyImmediate(state.Actions[i]); } state.Actions = new StateAction[0]; ResetActionList(); for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Add <StateAction>(state.Actions, (StateAction)dest); FsmEditorUtility.ParentChilds(state); EditorUtility.SetDirty(state); // NodeInspector.Dirty(); ErrorChecker.CheckForErrors(); } }); } else { menu.AddDisabledItem(new GUIContent("Replace")); } } else { menu.AddDisabledItem(new GUIContent("Paste After")); menu.AddDisabledItem(new GUIContent("Paste Before")); menu.AddDisabledItem(new GUIContent("Replace")); } menu.ShowAsContext(); }; this.host.Repaint(); if (FsmEditor.instance != null) { FsmEditor.instance.Repaint(); } }
public void ResetTransitionList() { SerializedObject obj = new SerializedObject(node); SerializedProperty elements = obj.FindProperty("transitions"); transitionList = new ReorderableObjectList(obj, elements); transitionList.drawHeaderCallback = delegate(Rect rect) { EditorGUI.LabelField(rect, "Transitions"); EditorGUI.LabelField(new Rect(rect.width - 25, rect.y, 50, 20), "Mute"); }; transitionList.onSelectCallback = delegate(int index) { if (node.Transitions.Length > 0) { FsmEditor.SelectTransition(this.node.Transitions[index]); this.ResetConditionList(); } }; transitionList.onRemoveCallback = delegate(ReorderableObjectList list) { Transition transition = node.Transitions[list.index]; node.Transitions = ArrayUtility.Remove(node.Transitions, transition); FsmEditorUtility.DestroyImmediate(transition); list.index = Mathf.Clamp(list.index - 1, 0, list.count - 1); ErrorChecker.CheckForErrors(); EditorUtility.SetDirty(node); }; transitionList.drawElementCallback = delegate(int index, bool selected) { Transition transition = node.Transitions [index]; if (selected) { GUIStyle selectBackground = new GUIStyle("MeTransitionSelectHead") { stretchHeight = false, }; selectBackground.overflow = new RectOffset(-1, -2, -2, 2); GUILayout.BeginVertical(selectBackground); } GUILayout.BeginHorizontal(); for (int i = 0; i < transition.Conditions.Length; i++) { Condition condition = transition.Conditions[i]; if (ErrorChecker.HasErrors(condition)) { GUILayout.Label(FsmEditorStyles.errorIcon); break; } } GUILayout.Label(transition.FromNode.Name + " -> " + transition.ToNode.Name, selected?EditorStyles.whiteLabel:EditorStyles.label); GUILayout.FlexibleSpace(); transition.Mute = GUILayout.Toggle(transition.Mute, GUIContent.none, GUILayout.Width(15)); GUILayout.Space(22f); GUILayout.EndHorizontal(); if (selected) { GUILayout.EndVertical(); } }; transitionList.onReorderCallback = delegate(ReorderableObjectList list) { FsmEditor.SelectTransition(this.node.Transitions[list.index]); this.ResetConditionList(); }; transitionList.onContextClick = delegate(int index) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Remove"), false, delegate() { Transition transition = node.Transitions[index]; node.Transitions = ArrayUtility.Remove(node.Transitions, transition); FsmEditorUtility.DestroyImmediate(transition); transitionList.index = Mathf.Clamp((index == transitionList.index?index - 1:(index < transitionList.index?transitionList.index - 1:transitionList.index)), 0, node.Transitions.Length - 1); ErrorChecker.CheckForErrors(); EditorUtility.SetDirty(node); }); menu.ShowAsContext(); }; this.ResetConditionList(); this.host.Repaint(); if (FsmEditor.instance != null) { FsmEditor.instance.Repaint(); } }
private void DestroyActive() { FsmEditorUtility.DestroyImmediate(active); }
private void ResetActionList() { this.actions = this.state.Actions; this.actionList = new ReorderableList(this.actions, "Action", true, true) { drawElementCallback = new ReorderableList.ElementCallbackDelegate(this.OnActionElement), onReorderCallback = new ReorderableList.ReorderCallbackDelegate(this.OnReorderList), onAddCallback = new ReorderableList.AddCallbackDelegate(delegate(){ FsmGUIUtility.SubclassMenu <StateAction> (CreateAction); }), onContextClick = new ReorderableList.ContextCallbackDelegate(delegate(int index){ FsmGUIUtility.ExecutableContextMenu(actions[index], state).ShowAsContext(); }), onHeaderClick = new ReorderableList.OnHeaderClick(delegate(){ GenericMenu menu = new GenericMenu(); if (actions.Length > 0) { menu.AddItem(new GUIContent("Copy"), false, delegate { copy = new List <StateAction>(actions); copyState = state; }); } else { menu.AddDisabledItem(new GUIContent("Copy")); } if (copy == null) { copy = new List <StateAction>(); } copy.RemoveAll(x => x == null); if (copy.Count > 0) { menu.AddItem(new GUIContent("Paste After"), false, delegate() { for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Add <StateAction>(state.Actions, (StateAction)dest); FsmEditorUtility.ParentChilds(state); NodeInspector.Dirty(); } }); menu.AddItem(new GUIContent("Paste Before"), false, delegate() { for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Insert <StateAction>(state.Actions, (StateAction)dest, 0); FsmEditorUtility.ParentChilds(state); NodeInspector.Dirty(); } }); if (copyState != state) { menu.AddItem(new GUIContent("Replace"), false, delegate() { for (int i = 0; i < state.Actions.Length; i++) { FsmEditorUtility.DestroyImmediate(state.Actions[i]); } state.Actions = new StateAction[0]; ResetActionList(); for (int i = 0; i < copy.Count; i++) { ExecutableNode dest = FsmUtility.Copy(copy[i]); state.Actions = ArrayUtility.Add <StateAction>(state.Actions, (StateAction)dest); FsmEditorUtility.ParentChilds(state); NodeInspector.Dirty(); } }); } else { menu.AddDisabledItem(new GUIContent("Replace")); } } else { menu.AddDisabledItem(new GUIContent("Paste After")); menu.AddDisabledItem(new GUIContent("Paste Before")); menu.AddDisabledItem(new GUIContent("Replace")); } menu.ShowAsContext(); }), }; this.host.Repaint(); if (FsmEditor.instance != null) { FsmEditor.instance.Repaint(); } }
private void DrawVariables() { scroll = GUILayout.BeginScrollView(scroll); Dictionary <string, List <FsmVariable> > groupParameters = GetGroupVariables(); EditorGUIUtility.labelWidth = 110; foreach (var kvp in groupParameters) { bool foldout = EditorPrefs.GetBool(kvp.Key, false); bool state = EditorGUILayout.Foldout(foldout, kvp.Key); if (state != foldout) { EditorPrefs.SetBool(kvp.Key, state); } if (foldout) { for (int i = 0; i < groupParameters[kvp.Key].Count; i++) { FsmVariable parameter = groupParameters[kvp.Key][i]; if (parameter != null) { SerializedObject paramObject = new SerializedObject(parameter); SerializedProperty prop = paramObject.FindProperty("value"); GUILayout.BeginHorizontal(); GUILayout.Space(16f); string name = paramObject.FindProperty("name").stringValue; if (parameter is FsmGameObject) { GUI.changed = false; FsmGameObject mParam = parameter as FsmGameObject; if (string.IsNullOrEmpty(mParam.ScenePath)) { mParam.Value = (GameObject)EditorGUILayout.ObjectField(name, mParam.Value, typeof(UnityEngine.GameObject), true); } else { GUILayout.Label(name, GUILayout.Width(106)); GUILayout.Label(mParam.ScenePath, FsmEditorStyles.wrappedLabelLeft); GUILayout.FlexibleSpace(); } if (GUI.changed) { if (!EditorUtility.IsPersistent(mParam.Value) && mParam.Value is GameObject) { string currentOpenScene = string.Empty; #if UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 currentOpenScene = EditorApplication.currentScene; #else currentOpenScene = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().name; #endif if (string.IsNullOrEmpty(currentOpenScene)) { EditorUtility.DisplayDialog("Save Scene!", "You need to save the scene before setting the GameObject.", "Ok"); mParam.Value = null; } else { #if UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 mParam.ScenePath = mParam.Value.name + "(" + EditorApplication.currentScene + ")"; #else mParam.ScenePath = mParam.Value.name + "(" + UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().path + ")"; #endif SetGlobalGameObject mSet = mParam.Value.GetComponent <SetGlobalGameObject>(); if (mSet == null) { mSet = mParam.Value.AddComponent <SetGlobalGameObject>(); } mSet.variableName = mParam.Name; } } EditorUtility.SetDirty(mParam); } } else { paramObject.Update(); if (prop != null) { EditorGUILayout.PropertyField(prop, new GUIContent(name), true); } paramObject.ApplyModifiedProperties(); } if (GUILayout.Button("down", EditorStyles.toolbarButton, GUILayout.Width(35))) { if (i < groupParameters[kvp.Key].Count) { int indexToMove = Array.FindIndex(globalVariables.Variables, x => x.Name == parameter.Name); globalVariables.Variables.Move(indexToMove, 0); EditorUtility.SetDirty(globalVariables); } } if (GUILayout.Button("up", EditorStyles.toolbarButton, GUILayout.Width(20))) { if (i > 0) { int indexToMove = Array.FindIndex(globalVariables.Variables, x => x.Name == parameter.Name); globalVariables.Variables.Move(indexToMove, 1); EditorUtility.SetDirty(globalVariables); } } if (GUILayout.Button(parameter.Group, EditorStyles.toolbarDropDown, GUILayout.Width(54))) { GenericMenu menu = new GenericMenu(); foreach (FsmVariable p in globalVariables.Variables) { string group = p.Group; FsmVariable mParam = parameter; menu.AddItem(new GUIContent(group), mParam.Group == group, delegate() { mParam.Group = group; }); } menu.ShowAsContext(); } if (GUILayout.Button(EditorGUIUtility.FindTexture("Toolbar Minus"), "label", GUILayout.Width(20))) { if (parameter is FsmGameObject) { string scenePath = (parameter as FsmGameObject).ScenePath; scenePath = scenePath.Substring(scenePath.IndexOf("(") + 1); scenePath = scenePath.Substring(0, scenePath.IndexOf(")")); #if UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 if (EditorApplication.currentScene != scenePath.Split('/').Last()) { EditorApplication.SaveScene(); EditorApplication.OpenScene(scenePath); } #else UnityEditor.SceneManagement.EditorSceneManager.SaveOpenScenes(); UnityEngine.SceneManagement.Scene scene = UnityEditor.SceneManagement.EditorSceneManager.OpenScene(scenePath); UnityEditor.SceneManagement.EditorSceneManager.SetActiveScene(scene); #endif List <SetGlobalGameObject> gos = FindObjectsOfType <SetGlobalGameObject>().ToList(); SetGlobalGameObject go = gos.Find(x => x.variableName == parameter.Name); if (go != null) { DestroyImmediate(go); } } globalVariables.Variables = ArrayUtility.Remove(globalVariables.Variables, parameter); FsmEditorUtility.DestroyImmediate(parameter);; EditorUtility.SetDirty(globalVariables); #if UNITY_4_6 || UNITY_4_7 || UNITY_5_0 || UNITY_5_1 || UNITY_5_2 EditorApplication.SaveScene(); #else UnityEditor.SceneManagement.EditorSceneManager.SaveOpenScenes(); #endif } GUILayout.EndHorizontal(); } } } } GUILayout.EndScrollView(); }
private void DrawVariables() { scroll = GUILayout.BeginScrollView(scroll); Dictionary <string, List <FsmVariable> > groupParameters = GetGroupVariables(); EditorGUIUtility.labelWidth = 110; foreach (var kvp in groupParameters) { bool foldout = EditorPrefs.GetBool(kvp.Key, false); bool state = EditorGUILayout.Foldout(foldout, kvp.Key); if (state != foldout) { EditorPrefs.SetBool(kvp.Key, state); } if (foldout) { for (int i = 0; i < groupParameters[kvp.Key].Count; i++) { FsmVariable parameter = groupParameters[kvp.Key][i]; if (parameter != null) { SerializedObject paramObject = new SerializedObject(parameter); SerializedProperty prop = paramObject.FindProperty("value"); GUILayout.BeginHorizontal(); GUILayout.Space(16f); string name = paramObject.FindProperty("name").stringValue; if (parameter is FsmGameObject) { GUI.changed = false; FsmGameObject mParam = parameter as FsmGameObject; if (string.IsNullOrEmpty(mParam.ScenePath)) { mParam.Value = (GameObject)EditorGUILayout.ObjectField(name, mParam.Value, typeof(UnityEngine.GameObject), true); } else { GUILayout.Label(name, GUILayout.Width(106)); GUILayout.Label(mParam.ScenePath, FsmEditorStyles.wrappedLabelLeft); GUILayout.FlexibleSpace(); } if (GUI.changed) { if (!EditorUtility.IsPersistent(mParam.Value) && mParam.Value is GameObject) { mParam.ScenePath = mParam.Value.name + "(" + EditorApplication.currentScene + ")"; SetGlobalGameObject mSet = mParam.Value.GetComponent <SetGlobalGameObject>(); if (mSet == null) { mSet = mParam.Value.AddComponent <SetGlobalGameObject>(); } mSet.variableName = mParam.Name; } EditorUtility.SetDirty(mParam); } } else { paramObject.Update(); if (prop != null) { EditorGUILayout.PropertyField(prop, new GUIContent(name), true); } paramObject.ApplyModifiedProperties(); } if (GUILayout.Button("down", EditorStyles.toolbarButton, GUILayout.Width(35))) { if (i < groupParameters[kvp.Key].Count) { int indexToMove = Array.FindIndex(globalVariables.Variables, x => x.Name == parameter.Name); globalVariables.Variables.Move(indexToMove, 0); EditorUtility.SetDirty(globalVariables); } } if (GUILayout.Button("up", EditorStyles.toolbarButton, GUILayout.Width(20))) { if (i > 0) { int indexToMove = Array.FindIndex(globalVariables.Variables, x => x.Name == parameter.Name); globalVariables.Variables.Move(indexToMove, 1); EditorUtility.SetDirty(globalVariables); } } if (GUILayout.Button(parameter.Group, EditorStyles.toolbarDropDown, GUILayout.Width(54))) { GenericMenu menu = new GenericMenu(); foreach (FsmVariable p in globalVariables.Variables) { string group = p.Group; FsmVariable mParam = parameter; menu.AddItem(new GUIContent(group), mParam.Group == group, delegate() { mParam.Group = group; }); } menu.ShowAsContext(); } if (GUILayout.Button(EditorGUIUtility.FindTexture("Toolbar Minus"), "label", GUILayout.Width(20))) { globalVariables.Variables = ArrayUtility.Remove(globalVariables.Variables, parameter); FsmEditorUtility.DestroyImmediate(parameter);; EditorUtility.SetDirty(globalVariables); } GUILayout.EndHorizontal(); } } } } GUILayout.EndScrollView(); }