Написать игру. Опишите классы (Мечник), (Лучник), (Маг), каждый из которых является экземпляром базового абстрактного класса

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Game
{
    class Program
    {
        static void Main(string[] args)
        {
            Unit arrUnit = new Swordsman();
            arrUnit = new Archer(arrUnit);
 
            Console.WriteLine(arrUnit.getDescription() + "\nAttack = " + arrUnit.setAttack()
                + ". Defence = " + arrUnit.setDefence() + ". Hitpoints = " + arrUnit.setHitpoints());
            Console.WriteLine("\n..::VS::..\n");
            Unit merlin = new Mage();
            Console.WriteLine(merlin.getDescription() + "\nAttack = " + merlin.setAttack()
                + ". Defence = " + merlin.setDefence() + ". Hitpoints = " + merlin.setHitpoints());
        }
    }
 
    public abstract class Unit
    {
        public Swordsman[] SwordsmanArray;
        public string hero = "";
 
        public abstract int setAttack();
        public abstract int setDefence();
        public abstract int setHitpoints();
 
        internal string getDescription()
        {
            return hero;
        }
 
 
    }
 
    public class Swordsman : Unit
    {
        public Swordsman()
        {
            hero = "Ranger - critical hit range unit";
        }
 
        override public int setAttack() 
        {
            return 5;
        }
        override public int setDefence()
        {
            return 60;
        }
        override public int setHitpoints()
        {
            return 15;
        }
    }
 
    public class Archer : Unit
    {
        Unit charaster;
 
        public Archer(Unit charaster)
        {
            this.charaster = charaster;
            hero = "Archer - powerful then the bang";
        }
 
        public string getDescription()
        {
            return charaster.getDescription() + ", BowOfGod";
        }
 
        override public int setAttack()
        {
            return 14 + charaster.setAttack();
        }
        override public int setDefence()
        {
            return 40 + charaster.setDefence();
        }
        override public int setHitpoints()
        {
            return 12 + charaster.setHitpoints();
        }
    }
 
    public class Mage : Unit
    {
        public Mage()
        {
            hero = "Mage - powerfull spelcaster";
        }
 
        override public int setAttack()
        {
            return 8;
        }
        override public int setDefence()
        {
            return 30;
        }
        override public int setHitpoints()
        {
            return 10;
        }
    }
 
 
}

public abstract class Unit
    {
        public Swordsman[] SwordsmanArray;
        public string hero = "";
 
        public abstract int setAttack();
        public abstract int setDefence();
        public abstract int setHitpoints();
 
        internal string getDescription()
        {
            return hero;
        } 
    }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
 
