// TODO: You must write this method.
public virtual bool Equals(ChessMove other)
{
ChessMoveType type = ChessMoveType.PawnPromote;
// Most chess moves are equal to each other if they have the same start and end position.
// PawnPromote moves must also be promoting to the same piece type.
if (this.StartPosition == other.StartPosition)
{
if (this.EndPosition == other.EndPosition)
{
if (this.MoveType == other.MoveType && other.MoveType == type)
{
if (this.PromotePiece == other.PromotePiece)
{
return(true);
}
else
{
return(false);
}
//Console.WriteLine(this.mov)
}
else
{
return(true);
}
}
}
return(false);
}
public ChessMove(BoardPosition start, BoardPosition end, ChessPieceType piece, ChessMoveType moveType = ChessMoveType.PawnPromote)
{
StartPosition = start;
EndPosition = end;
ChessPieceType = piece;
MoveType = moveType;
}
public GameMoveData(ChessMoveType moveType, ChessColor color, ChessPieceCoord from, ChessPieceCoord to)
{
MoveType = moveType;
Color = color;
From = from;
To = to;
}
/// <summary>
/// Constructs a ChessMove that moves a piece from one position to another
/// </summary>
/// <param name="start">the starting position of the piece to move</param>
/// <param name="end">the position where the piece will end up</param>
/// <param name="moveType">the type of move represented</param>
/// <param name="pieceType">the piece to replace pawn during promotion</param>
public ChessMove(BoardPosition start, BoardPosition end, ChessMoveType moveType = ChessMoveType.Normal, ChessPieceType pieceType = ChessPieceType.Empty)
{
StartPosition = start;
EndPosition = end;
MoveType = moveType;
PromotionPiece = pieceType;
}
public ChessMove(BoardPosition start, BoardPosition end, ChessPieceType promoteTo, ChessMoveType moveType = ChessMoveType.Normal)
{
StartPosition = start;
EndPosition = end;
MoveType = moveType;
PromoteTo = promoteTo;
}
/// <summary>
/// Parses a string representing a ChessMove into a ChessMove object.
/// </summary>
/// <param name="move">a string in the format "(start, end)", where start and end use
/// algebraic notation for board positions. In pawn promotion moves, "end" is a string name
/// for the piece to replace the promoted pawn with, e.g., "queen", "bishop", "knight", or "rook".
/// </param>
public IGameMove ParseMove(string move)
{
string[] split = move.ToLower().Trim(new char[] { '(', ')' }).Split(',');
BoardPosition start = ParsePosition(split[0].Trim());
ChessMoveType type = ChessMoveType.Normal;
string second = split[1].Trim();
BoardPosition end;
if (second == "queen")
{
end = new BoardPosition(-1, (int)ChessPieceType.Queen);
type = ChessMoveType.PawnPromote;
}
else if (second == "bishop")
{
end = new BoardPosition(-1, (int)ChessPieceType.Bishop);
type = ChessMoveType.PawnPromote;
}
else if (second == "knight")
{
end = new BoardPosition(-1, (int)ChessPieceType.Knight);
type = ChessMoveType.PawnPromote;
}
else if (second == "rook")
{
end = new BoardPosition(-1, (int)ChessPieceType.RookPawn);
type = ChessMoveType.PawnPromote;
}
else
{
end = ParsePosition(split[1].Trim());
}
return(new ChessMove(start, end, type));
}
public ChessMove(BoardPosition start, BoardPosition end, ChessPieceType _promoteto, ChessMoveType moveType = ChessMoveType.PawnPromote)
{
StartPosition = start;
EndPosition = end;
MoveType = moveType;
promoteTo = _promoteto;
}
public ChessMove(BoardPosition start, BoardPosition end, ChessPieceType chessPieceType, ChessMoveType moveType = ChessMoveType.Normal)
{
StartPosition = start;
EndPosition = end;
MoveType = moveType;
ChessPiece = chessPieceType;
}
/// <summary>
/// Constructs a ChessMove that moves a piece from one position to another
/// </summary>
/// <param name="start">the starting position of the piece to move</param>
/// <param name="end">the position where the piece will end up</param>
/// <param name="moveType">the type of move represented</param>
public ChessMove(BoardPosition start, BoardPosition end, ChessMoveType moveType = ChessMoveType.Normal)
{
StartPosition = start;
EndPosition = end;
MoveType = moveType;
PromoteType = ChessPieceType.Empty;
IsCapturing = false;
}
public ChessMoveData(ObjectGuid playerGuid, ObjectGuid pieceGuid, GameMoveData data)
{
Type = data.MoveType;
PlayerGuid = playerGuid;
Color = data.Color;
PieceGuid = pieceGuid;
From = data.From;
To = data.To;
}
/// <summary>
/// Constructs a ChessMove that moves a piece from one position to another
/// </summary>
/// <param name="start">the starting position of the piece to move</param>
/// <param name="end">the position where the piece will end up</param>
/// <param name="moveType">the type of move represented</param>
public ChessMove(BoardPosition start, BoardPosition end, ChessMoveType moveType = ChessMoveType.Normal)
{
StartPosition = start;
EndPosition = end;
MoveType = moveType;
if (moveType.Equals(ChessMoveType.PawnPromote))
{
promoteTo = ChessPieceType.Empty;
}
}
/// <summary>
/// Converts the given ChessMove to a string representation in the form
/// "(start, end)", where start and end are board positions in algebraic
/// notation (e.g., "a5").
///
/// If this move is a pawn promotion move, the selected promotion piece
/// must also be in parentheses after the end position, as in
/// "(a7, a8, Queen)".
/// </summary>
public string MoveToString(ChessMove move)
{
var row_map = new Dictionary <char, char>();
row_map.Add('0', '8');
row_map.Add('1', '7');
row_map.Add('2', '6');
row_map.Add('3', '5');
row_map.Add('4', '4');
row_map.Add('5', '3');
row_map.Add('6', '2');
row_map.Add('7', '1');
var col_map = new Dictionary <char, char>();
col_map.Add('0', 'a');
col_map.Add('1', 'b');
col_map.Add('2', 'c');
col_map.Add('3', 'd');
col_map.Add('4', 'e');
col_map.Add('5', 'f');
col_map.Add('6', 'g');
col_map.Add('7', 'h');
String start_position = move.StartPosition.ToString();
start_position = start_position.Replace(" ", "");
start_position = start_position.Replace("(", "");
start_position = start_position.Replace(")", "");
start_position = start_position.Replace(",", "");
char[] start_array = start_position.ToCharArray(0, start_position.Length);
start_array[0] = row_map[start_array[0]];
start_array[1] = col_map[start_array[1]];
String start_moveString = start_array[1].ToString() + start_array[0].ToString();
String end_position = move.EndPosition.ToString();
end_position = end_position.Replace(" ", "");
end_position = end_position.Replace("(", "");
end_position = end_position.Replace(")", "");
end_position = end_position.Replace(",", "");
char[] end_array = end_position.ToCharArray(0, end_position.Length);
end_array[0] = row_map[end_array[0]];
end_array[1] = col_map[end_array[1]];
String end_moveString = end_array[1].ToString() + end_array[0].ToString();
ChessMoveType movetype = move.MoveType;
//if (movetype == ChessMoveType.PawnPromote)
//{
// return ("(" + start_moveString + "," + end_moveString + "," + move.ChessPieceType + ")");
//}
//else
if (movetype == ChessMoveType.Normal)
{
return("(" + start_moveString + "," + end_moveString + ")");
}
if (movetype == ChessMoveType.PawnPromote)
{
return("(" + start_moveString + "," + end_moveString + "," + move.chessPiece + ")");
}
else
{
return("(" + start_moveString + "," + end_moveString + "," + move.MoveType + ")");
}
}
/// <summary>
/// Constructs a ChessMove that performs a "special" move from one position to another.
/// </summary>
/// <param name="start">the starting position of the piece to move</param>
/// <param name="end">the position where the piece will end up</param>
/// <param name="type">the special chess move type to perform</param>
public ChessMove(BoardPosition start, BoardPosition end, ChessMoveType type) :
this(start, end)
{
MoveType = type;
}
/// <summary>
/// Converts a string representation of a move into a ChessMove object.
/// Must work with any string representation created by MoveToString.
/// </summary>
public ChessMove ParseMove(string moveText)
{
var col_map = new Dictionary <char, int>();
col_map.Add('a', 0);
col_map.Add('b', 1);
col_map.Add('c', 2);
col_map.Add('d', 3);
col_map.Add('e', 4);
col_map.Add('f', 5);
col_map.Add('g', 6);
col_map.Add('h', 7);
var row_map = new Dictionary <char, int>();
row_map.Add('8', 0);
row_map.Add('7', 1);
row_map.Add('6', 2);
row_map.Add('5', 3);
row_map.Add('4', 4);
row_map.Add('3', 5);
row_map.Add('2', 6);
row_map.Add('1', 7);
//Console.WriteLine(moveText);
moveText = Regex.Replace(moveText, @" ", "");
moveText = moveText.Replace("(", "");
moveText = moveText.Replace(")", "");
moveText = moveText.Replace(" ", "");
//Console.WriteLine(moveText);
String[] move = moveText.Split(",");
String start_move = "";
String end_move = "";
if (move.Length > 0)
{
start_move = move[0];
end_move = move[1];
}
//Console.WriteLine("parsed start move:" + row_map[start_move[1]] + "," + col_map[start_move[0]]);
int parsedStart_row = row_map[start_move[1]];
int parsedStart_col = col_map[start_move[0]];
int parsedEnd_row = row_map[end_move[1]];
int parsedEnd_col = col_map[end_move[0]];
String moveType = "";
ChessMove test = null;
if (move.Length > 2)
{
moveType = move[move.Length - 1];
Console.WriteLine(moveType);
if (moveType == "Queen" || moveType == "queen")
{
test = new ChessMove(new BoardPosition(parsedStart_row, parsedStart_col), new BoardPosition(parsedEnd_row, parsedEnd_col), ChessPieceType.Queen, ChessMoveType.PawnPromote);
}
else if (moveType == "Bishop" || moveType == "bishop")
{
test = new ChessMove(new BoardPosition(parsedStart_row, parsedStart_col), new BoardPosition(parsedEnd_row, parsedEnd_col), ChessPieceType.Bishop, ChessMoveType.PawnPromote);
}
else if (moveType == "Rook" || moveType == "rook")
{
test = new ChessMove(new BoardPosition(parsedStart_row, parsedStart_col), new BoardPosition(parsedEnd_row, parsedEnd_col), ChessPieceType.Rook, ChessMoveType.PawnPromote);
}
else if (moveType == "Knight" || moveType == "knight")
{
test = new ChessMove(new BoardPosition(parsedStart_row, parsedStart_col), new BoardPosition(parsedEnd_row, parsedEnd_col), ChessPieceType.Knight, ChessMoveType.PawnPromote);
}
else
{
ChessMoveType typeParsed = (ChessMoveType)(Enum.Parse(typeof(ChessMoveType), move[move.Length - 1]));
test = new ChessMove(new BoardPosition(parsedStart_row, parsedStart_col), new BoardPosition(parsedEnd_row, parsedEnd_col), typeParsed);
}
}
else
{
test = new ChessMove(new BoardPosition(parsedStart_row, parsedStart_col), new BoardPosition(parsedEnd_row, parsedEnd_col));
}
return(test);
}
/// <summary> /// Creates a ChessMove using the given start and end positions. /// </summary> protected ChessMove Move(BoardPosition start, BoardPosition end, ChessMoveType type = ChessMoveType.Normal) => new ChessMove(start, end, type);
