pastemyst | Enemy from spawnpoint doesn't follow the generated path

Enemy from spawnpoint doesn't follow the generated path

EnemyWaveManager

C++copy raw

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class EnemyWaveManager : MonoBehaviour
{
    public float timeBetweenWaves = 5f;
    private float countdown = 2f;
    private int waveNumber = 0;
    public Transform spawnpoint;
    public GameObject enemyObject;
    private List<Vector2Int> pathCells;
    private GameObject enemyInstance;
    int nextPathCellIndex;
    bool enemyRunCompleted;

// Start is called before the first frame update
    void Start()
    {
        enemyInstance = Instantiate(enemyObject, new Vector3(0, 0.2f, 5f), Quaternion.identity );
        nextPathCellIndex = 1;
        enemyRunCompleted = false;
    }

// Update is called once per frame
    void Update()
    {
        if (pathCells !=null && pathCells.Count > 1 && !enemyRunCompleted)
        {
            Vector3 currentPos = enemyInstance.transform.position;
            Vector3 nextPos = new Vector3(pathCells[nextPathCellIndex].x, 0.2f, pathCells[nextPathCellIndex].y);
            enemyInstance.transform.position = Vector3.MoveTowards(currentPos, nextPos, Time.deltaTime * 2f);
            if (Vector3.Distance (currentPos, nextPos) < 0.05f) {

if (nextPathCellIndex >= pathCells.Count - 1)
                {
                    Debug.Log("Reached end");
                    enemyRunCompleted = true;
                } else
                {
                    nextPathCellIndex++;
                }
            }
        }

if (countdown <= 0f)
        {
            StartCoroutine(SpawnWave());
            countdown = timeBetweenWaves;
        }

countdown -= Time.deltaTime;

IEnumerator SpawnWave ()
        {
            waveNumber++;

for (int i = 0; i < waveNumber; i++)
            {
                SpawEnemy();

yield return new WaitForSeconds(0.5f);
            }

}

void SpawEnemy ()
        {
            enemyInstance = Instantiate(enemyObject, new Vector3(pathCells[0].x, 0.2f, pathCells[0].y), Quaternion.identity );      
        }

}

public void SetPathCells(List<Vector2Int> pathCells)
    {
        this.pathCells = pathCells;
    }
}

PathGenerator

