ООП.Гладиаторские бои.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace iJunior
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            Arena arena = new Arena();

            arena.Fight();
        }
    }

    enum Fighters { HumanWarrior = 1, HumanMage, OrkWarrior, OrkMage, ElfWarrior, ElfMage }

    abstract class Fighter
    {
        protected int ChanceOfSuccessNecessary = 50;

        public int HealthPoint { get; protected set; }
        public int ManaPoint { get; protected set; }
        public int Attack { get; protected set; }
        public int SpellChance { get; protected set; }

        protected Fighter(int healthPoint, int manaPoint, int physicalAttack, int magicalAttack)
        {
            HealthPoint = healthPoint;
            ManaPoint = manaPoint;
            Attack = physicalAttack;
            Attack = magicalAttack;
        }

        public virtual void AttackEnemy(Fighter enemyFighter)
        {
            Console.WriteLine($"Наносит обычный удар в {Attack} единиц урона");
            enemyFighter.TakeDamage(Attack);
        }

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

    class HumanWarrior : Fighter
    {
        private Random _random = new Random();

        public HumanWarrior() : base(126, 38, 4, 3) { }

        public override void AttackEnemy(Fighter enemyFighter)
        {
            SpellChance = _random.Next(100);

            if (SpellChance > 50)
            {
                enemyFighter.TakeDamage(CastMultiplierAttack());
            }
            else
            {
                base.AttackEnemy(enemyFighter);
            }
        }

        private int CastMultiplierAttack()
        {
            int manaCoast = 10;

            if (ManaPoint >= manaCoast)
            {
                int minCritical = 1;
                int maxCritical = 4;
                int criticalMultiplier = _random.Next(minCritical, maxCritical);
                int damage;

                Console.Write("Использует Critical Attack| ");

                damage = criticalMultiplier * Attack;
                ManaPoint -= manaCoast;

                Console.WriteLine($" и наносит противнику {damage} единиц урона!");

                return damage;
            }

            Console.WriteLine($" Не хватает маны! Наносит противнику {Attack} единиц урона!");
            return Attack;
        }

    }

    class HumanMage : Fighter
    {
        private Random _random = new Random();

        public HumanMage() : base(90, 59, 2, 7) { }

        public override void AttackEnemy(Fighter enemyFighter)
        {
            SpellChance = _random.Next(100);

            if (SpellChance > ChanceOfSuccessNecessary)
            {
                enemyFighter.TakeDamage(CastMagicSpell());
            }
            else
            {
                base.AttackEnemy(enemyFighter);
            }
        }

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

        private int CastMagicSpell()
        {
            int manaCouast = 20;
            int spellDamage = 18;
            int damage;

            if (ManaPoint >= manaCouast)
            {
                Console.Write("Использует Wind Strike");

                damage = spellDamage + Attack;

                Console.WriteLine($" и наносит противнику {damage} единиц урона!");

                ManaPoint -= manaCouast;

                return damage;
            }

            Console.WriteLine($" Не хватает маны! Наносит противнику {Attack} единиц урона!");
            return Attack;
        }
    }

    class OrkWarrior : Fighter
    {
        private int _killerChanse;
        private Random _random = new Random();

        public OrkWarrior() : base(133, 39, 4, 2) { }

        public override void AttackEnemy(Fighter enemyFighter)
        {
            int manaCouast = 20;
            SpellChance = _random.Next(100);

            if (SpellChance > ChanceOfSuccessNecessary && ManaPoint > manaCouast)
            {
                enemyFighter.TakeDamage(CastMortalBlow(enemyFighter));
            }
            else
            {
                base.AttackEnemy(enemyFighter);
            }
        }

        private int CastMortalBlow(Fighter fighter)
        {
            int spellDamage = 8;
            int damage;
            _killerChanse = _random.Next(10);

            Console.Write("Использует Mortal Blow");

            if (_killerChanse == 1)
            {
                damage = fighter.HealthPoint - 1;
                Console.WriteLine($" и наносит противнику {damage} единиц урона!!!!");
                return damage;
            }

            damage = spellDamage + Attack;

            Console.WriteLine($" и наносит противнику {damage} единиц урона!");
            return damage;
        }
    }

    class OrkMage : Fighter
    {
        private Random _random = new Random();

        public OrkMage() : base(105, 60, 2, 4) { }

        public override void AttackEnemy(Fighter enemyFighter)
        {
            SpellChance = _random.Next(100);

            if (SpellChance > ChanceOfSuccessNecessary)
            {
                enemyFighter.TakeDamage(CastHeal());
            }
            else
            {
                base.AttackEnemy(enemyFighter);
            }
        }

        private int CastHeal()
        {
            int manaCoast = 40;

            if (ManaPoint >= manaCoast && HealthPoint < 40)
            {
                int heal = _random.Next(10, 25);
                int damage;

                Console.Write("Использует Heal| ");

                damage = Attack;
                HealthPoint += heal;
                ManaPoint -= manaCoast;

                Console.WriteLine($" наносит противнику {damage} единиц урона! А также восстанавливает {heal} единиц здоровья");

                return damage;
            }

            Console.WriteLine($" Не хватает маны! Наносит противнику {Attack} единиц урона!");
            return Attack;
        }
    }

    class ElfWarrior : Fighter
    {
        private Random _random = new Random();
        private bool IsAwade;


        public ElfWarrior() : base(133, 39, 4, 2) { }

        public override void AttackEnemy(Fighter enemyFighter)
        {
            SpellChance = _random.Next(100);

            if (SpellChance > ChanceOfSuccessNecessary)
            {
                enemyFighter.TakeDamage(CastDodge());
            }
            else
            {
                base.AttackEnemy(enemyFighter);
            }
        }

        public override void TakeDamage(int damage)
        {
            if (IsAwade == false)
            {
                HealthPoint -= damage;
            }
            else
            {
                Console.Write(" | Уворот!");
            }
        }

        private int CastDodge()
        {
            int manaCoast = 10;
            IsAwade = false;

            if (ManaPoint >= manaCoast)
            {
                IsAwade = true;
                int damage;

                Console.Write("Использует Dodge| ");

                damage = Attack;
                ManaPoint -= manaCoast;

                Console.WriteLine($" наносит противнику {damage} единиц урона! А также готовиться увернуться от следующего удара");

                return damage;
            }

            Console.WriteLine($" Не хватает маны! Наносит противнику {Attack} единиц урона!");
            return Attack;
        }

    }

    class ElfMage : Fighter
    {
        private int _spellChanse;
        private Random _random = new Random();
        private bool IsAwade;

        public ElfMage() : base(96, 59, 2, 4) { }

        public override void AttackEnemy(Fighter enemyFighter)
        {
            SpellChance = _random.Next(100);

            if (SpellChance > ChanceOfSuccessNecessary)
            {
                enemyFighter.TakeDamage(CastDisembodied());
            }
            else
            {
                base.AttackEnemy(enemyFighter);
            }
        }

        public override void TakeDamage(int damage)
        {
            if (IsAwade == false)
            {
                HealthPoint -= damage;
            }
            else
            {
                Console.WriteLine(" | Удар прошел насквозь!");
            }
        }

        private int CastDisembodied()
        {
            int manaCoast = 20;
            IsAwade = false;

            if (ManaPoint >= manaCoast)
            {
                int damage;
                IsAwade = true;

                Console.Write("Использует Disembodied| ");

                damage = Attack + manaCoast;
                ManaPoint -= manaCoast;

                Console.WriteLine($" наносит противнику {damage} единиц урона! А также его тело стало прозрачным");

                return damage;
            }

            Console.WriteLine($" Не хватает маны! Наносит противнику {Attack} единиц урона!");
            return Attack;
        }
    }

    class Arena
    {
        private Fighter[] _allFighters;
        private Fighter _fighterLeft;
        private Fighter _fighterRight;
        private string _nameLeftFighter = "Боец 1: ";
        private string _nameRightFighter = "Боец 2: ";

        public Arena()
        {
            ShowAllFighters(CreateFightersList());

            _fighterLeft = CreateFighter(TakeIndexFighter());
            _fighterRight = CreateFighter(TakeIndexFighter());

            Console.Clear();
            Console.WriteLine("Вы выбрали:");
            ShowFighterInfo(_fighterLeft, _nameLeftFighter);
            ShowFighterInfo(_fighterRight, _nameRightFighter);

            Console.ReadKey();
        }

        public void Fight()
        {
            while (_fighterLeft.HealthPoint > 0 && _fighterRight.HealthPoint > 0)
            {
                Console.Clear();

                ShowFighterInfo(_fighterLeft, _nameLeftFighter);

                _fighterLeft.AttackEnemy(_fighterRight);

                ShowFighterInfo(_fighterRight, _nameRightFighter);

                _fighterRight.AttackEnemy(_fighterLeft);

                Console.ReadKey();
            }

            if (_fighterLeft.HealthPoint < 0 && _fighterRight.HealthPoint < 0)
            {
                Console.WriteLine("Ого! Оба бойца отдали концы %)");
            }
            else if (_fighterLeft.HealthPoint < 0)
            {
                Console.WriteLine("Боец 2 Победил!");
            }
            else if (_fighterRight.HealthPoint < 0)
            {
                Console.WriteLine("Боец 1 Победил!");
            }

            Console.ReadKey();
        }

        private void ShowFighterInfo(Fighter fighter, string nameFighter)
        {
            Console.WriteLine($"{nameFighter} HP - {fighter.HealthPoint} | MP {fighter.ManaPoint} | Phys Attack {fighter.Attack}");
        }

        private void ShowAllFighters(Fighter[] fighters)
        {
            int numberFighter = 1;

            foreach (var fighter in fighters)
            {
                Console.WriteLine($"{numberFighter})HP - {fighter.HealthPoint} | MP {fighter.ManaPoint} | Phys Attack {fighter.Attack}");
                numberFighter++;
            }
        }

        private Fighters TakeIndexFighter()
        {
            string userInputString;
            int userInputInt;

            do
            {
                Console.WriteLine("Выбери бойца. Вам необходимо ввести число: ");
                userInputString = Console.ReadLine();

            } while (int.TryParse(userInputString, out userInputInt) == false || userInputInt <= 0 || userInputInt > _allFighters.Length);
            
            Fighters figters;
            return figters = (Fighters)userInputInt;
        }

        private Fighter CreateFighter(Fighters fighter)
        {
            switch (fighter)
            {
                case Fighters.HumanWarrior:
                    return new HumanWarrior();

                case Fighters.HumanMage:
                    return new HumanMage();

                case Fighters.OrkWarrior:
                    return new OrkWarrior();

                case Fighters.OrkMage:
                    return new OrkMage();

                case Fighters.ElfWarrior:
                    return new ElfWarrior();

                case Fighters.ElfMage:
                    return new ElfMage();
            }

            return null;
        }

        private Fighter[] CreateFightersList()
        {
            _allFighters = new Fighter[6];
            _allFighters[0] = new HumanWarrior();
            _allFighters[1] = new HumanMage();
            _allFighters[2] = new OrkWarrior();
            _allFighters[3] = new OrkMage();
            _allFighters[4] = new ElfWarrior();
            _allFighters[5] = new ElfMage();

            return _allFighters;
        }
    }
}