/// <summary>
/// Crea una pieza
/// </summary>
private PieceBaseModel CreatePiece(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color)
{
switch (type)
{
case PieceBaseModel.PieceType.Pawn:
return(new PawnModel(color));
case PieceBaseModel.PieceType.Rook:
return(new RookModel(color));
case PieceBaseModel.PieceType.Knight:
return(new KnightModel(color));
case PieceBaseModel.PieceType.Bishop:
return(new BishopModel(color));
case PieceBaseModel.PieceType.Queen:
return(new QueenModel(color));
case PieceBaseModel.PieceType.King:
return(new KingModel(color));
default:
throw new ArgumentException($"Piece type unknown: {type}");
}
}
/// <summary>
/// Crea un promoción
/// </summary>
private void CreatePromoteAction(PieceBaseModel.PieceType?piece, PieceBaseModel.PieceColor color, CellModel to)
{
if (piece != null)
{
Add(new ActionPromoteModel(piece ?? PieceBaseModel.PieceType.Unknown, color, to));
}
}
/// <summary>
/// Añade una pieza
/// </summary>
public void Add(PieceBaseModel.PieceType piece, PieceBaseModel.PieceColor color, CellModel cell)
{
switch (piece)
{
case PieceBaseModel.PieceType.Pawn:
Add(new PawnModel(color, cell));
break;
case PieceBaseModel.PieceType.Rook:
Add(new RookModel(color, cell));
break;
case PieceBaseModel.PieceType.Knight:
Add(new KnightModel(color, cell));
break;
case PieceBaseModel.PieceType.Bishop:
Add(new BishopModel(color, cell));
break;
case PieceBaseModel.PieceType.Queen:
Add(new QueenModel(color, cell));
break;
case PieceBaseModel.PieceType.King:
Add(new KingModel(color, cell));
break;
}
}
public ActionMoveModel(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color,
int fromRow, int fromColumn, int toRow, int toColumn) : base(type, color)
{
FromRow = fromRow;
FromColumn = fromColumn;
ToRow = toRow;
ToColumn = toColumn;
}
public Figure(int row, int column, PieceBaseModel.PieceColor color, PieceBaseModel.PieceType?type, Image image, Label label)
{
Row = row;
Column = column;
Color = color;
Type = type;
Image = image;
Label = label;
}
/// <summary>
/// Crea una variación
/// </summary>
private VariationModel CreateVariation(PieceBaseModel.PieceColor actualColor, PieceBaseModelCollection previousPieces, RAVEntry rav)
{
VariationModel variation = new VariationModel();
// Asigna las piezas
variation.Setup = CreateBoardSetup(actualColor, previousPieces);
// Interpreta la lista de movimiento
variation.Movements.AddRange(ParseMovements(variation, rav.MoveText));
// Devuelve la variación
return(variation);
}
public CellViewModel(int row, int column, PieceBaseModel.PieceColor color) : base(row, column, color)
{
if (color == PieceBaseModel.PieceColor.White)
{
FileImage = "BoardLight.gif";
}
else
{
FileImage = "BoardDark.gif";
}
}
/// <summary>
/// Inhabilita el enroque corto
/// </summary>
internal void DisableCastleKingSide(PieceBaseModel.PieceColor color)
{
if (color == PieceBaseModel.PieceColor.White)
{
CanWhiteCastleKingSide = false;
}
else
{
CanBlackCastleKingSide = false;
}
}
/// <summary>
/// Comprueba si se puede hacer un enroque corto
/// </summary>
internal bool CanMoveCastleKingSide(PieceBaseModel.PieceColor color)
{
if (color == PieceBaseModel.PieceColor.White)
{
return(CanWhiteCastleKingSide);
}
else
{
return(CanBlackCastleKingSide);
}
}
/// <summary>
/// Deshace el movimiento de enroque largo
/// </summary>
private void UndoCastleQueenSide(PieceBaseModel.PieceColor color)
{
int row = GetRowKing(color);
// Mueve el rey
MoveWithoutCheck(row, 2, row, 4, false);
// Mueve la torre
MoveWithoutCheck(row, 3, row, 0, false);
// Habilita los enroques (los dos)
Parameters.EnableCastle(color);
//TODO --> Debería indicar que no se ha movido la torre ni el rey
}
/// <summary>
/// Habilita los enroques
/// </summary>
internal void EnableCastle(PieceBaseModel.PieceColor color)
{
if (color == PieceBaseModel.PieceColor.White)
{
CanWhiteCastleKingSide = true;
CanWhiteCastleQueenSide = true;
}
else
{
CanBlackCastleKingSide = true;
CanBlackCastleQueenSide = true;
}
}
/// <summary>
/// Busca una pieza
/// </summary>
private Figure SearchPiece(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color, CellModel cell)
{
// Busca la pieza
foreach (Figure figure in Cells)
{
if (figure.Type == type && figure.Color == color && figure.Row == cell.Row && figure.Column == cell.Column)
{
return(figure);
}
}
// Devuelve una pieza vacía
return(new Figure(-1, -1, color, null, null, null));
}
/// <summary>
/// Obtiene la pieza de un color que está en una fila / columna
/// </summary>
private PieceBaseModel GetPiece(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color, CellModel cell)
{
// Busca la pieza
foreach (PieceBaseModel piece in Pieces)
{
if (piece.Type == type && piece.Color == color && piece.Cell.Row == cell.Row && piece.Cell.Column == cell.Column)
{
return(piece);
}
}
// Si ha llegado hasta aquí es porque no ha encontrado nada
return(null);
}
/// <summary>
/// Crea la configuración del tablero
/// </summary>
private Board.BoardSetup CreateBoardSetup(PieceBaseModel.PieceColor actualColor, PieceBaseModelCollection previousPieces)
{
Board.BoardSetup setup = new Board.BoardSetup();
// Indica si es un movimiento de blancas
//? Se salta el color (una variación es sobre el mismo movimiento, por tanto hay que volver al color anterior)
//? ... es decir, si acaban de mover las negras, el primer movimiento de la variación también es de negras
setup.IsWhiteMove = actualColor != PieceBaseModel.PieceColor.White;
// Copia las piezas
setup.Pieces.AddRange(previousPieces);
// Devuelve la configuración
return(setup);
}
/// <summary>
/// Busca una pieza
/// </summary>
private Image SearchPiece(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color, int row, int column)
{
// Busca la pieza
foreach (FrameworkElement control in udtCanvas.Children)
{
if (control is Image image && image.Tag != null && image.Tag is FigureViewModel figure &&
figure.Type == type && figure.Color == color && figure.Row == row && figure.Column == column)
{
return(image);
}
}
// Devuelve una pieza vacía
return(null);
}
/// <summary>
/// Comprueba si se puede realizar un enroque (las piezas no se han movido y no hay nada entre medias)
/// </summary>
private bool CanMoveCastle(PieceBaseModel.PieceColor color, int column)
{
bool canMove = false;
int row = GetRowKing(color);
PieceBaseModel king = this[row, 4];
PieceBaseModel rook = this[row, column];
//TODO --> Debería comprobar además si las celdas intermedias no está en jaque
// Comprueba el movimiento
if (king != null && rook != null && !king.IsMoved && !rook.IsMoved)
{
canMove = IsPathEmpty(row, 4, row, column);
}
// Devuelve el valor que indica si se puede mover
return(canMove);
}
/// <summary>
/// Inicaliza las celdas
/// </summary>
private void InitCells()
{
PieceBaseModel.PieceColor color = PieceBaseModel.PieceColor.White;
// Añade las celdas
for (int row = 0; row < 8; row++)
{
// Rellena por columnas
for (int column = 0; column < 8; column++)
{
Scapes.Add(new CellViewModel(row, column, color));
color = GetNextColor(color);
}
// Cambia el color de inicio de la siguiente fila
color = GetNextColor(color);
}
}
/// <summary>
/// Crea una imagen y la añade al canvas
/// </summary>
private Image CreateImage(PieceBaseModel.PieceColor color, PieceBaseModel.PieceType?type, int row, int column)
{
Image view = new Image();
// Carga la imagen
view.Source = LoadImage(GetImageFileName(color, type));
view.Stretch = Stretch.Fill;
// Asigna las propiedades de visualización
Canvas.SetTop(view, GetImageTop(row));
Canvas.SetLeft(view, GetImageLeft(column));
view.Width = GetImageWidth();
view.Height = GetImageHeight();
// Añade el elemento al canvas
udtCanvas.Children.Add(view);
// Devuelve el control
return(view);
}
/// <summary>
/// Añade un movimiento a la lista
/// </summary>
private MovementFigureModel ParseMovement(GameBoardModel board, PieceBaseModel.PieceColor actualColor, Move move)
{
MovementFigureModel newMovement = new MovementFigureModel();
CellConversor cellConversor = new CellConversor();
// Asigna los datos
newMovement.Color = actualColor;
newMovement.Type = ConvertMovement(move.Type);
newMovement.Text = move.ToString();
newMovement.IsCheck = move.IsCheck ?? false;
newMovement.IsDoubleCheck = move.IsDoubleCheck ?? false;
newMovement.IsCheckMate = move.IsCheckMate ?? false;
switch (newMovement.Type)
{
case MovementFigureModel.MovementType.CastleKingSide:
case MovementFigureModel.MovementType.CastleQueenSide:
// Asigna la pieza de origen
newMovement.OriginPiece = PieceBaseModel.PieceType.Rook;
// Crea las acciones de enroque
newMovement.Actions.CreateCastleKingActions(board, newMovement);
break;
default:
PieceBaseModel.PieceType?targetPiece = null;
// Asigna los datos
newMovement.OriginPiece = ConvertPiece(move.Piece);
targetPiece = ConvertPiece(move.TargetPiece);
// Añade la pieza promocionada
if (move.PromotedPiece != null)
{
newMovement.PromotedPiece = ConvertPiece(move.PromotedPiece);
}
// Crea las acciones
newMovement.Actions.CreateActions(board, newMovement,
cellConversor.ConvertCell(move.TargetSquare.Rank, move.TargetSquare.File),
cellConversor.ConvertCell(move.OriginRank, move.OriginFile),
targetPiece);
break;
}
newMovement.Annotation = ConvertAnnotation(move.Annotation);
// Ejecuta los movimientos sobre el tablero
board.Execute(newMovement);
// Devuelve el movimiento
return(newMovement);
}
/// <summary>
/// Obtiene el nombre de archivo de imagen a cargar
/// </summary>
private string GetImageFileName(PieceBaseModel.PieceColor color, PieceBaseModel.PieceType?type)
{
string pathBoard = ViewModel.ComboPathBoard.SelectedPathImages;
string pathPieces = ViewModel.ComboPathPieces.SelectedPathImages;
if (type == null)
{
switch (color)
{
case PieceBaseModel.PieceColor.Black:
return(System.IO.Path.Combine(pathBoard, "BoardDark.gif"));
case PieceBaseModel.PieceColor.White:
return(System.IO.Path.Combine(pathBoard, "BoardLight.gif"));
}
}
else
{
string pieceColor = color == PieceBaseModel.PieceColor.White ? "White" : "Black";
switch (type)
{
case PieceBaseModel.PieceType.Pawn:
return(System.IO.Path.Combine(pathPieces, $"Pawn{pieceColor}.gif"));
case PieceBaseModel.PieceType.Rook:
return(System.IO.Path.Combine(pathPieces, $"Rook{pieceColor}.gif"));
case PieceBaseModel.PieceType.Knight:
return(System.IO.Path.Combine(pathPieces, $"Knight{pieceColor}.gif"));
case PieceBaseModel.PieceType.Bishop:
return(System.IO.Path.Combine(pathPieces, $"Bishop{pieceColor}.gif"));
case PieceBaseModel.PieceType.King:
return(System.IO.Path.Combine(pathPieces, $"King{pieceColor}.gif"));
case PieceBaseModel.PieceType.Queen:
return(System.IO.Path.Combine(pathPieces, $"Queen{pieceColor}.gif"));
}
}
return("");
}
/// <summary>
/// Enroque largo
/// </summary>
public bool MoveCastleQueenSide(PieceBaseModel.PieceColor color)
{
bool canMove = CanMoveCastleQueenSide(color);
// Realiza el enroque
if (canMove)
{
int row = GetRowKing(color);
// Mueve el rey
MoveWithoutCheck(row, 4, row, 2, false);
// Mueve la torre
MoveWithoutCheck(row, 0, row, 3, true);
// Deshabilita los enroques (los dos)
Parameters.DisableCastle(color);
}
// Devuelve el valor que indica si se ha movido
return(canMove);
}
/// <summary>
/// Inicializa el tablero
/// </summary>
private void Reset()
{
if (ViewModel.SelectedGame != null)
{
PieceBaseModel.PieceColor color = PieceBaseModel.PieceColor.White;
// Limpia el canvas
Cells.Clear();
udtCanvas.Children.Clear();
// Añade las celdas
for (int row = 0; row < 8; row++)
{
// Rellena por columnas
for (int column = 0; column < 8; column++)
{
Cells.Add(CreateFigure(row, column, color, null));
color = GetNextColor(color);
}
// Cambia el color de inicio de la siguiente fila
color = GetNextColor(color);
}
// Añade las etiquetas
for (int row = 0; row < 8; row++)
{
Cells.Add(CreateLabel(row, -1, (char)('0' + 8 - row)));
}
for (int column = 0; column < 8; column++)
{
Cells.Add(CreateLabel(-1, column, (char)('A' + column)));
}
// Añade las piezas
foreach (PieceBaseModel piece in ViewModel.MovementsList.GameBoard.Pieces)
{
Cells.Add(CreateFigure(piece.Cell.Row, piece.Cell.Column, piece.Color, piece.Type));
}
// Muestra las imágenes
ShowImages();
}
}
/// <summary>
/// Crea un promoción
/// </summary>
private ActionPromoteModel CreatePromoteAction(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color, CellModel target)
{
return(new ActionPromoteModel(type, color, target.Row, target.Column));
}
/// <summary>
/// Crea una captura
/// </summary>
private ActionCaptureModel CreateCaptureAction(PieceBaseModel.PieceType pieceCaptured, PieceBaseModel.PieceColor colorCaptured, CellModel target)
{
return(new ActionCaptureModel(pieceCaptured, colorCaptured, target.Row, target.Column));
}
/// <summary>
/// Crea un movimiento
/// </summary>
private ActionMoveModel CreateMoveAction(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color, CellModel from, CellModel to)
{
return(new ActionMoveModel(type, color, from.Row, from.Column, to.Row, to.Column));
}
/// <summary>
/// Crea una captura
/// </summary>
private void CreateCaptureAction(GameBoardModel board, PieceBaseModel.PieceType?piece, PieceBaseModel.PieceColor color, CellModel from)
{
PieceBaseModel targetPiece = board.Pieces.GetPiece(from);
//? En ocasiones la pieza leída no es la real del tablero, por eso buscamos la pieza adecuada
// Añade la pieza
Add(new ActionCaptureModel(targetPiece?.Type ?? piece ?? PieceBaseModel.PieceType.Unknown, color, from));
}
/// <summary>
/// Crea un movimiento
/// </summary>
private void CreateMoveAction(PieceBaseModel.PieceType type, PieceBaseModel.PieceColor color, CellModel from, CellModel to)
{
Add(new ActionMoveModel(type, color, from, to));
}
/// <summary>
/// Obtiene el siguiente color
/// </summary>
private PieceBaseModel.PieceColor GetNextColor(PieceBaseModel.PieceColor color)
{
return(color == PieceBaseModel.PieceColor.White ? PieceBaseModel.PieceColor.Black : PieceBaseModel.PieceColor.White);
}
/// <summary>
/// Obtiene la fila de rey de un color
/// </summary>
private int GetRowKing(PieceBaseModel.PieceColor color)
{
return(color == PieceBaseModel.PieceColor.White ? 7 : 0);
}
/// <summary>
/// Comprueba si se puede hacer un enroque largo
/// </summary>
public bool CanMoveCastleQueenSide(PieceBaseModel.PieceColor color)
{
return(color == Parameters.GetTurnColor() && Parameters.CanMoveCastleQueenSide(color) && CanMoveCastle(color, 0));
}