C++copy raw

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PathGenerator
{
    private int  width, height;
    private List<Vector2Int> pathCells;
    private List<Vector2Int> route;

public PathGenerator(int width, int height)
    {
        this.width = width;
        this.height = height;   
    }

public List<Vector2Int> GeneratePath()
    {
        pathCells = new List<Vector2Int>();
        int y = (int)(height / 2);
        int x = 0;

while (x < width)
        {
            pathCells.Add(new Vector2Int(x, y));

bool validMove = false;

while (!validMove)
            {
                int move = Random.Range(0, 3);

if (move == 0 || x % 2 == 0 || x > (width - 2)) 
                {
                    x++;
                    validMove = true;
                }
                else if (move == 1 && CellIsEmpty(x, y + 1) && y < (height - 2))
                {
                    y++;
                    validMove = true;
                }
                else if (move == 2 && CellIsEmpty(x, y - 1) && y > 2)
                {
                    y--;
                    validMove = true;
                }
            }
        }

return pathCells;
    }

public List<Vector2Int> GenerateRoute()
    {
        Vector2Int direction = Vector2Int.right;
        route = new List<Vector2Int>();
        Vector2Int currentCell = pathCells[0];

while (currentCell.x < width)
        {
            route.Add(new Vector2Int(currentCell.x, currentCell.y));

if (CellIsTaken(currentCell + direction ))
            {
                currentCell = currentCell + direction;
            }
            else if (CellIsTaken(currentCell + Vector2Int.up) && direction != Vector2Int.down)
            {
                direction = Vector2Int.up;
                currentCell = currentCell + direction;
            }
            else if (CellIsTaken(currentCell + Vector2Int.down) && direction != Vector2Int.up)
            {
                direction = Vector2Int.down;
                currentCell = currentCell + direction;
            }
            else if (CellIsTaken(currentCell + Vector2Int.right) && direction != Vector2Int.left)
            {
                direction = Vector2Int.right;
                currentCell = currentCell + direction;
            }
            else if (CellIsTaken(currentCell + Vector2Int.left) && direction != Vector2Int.right)
            {
                direction = Vector2Int.left;
                currentCell = currentCell + direction;
            }
            else 
            {
                //Nowhere to go. Returning the route
                return route; 
            }
        }

return route;
    }
    public bool GenerateCrossroads()
    {
        for (int i = 0; i <pathCells.Count; i++)
        {
            Vector2Int pathCell = pathCells[i];

if (pathCell.x > 3 && pathCell.x < width - 4 && pathCell.y > 2 && pathCell.y < height - 3) 
            {
                if (CellIsEmpty(pathCell.x, pathCell.y + 3) && CellIsEmpty(pathCell.x + 1, pathCell.y + 3) && CellIsEmpty(pathCell.x + 2, pathCell.y + 3)
                    && CellIsEmpty(pathCell.x - 1, pathCell.y + 2) && CellIsEmpty(pathCell.x, pathCell.y + 2) && CellIsEmpty(pathCell.x + 1, pathCell.y + 2) && CellIsEmpty(pathCell.x + 2, pathCell.y + 2) && CellIsEmpty(pathCell.x + 3, pathCell.y + 2)
                    && CellIsEmpty(pathCell.x - 1, pathCell.y + 1) && CellIsEmpty(pathCell.x, pathCell.y + 1) && CellIsEmpty(pathCell.x + 1, pathCell.y + 1) && CellIsEmpty(pathCell.x + 2, pathCell.y + 1) && CellIsEmpty(pathCell.x + 3, pathCell.y + 1)
                    && CellIsEmpty(pathCell.x + 1, pathCell.y) && CellIsEmpty(pathCell.x + 2, pathCell.y) && CellIsEmpty(pathCell.x + 3, pathCell.y)
                    && CellIsEmpty(pathCell.x + 1, pathCell.y - 1) && CellIsEmpty(pathCell.x + 2, pathCell.y -1))
                {

pathCells.InsertRange(i + 1, new List<Vector2Int> { new Vector2Int(pathCell.x + 1, pathCell.y), new Vector2Int(pathCell.x + 2, pathCell.y), new Vector2Int(pathCell.x + 2, pathCell.y + 1), new Vector2Int(pathCell.x + 2, pathCell.y + 2), new Vector2Int(pathCell.x + 1, pathCell.y + 2), new Vector2Int(pathCell.x, pathCell.y + 2), new Vector2Int(pathCell.x, pathCell.y + 1) });
                    return true;
                }

if (CellIsEmpty(pathCell.x + 1, pathCell.y + 1) && CellIsEmpty(pathCell.x + 2, pathCell.y + 1) 
                    && CellIsEmpty(pathCell.x + 1, pathCell.y) && CellIsEmpty(pathCell.x + 2, pathCell.y) && CellIsEmpty(pathCell.x + 3, pathCell.y) 
                    && CellIsEmpty(pathCell.x - 1, pathCell.y - 1) && CellIsEmpty(pathCell.x, pathCell.y - 1) && CellIsEmpty(pathCell.x + 1 , pathCell.y - 1) && CellIsEmpty(pathCell.x + 2, pathCell.y - 1) && CellIsEmpty(pathCell.x + 3, pathCell.y - 1)
                    && CellIsEmpty(pathCell.x - 1, pathCell.y - 2) && CellIsEmpty(pathCell.x, pathCell.y - 2) && CellIsEmpty(pathCell.x + 1 , pathCell.y - 2) && CellIsEmpty(pathCell.x + 2, pathCell.y - 2) && CellIsEmpty(pathCell.x + 3, pathCell.y - 2)
                    && CellIsEmpty(pathCell.x, pathCell.y - 3) && CellIsEmpty(pathCell.x + 1, pathCell.y - 3) && CellIsEmpty(pathCell.x + 2, pathCell.y - 3)) 
                {
                    pathCells.InsertRange(i + 1, new List <Vector2Int> { new Vector2Int(pathCell.x + 1, pathCell.y), new Vector2Int(pathCell.x + 2, pathCell.y), new Vector2Int(pathCell.x + 2, pathCell.y - 1), new Vector2Int(pathCell.x + 2, pathCell.y - 2), new Vector2Int(pathCell.x + 1, pathCell.y - 2), new Vector2Int(pathCell.x, pathCell.y - 2), new Vector2Int(pathCell.x, pathCell.y - 1) });
                    return true;
                }
            }
        }

return false;

}
    public bool CellIsEmpty(int x, int y)
    {
        return !pathCells.Contains(new Vector2Int(x, y));
    }

public bool CellIsTaken(int x, int y)
    {
        return pathCells.Contains(new Vector2Int(x, y));
    }

public bool CellIsTaken(Vector2Int cell)
    {
        return pathCells.Contains(cell);
    }

public int getCellNeighbourValue(int x, int y)
    {
        int returnValue = 0;

if (CellIsTaken(x, y - 1 ))
        {
            returnValue += 1;
        }

if (CellIsTaken(x - 1, y))
        {
            returnValue += 2;
        }
        
        if (CellIsTaken(x + 1, y))
        {
            returnValue += 4;
        }

if (CellIsTaken(x, y + 1 ))
        {
            returnValue += 8;
        }

return returnValue;
    }

}

