Нужно написать библиотеку классов БЕЛЫЙ КОРОЛЬ И КОНЬ ПРОТИВ ЧЕРНОГО КОРОЛЯ

using Game;
using System;
using System.Collections;
using System.Drawing;
namespace Game
{
    /// <summary>
    /// Класс задания позиции в игре.
    /// </summary>
    public class Position
    {
        // константы, характерные для шахмат
        private const int king = 1;
        private const int horse = 2;
        private const int white_color = 0;
        private const int black_color = 1;
        private const int board = 7;
        public string namegame; //название игры –
                                //обязателен для всех
        public int width, height; //ширина, высота
                                  // огранич.макс. изображение позиции
        public int cvet; //цвет того, кто
                         // делает ход в данной позиции
                         //--------------------------------------------------
        ArrayList sp_figur; // список фигур – не
                            // обязателен для др.игр
        
                   // инструменты для вывода позиции на экран
        private System.Drawing.Pen pen;
        private System.Drawing.Brush brush;
        private System.Drawing.Font font;
        //-----------------------------------------------------------------
        public Position() //обязательный метод
        {
            namegame = "Этюд: белые: король+слон; черные: король";
            sp_figur = new ArrayList();
            width = 80;
            height = 50;
            cvet = white_color;
            pen = new System.Drawing.Pen(System.Drawing.Color.Black);
            brush = System.Drawing.Brushes.Black;
        font = new System.Drawing.Font("Arial", 8.0f,System.Drawing.FontStyle.Regular);
        }
        //-----------------------------------------------------------------
        public void init() //обязательный метод
        {
            King king1 = new King();
            King king2 = new King();
            Horse horse_w = new Horse();
            
 
            king1.init(3, 4, white_color,king);
            king2.init(3, 7, black_color, king);
            horse_w.init(3, 1, white_color, horse);
       
 
            sp_figur.Add(king1);
            sp_figur.Add(king2);
            sp_figur.Add(horse_w);
 
 
 
 
            //King wk, bk; //белый i черный король
            // wk = new King();
            // bk = new King();
            // инициализация экземпляров классов
            // wk.init(3, 0, white_color, king);
            //// bk.init(3, 7, black_color, king);
            //занесение в список фигур---------------
            //sp_figur.Add(wk);
            // sp_figur.Add(bk);
        }
        //---Генерация списка позиций следующего уровня-----------
        public void Generate_Pos(int ho_go, ref ArrayList list_pos)
        //обязательный метод
        //переделаааать
        {
            list_pos.Clear();
            ArrayList pos = this.sp_figur, posn;
            ArrayList sp_pt = new ArrayList();
            Position new_pos;
            this.cvet = ho_go;
            //главный цикл по фигурам----------------------
            figura rf, rf1, rf2;
            Point pt;
            for (int i = 0; i < pos.Count; i++)
            {
                rf = (figura)pos[i];
                if (rf.cvet != ho_go) continue;
                sp_pt = rf.may_by_step(ho_go);
                if (sp_pt == null) continue;
                if (sp_pt.Count < 1) continue;
                sp_pt = na_doske(sp_pt);
                if (sp_pt.Count < 1) continue;
                sp_pt = ne_zanato(sp_pt, pos);
                if (sp_pt.Count < 1) continue;
 
            for (int jj = 0; jj < pos.Count; jj++)
                {
                    rf1 = (figura)pos[jj];
                    if (rf1.cvet == ho_go) continue;
                    if (i == jj) continue;
                    sp_pt = ne_pod_boem(sp_pt, rf1);
                    if (sp_pt.Count < 1) break;
                }
                for (int n = 0; n < pos.Count; n++)
                { rf2 = (figura)pos[n];
                    if (rf2.cvet == ho_go) continue;
 
                }
                //формирование позиций-------------------------------
                for (int j = 0; j < sp_pt.Count; j++)
                {
                    pt = (Point)sp_pt[j];
                    rf1 = new figura();
                    rf1.kod = rf.kod;
                    rf1.cvet = rf.cvet;
                    rf1.x = pt.X; rf1.y = pt.Y;
                    posn = new ArrayList();
                    for (int kk = 0; kk < pos.Count; kk++)
                    {
                        if (kk == i) posn.Add(rf1);
                        else posn.Add(pos[kk]);
                    }
                    new_pos = new Position();
                    new_pos.sp_figur = posn;
                    new_pos.width = this.width;
                    new_pos.height = this.height;
                    new_pos.cvet = 1 - ho_go;
                    list_pos.Add(new_pos);
                }
            }
        }
        //-----Отображение позиции на экране ----------------------------
        public void Draw_position(int X, int Y,
        System.Drawing.Graphics polotno)
        // обязательный метод
        //переделать
        {
            polotno.DrawRectangle(pen, X, Y, width, height);
            figura fg;
            string s;
            int yy = Y;
            for (int i = 0; i < sp_figur.Count; i++)
               
        {
                fg = (figura)sp_figur[i];
                s = fg.x.ToString() + "; " + fg.y.ToString();
                switch (fg.kod)
                {
                    case king:
                        if (fg.cvet == white_color) s = "Б.король " + s;
                        else s = "Ч.король " + s;
                        break;
                    case horse:
                        s = "Конь    " + s;
                        break;
                }
                polotno.DrawString(s, font, brush, (float)X, (float)yy);
                yy += 16;
            }
        }
        //----------Исключение из списка клеток с недоп. координатами -------
        ArrayList na_doske(ArrayList sp_pt)
        {
            Point pt;
            ArrayList new_sp = new ArrayList();
            for (int j = 0; j < sp_pt.Count; j++)
            {
                pt = (Point)sp_pt[j];
                if ((pt.X < 0) || (pt.X > board) || (pt.Y < 0) ||
                (pt.Y > board)) continue;
                new_sp.Add(pt);
            }
            return new_sp;
        }
        //--- Исключение из списка клеток, занятых фигурами--------
        ArrayList ne_zanato(ArrayList sp_pt, ArrayList pos)
        {
            Point pt;
            ArrayList new_sp = new ArrayList();
            figura fg;
            bool zan;
            for (int j = 0; j < sp_pt.Count; j++)
            {
                pt = (Point)sp_pt[j];
                zan = false;
                for (int k = 0; k < pos.Count; k++)
                {
                fg = (figura)pos[k];
                    if ((pt.X == fg.x) && (pt.Y == fg.y))
                    { zan = true; break; }
                }
                if (!zan) new_sp.Add(pt);
            }
            return new_sp;
        }
        //----- Исключение из списка клеток, находящихся под боем
        ArrayList ne_pod_boem(ArrayList sp_pt, figura fig)
        {
            Point pt;
            ArrayList new_sp = new ArrayList();
            for (int j = 0; j < sp_pt.Count; j++)
            {
                pt = (Point)sp_pt[j];
                if (fig.ne_pod_boem(pt.X, pt.Y)) new_sp.Add(pt);
            }
            return new_sp;
        }
    }
    //-------------------------------------------------------------------
    /// <summary>
    /// Базовый класс шахматной фигуры.
    /// </summary>
    class figura
    {
        public int x, y, cvet, kod;
        public void init(int nx, int ny, int ncvet, int nkod)
        {
            x = nx; y = ny; cvet = ncvet; kod = nkod;
        }
        public virtual ArrayList may_by_step(int cv)
        {
            return null;
        }
        public virtual bool ne_pod_boem(int xx, int yy)
        {
            return true;
        }
    }
    //------------------------------------------------------------
    /// <summary>
    /// Summary description for King.
    /// </summary>
    class Horse : figura
    {
        int[] dx = {-2,-2,-1,-1,1,1,2,2 };
        int[] dy = {-1,1,-2,2,-2,2,-1,1};
        public Horse()
        {
        }
 
