Merge pull request #52 from groud/use-iterators

Levin G · Levin G · commit 7f8699a0d2f2 · 2016-02-22T20:17:06.000+01:00
Replaced for-loops with foreach to improve code readability
diff --git a/Node_Editor/Framework/Canvas Save Objects/Transition.cs b/Node_Editor/Framework/Canvas Save Objects/Transition.cs
@@ -87,9 +87,9 @@ public void Delete ()
 		/// </summary>
 		public bool conditionsMet () 
 		{
-			for (int condCnt = 0; condCnt < conditions.Count; condCnt++) 
+			foreach (TransitionCondition condition in conditions)
 			{
-				if (!conditions[condCnt].Invoke (this))
+				if (!condition.Invoke (this))
 					return false;
 			}
 			return true;
diff --git a/Node_Editor/Framework/Node.cs b/Node_Editor/Framework/Node.cs
@@ -54,28 +54,26 @@ public void Delete ()
 				throw new UnityException ("The Node " + name + " does not exist on the Canvas " + NodeEditor.curNodeCanvas.name + "!");
 			NodeEditorCallbacks.IssueOnDeleteNode (this);
 			NodeEditor.curNodeCanvas.nodes.Remove (this);
-			for (int outCnt = 0; outCnt < Outputs.Count; outCnt++) 
+			foreach (NodeOutput output in Outputs) 
 			{
-				NodeOutput output = Outputs [outCnt];
 				while (output.connections.Count != 0)
 					output.connections[0].RemoveConnection ();
 				DestroyImmediate (output, true);
 			}
-			for (int inCnt = 0; inCnt < Inputs.Count; inCnt++) 
+			foreach (NodeInput input in Inputs) 
 			{
-				NodeInput input = Inputs [inCnt];
 				if (input.connection != null)
 					input.connection.connections.Remove (input);
 				DestroyImmediate (input, true);
 			}
-			for (int knobCnt = 0; knobCnt < nodeKnobs.Count; knobCnt++) 
+			foreach  (NodeKnob knob in nodeKnobs) 
 			{ // Inputs/Outputs need specific treatment, unfortunately
-				if (nodeKnobs[knobCnt] != null)
-					DestroyImmediate (nodeKnobs[knobCnt], true);
+				if (knob != null)
+					DestroyImmediate (knob, true);
 			}
-			for (int transCnt = 0; transCnt < transitions.Count; transCnt++) 
+			foreach  (Transition transition in transitions) 
 			{
-				transitions [transCnt].Delete ();
+				transition.Delete ();
 			}
 			DestroyImmediate (this, true);
 		}
@@ -244,8 +242,8 @@ protected internal virtual void DrawNode ()
 		protected internal virtual void DrawKnobs () 
 		{
 			CheckNodeKnobMigration ();
-			for (int knobCnt = 0; knobCnt < nodeKnobs.Count; knobCnt++) 
-				nodeKnobs[knobCnt].DrawKnob ();
+			foreach  (NodeKnob knob in nodeKnobs)
+				knob.DrawKnob ();
 		}
 
 		/// <summary>
@@ -256,15 +254,13 @@ protected internal virtual void DrawConnections ()
 			CheckNodeKnobMigration ();
 			if (Event.current.type != EventType.Repaint)
 				return;
