SpawnManager.cs

Ir a la documentación de este archivo.

 
using UnityEngine;
using System.Collections;

[System.Serializable]
public class Wave
{
    public string name;

    public GameObject[] enemyPrefabs;

    public int count;

    public float spawnRate;
}

public class SpawnManager : MonoBehaviour
{
    // ========== CONFIGURACIÓN DE OLEADAS ==========

    [Header("Oleadas y niveles")]
    public Wave[] waves;

    public float timeBetweenWaves = 5f;

    public float difficultyScalePerLevel = 1.2f;
 
    // ========== CONFIGURACIÓN DE SPAWN ==========

    [Header("Puntos de Spawn")]
    public Transform[] spawnPoints;
 
    // ========== CONFIGURACIÓN DE POWER-UPS ==========

    [Header("Power-Ups")]
    [Tooltip("Lista de prefabs de Power-Up a spawnear aleatoriamente")]
    public GameObject[] powerUpPrefabs;

    [Tooltip("Número base de power-ups por nivel")]
    public int basePowerUpsPerLevel = 1;
 
    // ========== ESTADO INTERNO ==========

    private int currentWaveIndex = 0;

    private int currentLevel = 1;
 
    // ========== FLUJO PRINCIPAL ==========

    void Start()
    {
        StartCoroutine(SpawnWavesRoutine());
    }

    IEnumerator SpawnWavesRoutine()
    {
        yield return new WaitForSeconds(timeBetweenWaves);
 
        while (true)
        {
            Wave wave = waves[currentWaveIndex];
            Debug.Log($"Nivel {currentLevel} – Oleada: {wave.name}");
 
            // === Calculamos generación de Power-Ups durante la oleada ===
            int puCount = Mathf.CeilToInt(basePowerUpsPerLevel * currentLevel);
            if (puCount > 0 && powerUpPrefabs.Length > 0)
            {
                float waveDuration = wave.count / wave.spawnRate;
                StartCoroutine(SpawnPowerUpsDuringWave(puCount, waveDuration));
            }
 
            // === Generación de enemigos ===
            for (int i = 0; i < wave.count; i++)
            {
                SpawnEnemyFromWave(wave);
                yield return new WaitForSeconds(1f / wave.spawnRate);
            }
 
            // Espera a que no quede ningún enemigo en pantalla
            while (GameObject.FindGameObjectsWithTag("Enemy").Length > 0)
                yield return null;
 
            // Preparar siguiente oleada / nivel
            currentWaveIndex++;
            if (currentWaveIndex >= waves.Length)
            {
                currentLevel++;
                ScaleWavesForNextLevel();
                currentWaveIndex = 0;
            }
 
            yield return new WaitForSeconds(timeBetweenWaves);
        }
    }

    private IEnumerator SpawnPowerUpsDuringWave(int count, float duration)
    {
        float interval = duration / count;
        for (int i = 0; i < count; i++)
        {
            yield return new WaitForSeconds(interval);
 
            var puPrefab = powerUpPrefabs[Random.Range(0, powerUpPrefabs.Length)];
            var spawnPt = spawnPoints[Random.Range(0, spawnPoints.Length)];
            Instantiate(puPrefab, spawnPt.position, spawnPt.rotation);
        }
    }

    void SpawnEnemyFromWave(Wave wave)
    {
        var prefab = wave.enemyPrefabs[Random.Range(0, wave.enemyPrefabs.Length)];
        var point = spawnPoints[Random.Range(0, spawnPoints.Length)];
        var enemy = Instantiate(prefab, point.position, Quaternion.Euler(0, 0, 180));
        enemy.tag = "Enemy";
    }

    void ScaleWavesForNextLevel()
    {
        Debug.Log($"Subiendo a nivel {currentLevel}, escalando dificultad...");
        for (int i = 0; i < waves.Length; i++)
        {
            waves[i].count = Mathf.CeilToInt(waves[i].count * difficultyScalePerLevel);
            waves[i].spawnRate *= difficultyScalePerLevel;
        }
    }
}