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);
}
