gladiator fight

using System.Security.Cryptography.X509Certificates;

namespace gladiator_fights
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Arena arena = new Arena();

            arena.Work();
        }
    }

    abstract class Fighter
    {
        public Fighter(int health, int damage, string name)
        {
            Health = health;
            Damage = damage;
            Name = name;
        }

        public int Health { get; protected set; }
        public int Damage { get; protected set; }
        public string Name { get; protected set; }

        virtual public void Attack(Fighter defenter)
        {
            defenter.TakeDamage(Damage);
        }

        virtual public void TakeDamage(int damage)
        {
            if (damage >= 0)
            {
                Health -= damage;
            }
        }

        abstract public Fighter Clone();
    }

    class Healer : Fighter
    {
        private int _rageNeedForRegen;
        private int _rage;

        public Healer() : base(150, 10, "Целитель")
        {
            _rage = 0;
            _rageNeedForRegen = 100;
        }

        public override void TakeDamage(int damage)
        {
            if (damage >= 0)
            {
                Health -= damage;

                RageRegen();
                Heal();
            }
        }

        public override Fighter Clone()
        {
            return new Healer();
        }

        private void RageRegen()
        {
            int maxPointOfRageRegen = 12;
            int minPointOfRageRegen = 7;
            int pointOfRageRegen = UserUnits.GenerateRandomNumber(minPointOfRageRegen, maxPointOfRageRegen);

            _rage += pointOfRageRegen;

            if (_rage > _rageNeedForRegen)
            {
                _rage = _rageNeedForRegen;
            }
        }

        private void Heal()
        {
            int maxHealth = 150;
            int pointOfHeal = 50;

            if (_rage == _rageNeedForRegen)
            {
                Health += pointOfHeal;
                _rage = 0;
            }

            if (Health > maxHealth)
            {
                Health = maxHealth;
            }
        }
    }

    class Dredevil : Fighter
    {
        private int _numberAttack;
        private int _numberForDoubleAttack;

        public Dredevil() : base(150, 10, "Смельчак")
        {
            _numberAttack = 0;
            _numberForDoubleAttack = 3;
        }

        public override void Attack(Fighter defender)
        {
            _numberAttack++;

            if (_numberAttack == _numberForDoubleAttack)
            {
                defender.TakeDamage(Damage);

                _numberAttack = 0;
            }

            defender.TakeDamage(Damage);
        }

        public override Fighter Clone()
        {
            return new Dredevil();
        }
    }

    class LuckyGuy : Fighter
    {
        private int _numberForChanceDodge;

        public LuckyGuy() : base(150, 10, "Проныра")
        {
            _numberForChanceDodge = 1;
        }

        public override void TakeDamage(int damage)
        {
            if (CanDodge() == false)
            {
                Health -= damage;
            }
        }

        public override Fighter Clone()
        {
            return new LuckyGuy();
        }

        private bool CanDodge()
        {
            int minRandomNumber = 1;
            int maxRandomNumber = 11;

            return _numberForChanceDodge == UserUnits.GenerateRandomNumber(minRandomNumber, maxRandomNumber);
        }
    }

    class Warlock : Fighter
    {
        private int _manaNeedForFireBallAttack;
        private int _damageForFireBall;
        private int _mana;
        private int _manaRegen;

        public Warlock() : base(150, 10, "Чернокнижник")
        {
            _manaNeedForFireBallAttack = 20;
            _damageForFireBall = 18;
            _mana = 100;
            _manaRegen = 15;
        }

        public override void Attack(Fighter defender)
        {
            if (TryConsumeMana())
            {
                defender.TakeDamage(_damageForFireBall);
                _mana = -_damageForFireBall;
            }
            else
            {
                defender.TakeDamage(Damage);
                _mana += _manaRegen;
            }
        }

        public override Fighter Clone()
        {
            return new Warlock();
        }

        private bool TryConsumeMana()
        {
            return _mana >= _manaNeedForFireBallAttack;
        }
    }

    class Knight : Fighter
    {
        private int _numberForCriticalAttack;
        private int _criticalAttack;

        public Knight() : base(150, 10, "Рыцарь")
        {
            _numberForCriticalAttack = 1;
            _criticalAttack = Damage * 2;
        }

        public override void Attack(Fighter defender)
        {
            if (IsChanseCriticalAttack())
            {
                defender.TakeDamage(_criticalAttack);
            }
            else
            {
                defender.TakeDamage(Damage);
            }
        }

        public override Fighter Clone()
        {
            return new Knight();
        }

        private bool IsChanseCriticalAttack()
        {
            int minRandomNumber = 1;
            int maxRandomNumber = 11;

            return _numberForCriticalAttack == UserUnits.GenerateRandomNumber(minRandomNumber, maxRandomNumber);
        }
    }

    class Arena
    {
        private List<Fighter> _fighters = new List<Fighter>();

        public Arena()
        {
            _fighters.Add(new Healer());
            _fighters.Add(new Dredevil());
            _fighters.Add(new LuckyGuy());
            _fighters.Add(new Warlock());
            _fighters.Add(new Knight());
        }

        public void Work()
        {
            Fighter fighterOne = null;
            Fighter fighterTwo = null;

            ChooseFighter(out fighterOne);
            ChooseFighter(out fighterTwo);

            Console.Clear();

            Fight(fighterOne, fighterTwo);

            IdentifyWinner(fighterOne, fighterTwo);
        }

        private void Fight(Fighter fighterOne, Fighter fighterTwo)
        {
            while (fighterOne.Health > 0 && fighterTwo.Health > 0)
            {
                ShowInfo(fighterOne, fighterTwo);

                fighterOne.Attack(fighterTwo);

                if (fighterTwo.Health <= 0)
                {
                    break;
                }

                ShowInfo(fighterOne, fighterTwo);

                fighterTwo.Attack(fighterOne);
            }
        }

        private void IdentifyWinner(Fighter fighterOne, Fighter fighterTwo)
        {
            if (fighterOne.Health <= 0 && fighterTwo.Health <= 0)
            {
                Console.WriteLine("Оба игрока погибли. Ничья.");
            }
            else if (fighterOne.Health <= 0)
            {
                Console.WriteLine($"Игрок 2 {fighterTwo.Name} победил.");
            }
            else
            {
                Console.WriteLine($"Игрок 1 {fighterOne.Name} победил.");
            }
        }

        private void ShowInfo(Fighter fighter, Fighter fighterTwo)
        {
            Console.WriteLine($"У 1 игрока {fighter.Name} осталось {fighter.Health} жизней.");
            Console.WriteLine($"У 2 игрока {fighterTwo.Name} осталось {fighterTwo.Health} жизней.");
            Console.ReadKey();
            Console.Clear();
        }

        private void ChooseFighter(out Fighter fighter)
        {
            fighter = null;

            while (fighter == null)
            {
                Console.WriteLine("Выберете бойца:");

                ShowAllFighters();

                int userInput = UserUnits.ReadNumber();
                int indexNeedFighter = userInput - 1;

                if (indexNeedFighter >= 0 && indexNeedFighter < _fighters.Count)
                {
                    fighter = _fighters[indexNeedFighter].Clone();
                    Console.Clear();
                }
                else
                {
                    Console.WriteLine("Вы ввели не верную команду.");
                    Console.ReadKey();
                    Console.Clear();
                }
            }
        }

        private void ShowAllFighters()
        {
            int numberFigterInList = 1;

            foreach (Fighter fighter in _fighters)
            {
                Console.WriteLine($"{numberFigterInList} {fighter.Name}");
                numberFigterInList++;
            }
        }
    }

    class UserUnits
    {
        private static Random s_random = new Random();

        public static int GenerateRandomNumber(int min, int max)
        {
            return s_random.Next(min, max);
        }

        public static int ReadNumber()
        {
            bool isNumber = false;
            int result = 0;

            while (isNumber == false)
            {
                isNumber = int.TryParse(Console.ReadLine(), out result);
            }

            return result;
        }
    }
}