Шахматы, реализация шах и мат

using MyChess;
using MyChess.Chess;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
 
string[,] field = new string[10, 10];
Dictionary<string, Tuple<int, int>> algebraicToIndex = new Dictionary<string, Tuple<int, int>>();
int rows = 10;
int columns = 10;
int x, y;
 
 
Console.OutputEncoding = System.Text.Encoding.UTF8;
 
 
string pw = "[♙]";
string pb = "[♟]";
string Kw = "[♔]";
string Kb = "[♚]";
string rw = "[♖]";
string rb = "[♜]";
string bw = "[♗]";
string bb = "[♝]";
string kw = "[♘]";
string kb = "[♞]";
string qw = "[♕]";
string qb = "[♛]";
 
for (int i = 1; i < 9; i++)
{
    char file = (char)('A' + (i - 1));
    field[0, i] = $" {file}";
    for (int j = 1; j < 9; j++)
    {
        char rank = (char)('8' - (j - 1));
        string key = $"{file}{rank}";
        algebraicToIndex[key] = new Tuple<int, int>(j, i);
    }
}
 
for (int i = 1; i < 9; i++)
{
    field[i, 0] = $" {9 - i}";
}
 
for (int i = 1; i < 9; i++)
{
    for (int j = 1; j < 9; j++)
    {
        field[i, j] = "[ ]";
    }
}
 
 
Console.WriteLine("C# survival game was begun");
 
//Здесь магия еммае
 
//Объявляем фигурки любимые
 
Pawn pawnW = new Pawn(2, 1, pw, "white");
Pawn pawn1W = new Pawn(2, 2, pw, "white");
Pawn pawn2W = new Pawn(2, 3, pw, "white");
Pawn pawn3W = new Pawn(2, 4, pw, "white");
Pawn pawn4W = new Pawn(2, 5, pw, "white");      
Pawn pawn5W = new Pawn(2, 6, pw, "white");
Pawn pawn6W = new Pawn(2, 7, pw, "white");
Pawn pawn7W = new Pawn(2, 8, pw, "white");
                                                //Здесь  белые пешечки
field[pawnW.x, pawnW.y] = pawnW.name;
field[pawn1W.x, pawn1W.y] = pawn1W.name;
field[pawn2W.x, pawn2W.y] = pawn2W.name;
field[pawn3W.x, pawn3W.y] = pawn3W.name;
field[pawn4W.x, pawn4W.y] = pawn4W.name;
field[pawn5W.x, pawn5W.y] = pawn5W.name;
field[pawn6W.x, pawn6W.y] = pawn6W.name;
field[pawn7W.x, pawn7W.y] = pawn7W.name;
 
Pawn pawnB = new Pawn(7, 1, pb, "black");
Pawn pawn1B = new Pawn(7, 2, pb, "black");
Pawn pawn2B = new Pawn(7, 3, pb, "black");
Pawn pawn3B = new Pawn(7, 4, pb, "black");
Pawn pawn4B = new Pawn(7, 5, pb, "black");      
Pawn pawn5B = new Pawn(7, 6, pb, "black");
Pawn pawn6B = new Pawn(7, 7, pb, "black");
Pawn pawn7B = new Pawn(7, 8, pb, "black");
                                                //Здесь  черные пешечки пешечки
field[pawnB.x, pawnB.y] = pawnB.name;
field[pawn1B.x, pawn1B.y] = pawn1B.name;
field[pawn2B.x, pawn2B.y] = pawn2B.name;
field[pawn3B.x, pawn3B.y] = pawn3B.name;
field[pawn4B.x, pawn4B.y] = pawn4B.name;
field[pawn5B.x, pawn5B.y] = pawn5B.name;
field[pawn6B.x, pawn6B.y] = pawn6B.name;
field[pawn7B.x, pawn7B.y] = pawn7B.name;
 
 
Rook rookW = new Rook(1, 1, rw, "white");
Rook rook1W = new Rook(1, 8, rw, "white");
Rook rookB = new Rook(8, 1, rb, "black");    
Rook rook1B = new Rook(8, 8, rb, "black");
                                                //Ладья
