/// <summary> /// Helper constructor that creates a new chess board based off of a Fen string. /// </summary> /// <param name="fenBoard">The Fen string that represents the board.</param> public ChessBoard(string fenBoard) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_ctor_string); Board = new ChessPiece[NumberOfRows, NumberOfColumns]; FromFenBoard(fenBoard); }
/// <summary> /// Constructor that creates a new ChessMove object based on two ChessLocations and a ChessFlag /// </summary> /// <param name="from">From ChessLocation</param> /// <param name="to">To ChessLocation</param> /// <param name="flag">The ChessFlag to create the move with.</param> public ChessMove(ChessLocation from, ChessLocation to, ChessFlag flag) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_ctor_ChessLocation_ChessLocation_ChessFlag); From = from; To = to; Flag = flag; ToStringPrefix = string.Empty; }
/// <summary> /// Creates a string that shows the describes the chess move. /// </summary> /// <returns>The description string.</returns> public override string ToString() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_ToString); string moveText = string.Empty; if (this.From == null) { moveText += "The Move's From field was null. "; } else { if (!this.From.IsValid) { moveText += "The Move's From field was outside the bounds of the board coordinates. "; } } if (this.To == null) { moveText += "The Move's To field was null. "; } else { if (!this.To.IsValid) { moveText += "The Move's To field was outside the bounds of the board coordinates. "; } } if (this.From == this.To) { moveText += "The Move's From and To fields are equal. "; } if ((moveText != string.Empty) && (this.Flag != ChessFlag.NoFlag)) { moveText += "Flag: " + this.Flag.ToString(); } else { moveText = ToStringPrefix + "From: [" + this.From.X + ", " + this.From.Y + "] To: [" + this.To.X + ", " + this.To.Y + "] "; if (this.Flag != ChessFlag.NoFlag) { moveText += "Flag: " + this.Flag.ToString();; } } moveText.TrimEnd(); return(moveText); }
/// <summary> /// Gets or sets the piece on the board in a specified location; 0,0 is the upper left hand corner of the board. /// </summary> /// <param name="x">Column of the desired piece location</param> /// <param name="y">Row of the desired piece location</param> /// <returns>ChessPiece</returns> public ChessPiece this[int x, int y] { get { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_get_Indexer_int_int); return(Board[x, y]); } set { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_set_Indexer_int_int); Board[x, y] = value; } }
/// <summary> /// Gets or sets the piece on the board in a specified location; 0,0 is the upper left hand corner of the board. /// </summary> /// <param name="location">Location of the desired piece</param> /// <returns>ChessPiece</returns> public ChessPiece this[ChessLocation location] { get { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_get_ChessLocationIndexer); return(this[location.X, location.Y]); } set { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_set_ChessLocationIndexer); this[location.X, location.Y] = value; } }
public static bool operator ==(ChessMove move1, ChessMove move2) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_EQ); if ((((object)move1) == null) && (((object)move2) == null)) { return(true); } if (((object)move1) == null) { return(false); } return(move1.Equals(move2)); }
private ChessPiece[,] CloneBoard(ChessPiece[,] board) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_CloneBoard_ChessPieceArray); ChessPiece[,] retBoard = new ChessPiece[NumberOfRows, NumberOfColumns]; for (int Y = 0; Y < NumberOfRows; Y++) { for (int X = 0; X < NumberOfColumns; X++) { retBoard[X, Y] = board[X, Y]; } } return(retBoard); }
public static bool operator==(ChessLocation lhs, ChessLocation rhs) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessLocation_EQ); if (((object)lhs == null) && ((object)rhs == null)) { return(true); } if (((object)lhs == null) || ((object)rhs == null)) { return(false); } return(lhs.Equals(rhs)); }
/// <summary> /// Create a ChessMove exactly like this one. /// </summary> /// <returns>The cloned move</returns> public ChessMove Clone() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_Clone); ChessMove newMove = new ChessMove(null, null); if (this.To != null) { newMove.To = this.To.Clone(); } if (this.From != null) { newMove.From = this.From.Clone(); } newMove.ValueOfMove = this.ValueOfMove; newMove.Flag = this.Flag; return(newMove); }
/// <summary> /// Executes a move on the ChessBoard. /// </summary> /// <param name="move">The move to execute.</param> public void MakeMove(ChessMove move) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_MakeMove_ChessMove); if (move.IsBasicallyValid) { // Handle Queening if ((this[move.From] == ChessPiece.WhitePawn) && (move.From.Y == 1) && (move.To.Y == 0)) { this[move.To] = ChessPiece.WhiteQueen; } else if ((this[move.From] == ChessPiece.BlackPawn) && (move.From.Y == 6) && (move.To.Y == 7)) { this[move.To] = ChessPiece.BlackQueen; } else { this[move.To] = this[move.From]; } this[move.From] = ChessPiece.Empty; } }
public override bool Equals(object obj) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessLocation_Equals); if (obj == null) { return(false); } if (!(obj is ChessLocation)) { return(false); } ChessLocation tmpLoc = (ChessLocation)obj; if ((this.X == tmpLoc.X) && (this.Y == tmpLoc.Y)) { return(true); } return(false); }
public override bool Equals(object obj) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_Equals); if (obj == null) { return(false); } if (!(obj is ChessMove)) { return(false); } ChessMove move2 = (ChessMove)obj; if (this.Flag != move2.Flag) { return(false); } if ((this.From != move2.From) || (this.To != move2.To)) { return(false); } return(true); }
/// <summary> /// Accepts a full Fen board and sets the ChessBoard object to that state. /// </summary> /// <param name="fenBoard">The Fen string</param> public void FromFenBoard(string fenBoard) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_FromFenBoard_string); string[] lines = fenBoard.Split(' ')[0].Split('/'); int spaces = 0; for (int y = 0; y < ChessBoard.NumberOfRows; ++y) { for (int x = 0; x < ChessBoard.NumberOfColumns; ++x) { this[x, y] = ChessPiece.Empty; } } ChessPiece piece = ChessPiece.Empty; for (int y = 0; y < ChessBoard.NumberOfRows; ++y) { for (int x = 0, boardCol = 0; x < lines[y].Length; ++x, ++boardCol) { if (Char.IsDigit(lines[y][x])) { spaces = Convert.ToInt32(lines[y][x]) - 48; boardCol += spaces - 1; } else { switch (lines[y][x]) { case 'r': piece = ChessPiece.BlackRook; break; case 'n': piece = ChessPiece.BlackKnight; break; case 'b': piece = ChessPiece.BlackBishop; break; case 'q': piece = ChessPiece.BlackQueen; break; case 'k': piece = ChessPiece.BlackKing; break; case 'p': piece = ChessPiece.BlackPawn; break; case 'K': piece = ChessPiece.WhiteKing; break; case 'Q': piece = ChessPiece.WhiteQueen; break; case 'R': piece = ChessPiece.WhiteRook; break; case 'B': piece = ChessPiece.WhiteBishop; break; case 'N': piece = ChessPiece.WhiteKnight; break; case 'P': piece = ChessPiece.WhitePawn; break; default: throw new Exception("Invalid FEN board"); } this[boardCol, y] = piece; } } } }
/// <summary> /// Creates a complete copy of this object and returns it. /// </summary> /// <returns>The ChessLocation copy.</returns> public ChessLocation Clone() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessLocation_Clone); return(new ChessLocation(this.X, this.Y)); }
/// <summary> /// Creates a ChessLocation object /// </summary> /// <param name="x">Column number. Ranges 0 - 7</param> /// <param name="y">Row number. Ranges from 0 - 7</param> public ChessLocation(int x, int y) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessLocation_ctor_int_int); X = x; Y = y; }
public override int GetHashCode() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessLocation_GetHashCode); return(X * 10 + Y); }
public static bool operator !=(ChessLocation lhs, ChessLocation rhs) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessLocation_NE); return(!(lhs == rhs)); }
/// <summary> /// Helper constructor that creates a new chess board based off of a ChessPiece array board. /// </summary> /// <param name="board">The ChessPiece array that represents the board.</param> public ChessBoard(ChessPiece[,] board) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_ctor_ChessPieceArray); Board = CloneBoard(board); }
public static bool operator !=(ChessMove move1, ChessMove move2) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_NE); return(!(move1 == move2)); }
/// <summary> /// The main constructor that defaults the ChessBoard to the normal starting chess board state. /// </summary> public ChessBoard() : this(ChessState.FenStartState) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_ctor); }
/// <summary> /// This is used to allow sorting of ChessMoves based on their values. /// </summary> /// <param name="other">a ChessMove to compare.</param> /// <returns></returns> public int CompareTo(ChessMove other) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_CompareTo_ChessMove); // Sorts it from lowest value move to highest value move return(this.ValueOfMove - other.ValueOfMove); }
/// <summary> /// Returns the hashcode for this object /// </summary> /// <returns>the hash code.</returns> public override int GetHashCode() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_GetHashCode); return(this.ToPartialFenBoard().GetHashCode()); }
/// <summary> /// Creates a partial Fen string from the ChessBoard. /// It is only partial however, since Fen strings contain more data than just the board. /// </summary> /// <returns>The partial Fen string.</returns> public string ToPartialFenBoard() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_ToPartialFenBoard); StringBuilder strBuild = new StringBuilder(); for (int y = 0; y < ChessBoard.NumberOfRows; ++y) { int spaces = 0; for (int x = 0; x < ChessBoard.NumberOfColumns; ++x) { char c = 'x'; switch (this[x, y]) { case ChessPiece.WhitePawn: c = 'P'; break; case ChessPiece.WhiteRook: c = 'R'; break; case ChessPiece.WhiteKnight: c = 'N'; break; case ChessPiece.WhiteBishop: c = 'B'; break; case ChessPiece.WhiteQueen: c = 'Q'; break; case ChessPiece.WhiteKing: c = 'K'; break; case ChessPiece.BlackPawn: c = 'p'; break; case ChessPiece.BlackRook: c = 'r'; break; case ChessPiece.BlackKnight: c = 'n'; break; case ChessPiece.BlackBishop: c = 'b'; break; case ChessPiece.BlackQueen: c = 'q'; break; case ChessPiece.BlackKing: c = 'k'; break; case ChessPiece.Empty: ++spaces; continue; default: throw new Exception("Invalid chess piece"); } if ((c != 'x') && (spaces > 0)) { strBuild.Append(spaces.ToString()); spaces = 0; } strBuild.Append(c); } if (spaces > 0) { strBuild.Append(spaces.ToString()); spaces = 0; } if (y < 7) { strBuild.Append('/'); } } return(strBuild.ToString()); }
public override int GetHashCode() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_GetHashCode); return(From.GetHashCode() * 10 + To.GetHashCode()); }
/// <summary> /// Constructor that creates a new ChessMove object based on two ChessLocations /// </summary> /// <param name="from">From ChessLocation</param> /// <param name="to">To ChessLocation</param> public ChessMove(ChessLocation from, ChessLocation to) : this(from, to, ChessFlag.NoFlag) { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessMove_ctor_ChessLocation_ChessLocation); }
/// <summary> /// Creates a complete copy of this object and returns it. /// </summary> /// <returns>The copy ChessBoard</returns> public ChessBoard Clone() { Profiler.AddToMainProfile((int)ProfilerMethodKey.ChessBoard_Clone); return(new ChessBoard(this.Board)); }