        public override ArrayList may_by_step(int cv)
        {
            ArrayList sp_pos = new ArrayList();
            if (this.cvet != cv) return sp_pos;
            for (int i= 0; i < dx.Length; i++)
            {
                Point point = new Point(x + dx[i], y + dy[i]);
                sp_pos.Add((object)point);
            }
            return sp_pos;
        }
 
        public override bool ne_pod_boem(int xx, int yy)
        {
            for (int i = 0; i < dx.Length; i++)
            {
                if (xx == x + dx[i] && yy == y + dy[i])
                    return false;
            }
            return true;
        }
    }
}
    
class King : figura
    {
        int[] dx = { -1, 0, 1, -1, 1, -1, 0, 1 };
        int[] dy = { -1, -1, -1, 0, 0, 1, 1, 1 };
        public King()
        {
        }
        //-----генерация списка всех возможных ходов короля-------------
        public override ArrayList may_by_step(int cv)
        {
            ArrayList sp_pos = new ArrayList();
            if (this.cvet != cv) return sp_pos;
            Point pt;
            for (int i = 0; i < dx.Length; i++)
            {
                pt = new Point(x + dx[i], y + dy[i]);
                sp_pos.Add(pt);
            }
            return sp_pos;
        }
        //---проверка что клетка(xx, yy) не находится под боем короля----- public override bool ne_pod_boem(int xx, int yy)
        public override bool ne_pod_boem(int xx, int yy)
        {
            if ((System.Math.Abs(xx - x) <= 1) &&(System.Math.Abs(yy - y) <= 1)) return false;
            return true;
        }
    }