field[rookW.x, rookW.y] = rookW.name;
field[rook1W.x, rook1W.y] = rook1W.name;
field[rookB.x, rookB.y] = rookB.name;
field[rook1B.x, rook1B.y] = rook1B.name;
 
 
Knight knightW = new Knight(1, 2, kw, "white");
Knight knight1W = new Knight(1, 7, kw, "white");  
Knight knightB = new Knight(8, 2, kb, "black");
Knight knight1B = new Knight(8, 7, kb, "black");
                                                      //Скачи-скачи мой пони иго-го
field[knightW.x, knightW.y] = knightW.name;
field[knight1W.x, knight1W.y] = knight1W.name;
field[knightB.x, knightB.y] = knightB.name;
field[knight1B.x, knight1B.y] = knight1B.name;
 
 
Bishop bishopW = new Bishop(1, 3, bw, "white");
Bishop bishop1W = new Bishop(1, 6, bw, "white");
Bishop bishopB = new Bishop(8, 3, bb, "white");   
Bishop bishop1B = new Bishop(8, 6, bb, "white");
                                                      //Слоники
field[bishopW.x, bishopW.y] = bishopW.name;
field[bishop1W.x, bishop1W.y] = bishop1W.name;
field[bishopB.x, bishopB.y] = bishopB.name;
field[bishop1B.x, bishop1B.y] = bishop1B.name;
 
Queen queenW = new Queen(1, 4, qw, "white");    
Queen queenB = new Queen(8, 4, qb, "black");
                                                    // Ферзь емае
field[queenW.x, queenW.y] = queenW.name;
field[queenB.x, queenB.y] = queenB.name;
 
King kingW = new King(1, 5, Kw, "white");
King kingB = new King(8, 5, Kb, "black");
                                                    //Короли
field[kingW.x, kingW.y] = kingW.name;
field[kingB.x, kingB.y] = kingB.name;
 
PrintField();
//тута с фигурками покончено
 
//делаем сраные ходы 
 
for (int i = 0; i < field.Length; i++)
{
 
    // а точно ли ходят эти дауны (проверяю на пешке)
    /*
    Console.WriteLine(pawnW.x);
    Console.WriteLine(pawnW.y);
    */
 
    Console.WriteLine("Выбери фигуру:");
    string input1 = Console.ReadLine();
    if (algebraicToIndex.ContainsKey(input1))
    {
        var coordinates = algebraicToIndex[input1];
        x = coordinates.Item1;
        y = coordinates.Item2;
 
        Console.WriteLine($"Вы выбрали фигуру: {input1}");
        ChessPiece selectedPiece = null;
 
        foreach (ChessPiece piece in new ChessPiece[] { pawnW, pawn1W, pawn2W, pawn3W, pawn4W, pawn5W, pawn6W, pawn7W, pawnB, pawn1B, pawn2B, pawn3B, pawn4B, pawn5B, pawn6B, pawn7B, rookW, rook1W, rookB, rook1B, knightW, knight1W, knightB, knight1B, bishopW, bishop1W, bishopB, bishop1B, queenW, queenB, kingW, kingB })
        {
            if (piece.x == x && piece.y == y)
            {
                selectedPiece = piece;
                break;
            }
        }
 
        if (selectedPiece == null)
        {
            Console.WriteLine("Фигура не найдена на выбранной позиции.");
            continue;
        }
 
        Console.WriteLine("Куда вы хотите сходить?");
        string input2 = Console.ReadLine();
        if (algebraicToIndex.ContainsKey(input2))
        {
            var coordinates2 = algebraicToIndex[input2];
            x = coordinates2.Item1;
            y = coordinates2.Item2;
 
            Console.WriteLine($"Вы сходили на: {input2}");
            MakeMove(selectedPiece, x, y); // Попытка сделать ход
            PrintField();
        }
        else { Console.WriteLine("Выбирайте в пределах поля!"); }
    }
    else { Console.WriteLine("Выбирайте в пределах поля!"); }
}
 
