IJunior-PlatoonWar

OOP Task 6.10

using System;
using System.Collections.Generic;

namespace Features
{
    interface ISoldierPrototype
    {
        Soldier Clone();
    }

    interface IDamageable
    {
        void TakeDamage(int damage);
    }

    enum UnitType
    {
        Sniper,
        Infantry,
        Artillery,
        MortarMan
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            BattleField battleField = new BattleField();
            battleField.ShowFight();
        }
    }

    public class BattleField
    {
        private PlatoonCreator _platoonFactory = new PlatoonCreator();
        private Platoon _whiteSoldiers;
        private Platoon _blackSoldiers;

        public void ShowFight()
        {
            _whiteSoldiers = new Platoon("Андромидеане", _platoonFactory.Create());
            _blackSoldiers = new Platoon("Орионцы", _platoonFactory.Create());

            UserUtils.ShowColorText("Добро пожаловать в видео игру <<Битва взводов>>", ConsoleColor.DarkYellow);
            Console.ReadKey();
            UserUtils.ShowColorText($"\nПеред вами на поле боя два взвода." +
                $"\nС севера надвигается взвод {_whiteSoldiers.Name}." +
                $"\nС юга надвигается взвод {_blackSoldiers.Name}.\n", ConsoleColor.Green);
            Console.ReadKey();

            UserUtils.ShowColorText("Да пусть начнётся битва!!!!", ConsoleColor.Green);
            Console.ReadKey();

            while (_whiteSoldiers.SoldiersCount > 0 && _blackSoldiers.SoldiersCount > 0)
            {
                Console.WriteLine();
                Console.WriteLine($" \n__________{_whiteSoldiers.Name}__________");
                _whiteSoldiers.ShowArmyInformation();
                Console.WriteLine($" \n__________{_blackSoldiers.Name}__________");
                _blackSoldiers.ShowArmyInformation();
                Console.WriteLine();

                FightBetweenPlatoons();
            }

            ShowWinner();
        }

        private void FightBetweenPlatoons()
        {
            _whiteSoldiers.Attack(_blackSoldiers.GetSoldiers());
            _blackSoldiers.Attack(_whiteSoldiers.GetSoldiers());

            _whiteSoldiers.RemoveDeadSoldiers();
            _blackSoldiers.RemoveDeadSoldiers();
        }

        private void ShowWinner()
        {
            if (_whiteSoldiers.SoldiersCount <= 0 && _blackSoldiers.SoldiersCount <= 0)
            {
                UserUtils.ShowColorText($"Никто не победил в этой битве, все померли.", ConsoleColor.Red);
            }
            else if (_whiteSoldiers.SoldiersCount == 0)
            {
                UserUtils.ShowColorText($"\n{_whiteSoldiers.Name} - проиграла", ConsoleColor.Red);
                UserUtils.ShowColorText($"\nВзвод победитель в этой войне {_blackSoldiers.Name}", ConsoleColor.Green);
            }
            else if (_blackSoldiers.SoldiersCount == 0)
            {
                UserUtils.ShowColorText($"\n{_blackSoldiers.Name} - проиграла", ConsoleColor.Red);
                UserUtils.ShowColorText($"\nВзвод победитель в этой войне {_whiteSoldiers.Name}", ConsoleColor.Green);
            }
        }
    }

    class Platoon
    {
        private List<Soldier> _soldiers = new List<Soldier>();

        public Platoon(string name, List<Soldier> soldiers)
        {
            Name = name;
            _soldiers = soldiers;
        }

        public int SoldiersCount => _soldiers.Count;
        public string Name { get; private set; }

        public void Attack(List<IDamageable> soldiers)
        {
            foreach (Soldier soldier in _soldiers)
            {
                soldier.Attack(soldiers);
            }
        }

        public void RemoveDeadSoldiers()
        {
            for (int i = _soldiers.Count - 1; i >= 0; i--)
            {
                if (_soldiers[i].IsAlive == false)
                {
                    UserUtils.ShowColorText($"\n{_soldiers[i].Type} погиб на поле боя.", ConsoleColor.Red);
                    _soldiers.Remove(_soldiers[i]);
                }
            }
        }

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

        public void ShowArmyInformation()
        {
            Dictionary<UnitType, int> soldiersCount = new Dictionary<UnitType, int>();

            foreach (Soldier soldier in _soldiers)
            {
                if (soldiersCount.ContainsKey(soldier.Type) == true)
                {
                    soldiersCount[soldier.Type]++;
                }
                else
                {
                    soldiersCount[soldier.Type] = 1;
                }
            }

            UserUtils.ShowColorText($"Колличество боевых едениц для битвы: {SoldiersCount}\n", ConsoleColor.Green);

            foreach (var type in soldiersCount)
            {
                UserUtils.ShowColorText($"{type.Key} {type.Value} едениц\n", ConsoleColor.Yellow);
            }
        }
    }

    class PlatoonCreator
    {
        private readonly Dictionary<UnitType, ISoldierPrototype> _prototypes = new Dictionary<UnitType, ISoldierPrototype>
        {
            { UnitType.Infantry, new Infantry()},
            { UnitType.Sniper, new Sniper()},
            { UnitType.Artillery,new Artillery()},
            { UnitType.MortarMan, new MortarMan()}
        };

        public List<Soldier> Create()
        {
            int minSoldiersCount = 15;
            int maxSoldiersCount = 60;
            List<Soldier> soldiers = new List<Soldier>();
            int randomSoldierCount = UserUtils.GenerateRandomNumber(minSoldiersCount, maxSoldiersCount + 1);

            for (int i = 0; i < randomSoldierCount; i++)
            {
                UnitType type = (UnitType)UserUtils.GenerateRandomNumber(0, Enum.GetNames(typeof(UnitType)).Length);

                if (_prototypes.ContainsKey(type))
                {
                    soldiers.Add(_prototypes[type].Clone());
                }
            }

            return soldiers;
        }
    }

    abstract class Soldier : IDamageable, ISoldierPrototype
    {
        public UnitType Type { get; protected set; }
        public int Health { get; protected set; }
        public int Armor { get; protected set; }
        public int Damage { get; protected set; }
        public bool IsAlive => Health > 0;

        public abstract Soldier Clone();

        public abstract void Attack(List<IDamageable> soldiers);

        public virtual void TakeDamage(int damage)
        {
            int actualDamage = damage - Armor;

            if (actualDamage < 0)
            {
                actualDamage = 0;
            }

            Health -= actualDamage;
        }
    }

    class Sniper : Soldier
    {
        private int _minValueDamage = 55;
        private int _maxValueDamage = 90;

        public Sniper()
        {
            Type = UnitType.Sniper;
            Health = 150;
            Armor = 25;
            Damage = 55;
        }

        public override void Attack(List<IDamageable> soldiers)
        {
            int _spesialDamage = UserUtils.GenerateRandomNumber(_minValueDamage, _maxValueDamage);

            soldiers[UserUtils.GenerateRandomNumber(0, soldiers.Count)].TakeDamage(Damage * _spesialDamage);
            UserUtils.ShowColorText($"\n{UnitType.Sniper} нанёс усиленный урон по противнику", ConsoleColor.Yellow);
        }

        public override Soldier Clone()
        {
            return new Sniper();
        }
    }

    class Infantry : Soldier
    {
        public Infantry()
        {
            Type = UnitType.Infantry;
            Health = 120;
            Armor = 35;
            Damage = 30;
        }

        public override void Attack(List<IDamageable> soldiers)
        {
            soldiers[UserUtils.GenerateRandomNumber(0, soldiers.Count)].TakeDamage(Damage);
            UserUtils.ShowColorText($"\n{UnitType.Infantry} произвёл обычную атаку по противнику", ConsoleColor.Cyan);
        }

        public override Soldier Clone()
        {
            return new Infantry();
        }
    }

    class Artillery : Soldier
    {
        public Artillery()
        {
            Type = UnitType.Artillery;
            Health = 200;
            Armor = 20;
            Damage = 70;
        }

        public override void Attack(List<IDamageable> soldiers)
        {
            int numberOfAttacks = 3;
            List<IDamageable> selectedSoldiers = new List<IDamageable>();

            while (selectedSoldiers.Count < numberOfAttacks)
            {
                int index = UserUtils.GenerateRandomNumber(0, soldiers.Count);
                IDamageable soldier = soldiers[index];

                if (selectedSoldiers.Contains(soldier) == false)
                {
                    selectedSoldiers.Add(soldier);
                }
            }

            foreach (IDamageable target in selectedSoldiers)
            {
                target.TakeDamage(Damage);
            }

            UserUtils.ShowColorText("\nАртиллерия нанесла удар сразу нескольким противникам.", ConsoleColor.DarkYellow);
        }

        public override Soldier Clone()
        {
            return new Artillery();
        }
    }

    class MortarMan : Soldier
    {
        public MortarMan()
        {
            Type = UnitType.MortarMan;
            Health = 180;
            Armor = 24;
            Damage = 65;
        }

        public override void Attack(List<IDamageable> soldiers)
        {
            int numberOfAttacks = 3;

            for (int i = 0; i < numberOfAttacks; i++)
            {
                int randomIndex = UserUtils.GenerateRandomNumber(0, soldiers.Count);
                IDamageable target = soldiers[randomIndex];
                target.TakeDamage(Damage);
            }

            UserUtils.ShowColorText($"\n{UnitType.MortarMan} Минамётчик атакует сразу несколько противников.", ConsoleColor.DarkBlue);
        }

        public override Soldier Clone()
        {
            return new MortarMan();
        }
    }

    public static class UserUtils
    {
        private static Random s_random = new Random();

        public static void ShowColorText(string text, ConsoleColor color)
        {
            Console.ForegroundColor = color;
            Console.Write(text);
            Console.ForegroundColor = ConsoleColor.White;
        }

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