PO/Assets/Scripts/Session.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEngine.Events;
using UnityEngine.UI;
using UnityEngine.SceneManagement;

public class Session : MonoBehaviour
{
    public static Session main;
    [SerializeField] private PlayerConfig playerConfig;
    [SerializeField] private BattleConfig battleConfig;

    [SerializeField] private UnityEvent onVictory;
    [SerializeField] private UnityEvent onDefeat;



    [Header("Enemies")]
    [Space]

    [SerializeField] private List<Transform> enemyUIPositions = new List<Transform>();
    [SerializeField] private List<GameObject> enemyPrefabs;
    [Header("Player")]
    [SerializeField] private GameObject player;
    [SerializeField] private Transform playerPosition;


    [Space(3)]
    [Header("For checking")]
    public int numberPhase = 1;
    public int quantityEnemies = 0;
    public bool waitingEndingRound = false;

    public List<GameObject> currentEnemies = new List<GameObject>();

    private void Awake()
    {
        if (main != null && main != this)
        {
            Debug.LogWarning("2 session on the scene");
            Destroy(this);
            return;
        }

        main = this;
    }
    public void Start()
    {
        CreatePlayer();
        FirstPhase();
    }
    public void FirstPhase()
    {
        var FP = battleConfig.battleCharacteristics.firstPhaseOptions;
        int quantity = Random.Range(FP.minimumQuantity, FP.maximumQuantity + 1);
        for (int i = 0; i < quantity; i++)
        {
            quantityEnemies++;
            EnemyConfig enemy = Randomizer(i, FP.enemies);
            currentEnemies.Add(CreateEnemies(enemy, i));

        }
    }

    public void SecondPhase()
    {
        if (!battleConfig.battleCharacteristics.SecondPhase)
        {
            Victory();
            return;
        }
        var SP = battleConfig.battleCharacteristics.SecondPhaseOptions;
        int quantity = Random.Range(SP.minimumQuantity, SP.maximumQuantity);
        for (int i = 0; i < quantity; i++)
        {
            quantityEnemies++;
            EnemyConfig enemy = Randomizer(i, SP.enemies);
            currentEnemies.Add(CreateEnemies(enemy, i));

        }
    }

    public void ThirdPhase()
    {
        if (!battleConfig.battleCharacteristics.ThirdPhase)
        {
            Victory();
            return;
        }
        var TP = battleConfig.battleCharacteristics.ThirdPhaseOptions;
        int quantity = Random.Range(TP.minimumQuantity, TP.maximumQuantity);
        for (int i = 0; i < quantity; i++)
        {
            quantityEnemies++;
            EnemyConfig enemy = Randomizer(i, TP.enemies);
            currentEnemies.Add(CreateEnemies(enemy, i));

        }
    }

    public void Victory()
    {
        onVictory?.Invoke();
    }
    public void Defeat()
    {
        onDefeat?.Invoke();
    }
    public void EnemyDeath(GameObject _deadEnemy)
    {
        quantityEnemies--;
        for(int i = 0; i < currentEnemies.Count; i++)
        {
            if(currentEnemies[i] == _deadEnemy)
            {
                Destroy(currentEnemies[i]);
                currentEnemies.RemoveAt(i);
            }
        }
        if (quantityEnemies == 0)
        {

            StartCoroutine(ChekingCoroutine());
        }
        SwitchEnemyPosition();
    }

    IEnumerator ChekingCoroutine()
    {
        waitingEndingRound = true;
        currentEnemies.Clear();
        yield return new WaitForSeconds(0.5f);
        if (numberPhase == 1 && battleConfig.battleCharacteristics.SecondPhase)
        {
            numberPhase++;
            SecondPhase();
        }
        else if (numberPhase == 2 && battleConfig.battleCharacteristics.ThirdPhase)
        {
            numberPhase++;
            ThirdPhase();
        }
        else
        {
            Victory();
        }
        waitingEndingRound = false;
    }


    // RandomBlock

    EnemyConfig Randomizer(int _position, List<EnemyConfig> _enemyConfigs)
    {
        for (int i = 0; i < _enemyConfigs.Count; i++)
        {
            if (_enemyConfigs[i].enemyCharacteristics.minimumPosition < _position + 1
            || _enemyConfigs[i].enemyCharacteristics.maximumPosition > _position + 1)
            {
                return RandomInRandomizer(_position, _enemyConfigs);
            }
        }
        Debug.LogError("WARNING! no config found for position" + _position.ToString());
        return null;
    }


    EnemyConfig RandomInRandomizer(int _position, List<EnemyConfig> _enemyConfigs)
    {
        int _numberEnemy;
        _numberEnemy = Random.Range(0, _enemyConfigs.Count);

        if (_enemyConfigs[_numberEnemy].enemyCharacteristics.minimumPosition > _position + 1
            || _enemyConfigs[_numberEnemy].enemyCharacteristics.maximumPosition < _position + 1)
        {
            return Randomizer(_position, _enemyConfigs);
        }
        return _enemyConfigs[_numberEnemy];
    }



    // RandomBlock end

    public GameObject CreateEnemies(EnemyConfig _config, int _position)
    {
        for (int i = 0; i < enemyPrefabs.Count; i++)
        {
            if (enemyPrefabs[i].GetComponent<Enemy>().enemyConfig == _config)
            {
                GameObject _enemy = Instantiate(enemyPrefabs[i], enemyUIPositions[_position]);
                _enemy.GetComponent<Enemy>().currentPosition = _position;
                return (_enemy);
            }
        }
        Debug.LogError("enemy prefab not found. Please, check battleConfig and enemyPrefabs");
        return null;

    }

    public void SwitchEnemyPosition()
    {
        for (int i = 0; i < currentEnemies.Count; i++)
        {
            currentEnemies[i].GetComponent<Enemy>().currentPosition = i;
            currentEnemies[i].transform.position = enemyUIPositions[currentEnemies[i].GetComponent<Enemy>().currentPosition].position;

        }
    }

    public void CreatePlayer()
    {
        Instantiate(player, playerPosition);
        Player.main.playerConfig = playerConfig;
        Player.main.NewInformation();
    }


    public void EnemiesStep()
    {
        for (int i = 0; i < currentEnemies.Count; i++)
        {
            if (currentEnemies[i] != null)
            {
                currentEnemies[i].GetComponent<Enemy>().Turn();
            }
        }
    }
}