ДЗ: Война # 2

gistfile1.txt

using System;
using System.Collections.Generic;

namespace War
{
    internal class Program
    {
        static void Main(string[] args)
        {
            War battlefield = new War();

            battlefield.ShowPlatoon();

            Console.WriteLine("Для начала боя нажмите любую клавишу!");
            Console.ReadKey();

            battlefield.InitiateBattle();
        }
    }

    class War
    {
        private Platoon _firstPlatoon;
        private Platoon _secondPlatoon;

        public War()
        {
            GeneratePlatoons(InitializeSoldiers());
        }

        public void ShowPlatoon()
        {
            _firstPlatoon.ShowInfo();
            _secondPlatoon.ShowInfo();
        }
        public void CheckWinner()
        {
            if (_firstPlatoon.IsAlive == false && _secondPlatoon.IsAlive == false)
                Console.WriteLine("\nНичья");
            else if (_firstPlatoon.IsAlive == false)
                Console.WriteLine("\nПервый взвод победил!");
            else
                Console.WriteLine("\nВторой взвод победил!");
        }

        public void InitiateBattle()
        {
            while (_firstPlatoon.IsAlive && _secondPlatoon.IsAlive)
            {
                Console.WriteLine($"\nЧисло живых бойцов в первом взводе = {_firstPlatoon.Soldiers.Count}, во втором = {_secondPlatoon.Soldiers.Count}\n");

                Console.WriteLine($"\nАтакует первый взвод!\n");

                InitiateAttack(_firstPlatoon, _secondPlatoon);

                Console.WriteLine($"\nАтакует второй взвод!\n");

                InitiateAttack(_secondPlatoon, _firstPlatoon);

                _firstPlatoon.RemoveSoldier();
                _secondPlatoon.RemoveSoldier();
            }

            CheckWinner();
        }
        private List<Soldier> InitializeSoldiers()
        {
            return new List<Soldier>()
        {
             new DefaultSoldier("Рядовой"),
             new DamageFactorSoldier("Сержант"),
             new SplashSoldier("Капитан"),
             new RandomDamageAttackSoldier("Майор")
        };
        }

        private void GeneratePlatoons(List<Soldier> soldiers)
        {
            PlatoonFactory factory = new PlatoonFactory();

            _firstPlatoon = factory.CreatePlatoon("Первый взвод", soldiers);

            _secondPlatoon = factory.CreatePlatoon("Второй взвод", soldiers);
        }

        private void InitiateAttack(Platoon attackingPlatoon, Platoon opponentPlatoon)
        {
            if (attackingPlatoon.Soldiers.Count > 0 && opponentPlatoon.Soldiers.Count > 0)
            {
                int attackingSoldierNumber = UserUtils.Generate(0, attackingPlatoon.Soldiers.Count - 1);
                int opponentSoldierNumber = UserUtils.Generate(0, opponentPlatoon.Soldiers.Count - 1);

                attackingPlatoon.Soldiers[attackingSoldierNumber].Attack(opponentPlatoon.Soldiers);
            }
        }
    }

    class PlatoonFactory
    {
        public Platoon CreatePlatoon(string name, List<Soldier> soldiers)
        {
            Platoon platoon = new Platoon(name);

            for (int i = 0; i < soldiers.Count; i++)
            {
                int randomIndex = UserUtils.Generate(0, soldiers.Count);
                platoon.AddSoldier(soldiers[randomIndex]);
            }

            return platoon;
        }
    }

    class Platoon
    {
        private List<Soldier> _soldiers;

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

        public bool IsAlive => _soldiers.Count > 0;

        public List<Soldier> Soldiers => new List<Soldier>(_soldiers);

        public string Name { get; private set; }

        public void RemoveSoldier()
        {
            for (int i = _soldiers.Count - 1; i >= 0; i--)
            {
                if (_soldiers[i].IsAlive == false)
                    _soldiers.RemoveAt(i);
            }
        }

        public void AddSoldier(Soldier soldier)
        {
            _soldiers.Add(soldier);
        }

        public void ShowInfo()
        {
            Console.WriteLine($"\nВзвод {Name}:");

            foreach (Soldier soldier in _soldiers)
            {
                soldier.ShowInfo();
            }
        }
    }

    abstract class Soldier
    {
        protected Soldier(string name, int health, int damage, int armor)
        {
            Name = name;
            Health = health;
            Damage = damage;
            Armor = armor;
        }

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

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

            Console.WriteLine($"\n{Name} получает {damage} урона. Осталось здоровья - {Health}");
        }

        public bool IsAlive => Health > 0;

        public virtual void Attack(List<Soldier> enemies)
        {
            Soldier target = enemies[UserUtils.Generate(0, enemies.Count - 1)];
            target.TakeDamage(Damage);
        }

        public virtual void ShowInfo()
        {
            Console.WriteLine($"Боец - {Name}, здоровье = {Health}, броня = {Armor}. Максимальный урон = {Damage}");
        }
    }

    class DefaultSoldier : Soldier
    {
        public DefaultSoldier(string name) : base(name, 100, 30, 20) { }
    }

    class DamageFactorSoldier : Soldier
    {
        public DamageFactorSoldier(string name) : base(name, 100, 20, 20) { }

        public override void Attack(List<Soldier> enemies)
        {
            int damageFactor = 2;

            Soldier target = enemies[UserUtils.Generate(0, enemies.Count - 1)];

            target.TakeDamage(Damage * damageFactor);
        }
    }

    class SplashSoldier : Soldier
    {
        public SplashSoldier(string name) : base(name, 100, 15, 15) { }

        public override void Attack(List<Soldier> enemies)
        {
            int numberOfTargets = 3;

            if (enemies.Count > numberOfTargets)
            {
                List<Soldier> possibleTargets = new List<Soldier>(enemies);

                for (int i = 0; i < numberOfTargets -1; i++)
                {
                    Soldier target = possibleTargets[UserUtils.Generate(0, possibleTargets.Count - 1)];
                    target.TakeDamage(Damage);
                    possibleTargets.Remove(target);
                }
            }
        }
    }

    class RandomDamageAttackSoldier : Soldier
    {
        public RandomDamageAttackSoldier(string name) : base(name, 100, 20, 5) { }

        public override void Attack(List<Soldier> enemies)
        {
            int attacksCount = 2;

            for (int i = 0; i < attacksCount; i++)
            {
                Soldier target = enemies[UserUtils.Generate(0, enemies.Count - 1)];
                target.TakeDamage(Damage);
            }
        }
    }

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

        public static int Generate(int minValue, int maxValue)
        {
            return s_random.Next(minValue, maxValue);
        }
    }
}