Coroutine not starting

[VeryGoodDeveloperISwear]

When I run the code below, I get the “starting courotine” Debug.Log but I don’t get the other Debug.Logs

using System.Collections;
using UnityEngine;

public class TileSpawn : MonoBehaviour
{
    private Vector3 pos;
    public int tilesToSpawn;
    private bool isFirstTileSpawned;
    private bool isStartingLoop;
    private int curSquareDimensions;

    private IEnumerator courotine;

    [SerializeField] private GameObject tile;

    private void Start()
    {
        pos = new Vector2(0, 0);
        isFirstTileSpawned = false;
        courotine = SpawnTiles(3);
    }
    void Update()
    {
        if (curSquareDimensions*curSquareDimensions >= tilesToSpawn)
        {
            Debug.Log("starting courotine");
            StopCoroutine("SpawnTiles");
        }
        else
        {
            Debug.Log("starting courotine");
            StartCoroutine(courotine);
        }
    }

    private IEnumerator SpawnTiles(int squareDimensions)
    {
        Debug.Log("courotine is currently running");
        tilesToSpawn = squareDimensions * squareDimensions;

        if (!isFirstTileSpawned)
        {
            Instantiate(tile, pos, Quaternion.identity);
            Debug.Log("first tile spawned");
            isFirstTileSpawned = true;
            curSquareDimensions = 1;
        }

        isStartingLoop = true;
        if (curSquareDimensions < squareDimensions)
        {
            if (isStartingLoop)
            {
                pos.y += 1;
                Instantiate(tile, pos, Quaternion.identity);
                curSquareDimensions += 2;
                isStartingLoop = false;
            }

            //this is for making the starting top part, going right
            for (int i = 0; i < (curSquareDimensions-1)/2; i++)
            {
                pos.x += 1;
                Instantiate(tile, pos, Quaternion.identity);
                yield return null;
            }

            //this is for making the right side
            for (int i = 0; i < (curSquareDimensions-1); i++)
            {
                pos.y -= 1;
                Instantiate(tile, pos, Quaternion.identity);
                yield return null;
            }
           
            //this is for making the bottom side
            for (int i = 0; i < (curSquareDimensions-1); i++)
            {
                pos.x -= 1;
                Instantiate(tile, pos, Quaternion.identity);
                yield return null;
            }

            //this is for making the left side
            for (int i = 0; i < (curSquareDimensions-1); i++)
            {
                pos.y += 1;
                Instantiate(tile, pos, Quaternion.identity);
                yield return null;
            }

            //this is for making the top left side
            for (int i = 0; i < (curSquareDimensions-1)/2; i++)
            {
                pos.x += 1;
                Instantiate(tile, pos, Quaternion.identity);
                yield return null;
            }

            pos.x += 1;
            isStartingLoop = true;
        }
       
    }
}

Also, I know that this will not work currently

[Kurt-Dekker]

Coroutines in a nutshell:

Destroying the object then restarting the scene

Hey Epoch, here’s how it goes down. A coroutine is just an IEnumerator object, and you make one by just calling a coroutine. When you do that, nothing happens. It’s like a water pump that needs to have its crank pumped, but nobody is pumping it so it sits there and does nothing. In Unity there’s a special agreement: if you hand that IEnumerator object into StartCoroutine(), which is a method belonging to the object where that StartCoroutine() call is located, what Unity does is starts “pumpin…

Proper way to stop coroutine?

Coroutines are an IEnumerator object. They have their own internal state. It’s different from just calling InvokeRepeating(), which would restart a fresh function call each time. Here is ALL you need to know about coroutines in Unity: they are an IEnumerator, also known in some languages as a Generator. It is an object with a .MoveNext() method on it that “yields” the next thing with each subsequent call. That is what you create by calling an IEnumerator: you create the object, you do NOTHIN…

Splitting up larger tasks in coroutines:

Best Way to Split a Long-Running Function So it's Non-Blocking?

Technically, yeah, there’s always a way. But in practice, in the general sense it can get really hairy. Also, in the particular case of adding lots of GameObjects, I know they’re not linear: last I checked, adding 1000 GameObjects is WAY more than 10x slower than adding 100 Gameobjects, I presume due to inefficiencies in newly-added stuff, not sure/ No way to tell with a closed-source engine like Unity. Trying to tie into system timers and judge how long things have taken so far will get you …

Coroutines are NOT always an appropriate solution: know when to use them!

Things to check before starting a coroutine?

The main thing to check before calling / making a coroutine is to ask yourself, “Does this even need to be a coroutine?” Generally, if your design requires you to call StopCoroutine(), then don’t make it a coroutine. If you just need something to happen a bit later, this is a more-robust approach: https://gist.github.com/kurtdekker/0da9a9721c15bd3af1d2ced0a367e24e If you’re flipping from one value to another, such as fading in, fading out, changing speeds slowly, etc., coroutines are an AW…

Heartbeat courutine fx

There’s never a need. As @PraetorBlue pointed out in a recent post of his, nobody NEEDS coroutines. They do solve a certain class of problem nicely however, primarily problems of sequencing a set of data or events to happen. Coroutines CAN be interrupted and restarted but doing so exponentially increases your chance of a bug, negating a lot of their inherent benefits. A lot of human behaviors are good coroutines: “Go take a shower.” So that breaks down to: get undressed start the shower …

Our very own Bunny83 has also provided a Coroutine Crash Course:

https://answers.unity.com/questions/1749615/coroutines-ienumerator-not-working-as-expected.html?childToView=1749714#answer-1749714

