task32

using System;
using System.Threading;

public class Program
{
    public static void Main()
    {
        Arena arena = new Arena();
        bool isFighting = true;
        const int TimeWait = 800;
        string name;

        while (isFighting)
        {
            arena.Update();

            if (arena.IsWin(out name))
            {
                Console.WriteLine($"Player : {name} win.");
                isFighting = false;
            }

            Thread.Sleep(TimeWait);
        }
    }
}

public class Arena
{
    private Gladiator _playerFirst;
    private Gladiator _playerSecond;

    private Gladiator[] _gladiators;
    private readonly Random _random;
    private bool _isFirstPlayerTurn;
    private int _turnAmount;

    private int _healthMinimum = 15;
    private int _healthMaximum = 300;
    private int _damageMinimum = 40;
    private int _damageMaximum = 150;
    private int _archetypeMinimum = 1;
    private int _archetypeMaximum = 3;

    private int _gladiatorsAmount = 5;
    private int _turnsTimeReload = 3;
    private int _turnsTimeStun = 2;

    public Arena()
    {
        _random = new Random();
        _isFirstPlayerTurn = true;
        _turnAmount = 1;
        _playerFirst = ChooseGladiator();
        _playerSecond = ChooseGladiator();
    }

    public void Update()
    {
        Console.Clear();

        if (_isFirstPlayerTurn)
        {
            PrintPlayer(_playerFirst, _playerSecond);
            AttackPlayer(_playerFirst, _playerSecond); ;
            _isFirstPlayerTurn = false;
        }
        else
        {
            PrintPlayer(_playerSecond, _playerFirst);
            AttackPlayer(_playerSecond, _playerFirst);
            _isFirstPlayerTurn = true;
        }

        CheckTurns(_playerSecond);
        CheckTurns(_playerFirst);
        ++_turnAmount;
    }

    public bool IsWin(out string name)
    {
        name = "";

        if (_playerSecond.IsDead())
        {
            name = _playerFirst.Name;
            return true;
        }
        else if (_playerFirst.IsDead())
        {
            name = _playerSecond.Name;
            return true;
        }

        return false;
    }

    private void CreateGladiators()
    {
        int health;
        int damage;
        int archetypeNumber;
        Gladiator gladiator = null;
        _gladiators = new Gladiator[_gladiatorsAmount];

        for (int i = 0; i < _gladiatorsAmount; ++i)
        {
            health = _random.Next(_healthMinimum, _healthMaximum);
            damage = _random.Next(_damageMinimum, _damageMaximum);
            archetypeNumber = _random.Next(_archetypeMinimum, _archetypeMaximum);

            switch(archetypeNumber)
            {
                case 1:
                    gladiator = new Fighter(health, damage);
                    break;
                case 2:
                    gladiator = new Mage(health, damage);
                    break;
                case 3:
                    gladiator = new Archer(health, damage);
                    break;
            }

            _gladiators[i] = gladiator;
        }
    }

    private Gladiator ChooseGladiator()
    {
        Gladiator player = null;
        string playerName;

        CreateGladiators();

        Console.Clear();
        Console.WriteLine("Input name of player : ");
        playerName = Console.ReadLine();

        int chooseNumber;
        bool isParsed;
        bool isInput = true;

        do
        {
            for (int i = 0; i < _gladiatorsAmount; ++i)
                Console.WriteLine($"\n{i} : {_gladiators[i]}");

            Console.WriteLine("\nInput number of gladiator : ");
            isParsed = int.TryParse(Console.ReadLine(), out chooseNumber);

            if (isParsed && (chooseNumber >= 0 && chooseNumber < _gladiatorsAmount))
            {
                player = _gladiators[chooseNumber];
                player.SetName(playerName);
                isInput = false;
            }
        }
        while (isInput);

        Console.WriteLine();

        return player;
    }

    private void PrintPlayer(Gladiator playerFirst, Gladiator playerSecond)
    {
        Console.WriteLine($"Turn : {_turnAmount}");

        if (playerFirst.IsActive != true)
        {
            Console.WriteLine($"Now turn is : {playerFirst.Name}");
            Console.WriteLine("You are stunned");
        }
        else
        {
            Console.WriteLine($"Now turn is : {playerFirst.Name}");
            Console.WriteLine("You : \n" + playerFirst);
            Console.WriteLine("Enemy : \n" + playerSecond);
        }
    }

