War2.0

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace war
{
    class Program
    {
        static void Main(string[] args)
        {
            Battle battle = new Battle();
            battle.RunMenu();
        }
    }

    class Battle
    {
        private int Raund { get; set; }
        private Squad squadLeft;
        private Squad squadRight;
        private static Random rand;

        public Battle()
        {
            Raund = 1;
            rand = new Random();
            squadLeft = new Squad();
            squadRight = new Squad();
        }

        public void RunMenu()
        {
            bool isRun = true;
            while (isRun)
            {
                Console.WriteLine("[1] - Создать отряд\n[2] - Запустить бой\n[3] - Выход");

                switch (Console.ReadLine())
                {
                    case "1":
                        squadLeft.CreateSquad();
                        squadRight.CreateSquad();
                        break;
                    case "2":
                        StartGame(squadLeft, squadRight);
                        break;
                    case "3":
                        isRun = false;
                        break;
                }
            }
        }

        private void StartGame(Squad leftSquad, Squad rightSquad)
        {
            if(IsGameReady() == false)
            {
                return;
            }

            Soldier leftSoldier;
            Soldier rightSoldier;

            while (IsGameOver() == false)
            {
                leftSoldier = leftSquad.GetSoldier();
                rightSoldier = rightSquad.GetSoldier();

                Console.WriteLine("Западный отряд атакует!");
                leftSoldier.GetScript(rightSoldier, rightSquad, leftSquad);

                Console.WriteLine("Восточный отряд атакует!");
                rightSoldier.GetScript(leftSoldier, leftSquad, rightSquad);

                IsRaundEnd(leftSquad, rightSquad);
                Console.ReadKey();
                Console.Clear();
            }
        }

        private bool IsRaundEnd(Squad leftSquad, Squad rightSquad)
        {
            if (leftSquad.IsSoldiersUnready() && rightSquad.IsSoldiersUnready())
            {
                Console.WriteLine("Обе стороны готовятся к следующей атаке");
                Console.WriteLine("Раунд: " + Raund++);

                squadLeft.Refresh();
                squadRight.Refresh();
                return true;
            }
            return false;
        }

        private bool IsGameOver()
        {
            if(squadLeft.GetHealthSquad() <= 0)
            {
                Console.WriteLine("Западный отряд умер!");
                return true;
            }
            else if(squadRight.GetHealthSquad() <= 0)
            {
                Console.WriteLine("Восточный отряд умер!");
                return true;
            }

            Console.WriteLine("Raund: " + Raund);
            Console.WriteLine("\nСилы западного отряда: " + squadLeft.GetHealthSquad());
            Console.WriteLine("Силы восточного отряда: " + squadRight.GetHealthSquad() + "\n");
            return false;
        }

        private bool IsGameReady()
        {
            if (squadLeft.GetSquadSize() < 0)
            {
                Console.WriteLine("Левый отряд не создан!");
                return false;
            }
            else if(squadRight.GetSquadSize() < 0)
            {
                Console.WriteLine("Правый отряд не создан!");
                return false;
            }
            return true;
        }
    }

    class Squad
    {
        private List<Soldier> _soldiers;
        private static Random rand = new Random();

        public Squad()
        {
            _soldiers = new List<Soldier>(20);
        }

        public void CreateSquad()
        {
            Console.WriteLine("Создаем отряд...");

            Medic medic = new Medic();
            CreateSoldier(5, medic);

            Sniper sniper = new Sniper();
            CreateSoldier(5, sniper);

            Infantryman infantryman = new Infantryman();
            CreateSoldier(10, infantryman);

            for (int counter = 0; counter < _soldiers.Count; counter++)
            {
                int swapIndex = rand.Next(_soldiers.Count);
                Soldier soldier = _soldiers[swapIndex];
                _soldiers[swapIndex] = _soldiers[counter];
                _soldiers[counter] = soldier;
            }
        }

        private void CreateSoldier(int soldiersCapasity, Soldier soldier)
        {
            for (int counter = 0; counter < soldiersCapasity; counter++)
            {
                var type = soldier;

                if (type as Medic != null)
                {
                    type = new Medic(counter, rand.Next(50, 100), rand.Next(25, 50));
                    _soldiers.Add(type);
                }
                else if (type as Sniper != null)
                {
                    type = new Sniper(counter, rand.Next(50, 70), rand.Next(85, 105));
                    _soldiers.Add(type);
                }
                else if (type as Infantryman != null)
                {
                    type = new Infantryman(counter, rand.Next(70, 100), rand.Next(50, 80));
                    _soldiers.Add(type);
                }
            }
        }

        public int GetHealthSquad()
        {
            int healthSquad = 0;

            foreach (var soldier in _soldiers)
            {
                healthSquad += soldier.Health;
            }
            return healthSquad;
        }

        public int GetSquadSize()
        {
            return _soldiers.Count;
        }

        public Soldier GetSoldier()
        {
            for (int i = 0; i < _soldiers.Count; i++)
            {
                Soldier soldier = GetSoldiers()[rand.Next(0, _soldiers.Count)];
                if (soldier.IsGunReady || soldier.AbillityCounter == 0)
                {
                    return soldier;
                }
            }
            return _soldiers[rand.Next(0, _soldiers.Count)];
        }

        public bool IsSoldiersUnready()
        {
            foreach (var soldier in _soldiers)
            {
                if (soldier.AbillityCounter == 0 && soldier.IsGunReady)
                {
                    return false;
                }
            }
            return true;
        }

        public void Refresh()
        {
            foreach (var soldier in _soldiers)
            {
                soldier.ReloadGun();
                soldier.CooldownAbility();
            }
        }

        public List<Soldier> GetSoldiers()
        {
            return _soldiers;
        }
    }

    abstract class Soldier
    {
        protected Random random = new Random();

        public bool IsTargetEnemy { get; protected set; }
        public bool IsGunReady { get; protected set; }
        public bool IsAvoid { get; protected set; }
        public int Number { get; protected set; }
        public int MaxHealth { get; protected set; }
        public int Health { get; protected set; }
        public int Damage { get; protected set; }
        public int AbillityCounter { get; protected set; }
        public string Specialty { get; protected set; }

        public abstract void UseAbillity(Squad squad);

        public void GetScript(Soldier enemy, Squad enemySquad, Squad allySquad)
        {
            if(IsGunReady && enemy.IsAvoid == false)
            {
                Attack(enemy, enemySquad);
            }
            else if (AbillityCounter == 0)
            {
                if(IsTargetEnemy)
                {
                    UseAbillity(enemySquad);
                }
                else if(IsTargetEnemy == false)
                {
                    UseAbillity(allySquad);
                }
            }
        }

        public virtual void Heal(Soldier ally)
        {
            if(Health < MaxHealth)
            {
                ally.Health += random.Next(10, 30);
            }
        }

        public virtual void AttackArea(Squad enemySquad)
        {
            for (int i = 0; i < random.Next(1,5); i++)
            {
                enemySquad.GetSoldier().Health -= Damage;
            }
        }

        public void Attack(Soldier enemy, Squad enemySquad)
        {
            IsGunReady = false;
            enemy.Health -= Damage;

            if(enemy.Health <= 0)
            {
                enemySquad.GetSoldiers().Remove(enemy);
            }
        }

        public void ReloadGun()
        {
            IsGunReady = true;
        }

        public void CooldownAbility()
        {
            if(AbillityCounter > 0)
                --AbillityCounter;
        }
    }

    class Medic : Soldier
    {
        public Medic()
        {
            Specialty = "Медик";
            IsTargetEnemy = false;
            IsGunReady = false;
            IsAvoid = false;
            Number = 0;
            MaxHealth = 0;
            Health = 0;
            Damage = 0;
            AbillityCounter = 0;
        }

        public Medic(int number, int health, int damage)
        {
            Specialty = "Медик";
            IsTargetEnemy = false;
            IsGunReady = false;
            IsAvoid = false;
            Number = number;
            MaxHealth = health;
            Health = health;
            Damage = damage;
            AbillityCounter = 0;
        }

        public override void UseAbillity(Squad allySquad)
        {

            for (int i = 0; i < random.Next(1,6); i++)
            {
                Heal(allySquad.GetSoldier());
            }
            AbillityCounter = 5;
        }
    }

    class Infantryman : Soldier
    {
        public Infantryman()
        {
            Specialty = "Штурмовик";
            IsTargetEnemy = false;
            IsGunReady = false;
            IsAvoid = false;
            Number = 0;
            MaxHealth = 0;
            Health = 0;
            Damage = 0;
            AbillityCounter = 0;
        }

        public Infantryman(int number, int health, int damage)
        {
            Specialty = "Штурмовик";
            IsTargetEnemy = true;
            IsGunReady = true;
            IsAvoid = false;
            Number = number;
            MaxHealth = health;
            Health = health;
            Damage = damage;
            AbillityCounter = 0;
            random = new Random();
        }

        public override void UseAbillity(Squad enemySquad)
        {
            AttackArea(enemySquad);
            AbillityCounter = 4;
        }
    }

    class Sniper : Soldier
    {
        public Sniper()
        {
            Specialty = "Снайпер";
            IsTargetEnemy = false;
            IsGunReady = false;
            IsAvoid = false;
            Number = 0;
            MaxHealth = 0;
            Health = 0;
            Damage = 0;
            AbillityCounter = 0;
        }

        public Sniper(int number, int health, int damage)
        {
            Specialty = "Снайпер";
            IsTargetEnemy = true;
            IsGunReady = true;
            IsAvoid = false;
            Number = number;
            MaxHealth = health;
            Health = health;
            Damage = damage;
            AbillityCounter = 3;
        }

        public override void UseAbillity(Squad squad)
        {
            IsAvoid = true;
            AbillityCounter = 3;
        }
    }
}