Mfcttrf

I'm new to Unity. I was learning coroutines and I wrote this.

When the button is pressed the coroutine is called and it enters the 'while' loop. When I leave the button it stops the coroutine. Shouldn't it get stuck in the 'while' loop as it is an infinite loop ? Why?

When the fire button is lifted, the second if statement is entered, and StopAllCoroutines is run. This means that the Coroutine that the while loop is running in is ended, thus there is no more infinite loop. The coroutine is like a container for the code to execute in.

I can recommend the Unity Manual and the Unity Scripting API to get a better grasp on what coroutines are and how powerful they can be.

This blog and searching youtube post was also helpful for me to better use coroutines.

Coroutines are a strange beast. Yield return causes the method to suspend execution until it is later stepped. Behind the scenes, it might look something like this:

class FireContinuouslyData 
 int state;
 bool shouldBreak;


object FireContinuously(FireContinuouslyData data) 
 switch (data.state) 
 case 0:
 goto State_0;
 
 while (true) 
 GameObject laser = ...;
 laser.GetComponent...
 //the next three lines handle the yield return
 data.state = 0;
 return new WaitForSeconds(fireTime);
 State_0:
 

And internal to Unity/C# (since yield return is a native c# feature), when you call StartCoroutine, it creates a FireContinuouslyData object, and pass it in to the method. Based on the return value, it determines when to call it again later, simply storing the FireContinuouslyData object to pass it in next time.

If you ever did a yield break, it could internally just set data.shouldBreak = true and then Unity would simply throw away the data and not schedule it again.

And if there were any data that needed to be saved between executions, it would also be stored in the data for later.

An example of how Unity/C# might implement the coroutine functionality:

//Internal to Unity/C#

class Coroutine 
 Action<object> method;
 object data;


Coroutine StartCoroutine(IEnumerator enumerator) 
 object data = CreateDataForEnumerator(method); //Very internal to C#
 Action<object> method = GetMethodForEnumerator(enumerator); //Also very internal to C#
 Coroutine coroutine = new Coroutine(method, data);
 RunCoroutine(coroutine);
 return coroutine;


//Called whenever this coroutine is scheduled to run
void RunCoroutine(Coroutine coroutine) 
 object yieldInstruction = coroutine.method(coroutine.data);
 if (!data.shouldBreak) 
 //Put this coroutine into a collection of coroutines to run later, by calling RunCoroutine on it again
 ScheduleForLater(yieldInstruction, coroutine);
 

Another answer mentions that you are stopping co-routines when "Fire1" is up - this is completely correct, insofar as why the coroutine does not continue instantiating GameObjects after the first press of "Fire1".

In your case however this code will not become 'stuck' in an infinite loop, which is what it looks like you're looking for an answer to - i.e. the while(true) loop, even if you did not stop it externally.

It won't get stuck but your coroutine won't end (without calling StopCoroutine() or StopAllCoroutines()) either. This is because Unity coroutines yield control to their caller. yielding is different to returning:

• a return statement will cease execution of a function, even if there is more code following it


• a yield statement will pause the function, starting at the next line after yield when resumed.

Usually, coroutines will be resumed each frame but you're also returning a WaitForSeconds object.

The line yield return new WaitForSeconds(fireTime) roughly translates as "now suspend me, and don't come back until fireTime seconds have passed".

IEnumerator FireContinuously()

 // When started, this coroutine enters the below while loop...
 while(true)
 
 // It does some things... (Infinite coroutine code goes here)

 // Then it yields control back to it's caller and pauses...
 yield return new WaitForSeconds(fireTime);
 // The next time it is called , it resumes here...
 // It finds the end of a loop, so will re-evaluate the loop condition...
 // Which passes, so control is returned to the top of the loop.
 

Unless stopped, this is a coroutine which, once started, will perform the whole loop once every fireTime seconds.

A simple explanation: under the hood Unity is iterating over a collection (of YieldInstructions or nulls or whatever you yield return) using the IEnumerator that your function returns.

Since you use the yield keyword, your method is an iterator. It's not the Unity thing, it's a C# language feature. How does it work?

It is lazy and doesn't generate all the collection at once (and the collection may be infinite and impossible to be generated at once). Elements of the collection are generated as needed. Your function returns an iterator for Unity to work with. It calls its MoveNext method to generate a new element and Current property to access it.

So your loop isn't endless, it runs some code, returns an element and returns control back to Unity so it's not stuck and can do other work such as handling your input to stop the coroutine.

The reason is the keyword yield which has a specific meaning in C#.

On encountering the words yield return a function in C# returns, as one would expect.

Using yield to define an iterator removes the need for an explicit extra class

[...]

When a yield return statement is reached in the iterator method, expression is returned, and the current location in code is retained. Execution is restarted from that location the next time that the iterator function is called.

So there is no infinite loop. There is a function/iterator that can be called an infinite number of times.

The Unity function StartCoroutine() makes the Unity framework call the function/iterator once per frame.

The Unity function StopAllCoroutines makes the Unity framework stop calling the function/iterator.

And returning WaitForSeconds(time) from the iterator makes the Unity framework suspend calling the function/iterator for time.