public IChessGame Move(string move) // Pe2e4 Pe7e8Q
{
var movingFigure = new MovingFigure(move);
if (board.GetFigureAt(movingFigure.From) == Figure.None)
{
return(this);
}
if ((movingFigure.Figure == Figure.BlackKing || movingFigure.Figure == Figure.WhiteKing) &&
(movingFigure.AbsDeltaX == 2 && movingFigure.AbsDeltaY == 0)) // its castling
{
var targetColor = movingFigure.Figure.GetColor();
if (targetColor != board.MoveColor)
{
return(this);
}
var isToKingside = movingFigure.SignX > 0;
if (CanKingCastle(isToKingside))
{
return(Castle(isToKingside));
}
else
{
return(this);
}
}
if (!currentMove.CanMove(movingFigure))
{
return(this);
}
if (board.IsCheckAfterMove(movingFigure))
{
return(this);
}
var nextBoard = board.Move(movingFigure);
var nextChessPosition = new ChessGame(nextBoard);
if (nextBoard.IsCheckAfterMove(movingFigure))
{
CheckTo = (Common.Helpers.Color)nextBoard.MoveColor;
if (nextChessPosition.ComputeAllMoves().Count < 1)
{
MateTo = (Common.Helpers.Color)nextBoard.MoveColor;
}
}
else
{
CheckTo = Common.Helpers.Color.None;
}
return(nextChessPosition);
}
public List <string> GetAllValidMovesForFigureAt(int x, int y)
{
var validMoves = new List <string>();
var targetSquare = new Square(x, y);
if (!targetSquare.IsOnBoard())
{
return(validMoves);
}
var targetFigure = board.GetFigureAt(targetSquare);
if (targetFigure == Figure.None || targetFigure.GetColor() != board.MoveColor)
{
return(validMoves);
}
var figureOnSquare = new FigureOnSquare(targetFigure, targetSquare);
MovingFigure movingFigure;
foreach (var squareTo in Square.YieldSquares())
{
movingFigure = new MovingFigure(figureOnSquare, squareTo);
if (currentMove.CanMove(movingFigure) &&
!board.IsCheckAfterMove(movingFigure))
{
validMoves.Add(((char)('a' + squareTo.X)).ToString() + (squareTo.Y + 1));
}
}
if (targetFigure == Figure.BlackKing || targetFigure == Figure.WhiteKing)
{
if (CanKingCastle(true))
{
validMoves.Add($"g{y + 1}");
}
if (CanKingCastle(false))
{
validMoves.Add($"c{y + 1}");
}
}
return(validMoves);
}
private List <MovingFigure> ComputeAllMoves()
{
var allMoves = new List <MovingFigure>();
MovingFigure movingFigure;
foreach (var figureOnSquare in board.YieldFigures())
{
foreach (var squareTo in Square.YieldSquares())
{
movingFigure = new MovingFigure(figureOnSquare, squareTo);
if (currentMove.CanMove(movingFigure) &&
!board.IsCheckAfterMove(movingFigure))
{
allMoves.Add(movingFigure);
}
}
}
return(allMoves);
}
public bool CanMove(MovingFigure movingFigure)
{
this.movingFigure = movingFigure;
return(movingFigure.To.IsOnBoard() && CanFigureMove() && CanMove() && CanMoveTo());
}
private bool CanKingCastle(bool isToKingside)
{
board.MoveColor = board.MoveColor.FlipColor();
if (board.IsCheckTo())
{
board.MoveColor = board.MoveColor.FlipColor();
return(false);
}
board.MoveColor = board.MoveColor.FlipColor();
var isWhiteSide = board.MoveColor == Moves.Helpers.Color.White;
var king = (isWhiteSide) ? Figure.WhiteKing : Figure.BlackKing;
var rookFigure = (isWhiteSide) ? Figure.WhiteRook : Figure.BlackRook;
var y = (isWhiteSide) ? 0 : 7;
var stepX = (isToKingside) ? 1 : -1;
if (!IsCastlingPossible(stepX > 0, king.GetColor()))
{
return(false);
}
MovingFigure mf;
if (stepX == -1)
{
if (board.GetFigureAt(1, y) != Figure.None ||
board.GetFigureAt(2, y) != Figure.None ||
board.GetFigureAt(3, y) != Figure.None)
{
return(false);
}
}
else
{
if (board.GetFigureAt(6, y) != Figure.None ||
board.GetFigureAt(5, y) != Figure.None)
{
return(false);
}
}
var firstKingDestSquare = new Square(4 + stepX, y);
mf = new MovingFigure(new FigureOnSquare(king, new Square(4, y)), firstKingDestSquare);
if (!currentMove.CanMove(mf))
{
return(false);
}
if (board.IsCheckAfterMove(mf))
{
return(false);
}
var boardAfterFirstMove = board.GetBoardAfterFirstKingCastlingMove(mf);
var moveAfterFirstKingMove = new Move(boardAfterFirstMove);
var finalKingDestSquare = new Square(firstKingDestSquare.X + stepX, y);
mf = new MovingFigure(new FigureOnSquare(king, firstKingDestSquare), finalKingDestSquare);
if (!moveAfterFirstKingMove.CanMove(mf))
{
return(false);
}
if (boardAfterFirstMove.IsCheckAfterMove(mf))
{
return(false);
}
return(true);
}
private void Awake()
{
figure = transform.parent.parent.GetComponent <MovingFigure>();
direction = transform.localPosition;
}
