// If piece is king, check if it moves to a castle part of the victory condition.
public bool CheckKingMoveVic(GameData.ITile tile)
{
if (tile.VictoryCond == true && tile.Piece.VictoryCond == true)
{
return(true);
}
return(false);
}
// Remove enemy pieces.
public void RemovePieces(int column, int row, GameRules.IRules rules)
{
// Check if there are pieces to be removed until there are no more to remove.
GameData.ITile tile = rules.CheckRemoval(BoardGrid[column, row], PlayerTurn);
while (tile != null)
{
// Check if the removed piece is the king.
if (tile.Piece is GameData.King)
{
EndGame();
break;
}
tile.Piece = null;
tile = rules.CheckRemoval(BoardGrid[column, row], PlayerTurn);
}
}
// Check if the piece left of the moved piece can be removed.
private bool CheckLeft(GameData.ITile tile, int player)
{
// Check if there is a piece.
if (BoardGrid[tile.Column - 1, tile.Row].Piece != null)
{
// Check if piece belongs to enemy.
if (BoardGrid[tile.Column - 1, tile.Row].Piece.Player != player)
{
// Check if there's another piece or a castle.
if (BoardGrid[tile.Column - 2, tile.Row].Piece != null ||
BoardGrid[tile.Column - 2, tile.Row] is GameData.Castle)
{
// Check if next piece belongs to you or if there is a castle.
// Castle is checked first since player can't be refered to if it's a castle.
if (BoardGrid[tile.Column - 2, tile.Row] is GameData.Castle ||
BoardGrid[tile.Column - 2, tile.Row].Piece.Player == player)
{
return(true);
}
}
}
}
return(false);
}
// Check if piece can be moved to the selected tile.
// Soldiers can't access castles, but can cross them.
// Soldiers can't move over other pieces or access tiles with another piece.
// King can move over and access castles.
// King can't move over other pieces or access tiles with another piece.
// Pieces can't move diagonally.
public bool CheckMove(GameData.ITile fromTile, GameData.ITile toTile)
{
// Boolean set to true if piece can cross tiles and pieces.
bool canReachDest = false;
// Check if piece can move though all tiles to reach destination tile.
// MOVE VERTICALLLY
if (fromTile.Column == toTile.Column)
{
// If the fromTile row is smaller than the toTile row, increase tmp in loop. Move down.
if (fromTile.Row < toTile.Row)
{
// Iterate the tiles from the destination to the piece that is to be moved.
// Don't start with the selected piece's tile.
for (int tmp = fromTile.Row + 1; tmp < toTile.Row; tmp++)
{
// Check if piece can cross tile.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[fromTile.Column, tmp].AccessType))
{
return(false);
}
// Check if there's piece on the tile.
if (BoardGrid[fromTile.Column, tmp].Piece != null)
{
// Check if piece on fromTile can cross the tile's piece.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[fromTile.Column, tmp].Piece.AccessType))
{
return(false);
}
}
}
}
// Else decrease tmp in loop. Move up.
else
{
// Iterate the tiles from the destination to the piece that is to be moved.
for (int tmp = fromTile.Row - 1; tmp > toTile.Row; tmp--)
{
// Check if piece can cross tile.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[fromTile.Column, tmp].AccessType))
{
return(false);
}
// Check if there's piece on the tile.
if (BoardGrid[fromTile.Column, tmp].Piece != null)
{
// Check if piece on fromTile can cross the tile's piece.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[fromTile.Column, tmp].Piece.AccessType))
{
return(false);
}
}
}
}
canReachDest = true;
}
// MOVE HORIZONTALLY
else if (fromTile.Row == toTile.Row)
{
// If the fromTile column is smaller than the toTile column, increase tmp in loop. Move right.
if (fromTile.Column < toTile.Column)
{
// Iterate the tiles from the destination to the piece that is to be moved.
for (int tmp = fromTile.Column + 1; tmp < toTile.Column; tmp++)
{
// Check if piece can cross tile.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[tmp, fromTile.Row].AccessType))
{
return(false);
}
// Check if there's piece on the tile.
if (BoardGrid[tmp, fromTile.Row].Piece != null)
{
// Check if piece on fromTile can cross the tile's piece.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[tmp, fromTile.Row].Piece.AccessType))
{
return(false);
}
}
}
}
// Else decrease tmp in loop. Move left.
else
{
// Iterate the tiles from the destination to the piece that is to be moved.
for (int tmp = fromTile.Column - 1; tmp > toTile.Column; tmp--)
{
// Check if piece can cross tile.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[tmp, fromTile.Row].AccessType))
{
return(false);
}
// Check if there's piece on the tile.
if (BoardGrid[tmp, fromTile.Row].Piece != null)
{
// Check if piece on fromTile can cross the tile's piece.
if (!fromTile.Piece.CrossableTypes.Contains(BoardGrid[tmp, fromTile.Row].Piece.AccessType))
{
return(false);
}
}
}
}
canReachDest = true;
}
// CHECK IF PIECE CAN BE PLACED ON DESTIONATION TILE
// If the piece can cross to until destination has been reached, check if it can be placed.
if (canReachDest == true)
{
bool check1 = false, check2 = false;
// Check if tile can be accessed.
check1 = fromTile.Piece.AccessibleTypes.Contains(BoardGrid[toTile.Column, toTile.Row].AccessType);
check2 = true;
// Check if there is already a piece on the tile.
if (BoardGrid[toTile.Column, toTile.Row].Piece != null)
{
// Check if piece allows access.
check2 = fromTile.Piece.AccessibleTypes.Contains(BoardGrid[toTile.Column, toTile.Row].Piece.AccessType);
}
if (check1 == true && check2 == true)
{
return(true);
}
}
return(false);
}
// Check if any of opponent's pieces can be removed.
// A piece is removed if it's between two unfriendly pieces
// or between an unfriendly piece and a castle.
// Output is the tile with the piece that should be removed.
// This method is repeated until no more tiles are returned.
public GameData.ITile CheckRemoval(GameData.ITile tile, int player)
{
// Number of tiles in a column or row. From 0 to 8, that is 9.
int max = 8;
// There are 4 corners, 4 sides and the grid.
// Upper-left corner.
if (tile.Column <= 1 && tile.Row <= 1)
{
// Check piece below.
if (CheckBeneath(tile, player))
{
return(BoardGrid[tile.Column, tile.Row + 1]);
}
// Check right of piece.
if (CheckRight(tile, player))
{
return(BoardGrid[tile.Column + 1, tile.Row]);
}
}
// Lower-left corner.
else if (tile.Column <= 1 && tile.Row >= max - 1)
{
// Check above the piece.
if (CheckOver(tile, player))
{
return(BoardGrid[tile.Column, tile.Row - 1]);
}
// Check right of piece.
if (CheckRight(tile, player))
{
return(BoardGrid[tile.Column + 1, tile.Row]);
}
}
// Upper-right corner.
else if (tile.Column >= max - 1 && tile.Row <= 1)
{
// Check piece below.
if (CheckBeneath(tile, player))
{
return(BoardGrid[tile.Column, tile.Row + 1]);
}
// Check left of piece.
if (CheckLeft(tile, player))
{
return(BoardGrid[tile.Column - 1, tile.Row]);
}
}
// Lower-right corner.
else if (tile.Column >= max - 1 && tile.Row >= max - 1)
{
// Check piece above.
if (CheckOver(tile, player))
{
return(BoardGrid[tile.Column, tile.Row - 1]);
}
// Check left of piece.
if (CheckLeft(tile, player))
{
return(BoardGrid[tile.Column - 1, tile.Row]);
}
}
// Left side.
else if (tile.Column <= 1)
{
// Check piece above.
if (CheckOver(tile, player))
{
return(BoardGrid[tile.Column, tile.Row - 1]);
}
// Check piece below.
if (CheckBeneath(tile, player))
{
return(BoardGrid[tile.Column, tile.Row + 1]);
}
// Check right of piece.
if (CheckRight(tile, player))
{
return(BoardGrid[tile.Column + 1, tile.Row]);
}
}
// Right side.
else if (tile.Column >= max - 1)
{
// Check piece above.
if (CheckOver(tile, player))
{
return(BoardGrid[tile.Column, tile.Row - 1]);
}
// Check piece below.
if (CheckBeneath(tile, player))
{
return(BoardGrid[tile.Column, tile.Row + 1]);
}
// Check left of piece.
if (CheckLeft(tile, player))
{
return(BoardGrid[tile.Column - 1, tile.Row]);
}
}
// Upper side.
else if (tile.Row <= 1)
{
// Check piece below.
if (CheckBeneath(tile, player))
{
return(BoardGrid[tile.Column, tile.Row + 1]);
}
// Check right of piece.
if (CheckRight(tile, player))
{
return(BoardGrid[tile.Column + 1, tile.Row]);
}
// Check left of piece.
if (CheckLeft(tile, player))
{
return(BoardGrid[tile.Column - 1, tile.Row]);
}
}
// Lower side.
else if (tile.Row >= max - 1)
{
// Check piece above.
if (CheckOver(tile, player))
{
return(BoardGrid[tile.Column, tile.Row - 1]);
}
// Check right of piece.
if (CheckRight(tile, player))
{
return(BoardGrid[tile.Column + 1, tile.Row]);
}
// Check left of piece.
if (CheckLeft(tile, player))
{
return(BoardGrid[tile.Column - 1, tile.Row]);
}
}
// Check every direction around the piece.
else
{
// Check piece above.
if (CheckOver(tile, player))
{
return(BoardGrid[tile.Column, tile.Row - 1]);
}
// Check piece below.
if (CheckBeneath(tile, player))
{
return(BoardGrid[tile.Column, tile.Row + 1]);
}
// Check right of piece.
if (CheckRight(tile, player))
{
return(BoardGrid[tile.Column + 1, tile.Row]);
}
// Check left of piece.
if (CheckLeft(tile, player))
{
return(BoardGrid[tile.Column - 1, tile.Row]);
}
}
return(null);
}