namespace Game
{
    class Program
    {
        static void Main(string[] args)
        {
            Game game = new Game(true, false);
            while (!game.GameOver)
                game.Next();
        }
    }
    class Game
    {
        Command[] commands;
        int Step;
        public bool GameOver
        {
            get
            {
                if (!commands[0].IsAlive)
                {
                    Congratulations(1);
                    return true;
                }
                if (!commands[1].IsAlive)
                {
                    Congratulations(0);
                    return true;
                }
                return false;
            }
        }
        public void Congratulations(int command)
        {
            Console.WriteLine("Congratulations command {0} win!\nList of heroes:", command+1);
            foreach (Unit unit in commands[command].units)
                Console.WriteLine(unit.getDescription());
        }
        public Game(bool duel1, bool duel2, int initialStep=0, int quantity1 = 3, int quantity2 = 3)
        {
            Step = initialStep;
            commands = new Command[2];
            commands[0] = new Command(duel1, quantity1);
            commands[1] = new Command(duel2, quantity2);
        }
        public void Next()
        {
            Console.WriteLine("Step: " + Step);
            var r = new RNGCryptoServiceProvider();
            byte[] data = new byte[1];
            Console.WriteLine("Command {0} attacks:", (Step % 2) +1);
            foreach (Unit unit in commands[Step % 2].units)
                if (unit.IsAlive)
                {
                    var availibleTargets = new List<Unit>();
                    if (commands[Step % 2].duel)
                    {
                        foreach (Unit enemy in commands[(Step + 1) % 2].units)
                        {
                            if (enemy.type == unit.type&&enemy.IsAlive)
                                availibleTargets.Add(enemy);
                        }
                        if (availibleTargets.Count==0)
                            Console.WriteLine("{0} can't attack primary target", unit.hero);
                    }
                    if (availibleTargets.Count==0)
                    {
                        foreach (Unit enemy in commands[(Step + 1) % 2].units)
                            if (enemy.IsAlive)
                                availibleTargets.Add(enemy);
                    }
                    if (availibleTargets.Count == 0)
                        break;
                    r.GetBytes(data);
                    unit.Attack(availibleTargets[data[0]%availibleTargets.Count]);
 
                }
            Step++;
            
        }
        private class Command
        {
            public Unit[] units { get; set; }
            public bool duel { get; set; }
            public Command(bool duel, int quantity)
            {
                this.duel = duel;
                byte[] data = new byte[1];
                var r = new RNGCryptoServiceProvider();
                r.GetBytes(data);
                units = new Unit[quantity];
                for (int i = 0; i < quantity; i++)
                {
                    r.GetBytes(data);
                    int q = data[0] % 3;
                    switch (q)
                    {
                        case 0:
                            units[i] = new Swordsman();
                            break;
                        case 1:
                            units[i] = new Archer();
                            break;
                        case 2:
                            units[i] = new Mage();
                            break;
                    }
                }
            }
            public bool IsAlive
            {
                get
                {
                    foreach (Unit unit in units)
                        if (unit.IsAlive)
                            return true;
                    return false;
                }
            }
        }
 
        private abstract class Unit
        {
            public virtual string hero { get; set; }
            public virtual int attack { get; set; }
            public virtual int dodge { get; set; }
            public virtual int hitpoints { get; set; }
            public enum UnitType
            {
                Swordsman,
                Archer,
                Mage
            }
            public virtual UnitType type { get; set; }
 
            public virtual void Attack(Unit target)
            {
                byte[] data = new byte[1];
                var r = new RNGCryptoServiceProvider();
                r.GetBytes(data);
                int q = data[0] % 100;
                if (q < target.dodge)
                    Console.WriteLine("{0} trying attack {1} but he dodged this swing", hero, target.hero);
                else
                {
                    Console.WriteLine("{0} attack {1} by {2} damage", hero, target.hero, attack);
                    target.hitpoints -= attack;
                    if (target.hitpoints <= 0)
                        Console.WriteLine("{0} dying", target.hero);
                }
            }
            public virtual string getDescription()
            {
                string hp = (hitpoints <= 0) ? "Dead :(" : "Hitpoints: " + hitpoints.ToString();
                return hero + "\n" + hp;
            }
            public virtual bool IsAlive
            {
                get
                {
                    return hitpoints > 0;
                }
            }
 
 
        }
 
        private class Swordsman : Unit
        {
            public Swordsman()
            {
                hero = "Swordsman - melee unit";
                attack = 5;
                dodge = 60;
                hitpoints = 15;
                type = UnitType.Swordsman;
            }
        }
 
        private class Archer : Unit
        {
            public Archer()
            {
                hero = "Archer - powerful then the bang";
                attack = 4;
                dodge = 40;
                hitpoints = 12;
                type = UnitType.Archer;
            }
        }
 
        private class Mage : Unit
        {
            public Mage()
            {
                hero = "Mage - powerfull spellcaster";
                attack = 10;
                dodge = 30;
                hitpoints = 8;
                type = UnitType.Mage;
            }
        }
    }
    
}

using System;
using System.Collections.Generic;
 