GridManager

C++copy raw

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GridManager : MonoBehaviour
{
    public int gridwidth = 16;
    public int gridheight = 8;
    public int minPathLength = 30;
    private EnemyWaveManager waveManager;

public GridCellObject[] gridCells;
    public GridCellObject[] sceneryCells;

private PathGenerator  pathGenerator;

// Start is called before the first frame update
    void Start()
    {
        pathGenerator = new PathGenerator(gridwidth, gridheight);
        waveManager = GetComponent<EnemyWaveManager>();

List<Vector2Int> pathCells = pathGenerator.GeneratePath();
        int pathSize = pathCells.Count;
        
        while (pathSize < minPathLength)
        {
            pathCells = pathGenerator.GeneratePath();
            while (pathGenerator.GenerateCrossroads());
            pathSize = pathCells.Count;
        }

StartCoroutine(CreateGrid(pathCells));
    }

IEnumerator CreateGrid(List<Vector2Int> pathCells)
    {
        yield return LayPathCells(pathCells);
        yield return LaySceneryCells();
        waveManager.SetPathCells(pathGenerator.GenerateRoute());
    }

private IEnumerator LayPathCells(List<Vector2Int> pathCells)
    {    
        foreach (Vector2Int pathCell in pathCells)
        {
            int neighbourValue = pathGenerator.getCellNeighbourValue(pathCell.x, pathCell.y);
            // Debug.Log("Tile " + pathCell.x + " , " + pathCell.y + "neighbour value = " + neighbourValue);
            GameObject pathTile = gridCells[neighbourValue].cellPrefab;
            GameObject pathTileCell = Instantiate(pathTile, new Vector3(pathCell.x, 0f, pathCell.y), Quaternion.identity);
            pathTileCell.transform.Rotate(0f, gridCells[neighbourValue].yRotation, 0f, Space.Self);

yield return new WaitForSeconds(0.1f);
        }

yield return null;
    }

IEnumerator LaySceneryCells()
    {
        Debug.Log("Lay Scenery Cells started");
        for (int x = 0; x <gridwidth; x++)
        {
            for (int y = 0; y <gridheight; y++)
            {
                if (pathGenerator.CellIsEmpty(x, y))
                {
                    int randomSceneryCellIndex = Random.Range(0, sceneryCells.Length);
                    Instantiate(sceneryCells[randomSceneryCellIndex].cellPrefab, new Vector3(x, 0f, y), Quaternion.identity);
                    yield return new WaitForSeconds(0.030f);
                }
            }
        }

yield return null;
    }

}

created at:

stats: 330 lines, 1135 words, 11.43kb