-			for (int outCnt = 0; outCnt < Outputs.Count; outCnt++) 
+			foreach (NodeOutput output in Outputs) 
 			{
-				NodeOutput output = Outputs [outCnt];
 				Vector2 startPos = output.GetGUIKnob ().center;
 				Vector2 startDir = output.GetDirection ();
 
-				for (int conCnt = 0; conCnt < output.connections.Count; conCnt++) 
+				foreach (NodeInput input in output.connections) 
 				{
-					NodeInput input = output.connections [conCnt];
 					NodeEditorGUI.DrawConnection (startPos,
 					                           startDir,
 					                           input.GetGUIKnob ().center,
@@ -279,10 +275,10 @@ protected internal virtual void DrawConnections ()
 		/// </summary>
 		public void DrawTransitions () 
 		{
-			for (int cnt = 0; cnt < transitions.Count; cnt++)
+			foreach (Transition transition in transitions)
 			{
-				if (transitions[cnt].startNode == this)
-					transitions[cnt].DrawFromStartNode ();
+				if (transition.startNode == this)
+					transition.DrawFromStartNode ();
 			}
 		}
 
@@ -301,9 +297,9 @@ public virtual void DrawNodePropertyEditor() { }
 		/// </summary>
 		protected internal bool allInputsReady ()
 		{
-			for (int inCnt = 0; inCnt < Inputs.Count; inCnt++) 
+			foreach (NodeInput input in Inputs) 
 			{
-				if (Inputs[inCnt].connection == null || Inputs[inCnt].connection.IsValueNull)
+				if (input.connection == null || input.connection.IsValueNull)
 					return false;
 			}
 			return true;
@@ -313,8 +309,8 @@ protected internal bool allInputsReady ()
 		/// </summary>
 		protected internal bool hasUnassignedInputs () 
 		{
-			for (int inCnt = 0; inCnt < Inputs.Count; inCnt++)
-				if (Inputs [inCnt].connection == null)
+			foreach (NodeInput input in Inputs) 
+				if (input.connection == null)
 					return true;
 			return false;
 		}
@@ -324,9 +320,9 @@ protected internal bool hasUnassignedInputs ()
 		/// </summary>
 		protected internal bool descendantsCalculated () 
 		{
-			for (int cnt = 0; cnt < Inputs.Count; cnt++) 
+			foreach (NodeInput input in Inputs) 
 			{
-				if (Inputs [cnt].connection != null && !Inputs [cnt].connection.body.calculated)
+				if (input.connection != null && !input.connection.body.calculated)
 					return false;
 			}
 			return true;
@@ -337,8 +333,8 @@ protected internal bool descendantsCalculated ()
 		/// </summary>
 		protected internal bool isInput () 
 		{
-			for (int cnt = 0; cnt < Inputs.Count; cnt++)
-				if (Inputs [cnt].connection != null)
+			foreach (NodeInput input in Inputs) 
+				if (input.connection != null)
 					return false;
 			return true;
 		}
@@ -386,10 +382,10 @@ protected void OutputKnob (int outputIdx)
 		/// </summary>
 		public NodeOutput GetOutputAtPos (Vector2 pos) 
 		{
-			for (int outCnt = 0; outCnt < Outputs.Count; outCnt++) 
+			foreach (NodeOutput output in Outputs) 
 			{ // Search for an output at the position
-				if (Outputs [outCnt].GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))
-					return Outputs [outCnt];
+				if (output.GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))
+					return output;
 			}
 			return null;
 		}
@@ -434,10 +430,10 @@ protected void InputKnob (int inputIdx)
 		/// </summary>
 		public NodeInput GetInputAtPos (Vector2 pos) 
 		{
-			for (int inCnt = 0; inCnt < Inputs.Count; inCnt++) 
+			foreach (NodeInput input in Inputs) 
 			{ // Search for an input at the position
-				if (Inputs [inCnt].GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))
-					return Inputs [inCnt];
+				if (input.GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))
+					return input;
 			}
 			return null;
 		}
@@ -454,9 +450,9 @@ public bool isChildOf (Node otherNode)
 			if (otherNode == null || otherNode == this)
 				return false;
 			if (BeginRecursiveSearchLoop ()) return false;
-			for (int cnt = 0; cnt < Inputs.Count; cnt++) 
+			foreach (NodeInput input in Inputs) 
 			{
-				NodeOutput connection = Inputs [cnt].connection;
+				NodeOutput connection = input.connection;
 				if (connection != null) 
 				{
 					if (connection.body != startRecursiveSearchNode)
@@ -479,9 +475,9 @@ public bool isChildOf (Node otherNode)
 		internal bool isInLoop ()
 		{
 			if (BeginRecursiveSearchLoop ()) return this == startRecursiveSearchNode;
-			for (int cnt = 0; cnt < Inputs.Count; cnt++) 
+			foreach (NodeInput input in Inputs) 
 			{
-				NodeOutput connection = Inputs [cnt].connection;
+				NodeOutput connection = input.connection;
 				if (connection != null) 
 				{
 					if (connection.body.isInLoop ())
@@ -507,9 +503,9 @@ internal bool allowsLoopRecursion (Node otherNode)
 			if (otherNode == null)
 				return false;
 			if (BeginRecursiveSearchLoop ()) return false;
-			for (int cnt = 0; cnt < Inputs.Count; cnt++) 
+			foreach (NodeInput input in Inputs)
 			{
-				NodeOutput connection = Inputs [cnt].connection;
+				NodeOutput connection = input.connection;
 				if (connection != null) 
 				{
 					if (connection.body != startRecursiveSearchNode)
@@ -534,11 +530,10 @@ public void ClearCalculation ()
 		{
 			if (BeginRecursiveSearchLoop ()) return;
 			calculated = false;
-			for (int outCnt = 0; outCnt < Outputs.Count; outCnt++)
+			foreach (NodeOutput output in Outputs)
 			{
-				NodeOutput output = Outputs [outCnt];
-				for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)
-					output.connections [conCnt].body.ClearCalculation ();
+				foreach (NodeInput connection in output.connections)
+					connection.body.ClearCalculation ();
 			}
 			EndRecursiveSearchLoop ();
 		}
@@ -608,4 +603,7 @@ public static void CreateTransition (Node fromNode, Node toNode)
 
 		#endregion
 	}
+
+
+
 }
diff --git a/Node_Editor/Framework/NodeEditor.cs b/Node_Editor/Framework/NodeEditor.cs
@@ -217,17 +217,16 @@ public static void DrawSubCanvas (NodeCanvas nodeCanvas, NodeEditorState editorS
 			}
 
 			// Draw the transitions and connections. Has to be drawn before nodes as transitions originate from node centers
-			for (int nodeCnt = 0; nodeCnt < curNodeCanvas.nodes.Count; nodeCnt++)  
+
+			foreach (Node node in curNodeCanvas.nodes)  
 			{
-				Node node = curNodeCanvas.nodes [nodeCnt];
 				node.DrawTransitions ();
 				node.DrawConnections ();
 			}
 
 			// Draw the nodes
-			for (int nodeCnt = 0; nodeCnt < curNodeCanvas.nodes.Count; nodeCnt++)
+			foreach (Node node in curNodeCanvas.nodes)  
 			{
-				Node node = curNodeCanvas.nodes [nodeCnt];
 				node.DrawNode ();
 				if (Event.current.type == EventType.Repaint)
 					node.DrawKnobs ();
@@ -268,9 +267,9 @@ public static Node NodeAtPosition (NodeEditorState editorState, NodeCanvas nodeC
 				Node node = nodeCanvas.nodes [nodeCnt];
 				if (CanvasGUIToScreenRect (node.rect).Contains (pos)) // Node Body
 					return node;
-				for (int knobCnt = 0; knobCnt < node.nodeKnobs.Count; knobCnt++)
+				foreach (NodeKnob knob in node.nodeKnobs)
 				{ // Any edge control
-					if (node.nodeKnobs[knobCnt].GetScreenKnob ().Contains (pos))
+					if (knob.GetScreenKnob ().Contains (pos))
 						return node;
 				}
 			}
@@ -323,9 +322,9 @@ private static bool ignoreInput (Vector2 mousePos)
 			// Mouse outside of canvas rect or inside an ignoreInput rect
 			if (!curEditorState.canvasRect.Contains (mousePos))
 				return true;
-			for (int ignoreCnt = 0; ignoreCnt < curEditorState.ignoreInput.Count; ignoreCnt++) 
+			foreach(Rect rect in curEditorState.ignoreInput) 
 			{
-				if (curEditorState.ignoreInput [ignoreCnt].Contains (mousePos)) 
+				if (rect.Contains (mousePos)) 
 					return true;
 			}
 			return false;
@@ -433,9 +432,9 @@ public static void InputEvents ()
 						{ // A connection is drawn, so provide a context menu with apropriate nodes to auto-connect
 							foreach (Node node in NodeTypes.nodes.Keys)
 							{ // Iterate through all nodes and check for compability
-								for (int inputCnt = 0; inputCnt < node.Inputs.Count; inputCnt++)
+								foreach (NodeInput input in node.Inputs)
 								{
-									if (node.Inputs[inputCnt].type == curEditorState.connectOutput.type)
+									if (input.type == curEditorState.connectOutput.type)
 									{
 										menu.AddItem (new GUIContent ("Add " + NodeTypes.nodes[node].adress), false, ContextCallback, new NodeEditorMenuCallback (node.GetID, curNodeCanvas, curEditorState));
 										break;
@@ -531,8 +530,8 @@ public static void InputEvents ()
 				if (curEditorState.panWindow) 
 				{ // Scroll everything with the current mouse delta
 					curEditorState.panOffset += e.delta * curEditorState.zoom;
-					for (int nodeCnt = 0; nodeCnt < curNodeCanvas.nodes.Count; nodeCnt++) 
-						curNodeCanvas.nodes [nodeCnt].rect.position += e.delta * curEditorState.zoom;
+					foreach (Node node in curNodeCanvas.nodes) 
+						node.rect.position += e.delta * curEditorState.zoom;
 					e.delta = Vector2.zero;
 					RepaintClients ();
 				}
@@ -731,9 +730,8 @@ public static void StopTransitioning (NodeCanvas nodeCanvas)
 		/// </summary>
 		private static void UpdateTransitions () 
 		{
-			for (int cnt = 0; cnt < transitioningNodeCanvases.Count; cnt++)
+			foreach (NodeCanvas nodeCanvas in transitioningNodeCanvases)
 			{
-				NodeCanvas nodeCanvas = transitioningNodeCanvases[cnt];
 				if (!nodeCanvas.currentNode.AcceptsTranstitions || nodeCanvas.currentNode.transitions.Count == 0) 
 				{ // Error - this node should not have any transitions, in or out
 					StopTransitioning (nodeCanvas);
@@ -787,9 +785,8 @@ public static bool isTransitioning (NodeCanvas nodeCanvas)
 		/// </summary>
 		private static Transition GetNextTransition (Node node) 
 		{
-			for (int transCnt = 0; transCnt < node.transitions.Count; transCnt++) 
+			foreach (Transition trans in node.transitions) 
 			{
-				Transition trans = node.transitions[transCnt];
 				if (trans.startNode == node && trans.conditionsMet ()) 
 					return trans;
 			}
@@ -846,9 +843,9 @@ public static void StartCalculation ()
 			for (int roundCnt = 0; !limitReached; roundCnt++)
 			{ // Runs until every node possible is calculated
 				limitReached = true;
-				for (int workCnt = 0; workCnt < workList.Count; workCnt++) 
+				foreach (Node node in workList) 
 				{
-					if (ContinueCalculation (workList [workCnt]))
+					if (ContinueCalculation (node))
 						limitReached = false;
 				}
 			}
@@ -870,11 +867,10 @@ public static bool ContinueCalculation (Node node)
 				workList.Remove (node);
 				if (node.ContinueCalculation && calculationCount < 1000) 
 				{
-					for (int outCnt = 0; outCnt < node.Outputs.Count; outCnt++)
+					foreach (NodeOutput output in node.Outputs)
 					{
-						NodeOutput output = node.Outputs [outCnt];
-						for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)
-							ContinueCalculation (output.connections [conCnt].body);
+						foreach (NodeInput connection in output.connections)
+							ContinueCalculation(connection.body);
 					}
 				}
 				else if (calculationCount >= 1000)
diff --git a/Node_Editor/Framework/NodeEditorSaveManager.cs b/Node_Editor/Framework/NodeEditorSaveManager.cs

Original file line number	Diff line number	Diff line change
`@@ -87,9 +87,9 @@ public void Delete ()`
`87`	`87`	`/// </summary>`
`88`	`88`	`public bool conditionsMet ()`
`89`	`89`	`{`
`90`		`- for (int condCnt = 0; condCnt < conditions.Count; condCnt++)`
	`90`	`+ foreach (TransitionCondition condition in conditions)`
`91`	`91`	`{`
`92`		`- if (!conditions[condCnt].Invoke (this))`
	`92`	`+ if (!condition.Invoke (this))`
`93`	`93`	`return false;`
`94`	`94`	`}`
`95`	`95`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -54,28 +54,26 @@ public void Delete ()`
`54`	`54`	`throw new UnityException ("The Node " + name + " does not exist on the Canvas " + NodeEditor.curNodeCanvas.name + "!");`
`55`	`55`	`NodeEditorCallbacks.IssueOnDeleteNode (this);`
`56`	`56`	`NodeEditor.curNodeCanvas.nodes.Remove (this);`
`57`		`- for (int outCnt = 0; outCnt < Outputs.Count; outCnt++)`
	`57`	`+ foreach (NodeOutput output in Outputs)`
`58`	`58`	`{`
`59`		`- NodeOutput output = Outputs [outCnt];`
`60`	`59`	`while (output.connections.Count != 0)`
`61`	`60`	`output.connections[0].RemoveConnection ();`
`62`	`61`	`DestroyImmediate (output, true);`
`63`	`62`	`}`
`64`		`- for (int inCnt = 0; inCnt < Inputs.Count; inCnt++)`
	`63`	`+ foreach (NodeInput input in Inputs)`
`65`	`64`	`{`
`66`		`- NodeInput input = Inputs [inCnt];`
`67`	`65`	`if (input.connection != null)`
`68`	`66`	`input.connection.connections.Remove (input);`
`69`	`67`	`DestroyImmediate (input, true);`
`70`	`68`	`}`
`71`		`- for (int knobCnt = 0; knobCnt < nodeKnobs.Count; knobCnt++)`
	`69`	`+ foreach (NodeKnob knob in nodeKnobs)`
`72`	`70`	`{ // Inputs/Outputs need specific treatment, unfortunately`
`73`		`- if (nodeKnobs[knobCnt] != null)`
`74`		`- DestroyImmediate (nodeKnobs[knobCnt], true);`
	`71`	`+ if (knob != null)`
	`72`	`+ DestroyImmediate (knob, true);`
`75`	`73`	`}`
`76`		`- for (int transCnt = 0; transCnt < transitions.Count; transCnt++)`
	`74`	`+ foreach (Transition transition in transitions)`
`77`	`75`	`{`
`78`		`- transitions [transCnt].Delete ();`
	`76`	`+ transition.Delete ();`
`79`	`77`	`}`
`80`	`78`	`DestroyImmediate (this, true);`
`81`	`79`	`}`
`@@ -244,8 +242,8 @@ protected internal virtual void DrawNode ()`
`244`	`242`	`protected internal virtual void DrawKnobs ()`
`245`	`243`	`{`
`246`	`244`	`CheckNodeKnobMigration ();`
`247`		`- for (int knobCnt = 0; knobCnt < nodeKnobs.Count; knobCnt++)`
`248`		`- nodeKnobs[knobCnt].DrawKnob ();`
	`245`	`+ foreach (NodeKnob knob in nodeKnobs)`
	`246`	`+ knob.DrawKnob ();`
`249`	`247`	`}`
`250`	`248`
`251`	`249`	`/// <summary>`
`@@ -256,15 +254,13 @@ protected internal virtual void DrawConnections ()`
`256`	`254`	`CheckNodeKnobMigration ();`
`257`	`255`	`if (Event.current.type != EventType.Repaint)`
`258`	`256`	`return;`
`259`		`- for (int outCnt = 0; outCnt < Outputs.Count; outCnt++)`
	`257`	`+ foreach (NodeOutput output in Outputs)`
`260`	`258`	`{`
`261`		`- NodeOutput output = Outputs [outCnt];`
`262`	`259`	`Vector2 startPos = output.GetGUIKnob ().center;`
`263`	`260`	`Vector2 startDir = output.GetDirection ();`
`264`	`261`
`265`		`- for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)`
	`262`	`+ foreach (NodeInput input in output.connections)`
`266`	`263`	`{`
`267`		`- NodeInput input = output.connections [conCnt];`
`268`	`264`	`NodeEditorGUI.DrawConnection (startPos,`
`269`	`265`	`startDir,`
`270`	`266`	`input.GetGUIKnob ().center,`
`@@ -279,10 +275,10 @@ protected internal virtual void DrawConnections ()`
`279`	`275`	`/// </summary>`
`280`	`276`	`public void DrawTransitions ()`
`281`	`277`	`{`
`282`		`- for (int cnt = 0; cnt < transitions.Count; cnt++)`
	`278`	`+ foreach (Transition transition in transitions)`
`283`	`279`	`{`
`284`		`- if (transitions[cnt].startNode == this)`
`285`		`- transitions[cnt].DrawFromStartNode ();`
	`280`	`+ if (transition.startNode == this)`
	`281`	`+ transition.DrawFromStartNode ();`
`286`	`282`	`}`
`287`	`283`	`}`
`288`	`284`
`@@ -301,9 +297,9 @@ public virtual void DrawNodePropertyEditor() { }`
`301`	`297`	`/// </summary>`
`302`	`298`	`protected internal bool allInputsReady ()`
`303`	`299`	`{`
`304`		`- for (int inCnt = 0; inCnt < Inputs.Count; inCnt++)`
	`300`	`+ foreach (NodeInput input in Inputs)`
`305`	`301`	`{`
`306`		`- if (Inputs[inCnt].connection == null \|\| Inputs[inCnt].connection.IsValueNull)`
	`302`	`+ if (input.connection == null \|\| input.connection.IsValueNull)`
`307`	`303`	`return false;`
`308`	`304`	`}`
`309`	`305`	`return true;`
`@@ -313,8 +309,8 @@ protected internal bool allInputsReady ()`
`313`	`309`	`/// </summary>`
`314`	`310`	`protected internal bool hasUnassignedInputs ()`
`315`	`311`	`{`
`316`		`- for (int inCnt = 0; inCnt < Inputs.Count; inCnt++)`
`317`		`- if (Inputs [inCnt].connection == null)`
	`312`	`+ foreach (NodeInput input in Inputs)`
	`313`	`+ if (input.connection == null)`
`318`	`314`	`return true;`
`319`	`315`	`return false;`
`320`	`316`	`}`
`@@ -324,9 +320,9 @@ protected internal bool hasUnassignedInputs ()`
`324`	`320`	`/// </summary>`
`325`	`321`	`protected internal bool descendantsCalculated ()`
`326`	`322`	`{`
`327`		`- for (int cnt = 0; cnt < Inputs.Count; cnt++)`
	`323`	`+ foreach (NodeInput input in Inputs)`
`328`	`324`	`{`
`329`		`- if (Inputs [cnt].connection != null && !Inputs [cnt].connection.body.calculated)`
	`325`	`+ if (input.connection != null && !input.connection.body.calculated)`
`330`	`326`	`return false;`
`331`	`327`	`}`
`332`	`328`	`return true;`
`@@ -337,8 +333,8 @@ protected internal bool descendantsCalculated ()`
`337`	`333`	`/// </summary>`
`338`	`334`	`protected internal bool isInput ()`
`339`	`335`	`{`
`340`		`- for (int cnt = 0; cnt < Inputs.Count; cnt++)`
`341`		`- if (Inputs [cnt].connection != null)`
	`336`	`+ foreach (NodeInput input in Inputs)`
	`337`	`+ if (input.connection != null)`
`342`	`338`	`return false;`
`343`	`339`	`return true;`
`344`	`340`	`}`
`@@ -386,10 +382,10 @@ protected void OutputKnob (int outputIdx)`
`386`	`382`	`/// </summary>`
`387`	`383`	`public NodeOutput GetOutputAtPos (Vector2 pos)`
`388`	`384`	`{`
`389`		`- for (int outCnt = 0; outCnt < Outputs.Count; outCnt++)`
	`385`	`+ foreach (NodeOutput output in Outputs)`
`390`	`386`	`{ // Search for an output at the position`
`391`		`- if (Outputs [outCnt].GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))`
`392`		`- return Outputs [outCnt];`
	`387`	`+ if (output.GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))`
	`388`	`+ return output;`
`393`	`389`	`}`
`394`	`390`	`return null;`
`395`	`391`	`}`
`@@ -434,10 +430,10 @@ protected void InputKnob (int inputIdx)`
`434`	`430`	`/// </summary>`
`435`	`431`	`public NodeInput GetInputAtPos (Vector2 pos)`
`436`	`432`	`{`
`437`		`- for (int inCnt = 0; inCnt < Inputs.Count; inCnt++)`
	`433`	`+ foreach (NodeInput input in Inputs)`
`438`	`434`	`{ // Search for an input at the position`
`439`		`- if (Inputs [inCnt].GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))`
`440`		`- return Inputs [inCnt];`
	`435`	`+ if (input.GetScreenKnob ().Contains (new Vector3 (pos.x, pos.y)))`
	`436`	`+ return input;`
`441`	`437`	`}`
`442`	`438`	`return null;`
`443`	`439`	`}`
`@@ -454,9 +450,9 @@ public bool isChildOf (Node otherNode)`
`454`	`450`	`if (otherNode == null \|\| otherNode == this)`
`455`	`451`	`return false;`
`456`	`452`	`if (BeginRecursiveSearchLoop ()) return false;`
`457`		`- for (int cnt = 0; cnt < Inputs.Count; cnt++)`
	`453`	`+ foreach (NodeInput input in Inputs)`
`458`	`454`	`{`
`459`		`- NodeOutput connection = Inputs [cnt].connection;`
	`455`	`+ NodeOutput connection = input.connection;`
`460`	`456`	`if (connection != null)`
`461`	`457`	`{`
`462`	`458`	`if (connection.body != startRecursiveSearchNode)`
`@@ -479,9 +475,9 @@ public bool isChildOf (Node otherNode)`
`479`	`475`	`internal bool isInLoop ()`
`480`	`476`	`{`
`481`	`477`	`if (BeginRecursiveSearchLoop ()) return this == startRecursiveSearchNode;`
`482`		`- for (int cnt = 0; cnt < Inputs.Count; cnt++)`
	`478`	`+ foreach (NodeInput input in Inputs)`
`483`	`479`	`{`
`484`		`- NodeOutput connection = Inputs [cnt].connection;`
	`480`	`+ NodeOutput connection = input.connection;`
`485`	`481`	`if (connection != null)`
`486`	`482`	`{`
`487`	`483`	`if (connection.body.isInLoop ())`
`@@ -507,9 +503,9 @@ internal bool allowsLoopRecursion (Node otherNode)`
`507`	`503`	`if (otherNode == null)`
`508`	`504`	`return false;`
`509`	`505`	`if (BeginRecursiveSearchLoop ()) return false;`
`510`		`- for (int cnt = 0; cnt < Inputs.Count; cnt++)`
	`506`	`+ foreach (NodeInput input in Inputs)`
`511`	`507`	`{`
`512`		`- NodeOutput connection = Inputs [cnt].connection;`
	`508`	`+ NodeOutput connection = input.connection;`
`513`	`509`	`if (connection != null)`
`514`	`510`	`{`
`515`	`511`	`if (connection.body != startRecursiveSearchNode)`
`@@ -534,11 +530,10 @@ public void ClearCalculation ()`
`534`	`530`	`{`
`535`	`531`	`if (BeginRecursiveSearchLoop ()) return;`
`536`	`532`	`calculated = false;`
`537`		`- for (int outCnt = 0; outCnt < Outputs.Count; outCnt++)`
	`533`	`+ foreach (NodeOutput output in Outputs)`
`538`	`534`	`{`
`539`		`- NodeOutput output = Outputs [outCnt];`
`540`		`- for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)`
`541`		`- output.connections [conCnt].body.ClearCalculation ();`
	`535`	`+ foreach (NodeInput connection in output.connections)`
	`536`	`+ connection.body.ClearCalculation ();`
`542`	`537`	`}`
`543`	`538`	`EndRecursiveSearchLoop ();`
`544`	`539`	`}`
`@@ -608,4 +603,7 @@ public static void CreateTransition (Node fromNode, Node toNode)`
`608`	`603`
`609`	`604`	`#endregion`
`610`	`605`	`}`
	`606`	`+`
	`607`	`+`
	`608`	`+`
`611`	`609`	`}`
Original file line number	Diff line number	Diff line change
`@@ -217,17 +217,16 @@ public static void DrawSubCanvas (NodeCanvas nodeCanvas, NodeEditorState editorS`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`// Draw the transitions and connections. Has to be drawn before nodes as transitions originate from node centers`
`220`		`- for (int nodeCnt = 0; nodeCnt < curNodeCanvas.nodes.Count; nodeCnt++)`
	`220`	`+`
	`221`	`+ foreach (Node node in curNodeCanvas.nodes)`
`221`	`222`	`{`
`222`		`- Node node = curNodeCanvas.nodes [nodeCnt];`
`223`	`223`	`node.DrawTransitions ();`
`224`	`224`	`node.DrawConnections ();`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`// Draw the nodes`
`228`		`- for (int nodeCnt = 0; nodeCnt < curNodeCanvas.nodes.Count; nodeCnt++)`
	`228`	`+ foreach (Node node in curNodeCanvas.nodes)`
`229`	`229`	`{`
`230`		`- Node node = curNodeCanvas.nodes [nodeCnt];`
`231`	`230`	`node.DrawNode ();`
`232`	`231`	`if (Event.current.type == EventType.Repaint)`
`233`	`232`	`node.DrawKnobs ();`
`@@ -268,9 +267,9 @@ public static Node NodeAtPosition (NodeEditorState editorState, NodeCanvas nodeC`
`268`	`267`	`Node node = nodeCanvas.nodes [nodeCnt];`
`269`	`268`	`if (CanvasGUIToScreenRect (node.rect).Contains (pos)) // Node Body`
`270`	`269`	`return node;`
`271`		`- for (int knobCnt = 0; knobCnt < node.nodeKnobs.Count; knobCnt++)`
	`270`	`+ foreach (NodeKnob knob in node.nodeKnobs)`
`272`	`271`	`{ // Any edge control`
`273`		`- if (node.nodeKnobs[knobCnt].GetScreenKnob ().Contains (pos))`
	`272`	`+ if (knob.GetScreenKnob ().Contains (pos))`
`274`	`273`	`return node;`
`275`	`274`	`}`
`276`	`275`	`}`
`@@ -323,9 +322,9 @@ private static bool ignoreInput (Vector2 mousePos)`
`323`	`322`	`// Mouse outside of canvas rect or inside an ignoreInput rect`
`324`	`323`	`if (!curEditorState.canvasRect.Contains (mousePos))`
`325`	`324`	`return true;`
`326`		`- for (int ignoreCnt = 0; ignoreCnt < curEditorState.ignoreInput.Count; ignoreCnt++)`
	`325`	`+ foreach(Rect rect in curEditorState.ignoreInput)`
`327`	`326`	`{`
`328`		`- if (curEditorState.ignoreInput [ignoreCnt].Contains (mousePos))`
	`327`	`+ if (rect.Contains (mousePos))`
`329`	`328`	`return true;`
`330`	`329`	`}`
`331`	`330`	`return false;`
`@@ -433,9 +432,9 @@ public static void InputEvents ()`
`433`	`432`	`{ // A connection is drawn, so provide a context menu with apropriate nodes to auto-connect`
`434`	`433`	`foreach (Node node in NodeTypes.nodes.Keys)`
`435`	`434`	`{ // Iterate through all nodes and check for compability`
`436`		`- for (int inputCnt = 0; inputCnt < node.Inputs.Count; inputCnt++)`
	`435`	`+ foreach (NodeInput input in node.Inputs)`
`437`	`436`	`{`
`438`		`- if (node.Inputs[inputCnt].type == curEditorState.connectOutput.type)`
	`437`	`+ if (input.type == curEditorState.connectOutput.type)`
`439`	`438`	`{`
`440`	`439`	`menu.AddItem (new GUIContent ("Add " + NodeTypes.nodes[node].adress), false, ContextCallback, new NodeEditorMenuCallback (node.GetID, curNodeCanvas, curEditorState));`
`441`	`440`	`break;`
`@@ -531,8 +530,8 @@ public static void InputEvents ()`
`531`	`530`	`if (curEditorState.panWindow)`
`532`	`531`	`{ // Scroll everything with the current mouse delta`
`533`	`532`	`curEditorState.panOffset += e.delta * curEditorState.zoom;`
`534`		`- for (int nodeCnt = 0; nodeCnt < curNodeCanvas.nodes.Count; nodeCnt++)`
`535`		`- curNodeCanvas.nodes [nodeCnt].rect.position += e.delta * curEditorState.zoom;`
	`533`	`+ foreach (Node node in curNodeCanvas.nodes)`
	`534`	`+ node.rect.position += e.delta * curEditorState.zoom;`
`536`	`535`	`e.delta = Vector2.zero;`
`537`	`536`	`RepaintClients ();`
`538`	`537`	`}`
`@@ -731,9 +730,8 @@ public static void StopTransitioning (NodeCanvas nodeCanvas)`
`731`	`730`	`/// </summary>`
`732`	`731`	`private static void UpdateTransitions ()`
`733`	`732`	`{`
`734`		`- for (int cnt = 0; cnt < transitioningNodeCanvases.Count; cnt++)`
	`733`	`+ foreach (NodeCanvas nodeCanvas in transitioningNodeCanvases)`
`735`	`734`	`{`
`736`		`- NodeCanvas nodeCanvas = transitioningNodeCanvases[cnt];`
`737`	`735`	`if (!nodeCanvas.currentNode.AcceptsTranstitions \|\| nodeCanvas.currentNode.transitions.Count == 0)`
`738`	`736`	`{ // Error - this node should not have any transitions, in or out`
`739`	`737`	`StopTransitioning (nodeCanvas);`
`@@ -787,9 +785,8 @@ public static bool isTransitioning (NodeCanvas nodeCanvas)`
`787`	`785`	`/// </summary>`
`788`	`786`	`private static Transition GetNextTransition (Node node)`
`789`	`787`	`{`
`790`		`- for (int transCnt = 0; transCnt < node.transitions.Count; transCnt++)`
	`788`	`+ foreach (Transition trans in node.transitions)`
`791`	`789`	`{`
`792`		`- Transition trans = node.transitions[transCnt];`
`793`	`790`	`if (trans.startNode == node && trans.conditionsMet ())`
`794`	`791`	`return trans;`
`795`	`792`	`}`
`@@ -846,9 +843,9 @@ public static void StartCalculation ()`
`846`	`843`	`for (int roundCnt = 0; !limitReached; roundCnt++)`
`847`	`844`	`{ // Runs until every node possible is calculated`
`848`	`845`	`limitReached = true;`
`849`		`- for (int workCnt = 0; workCnt < workList.Count; workCnt++)`
	`846`	`+ foreach (Node node in workList)`
`850`	`847`	`{`
`851`		`- if (ContinueCalculation (workList [workCnt]))`
	`848`	`+ if (ContinueCalculation (node))`
`852`	`849`	`limitReached = false;`
`853`	`850`	`}`
`854`	`851`	`}`
`@@ -870,11 +867,10 @@ public static bool ContinueCalculation (Node node)`
`870`	`867`	`workList.Remove (node);`
`871`	`868`	`if (node.ContinueCalculation && calculationCount < 1000)`
`872`	`869`	`{`
`873`		`- for (int outCnt = 0; outCnt < node.Outputs.Count; outCnt++)`
	`870`	`+ foreach (NodeOutput output in node.Outputs)`
`874`	`871`	`{`
`875`		`- NodeOutput output = node.Outputs [outCnt];`
`876`		`- for (int conCnt = 0; conCnt < output.connections.Count; conCnt++)`
`877`		`- ContinueCalculation (output.connections [conCnt].body);`
	`872`	`+ foreach (NodeInput connection in output.connections)`
	`873`	`+ ContinueCalculation(connection.body);`
`878`	`874`	`}`
`879`	`875`	`}`
`880`	`876`	`else if (calculationCount >= 1000)`