[halley]

You need to use courotine = StartCoroutine(SpawnTiles(3)); - it’s not a coroutine unless you tell Unity that it’s a coroutine. (And spelling “coroutine” correctly will help you find and understand code better later, too.)

[VeryGoodDeveloperISwear]

@halley1

You need to use courotine = StartCoroutine(SpawnTiles(3));

When I replaced courotine = SpawnTiles(3); with the code you provided, it gave me an error saying "Cannot implicitly convert type ‘UnityEngine.Coroutine’ to ‘System.Collections.IEnumerator’ "

[halley]

Change the type on line 12.

IEnumerator is the return value type for a coroutine. But it is not a coroutine.

In a nutshell, these are the bits that make up code using coroutines. It’s not meant for you to cut and paste into your code, just for learning from it. Kurt above already gave you plenty of documentation.

private Coroutine coruotine;

// ...

coroutine = StartCoroutine(MyCoroutine());

// ...

StopCoroutine(coroutine);

// ...

IEnumerator MyCoroutine()
{
    // do stuff
    yield return null;
    // do more stuff
}

[VeryGoodDeveloperISwear]

    private Coroutine coroutine;

    [SerializeField] private GameObject tile;

    private void Start()
    {
        pos = new Vector2(0, 0);
        isFirstTileSpawned = false;
        coroutine = StartCoroutine(SpawnTiles(3));
    }
    void Update()
    {
        if (curSquareDimensions*curSquareDimensions >= tilesToSpawn)
        {
            Debug.Log("stopping courotine");
            StopCoroutine(coroutine);
        }
        else
        {
            Debug.Log("starting coroutine");
            _ = coroutine;
        }
    }

The coroutine only runs once despite “starting coroutine” being run multiple times, why is this? (Visual Studio 2019 told me to use a discard _ to stop the error when I just do coroutine; on line 21, same result occurs when I do StartCoroutine(SpawnTiles(3));)

[halley]

A couroutine only runs through its body once. The returned value is no longer useful once the coroutine gets to the bottom of its code, it basically stops itself when it’s done. If you want to start the couroutine again, you can: just call StartCoroutine again. PLEASE read the documentation that’s been given to you above.

[PraetorBlue]

@VeryGoodDeveloperISwear

The coroutine only runs once despite “starting coroutine” being run multiple times

Despite your log message on line 20, you are actually only ever starting the coroutine on line 9. That only happens once, in Start.

[VeryGoodDeveloperISwear]

For my case, I want a square made of evenly sized tiles and is odd in lengths so that it has a proper center, what should I use instead of a coroutine?

[Kurt-Dekker]

@VeryGoodDeveloperISwear

For my case, I want a square made of evenly sized tiles and is odd in lengths so that it has a proper center, what should I use instead of a coroutine?

Coroutines and grid spawning are not even remotely related or dependent.

If you need an example of spawning stuff in a grid, go look at my Bitmap2Grid example here:

MakeGeo is presently hosted at these locations:

https://bitbucket.org/kurtdekker/makegeo

GitHub - kurtdekker/makegeo: Make Geometry - Procedural Unity3D Geometry

Kurt Dekker / makegeo · GitLab

makegeo

[Ryiah]

@VeryGoodDeveloperISwear

For my case, I want a square made of evenly sized tiles and is odd in lengths so that it has a proper center, what should I use instead of a coroutine?

I refactored your code (with the assistance of GPT-4) to remove the coroutine. I did a rough count of the number of lines that were just boilerplate supporting the coroutine while adding nothing of value to the script and came out to at least 25 lines of code.

Refactored Script

using System.Collections;
using UnityEngine;

public class TileSpawn : MonoBehaviour
{
    private Vector3 pos;
    public int tilesToSpawn;
    private bool isFirstTileSpawned;
    private int curSquareDimensions;

    [SerializeField] private GameObject tile;

    private void Start()
    {
        pos = new Vector2(0, 0);
        isFirstTileSpawned = false;
        SpawnTiles(3);
    }

    private void SpawnTiles(int squareDimensions)
    {
        tilesToSpawn = squareDimensions * squareDimensions;

        if (!isFirstTileSpawned)
        {
            Instantiate(tile, pos, Quaternion.identity);
            isFirstTileSpawned = true;
            curSquareDimensions = 1;
        }

        while (curSquareDimensions < squareDimensions)
        {
            pos.y += 1;
            Instantiate(tile, pos, Quaternion.identity);
            curSquareDimensions += 2;

            SpawnTileLayer();
        }
    }

    private void SpawnTileLayer()
    {
        // Starting top part, going right
        for (int i = 0; i < (curSquareDimensions - 1) / 2; i++)
        {
            pos.x += 1;
            Instantiate(tile, pos, Quaternion.identity);
        }

        // Right side
        for (int i = 0; i < (curSquareDimensions - 1); i++)
        {
            pos.y -= 1;
            Instantiate(tile, pos, Quaternion.identity);
        }

        // Bottom side
        for (int i = 0; i < (curSquareDimensions - 1); i++)
        {
            pos.x -= 1;
            Instantiate(tile, pos, Quaternion.identity);
        }

        // Left side
        for (int i = 0; i < (curSquareDimensions - 1); i++)
        {
            pos.y += 1;
            Instantiate(tile, pos, Quaternion.identity);
        }

        // Top left side
        for (int i = 0; i < (curSquareDimensions - 1) / 2; i++)
        {
            pos.x += 1;
            Instantiate(tile, pos, Quaternion.identity);
        }

        pos.x += 1;
    }
}