void PrintField()
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < columns; j++)
        {
            Console.Write($"{field[i, j]} \t");
        }
        Console.WriteLine();
    }
}
 
bool MakeMove(ChessPiece piece, int newX, int newY)
{
    if (piece is Pawn pawn)
    {
        if (pawn.IsValidMove(newX, newY))
        {
            field[piece.x, piece.y] = "[ ]";
            piece.x = newX;
            piece.y = newY;
            field[newX, newY] = piece.name;
 
            if (!pawn.hasMoved) pawn.hasMoved = true;
 
            return true;
        }
        else
        {
            Console.WriteLine("Недопустимый ход.");
            return false;
        }
    }
    else
    {
        if ((piece.IsValidMove(newX, newY)) && CheckObstacles(piece.x, piece.y, newX, newY, field))
        {
            field[piece.x, piece.y] = "[ ]"; // очистка старой позиции
            piece.x = newX;
            piece.y = newY;
            field[newX, newY] = piece.name; // установка новой позиции
 
 
 
            return true;
        }
        else
        {
            Console.WriteLine("Недопустимый ход.");
            return false;
        }
    }
}
 
 
 
bool CheckObstacles(int startX, int startY, int endX, int endY, string[,] field)
{
    // Проверка на вертикальное препятствие
    if (startX == endX)
    {
        int minY = Math.Min(startY, endY);
        int maxY = Math.Max(startY, endY);
 
        for (int y = minY + 1; y < maxY; y++)
        {
            if (field[startX, y] != "[ ]")
            {
                return false;
            }
        }
    }
    // Проверка на горизонтальное препятствие
    else if (startY == endY)
    {
        int minX = Math.Min(startX, endX);
        int maxX = Math.Max(startX, endX);
 
        for (int x = minX + 1; x < maxX; x++)
        {
            if (field[x, startY] != "[ ]")
            {
                return false;
            }
        }
    }
    // Проверка на диагональное препятствие
    else if (Math.Abs(startX - endX) == Math.Abs(startY - endY))
    {
        int minX = Math.Min(startX, endX);
        int maxX = Math.Max(startX, endX);
        int minY = Math.Min(startY, endY);
        int maxY = Math.Max(startY, endY);
 
        int j = minY + 1;
 
        for (int i = minX + 1; i < maxX; i++)
        {
            if (startY < endY)
            {
                if (field[i, j] != "[ ]")
                {
                    return false;
                }
                j++;
            }
            else
            {
                if (field[i, j] != "[ ]")
                {
                    return false;
                }
                j--;
            }
        }
    }
 
    return true;
}
 
bool IsCheck(string color, ChessPiece[,] board)
{
    // Найти позицию короля текущего игрока
    int kingX = -1, kingY = -1;
    foreach (ChessPiece piece in board)
    {
        if (piece != null && piece.color == color && piece is King)
        {
            kingX = piece.x;
            kingY = piece.y;
            break;
        }
    }
 
    // Проверить, может ли какая-либо фигура оппонента атаковать короля
    foreach (ChessPiece piece in board)
    {
        if (piece != null && piece.color != color && piece.IsValidMove(kingX, kingY))
        {
            return true;
        }
    }
 
    return false;
}
 
bool IsCheckmate(string color, ChessPiece[,] board)
{
    if (!IsCheck(color, board)) return false;
 
    // Проверить, может ли король переместиться в безопасное положение
    // Проверить, может ли любая другая фигура захватить или заблокировать угрозу
 
    // Реализация зависит от логики ваших классов ChessPiece и правил игры.
    // Вам нужно имитировать все возможные ходы и проверить, может ли какой-либо из них предотвратить мат.
 
    return false; // Вернуть true, если условие мате выполнено
}
 