    private void AttackPlayer(Gladiator playerFirst, Gladiator playerSecond)
    {
        if (playerFirst.IsActive == true)
        {
            bool isAttackChoosing = true;
            string input;

            do
            {
                Console.WriteLine("\nChoose attack:");
                Console.WriteLine("1. Default attack.");
                if (playerFirst.IsActiveSpecialAttack == true)
                    Console.WriteLine("2. Special Attack");

                input = Console.ReadLine();

                if (input.Equals("1"))
                {
                    playerFirst.Attack(playerSecond);
                    isAttackChoosing = false;
                }
                else if (input.Equals("2") && playerFirst.IsActiveSpecialAttack == true)
                {
                    playerFirst.AttackSpecial(playerSecond, _turnAmount);
                    isAttackChoosing = false;
                }
            }
            while (isAttackChoosing);
        }
    }

    private Gladiator CheckTurns(Gladiator player)
    {
        if (player.IsActive != true && _turnAmount - player.TurnStun >= _turnsTimeStun)
            player.Activate();

        if (player.IsActiveSpecialAttack != true && _turnAmount - player.TurnReload >= _turnsTimeReload)
            player.ReloadAttackSpecial();

        return player;
    }
}

public class Gladiator
{
    protected int Health;
    protected int Damage;
    protected int DamageSpecialAttack;
    protected int DamageIncreaseNumber;

    public int TurnStun { get; private set; }
    public int TurnReload { get; private set; }
    public string Name { get; private set; }

    public bool IsActiveSpecialAttack { get; private set; }
    public bool IsActive { get; private set; }

    public Gladiator(int health, int damage)
    {
        SetValues(health, damage);
    }

    public void Attack(Gladiator gladiator)
    {
        gladiator.TakeDamage(Damage);
        Console.WriteLine($"You decrease : {Damage} hp enemy.");
    }

    public void TakeDamage(int damage)
    {
        Health -= damage;
    }

    public void Stun(int turn)
    {
        IsActive = false;
        TurnStun = turn;
    }

    public void Activate()
    {
        IsActive = true;
        TurnStun = -1;
    }

    public void UseAttackSpecial(int turn)
    {
        IsActiveSpecialAttack = false;
        TurnReload = turn;
    }

    public void ReloadAttackSpecial()
    {
        IsActiveSpecialAttack = true;
        TurnReload = -1;
    }

    public bool IsDead()
    {
        return Health <= 0;
    }

    public void SetName(string name)
    {
        Name = name;
    }

    public virtual void AttackSpecial(Gladiator gladiator, int turn)
    {
    }

    public override string ToString()
    {
        string result = "\n";
        result += "Health : " + Health + " \n";
        result += "Damage : " + Damage + " \n";
        return result;
    }

    private void SetValues(int health, int damage)
    {
        Health = health;
        Damage = damage;
        TurnStun = -1;
        TurnReload = -1;
        IsActiveSpecialAttack = true;
        IsActive = true;
    }
}

public class Fighter : Gladiator
{
    public Fighter(int health, int damage) : base (health, damage)
    {
        DamageIncreaseNumber = 40;
        DamageSpecialAttack += damage + DamageIncreaseNumber;
    }

    public override void AttackSpecial(Gladiator gladiator, int turn)
    {
        gladiator.TakeDamage(DamageSpecialAttack);
        gladiator.Stun(turn);
        UseAttackSpecial(turn);
        Console.WriteLine($"You decrease : {DamageSpecialAttack} hp enemy " +
                          $"and stunned your enemy with your special attack. ");
    }

    public override string ToString()
    {
        string result;
        result = base.ToString();
        result += "Archetype : Fighter \n";
        return result;
    }
}

public class Archer : Gladiator
{
    public Archer(int health, int damage) : base(health, damage)
    {
        DamageIncreaseNumber = 100;
        DamageSpecialAttack = damage + DamageIncreaseNumber;
    }

    public override void AttackSpecial(Gladiator gladiator, int turn)
    {
        gladiator.TakeDamage(DamageSpecialAttack);
        UseAttackSpecial(turn);
        Console.WriteLine($"You decrease : {DamageSpecialAttack} hp enemy with your special attack.");
    }

    public override string ToString()
    {
        string result;
        result = base.ToString();
        result += "Archetype : Archer \n";
        return result;
    }
}

public class Mage : Gladiator
{
    public Mage(int health, int damage) : base(health, damage)
    {
        DamageIncreaseNumber = 20;
        DamageSpecialAttack = damage + DamageIncreaseNumber;
    }

    public override void AttackSpecial(Gladiator gladiator, int turn)
    {
        gladiator.TakeDamage(DamageSpecialAttack);
        Health += DamageSpecialAttack;
        UseAttackSpecial(turn);
        Console.WriteLine($"You decrease : {DamageSpecialAttack} hp enemy " +
                          $"and increase your health on {DamageSpecialAttack} hp " +
                          $"with your special attack.");
    }

    public override string ToString()
    {
        string result;
        result = base.ToString();
        result += "Archetype : Mage \n";
        return result;
    }
}