/// <summary>Перечисление допустимых цветов</summary>
public enum ColorsEnum
{
    /// <summary>Белый</summary>
    White,
    /// <summary>Чёрный</summary>
    Black    
}

/// <summary>Позиция фигуры</summary>
public struct Point
{
   /// <summary>Позиция по горизонтали</summary>
   public int X {get;}
   /// <summary>Позиция по Вертикали</summary>
   public int Y {get;}
 
   /// <summary>Конструктор</summary>
   public Point (int x, int y)
   {
      if (x <0 || x >8)
        throw new ArgumentOutOfRangeException(nameof(x));
      if (y <0 || y >8)
        throw new ArgumentOutOfRangeException(nameof(y));
 
       X = x;
       Y = y;
    }
 
    /// <summary>Статический метод Парсер-Конструктор</summary>
    public static Point Parse(string str)
    {
        if (str.Lenght !=2)
           throw new ArgumentException("Должен передаваться двух буквенный аргумент", nameof(str));
 
        char x = char.ToLower(str[0]);
        int xx=0;
        if (x >='a' && x <= 'h')
          xx = x - 'a';
        else if(x >='0' && x <= '8')
          xx = x - '0';
        else 
           throw new ArgumentException("Первый символ некорректен", nameof(str));
      
        char y = char.ToLower(str[1]);
        int yy=0;
        if(y >='0' && y <= '8')
          yy = y - '0';
        else 
           throw new ArgumentException("Второй символ некорректен", nameof(str));
 
       return new Point(xx, yy);
    }
    public static bool TryParse(string str, out Point point)
    {
       try
       {
           point = Parse(str);
           return true;
       }
       catch (Exception)
      {
           point = new Point();
           return false;
       }
 
   }
   
    public override string ToString() => new string(new char[]{(char)('a'+X), (char)('0'+Y)});
}

    /// <summary>Базовый класс шахматной фигуры</summary>
    public class Figura
    {
        /// <summary>Позиция фигуры</summary>
        public Point Position {get; private set;}
        /// <summary>Цвет фигуры</summary>
        public ColorsEnum Color {get;}
        /// <summary>Название фигуры</summary>
        public NamesEnum Name {get}
 
        piblic Figura(NamesEnum name, ColorsEnum color) 
        {
            Name = name; 
            Color = color;
        }
        
        public Figura(NamesEnum name, ColorsEnum color, Point position)
           : this(name, color)
           => SetPosition (position);
 
        public void SetPosition (Point position)=> Position = position;
 
        public virtual IEnumerable<Point> MayByStep(int cv)
        {
            return null;
        }
 
        public virtual bool NePodBoem(Point position)
        {
            return true;
        }
    }