namespace ConsoleWars
{
    class Program
    {
        static void Main()
        {
            const int n = 3;
            var team1 = new Unit[n];
            for (int i = 0; i < n; i++)
                team1[i] = new Mage();
            var team2 = new Unit[n];
            for (int i = 0; i < n; i++)
                team2[i] = new Mage();
            while (CheckTeam(team1) && CheckTeam(team2))
            {
                for (int i = 0; i < n; i++)
                {
                    //Ход бойца первой команды
                    int index;
                    bool result = team1[i].Attack(team2, out index);
                    if (index > 0 && index <= n)
                    {
                        Console.Write("{0} боец команды I ударил {1} бойца команды II", i + 1, index);
                        Console.Write(result ? ", нанеся {0} урона, " : " и промахнулся", team1[i].Damage);
                        Console.WriteLine(team2[index - 1].Dead ? "и убил его" : ". У него осталось {0} жизней",
                                          team2[index - 1].HitPoints);
                    }
                    //Ход бойца второй команды
                    result = team2[i].Attack(team1, out index);
                    if (index <= 0 || index > n) continue;
                    Console.Write("{0} боец команды II ударил {1} бойца команды I", i + 1, index);
                    Console.Write(result ? ", нанеся {0} урона, " : " и промахнулся", team2[i].Damage);
                    Console.WriteLine(team1[index - 1].Dead ? "и убил его" : ". У него осталось {0} жизней",
                                      team1[index - 1].HitPoints);
                }
                int alive1 = 0, alive2 = 0;
                foreach (var unit in team1)
                    if (!unit.Dead)
                        alive1++;
                foreach (var unit in team2)
                    if (!unit.Dead)
                        alive2++;
                Console.WriteLine("\nХод закончен");
                Console.WriteLine("В команде №1 {0} выживших. В команде № 2 {1} выживших",alive1,alive2);
            } 
            int winner = CheckTeam(team1) ? 1 : 2;
            Console.WriteLine("Все бойцы команды {0} умерли. Победила команда {1}", 3 - winner, winner);
            Console.ReadKey();
        }
        static bool CheckTeam(IEnumerable<Unit> team)
        {
            bool result = true;
            foreach (var unit in team)
                result &= unit.Dead;
            return !result;
        }
    }
}

using System;
 
namespace ConsoleWars
{
    internal abstract class Unit
    {
        public int HitPoints { get; protected set; }
        public int Damage { get; protected set; }
        public double Evasion { get; protected set; }
        public bool Dead { get; protected set; }
        protected static readonly Random TeamRandom = new Random(); //Статический для того, чтобы на всю команду был один рандом
 
 
        protected abstract bool Evade();
        protected abstract void Die();
        public abstract bool Attacked(int damage);
        public abstract bool Attack(Unit[] enemies, out int i);
    }
 
    internal class Mage : Unit
    {
        private const int HP = 8;
        private const int DMG = 10;
        private const double EVA = 0.3;
        
 
        public Mage()
        {
            HitPoints = HP;
            Damage = DMG;
            Evasion = EVA;
        }
 
 
        public override bool Attack(Unit[] enemies, out int i)
        {
            i = 0;
            if (Dead) return false; //Если умерли, ничего не делаем
            foreach (var other in enemies) //Если есть враг нашего типа, то бьем его
            {
                i++;
                if (other is Mage && !other.Dead)
                    return other.Attacked(Damage);
            }
            do
            {
                i = TeamRandom.Next(enemies.Length);
            } while (!enemies[i].Dead);
            return enemies[i].Attacked(Damage); //Иначе бьем случайного врага
        }
 
        public override bool Attacked(int damage)
        {
            if (Dead || Evade())
                return false; //Если увернулись, то не деремся. Умерший считается всегда уворачивающимся
            HitPoints -= damage;
            if (HitPoints <= 0)
                Die();
            return true;
        }
 
        protected override bool Evade()
        {
            var x = TeamRandom.NextDouble();
            return x < Evasion;
        }
 
        protected override void Die()
        {
            Dead = true;
        }
    }
}