private void DrawTransitions() { Handles.BeginGUI(); foreach (LZFighterStateTransition t in GetCurrentTransitions()) { StateMachineNode source = machine[t.source]; StateMachineNode target = machine[t.target]; Vector2 startP = source.nodeRect.center; Vector2 endP = target.nodeRect.center; Vector2 dir = endP - startP; Vector2 rotatedDir = dir.normalized.Rotated(90); startP += rotatedDir * 7; endP += rotatedDir * 7; if (selectedTransitions.Contains(t) && selectedType == SELECTED_TYPE.TRANSITION) { Handles.color = Color.cyan; } else { Handles.color = Color.white; } Handles.DrawLine(startP, endP); GUITools.DrawArrow(startP + dir / 2f + dir.normalized * 5f, dir.normalized); Handles.color = Color.white; } if (state == STATE.MAKING_TRANSITION) { Handles.DrawLine(transitionStart.nodeRect.position + transitionStart.nodeRect.size / 2f, Event.current.mousePosition); } Handles.EndGUI(); }
private void DrawShortcut(StateMachineNode node) { StateMachineNode target = fighter.stateMachine.states[node.Target]; node.name = target.name; DrawState(target); }
private void OnClickAddNode(Vector2 mousePosition, LZFighter fighter) { /*string path = AssetDatabase.GetAssetPath(fighter); * string filename = Path.GetFileNameWithoutExtension(path); * string directory = Path.GetDirectoryName(path); * if (!AssetDatabase.IsValidFolder(directory + "/" + filename)) { * AssetDatabase.CreateFolder(directory, filename); * }*/ StateMachineNode newState = new StateMachineNode(); newState.nodeRect.position = mousePosition; int id = machine.states.Add(newState); if (treePath.Count > 0) { StateMachineNode parent = machine.states[treePath[treePath.Count - 1]]; newState.parent = treePath[treePath.Count - 1]; parent.containedNodes.Add(id); if (parent.containedNodes.Count == 1) { parent.startState = id; } } /*AssetDatabase.CreateAsset(newState, directory + "/" + filename + "/" + fighter.states.Count + ".asset"); * Debug.Log(Path.GetDirectoryName(path));*/ }
/// <summary>Triggers a transition to a new state via a specified link.</summary> /// <param name="node">The state node to transition to.</param> /// <param name="link">The link which triggered this new state.</param> public void Transition(StateMachineNode node, StateMachineLink link) { var e = new TransitionEventArgs(this.currentNode, node, link); nodeTime = 0f; this.currentNode = node; OnTransition?.Invoke(this, e); }
public void GenerateData(StateMachineNode stateMachineNode, Dictionary <StateNodeUI, State> stateMap) { if (ExitConnections.Count > 0) { stateMachineNode.EntryState = stateMap[(StateNodeUI)ExitConnections[0].Destination]; } else if (stateMap.Count > 0) { stateMachineNode.EntryState = stateMap.Values.ElementAt(0); } }
public void ProcessEvents(StateMachineNode fighterState) { Event ev = Event.current; Rect rect = new Rect(Vector2.zero, fighterState.nodeRect.size); switch (ev.type) { case EventType.MouseDown: if (ev.button == 0 && rect.Contains(ev.mousePosition)) { if (ev.clickCount > 1) { int index = machine.states.FindIndex((s) => s == fighterState); treePath.Add(index); if (OnNodeSelected != null) { OnNodeSelected.Invoke(index); } ev.Use(); return; } fighterState.isDragged = true; selectedType = SELECTED_TYPE.STATE; if (!ev.shift) { selectedStates.Clear(); } selectedTransitions.Clear(); selectedStates.Add(fighterState); hasSelected = true; ev.Use(); LZFighterEditor.RepaintWindow(); GUI.FocusControl("Node"); } if (ev.button == 1) { BeginTransition(fighterState); ev.Use(); } break; case EventType.MouseUp: if (state == STATE.MAKING_TRANSITION) { Debug.Log("Making transition between " + transitionStart.name + " and " + fighterState.name); EndTransition(fighterState); ev.Use(); } break; } }
/// <summary>Link two states together with a simple test function.</summary> /// <param name="a">The state to transition from.</param> /// <param name="b">The linked state to transition to.</param> /// <param name="test"></param> public void LinkNodes(StateMachineNode a, StateMachineNode b, StateMachineLink.TestDelegate test) { if (a == b) { throw new NotSupportedException("Cannot link a node to itself."); } if (!Nodes.Contains(a) || !Nodes.Contains(b)) { throw new NotSupportedException("Cannot link nodes that are not contained within the state machine."); } var link = new StateMachineLink(b, test); a.Links.Add((b, link)); }
private void OnClickAddShortcut(Vector2 mousePosition, int state) { StateMachineNode newState = new StateMachineNode(true, state); newState.name = machine.states[state].name; newState.nodeRect.position = mousePosition; int id = machine.states.Add(newState); if (treePath.Count > 0) { newState.parent = treePath[treePath.Count - 1]; machine.states[treePath.Count - 1].containedNodes.Add(id); } }
private void EndTransition(StateMachineNode end) { state = STATE.IDLE; LZFighterStateTransition newTransition = new LZFighterStateTransition(); newTransition.source = machine.states.FindIndex((s) => s == transitionStart); newTransition.target = machine.states.FindIndex((s) => s == end); if (newTransition.source != newTransition.target && machine.transitions.Find((t) => t.source == newTransition.source && t.target == newTransition.target) == null) { machine.transitions.Add(newTransition); } LZFighterEditor.RepaintWindow(); }
public void DrawState(StateMachineNode state) { if (state.IsShortcut) { DrawShortcut(state); return; } LabelTitle(state.name); state.data = (LZFighterStateData)EditorGUILayout.ObjectField(state.data, typeof(LZFighterStateData), false); if (state.data != null && state.name == "") { state.name = state.data.name; } // Edit instance if (GUILayout.Button("Edit")) { if (state.data == null) { LZFighter fighter = LZFighterEditor.Instance.fighter; string path = AssetDatabase.GetAssetPath(fighter); string filename = Path.GetFileNameWithoutExtension(path); string directory = Path.GetDirectoryName(path); if (!AssetDatabase.IsValidFolder(directory + "/" + filename)) { AssetDatabase.CreateFolder(directory, filename); } LZFighterStateData newData = ScriptableObject.CreateInstance <LZFighterStateData>(); AssetDatabase.CreateAsset(newData, directory + "/" + filename + "/" + state.name + ".asset"); Debug.Log(Path.GetDirectoryName(path)); state.data = newData; } LZFighterStateEditor.Open(state.data); } string currentName = state.name; string newName = EditorGUILayout.TextField("Name:", currentName); /*if (currentName != newName && state.data != null) { * AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(state.data), newName); * }*/ state.name = newName; state.velocity = EditorGUILayout.Vector2Field("StateVelocity: ", state.velocity); if (state.data != null) { state.data.velocity = EditorGUILayout.Vector2Field("DataVelocity:", state.data.velocity); } state.invert = EditorGUILayout.Toggle("Invert", state.invert); state.loop = EditorGUILayout.Toggle("Loop", state.loop); GUITools.ScriptListField(state.scripts, fighter); }
public void Update(GameTime gameTime) { if (!Enabled) { return; } nodeTime += (float)gameTime.ElapsedGameTime.TotalSeconds; StateMachineNode t = null; do { t = currentNode?.TryTransition(this); } while (t != null); currentNode.Update(new StateUpdateEventArgs(this, gameTime)); }
/// <summary>Add a link to a state.</summary> /// <param name="a">The state to transition from.</param> /// <param name="link">The link defining the transition.</param> public void LinkNodes(StateMachineNode a, StateMachineLink link) { LinkNodes(a, link.Target, link); }
public TransitionEventArgs(StateMachineNode from, StateMachineNode to, StateMachineLink link) : base() { this.from = from; this.to = to; this.link = link; }
private void SaveStateMachine() { var stateMachine = new StateMachineNode(); NodeUI.StateMachineNodeAsset = new StateMachineNodeAsset { Data = stateMachine }; var parameterMap = new Dictionary <ParameterNodeUI, Parameter>(); var stateMap = new Dictionary <StateNodeUI, State>(); var anyStateMap = new Dictionary <AnyStateNodeUI, AnyState>(); var transitionMap = new Dictionary <TransitionInfo, Transition>(); Parameters.Items.Values.ForEach(p => { var parameter = stateMachine.AddParameter(p.Name); parameter.Type = (ValueProviderType)p.ParameterTypeField.value; NodeUI.StateMachineNodeAsset.ParameterMap.Add(parameter.Id, new NodeVisualInfo(p.GetPosition().position, p.expanded)); switch (parameter.ValueProvider) { case BoolProvider boolProvider: boolProvider.Value = p.BoolField.value; break; case IntProvider intProvider: intProvider.Value = p.IntField.value; break; case FloatProvider floatProvider: floatProvider.Value = p.FloatField.value; break; default: break; } parameterMap.Add(p, parameter); }); TransitionConnections.ForEach(transitionConnection => { transitionConnection.Transitions.ForEach(transitionInfo => { Transition transition = new Transition() { DurationType = transitionInfo.DurationType, Duration = transitionInfo.Duration, OffsetType = transitionInfo.OffsetType, Offset = transitionInfo.Offset, InterruptionSource = transitionInfo.InterruptionSource, OrderedInterruption = transitionInfo.OrderedInterruption, InterruptableByAnyState = transitionInfo.InterruptableByAnyState, PlayAfterTransition = transitionInfo.PlayAfterTransition }; stateMachine.Transitions.Add(transition); transitionMap.Add(transitionInfo, transition); }); }); States.Items.Values.ForEach(stateNode => { var state = stateMachine.AddState(stateNode.Name); stateNode.ExitConnections.ForEach(connection => { ((TransitionConnectionUI)connection).Transitions.ForEach(transitionInfo => { Transition transition = transitionMap[transitionInfo]; transition.SourceState = state; state.ExitTransitions.Add(transition); }); }); stateNode.EntryConnections.ForEach(connection => { if (!(connection is TransitionConnectionUI transitionConnection)) { return; } transitionConnection.Transitions.ForEach(transitionInfo => { Transition transition = transitionMap[transitionInfo]; transition.DestinationState = state; state.EntryTransitions.Add(transition); }); }); NodeUI.StateMachineNodeAsset.StateMap.Add(state.Id, new NodeVisualInfo(stateNode.GetPosition().position, stateNode.expanded)); stateMap.Add(stateNode, state); }); HashSet <AnyStateNodeUI> alreadyAddedAnyStates = new HashSet <AnyStateNodeUI>(); if (GraphView.AnyStatePriorityManager == null) { NodeUI.StateMachineNodeAsset.AnyStatePriorityManager = null; } else { NodeUI.StateMachineNodeAsset.AnyStatePriorityManager = new NodeVisualInfo(GraphView.AnyStatePriorityManager.GetPosition().position, GraphView.AnyStatePriorityManager.expanded); foreach (var anyStateNode in GraphView.AnyStatePriorityManager.AnyStates) { if (anyStateNode == null) { continue; } AnyState anyState = anyStateNode.GenerateData(stateMap); anyStateNode.ExitConnections.ForEach(connection => { ((TransitionConnectionUI)connection).Transitions.ForEach(transitionInfo => { Transition transition = transitionMap[transitionInfo]; transition.SourceState = anyState; anyState.ExitTransitions.Add(transition); }); }); stateMachine.AnyStates.AddItem(anyState); NodeUI.StateMachineNodeAsset.AnyStateMap.Add(anyState.Id, new NodeVisualInfo(anyStateNode.GetPosition().position, anyStateNode.expanded)); alreadyAddedAnyStates.Add(anyStateNode); anyStateMap.Add(anyStateNode, anyState); } } AnyStates.Items.Values.ForEach(anyStateNode => { if (alreadyAddedAnyStates.Contains(anyStateNode)) { return; } AnyState anyState = anyStateNode.GenerateData(stateMap); anyStateNode.ExitConnections.ForEach(connection => { ((TransitionConnectionUI)connection).Transitions.ForEach(transitionInfo => { Transition transition = transitionMap[transitionInfo]; transition.SourceState = anyState; anyState.ExitTransitions.Add(transition); }); }); stateMachine.AnyStates.AddItem(anyState); NodeUI.StateMachineNodeAsset.AnyStateMap.Add(anyState.Id, new NodeVisualInfo(anyStateNode.GetPosition().position, anyStateNode.expanded)); anyStateMap.Add(anyStateNode, anyState); }); TransitionConnections.ForEach(transitionConnection => { transitionConnection.Transitions.ForEach(transitionInfo => { Transition transition = transitionMap[transitionInfo]; transition.Conditions.Capacity = transitionInfo.Conditions.Count; transitionInfo.Conditions.ForEach(infoCondition => { TransitionCondition condition = new TransitionCondition(); if (infoCondition.ProviderSourceType == ValueProviderSourceType.State) { if (infoCondition.State != null) { State state = stateMap[infoCondition.State]; switch (infoCondition.StateValueProvider) { case StateValueProviders.PreviousTime: condition.SetValueProvider(state.PreviousTime); break; case StateValueProviders.Time: condition.SetValueProvider(state.Time); break; case StateValueProviders.PreviousNormalizedTime: condition.SetValueProvider(state.PreviousNormalizedTime); break; case StateValueProviders.NormalizedTime: condition.SetValueProvider(state.NormalizedTime); break; } FloatConditionEvaluator floatEvaluator = (FloatConditionEvaluator)condition.Evaluator; floatEvaluator.Comparison = infoCondition.FloatComparison; floatEvaluator.ComparisonValue = infoCondition.FloatComparisonValue; } } else if (infoCondition.Parameter != null) { condition.SetValueProvider(parameterMap[infoCondition.Parameter].ValueProvider); switch (condition.Evaluator) { case BoolConditionEvaluator boolEvaluator: boolEvaluator.ComparisonValue = infoCondition.BoolComparisonValue ? Bool.True : Bool.False; break; case IntConditionEvaluator intEvaluator: intEvaluator.Comparison = infoCondition.IntComparison; intEvaluator.ComparisonValue = infoCondition.IntComparisonValue; break; case FloatConditionEvaluator floatEvaluator: floatEvaluator.Comparison = infoCondition.FloatComparison; floatEvaluator.ComparisonValue = infoCondition.FloatComparisonValue; break; default: break; } } transition.Conditions.Add(condition); }); }); }); GraphView.EntryNode.GenerateData(stateMachine, stateMap); NodeUI.StateMachineNodeAsset.EntryState = new NodeVisualInfo(GraphView.EntryNode.GetPosition().position, GraphView.EntryNode.expanded); NodeUI.UpdateStatePorts(); }
EmailSearchStateMaсhineWithUSM() { var nodes = new StateMachineNode <char> [9]; sb = new StringBuilder(); resultStrings = new List <FindedDataInfo>(); nodes[0] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // начало { new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[1] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // считывание логина { new StateMachineTransaction <char>(c => char.IsLetterOrDigit(c), c => { sb.Clear(); sb.Append(c); startPosition = position; }, 2), new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[2] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // достигли разделителя @ { new StateMachineTransaction <char>(c => c == '@', c => sb.Append(c), 3), new StateMachineTransaction <char>(c => char.IsLetterOrDigit(c) || IsEmailAllowSymbol(c) || c == '.', c => sb.Append(c), 2), new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[3] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // считывание первого домена { new StateMachineTransaction <char>(c => char.IsLetterOrDigit(c), c => sb.Append(c), 4), new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[4] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // достигли разделителя . { new StateMachineTransaction <char>(c => c == '.', c => sb.Append(c), 5), new StateMachineTransaction <char>(c => char.IsLetterOrDigit(c) || IsEmailAllowSymbol(c), c => sb.Append(c), 4), new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[5] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // считывание домена второго уровня { new StateMachineTransaction <char>(c => char.IsLetter(c), c => sb.Append(c), 6), new StateMachineTransaction <char>(c => char.IsNumber(c) || IsEmailAllowSymbol(c), c => sb.Append(c), 4), new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[6] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // считывание домена второго уровня { new StateMachineTransaction <char>(c => char.IsLetter(c), c => sb.Append(c), 7), new StateMachineTransaction <char>(c => char.IsNumber(c) || IsEmailAllowSymbol(c), c => sb.Append(c), 4), new StateMachineTransaction <char>(c => IsSeparator(c), null, 1), }, 0); nodes[7] = new StateMachineNode <char>(new StateMachineTransaction <char>[] // { new StateMachineTransaction <char>(c => c == '.', c => sb.Append(c), 5), new StateMachineTransaction <char>(c => IsSeparator(c), c => { ApplySearchResult(); }, 1), new StateMachineTransaction <char>(c => char.IsLetter(c), c => sb.Append(c), 7), new StateMachineTransaction <char>(c => char.IsNumber(c) || IsEmailAllowSymbol(c), c => sb.Append(c), 4), }, 0); stateMachine = new UniversalStateMachine <char>(nodes); }
private void DoConvert() { var oldGraph = target as IGraphData; IGraphData graphData = null; var graph = ScriptableObject.CreateInstance<UnityGraphData>(); if (oldGraph is ExternalStateMachineGraph) { graph.Graph = new StateMachineGraph(); } else if (oldGraph is ExternalSubsystemGraph) { graph.Graph = new StateMachineGraph(); } else { graph.Graph = new MVVMGraph(); } graphData = graph; graph.name = oldGraph.Name; graph.Identifier = oldGraph.Identifier; graph.Graph.Identifier = oldGraph.Identifier; // Convert all the nodes Dictionary<DiagramNode, DiagramNode> converted = new Dictionary<DiagramNode, DiagramNode>(); List<ConnectionData> connections = new List<ConnectionData>(); foreach (var oldNode in oldGraph.NodeItems.OfType<SceneManagerData>()) { var node = new SceneTypeNode { Identifier = oldNode.Identifier, Name = oldNode.Name }; //foreach (var item in oldNode.Transitions) //{ // node.ChildItems.Add(new SceneTransitionsReference() // { // Node = node, // Identifier = item.Identifier, // SourceIdentifier = item.CommandIdentifier, // }); // if (string.IsNullOrEmpty(item.ToIdentifier)) continue; // connections.Add(new ConnectionData(item.Identifier, item.ToIdentifier)); //} converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<SubSystemData>()) { var node = new SubsystemNode() { Identifier = oldNode.Identifier, Name = oldNode.Name }; converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<ComputedPropertyData>()) { var node = new ComputedPropertyNode() { Identifier = oldNode.Identifier, Name = oldNode.Name, PropertyType = oldNode.RelatedType }; foreach (var item in oldNode.DependantProperties) { connections.Add(new ConnectionData(item.Identifier, node.Identifier)); } foreach (var x in oldNode.DependantNodes) { foreach (var item in x.AllProperties) { if (x[item.Identifier]) { node.ChildItems.Add(new SubPropertiesReference() { SourceIdentifier = item.Identifier, Node = node, }); } } } converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<ElementData>()) { var node = new ElementNode() { Identifier = oldNode.Identifier, Name = oldNode.Name, }; if (!string.IsNullOrEmpty(oldNode.BaseIdentifier)) { connections.Add(new ConnectionData(oldNode.BaseIdentifier, oldNode.Identifier)); } foreach (var item in oldNode.Properties) { node.ChildItems.Add(new PropertiesChildItem() { Identifier = item.Identifier, Node = node, Name = item.Name, RelatedType = item.RelatedType }); } foreach (var item in oldNode.Collections) { node.ChildItems.Add(new CollectionsChildItem() { Identifier = item.Identifier, Name = item.Name, Node = node, RelatedType = item.RelatedType }); } foreach (var item in oldNode.Commands) { node.ChildItems.Add(new CommandsChildItem() { Identifier = item.Identifier, Name = item.Name, Node = node, RelatedType = item.RelatedType }); if (!string.IsNullOrEmpty(item.TransitionToIdentifier)) connections.Add(new ConnectionData(item.Identifier, item.TransitionToIdentifier)); } converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<ClassNodeData>()) { var node = new ElementNode() { Identifier = oldNode.Identifier, Name = oldNode.Name, }; if (!string.IsNullOrEmpty(oldNode.BaseIdentifier)) { connections.Add(new ConnectionData(oldNode.BaseIdentifier, oldNode.Identifier)); } foreach (var item in oldNode.Properties) { node.ChildItems.Add(new PropertiesChildItem() { Identifier = item.Identifier, Node = node, Name = item.Name, RelatedType = item.RelatedType }); } foreach (var item in oldNode.Collections) { node.ChildItems.Add(new CollectionsChildItem() { Identifier = item.Identifier, Name = item.Name, Node = node, RelatedType = item.RelatedType }); } converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<ViewData>()) { var node = new ViewNode() { Identifier = oldNode.Identifier, Name = oldNode.Name }; // TODO CONVERT INHERITANCE // Connect the scene property foreach (var sceneProperty in oldNode.SceneProperties) { connections.Add(new ConnectionData(sceneProperty.Identifier, node.ScenePropertiesInputSlot.Identifier)); } // TODO CONVERT BINDINGS converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<ViewComponentData>()) { var node = new ViewComponentNode() { Identifier = oldNode.Identifier, Name = oldNode.Name }; // TODO CONVERT INHERITANCE converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<EnumData>()) { var node = new EnumNode() { Identifier = oldNode.Identifier, Name = oldNode.Name }; foreach (var item in oldNode.EnumItems) { node.ChildItems.Add(new EnumChildItem() { Identifier = item.Identifier, Node = node, Name = item.Name }); } converted.Add(oldNode, node); //Debug.Log(string.Format("Converted {0}", oldNode.Name)); } foreach (var oldNode in oldGraph.NodeItems.OfType<StateMachineNodeData>()) { var node = new StateMachineNode() { Identifier = oldNode.Identifier, Name = oldNode.Name }; if (oldNode.StartState != null) { connections.Add(new ConnectionData(node.StartStateOutputSlot.Identifier, oldNode.StartState.Identifier)); } foreach (var transition in oldNode.Transitions) { node.ChildItems.Add(new TransitionsChildItem() { Name = transition.Name, Identifier = transition.Identifier, Node = node, }); connections.Add(new ConnectionData(transition.PropertyIdentifier, transition.Identifier)); //connections.Add(); } connections.Add(new ConnectionData(oldNode.StatePropertyIdentifier, oldNode.Identifier)); converted.Add(oldNode, node); } foreach (var oldNode in oldGraph.NodeItems.OfType<StateMachineStateData>()) { var node = new StateNode() { Identifier = oldNode.Identifier, Name = oldNode.Name }; foreach (var transition in oldNode.Transitions) { node.ChildItems.Add(new StateTransitionsReference() { Name = transition.Name, Identifier = transition.Identifier, Node = node, }); connections.Add(new ConnectionData(transition.Identifier, transition.TransitionToIdentifier)); } converted.Add(oldNode, node); } // Grab all the connections ConvertSubsystems(converted, connections); ConvertSceneManagers(converted, connections); ConvertElements(converted, connections); ConvertStateMachines(converted, connections); ConvertViews(converted, connections); foreach (var item in converted.Values) { graphData.AddNode(item); } foreach (var item in connections) { if (item == null) continue; if (item.OutputIdentifier == item.InputIdentifier) { continue; } graphData.AddConnection(item.OutputIdentifier, item.InputIdentifier); Debug.Log(string.Format("Added connection {0} - {1}", item.OutputIdentifier, item.InputIdentifier)); } // Reconstruct the filters var oldElementGraph = oldGraph as IGraphData; if (oldElementGraph != null) { foreach (var node in converted.Keys) { var newNOde = converted[node]; if (oldGraph.PositionData.HasPosition(oldGraph.RootFilter, node)) { graph.SetItemLocation(newNOde, oldGraph.GetItemLocation(node)); } } foreach (var item in oldElementGraph.PositionData.Positions) { graph.PositionData.Positions.Add(item.Key, item.Value); } } AssetDatabase.CreateAsset(graph, AssetDatabase.GetAssetPath(Selection.activeObject).Replace(".asset", "-new.asset")); AssetDatabase.SaveAssets(); }
public StateLeaveEventArgs(StateMachine parent, StateMachineNode next) : base() { this.parent = parent; this.next = next; }
/// <param name="target">StateMachineNode this link will transition to if the test condition passes.</param> /// <param name="test">Function for the test to perform to determine whether or not to transition to the linked state.</param> public StateMachineLink(StateMachineNode target, TestDelegate test) { this.Target = target; this.Test = test; }
private void BeginTransition(StateMachineNode start) { transitionStart = start; state = STATE.MAKING_TRANSITION; }
/// <summary>Add a unique state node to this StateMachine.</summary> /// <param name="node">The unique state node to add.</param> public void AddNode(StateMachineNode node) { Nodes.Add(node); }
public StateEnterEventArgs(StateMachine parent, StateMachineNode prev) : base() { this.parent = parent; this.prev = prev; }
/// <param name="target">StateMachineNode this link will transition to if the test condition passes.</param> public StateMachineLink(StateMachineNode target) { this.Target = target; }