public override bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
// ScanForPiece for Bishop checks diagonal lines for pieces //
destX -= 1;
destY -= 1;
// If moving diagonally right and down
if (destX > this.X && destY > this.Y)
{
// Iterate through the squares diagonally to find a piece.
for (int i = (this.Y + 1), j = (this.X + 1); (i <= destY || j <= destX); ++i, ++j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
}
}
// If moving left and up //
else if (destX < this.X && destY < this.Y)
{
for (int i = (this.Y - 1), j = (this.X - 1); (i >= destY || j >= destX); --i, --j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
}
}
// If moving right and up //
else if (destX > this.X && destY < this.Y)
{
for (int i = (this.Y - 1), j = (this.X + 1); (i >= destY || j <= destX); --i, ++j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
// If moving left and down //
else if (destX < this.X && destY > this.Y)
{
for (int i = (this.Y + 1), j = (this.X - 1); (i <= destY || j >= destX); ++i, --j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
return false;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
if (!ScanForPiece(gb, player, dX, dY))
{
// Check to see if the destination coords are diagonal movements //
if ((dX - (this.X + 1) == dY - (this.Y + 1) ||
(this.X + 1) - dX == dY - (this.Y + 1)))
{
return base.Move(gb, player, dX, dY);
}
else
return false;
}
else
return false;
}
public void Initialize()
{
/* INITIALIZE SETS UP PLAYER COLOURS AND PLAYER NAMES.
* INITIALIZE ALSO SETS UP THE COLOUR SCHEME AS PER USER
* REQUEST */
playerOne = new Player("white");
playerTwo = new Player("black");
Console.Write("\n\n\n\n\n\n\n\n\n\n\n\n\n\n ");
Console.Write("Select a colour theme:\n");
Console.Write(" [1] - Default\n");
Console.Write(" [2] - Christmas!\n");
Console.Write(" -> ");
int colourChoice = int.Parse(Console.ReadLine());
Console.Clear();
Console.Write("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n ");
Console.Write("Player 1 (white/red) enter a name -> ");
playerOne.GetName();
Console.Clear();
Console.Write("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n ");
Console.Write("Player 2 (black/green) enter a name -> ");
playerTwo.GetName();
switch (colourChoice)
{
case 1:
gb.Initialize("default");
break;
case 2:
gb.Initialize("christmas");
break;
default:
gb.Initialize("default");
break;
}
}
public virtual bool Move(ChessBoard gb, Player player, int dX, int dY)
{
// MOVE PROCESSES THE MOVEMENTS OF PIECES. RETURNS TRUE FOR SUCCESSFUL OPERATIONS //
// AND FALSE FOR UNSUCCESSFUL ONES //
if (dX > 0)
dX -= 1;
if (dY > 0)
dY -= 1;
// create node objects to hold the current pieces from both sets of coordinates //
Node piece = gb.NodeArray[this.Y, this.X].CurrentPiece;
Node dest = gb.NodeArray[dY, dX].CurrentPiece;
// swap the pieces //
gb.NodeArray[dY, dX].CurrentPiece = piece;
gb.NodeArray[this.Y, this.X].CurrentPiece = dest;
// set the nodes x and y position to the new values //
this.X = dX;
this.Y = dY;
return true;
}
public virtual bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
/* This base version of ScanForPiece() is the last called. It checks to see if
* the piece encountered is a piece of the other colour. If it is, it takes the
* piece. Returns true for a failed operation, and false for a successful one */
// If the current object in use is a Pawn, a separate branch of logic is needed //
if (this is Pawn)
{
// If the pawn is trying to move forward, it cannot do anything with the piece //
// ahead of it. //
if (destX == this.X)
{
if (gb.NodeArray[destY, destX].CurrentPiece is Piece)
{
// So return //
return true;
}
}
// Otherwise, if the pawn is trying to move diagonally, it can only do this //
// if it can take the piece at the destination. //
if (destX > this.X || destX < this.X)
{
if (gb.NodeArray[destY, destX].CurrentPiece is Piece)
{
// If the piece at the destination coordinates is a white piece, and the //
// player colour is green (black), allow. //
if (gb.WhitePieces.Contains<Piece>(gb.NodeArray[destY, destX].CurrentPiece as Piece)
&& player.Colour == "Green")
{
// Ensure the pawn is moving in the right direction according to piece //
// colour orientation //
if (destY < this.Y)
{
// Take the piece //
Take(gb, gb.NodeArray[destY, destX].CurrentPiece as Piece, 2);
// Replace it with a new EmptyNode
gb.NodeArray[destY, destX].CurrentPiece = new EmptyNode();
return false;
}
else
return true;
}
// If the piece at the destination coords is a black piece and the player //
// colour is red (white), allow. //
else if (gb.BlackPieces.Contains<Piece>(gb.NodeArray[destY, destX].CurrentPiece as Piece)
&& player.Colour == "Red")
{
if (destY > this.Y)
{
Take(gb, gb.NodeArray[destY, destX].CurrentPiece as Piece, 1);
gb.NodeArray[destY, destX].CurrentPiece = new EmptyNode();
return false;
}
else
return true;
}
}
else
return true;
}
else
return false;
}
// Do the same thing but without the pawn rule check: //
if (gb.WhitePieces.Contains<Piece>(gb.NodeArray[destY, destX].CurrentPiece as Piece)
&& player.Colour == "Green")
{
Take(gb, gb.NodeArray[destY, destX].CurrentPiece as Piece, 2);
gb.NodeArray[destY, destX].CurrentPiece = new EmptyNode();
return false;
}
else if (gb.BlackPieces.Contains<Piece>(gb.NodeArray[destY, destX].CurrentPiece as Piece)
&& player.Colour == "Red")
{
Take(gb, gb.NodeArray[destY, destX].CurrentPiece as Piece, 1);
gb.NodeArray[destY, destX].CurrentPiece = new EmptyNode();
return false;
}
return true;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
// This portion of move just passes control to the base and returns true //
base.Move(gb, player, dX, dY);
return true;
}
public override bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
// Overidden version of ScanForPiece //
destX -= 1;
destY -= 1;
// If the pawn is trying to move diagonally, call the base ScanForPiece to check //
// if it is a piece that can be taken. Base ScanForPiece ultimately returns true //
// unless otherwise stated //
if (destX > this.X || destX < this.X)
{
return base.ScanForPiece(gb, player, destX, destY);
}
// If moving forward and there is a piece in the way, return the base //
// ScanForPiece, which will return true and not allow a move //
if (gb.NodeArray[destY, this.X].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
else
return false;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
// Move is overidden for the rules of the Pawn piece //
// Guard against improper move. If the pawn is trying to move diagonally //
// and there is no piece, return false //
if ((dX > (this.X + 1) || dX < (this.X + 1))
&& !(gb.NodeArray[dY - 1, dX - 1].CurrentPiece is Piece))
return false;
// If ScanForPiece returns false, no piece is in the way and moves can happen //
if (!ScanForPiece(gb, player, dX, dY))
{
// Depending on the colour of the piece being moved, different operations //
// are needed //
if (IsWhite(gb))
{
// If the pawn is on the first move, it's allowed to move 2 squares at a time. //
if (firstMove)
{
if (dY - (this.Y + 1) > 0 && dY - (this.Y + 1) <= 2)
{
firstMove = false;
return base.Move(gb, player, dX, dY);
}
else
return false;
}
else
{
// Otherwise the pawn is only allowed to move one //
if (dY - (this.Y + 1) == 1)
return base.Move(gb, player, dX, dY);
else
return false;
}
}
else
{
if (firstMove)
{
if ((this.Y + 1) - dY > 0 && (this.Y + 1) - dY <= 2)
{
firstMove = false;
return base.Move(gb, player, dX, dY);
}
else
return false;
}
else
{
if ((this.Y + 1) - dY == 1)
return base.Move(gb, player, dX, dY);
else
return false;
}
}
}
else
return false;
}
public override bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
// Override for Horse is easy. If the destination coords contains a piece //
// pass control to the base method and determine if it can be taken //
destX -= 1;
destY -= 1;
if (gb.NodeArray[destY, destX].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
else
return false;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
if (!ScanForPiece(gb, player, dX, dY))
{
// Check for valid move coordinates for horse. 2 down, one across //
if ((dY - (this.Y + 1) == 2 || (this.Y + 1) - dY == 2) &&
(dX - (this.X + 1) == 1 || (this.X + 1) - dX == 1))
{
return base.Move(gb, player, dX, dY);
}
// Check for 2 across, one down //
else if ((dX - (this.X + 1) == 2 || (this.X + 1) - dX == 2) &&
(dY - (this.Y + 1) == 1 || (this.Y + 1) - dY == 1))
{
return base.Move(gb, player, dX, dY);
}
return false;
}
else
return false;
}
public override bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
// Override for King checks destination square for a piece and passes control //
// to the base method to determine if it can be taken //
destX -= 1;
destY -= 1;
if (gb.NodeArray[destY, destX].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
else
return false;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
if (!Check(gb, dX, dY))
{
if (!ScanForPiece(gb, player, dX, dY))
{
// Check for legal moves. One square in either direction //
if ((dX - (this.X + 1) <= 1 && dX - (this.X + 1) > 0) ||
((this.X + 1) - dX <= 1 && (this.X + 1) - dX > 0))
return base.Move(gb, player, dX, dY);
else if ((dY - (this.Y + 1) <= 1 && dY - (this.Y + 1) > 0) ||
((this.Y + 1) - dY <= 1 && (this.Y + 1) - dY > 0))
return base.Move(gb, player, dX, dY);
else
return false;
}
else
return false;
}
else
return false;
}
public override bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
// Rook ScanForPiece checks all vertical and horizontal movements along the destination //
// axis' //
destX -= 1;
destY -= 1;
// If destX is the same as the current x position, the rook is moving vertically //
if (destX == this.X)
{
if ((this.Y + 1) == 8)
{
// Check vertical up
for (int i = this.Y - 1; i >= destY; --i)
{
if (gb.NodeArray[i, this.X].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
else
continue; // If a piece hasn't been found, move to next iteration //
}
}
else
{
// Check vertical down
for (int i = (this.Y + 1); i <= destY; ++i)
{
if (gb.NodeArray[i, this.X].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
else
continue;
}
}
}
else if (destY == this.Y)
{
if ((this.X + 1) == 8)
{
// Check horizontal left
for (int i = (this.X - 1); i >= destX; --i)
{
if (gb.NodeArray[this.Y, i].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
else
continue;
}
}
else
{
// Check horizontal right
for (int i = (this.X + 1); i <= destX; ++i)
{
if (gb.NodeArray[this.Y, i].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
else
continue;
}
}
}
return false;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
// If ScanForPiece returns false //
if (!ScanForPiece(gb, player, dX, dY))
{
// Allow a move //
if (dX == (this.X + 1) && dY > 0)
return base.Move(gb, player, dX, dY);
else if (dX > 0 && dY == (this.Y + 1))
return base.Move(gb, player, dX, dY);
else
return false;
}
else
return false;
}
public override bool ScanForPiece(ChessBoard gb, Player player, int destX, int destY)
{
destX -= 1;
destY -= 1;
// If moving vertically //
if (destX == (this.X))
{
// If moving down //
if (destY > this.Y)
{
// Check squares along path //
for (int i = (this.Y + 1); i <= destY; ++i)
{
if (gb.NodeArray[i, this.X].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
// If moving up //
else if (destY < (this.Y))
{
for (int i = (this.Y - 1); i >= destY; --i)
{
if (gb.NodeArray[i, this.X].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
}
// If moving horizontally //
else if (destY == this.Y)
{
// If moving right //
if (destX > this.X)
{
// Check squares along path //
for (int i = (this.X + 1); i <= destX; ++i)
{
if (gb.NodeArray[this.Y, i].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
// If moving left //
else if (destX < this.X)
{
for (int i = (this.X - 1); i >= destX; --i)
{
if (gb.NodeArray[this.Y, i].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
}
// If moving right and down //
else if (destX > this.X && destY > this.Y)
{
for (int i = (this.Y + 1), j = (this.X + 1); (i <= destY || j <= destX); ++i, ++j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
}
}
// If moving left and up //
else if (destX < this.X && destY < this.Y)
{
for (int i = (this.Y - 1), j = (this.X - 1); (i >= destY || j >= destX); --i, --j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece ||
gb.NodeArray[destY, destX].CurrentPiece is Piece)
{
return base.ScanForPiece(gb, player, destX, destY);
}
}
}
// If moving right and up //
else if (destX > this.X && destY < this.Y)
{
for (int i = (this.Y - 1), j = (this.X + 1); (i >= destY || j <= destX); --i, ++j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
// If moving left and down //
else if (destX < this.X && destY > this.Y)
{
for (int i = (this.Y + 1), j = (this.X - 1); (i <= destY || j >= destX); ++i, --j)
{
if (gb.NodeArray[i, j].CurrentPiece is Piece)
return base.ScanForPiece(gb, player, destX, destY);
}
}
return false;
}
public override bool Move(ChessBoard gb, Player player, int dX, int dY)
{
if (!ScanForPiece(gb, player, dX, dY))
{
// Queen can move freely throughout the board unless obstructed by a peice //
// Check for valid moves //
if ((dX - (this.X + 1) == dY - (this.Y + 1)) ||
((this.X + 1) - dX == (this.Y + 1) - dY))
return base.Move(gb, player, dX, dY);
else if ((dX - (this.X + 1) > 0 || dY - (this.Y + 1) > 0) ||
((this.X + 1) - dX > 0 || (this.Y + 1) - dY > 0))
return base.Move(gb, player, dX, dY);
else
return false;
}
else
return false;
}