WarWithStatus

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 _round = 0;

        private Squad _squadLeft;
        private Squad _squadRight;

        public Battle()
        {
            _round = 1;
            _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();
                        break;
                    case "3":
                        isRun = false;
                        break;
                }
            }
        }

        private void StartGame()
        {
            if (IsGameReady() == false)
            {
                return;
            }

            while (IsGameOver() == false)
            {
                MakeRound();

                Console.ReadKey();
                Console.Clear();
            }
        }

        private void MakeRound()
        {
            InitStage();
            FightStage();
            EndStage();
        }

        private void InitStage()
        {
            _squadLeft.ChooseRandomFrontmen();
            _squadRight.ChooseRandomFrontmen();
        }

        private void FightStage()
        {
            Console.WriteLine("Западный отряд атакует!");
            _squadRight.TakeAction(_squadLeft.Frontman);

            Console.WriteLine("Восточный отряд атакует!");
            _squadLeft.TakeAction(_squadRight.Frontman);
        }

        private void EndStage()
        {
            _squadLeft.TryDeleteDeadSoldier();
            _squadRight.TryDeleteDeadSoldier();

            if(IsSquadsReady())
            {
                Console.WriteLine("Новый раунд!");
                _round++;
            }
        }

        private bool IsSquadsReady()
        {
            if (_squadLeft.IsSoldiersUnready() && _squadRight.IsSoldiersUnready())
            {
                _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: " + _round);
            Console.WriteLine("\nСилы западного отряда: " + _squadLeft.GetHealthSquad());
            Console.WriteLine("Силы восточного отряда: " + _squadRight.GetHealthSquad() + "\n");
            return false;
        }

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

    class Squad
    {
        private List<Soldier> _soldiers;

        private static Random _rand = new Random(DateTime.Now.Millisecond);

        public int SoldiersCount => _soldiers.Count;
        public Soldier Frontman { get; private set; }

        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;
            }
        }

        public void TakeAction(Soldier enemyFrontman)
        {
            Frontman.TryAttack(enemyFrontman, GetRandomSoldier(_soldiers));
        }

        public int GetHealthSquad()
        {
            int healthSquad = 0;

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

        public Soldier ChooseRandomFrontmen()
        {
            List<Soldier> readySoldiers = new List<Soldier>();

            foreach (var soldier in _soldiers)
            {
                if(soldier.GetGunLoadState() == true || soldier.AbillityCounter == 0)
                {
                    readySoldiers.Add(soldier);
                }
            }

            if(readySoldiers.Count == 0)
            {
                Frontman = GetRandomSoldier(_soldiers);
            }
            else
            {
                Frontman = GetRandomSoldier(readySoldiers);
            }
            return Frontman;
        }

        public Soldier GetRandomSoldier(List<Soldier> soldiers)
        {
            return soldiers[_rand.Next(0, soldiers.Count)];
        }

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

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

        public bool TryDeleteDeadSoldier()
        {
            if (Frontman.Health <= 0)
            {
                _soldiers.Remove(Frontman);
                return true;
            }
            return false;
        }

        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);
                }
            }
        }
    }

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

        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(Soldier soldier);


        public Soldier()
        {
            Status = new Status();

            Status.SetTarget(false);
            Status.SetLoadGun(false);
            Status.SetAvoid(false);

            Number = 0;
            MaxHealth = 0;
            Health = 0;
            Damage = 0;
            AbillityCounter = 0;
            Specialty = "Новобранец";
        }

        public bool GetAvoidState()
        {
            return Status.IsAvoid;
        }

        public bool GetGunLoadState()
        {
            return Status.IsGunLoaded;
        }

        public bool GetTargetState()
        {
            return Status.IsTargetEnemy;
        }

        public void TryAttack(Soldier enemy, Soldier ally)
        {
            if (Status.IsGunLoaded)
            {
                Attack(enemy);
            }
            else if (AbillityCounter == 0)
            {
                if (Status.IsTargetEnemy)
                {
                    UseAbillity(enemy);
                }
                else if (Status.IsTargetEnemy == false)
                {
                    UseAbillity(ally);
                }
            }
        }

        public void Attack(Soldier enemy)
        {
            if(enemy.Status.IsAvoid == false)
            {
                enemy.Health -= Damage;
            }

            Status.SetLoadGun(false);
        }

        public void ReloadGun()
        {
            Status.SetLoadGun(true);
        }

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

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

    class Medic : Soldier
    {
        public int ChargeAbility { get; private set; }

        public Medic() : base()
        {

        }

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

        public override void UseAbillity(Soldier ally)
        {
            Heal(ally);
            AbillityCounter = 5;
        }
    }

    class Infantryman : Soldier
    {
        public Infantryman() : base()
        {

        }
        public Infantryman(int number, int health, int damage)
        {
            Status.SetTarget(true);
            Status.SetLoadGun(true);
            Status.SetAvoid(false);

            Specialty = "Штурмовик";
            Number = number;
            MaxHealth = health;
            Health = health;
            Damage = damage;
        }

        public override void UseAbillity(Soldier enemy)
        {
            Health += Random.Next(10, 20);
            AbillityCounter = Random.Next(1, 3);
        }
    }

    class Sniper : Soldier
    {
        public Sniper() : base()
        {

        }
        public Sniper(int number, int health, int damage)
        {
            Status.SetTarget(true);
            Status.SetLoadGun(true);
            Status.SetAvoid(false);

            Specialty = "Снайпер";
            Number = number;
            MaxHealth = health;
            Health = health;
            Damage = damage;
            AbillityCounter = 3;
        }

        public override void UseAbillity(Soldier soldier)
        {
            Status.SetAvoid(true);
            AbillityCounter = 3;
        }
    }

    class Status
    {
        public bool IsTargetEnemy { get; private set; }
        public bool IsGunLoaded { get; private set; }
        public bool IsAvoid { get; private set; }

        public Status()
        {
            IsTargetEnemy = false;
            IsGunLoaded = false;
            IsAvoid = false;
        }

        public void SetTarget(bool state)
        {
            IsTargetEnemy = state;
        }

        public void SetLoadGun(bool state)
        {
            IsGunLoaded = state;
        }

        public void SetAvoid(bool state)
        {
            IsAvoid = state;
        }
    }
}