Помогите решить задачу на C#

Каво
using System;

namespace ChessGame
{
class PositionCheck
{
public bool IsChecked(Chessboard board, ChessGamePiece currentPiece)
{
// Проверка шахов
if (currentPiece.IsKing && CanBeChecked(board.BlackKing, currentPiece))
{
return true;
}
return false;

}
}
}

Для решения этой задачи тебе придется реализовать иерархию классов. Я предлагаю (но не настаиваю) то, что ниже. Задание там формально выполнено, метод UnderCheck у короля присутствует. Если нужен полный код - реализуй оставшиеся фигуры и расставь их на доске.

 public struct ChessPosition : IEquatable<ChessPosition> 
{ 
    private char x; 
    private int y; 
    public char X 
    { 
        get => x; 
        set 
        { 
            if (value < 'a' || value > 'h') 
                throw new ArgumentException("Invalid position"); 
            x = value; 
        } 
    } 
    public int Y 
    { 
        get => y; 
        set 
        { 
            if (value < '1' || value > '8') 
                throw new ArgumentException("Invalid position"); 
            y = value; 
        } 
    }     
 
    public bool Equals(ChessPosition other) 
    { 
        return other.X == X && other.Y == Y; 
    } 
 
    public ChessPosition(string _Position) 
    { 
        X = _Position[0]; 
        Y = int.Parse(_Position[1].ToString()); 
    } 
} 
 
 
public abstract class BaseChessFigurine 
{ 
    public enum ChessColor { White, Black } 
    private ChessColor color; 
    private ChessPosition position; 
    public ChessColor Color { get => color; } 
    public ChessPosition Position { get => position; } 
    public BaseChessFigurine(ChessColor _Color, ChessPosition _Position) 
    { 
        this.color = _Color; 
        this.position = _Position; 
    } 
    public abstract bool CanMoveTo(ChessPosition _NewPosition); 
} 
 
public class BaseChessBoard : List<BaseChessFigurine> 
{ 
    public bool Occupied(ChessPosition _Position) 
    { 
        foreach (var f in this) 
            if (f.Position.Equals(_Position)) 
                return true; 
        return false; 
    } 
} 
 
public abstract class BaseMovingChessFigurine : BaseChessFigurine 
{ 
    protected BaseChessBoard Board; 
    public BaseMovingChessFigurine(ChessColor _Color, ChessPosition _Position, BaseChessBoard _Board) : base(_Color, _Position) 
    { 
        this.Board = _Board; 
    } 
 
    public bool UnderFire() 
    { 
        foreach (var figurine in Board) 
            if (figurine.Color != Color && figurine.CanMoveTo(Position)) 
                return true; 
        return false; 
    } 
} 
 
public class King : BaseMovingChessFigurine 
{ 
    public King(ChessColor _Color, ChessPosition _Position, BaseChessBoard _Board) : base(_Color, _Position, _Board) 
    { 
    } 
 
    public override bool CanMoveTo(ChessPosition _NewPosition) 
    { 
        King NewKing = new King(Color, _NewPosition, Board); 
        return Math.Abs(_NewPosition.Y - Position.Y) < 2 && Math.Abs(_NewPosition.X - Position.X) < 2 && !_NewPosition.Equals(Position) && !NewKing.UnderCheck();
    } 
 
    public bool UnderCheck() => UnderFire(); 
}