private void DetectInput(Event e) { if (m_currentAIBehaviour == null && e.type == EventType.MouseDown) { EditorUtility.DisplayDialog("Error", "Generate or Assign AI Behaviour Data First", "OK"); return; } if (e.button == 1 && e.type == EventType.MouseDown) { m_isLinkingState = false; DetectIsClickedOnNode(e); CreateContextMenu(); } if (e.button == 0 && e.type == EventType.MouseDown && m_isLinkingState) { m_isLinkingState = false; if (m_selectedNode is TransitionNode) { TransitionNode _transitionNode = (TransitionNode)m_selectedNode; DetectIsClickedOnNode(e); if (m_selectedNode != null && m_selectedNode is StateNode) { _transitionNode.ToStateNode = (StateNode)m_selectedNode; ((StateNode)m_selectedNode).transitions_in.Add(_transitionNode); } } } }
private static void AssignStateToNextState(long transitionNodeId, ref NextAIState nextAIState) { TransitionNode _transitionNode = AIBehaviourEditor.GetNode(transitionNodeId) as TransitionNode; if (_transitionNode.ToStateNode != null) { switch (_transitionNode.ToStateNode.stateType) { case StateNode.StateType.Attack: { nextAIState.nextState = m_nodeIdToAttackStates[_transitionNode.ToStateNode.ID]; break; } case StateNode.StateType.Idle: { nextAIState.nextState = m_nodeIdToIdleStates[_transitionNode.ToStateNode.ID]; break; } case StateNode.StateType.Move: { nextAIState.nextState = m_nodeIdToMoveStates[_transitionNode.ToStateNode.ID]; break; } } } }
public void OnTransition(TransitionNode n) { foreach (var v in Nodes) { v.gameObject.SetActive(true); } n.gameObject.SetActive(false); }
//This is where we would do the preprocessing and data injection. public void PrintContent(TransitionNode node) { System.Threading.Thread.Sleep(250); var content = _processor.GetContentFileContents(node.ContentFilePath); if (content != null) { _printer.PrintContent(content); } }
public override int GetWidth() { TransitionNode asTransitionNode = target as TransitionNode; if (asTransitionNode != null) { collapsed = asTransitionNode.Collapsed; } return(collapsed ? 500 : 500); }
/// <summary> /// Removes transition editor node from metadata and state machine /// </summary> /// <param name="node"></param> /// <returns>true if the node was removed, false otherwise.</returns> public bool RemoveTransitionNode(TransitionNode node) { if (node == null) { return(false); } if (_transitionNodes.Remove(node)) { node.Asset.Destroy(); return(true); } return(false); }
// Update is called once per frame void Update() { RaycastHit ifo; if (Physics.Raycast(transform.position, transform.rotation * Vector3.forward, out ifo)) { if (ifo.collider.gameObject.tag == "TransitionNode") { TransitionNode node = ifo.collider.gameObject.GetComponent <TransitionNode> (); Debug.Log(ifo.collider.gameObject.name); node.OnTransition(); } } }
private void AddTranstionNode(Vector2 position, StateNode from) { CreateNodeInstance <TransitionNode>( delegate(BaseNode node) { TransitionNode _transitionNode = node as TransitionNode; _transitionNode.ID = m_currentID; _transitionNode.FromStateNode = from; _transitionNode.orgainHeight = 150f; Rect _windowRect = new Rect(new Vector2(position.x, position.y), new Vector2(200, 150)); _transitionNode.windowRect = _windowRect; ((StateNode)m_selectedNode).transitions_out.Add(_transitionNode); }); }
private char movement; //Movement of the tape //Constructor of the TransitionNode //We need a StateNode type variable which will be the destination node to the next state in the Turing Machine //String array named t contains the conditions for the transition in order to move to the next state and/or finish the Turing Machine public TransitionNode(StateNode destinationNode, string[] t) { destNode = destinationNode;//State destination node //Index on the array. What the number, character or letter represents. //2. What it is on the tape //3. What it will put on the tape //4. Movement of the tape charInTape = char.Parse(t[2]); repInTape = char.Parse(t[3]); movement = char.Parse(t[4]); //Reference to the next transition node, in case there is. This is asigned later nextTNode = null; }
public void UpdatePreviewData(TransitionNode node) { _previewDataModel.Clear(); _previewDataModel.Add(("Control+Alt+P", _contentFileProcessor.GetContentFileContents(node.ContentFilePath))); foreach (var t in node.Transitions) { var tNode = _definitionFileProcessor.ProcessDefinitionFile(t.DefFilePath); var tContent = _contentFileProcessor.GetContentFileContents(tNode.ContentFilePath); _previewDataModel.Add((t.Trigger, tContent)); } _previewDataModel.MarkUpdated(); }
public override void OnBodyGUI() { EditorGUIUtility.labelWidth = 120f; base.OnBodyGUI(); //End the current GUI Area that is restricted to node's dimensions GUILayout.EndArea(); Vector2 nodePos = NodeEditorWindow.current.GridToWindowPositionNoClipped(target.position); //Show Condition Preview below if collapsed if (collapsed) { Vector2 nodeLabelPos = NodeEditorWindow.current.GridToWindowPositionNoClipped(target.position + new Vector2(17f, 130f)); Vector2 topLeftPos = NodeEditorWindow.current.GridToWindowPositionNoClipped(target.position + new Vector2(0f, 110)); //Borders EditorGUI.DrawRect(new Rect(topLeftPos + new Vector2(5f, 0f), new Vector2(GetWidth() - 10, 300f)), new Color(80f / 255f, 46f / 255f, 50f / 255f, 1f)); //Text Area Rect textAreaRect = new Rect(topLeftPos + new Vector2(12f, 0f), new Vector2(GetWidth() - 25, 290f)); EditorGUI.DrawRect(textAreaRect, new Color(0, 0, 0, .9f)); //Condition Preview TransitionNode nodeAsTransition = target as TransitionNode; NodeEditorPreferences.Settings prefs = NodeEditorPreferences.GetSettings(); GUIStyle labelStyle = XNodeUtils.ZoomBasedStyle(18f, 45f, NodeEditorWindow.current.zoom, prefs.minZoom, prefs.maxZoom, new Color(1f, .85f, .85f), FontStyle.Normal); labelStyle.clipping = TextClipping.Clip; GUI.Label(textAreaRect, nodeAsTransition.ConditionPreview, labelStyle); } //Put back the GUI area that is restricted to node's dimensions GUILayout.BeginArea(new Rect(nodePos, new Vector2(GetWidth(), 4000))); }
/// <summary> /// Creates transition editor node alongside a StateTransitionAsset /// </summary> public TransitionNode AddTransitionNode(StateNode src, StateNode dst) { Argument.NotNull(src); Argument.NotNull(dst); if (src == dst) { throw new InvalidOperationException("Cannot create a transition from a state to itself"); } if (TransitionNodeExists(src, dst)) { throw new InvalidOperationException("Cannot create a transition that already exists"); } var asset = src.Asset.CreateTransition(dst.Asset); var node = new TransitionNode(asset); node.UpdateVectors(src, dst, true); _transitionNodes.Add(node); return(node); }
private void Start() { foreach (var tr in profile.transitions) { var node = new TransitionNode { transition = tr, }; _transitionList.Add(node); } foreach (var state in profile.states) { _stateTable.Add(Animator.StringToHash(state.stateName), state); _InitStateBehaviours(state.behaviours); foreach (var portion in state.allPortions) { _InitStateBehaviours(portion.behaviours); } } }
private void DrawLines() { for (int _nodeIndex = 0; _nodeIndex < m_currentAIBehaviour.nodeDatas.Count; _nodeIndex++) { if (m_currentAIBehaviour.nodeDatas[_nodeIndex] is TransitionNode) { TransitionNode _transitionNode = m_currentAIBehaviour.nodeDatas[_nodeIndex] as TransitionNode; if (_transitionNode.FromStateNode != null) { Handles.color = Color.black; Handles.DrawLine(_transitionNode.FromStateNode.OutPoint, _transitionNode.EnterPoint); DrawArrow(_transitionNode.FromStateNode.OutPoint, _transitionNode.EnterPoint, 15f, ArrowColor.Black); } if (_transitionNode.ToStateNode != null) { Handles.color = Color.red; Handles.DrawLine(_transitionNode.OutPoint, _transitionNode.ToStateNode.EnterPoint); DrawArrow(_transitionNode.OutPoint, _transitionNode.ToStateNode.EnterPoint, 15f, ArrowColor.Red); } } } }
public void setNextTNode(TransitionNode nextTNode) { this.nextTNode = nextTNode; }
public void addTransition(Enum currentState, TransitionRuleType transitionRule, Enum nextState, StateAction stateAction) { var node = new TransitionNode(currentState, transitionRule, nextState, stateAction); transitionsTable.Add(node); }
private void ContextCallbak(object action) { switch ((UserAction)action) { case UserAction.AddState: { AddStateNode(m_mousePosition); break; } case UserAction.AddTranstionNode: { AddTranstionNode(m_mousePosition, (StateNode)m_selectedNode); break; } case UserAction.DeleteNode: { if (m_selectedNode is TransitionNode) { TransitionNode _selectedTranstionNode = m_selectedNode as TransitionNode; if (_selectedTranstionNode.FromStateNode != null) { _selectedTranstionNode.FromStateNode.transitions_out.Remove(_selectedTranstionNode); } if (_selectedTranstionNode.ToStateNode != null) { _selectedTranstionNode.ToStateNode.transitions_in.Remove(_selectedTranstionNode); } } if (m_selectedNode is StateNode) { StateNode _selectedStateNode = m_selectedNode as StateNode; List <TransitionNode> _waitForRemoveTransitionNode = new List <TransitionNode>(); for (int i = 0; i < m_currentAIBehaviour.nodeDatas.Count; i++) { if (m_currentAIBehaviour.nodeDatas[i] is TransitionNode) { TransitionNode _transtionNode = m_currentAIBehaviour.nodeDatas[i] as TransitionNode; if (_transtionNode.ToStateNode != null && _transtionNode.ToStateNode.ID == _selectedStateNode.ID) { _transtionNode.ToStateNode = null; } if (_transtionNode.FromStateNode != null && _transtionNode.FromStateNode.ID == _selectedStateNode.ID) { _transtionNode.FromStateNode = null; } if (_transtionNode.ToStateNode == null && _transtionNode.FromStateNode == null) { _waitForRemoveTransitionNode.Add(_transtionNode); } } } for (int i = 0; i < _waitForRemoveTransitionNode.Count; i++) { m_currentAIBehaviour.nodeDatas.Remove(_waitForRemoveTransitionNode[i]); } } m_currentAIBehaviour.nodeDatas.Remove(m_selectedNode); m_selectedNode = null; break; } case UserAction.TranstionNodeLinkToStateNode: { m_isLinkingState = true; break; } } }
public static void Save(string savePath, AIBehaviourData aiBehaviour, Action <AIBehaviourData> onSaved = null) { if (Directory.Exists(savePath)) { List <BaseNode> _nodes = aiBehaviour.nodeDatas; string _statePath = savePath + "States/"; string _conditionPath = savePath + "Conditions/"; if (!Directory.Exists(_statePath)) { Directory.CreateDirectory(_statePath); } else { Directory.Delete(_statePath, true); Directory.CreateDirectory(_statePath); } if (!Directory.Exists(_conditionPath)) { Directory.CreateDirectory(_conditionPath); } else { Directory.Delete(_conditionPath, true); Directory.CreateDirectory(_conditionPath); } m_nodeIdToIdleStates = new Dictionary <long, IdleState>(); m_nodeIdToAttackStates = new Dictionary <long, AttackState>(); m_nodeIdToMoveStates = new Dictionary <long, MoveState>(); m_nodeIdToDistanceConditions = new Dictionary <long, List <DistanceCondition> >(); m_nodeIdToNearestIsConditions = new Dictionary <long, List <NearestIsCondition> >(); m_nodeIdToStatusConditions = new Dictionary <long, List <StatusCondition> >(); m_distanceConditionToConditionListIndex = new Dictionary <DistanceCondition, int>(); m_nearestIsConditionToConditionListIndex = new Dictionary <NearestIsCondition, int>(); m_statusConditionToConditionListIndex = new Dictionary <StatusCondition, int>(); m_allState = new List <AIStateBase>(); m_allCondition = new List <AIConditionBase>(); for (int i = 0; i < _nodes.Count; i++) { if (_nodes[i] is StateNode) { StateNode _stateNode = (StateNode)_nodes[i]; switch (_stateNode.stateType) { case StateNode.StateType.Idle: { CreateStateInstance(_statePath, _nodes[i].ID, ref m_nodeIdToIdleStates); break; } case StateNode.StateType.Attack: { CreateStateInstance(_statePath, _nodes[i].ID, ref m_nodeIdToAttackStates); break; } case StateNode.StateType.Move: { CreateStateInstance(_statePath, _nodes[i].ID, ref m_nodeIdToMoveStates); break; } } } if (_nodes[i] is TransitionNode) { TransitionNode _transitionNode = (TransitionNode)_nodes[i]; for (int _transitionDataIndex = 0; _transitionDataIndex < _transitionNode.transitionNodeDatas.Count; _transitionDataIndex++) { switch (_transitionNode.transitionNodeDatas[_transitionDataIndex].conditionType) { case TransitionNodeData.ConditionType.Distance: { CreateConditionInstance(_conditionPath, _nodes[i].ID, _transitionDataIndex, ref m_nodeIdToDistanceConditions, ref m_distanceConditionToConditionListIndex); break; } case TransitionNodeData.ConditionType.NearestIs: { CreateConditionInstance(_conditionPath, _nodes[i].ID, _transitionDataIndex, ref m_nodeIdToNearestIsConditions, ref m_nearestIsConditionToConditionListIndex); break; } case TransitionNodeData.ConditionType.Status: { CreateConditionInstance(_conditionPath, _nodes[i].ID, _transitionDataIndex, ref m_nodeIdToStatusConditions, ref m_statusConditionToConditionListIndex); break; } } } } } // Set Data foreach (KeyValuePair <long, IdleState> kvp in m_nodeIdToIdleStates) { AssignNextStatesToState(kvp.Key, kvp.Value); } foreach (KeyValuePair <long, AttackState> kvp in m_nodeIdToAttackStates) { StateNode _stateNode = AIBehaviourEditor.GetNode(kvp.Key) as StateNode; if (m_nodeIdToIdleStates.ContainsKey(_stateNode.defaultIdleStateNodeID)) { m_nodeIdToAttackStates[kvp.Key].SetData(m_nodeIdToAllStates[_stateNode.defaultIdleStateNodeID], _stateNode.attackTargetType); } else { m_nodeIdToAttackStates[kvp.Key].SetData(null, _stateNode.attackTargetType); } AssignNextStatesToState(kvp.Key, kvp.Value); } foreach (KeyValuePair <long, MoveState> kvp in m_nodeIdToMoveStates) { StateNode _stateNode = AIBehaviourEditor.GetNode(kvp.Key) as StateNode; if (m_nodeIdToIdleStates.ContainsKey(_stateNode.defaultIdleStateNodeID)) { m_nodeIdToMoveStates[kvp.Key].SetData(m_nodeIdToAllStates[_stateNode.defaultIdleStateNodeID], _stateNode.moveTargetType, _stateNode.detctRangeData); } else { m_nodeIdToMoveStates[kvp.Key].SetData(null, _stateNode.moveTargetType, _stateNode.detctRangeData); } AssignNextStatesToState(kvp.Key, kvp.Value); } foreach (KeyValuePair <long, List <DistanceCondition> > kvp in m_nodeIdToDistanceConditions) { TransitionNode _transitionNode = AIBehaviourEditor.GetNode(kvp.Key) as TransitionNode; for (int i = 0; i < kvp.Value.Count; i++) { int _index = m_distanceConditionToConditionListIndex[kvp.Value[i]]; kvp.Value[i].SetData(_transitionNode.transitionNodeDatas[_index].distanceConditionTarget, _transitionNode.transitionNodeDatas[_index].compareCondition, _transitionNode.transitionNodeDatas[_index].distance); } } foreach (KeyValuePair <long, List <NearestIsCondition> > kvp in m_nodeIdToNearestIsConditions) { TransitionNode _transitionNode = AIBehaviourEditor.GetNode(kvp.Key) as TransitionNode; for (int i = 0; i < kvp.Value.Count; i++) { int _index = m_nearestIsConditionToConditionListIndex[kvp.Value[i]]; kvp.Value[i].SetData(_transitionNode.transitionNodeDatas[_index].actorType); } } foreach (KeyValuePair <long, List <StatusCondition> > kvp in m_nodeIdToStatusConditions) { TransitionNode _transitionNode = AIBehaviourEditor.GetNode(kvp.Key) as TransitionNode; for (int i = 0; i < kvp.Value.Count; i++) { int _index = m_statusConditionToConditionListIndex[kvp.Value[i]]; kvp.Value[i].SetData(_transitionNode.transitionNodeDatas[_index].statusType, _transitionNode.transitionNodeDatas[_index].compareCondition, _transitionNode.transitionNodeDatas[_index].statusConditionTarget, _transitionNode.transitionNodeDatas[_index].value); } } // Set Dirty for (int i = 0; i < _nodes.Count; i++) { EditorUtility.SetDirty(_nodes[i]); } for (int i = 0; i < m_allState.Count; i++) { EditorUtility.SetDirty(m_allState[i]); } for (int i = 0; i < m_allCondition.Count; i++) { EditorUtility.SetDirty(m_allCondition[i]); } AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); EditorUtility.FocusProjectWindow(); Selection.activeObject = aiBehaviour; if (onSaved != null) { onSaved(aiBehaviour); } } else { EditorUtility.DisplayDialog("Error", "Unexisting Path:" + savePath, "OK"); } }
public void setTransition(TransitionNode transition) { this.transition = transition; }
private short stateId; //State's Id //Constructor of the class StateNode public StateNode(short stateId) { this.nextSNode = null; //Set the next node to null this.transition = null; //Set the transitions to null this.stateId = stateId; //Set the state's id }
public void AddTransitionNode(TransitionNode node) { dependencies.Add(node); }