private Match(
Pieces pieces,
IReadOnlyCollection <User> players,
IReadOnlyCollection <User> spectators)
{
this.Pieces = pieces;
this.Players = players;
this.Spectators = spectators;
}
public void PerformChessMove(Position source, Position target)
{
Piece capturedPiece = PerformMove(source, target);
if (IsACheck(CurrentPlayer))
{
UndoMove(source, target, capturedPiece);
throw new BoardException("You can't put yourself in Check!");
}
Piece p = Board.Piece(target);
// #Special move - En Passant
if (p is Pawn)
{
if ((p.Color == Color.White && target.Row == 0) || (p.Color == Color.Black && target.Row == 7))
{
p = Board.RemovePiece(target);
Pieces.Remove(p);
Piece queen = new Queen(Board, p.Color);
Board.PlacePiece(queen, target);
Pieces.Add(queen);
}
}
if (IsACheck(OpponentPlayer(CurrentPlayer)))
{
Check = true;
}
else
{
Check = false;
}
if (IsACheckMate(OpponentPlayer(CurrentPlayer)))
{
GameOver = true;
}
else
{
Turn++;
ChangePlayer();
}
// #Special move - En Passant
if (p is Pawn && (target.Row == source.Row - 2 || target.Row == source.Row + 2))
{
EnPassantVulnerable = p;
}
else
{
EnPassantVulnerable = null;
}
}
public void makeMoviment(Position origin, Position destiny)
{
Pieces p = board.removePiece(origin);
p.raiseMoviment();
Pieces capturedPieces = board.removePiece(destiny);
board.putPiece(p, destiny);
if (capturedPieces != null)
{
captured.Add(capturedPieces);
}
}
/// <summary> /// Given a team, this method returns that team's king. /// </summary> /// <param name="t">The team to get its king.</param> /// <returns></returns> /// <exception cref="InvalidOperationException">Thrown when there is no <paramref name="t"/>-team king on the board.</exception> public King GetKing(Team t) => Pieces.First(p => p is King && p.Team == t) as King;
private bool canMove(Position pos)
{
Pieces p = Board.piece(pos);
return(p == null || p.Color != Color);
}
public void Initialize()
{
//Initialize all squares
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
Square square = new Square();
square.File = (File)(i);
square.Rank = j;
BoardCoordinates.Add(square);
}
}
//Initialize all pieces
int whiteMajorPieceRank = 1;
int whitePawnRank = 2;
int blackPawnRank = 7;
int blackMajorPieceRank = 8;
File queenRookFile = File.A;
File queenKnightFile = File.B;
File queenBishopFile = File.C;
File queenFile = File.D;
File kingFile = File.E;
File kingBishopFile = File.F;
File kingKnightFile = File.G;
File kingRookFile = File.H;
#region Pawns
for (int i = 0; i < 16; i++)
{
Pawn pawn = new Pawn();
pawn.PieceColor = i < 8 ? PieceColor.White : PieceColor.Black;
pawn.Coordinates.Rank = i < 8 ? whitePawnRank : blackPawnRank;
pawn.Coordinates.File = (File)(i % 8);
pawn.IsOnBoard = true;
Pieces.Add(pawn);
}
#endregion
#region Rooks
Rook whiteKingRook = new Rook();
whiteKingRook.Coordinates.Rank = whiteMajorPieceRank;
whiteKingRook.Coordinates.File = kingRookFile;
whiteKingRook.IsOnBoard = true;
whiteKingRook.PieceColor = PieceColor.White;
Pieces.Add(whiteKingRook);
Rook whiteQueenRook = new Rook();
whiteQueenRook.Coordinates.Rank = whiteMajorPieceRank;
whiteQueenRook.Coordinates.File = queenRookFile;
whiteQueenRook.IsOnBoard = true;
whiteQueenRook.PieceColor = PieceColor.White;
Pieces.Add(whiteQueenRook);
Rook blackKingRook = new Rook();
blackKingRook.Coordinates.Rank = blackMajorPieceRank;
blackKingRook.Coordinates.File = kingRookFile;
blackKingRook.IsOnBoard = true;
blackKingRook.PieceColor = PieceColor.Black;
Pieces.Add(blackKingRook);
Rook blackQueenRook = new Rook();
blackQueenRook.Coordinates.File = queenRookFile;
blackQueenRook.Coordinates.Rank = blackMajorPieceRank;
blackQueenRook.IsOnBoard = true;
blackQueenRook.PieceColor = PieceColor.Black;
Pieces.Add(blackQueenRook);
#endregion
#region Knights
Knight whiteQueenKnight = new Knight();
whiteQueenKnight.Coordinates.File = queenKnightFile;
whiteQueenKnight.Coordinates.Rank = whiteMajorPieceRank;
whiteQueenKnight.IsOnBoard = true;
whiteQueenKnight.PieceColor = PieceColor.White;
Pieces.Add(whiteQueenKnight);
Knight whiteKingKnight = new Knight();
whiteKingKnight.Coordinates.File = kingKnightFile;
whiteKingKnight.Coordinates.Rank = whiteMajorPieceRank;
whiteKingKnight.IsOnBoard = true;
whiteKingKnight.PieceColor = PieceColor.White;
Pieces.Add(whiteKingKnight);
Knight blackQueenKnight = new Knight();
blackQueenKnight.Coordinates.File = queenKnightFile;
blackQueenKnight.Coordinates.Rank = blackMajorPieceRank;
blackQueenKnight.IsOnBoard = true;
blackQueenKnight.PieceColor = PieceColor.Black;
Pieces.Add(blackQueenKnight);
Knight blackKingKnight = new Knight();
blackKingKnight.Coordinates.File = kingKnightFile;
blackKingKnight.Coordinates.Rank = blackMajorPieceRank;
blackQueenKnight.IsOnBoard = true;
blackQueenKnight.PieceColor = PieceColor.Black;
Pieces.Add(blackKingKnight);
#endregion
#region Bishop
Bishop whiteKingBishop = new Bishop();
whiteKingBishop.Coordinates.Rank = whiteMajorPieceRank;
whiteKingBishop.Coordinates.File = kingBishopFile;
whiteKingBishop.IsOnBoard = true;
whiteKingBishop.PieceColor = PieceColor.White;
Pieces.Add(whiteKingBishop);
Bishop whiteQueenBishop = new Bishop();
whiteQueenBishop.Coordinates.Rank = whiteMajorPieceRank;
whiteQueenBishop.Coordinates.File = queenBishopFile;
whiteQueenBishop.IsOnBoard = true;
whiteQueenBishop.PieceColor = PieceColor.White;
Pieces.Add(whiteQueenBishop);
Bishop blackKingBishop = new Bishop();
blackKingBishop.Coordinates.Rank = blackMajorPieceRank;
blackKingBishop.Coordinates.File = kingBishopFile;
blackKingBishop.IsOnBoard = true;
blackKingBishop.PieceColor = PieceColor.Black;
Pieces.Add(blackKingBishop);
Bishop blackQueenBishop = new Bishop();
blackQueenBishop.Coordinates.Rank = blackMajorPieceRank;
blackQueenBishop.Coordinates.File = queenBishopFile;
blackQueenBishop.IsOnBoard = true;
blackQueenBishop.PieceColor = PieceColor.Black;
Pieces.Add(blackQueenBishop);
#endregion
#region Queens
Queen whiteQueen = new Queen();
whiteQueen.Coordinates.Rank = whiteMajorPieceRank;
whiteQueen.Coordinates.File = queenFile;
whiteQueen.IsOnBoard = true;
whiteQueen.PieceColor = PieceColor.White;
Pieces.Add(whiteQueen);
Queen blackQueen = new Queen();
blackQueen.Coordinates.Rank = blackMajorPieceRank;
blackQueen.Coordinates.File = queenFile;
blackQueen.IsOnBoard = true;
blackQueen.PieceColor = PieceColor.Black;
Pieces.Add(blackQueen);
#endregion
#region Kings
King whiteKing = new King();
whiteKing.Coordinates.Rank = whiteMajorPieceRank;
whiteKing.Coordinates.File = kingFile;
whiteKing.IsOnBoard = true;
whiteKing.PieceColor = PieceColor.White;
Pieces.Add(whiteKing);
King blackKing = new King();
blackKing.Coordinates.File = kingFile;
blackKing.Coordinates.Rank = blackMajorPieceRank;
blackKing.IsOnBoard = true;
blackKing.PieceColor = PieceColor.Black;
Pieces.Add(blackKing);
#endregion
}
public void putNewPiece(char column, int row, Pieces piece)
{
board.putPiece(piece, new ChessPosition(column, row).toPosition());
pieces.Add(piece);
}
public static Match CreateMatch(
Pieces pieces,
IReadOnlyCollection <User> players,
IReadOnlyCollection <User> spectators) => new Match(pieces, players, spectators);
static void Main(string[] args)
{
RenderBoard renderboard = new RenderBoard(board);
UserInput userinput = new UserInput();
Pieces pieces = new Pieces();
bool whoseTurn = true; //white - true, black - false
Transform transform = new Transform();
PossbileMoves possiblemoves = new PossbileMoves();
Moves moves = new Moves();
string attackedTiles = "AA";
string movesInt = "";
//renderboard.CostumBoard(board);
while (true) // to be changed to IsGameOver method
{
attackedTiles = "AA";
int posToWhichMove, posOfPiece;
ChessBoard piece;
//renderboard.CostumBoard(board); //DEBUG
renderboard.Render(board);
Coms.RenderComs(1);
posOfPiece = userinput.GetInput();
if (!pieces.IsPlayerPiece(board[posOfPiece / 10, posOfPiece % 10], whoseTurn))
{
Coms.RenderComs(6);
continue;
}
Coms.RenderComs(3);
posToWhichMove = userinput.GetInput(); // get input to where should the piece be moved
movesInt = ListMoves.RememberAsInt(posToWhichMove / 10, posToWhichMove % 10, movesInt);
if (moves.Controller(board, posToWhichMove / 10, posToWhichMove % 10, posOfPiece / 10, posOfPiece % 10, whoseTurn, movesInt).IndexOf(posToWhichMove.ToString()) != -1)
{
ChessBoard[,] copyOfBoard = new ChessBoard[8, 8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
copyOfBoard[i, j] = board[i, j];
}
}
moves.ExecuteMove(copyOfBoard, posToWhichMove / 10, posToWhichMove % 10, posOfPiece / 10, posOfPiece % 10, whoseTurn);
if (whoseTurn)
{
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (board[i, j] < 0 && board[i, j] != 0)
{
attackedTiles = String.Concat(attackedTiles, transform.TransformFromIntToNotation((moves.ListAttackedTiles(board, i, j, !whoseTurn))));
}
}
}
}
else
{
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (board[i, j] > 0 && board[i, j] != 0)
{
attackedTiles = String.Concat(attackedTiles, transform.TransformFromIntToNotation((moves.ListAttackedTiles(board, i, j, !whoseTurn))));
}
//, Console.WriteLine(attackedTiles);
}
}
}
//Console.WriteLine(attackedTiles);
if (attackedTiles.IndexOf(possiblemoves.SearchForKing(copyOfBoard, whoseTurn)) == -1)
{
}
else
{
//write funciton that lists all moves white can move and then check if after any of those moves the check is still in place, if it is then game over!!
Coms.RenderComs(8);
continue;
}
moves.ExecuteMove(board, posToWhichMove / 10, posToWhichMove % 10, posOfPiece / 10, posOfPiece % 10, whoseTurn);
}
else
{
Coms.RenderComs(5);
continue;
}
if (whoseTurn)
{
whoseTurn = false;
}
else
{
whoseTurn = true;
}
}
}
public void PlaceNewPiece(char column, int row, Piece p)
{
Board.PlacePiece(p, new ChessPosition(column, row).ToPosition());
Pieces.Add(p);
}
/// <summary>
/// This constructor takes 2 ChessPiece objects as parameters
/// </summary>
/// <param name="first">First Piece</param>
/// <param name="second">Second Piece</param>
public PositionAnalyzer(ChessPiece first, ChessPiece second)
{
Pieces.Add(first);
Pieces.Add(second);
}
