public void TestAreMovePositionsPossibleMethod(
char initialHorizontal,
int initialVertical,
char targetHorizontal,
int targetVertical,
ChessColors pawnColor,
bool isValid)
{
var arePositionsPossibleMethod = this.PawnType.GetMethod("AreMovePositionsPossible");
var normalChessMoveType = ChessGameLogicProvider.GetType("ChessGameLogic.ChessMoves.NormalChessMovePositions");
var chessBoardPositionType = ChessGameLogicProvider.GetType("ChessGameLogic.ChessBoardPosition");
var move = normalChessMoveType.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0]
.Invoke(new object[]
{
initialHorizontal,
initialVertical,
targetHorizontal,
targetVertical,
});
bool actualResult;
if (pawnColor == ChessColors.White)
{
actualResult = (bool)arePositionsPossibleMethod.Invoke(this.WhitePawnInstance, new object[] { move });
}
else
{
actualResult = (bool)arePositionsPossibleMethod.Invoke(this.BlackPawnInstance, new object[] { move });
}
Assert.AreEqual(isValid, actualResult);
}
/// <summary>
/// Obfuscate the board so <c>obfPlayer</c> does not see the enemies pieces,
/// castling information, or en passant.
/// </summary>
/// <param name="obfPlayer">The player to hide the opponents pieces from</param>
public void Obfuscate(ChessColors obfPlayer)
{
for (int i = 0; i < board.Size; i++)
{
for (int j = 0; j < board.Size; j++)
{
var piece = board.GetPiece(new BoardPosition(i, j));
if (piece != null && piece.Color != obfPlayer)
{
piece.Promote(PieceTypes.Unknown);
}
}
}
if (obfPlayer == ChessColors.White)
{
castling.blackKing = false;
castling.blackQueen = false;
castling.blackLeftRook = new BoardPosition(-1, -1);
castling.blackRightRook = new BoardPosition(-1, -1);
}
else
{
castling.whiteKing = false;
castling.whiteQueen = false;
castling.whiteLeftRook = new BoardPosition(-1, -1);
castling.whiteRightRook = new BoardPosition(-1, -1);
}
enPassant = null;
}
public void TestIsPositionProducableMethod(
char positionHorizontal,
int positionVertical,
ChessColors pawnColor,
bool isProducable)
{
var isPositionProducableMethod = this.PawnType.GetMethod(
"IsPositionProducable",
BindingFlags.Instance | BindingFlags.NonPublic);
var chessBoardPositionType = ChessGameLogicProvider.GetType("ChessGameLogic.ChessBoardPosition");
bool isPositionProducableActualResult;
if (pawnColor == ChessColors.Black)
{
isPositionProducableActualResult = (bool)isPositionProducableMethod.Invoke(
this.BlackPawnInstance,
new object[] { chessBoardPositionType.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).First().Invoke(new object[] { positionHorizontal, positionVertical }), });
}
else
{
isPositionProducableActualResult = (bool)isPositionProducableMethod.Invoke(
this.WhitePawnInstance,
new object[] { chessBoardPositionType.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic).First().Invoke(new object[] { positionHorizontal, positionVertical }), });
}
Assert.AreEqual(isProducable, isPositionProducableActualResult);
}
public ChessPiece(ChessPieces name, ChessColors color, Icon icon)
{
this.name = name;
this.pieceColor = color;
this.lastMove = 0;
image = (new Icon(icon, 48, 48)).ToBitmap();
}
public virtual bool IsValidMove(BoardSquare[,] board, int fromRow, int fromCol, int toRow, int toCol, ChessColors turn, int turnNumber)
{
if (!(InRange(fromRow) && InRange(fromCol) && InRange(toRow) && InRange(toCol)))
return false;
else if (fromRow == toRow && fromCol == toCol)
return false;
else
return true;
}
private static Tuple <ChessColors, ChessTimeControl, ChessGameVariants, string, string, string> ParseSettings(string settings)
{
//!chess new color:{Color}, timemode:{TimeControl}, variant:{GameVariant}, fen:{string}, increment:{int}, time:{double}
int settingsIndexStart = settings.IndexOf("new", StringComparison.Ordinal) + 4;
if (settings.Length <= settingsIndexStart)
{
return
(new Tuple <ChessColors, ChessTimeControl, ChessGameVariants, string, string, string>(
ChessColors.Random, ChessTimeControl.Unlimited, ChessGameVariants.Standard,
"", "8", "5.0"));
}
string[] settingStrings = settings.Substring(settingsIndexStart).ToLower().Replace(" ", "").Split(',');
string color = string.Empty;
string timemode = string.Empty;
string variant = string.Empty;
string fen = string.Empty;
string increment = "8";
string time = "5.0";
foreach (string setting in settingStrings)
{
if (setting.Contains("color"))
{
color = setting.Substring(6, setting.Length - 6);
}
else if (setting.Contains("timemode"))
{
timemode = setting.Substring(9, setting.Length - 9);
}
else if (setting.Contains("variant"))
{
variant = setting.Substring(8, setting.Length - 8);
}
else if (setting.Contains("fen"))
{
fen = setting.Substring(4, setting.Length - 4);
}
else if (setting.Contains("increment"))
{
increment = setting.Substring(10, setting.Length - 10);
}
else if (setting.Contains("time"))
{
time = setting.Substring(5, setting.Length - 5);
}
}
ChessColors chessColors = (ChessColors)(string.IsNullOrEmpty(color) ? ChessColors.Random : color.GetEnum <ChessColors>());
ChessTimeControl chessTimeControl = (ChessTimeControl)(string.IsNullOrEmpty(timemode) ? ChessTimeControl.Unlimited : timemode.GetEnum <ChessTimeControl>());
ChessGameVariants chessGameVariants = (ChessGameVariants)(string.IsNullOrEmpty(variant) ? ChessGameVariants.Standard : variant.GetEnum <ChessGameVariants>());
return(new Tuple <ChessColors, ChessTimeControl, ChessGameVariants, string, string, string>(chessColors, chessTimeControl, chessGameVariants, fen, increment, time));
}
/// <summary>
/// Get a move from the user
/// </summary>
/// <param name="gameState">The current state of the game</param>
/// <param name="color">The color of the player</param>
/// <returns></returns>
public ChessMove GetMove(GameState gameState, ChessColors color)
{
this.gameState = gameState;
this.playerColor = color;
ChessMove move = storedMove.Var;
legalMoves.Clear();
return(move);
}
/// <summary>
/// Convert a chess color to a character
/// </summary>
/// <para>
/// White becomes 'w' and black becomes 'b'
/// </para>
/// <seealso cref="FromChar"/>
public static char ToChar(this ChessColors color)
{
switch (color)
{
case ChessColors.Black:
return('b');
default:
return('w');
}
}
/// <summary>
/// Return the color that is not this one
/// </summary>
public static ChessColors Other(this ChessColors color)
{
switch (color)
{
case ChessColors.Black:
return(ChessColors.White);
default:
return(ChessColors.Black);
}
}
private void InitBoard()
{
toSq = null;
fromSq = null;
board = new BoardSquare[8, 8];
int width = panelChessBoard.Width/8;
int height = panelChessBoard.Height/8;
for (int row=0; row < 8; row++)
for (int col = 0; col < 8; col++)
{
board[row, col] = new BoardSquare(row, col, width, height);
panelChessBoard.Controls.Add(board[row, col]);
board[row, col].Click += new System.EventHandler(Square_Click);
}
board[0, 0].ChessPiece = new Rook(ChessColors.Black);
board[0, 7].ChessPiece = new Rook(ChessColors.Black);
board[7, 0].ChessPiece = new Rook(ChessColors.White);
board[7, 7].ChessPiece = new Rook(ChessColors.White);
board[0, 2].ChessPiece = new Bishop(ChessColors.Black);
board[0, 5].ChessPiece = new Bishop(ChessColors.Black);
board[7, 2].ChessPiece = new Bishop(ChessColors.White);
board[7, 5].ChessPiece = new Bishop(ChessColors.White);
board[0, 1].ChessPiece = new Knight(ChessColors.Black);
board[0, 6].ChessPiece = new Knight(ChessColors.Black);
board[7, 1].ChessPiece = new Knight(ChessColors.White);
board[7, 6].ChessPiece = new Knight(ChessColors.White);
board[0, 3].ChessPiece = new King(ChessColors.Black);
board[7, 4].ChessPiece = new King(ChessColors.White);
board[0, 4].ChessPiece = new Queen(ChessColors.Black);
board[7, 3].ChessPiece = new Queen(ChessColors.White);
for (int i = 0; i <= 7; i++)
board[1, i].ChessPiece = new Pawn(ChessColors.Black);
for (int i = 0; i <= 7; i++)
board[6, i].ChessPiece = new Pawn(ChessColors.White);
turn = ChessColors.White;
label2.Text = turn.ToString();
label2.Refresh();
//board[0, 0].Image = (new Icon(Properties.Resources.Black_Rook, 48, 48)).ToBitmap();
}
/// <summary>
/// Construct a game state given all of its parameters
/// </summary>
/// <param name="board"></param>
/// <param name="taken"></param>
/// <param name="player"></param>
/// <param name="castling"></param>
/// <param name="enPassant"></param>
/// <param name="halfmoveClock"></param>
/// <param name="fullmoveClock"></param>
/// <param name="gameType"></param>
public GameState(Board board, List <Piece> taken, ChessColors player,
CastlingInfo castling, Nullable <BoardPosition> enPassant,
int halfmoveClock, int fullmoveClock, GameTypes gameType)
{
this.board = board;
this.taken = taken;
this.player = player;
this.castling = castling;
this.enPassant = enPassant;
this.halfmoveClock = halfmoveClock;
this.fullmoveClock = fullmoveClock;
this.gameType = gameType;
}
/// <summary>
/// Construct a game state given only a board
/// </summary>
/// <param name="board">The game board</param>
public GameState(Board board)
{
this.board = board;
this.taken = new List <Piece>();
this.player = ChessColors.White;
this.castling = new CastlingInfo {
whiteKing = true,
whiteQueen = true,
blackKing = true,
blackQueen = true
};
enPassant = null;
gameType = GameTypes.Normal;
}
public BoardSquare(int row, int col, int width, int height)
{
this.row = row;
this.col = col;
this.Location = new Point(col * width, row * height);
this.Size = new Size(width, height);
squareColor = (row + col) % 2 == 0 ? ChessColors.Black : ChessColors.White;
this.BackColor = squareColor == ChessColors.Black ? Color.Black : Color.White;
this.SizeMode = PictureBoxSizeMode.CenterImage;
chessPiece = null;
}
public override bool IsValidMove(BoardSquare[,] board, int fromRow, int fromCol, int toRow, int toCol, ChessColors turn, int turnNumber)
{
if (!base.IsValidMove(board, fromRow, fromCol, toRow, toCol, turn, turnNumber))
return false;
if (turn == ChessColors.Black)
{
if (fromRow > toRow)
return false;
}
if (turn == ChessColors.White)
{
if (fromRow < toRow)
return false;
}
if (board[toRow, toCol].ChessPiece == null)
{
if (Math.Abs(fromRow - toRow) == 1 && fromCol == toCol)
return true;
//en passant implemented here
else if (Math.Abs(fromRow - toRow) == 1 && Math.Abs(toCol - fromCol) == 1)
{
if (board[fromRow, toCol].ChessPiece.Name == ChessPieces.Pawn &&board[fromRow, toCol].ChessPiece.PieceColor != turn && board[fromRow, toCol].ChessPiece.LastMove == turnNumber - 1)
return true;
else
return false;
}
else if (Math.Abs(fromRow - toRow) == 2 && toCol == fromCol)
{
if (board[fromRow,fromCol].ChessPiece.LastMove == 0)
return true;
else
return false;
}
else
return false;
}
else if (board[toRow, toCol].ChessPiece != null)
{
if (board[toRow, toCol].ChessPiece.PieceColor != turn && Math.Abs(fromRow - toRow) == 1 && Math.Abs(toCol-fromCol) == 1)
return true;
else
return false;
}
return false;
}
public override bool IsValidMove(BoardSquare[,] board, int fromRow, int fromCol, int toRow, int toCol, ChessColors turn, int turnNumber)
{
if (!base.IsValidMove(board, fromRow, fromCol, toRow, toCol, turn, turnNumber))
return false;
if (Math.Abs(toRow-fromRow) > 2 || Math.Abs(toCol-fromCol) > 2 || toRow == fromRow || toCol == fromCol)
return false;
else if (Math.Abs(toRow-fromRow) == 2 && Math.Abs(toCol-fromCol) == 1)
{
if (board[toRow,toCol].ChessPiece == null)
{
return true;
}
else if(board[toRow,toCol].ChessPiece.PieceColor != turn)
{
return true;
}
else
return false;
}
else if(Math.Abs(toRow-fromRow) == 1 && Math.Abs(toCol-fromCol) == 2)
{
if (board[toRow,toCol].ChessPiece == null)
{
return true;
}
else if(board[toRow,toCol].ChessPiece.PieceColor != turn)
{
return true;
}
else
return false;
}
else
return false;
}
public override bool IsValidMove(BoardSquare[,] board, int fromRow, int fromCol, int toRow, int toCol, ChessColors turn, int turnNumber)
{
if (!base.IsValidMove(board, fromRow, fromCol, toRow, toCol, turn, turnNumber))
return false;
if (toCol == fromCol || toRow == fromRow)
return false;
if (Math.Abs(fromRow - toRow) == Math.Abs(fromCol - toCol))
{
for (int i = 1; i < Math.Abs(fromRow-toRow); i++)
{
if (fromRow> toRow && fromCol>toCol)
{
if (board[fromRow-i,fromCol-i].ChessPiece != null)
return false;
}
if (fromRow> toRow && fromCol<toCol)
{
if (board[fromRow-i,fromCol+i].ChessPiece != null)
return false;
}
if (fromRow<toRow && fromCol<toCol)
{
if (board[fromRow+i,fromCol+i].ChessPiece != null)
return false;
}
if (fromRow< toRow && fromCol>toCol)
{
if (board[fromRow+i,fromCol-i].ChessPiece != null)
return false;
}
}
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
}
else
return false;
//if absolute vaalue of (fromRow - toRow) == absolute value of (toRow - toCol) Math.Abs(----)
}
/// <summary>
/// Get a move from the AI using the minimax algorithm
/// </summary>
/// <param name="color">The color of the AI</param>
public ChessMove GetMove(GameState _, ChessColors color)
{
if (gameState.gameType == GameTypes.SkaktegoPrep)
{
return(GetPrepMove());
}
bool maximizingPlayer = color == ChessColors.White;
MiniMax(gameState, SearchDepth, double.NegativeInfinity, double.PositiveInfinity, maximizingPlayer);
if (!bestMove.HasValue)
{
throw new InvalidOperationException("No best move found");
}
return(bestMove.Value);
}
/// <summary>
/// Update and draw the UI
/// </summary>
public void Update()
{
PollEvents();
// When the player switches, hide the screen
if (gameState != null &&
gameState.player != lastPlayer &&
gameState.gameType != GameTypes.Normal &&
!aiPlaying
)
{
screenHidden = true;
lastPlayer = gameState.player;
}
// Update screen rect
screenRect = renderer.OutputRect();
//Reset if the user has already pressed a button this frame
pressedSomething = false;
// Check if the user wants to quit.
if (events.Any(e => e.type == SDL.SDL_EventType.SDL_QUIT))
{
quit = true;
}
if (isGaming)
{
if (gameState != null)
{
UpdateGame();
}
}
else
{
UpdateMainMenu();
}
}
private void btn_Click(object sender, EventArgs e)
{
if (toSq == null || fromSq == null)
{
MessageBox.Show("Must select to/from square");
}
else
{
if(fromSq.ChessPiece.IsValidMove(board, fromSq.Row, fromSq.Col, toSq.Row, toSq.Col, turn, turnNumber))
{
if(board[fromSq.Row,fromSq.Col].ChessPiece.Name == ChessPieces.King)
{
if(board[fromSq.Row,fromSq.Col].ChessPiece.PieceColor == ChessColors.Black)
{
BlackKing[0] = toSq.Row;
BlackKing[1] = toSq.Col;
}
if(board[fromSq.Row,fromSq.Col].ChessPiece.PieceColor == ChessColors.White)
{
WhiteKing[0] = toSq.Row;
WhiteKing[1] = toSq.Col;
}
}
bool enpassant = false;
ChessPiece tmp;
if (fromSq.ChessPiece.Name == ChessPieces.Pawn && toSq.ChessPiece == null && Math.Abs(toSq.Row - fromSq.Row) == Math.Abs(toSq.Col - fromSq.Col))
{
enpassant = true;
tmp = board[fromSq.Row, toSq.Col].ChessPiece;
toSq.ChessPiece = fromSq.ChessPiece;
fromSq.ChessPiece = null;
board[fromSq.Row, toSq.Col].ChessPiece = null;
}
else
{
tmp = toSq.ChessPiece;
toSq.ChessPiece = fromSq.ChessPiece;
fromSq.ChessPiece = null;
}
bool check = false;
//MessageBox.Show("Valid");
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (board[i, j].ChessPiece == null) { }
else if (board[i, j].ChessPiece.PieceColor == ChessColors.Black)
{
if (board[i, j].ChessPiece.IsValidMove(board, i, j, WhiteKing[0], WhiteKing[1], ChessColors.Black, turnNumber))
{
if(turn == ChessColors.Black)
MessageBox.Show("Puts White King in Check");
if(turn ==ChessColors.White)
{
MessageBox.Show("Invalid: Puts king in check");
check = true;
}
}
}
else if (board[i, j].ChessPiece.PieceColor == ChessColors.White)
{
if (board[i, j].ChessPiece.IsValidMove(board, i, j, BlackKing[0], BlackKing[1], ChessColors.White, turnNumber))
{
if(turn == ChessColors.White)
MessageBox.Show("Puts Black King in Check");
if(turn == ChessColors.Black)
{
MessageBox.Show("Invalid: Puts king in check");
check = true;
}
}
}
}
}
if(!check)
{
toSq.ChessPiece.LastMove = turnNumber;
turnNumber++;
if (turn == ChessColors.Black)
turn = ChessColors.White;
else
turn = ChessColors.Black;
label2.Text = turn.ToString();
label2.Refresh();
}
else
{
if (enpassant)
{
fromSq.ChessPiece = toSq.ChessPiece;
toSq.ChessPiece = null;
board[fromSq.Row, toSq.Col].ChessPiece = tmp;
enpassant = false;
}
else
{
fromSq.ChessPiece = toSq.ChessPiece;
toSq.ChessPiece = tmp;
}
if (board[fromSq.Row, fromSq.Col].ChessPiece.Name == ChessPieces.King)
{
if (board[fromSq.Row, fromSq.Col].ChessPiece.PieceColor == ChessColors.Black)
{
BlackKing[0] = fromSq.Row;
BlackKing[1] = fromSq.Col;
}
if (board[fromSq.Row, fromSq.Col].ChessPiece.PieceColor == ChessColors.White)
{
WhiteKing[0] = fromSq.Row;
WhiteKing[1] = fromSq.Col;
}
}
check = false;
}
}
else
{
MessageBox.Show("Not a Valid Move");
}
}
}
public Pawn(ChessColors color)
: base(ChessPieces.Pawn, color, color == ChessColors.Black ? Properties.Resources.Black_Pawn : Properties.Resources.White_Pawn)
{
}
public Bishop(ChessColors color)
: base(ChessPieces.Bishop, color, color == ChessColors.Black ? Properties.Resources.Black_Bishop : Properties.Resources.White_Bishop)
{
}
public King(ChessColors color)
: base(ChessPieces.King, color, color == ChessColors.Black ? Properties.Resources.Black_King : Properties.Resources.White_King)
{
}
/// <summary>
/// Convert a string to a game state
/// </summary>
/// <para>
/// The string notation is very close to FEN,
/// but modified to accomidate for skaktego rules.
/// </para>
/// <seealso cref="ToString"/>
public static GameState FromString(string stateStr)
{
string[] splitStr = stateStr.Split(' ');
var boardStr = splitStr[0];
var takenStr = splitStr[1];
var playerStr = splitStr[2];
var castlingStr = splitStr[3];
var enPassantStr = splitStr[4];
var halfmoveStr = splitStr[5];
var fullmoveStr = splitStr[6];
var gameTypeStr = splitStr[7];
// Construct all of the elements of the game state from the
// string parts.
Board board = Board.FromString(boardStr);
List <Piece> taken = new List <Piece>();
if (takenStr != "-")
{
foreach (char pieceChar in takenStr)
{
Piece piece = Piece.FromChar(pieceChar);
taken.Add(piece);
}
}
ChessColors player = ChessColorsMethods.FromChar(playerStr[0]);
CastlingInfo castling = CastlingInfo.FromString(castlingStr);
Nullable <BoardPosition> enPassant = null;
if (enPassantStr != "-")
{
enPassant = BoardPosition.FromString(enPassantStr);
}
int halfmoveClock = int.Parse(halfmoveStr);
int fullmoveClock = int.Parse(fullmoveStr);
GameTypes gameType;
switch (gameTypeStr)
{
case "s":
gameType = GameTypes.Normal;
break;
case "st":
gameType = GameTypes.Skaktego;
break;
case "stp":
gameType = GameTypes.SkaktegoPrep;
break;
default:
throw new ArgumentException("'" + gameTypeStr + "' is not a valid string");
}
return(new GameState(board, taken, player,
castling, enPassant, halfmoveClock,
fullmoveClock, gameType));
}
public void TestGetPositionsInTheWayOfMoveMethod(
char initialHorizontal,
int initialVertical,
char targetHorizontal,
int targetVertical,
ChessColors pawnColor,
object[] positionsInTheWayOfMove)
{
List <Tuple <char, int> > positions = new List <Tuple <char, int> >();
if (positionsInTheWayOfMove != null)
{
for (int i = 0; i < positionsInTheWayOfMove.Length; i++)
{
if (i % 2 == 0)
{
positions.Add(new Tuple <char, int>((char)positionsInTheWayOfMove[i], (int)positionsInTheWayOfMove[i + 1]));
}
}
}
var getPositionsInTheWayOfMoveMethod = this.PawnType.GetMethod("GetPositionsInTheWayOfMove");
var normalChessMoveType = ChessGameLogicProvider.GetType("ChessGameLogic.ChessMoves.NormalChessMovePositions");
var chessBoardPositionType = ChessGameLogicProvider.GetType("ChessGameLogic.ChessBoardPosition");
var move = normalChessMoveType.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0]
.Invoke(new object[]
{
initialHorizontal,
initialVertical,
targetHorizontal,
targetVertical,
});
ICollection actualPositionsInTheWayOfMove = null;
if (pawnColor == ChessColors.White)
{
actualPositionsInTheWayOfMove = (ICollection)getPositionsInTheWayOfMoveMethod.Invoke(this.WhitePawnInstance, new object[] { move });
}
else
{
actualPositionsInTheWayOfMove = (ICollection)getPositionsInTheWayOfMoveMethod.Invoke(this.BlackPawnInstance, new object[] { move });
}
if (positionsInTheWayOfMove == null)
{
Assert.IsNull(actualPositionsInTheWayOfMove);
}
else
{
Assert.AreEqual(positions.Count, actualPositionsInTheWayOfMove.Count);
foreach (var postition in positions)
{
bool actualPositionsContainCurrentExpectedPosition = false;
foreach (var actualPosition in actualPositionsInTheWayOfMove)
{
var actualHorizontal = (char)chessBoardPositionType
.GetProperty("Horizontal", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(actualPosition);
var actualVertical = (int)chessBoardPositionType
.GetProperty("Vertical", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(actualPosition);
if (actualHorizontal == postition.Item1 && actualVertical == postition.Item2)
{
actualPositionsContainCurrentExpectedPosition = true;
break;
}
}
Assert.That(actualPositionsContainCurrentExpectedPosition);
}
}
}
protected Figure(ChessColors color)
{
this.Color = color;
}
/// <summary>
/// Create a new piece given a color and type
/// </summary>
/// <param name="color">The color the piece belongs to.</param>
/// <param name="type">The type of the piece.</param>
public Piece(ChessColors color, PieceTypes type, bool hasMoved = true)
{
Color = color;
Type = type;
this.hasMoved = hasMoved;
}
public override bool IsValidMove(BoardSquare[,] board, int fromRow, int fromCol, int toRow, int toCol, ChessColors turn, int turnNumber)
{
if (!base.IsValidMove(board, fromRow, fromCol, toRow, toCol, turn, turnNumber))
return false;
if (fromRow != toRow && fromCol != toCol)
return false;
//horiz or vert?
if (fromRow == toRow )
{
if (Math.Abs(fromCol - toCol) == 1)
{
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
}
for (int i = 1; i <= Math.Abs(toCol - fromCol) - 1; i++)
{
if (fromCol > toCol)
{
if (board[fromRow, fromCol - i].ChessPiece != null)
return false;
}
if (fromCol < toCol)
{
if (board[fromRow, fromCol+i].ChessPiece != null)
return false;
}
}
}
if (fromCol == toCol)
{
if (Math.Abs(fromRow - toRow) == 1)
{
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
}
for (int i = 1; i <= Math.Abs(toRow - fromRow) - 1; i++)
{
if (fromRow > toRow)
{
if (board[fromRow-i, fromCol].ChessPiece != null)
return false;
}
if (fromCol < toCol)
{
if (board[fromRow+i, fromCol].ChessPiece != null)
return false;
}
}
}
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
//to Empty or OppColor
//Math.Sign(----) +1, -1, 0
//Castling
//check?
//1. Make move
//2. Ask each opposing piece if it can move to king location
//3. if all no --> commit , else --> undo
}
public Rook(ChessColors color)
: base(ChessPieces.Rook, color, color == ChessColors.Black ? Properties.Resources.Black_Rook : Properties.Resources.White_Rook)
{
}
public Queen(ChessColors color)
: base(ChessPieces.Queen, color, color == ChessColors.Black ? Properties.Resources.Black_Queen : Properties.Resources.White_Queen)
{
}
public override bool IsValidMove(BoardSquare[,] board, int fromRow, int fromCol, int toRow, int toCol, ChessColors turn, int turnNumber)
{
if (!base.IsValidMove(board, fromRow, fromCol, toRow, toCol, turn, turnNumber))
return false;
if (fromRow != toRow && fromCol != toCol && Math.Abs(fromRow - toRow) != Math.Abs(fromCol - toCol))
return false;
if (fromRow == toRow)
{
if (Math.Abs(fromCol - toCol) == 1)
{
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
}
for (int i = 1; i <= Math.Abs(toCol - fromCol) - 1; i++)
{
if (fromCol > toCol)
{
if (board[fromRow, fromCol - i].ChessPiece != null)
return false;
}
if (fromCol < toCol)
{
if (board[fromRow, fromCol + i].ChessPiece != null)
return false;
}
}
}
if (fromCol == toCol)
{
if (Math.Abs(fromRow - toRow) == 1)
{
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
}
for (int i = 1; i <= Math.Abs(toRow - fromRow) - 1; i++)
{
if (fromRow > toRow)
{
if (board[fromRow - i, fromCol].ChessPiece != null)
return false;
}
if (fromRow < toRow)
{
if (board[fromRow + i, fromCol].ChessPiece != null)
return false;
}
}
}
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
if (Math.Abs(fromRow - toRow) == Math.Abs(fromCol - toCol))
{
for (int i = 1; i < Math.Abs(fromRow - toRow); i++)
{
if (fromRow > toRow && fromCol > toCol)
{
if (board[fromRow - i, fromCol - i].ChessPiece != null)
return false;
}
if (fromRow > toRow && fromCol < toCol)
{
if (board[fromRow - i, fromCol + i].ChessPiece != null)
return false;
}
if (fromRow < toRow && fromCol < toCol)
{
if (board[fromRow + i, fromCol + i].ChessPiece != null)
return false;
}
if (fromRow < toRow && fromCol > toCol)
{
if (board[fromRow + i, fromCol - i].ChessPiece != null)
return false;
}
}
if (board[toRow, toCol].ChessPiece == null)
return true;
else if (board[toRow, toCol].ChessPiece.PieceColor != turn)
return true;
else
return false;
}
else
return false;
}
public Knight(ChessColors color)
: base(ChessPieces.Knight, color, color == ChessColors.Black ? Properties.Resources.Black_Knight : Properties.Resources.White_Knight)
{
}
internal Bishop(ChessColors color)
: base(color)
{
}