bool IsStalemate(string color, ChessPiece[,] board)
{
    if (IsCheck(color, board)) return false;
 
    // Проверить, есть ли у текущего игрока допустимые ходы
    // Если доступных ходов нет, это пат
 
    // Реализация зависит от логики ваших классов ChessPiece и правил игры.
    // Имитируйте все возможные ходы и проверьте, есть ли допустимый ход.
 
    return false; // Вернуть true, если условие пата выполнено
}

using System;
using System.Collections.Generic;
 
namespace MyChess.Chess
{
    public abstract class ChessPiece
    {
        public int x;
        public int y;
        public string name;
        public string color;
 
        public ChessPiece(string name, string color)
        {
            this.name = name;
            this.color = color;
        }
 
        public abstract bool IsValidMove(int newX, int newY);
    }
 
    public class Pawn : ChessPiece
    {
        public bool hasMoved = false;
 
        public Pawn(int newX, int newY, string name, string color) : base(name, color)
        {
            this.x = newX;
            this.y = newY;
        }
 
        public override bool IsValidMove(int a, int b)
        {
            if (color == "white")
            {
                if (!hasMoved)
                {
                    if ((a - x == 1 || a - x == 2) && b == y)
                    {
                        hasMoved = true;
                        return true;
                    }
                }
                else
                {
                    if (a - x == 1 && b == y)
                    {
                        return true;
                    }
                }
                return (a - x == 1 && Math.Abs(b - y) == 1);
            }
            else
            {
                if (!hasMoved)
                {
                    if ((x - a == 1 || x - a == 2) && b == y)
                    {
                        hasMoved = true;
                        return true;
                    }
                }
                else
                {
                    if (x - a == 1 && b == y)
                    {
                        return true;
                    }
                }
                return (x - a == 1 && Math.Abs(b - y) == 1);
            }
        }
    }
 
    public class King : ChessPiece
    {
        public King(int newX, int newY, string name, string color) : base(name, color)
        {
            this.x = newX;
            this.y = newY;
        }
 
        public override bool IsValidMove(int newX, int newY)
        {
            return Math.Abs(x - newX) <= 1 && Math.Abs(y - newY) <= 1;
        }
    }
 
    public class Bishop : ChessPiece
    {
        public Bishop(int newX, int newY, string name, string color) : base(name, color)
        {
            this.x = newX;
            this.y = newY;
        }
 
        public override bool IsValidMove(int newX, int newY)
        {
            return Math.Abs(newX - x) == Math.Abs(newY - y);
        }
    }
 
    public class Rook : ChessPiece
    {
        public Rook(int newX, int newY, string name, string color) : base(name, color)
        {
            this.x = newX;
            this.y = newY;
        }
 
        public override bool IsValidMove(int newX, int newY)
        {
            return (x == newX && y != newY) || (x != newX && y == newY);
        }
    }
 
    public class Queen : ChessPiece
    {
        public Queen(int newX, int newY, string name, string color) : base(name, color)
        {
            this.x = newX;
            this.y = newY;
        }
 
        public override bool IsValidMove(int newX, int newY)
        {
            return (x == newX && y != newY) || (x != newX && y == newY) || (Math.Abs(newX - x) == Math.Abs(newY - y));
        }
    }
 
    public class Knight : ChessPiece
    {
        public Knight(int newX, int newY, string name, string color) : base(name, color)
        {
            this.x = newX;
            this.y = newY;
        }
 
        public override bool IsValidMove(int newX, int newY)
        {
            return (Math.Abs(x - newX) == 2 && Math.Abs(y - newY) == 1) || (Math.Abs(x - newX) == 1 && Math.Abs(y - newY) == 2);
        }
    }
}