PO/Assets/Scripts/DeckManager.cs

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

public class DeckManager : MonoBehaviour
{
    public static DeckManager main;
    [SerializeField] private List<GameObject> deck = new List<GameObject>();
    [SerializeField] private List<Transform> cardsPosition = new List<Transform>();
    private List<GameObject> currentDeck = new List<GameObject>();
    //private List<CardConfig> passedDeck = new List<CardConfig>();
    [HideInInspector] public List<GameObject> CardInTable = new List<GameObject>();
    public int numberCurrentCard;
    public CardConfig currentCard;
    [Header("Stamina")]
    [SerializeField] private List<Image> staminaCells = new List<Image>();
    [HideInInspector] public int stamina;
    [SerializeField] private GameObject firstCard;
    [SerializeField] private GameObject firstEquip;
    [SerializeField] private GameObject secondCard;
    [SerializeField] private GameObject secondEquip;
    public bool waitingEnemyTurn = false;

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

        main = this;
    }
    private void Start()
    {
        stamina = 3;
        CompletionDeck();
        HandingOut();
        for (int i = 0; i < DataHolder.main.PlayerEquipment.Count; i++)
        {
            var _equipmentCharacter =
                DataHolder.main.PlayerEquipment[i].GetComponent<Equipment>().equipmentConfig.equipmentCharacteristics;
            if (_equipmentCharacter.equipmentCards.Length != 0)
            {
                for (int j = 0; j < _equipmentCharacter.equipmentCards.Length; j++)
                {
                    AddCard(_equipmentCharacter.equipmentCards[i]);
                }
            }
        }
    }

    public void CheckLevel(GameObject _card)
    {
        // Мне за это стыдно, но в голову иных варинтов не приходит
        var _cardCharacteristics = _card.GetComponent<Card>().cardConfig.CardCharacteristics;
        if (((int)_cardCharacteristics.level) == 1)
        {
            _cardCharacteristics.quantityStamina = _cardCharacteristics.quantityStamina2;
            _cardCharacteristics.quantityHealth = _cardCharacteristics.quantityHealth2;
            _cardCharacteristics.damage = _cardCharacteristics.damage2;
            _cardCharacteristics.addHealth = _cardCharacteristics.addHealth2;
            _cardCharacteristics.addStamina = _cardCharacteristics.addStamina2;
            _cardCharacteristics.addArmor = _cardCharacteristics.addArmor2;
        }
    }

    public void AddCard(GameObject card)
    {
        deck.Add(card);
    }
    public void DeletedCard(GameObject card)
    {
        for (int i = 0; i < deck.Count; i++)
        {
            if (deck[i] == card)
            {
                deck.RemoveAt(i);
                return;
            }
        }
        Debug.LogWarning("No card found to delete");
    }
    public void HandingOut()
    {
        for (int i = 0; i < 5; i++)
        {
            if (currentDeck.Count > 0)
            {
                CompletionDeck();
            }
            int _number = Random.Range(0, currentDeck.Count);

            GameObject _card = Instantiate(currentDeck[_number], cardsPosition[i]);
            _card.GetComponent<Card>().number = i;
            CardInTable.Add(_card);
            CheckLevel(_card);
            currentDeck.RemoveAt(_number);
        }
    }
    public void CompletionDeck()
    {
        for (int i = 0; i < deck.Count; i++)
        {
            currentDeck.Add(deck[i]);
        }
    }
    public void NewStaminaQuantity(int q)
    {
        stamina = q;
        if (stamina > 3) stamina = 3;

        for (int i = 0; i < 3; i++)
        {
            if (i < stamina)
            {
                staminaCells[i].enabled = true;
            }
            else
            {
                staminaCells[i].enabled = false;
            }
        }
    }
    public void EndTurn(bool enemyTurn)
    {
        if (waitingEnemyTurn || Session.main.waitingEndingRound) return;
        currentCard = null;
        MarkersRegulator();
        for (int i = 0; i < 5; i++)
        {
            if (CardInTable[i] != null)
            {
                CardInTable[i].GetComponent<Card>().DestroyObject();
            }
        }
        CardInTable.Clear();
        HandingOut();
        if (stamina < 3)
            NewStaminaQuantity(stamina + 1);
        //нужна корутина для вражеского хода
        if (enemyTurn)
            StartCoroutine(EnemyStep());
        //а, вот же она

    }
    public void MarkersRegulator()
    {
        List<GameObject> _enemies = Session.main.currentEnemies;
        for (int i = 0; i < _enemies.Count; i++)
        {
            if (_enemies[i] != null)
            {
                _enemies[i].GetComponent<Enemy>().OffMarker();
            }
        }
        Player.main.OffMarker();
        if (currentCard == null)
        {
            return;
        }

        var _specializationCard = currentCard.CardCharacteristics.specialization;
        for (int i = 0; i < _enemies.Count; i++)
        {
            if (_enemies[i] != null)
            {
                if (_specializationCard == Specialization.meleeAtack)
                {
                    _enemies[i].GetComponent<Enemy>().OnMarker();
                    return;
                }
                else if (_specializationCard == Specialization.longAttack)
                {
                    _enemies[i].GetComponent<Enemy>().OnMarker();
                }

            }
        }
        if (_specializationCard == Specialization.healing)
        {
            Player.main.OnMarker();
        }

    }
    public void ActionInEnemy(Enemy enemy)
    {
        if (waitingEnemyTurn || currentCard == null || !enemy.CheckMarker()) return;

        var _local = (int)currentCard.CardCharacteristics.enemyCount;

        if (_local != 0)
        {
            MassiveAttack(_local);
        }
        else
        {
            if (currentCard.CardCharacteristics.damage > 0)
            {
                enemy.ChangeHp(currentCard.CardCharacteristics.damage);
            }
            else if (currentCard.CardCharacteristics.addHealth > 0)
            {
                enemy.ChangeHp(-currentCard.CardCharacteristics.addHealth);
            }
        }
        NewStaminaQuantity(stamina - currentCard.CardCharacteristics.quantityStamina);
        CardInTable[numberCurrentCard].GetComponent<Card>().DestroyObject();
        currentCard = null;
        MarkersRegulator();
    }

    IEnumerator EnemyStep()
    {
        waitingEnemyTurn = true;
        Session.main.EnemiesStep();
        yield return new WaitForSeconds(0.5f);
        waitingEnemyTurn = false;

    }

    public void MassiveAttack(int _targetCount)
    {
        if(Session.main.currentEnemies.Count < _targetCount)
        {
            _targetCount = Session.main.currentEnemies.Count;
        }

        for (int i = 0; i < _targetCount; i++)
        {
            Session.main.currentEnemies[i].GetComponent<Enemy>().ChangeHp(currentCard.CardCharacteristics.damage);
        }
    }
}