/// <summary>
/// Get the node connection count
/// </summary>
/// <param name="target"></param>
/// <param name="from"></param>
/// <returns></returns>
public static int GetConnectionCount(Node target, NodeComponent from)
{
int num = 0;
if (target != null && from != null)
{
if (from is StateNode)
{
StateNode node = from as StateNode;
TransitionEvent[] TE = node.GetTransitions();
foreach (TransitionEvent transition in TE)
{
if (transition != null && transition.GetTargetNode() == target)
{
num++;
}
}
}
else if (from is EventNode)
{
EventNode method = from as EventNode;
foreach (var node in method.GetFlows())
{
if (node.GetTargetNode() == target)
{
num++;
}
}
}
}
return(num);
}
/// <summary>
/// Get all connection node from target.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static IList <NodeComponent> GetNodeConnectedTo(Node target)
{
if (target != null)
{
if (generatorData.EventConnectedInNode.ContainsKey(target))
{
return(generatorData.EventConnectedInNode[target]);
}
int num = 0;
List <NodeComponent> comp = new List <NodeComponent>();
foreach (Node node in generatorData.allNode)
{
if (target == node)
{
continue;
}
if (node is StateNode)
{
StateNode eventNode = node as StateNode;
TransitionEvent[] TE = eventNode.GetTransitions();
foreach (TransitionEvent transition in TE)
{
if (transition != null && transition.GetTargetNode() == target)
{
if (!comp.Contains(node))
{
comp.Add(node);
}
num++;
}
}
}
}
foreach (EventNode method in generatorData.eventNodes)
{
if (method == null)
{
continue;
}
foreach (var flow in method.GetFlows())
{
if (flow.GetTargetNode() == target)
{
if (!comp.Contains(method))
{
comp.Add(method);
}
num++;
}
}
}
var compArray = comp;
generatorData.ConnectedInNodeCount.Add(target, num);
generatorData.EventConnectedInNode.Add(target, compArray);
return(compArray);
}
return(null);
}
public static HashSet <NodeComponent> GetConnections(NodeComponent node)
{
HashSet <NodeComponent> allNodes;
if (generatorData.nodeConnectionsMap.TryGetValue(node, out allNodes))
{
return(allNodes);
}
allNodes = new HashSet <NodeComponent>();
if (node is StateNode)
{
StateNode eventNode = node as StateNode;
TransitionEvent[] TE = eventNode.GetTransitions();
foreach (TransitionEvent transition in TE)
{
var tNode = transition.GetTargetNode();
if (tNode != null)
{
allNodes.Add(tNode);
}
}
}
else if (node is BaseEventNode)
{
BaseEventNode stateEvent = node as BaseEventNode;
foreach (var member in stateEvent.GetFlows())
{
var tNode = member.GetTargetNode();
if (tNode != null)
{
allNodes.Add(tNode);
}
}
}
Func <object, bool> validation = delegate(object obj) {
if (obj is MemberData)
{
MemberData member = obj as MemberData;
if (member != null && member.IsTargetingPinOrNode)
{
allNodes.Add(member.GetTargetNode());
}
}
return(false);
};
AnalizerUtility.AnalizeObject(node, validation);
generatorData.nodeConnectionsMap[node] = allNodes;
return(allNodes);
}
protected void BuildTransitions()
{
StateNode node = targetNode as StateNode;
TransitionEvent[] transitions = node.GetTransitions();
for (int x = 0; x < transitions.Length; x++)
{
var tr = transitions[x];
int index = x;
var transition = owner.AddTransition(tr);
var port = AddOutputFlowPort(
new PortData()
{
portID = "[Transition]" + x,
getPortValue = () => transition,
}
);
port.SetEnabled(false);
}
}
/// <summary>
/// Get flow nodes from node.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static HashSet <NodeComponent> GetFlowConnection(NodeComponent node)
{
HashSet <NodeComponent> allNodes;
if (generatorData.flowNodeConnectionsMap.TryGetValue(node, out allNodes))
{
return(allNodes);
}
allNodes = new HashSet <NodeComponent>();
if (node is StateNode)
{
StateNode eventNode = node as StateNode;
TransitionEvent[] TE = eventNode.GetTransitions();
foreach (TransitionEvent transition in TE)
{
if (transition.GetTargetNode() != null && !allNodes.Contains(transition.GetTargetNode()))
{
allNodes.Add(transition.GetTargetNode());
}
}
}
Func <object, bool> validation = delegate(object obj) {
if (obj is MemberData)
{
MemberData member = obj as MemberData;
if (member != null && member.isAssigned &&
(member.targetType == MemberData.TargetType.FlowNode ||
member.targetType == MemberData.TargetType.FlowInput) &&
!allNodes.Contains(member.GetTargetNode()))
{
allNodes.Add(member.GetTargetNode());
}
}
return(false);
};
AnalizerUtility.AnalizeObject(node, validation);
generatorData.flowNodeConnectionsMap[node] = allNodes;
return(allNodes);
}
/// <summary>
/// Get the node connection count
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static int GetConnectionCount(Node target)
{
int num = 0;
if (target != null)
{
if (generatorData.ConnectedInNodeCount.TryGetValue(target, out num))
{
return(num);
}
List <NodeComponent> comp = new List <NodeComponent>();
foreach (Node node in generatorData.allNode)
{
if (target == node)
{
continue;
}
if (node is StateNode)
{
StateNode stateNode = node as StateNode;
TransitionEvent[] TE = stateNode.GetTransitions();
foreach (TransitionEvent transition in TE)
{
if (transition != null && transition.GetTargetNode() == target)
{
if (!comp.Contains(transition.GetTargetNode()))
{
comp.Add(transition.GetTargetNode());
}
num++;
}
}
}
}
generatorData.ConnectedInNodeCount.Add(target, num);
generatorData.EventConnectedInNode.Add(target, comp);
}
return(num);
}
public void SelectConnectedNode(Component from, bool allConnection = false, Action <NodeComponent> callbackAction = null)
{
if (from == null)
{
return;
}
if (from is BaseEventNode)
{
BaseEventNode method = from as BaseEventNode;
var flows = method.GetFlows();
foreach (var n in flows)
{
if (n == null || n.GetTargetNode() == null)
{
continue;
}
if (!editorData.selectedNodes.Contains(n.GetTargetNode()))
{
editorData.selectedNodes.Add(n.GetTargetNode());
editorData.selected = editorData.selectedNodes;
if (allConnection)
{
SelectConnectedNode(n.GetTargetNode(), allConnection, callbackAction);
}
SelectionChanged();
if (callbackAction != null)
{
callbackAction(n.GetTargetNode());
}
}
}
}
else if (from is Node)
{
Node node = from as Node;
if (node as StateNode)
{
StateNode eventNode = node as StateNode;
TransitionEvent[] TE = eventNode.GetTransitions();
foreach (TransitionEvent T in TE)
{
if (T.GetTargetNode() != null)
{
if (!editorData.selectedNodes.Contains(T.GetTargetNode()))
{
editorData.selectedNodes.Add(T.GetTargetNode());
editorData.selected = editorData.selectedNodes;
if (allConnection)
{
SelectConnectedNode(T.GetTargetNode(), allConnection, callbackAction);
}
SelectionChanged();
if (callbackAction != null)
{
callbackAction(T.GetTargetNode());
}
}
}
}
}
Func <object, bool> validation = delegate(object o) {
if (o is MemberData)
{
MemberData member = o as MemberData;
if (member.targetType == MemberData.TargetType.FlowNode ||
member.targetType == MemberData.TargetType.ValueNode)
{
Node n = member.GetInstance() as Node;
if (member.isAssigned && member.GetInstance() is Node)
{
if (!editorData.selectedNodes.Contains(n))
{
editorData.selectedNodes.Add(n);
editorData.selected = editorData.selectedNodes;
if (allConnection)
{
SelectConnectedNode(n, allConnection, callbackAction);
}
SelectionChanged();
if (callbackAction != null)
{
callbackAction(n);
}
}
//return true;
}
}
}
return(false);
};
AnalizerUtility.AnalizeObject(node, validation);
}
}
public void PasteNode(Vector3 position)
{
if (nodeToCopy == null || nodeToCopy.Count == 0)
{
return;
}
if (uNodeEditorUtility.IsPrefab(editorData.graph.gameObject))
{
throw new Exception("Editing graph prefab dirrectly is not supported.");
}
uNodeEditorUtility.RegisterUndo(editorData.graph, "Paste Node");
uNodeRoot UNR = editorData.graph;
float progress = 0;
int loopIndex = 0;
if (nodeToCopy.Count > 5)
{
EditorUtility.DisplayProgressBar("Loading", "", progress);
}
Vector2 center = Vector2.zero;
int centerLength = 0;
Dictionary <uNodeComponent, uNodeComponent> CopyedObjectMap = new Dictionary <uNodeComponent, uNodeComponent>(EqualityComparer <uNodeComponent> .Default);
foreach (uNodeComponent comp in nodeToCopy)
{
if (comp == null || comp is EventNode && editorData.selectedGroup != null)
{
continue;
}
Node node = comp as Node;
if (!CopyedObjectMap.ContainsKey(comp))
{
uNodeComponent com = Object.Instantiate(comp);
com.gameObject.name = com.gameObject.name.Replace("(Clone)", "");
if (editorData.selectedGroup == null)
{
if (editorData.selectedRoot)
{
com.transform.parent = editorData.selectedRoot.transform;
}
else
{
com.transform.parent = NodeEditorUtility.GetNodeRoot(UNR).transform;
}
}
else
{
com.transform.parent = editorData.selectedGroup.transform;
}
int index = 0;
string nm = com.gameObject.name.TrimEnd(numberChar);
while (true)
{
bool flag = false;
string gName = com.gameObject.name;
foreach (Transform t in com.transform.parent)
{
if (t != com.transform)
{
if (t.gameObject.name.Equals(gName))
{
flag = true;
break;
}
}
}
if (flag)
{
com.gameObject.name = nm + index.ToString();
index++;
continue;
}
break;
}
CopyedObjectMap.Add(comp, com);
if (comp is IMacro || comp is ISuperNode)
{
var fields = EditorReflectionUtility.GetFields(comp.GetType());
foreach (var field in fields)
{
if (field.FieldType == typeof(List <Nodes.MacroPortNode>))
{
var value = field.GetValueOptimized(comp) as List <Nodes.MacroPortNode>;
if (value != null)
{
var sourceValue = field.GetValueOptimized(com) as List <Nodes.MacroPortNode>;
for (int i = 0; i < value.Count; i++)
{
if (value[i] == null)
{
continue;
}
CopyedObjectMap.Add(value[i], sourceValue[i]);
}
}
}
}
}
}
if (node != null)
{
center.x += node.editorRect.x;
center.y += node.editorRect.y;
centerLength++;
}
else
{
BaseEventNode met = comp as BaseEventNode;
if (met != null)
{
center.x += met.editorRect.x;
center.y += met.editorRect.y;
centerLength++;
}
}
loopIndex++;
progress = (float)loopIndex / (float)nodeToCopy.Count;
if (nodeToCopy.Count > 5)
{
EditorUtility.DisplayProgressBar("Loading", "", progress);
}
}
progress = 0;
center /= centerLength;
HashSet <uNodeComponent> needReflectedComponent = new HashSet <uNodeComponent>();
uNodeRoot compEvent = null;
foreach (uNodeComponent com in nodeToCopy)
{
uNodeComponent comp = null;
if (CopyedObjectMap.ContainsKey(com))
{
comp = CopyedObjectMap[com];
if (comp == null)
{
loopIndex++;
progress = (float)loopIndex / (float)nodeToCopy.Count;
if (nodeToCopy.Count > 5)
{
EditorUtility.DisplayProgressBar("Loading", "", progress);
}
continue;
}
if (comp as Node)
{
Node node = comp as Node;
Func <object, bool> validation = delegate(object o) {
if (o is MemberData)
{
MemberData member = o as MemberData;
if (member.IsTargetingPinOrNode)
{
NodeComponent n = member.GetInstance() as NodeComponent;
if (n && n is uNodeComponent)
{
if (CopyedObjectMap.ContainsKey(n))
{
member.instance = CopyedObjectMap[n] as NodeComponent;
n.owner = UNR;
return(true);
}
else if (n.owner != UNR || n.transform.parent != node.transform.parent)
{
member.instance = null;
n.owner = UNR;
return(true);
}
//return true;
}
}
}
return(false);
};
if (node as StateNode)
{
StateNode eventNode = node as StateNode;
TransitionEvent[] TE = eventNode.GetTransitions();
foreach (TransitionEvent n in TE)
{
var tn = n.GetTargetNode();
if (tn == null)
{
continue;
}
if (CopyedObjectMap.ContainsKey(tn))
{
n.target = MemberData.CreateConnection(CopyedObjectMap[tn] as Node, true);
n.owner = UNR;
}
else if (n.owner != UNR || tn != null && tn.owner != UNR ||
tn != null && tn.transform.parent != node.transform.parent)
{
n.target = MemberData.none;
n.owner = UNR;
}
}
}
else if (node is IMacro || node is ISuperNode)
{
var fields = EditorReflectionUtility.GetFields(comp.GetType());
foreach (var field in fields)
{
if (field.FieldType == typeof(List <Nodes.MacroPortNode>))
{
var value = field.GetValueOptimized(comp) as List <Nodes.MacroPortNode>;
if (value != null)
{
foreach (var v in value)
{
AnalizerUtility.AnalizeObject(v, validation);
}
}
}
}
}
AnalizerUtility.AnalizeObject(node, validation);
node.editorRect = new Rect(node.editorRect.x - center.x + position.x, node.editorRect.y - center.y + position.y, node.editorRect.width, node.editorRect.height);
if (node.owner != UNR)
{
node.owner = UNR;
}
}
else if (comp is BaseEventNode)
{
BaseEventNode method = comp as BaseEventNode;
var flows = method.GetFlows();
for (int i = 0; i < flows.Count; i++)
{
var tn = flows[i].GetTargetNode();
if (tn != null && CopyedObjectMap.ContainsKey(tn))
{
flows[i] = new MemberData(CopyedObjectMap[flows[i].GetTargetNode()], MemberData.TargetType.FlowNode);
}
else if (method.owner != UNR)
{
flows[i] = MemberData.none;
}
}
method.owner = UNR;
method.editorRect = new Rect(method.editorRect.x - center.x + position.x, method.editorRect.y - center.y + position.y, method.editorRect.width, method.editorRect.height);
}
}
loopIndex++;
progress = (float)loopIndex / (float)nodeToCopy.Count;
if (nodeToCopy.Count > 5)
{
EditorUtility.DisplayProgressBar("Loading", "", progress);
}
}
if (nodeToCopy.Count > 5)
{
EditorUtility.ClearProgressBar();
}
if (needReflectedComponent.Count > 0)
{
NodeEditorUtility.PerformReflectComponent(needReflectedComponent.ToList(), compEvent, UNR);
}
foreach (KeyValuePair <uNodeComponent, uNodeComponent> keys in CopyedObjectMap)
{
if (keys.Value != null)
{
Undo.RegisterCreatedObjectUndo(keys.Value.gameObject, "Paste Node");
}
}
//allCopyedEvent.Clear();
Refresh();
}
public static HashSet <NodeComponent> GetFlowConnectedTo(Node target)
{
if (target != null)
{
if (generatorData.FlowConnectedTo.TryGetValue(target, out var comp))
{
return(comp);
}
comp = new HashSet <NodeComponent>();
Node currNode = null;
Func <object, bool> validation = delegate(object obj) {
if (obj is MemberData)
{
MemberData member = obj as MemberData;
Node targetNode = member.GetTargetNode();
if (targetNode == target)
{
if (member.targetType == MemberData.TargetType.FlowNode || member.targetType == MemberData.TargetType.FlowInput)
{
comp.Add(currNode);
return(true);
}
else if (member.targetType == MemberData.TargetType.ValueNode ||
member.targetType == MemberData.TargetType.NodeField ||
member.targetType == MemberData.TargetType.NodeFieldElement)
{
var connectedNodes = GetFlowConnectedTo(currNode);
if (connectedNodes != null)
{
foreach (var n in connectedNodes)
{
comp.Add(n);
}
}
}
}
}
return(false);
};
foreach (Node node in generatorData.allNode)
{
if (target == node)
{
continue;
}
if (node is StateNode)
{
StateNode eventNode = node as StateNode;
TransitionEvent[] TE = eventNode.GetTransitions();
foreach (TransitionEvent transition in TE)
{
if (transition != null && transition.GetTargetNode() == target)
{
comp.Add(node);
break;
}
}
}
else if (node is IMacro)
{
IMacro macro = node as IMacro;
var outputFlows = macro.OutputFlows;
foreach (var flow in outputFlows)
{
if (flow != null && flow.target.GetTargetNode() == target)
{
comp.Add(node);
break;
}
}
}
currNode = node;
AnalizerUtility.AnalizeObject(node, validation);
}
foreach (EventNode method in generatorData.eventNodes)
{
if (method == null)
{
continue;
}
foreach (var flow in method.GetFlows())
{
if (flow.GetTargetNode() == target)
{
comp.Add(method);
break;
}
}
}
generatorData.FlowConnectedTo[target] = comp;
return(comp);
}
return(null);
}