Beispiel #1
0
        /// <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);
        }
    ///////////////////////////////////////////////////////////////////////////
    public override bool IsReady()
    {
        potentialTargets = new ArrayList ();

        foreach (ChessPiece player1Piece in scenario.GetAllChessPiecesForPlayer(1)) {
                    foreach (ChessPiece player2Piece in scenario.GetAllChessPiecesForPlayer(2)) {
                            if (player1Piece.CanCaptureXY (player2Piece.x, player2Piece.y))
                                    potentialTargets.Add (player1Piece);
                    }
            }

            int targetValue = 0;

            foreach (ChessPiece piece in potentialTargets) {
                    if (piece.GetValue () > targetValue) {
                            targetValue = piece.GetValue ();
                            targetChessPiece = piece;
                    }
            }

            if (targetChessPiece == null)
        {
            return false;
        }
        else
        {

             potentialPlacesToMoveTarget = new ArrayList ();

            foreach (PotentialMove move in targetChessPiece.GetMoveList())
            {
                //Debug.Log (player2Piece.gameObject.name + ": Has " + player2Piece.GetMoveList().Count + " potential moves");
                //int goodmoves = 0;

                foreach (ChessPiece player2Piece in scenario.GetAllChessPiecesForPlayer(2)) 				{
                    //Debug.Log ("checked" + counter + "moves");

                    if (player2Piece.CanCaptureChessPieceIfItMovedToXY (targetChessPiece, move.x, move.y))
                    {
                        if (GameObject.FindGameObjectWithTag ("Scenario").GetComponent<Scenario> ().GetPieceAtXY (move.x, move.y) == null)
                        {
                            //goodmoves++;
                            potentialPlacesToMoveTarget.Add (move);
                            Debug.Log(potentialPlacesToMoveTarget.Count);

                        }
                    }

                }

                //	Debug.Log (player2Piece.gameObject.name + ": Potential Places to Move Target: " + goodmoves);
            }
        }
                    if(potentialPlacesToMoveTarget.Count > 0){
                return true;
            }
             else {
                    return false;
            }
    }
    ///////////////////////////////////////////////////////////////////////////
    public override bool IsReady()
    {
        potentialTargets = new ArrayList ();

        foreach (ChessPiece player1Piece in scenario.GetAllChessPiecesForPlayer(1)) {
            foreach (ChessPiece player2Piece in scenario.GetAllChessPiecesForPlayer(2)) {
                if (player1Piece.CanCaptureXY (player2Piece.x, player2Piece.y) && !player1Piece.IsDepressed())
                {
                    potentialTargets.Add (player1Piece);
                }
            }
        }

        int targetValue = 0;

        foreach (ChessPiece piece in potentialTargets) {
            if (piece.GetValue () > targetValue) {
                targetValue = piece.GetValue ();
                targetChessPiece = piece;
            }
        }

        if (targetChessPiece == null)
        {
            return false;
        }
        else
        {
            return true;

        }
    }
Beispiel #4
0
 public void SetPiece( ChessPiece chessPiece )
 {
     this.gameObject = chessPiece.gameObject;
     this.playerSide = chessPiece.playerSide;
     this.pieceType = chessPiece.pieceType;
     this.piecePlayerType = chessPiece.piecePlayerType;
 }
Beispiel #5
0
            public override string getNotation(ChessSide side,
							    ChessPiece[,]
							    positions, int sr,
							    int sf, int dr,
							    int df,
							    PromotionType
							    promotion_type)
            {
                string str;
                if (sf == df)
                  {
                      str = "" + (char) ('a' + df) + (dr +
                                      1);
                  }
                else
                  {
                      str = "" + (char) ('a' + sf);
                      if (positions[dr, df] != null)
                          str += 'x';
                      str += "" + (char) ('a' + df) +
                          (dr + 1);
                  }
                if (dr == 7 || dr == 0)
                  {
                      /* No need to verify for specific colors
                       * only whites can reach 7 and blacks can reach 0
                       */
                      str += ChessPiece.
                          getPromotionString
                          (promotion_type);
                  }
                return str;
            }
Beispiel #6
0
            public override bool isValidMove(int i, int j,
							  ChessPiece[,]
							  positions,
							  int flags)
            {
                if (!base.
                    isValidMove (i, j, positions, flags))
                    return false;
                int r_diff = i - rank;
                int f_diff = j - file;

                if (r_diff < 0)
                    r_diff = -r_diff;
                if (f_diff < 0)
                    f_diff = -f_diff;

                if (r_diff < 2 && f_diff < 2)
                    return true;

                //                if( castling ) {
                //                        if( file == ChessBoardConstants.e && j == ChessBoardConstants.g )
                //                                return true;
                //                        if( file == ChessBoardConstants.e && j == ChessBoardConstants.c )
                //                                return true;
                //                }

                return false;
            }
 public ChessPieceViewModel(ChessPiece i_ChessPiece, PieceColor i_PieceColor, PieceSide i_PieceSide, int i_File, int i_Rank)
 {
     ChessCoord tempChessCoord = new ChessCoord();
     tempChessCoord.File = i_File;
     tempChessCoord.Rank = i_Rank;
     m_ChessPieceModel = new ChessPieceModel(i_ChessPiece, i_PieceColor, i_PieceSide, tempChessCoord);
 }
 ///////////////////////////////////////////////////////////////////////////
 public override void Deactivate()
 {
     base.Deactivate ();
     primaryTarget = null;
     collateralTarget = null;
     Destroy(transform.GetComponent<Rigidbody>());
 }
Beispiel #9
0
 public void CopyFrom( ChessPiece chessPiece )
 {
     this.gameObject = chessPiece.gameObject;
     this.playerSide = chessPiece.playerSide;
     this.pieceType = chessPiece.pieceType;
     this.piecePlayerType = chessPiece.piecePlayerType;
     this.bEnPassantCapture = chessPiece.bEnPassantCapture;
 }
        protected override Int32 Evaluate(ChessBoard myBoard, ChessPiece turn, Int16 depth)
        {
            IncrementSearchCount();
            var materialValue = (turn == ChessPiece.White ? 1 : -1) * myBoard.GetMaterialValue(this.ChessPieceRelativeValues, depth);
            var positionalValue = (turn == ChessPiece.White ? 1 : -1) * myBoard.GetPositionalValue();

            return MaterialFactor * materialValue + PositionalFactor * positionalValue;
        }
    public ChessBoardSquare( ChessPiece piece, ParticleSystem moveablePSystem, int nPile, int nRank )
    {
        this.position = new ChessPosition( nRank, nPile );
        this.piece = piece;
        if( this.piece != null )
            this.piece.SetPosition( this.position.Get3DPosition() );

        SetMovableEffect( moveablePSystem );
    }
Beispiel #12
0
    public void ClearPiece( bool bClearGameObject = false )
    {
        if( IsBlank() )
            return;

        if( bClearGameObject )
            piece.Clear( true );

        piece = null;
    }
Beispiel #13
0
            public override string getNotation(ChessSide side,
							    ChessPiece[,]
							    positions, int sr,
							    int sf, int dr,
							    int df,
							    PromotionType
							    promotion)
            {
                return "K" + (char) ('a' + df) + (dr + 1);
            }
Beispiel #14
0
        internal Piece(Piece piece)
        {
            PieceColor = piece.PieceColor;
            PieceType = piece.PieceType;
            Moved = piece.Moved;
            PieceValue = piece.PieceValue;
            PieceActionValue = piece.PieceActionValue;

            if (piece.ValidMoves != null)
                LastValidMoveCount = piece.ValidMoves.Count;
        }
        public List<Tuple<int, int>[]> GetRelativePaths(ChessPiece p)
        {
            int direction = p.Direction;

            return new List<Tuple<int, int>[]>()
            {
                new[] { new Tuple<int, int>(direction, -1), },
                new[] { new Tuple<int, int>(direction, 0), },
                new[] { new Tuple<int, int>(direction * 2, 0), },
                new[] { new Tuple<int, int>(direction, 1) },
            };
        }
        public List<Tuple<int, int>[]> GetRelativePaths(ChessPiece p)
        {
            var l = new List<Tuple<int, int>[]>();

            foreach (var subPath in new RookRelativePathProvider().GetRelativePaths(p))
                l.Add(subPath);

            foreach (var subPath in new BishopRelativePathProvider().GetRelativePaths(p))
                l.Add(subPath);

            return l;
        }
Beispiel #17
0
 public static void TestInequality_DifferentPieceAndPlayer()
 {
     ChessPiece piece1 = new ChessPiece(Piece.King, Player.White);
     ChessPiece piece2 = new ChessPiece(Piece.Queen, Player.Black);
     Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
     Assert.False(piece1.Equals(piece2), "piece1.Equals(piece2) should be false");
     Assert.False(piece2.Equals(piece1), "piece2.Equals(piece1) should be false");
     Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
     Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
     Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
     Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
     Assert.AreNotEqual(piece1.GetHashCode(), piece2.GetHashCode(), "Hash codes are equal");
 }
Beispiel #18
0
 public static void TestEquality()
 {
     ChessPiece piece1 = new ChessPiece(Piece.King, Player.White);
     ChessPiece piece2 = new ChessPiece(Piece.King, Player.White);
     Assert.AreEqual(piece1, piece2, "piece1 and piece2 are not equal");
     Assert.True(piece1.Equals(piece2), "piece1.Equals(piece2) should be True");
     Assert.True(piece2.Equals(piece1), "piece2.Equals(piece1) should be True");
     Assert.True(piece1 == piece2, "piece1 == piece2 should be True");
     Assert.True(piece2 == piece1, "piece2 == piece1 should be True");
     Assert.False(piece1 != piece2, "piece1 != piece2 should be false");
     Assert.False(piece2 != piece1, "piece2 != piece1 should be false");
     Assert.AreEqual(piece1.GetHashCode(), piece2.GetHashCode(), "Hash codes are different");
 }
    public void ClearPiece( bool bClearGameObject = false )
    {
        if( IsBlank() )
            return;

        //if( bClearGameObject )
        //	UnityEngine.Debug.Log( "---------------------------------------ChessBoardSquare::Clear() - success!!!!    piece type : " + piece.pieceType +
        //		"   File : " +  position.nPile + "   Rank : " + position.nRank );

        piece.Clear( bClearGameObject );

        piece = null;
    }
Beispiel #20
0
        public static void TestThrowIfNull()
        {
            Assert.Throws<ArgumentNullException>(delegate ()
            {
                object value = null;
                Utilities.ThrowIfNull(value, "value");
            });

            Assert.DoesNotThrow(delegate ()
            {
                ChessPiece piece = new ChessPiece(Piece.Bishop, Player.White);
                Utilities.ThrowIfNull(piece, "piece");
            });
        }
 public List<Tuple<int, int>[]> GetRelativePaths(ChessPiece p)
 {
     return new List<Tuple<int, int>[]>()
     {
         new[] { new Tuple<int, int>(-2, -1), },
         new[] { new Tuple<int, int>(-2, 1), },
         new[] { new Tuple<int, int>(-1, 2), },
         new[] { new Tuple<int, int>(1, 2) },
         new[] { new Tuple<int, int>(2, 1) },
         new[] { new Tuple<int, int>(2, -1) },
         new[] { new Tuple<int, int>(1, -2) },
         new[] { new Tuple<int, int>(-1, -2) },
     };
 }
Beispiel #22
0
            public override bool isValidMove(int i, int j,
							  ChessPiece[,]
							  positions,
							  int flags)
            {
                if (!base.
                    isValidMove (i, j, positions, flags))
                    return false;

                int tmp_r = rank, tmp_f = file;
                int rinc, finc, rdiff, fdiff;
                if (rank < i)
                  {
                      rinc = 1;
                      rdiff = i - rank;
                  }
                else
                  {
                      rinc = -1;
                      rdiff = rank - i;
                  }

                if (file < j)
                  {
                      finc = 1;
                      fdiff = j - file;
                  }
                else
                  {
                      finc = -1;
                      fdiff = file - j;
                  }

                if (rdiff != fdiff)
                    return false;

                for (int dist = rdiff - 1; dist > 0; dist--)
                  {
                      tmp_r += rinc;
                      tmp_f += finc;
                      if (positions[tmp_r, tmp_f] != null)
                        {
                            return false;
                        }
                  }

                return true;
            }
Beispiel #23
0
            public static bool isPawnPromotion(ChessPiece piece,
							    int file)
            {
                if (piece.Type != PieceType.PAWN)
                    return false;

                if (piece.Color == ColorType.WHITE
                    && file == 7)
                    return true;

                if (piece.Color == ColorType.BLACK
                    && file == 0)
                    return true;

                return false;
            }
 public ChessPieceModel(ChessPiece i_ChessPiece, PieceColor i_PieceColor, PieceSide i_PieceSide, ChessCoord i_ChessCoord)
 {
     ChessPiece = i_ChessPiece;
     PieceColor = i_PieceColor;
     PieceSide = i_PieceSide;
     ChessCoord = i_ChessCoord;
     string PieceColorStr;
     if (i_PieceColor == PieceColor.White) { PieceColorStr = "White"; } else { PieceColorStr = "Black"; }
     switch (i_ChessPiece) {
         case ChessPiece.King: ResourceURI = @"/ChessAI;component/Resources/Pieces/" + PieceColorStr + "_King.png"; break;
         case ChessPiece.Queen: ResourceURI = @"/ChessAI;component/Resources/Pieces/" + PieceColorStr + "_Queen.png"; break;
         case ChessPiece.Bishop: ResourceURI = @"/ChessAI;component/Resources/Pieces/" + PieceColorStr + "_Bishop.png"; break;
         case ChessPiece.Knight: ResourceURI = @"/ChessAI;component/Resources/Pieces/" + PieceColorStr + "_Knight.png"; break;
         case ChessPiece.Rook: ResourceURI = @"/ChessAI;component/Resources/Pieces/" + PieceColorStr + "_Rook.png"; break;
         case ChessPiece.Pawn: ResourceURI = @"/ChessAI;component/Resources/Pieces/" + PieceColorStr + "_Pawn.png"; break;
     }
 }
 public static string ChessPieceTypeToNotation(ChessPiece chessPiece)
 {
     switch (chessPiece & ChessPiece.Type)
     {
         case ChessPiece.Pawn:
             return "P";
         case ChessPiece.Knight:
             return "N";
         case ChessPiece.Bishop:
             return "B";
         case ChessPiece.Rook:
             return "R";
         case ChessPiece.Queen:
             return "Q";
         case ChessPiece.King:
             return "K";
     }
     return "";
 }
Beispiel #26
0
 public ChessMove(string moveString)
 {
     string[] coords = moveString.Split('-');
      if (coords.Length != 2)
     throw new ArgumentException("ChessMove must cotnain two coordinates separated by a hyphen");
      if (coords[0].Length != 2)
     throw new ArgumentException("First component of ChessMove must be 2 characters");
      if (coords[1].Length == 2)
     promotion = ChessPiece.Empty;
      else
      {
     if (coords[1].Length != 3)
        throw new ArgumentException("Second component of ChessMove must be 2 or 3 characters");
     promotion = GetChessPiece(coords[1][2]);
     coords[1] = coords[1].Substring(0, 2);
      }
      source = new Coordinate(coords[0]);
      target = new Coordinate(coords[1]);
 }
Beispiel #27
0
        /// <summary>
        /// 评价单个点的价值,仅为实验使用,不含神经网络
        /// </summary>
        /// <param name="gs"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="type">棋子类型</param>
        /// <returns></returns>
        private static int EvaluatePointSimple(GameState gs, int x, int y, ChessPiece type)
        {
            int ans = 0;

            for (int i = 0; i < 4; i++)
            {
                if (x + d_x[i] >= 0 && x + d_x[i] < Settings.BOARD_SIZE
                    && y + d_y[i] >= 0 && y + d_y[i] < Settings.BOARD_SIZE)
                    ans += ChessPiece.EMPTY != gs.chessboard[x + d_x[i], y + d_y[i]] ? 1 : 0;
            }
            for (int i = 4; i < 8; i++)
            {
                if (x + d_x[i] >= 0 && x + d_x[i] < Settings.BOARD_SIZE
                    && y + d_y[i] >= 0 && y + d_y[i] < Settings.BOARD_SIZE)
                    ans += (ChessPiece.EMPTY != gs.chessboard[x + d_x[i], y + d_y[i]] ? 2 : 0);
            }
            return ans;

        }
Beispiel #28
0
        public static void TestInEquality_OneIsNull()
        {
            ChessPiece piece1 = new ChessPiece(Piece.Rook, Player.White);
            ChessPiece piece2 = null;
            Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
            Assert.False(piece1.Equals(piece2), "piece1.Equals(piece2) should be false");
            Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
            Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
            Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
            Assert.True(piece2 != piece1, "piece2 != piece1 should be True");

            piece1 = null;
            piece2 = new ChessPiece(Piece.Bishop, Player.Black);
            Assert.AreNotEqual(piece1, piece2, "piece1 and piece2 are equal");
            Assert.False(piece2.Equals(piece1), "piece1.Equals(piece2) should be false");
            Assert.False(piece1 == piece2, "piece1 == piece2 should be false");
            Assert.False(piece2 == piece1, "piece2 == piece1 should be false");
            Assert.True(piece1 != piece2, "piece1 != piece2 should be True");
            Assert.True(piece2 != piece1, "piece2 != piece1 should be True");
        }
 void OnMouseDown()
 {
     if (spaceState == SpaceState.Open)
     {
         GameManager.currentInstance.MovePiece(this);
         GameManager.currentInstance.AdvanceGameState();
     }
     else if (spaceState == SpaceState.Contested)
     {
         if (this.OccupyingPiece != null) {
             GameManager.currentInstance.RemovePiece(this.OccupyingPiece);   //default capture case
         }
         else if (Pawn.EnPassantPossible) {
              BoardSpace enPassantSpace = GameManager.currentInstance.Board.getAdjacentSpace(this, SpaceDirection.Back, GameManager.currentInstance.activePiece.PieceColor,false);
              GameManager.currentInstance.RemovePiece(enPassantSpace.OccupyingPiece);
         }
         GameManager.currentInstance.MovePiece(this);
         OccupyingPiece = GameManager.currentInstance.activePiece;
         GameManager.currentInstance.AdvanceGameState();
     }
 }
        public List<Tuple<int, int>[]> GetRelativePaths(ChessPiece p)
        {
            int direction = p.Direction;

            var l = new List<Tuple<int, int>>();
            var lResult = new List<Tuple<int, int>[]>();

            for (int i = 1; i < 8; i++)
            {
                l.Add(new Tuple<int, int>(direction * i, 0));
            }

            lResult.Add(l.ToArray());
            l.Clear();
            
            for (int i = 1; i < 8; i++)
            {
                l.Add(new Tuple<int, int>(direction * i * -1, 0));
            }

            lResult.Add(l.ToArray());
            l.Clear();

            for (int i = 1; i < 8; i++)
            {
                l.Add(new Tuple<int, int>(0, -1 * i));
            }

            lResult.Add(l.ToArray());
            l.Clear();

            for (int i = 1; i < 8; i++)
            {
                l.Add(new Tuple<int, int>(0, 1 * i));
            }

            lResult.Add(l.ToArray());

            return lResult;
        }
Beispiel #31
0
 public void SetContainedPiece(ChessPiece piece)
 {
     containedPiece = piece;
 }
Beispiel #32
0
    /// <summary>
    /// This method is used to determine the situation on the board after each move.
    /// The king has to know what has moved and how is this affecting him.
    /// </summary>
    public void UpdateKingsCurrentState()
    {
        movesInCheck = new bool[8, 8];
        bool[,] possitionsToBreakCheck = new bool[8, 8];
        army          = new List <ChessPiece>();
        IsKingInCheck = false;
        ChessPiece causeOfCheck = null;

        BoardVisualEffects.Instance.HideKingVisuals();
        PossibleMoves();

        for (int i = 0; i < BoardManager.BOARD_SIZE; i++)
        {
            for (int j = 0; j < BoardManager.BOARD_SIZE; j++)
            {
                ChessPiece piece = BoardManager.Instance.ChessBoardArr[i, j];
                if (piece != null)
                {
                    if (piece.IsWhite != IsWhite)
                    {
                        bool[,] pieceCheckPositions = piece.GetCheckPositions();
                        if (pieceCheckPositions[CurrentX, CurrentY])
                        {
                            //in check
                            BoardVisualEffects.Instance.DisplayKingInCheck(CurrentX, CurrentY);
                            IsKingInCheck          = true;
                            causeOfCheck           = piece;
                            possitionsToBreakCheck = GetCheckPossitionsToKing(causeOfCheck);
                        }

                        for (int x = 0; x < BoardManager.BOARD_SIZE; x++)
                        {
                            for (int y = 0; y < BoardManager.BOARD_SIZE; y++)
                            {
                                if (pieceCheckPositions[x, y] == true)
                                {
                                    if (pieceCheckPositions[x, y] == legalMoves[x, y])
                                    {
                                        if (movesInCheck[x, y] != true)
                                        {
                                            movesInCheck[x, y] = true;
                                            numberOfPossibleMoves--;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        army.Add(piece);
                    }
                }
            }
        }
        if (numberOfPossibleMoves == 0 && IsKingInCheck)
        {
            //if any of the King's pieces can hit the enemy causing the check => King is not yet dead!
            bool kingIsStillAlive = false;

            foreach (ChessPiece p in army)
            {
                bool[,] possibleMoves = p.PossibleMoves();

                for (int x = 0; x < BoardManager.BOARD_SIZE; x++)
                {
                    for (int y = 0; y < BoardManager.BOARD_SIZE; y++)
                    {
                        if ((possibleMoves[causeOfCheck.CurrentX, causeOfCheck.CurrentY]) ||
                            (possitionsToBreakCheck[x, y]))
                        {
                            kingIsStillAlive = true;
                            break;
                        }
                    }
                }
            }
            if (!kingIsStillAlive)
            {
                CheckMate();    // weeell... at least we tried
            }
        }
    }
Beispiel #33
0
    private void MoveChessPiece(int x, int y)
    {
        if (allowedMoves[x, y])
        {
            ChessPiece enemyPiece = ChessPiecePositions[x, y];

            if (enemyPiece != null && enemyPiece.isLight != isLightTurn)
            {
                piecesActive.Remove(enemyPiece.gameObject);
                Destroy(enemyPiece.gameObject);

                if (enemyPiece.GetType() == typeof(King))
                {
                    selectedPiece.transform.position = GetTileCenter(x, y);
                    EndGame();
                    return;
                }
            }

            if (x == EnPassantMove[0] && y == EnPassantMove[1])
            {
                if (isLightTurn)
                {
                    enemyPiece = ChessPiecePositions[x, y - 1];
                }
                else
                {
                    enemyPiece = ChessPiecePositions[x, y + 1];
                }

                piecesActive.Remove(enemyPiece.gameObject);
                Destroy(enemyPiece.gameObject);
            }
            EnPassantMove[0] = -1;
            EnPassantMove[1] = -1;
            if (selectedPiece.GetType() == typeof(Pawn))
            {
                if (y == 7) // белая пешка в ферзя
                {
                    piecesActive.Remove(selectedPiece.gameObject);
                    Destroy(selectedPiece.gameObject);
                    SpawnChessPiece(1, x, y);
                    selectedPiece = ChessPiecePositions[x, y];
                }
                else if (y == 0) // черная пешка в ферзя
                {
                    piecesActive.Remove(selectedPiece.gameObject);
                    Destroy(selectedPiece.gameObject);
                    SpawnChessPiece(7, x, y);
                    selectedPiece = ChessPiecePositions[x, y];
                }
                // взятие на проходе
                EnPassantMove[0] = x;
                if (selectedPiece.CurrentY == 1 && y == 3)
                {
                    EnPassantMove[1] = y - 1;
                }
                else if (selectedPiece.CurrentY == 6 && y == 4)
                {
                    EnPassantMove[1] = y + 1;
                }
            }

            ChessPiecePositions[selectedPiece.CurrentX, selectedPiece.CurrentY] = null;
            ChessPiecePositions[x, y]        = selectedPiece;
            selectedPiece.transform.position = GetTileCenter(x, y);
            selectedPiece.SetPosition(x, y);
            isLightTurn = !isLightTurn;
        }

        BoardHighlighting.Instance.HideHighlights();
        selectedPiece = null;
    }
        public override ReadOnlyCollection <Move> GetCandidateMoves(BoardState board, ChessPiece piece)
        {
            List <Move> CandidateMoves = new List <Move>();

            if (!piece.HasMoved)
            {
                ReadOnlyCollection <Tile> CandidateTiles = GetCandidateTiles(board, piece);
                foreach (Tile Tile in CandidateTiles)
                {
                    if (piece is IEnPassantable)
                    {
                        CandidateMoves.Add(new EnPassantableStartingMove(board[piece.Row, piece.Column], Tile));
                    }
                    else
                    {
                        CandidateMoves.Add(new MovementMove(board[piece.Row, piece.Column], Tile));
                    }
                }
            }
            return(CandidateMoves.AsReadOnly());
        }
Beispiel #35
0
 public bool DidMovePiece(ChessPiece piece, Location destination)
 {
     return(false);
 }
    /** Check if the specified piece can legally be moved the specified change in tiles. */
    public static bool CanMovePiece(ChessPiece chessPiece, IntVector2 deltaTiles)
    {
        // FEATURE add a method that returns the reason for false
        // UNITTEST
        if (deltaTiles.IsZero())
        {
            return(false);
        }
        switch (chessPiece.pieceType)
        {
        case ChessPiece.PieceType.PAWN:
            // Pawn normally only moves vertically
            if (!deltaTiles.IsVertical())
            {
                return(false);
            }
            // Cannot move more than two tiles
            if (deltaTiles.stepMagnitude > 2)
            {
                return(false);
            }
            // Make sure the pawn is allowed to move two if it is trying to
            if (deltaTiles.stepMagnitude == 2)
            {
                if (!currentRuleSet.pawnCanMoveTwoOnFirstMove || chessPiece.movementsMade > 0)
                {
                    return(false);
                }
            }
            // Cannot move pawns backwards
            if (chessPiece.pieceColor == ChessPiece.PieceColor.WHITE)
            {
                if (deltaTiles.y < 0)
                {
                    return(false);
                }
            }
            else
            {
                if (deltaTiles.y > 0)
                {
                    return(false);
                }
            }
            return(true);

        case ChessPiece.PieceType.BISHOP:
            return(deltaTiles.IsDiagonal());

        case ChessPiece.PieceType.KNIGHT:
            int dx = Mathf.Abs(deltaTiles.x);
            int dy = Mathf.Abs(deltaTiles.y);
            return((dx == 1 && dy == 2) || (dx == 2 && dy == 1));

        case ChessPiece.PieceType.ROOK:
            return(deltaTiles.IsHorizontal() || deltaTiles.IsVertical());

        case ChessPiece.PieceType.QUEEN:
            return(deltaTiles.IsDiagonal() || deltaTiles.IsHorizontal() || deltaTiles.IsVertical());

        case ChessPiece.PieceType.KING:
            return(deltaTiles.IsInUnitForm());

        default:
            Debug.LogWarning("Unhandled chess piece type. Value:" + (int)chessPiece.pieceType);
            return(false);
        }
    }
 public static bool IsEnPassantPossible(ChessPiece attackingPiece, ChessPiece defendingPiece, ChessBoard chessBoard)
 {
     // TODO implement
     return(false);
 }
    private static bool IsPathClearRecursive(ChessPiece chessPiece, IntVector2 targetCoordinates, ChessBoard chessBoard)
    {
        // FEATURE add a method that returns the reason for false
        IntVector2 startCoords = chessBoard.GetTileCoordinates(chessPiece);
        IntVector2 deltaTiles  = targetCoordinates - startCoords;
        ChessPiece pieceAt     = chessBoard.GetChessPieceAt(targetCoordinates);

        // If the target is occupied, we cannot move through it
        if (pieceAt != null)
        {
            Debug.Log(pieceAt);
            return(false);
        }
        IntVector2 newTarget = IntVector2.zero;

        // Check if the path up to the target is clear
        switch (chessPiece.pieceType)
        {
        case ChessPiece.PieceType.PAWN:
            // Handled completely in the non-recursive portion
            return(true);

        case ChessPiece.PieceType.BISHOP:
            if (deltaTiles.IsInUnitForm())
            {
                return(true);
            }
            newTarget = targetCoordinates;
            if (deltaTiles.y > 0)
            {
                newTarget.y -= 1;
            }
            else
            {
                newTarget.y += 1;
            }
            if (deltaTiles.x > 0)
            {
                newTarget.x -= 1;
            }
            else
            {
                newTarget.x += 1;
            }
            return(IsPathClearRecursive(chessPiece, newTarget, chessBoard));

        case ChessPiece.PieceType.KNIGHT:
            // Handled completely in the non-recursive portion
            return(true);

        case ChessPiece.PieceType.ROOK:
            int moveDelta = deltaTiles.x + deltaTiles.y;
            if (Mathf.Abs(moveDelta) != 1)
            {
                newTarget = targetCoordinates;
                if (deltaTiles.IsHorizontal())
                {
                    if (moveDelta > 0)
                    {
                        newTarget.x -= 1;
                    }
                    else
                    {
                        newTarget.x += 1;
                    }
                }
                else
                {
                    if (moveDelta > 0)
                    {
                        newTarget.y -= 1;
                    }
                    else
                    {
                        newTarget.y += 1;
                    }
                }
                return(IsPathClearRecursive(chessPiece, newTarget, chessBoard));
            }
            return(true);

        case ChessPiece.PieceType.QUEEN:
            if (deltaTiles.IsInUnitForm())
            {
                return(true);
            }
            newTarget = targetCoordinates;
            if (deltaTiles.IsDiagonal())
            {
                if (deltaTiles.y > 0)
                {
                    newTarget.y -= 1;
                }
                else
                {
                    newTarget.y += 1;
                }
                if (deltaTiles.x > 0)
                {
                    newTarget.x -= 1;
                }
                else
                {
                    newTarget.x += 1;
                }
            }
            else if (deltaTiles.IsHorizontal() || deltaTiles.IsVertical())
            {
                moveDelta = deltaTiles.x + deltaTiles.y;
                if (deltaTiles.IsHorizontal())
                {
                    if (moveDelta > 0)
                    {
                        newTarget.x -= 1;
                    }
                    else
                    {
                        newTarget.x += 1;
                    }
                }
                else
                {
                    if (moveDelta > 0)
                    {
                        newTarget.y -= 1;
                    }
                    else
                    {
                        newTarget.y += 1;
                    }
                }
            }
            return(IsPathClearRecursive(chessPiece, newTarget, chessBoard));

        case ChessPiece.PieceType.KING:
            // Handled completely in the non-recursive portion
            return(true);

        default:
            Debug.LogWarning("Unhandled chess piece type. Value:" + (int)chessPiece.pieceType);
            return(false);
        }
    }
    /** Check if the piece would encounter other pieces it cannot pass over while moving to the specified tile.
     * This method should only be called with verified legal target coordinates; illegal movement will return a
     * meaningless/undefined result. Legal coordinates are coordinates within the board that return true for
     * CanMovePiece(ChessPiece chessPiece, Vector2 deltaTiles).
     */
    public static bool IsPathClear(ChessPiece chessPiece, IntVector2 targetCoordinates, ChessBoard chessBoard)
    {
        // TODO implement
        // FEATURE add a method that returns the reason for false
        IntVector2 startCoords = chessBoard.GetTileCoordinates(chessPiece);
        IntVector2 deltaTiles  = targetCoordinates - chessBoard.GetTileCoordinates(chessPiece);
        ChessPiece pieceAt     = chessBoard.GetChessPieceAt(targetCoordinates);

        // Cannot move to a space if it is occupied by a piece of the same color
        if (pieceAt != null && pieceAt.pieceColor == chessPiece.pieceColor)
        {
            return(false);
        }
        int        moveDelta = 0;
        IntVector2 newTarget = IntVector2.zero;

        switch (chessPiece.pieceType)
        {
        case ChessPiece.PieceType.PAWN:
            moveDelta = deltaTiles.y;
            if (Mathf.Abs(moveDelta) == 2)
            {
                if (moveDelta > 0)
                {
                    if (chessBoard.GetChessPieceAt(startCoords.x, startCoords.y + 1) != null)
                    {
                        return(false);
                    }
                }
                else
                {
                    if (chessBoard.GetChessPieceAt(startCoords.x, startCoords.y - 1) != null)
                    {
                        return(false);
                    }
                }
            }
            return(pieceAt == null);

        case ChessPiece.PieceType.BISHOP:
            if (deltaTiles.IsInUnitForm())
            {
                return(true);
            }
            newTarget = targetCoordinates;
            if (deltaTiles.y > 0)
            {
                newTarget.y -= 1;
            }
            else
            {
                newTarget.y += 1;
            }
            if (deltaTiles.x > 0)
            {
                newTarget.x -= 1;
            }
            else
            {
                newTarget.x += 1;
            }
            return(IsPathClearRecursive(chessPiece, newTarget, chessBoard));

        case ChessPiece.PieceType.KNIGHT:
            // The knight does not have to pass through intermediate tiles, so if it got this far it can move there
            return(true);

        case ChessPiece.PieceType.ROOK:
            moveDelta = deltaTiles.x + deltaTiles.y;
            if (Mathf.Abs(moveDelta) != 1)
            {
                newTarget = targetCoordinates;
                if (deltaTiles.IsHorizontal())
                {
                    if (moveDelta > 0)
                    {
                        newTarget.x -= 1;
                    }
                    else
                    {
                        newTarget.x += 1;
                    }
                }
                else
                {
                    if (moveDelta > 0)
                    {
                        newTarget.y -= 1;
                    }
                    else
                    {
                        newTarget.y += 1;
                    }
                }
                return(IsPathClearRecursive(chessPiece, newTarget, chessBoard));
            }
            return(true);

        case ChessPiece.PieceType.QUEEN:
            if (deltaTiles.IsInUnitForm())
            {
                return(true);
            }
            newTarget = targetCoordinates;
            if (deltaTiles.IsDiagonal())
            {
                if (deltaTiles.y > 0)
                {
                    newTarget.y -= 1;
                }
                else
                {
                    newTarget.y += 1;
                }
                if (deltaTiles.x > 0)
                {
                    newTarget.x -= 1;
                }
                else
                {
                    newTarget.x += 1;
                }
            }
            else if (deltaTiles.IsHorizontal() || deltaTiles.IsVertical())
            {
                moveDelta = deltaTiles.x + deltaTiles.y;
                if (deltaTiles.IsHorizontal())
                {
                    if (moveDelta > 0)
                    {
                        newTarget.x -= 1;
                    }
                    else
                    {
                        newTarget.x += 1;
                    }
                }
                else
                {
                    if (moveDelta > 0)
                    {
                        newTarget.y -= 1;
                    }
                    else
                    {
                        newTarget.y += 1;
                    }
                }
            }
            return(IsPathClearRecursive(chessPiece, newTarget, chessBoard));

        case ChessPiece.PieceType.KING:
            return(deltaTiles.IsInUnitForm());

        default:
            Debug.LogWarning("Unhandled chess piece type. Value:" + (int)chessPiece.pieceType);
            return(false);
        }
    }
Beispiel #40
0
        public void PlacePiece(Rank rank, File file, ChessPiece piece)
        {
            int square = SquareFromRankAndFile(rank, file);

            _squares[square].Piece = piece;
        }
 // assuming you create the set of pieces programatically, use this constructor
 public ChessPiece(ChessPiece piece, ChessColor color)
 {
     FenId = color == ChessColor.Black
             ? FenIds[piece].ToLower()
             : FenIds[piece].ToUpper();
 }
    public static bool TestRand(ref string[][] generatedPairs, int Sign, int MyModuleId, out string BoardString)
    {
        BoardString = "";
        try {
            string[] RandPieces = new string[6];
            string   TestString = "";
            int      ji         = 0;
            while (ji < 6)
            {
                string temp = (char)(UnityEngine.Random.Range(0, 6) + 'a') + "" + (UnityEngine.Random.Range(0, 6) + 1);
                if (!TestString.Contains(temp))
                {
                    RandPieces[ji] = temp;
                    TestString    += temp;
                    ji++;
                }
            }
            BoardState[,] chessBoard = new BoardState[6, 6];
            ChessPiece[] myPieces;
            for (int i = 0; i < 6; i++)
            {
                for (int j = 0; j < 6; j++)
                {
                    chessBoard[i, j] = BoardState.Empty;
                }
            }

            myPieces    = new ChessPiece[6];
            myPieces[1] = new ChessPiece((RandPieces[1][0]) - 'a', (RandPieces[1][1]) - '1', (Sign == 0 ? ChessPieceType.Knight : ChessPieceType.Rook), ref chessBoard);
            myPieces[3] = new ChessPiece(RandPieces[3][0] - 'a', RandPieces[3][1] - '1', ChessPieceType.Rook, ref chessBoard);
            if (ChessPiece.getWhite(RandPieces[4][0] - 'a', RandPieces[4][1] - '1'))
            {
                myPieces[4] = new ChessPiece(RandPieces[4][0] - 'a', RandPieces[4][1] - '1', ChessPieceType.Queen, ref chessBoard);
                myPieces[0] = new ChessPiece(RandPieces[0][0] - 'a', RandPieces[0][1] - '1', ChessPieceType.King, ref chessBoard);
            }
            else
            {
                myPieces[4] = new ChessPiece(RandPieces[4][0] - 'a', RandPieces[4][1] - '1', ChessPieceType.Rook, ref chessBoard);
                myPieces[0] = new ChessPiece(RandPieces[0][0] - 'a', RandPieces[0][1] - '1', ChessPieceType.Bishop, ref chessBoard);
            }

            if (Sign == 1 || myPieces[4].piece == ChessPieceType.Rook)
            {
                myPieces[2] = new ChessPiece(RandPieces[2][0] - 'a', RandPieces[2][1] - '1', ChessPieceType.King, ref chessBoard);
            }
            else
            {
                myPieces[2] = new ChessPiece(RandPieces[2][0] - 'a', RandPieces[2][1] - '1', ChessPieceType.Queen, ref chessBoard);
            }

            bool hasQueen  = false;
            bool hasKnight = false;
            for (int i = 0; i < 5; i++)
            {
                if (myPieces[i].piece == ChessPieceType.Queen)
                {
                    hasQueen = true;
                }
                if (myPieces[i].piece == ChessPieceType.Knight)
                {
                    hasKnight = true;
                }
            }
            if (!hasQueen)
            {
                myPieces[5] = new ChessPiece(RandPieces[5][0] - 'a', RandPieces[5][1] - '1', ChessPieceType.Queen, ref chessBoard);
            }
            else if (!hasKnight)
            {
                myPieces[5] = new ChessPiece(RandPieces[5][0] - 'a', RandPieces[5][1] - '1', ChessPieceType.Knight, ref chessBoard);
            }
            else
            {
                myPieces[5] = new ChessPiece(RandPieces[5][0] - 'a', RandPieces[5][1] - '1', ChessPieceType.Bishop, ref chessBoard);
            }
            foreach (ChessPiece i in myPieces)
            {
                i.getTouchable(ref chessBoard);
            }

            int           empty    = 0;
            List <string> emptyArr = new List <string>();
            for (int i = 5; i >= 0 && empty < 2; i--)
            {
                for (int j = 0; j < 6 && empty < 2; j++)
                {
                    if (chessBoard[j, i] == BoardState.Empty)
                    {
                        empty++;
                        emptyArr.Add((char)(j + 'a') + "" + (i + 1));
                    }
                }
            }
            if (empty == 1)
            {
                for (int i = 0; i < 6; i++)
                {
                    generatedPairs[Sign][i] = RandPieces[i];
                }
                generatedPairs[Sign][6] = emptyArr[0];
                int[] Numbers = new int[6];
                int   SolutionNumber;
                {
                    string s1 = generatedPairs[Sign][6];
                    SolutionNumber = ((s1[0] - 'a')) + 6 * (s1[1] - '1');
                    for (int i = 0; i < 6; i++)
                    {
                        s1         = generatedPairs[Sign][i];
                        Numbers[i] = ((s1[0] - 'a')) + 6 * (s1[1] - '1');
                    }
                }
                StringBuilder s = new StringBuilder("┌───┬───┬───┬───┬───┬───┐");

                for (int i = 0; i < 11; i++)
                {
                    s.Append("\n");
                    if (i % 2 == 0)
                    {
                        int v = 5 - (i / 2);
                        for (int j = 0; j < 6; j++)
                        {
                            s.Append("│");
                            int o = Array.FindIndex(Numbers, x => x == v * 6 + j);
                            s.Append(" ");
                            if (o != -1)
                            {
                                ChessPieceType c         = myPieces[o].piece;
                                char           pieceChar = ' ';
                                switch (c)
                                {
                                case ChessPieceType.Bishop:
                                    pieceChar = 'B';
                                    break;

                                case ChessPieceType.King:
                                    pieceChar = 'K';
                                    break;

                                case ChessPieceType.Queen:
                                    pieceChar = 'Q';
                                    break;

                                case ChessPieceType.Knight:
                                    pieceChar = 'N';
                                    break;

                                case ChessPieceType.Rook:
                                    pieceChar = 'R';
                                    break;
                                }
                                s.Append(pieceChar);
                            }
                            else
                            {
                                if (v * 6 + j == SolutionNumber)
                                {
                                    s.Append('×');
                                }
                                else
                                {
                                    s.Append(" ");
                                }
                            }
                            s.Append(" ");
                        }
                        s.Append("│");
                    }
                    else
                    {
                        s.Append("├───┼───┼───┼───┼───┼───┤");
                    }
                }
                s.Append("\n");
                s.Append("└───┴───┴───┴───┴───┴───┘");


                BoardString = s.ToString();

                return(true);
            }
        }catch (UnityException e) {
            Debug.Log("[Chess #" + MyModuleId + "] TestRand exception: " + e.Message);
        }
        return(false);
    }
Beispiel #43
0
        public override ReadOnlyCollection <Move> GetCandidateMoves(BoardState board, ChessPiece piece)
        {
            ReadOnlyCollection <Tile> CandidateTiles = GetCandidateTiles(board, piece);

            List <Move> CandidateMoves = new List <Move>();

            foreach (Tile tile in CandidateTiles)
            {
                CandidateMoves.Add(new BasicCaptureMove(board[piece.Row, piece.Column], tile));
            }
            return(CandidateMoves.AsReadOnly());
        }
Beispiel #44
0
        /*
         *  @InsertNewPiece -> Funcao de suporte para facilitar a insercao de novas pecas no tabuleiro
         *   a partir da partida atual
         */

        public void InsertNewPiece(char column, int line, ChessPiece piece)
        {
            Board.InsertPiece(piece, new ChessPosition(column, line).ToChessPosition());
            Pieces.Add(piece);
        }
Beispiel #45
0
        public void PrintBoard()
        {
            chessboard = new string[xValue, yValue];
            chessPiece = new ChessPiece();

            while (endProgram == false)
            {
                System.Console.Clear();
                ChessBoardHeader();
                try
                {
                    for (int rowX = 0; rowX < xValue; rowX++)
                    {
                        //Indent
                        System.Console.Write(("").PadRight(5));

                        for (int columnY = 0; columnY < yValue; columnY++)
                        {
                            //Draw Rows
                            System.Console.Write(rowBorder);
                        }
                        System.Console.Write("+\n");

                        for (int columnY = 0; columnY < yValue; columnY++)
                        {
                            if (columnY == 0)
                            {
                                // Y-Axis Header + Indent
                                System.Console.Write((((rowX + 1).ToString().PadLeft(4)) + " ").PadRight(3));
                            }
                            else
                            {
                                //System.Console.Write(" ");
                            }
                            System.Console.Write((columnBorder).PadRight(2));
                            //Print Symbol or Space?
                            System.Console.Write((ChessPiece.chessPiece[rowX, columnY]).PadLeft(1).PadRight(2));
                        }
                        //End of Column
                        System.Console.Write(("|\n").PadLeft(2));
                    }


                    System.Console.Write((" ").PadRight(5));
                    for (int columnY = 0; columnY < yValue; columnY++)
                    {
                        System.Console.Write((rowBorder));
                    }
                    System.Console.Write("+\n\n");
                    System.Console.WriteLine();
                    chessPiece.MovePiece();
                    if (endProgram == true)
                    {
                        break;
                    }
                    if (endProgram == false)
                    {
                        continue;
                    }
                }
                //commit test
                catch
                {
                }
            }
        }
Beispiel #46
0
        private bool CanMove(Position position)
        {
            ChessPiece cp = Chessboard.ChessPiece(position);

            return(cp == null || cp.Color != Color);
        }
 public void OnSelect(ChessPiece piece)
 {
     SelectPiece = piece;
 }
Beispiel #48
0
    private void MovePiece(int x, int y)
    {
        if (allowedMoves[x, y])
        {
            // Get the piece in the destination tile
            ChessPiece piece = Board[x, y];

            // If there is a piece at this place and it is not on our team
            if (piece != null && piece.isWhite != isWhiteTurn)
            {
                // Capture the piece

                // If it's the king
                if (piece.GetType() == typeof(King))
                {
                    EndGame(false);
                    return;
                }

                activeChessPieces.Remove(piece.gameObject);
                Destroy(piece.gameObject);
            }

            // If it was an EnPassantMove
            if (x == EnPassantMove[0] && y == EnPassantMove[1])
            {
                if (isWhiteTurn)
                {
                    piece = Board[x, y - 1];
                }
                else
                {
                    piece = Board[x, y + 1];
                }

                activeChessPieces.Remove(piece.gameObject);
                Destroy(piece.gameObject);
            }

            // Reset the EnPassantMove before calculating it
            EnPassantMove[0] = -1;
            EnPassantMove[1] = -1;

            // If we are moving a pawn, calculate EnPassantMove
            if (selectedPiece.GetType() == typeof(Pawn))
            {
                if (y == 7)
                {
                    // If white has reached the top, promote it
                    activeChessPieces.Remove(selectedPiece.gameObject);
                    Destroy(selectedPiece.gameObject);
                    SpawnChessPiece(10, x, y);
                    selectedPiece = Board[x, y];
                }
                else if (y == 0)
                {
                    // if black has reached the bottom, promote it
                    activeChessPieces.Remove(selectedPiece.gameObject);
                    Destroy(selectedPiece.gameObject);
                    SpawnChessPiece(4, x, y);
                    selectedPiece = Board[x, y];
                }

                if (selectedPiece.CurrentY == 1 && y == 3)
                {
                    // set the black enPassantMove
                    EnPassantMove[0] = x;
                    EnPassantMove[1] = y - 1;
                }
                else if (selectedPiece.CurrentY == 6 && y == 4)
                {
                    // set the white enPassantMove
                    EnPassantMove[0] = x;
                    EnPassantMove[1] = y + 1;
                }
            }

            // Remove the piece from the grid's current position
            Board[selectedPiece.CurrentX, selectedPiece.CurrentY] = null;
            // Move the object
            StartCoroutine(MovePiece(selectedPiece.transform.localPosition, GetPosition(x, y), selectedPiece.transform));
            selectedPiece.SetPosition(x, y);
            // Move the piece on the virtual board
            Board[x, y] = selectedPiece;
            // Swap turns
            isWhiteTurn = !isWhiteTurn;
        }

        // Hide the highlights after the movement
        BoardHighlights.Instance.Hidehighlights();
        // Deselect the piece after the movement
        selectedPiece = null;
    }
Beispiel #49
0
    public List <GridSquare> getMoves(GridSquare g)
    {
        ChessPiece        piece         = g.getPiece();
        int               curRow        = g.getRow();
        int               curCol        = g.getCol();
        List <GridSquare> possibleMoves = new List <GridSquare>();
        Dictionary <MoveType, List <MoveOffset> > offsetMap = new Dictionary <MoveType, List <MoveOffset> >();
        Player     friendly      = (whiteTurn ? whitePlayer : blackPlayer);
        Player     enemy         = (whiteTurn ? blackPlayer : whitePlayer);
        Player     playerOfPiece = g.getPlayer();
        GridSquare candidateMove;
        Player     candidatePlayer;

        // add the move types of the piece to the map
        offsetMap.Add(MoveType.UP, piece.getUpMoveOffsets());
        offsetMap.Add(MoveType.DOWN, piece.getDownMoveOffsets());
        offsetMap.Add(MoveType.RIGHT, piece.getRightMoveOffsets());
        offsetMap.Add(MoveType.LEFT, piece.getLeftMoveOffsets());
        offsetMap.Add(MoveType.DIAG_NE, piece.getNEDiagMoveOffsets());
        offsetMap.Add(MoveType.DIAG_NW, piece.getNWDiagMoveOffsets());
        offsetMap.Add(MoveType.DIAG_SW, piece.getSWDiagMoveOffsets());
        offsetMap.Add(MoveType.DIAG_SE, piece.getSEDiagMoveOffsets());

        // handle the knights separately for simplicitly
        if (piece is Knight)
        {
            foreach (MoveOffset offset in piece.getKnightMoveOffsets())
            {
                int moveRow = curRow + offset.getRow();
                int moveCol = curCol + offset.getCol();

                if (boundaryCheck(moveRow, moveCol))
                {
                    candidateMove   = grid[moveRow, moveCol];
                    candidatePlayer = candidateMove.getPlayer();

                    if (candidatePlayer == null || candidatePlayer == enemy)
                    {
                        possibleMoves.Add(candidateMove);
                    }

                    if (candidatePlayer == null)
                    {
                        candidateMove.markOpenPath();
                    }

                    if (candidatePlayer == enemy)
                    {
                        candidateMove.markEnemy();
                    }
                }
            }

            // we do not need to consider the other move types
            return(possibleMoves);
        }

        // add pawn attacking moves to possibleMoves
        if (piece is Pawn)
        {
            // check the possible attacking pawn moves
            foreach (MoveOffset offset in piece.getSpecialMoveOffsets())
            {
                int moveRow = curRow + offset.getRow();
                int moveCol = curCol + offset.getCol();

                // black pawns move down the board
                if (playerOfPiece == blackPlayer)
                {
                    // so we need to correct the row offset
                    moveRow = curRow - offset.getRow();
                }

                // add the offseted square to the list of possible moves if
                // it contains an enemy
                if (boundaryCheck(moveRow, moveCol))
                {
                    candidateMove   = grid[moveRow, moveCol];
                    candidatePlayer = candidateMove.getPlayer();

                    if (candidatePlayer == enemy)
                    {
                        possibleMoves.Add(candidateMove);
                        candidateMove.markEnemy();
                    }
                }
            }
        }

        // iterate through the non-special move types
        foreach (KeyValuePair <MoveType, List <MoveOffset> > kvp in offsetMap)
        {
            MoveType          moveType        = kvp.Key;
            List <MoveOffset> possibleOffsets = kvp.Value;

            foreach (MoveOffset offset in possibleOffsets)
            {
                int moveRow = curRow + offset.getRow();
                int moveCol = curCol + offset.getCol();

                // black pawns move down the board
                if (piece is Pawn && playerOfPiece == blackPlayer)
                {
                    // so we need to correct the row offset
                    moveRow = curRow - offset.getRow();
                }

                if (!boundaryCheck(moveRow, moveCol))   // invalid square
                // All squares beyond this square are also invalid.
                // This isn't true in the case of a knight, so it is
                // considered separately.
                {
                    break;
                }

                candidateMove   = grid[moveRow, moveCol];
                candidatePlayer = candidateMove.getPlayer();

                if (candidatePlayer == null)
                {
                    possibleMoves.Add(candidateMove);
                    candidateMove.markOpenPath();
                }
                else if (candidatePlayer == enemy)
                {
                    // when moving upwards, everything except the pawn can take a piece
                    if (!(piece is Pawn))
                    {
                        possibleMoves.Add(candidateMove);
                        candidateMove.markEnemy();
                    }

                    break;
                }
                else     // friendly piece
                {
                    break;
                }
            }
        }

        return(possibleMoves);
    }
Beispiel #50
0
        public override bool IsLegalMove(Move move, ChessGame game)
        {
            ChessUtility.ThrowIfNull(move, "move");
            ChessUtility.ThrowIfNull(game, "game");
            BoardPosition origin      = move.OriginalPosition;
            BoardPosition destination = move.NewPosition;

            ChessPiece promotion = null;

            if (move.Promotion.HasValue && ValidPromotionPieces.Contains(move.Promotion.Value))
            {
                promotion = game.MapPgnCharToPiece(char.ToUpper(move.Promotion.Value), move.Player);
            }
            BoardDistance posDelta = new BoardDistance(origin, destination);

            if ((posDelta.X != 0 || posDelta.Y != 1) && (posDelta.X != 1 || posDelta.Y != 1) &&
                (posDelta.X != 0 || posDelta.Y != 2))
            {
                return(false);
            }
            if (Owner == ChessPlayer.White)
            {
                if (origin.Rank > destination.Rank)
                {
                    return(false);
                }
                if (destination.Rank == 8)
                {
                    if (promotion == null)
                    {
                        return(false);
                    }
                    if (promotion.Owner != ChessPlayer.White)
                    {
                        return(false);
                    }
                    if (!ValidPromotionPieces.Contains(promotion.GetFENLetter()))
                    {
                        return(false);
                    }
                }
            }
            if (Owner == ChessPlayer.Black)
            {
                if (origin.Rank < destination.Rank)
                {
                    return(false);
                }
                if (destination.Rank == 1)
                {
                    if (promotion == null)
                    {
                        return(false);
                    }
                    if (promotion.Owner != ChessPlayer.Black)
                    {
                        return(false);
                    }
                    if (!ValidPromotionPieces.Contains(promotion.GetFENLetter()))
                    {
                        return(false);
                    }
                }
            }
            bool checkEnPassant = false;

            if (posDelta.Y == 2)
            {
                if ((origin.Rank != 2 && Owner == ChessPlayer.White) ||
                    (origin.Rank != 7 && Owner == ChessPlayer.Black))
                {
                    return(false);
                }
                if (origin.Rank == 2 && game.GetPieceAt(origin.File, 3) != null)
                {
                    return(false);
                }
                if (origin.Rank == 7 && game.GetPieceAt(origin.File, 6) != null)
                {
                    return(false);
                }
            }
            ChessPiece pieceAtDestination = game.GetPieceAt(destination);

            if (posDelta.X == 0 && (posDelta.Y == 1 || posDelta.Y == 2))
            {
                if (pieceAtDestination != null)
                {
                    return(false);
                }
            }
            else
            {
                if (pieceAtDestination == null)
                {
                    checkEnPassant = true;
                }
                else if (pieceAtDestination.Owner == Owner)
                {
                    return(false);
                }
            }
            if (checkEnPassant)
            {
                ReadOnlyCollection <DetailedMove> _moves = game.Moves;
                if (_moves.Count == 0)
                {
                    return(false);
                }
                if ((origin.Rank != 5 && Owner == ChessPlayer.White) ||
                    (origin.Rank != 4 && Owner == ChessPlayer.Black))
                {
                    return(false);
                }
                Move latestMove = _moves[_moves.Count - 1];
                if (latestMove.Player != ChessUtility.GetOpponentOf(Owner))
                {
                    return(false);
                }
                if (!(game.GetPieceAt(latestMove.NewPosition) is Pawn))
                {
                    return(false);
                }
                if (game.GetPieceAt(latestMove.NewPosition).Owner == Owner)
                {
                    return(false);
                }
                if (Owner == ChessPlayer.White)
                {
                    if (latestMove.OriginalPosition.Rank != 7 || latestMove.NewPosition.Rank != 5)
                    {
                        return(false);
                    }
                }
                else // (m.Player == Players.Black)
                {
                    if (latestMove.OriginalPosition.Rank != 2 || latestMove.NewPosition.Rank != 4)
                    {
                        return(false);
                    }
                }
                if (destination.File != latestMove.NewPosition.File)
                {
                    return(false);
                }
            }
            return(true);
        }
Beispiel #51
0
    private bool[,] GetCheckPossitionsToKing(ChessPiece checkPiece)
    {
        bool[,] result = new bool[8, 8];

        if (checkPiece.GetType() != typeof(Knight))
        {
            if (checkPiece.CurrentX == CurrentX)                //vertical
            {
                if (checkPiece.CurrentY > CurrentY)
                {
                    for (int y = checkPiece.CurrentY - 1; y > CurrentY; y--)
                    {
                        result [CurrentX, y] = true;
                    }
                }
                else
                {
                    for (int y = checkPiece.CurrentY + 1; y < CurrentY; y++)
                    {
                        result [CurrentX, y] = true;
                    }
                }
            }
            else if (checkPiece.CurrentY == CurrentY)                   //horizontal
            {
                if (checkPiece.CurrentX > CurrentX)
                {
                    for (int x = checkPiece.CurrentX - 1; x > CurrentX; x--)
                    {
                        result [x, CurrentY] = true;
                    }
                }
                else
                {
                    for (int x = checkPiece.CurrentX + 1; x < CurrentX; x++)
                    {
                        result [x, CurrentY] = true;
                    }
                }
            }
            else                        //diagonal
            {
                int x = checkPiece.CurrentX, y = checkPiece.CurrentY;

                if (checkPiece.CurrentX > CurrentX && checkPiece.CurrentY > CurrentY)
                {
                    while (x - 1 > CurrentX && y - 1 > CurrentY)
                    {
                        result [--x, --y] = true;
                    }
                }
                else if (checkPiece.CurrentX > CurrentX && checkPiece.CurrentY < CurrentY)
                {
                    while (x - 1 > CurrentX && y + 1 < CurrentY)
                    {
                        result [--x, ++y] = true;
                    }
                }
                else if (checkPiece.CurrentX < CurrentX && checkPiece.CurrentY < CurrentY)
                {
                    while (x + 1 < CurrentX && y + 1 < CurrentY)
                    {
                        result [++x, ++y] = true;
                    }
                }
                else
                {
                    while (x + 1 < CurrentX && y - 1 > CurrentY)
                    {
                        result [++x, --y] = true;
                    }
                }
            }
        }

        return(result);
    }
Beispiel #52
0
        public Game()
        {
            //TODO: Setup board
            board = new ChessPiece[BOARD_WIDTH][];

            for (int i = 0; i < BOARD_WIDTH; i++)
            {
                board[i] = new ChessPiece[BOARD_HEIGHT];
            }

            turn = -1;

            /*Generate board*/

            /**Pawns**/
            //Black
            for (int i = 0; i < BOARD_WIDTH; i++)
            {
                board[i][1] = new Pawn(i, 1, 1);
            }
            //White
            for (int i = 0; i < BOARD_WIDTH; i++)
            {
                board[i][6] = new Pawn(i, 6, -1);
            }


            /**Rooks**/
            //Black
            board[0][0] = new Rook(0, 0, 1);
            board[BOARD_WIDTH - 1][0] = new Rook(BOARD_WIDTH - 1, 0, 1);

            //White
            board[0][BOARD_HEIGHT - 1] = new Rook(0, BOARD_HEIGHT - 1, -1);
            board[BOARD_WIDTH - 1][BOARD_HEIGHT - 1] = new Rook(BOARD_WIDTH - 1, BOARD_HEIGHT - 1, -1);


            /**Knights**/
            //Black
            board[1][0] = new Knight(1, 0, 1);
            board[BOARD_WIDTH - 2][0] = new Knight(BOARD_WIDTH - 2, 0, 1);

            //White
            board[1][BOARD_HEIGHT - 1] = new Knight(1, BOARD_HEIGHT - 1, -1);
            board[BOARD_WIDTH - 2][BOARD_HEIGHT - 1] = new Knight(BOARD_WIDTH - 2, BOARD_HEIGHT - 1, -1);


            /**Bishops**/
            //Black
            board[2][0] = new Bishop(2, 0, 1);
            board[BOARD_WIDTH - 3][0] = new Bishop(BOARD_WIDTH - 3, 0, 1);

            //White
            board[2][BOARD_HEIGHT - 1] = new Bishop(2, BOARD_HEIGHT - 1, -1);
            board[BOARD_WIDTH - 3][BOARD_HEIGHT - 1] = new Bishop(BOARD_WIDTH - 3, BOARD_HEIGHT - 1, -1);


            /**Kings**/
            //Black
            board[3][0] = new King(3, 0, 1);

            //White
            board[3][BOARD_HEIGHT - 1] = new King(3, BOARD_HEIGHT - 1, -1);

            /**Queens**/
            //Black
            board[4][0] = new Queen(4, 0, 1);

            //White
            board[4][BOARD_HEIGHT - 1] = new Queen(4, BOARD_HEIGHT - 1, -1);
        }
Beispiel #53
0
 public GameState(GameState gs)
 {
     chessboard  = (ChessPiece[, ])gs.chessboard.Clone();
     turn        = gs.turn;
     last_modify = (int[])gs.last_modify.Clone();
 }
    private void Update()
    {
        if (!currentCamera)
        {
            currentCamera = Camera.main;
            return;
        }

        RaycastHit info;
        Ray        ray = currentCamera.ScreenPointToRay(Input.mousePosition);

        if (Physics.Raycast(ray, out info, 100, LayerMask.GetMask("Tile", "Hover", "Highlight")))
        {
            // Get the indexes of a tile i've hit
            Vector2Int hitPosition = LookupTileIndex(info.transform.gameObject);

            // if we are hovring a tile after not hovring any tiles
            if (currentHover == -Vector2Int.one)
            {
                currentHover = hitPosition;
                tiles[hitPosition.x, hitPosition.y].layer = LayerMask.NameToLayer("Hover");
            }

            // if we were already hovring a tile, change the previous one
            if (currentHover != hitPosition)
            {
                tiles[currentHover.x, currentHover.y].layer = (ContainsValidMove(ref availableMoves, currentHover)) ? LayerMask.NameToLayer("Highlight") : LayerMask.NameToLayer("Tile");
                currentHover = hitPosition;
                tiles[hitPosition.x, hitPosition.y].layer = LayerMask.NameToLayer("Hover");
            }

            // if we press down on the mouse
            if (Input.GetMouseButtonDown(0))
            {
                if (chessPieces[hitPosition.x, hitPosition.y] != null)
                {
                    // Is it our turn
                    if ((chessPieces[hitPosition.x, hitPosition.y].team == 0 && isWhiteTurn) || (chessPieces[hitPosition.x, hitPosition.y].team == 1 && !isWhiteTurn))
                    {
                        currentlyDragging = chessPieces[hitPosition.x, hitPosition.y];

                        // Get a list of where i can go, highlights tile as well
                        availableMoves = currentlyDragging.GetAvailableMoves(ref chessPieces, TILE_COUNT_X, TILE_COUNT_Y);
                        HighlightTiles();
                    }
                }
            }
            // if we are releasing the mouse
            if (currentlyDragging != null && Input.GetMouseButtonUp(0))
            {
                Vector2Int previousPosition = new Vector2Int(currentlyDragging.currentX, currentlyDragging.currentY);


                bool validMove = MoveTo(currentlyDragging, hitPosition.x, hitPosition.y);
                if (!validMove)
                {
                    currentlyDragging.SetPosition(GetTileCenter(previousPosition.x, previousPosition.y));
                }

                currentlyDragging = null;
                RemoveHighlightTiles();
            }
        }
        else
        {
            if (currentHover != -Vector2Int.one)
            {
                tiles[currentHover.x, currentHover.y].layer = (ContainsValidMove(ref availableMoves, currentHover)) ? LayerMask.NameToLayer("Highlight") : LayerMask.NameToLayer("Tile");
                currentHover = -Vector2Int.one;
            }
            if (currentlyDragging && Input.GetMouseButtonUp(0))
            {
                currentlyDragging.SetPosition(GetTileCenter(currentlyDragging.currentX, currentlyDragging.currentY));
                currentlyDragging = null;
                RemoveHighlightTiles();
            }
        }
        // if we are dragging a piece
        if (currentlyDragging)
        {
            Plane horizontalPlane = new Plane(Vector3.up, Vector3.up * yoffset);
            float distance        = 0.0f;
            if (horizontalPlane.Raycast(ray, out distance))
            {
                currentlyDragging.SetPosition(ray.GetPoint(distance) + Vector3.up * dragOffset);
            }
        }
    }
Beispiel #55
0
 /// <summary>
 /// 得到另一位选手
 /// </summary>
 /// <param name="cp"></param>
 /// <returns></returns>
 public static ChessPiece AnotherPlayer(ChessPiece cp)
 {
     return(cp == ChessPiece.CROSS ? ChessPiece.NOUGHT : ChessPiece.CROSS);
 }
Beispiel #56
0
        /// <summary>
        /// Checks if the move from startPosition to endPosition is valid.
        /// Assumes that startPosition and endPosition are valid parameters.
        /// Returns false if there is no piece at startPosition, or the piece otherwise
        /// cannot complete the requested move.
        /// </summary>
        /// <param name="startPosition">The position of the piece to move.</param>
        /// <param name="endPosition">The destination of the piece.</param>
        /// <returns></returns>
        public bool IsMoveValid(Position startPosition, Position endPosition)
        {
            // Get piece at input location
            ChessPiece startPiece = board.PieceAt(startPosition);
            ChessPiece endPiece   = board.PieceAt(endPosition);

            // If there is no piece at the requested start position, return false
            if (startPiece == null)
            {
                return(false);
            }

            // Piece can't move if it's not this pieces turn to move
            if (startPiece.Team != board.WhoseTurn)
            {
                return(false);
            }

            //get places this piece could move ignoring obstructions
            IReadOnlyList <Vector2D> pieceMovementVectors;

            if (endPiece == null)               //replace with DoesMoveCapture when implementing En Passant
            {
                pieceMovementVectors = startPiece.GetAllowedMotionVectors();
            }
            else
            {
                // If there is a piece in the way and it is a friendly piece, then we can't move there
                if (endPiece.Team == startPiece.Team)
                {
                    return(false);
                }
                pieceMovementVectors = startPiece.GetAttackMotionVectors();
            }

            //checks if destination is in one of the positions this piece could move (ignoring obsturctions for now)
            var  requestedMoveVector = (Point2D)endPosition - (Point2D)startPosition;
            bool onPieceVector       = false;

            foreach (var v in pieceMovementVectors)             //TODO: make more efficient
            {
                if (v == requestedMoveVector)
                {
                    onPieceVector = true;
                    break;
                }
            }
            if (!onPieceVector)
            {
                System.Diagnostics.Debug.WriteLine("Destination not on this piece's vectors.");
                return(false);
            }

            /*try
             * {
             *      var matchingMove = pieceMovementVectors.Single(v => v == requestedMoveVector);
             * }
             * catch (InvalidOperationException)
             * {
             *      // Could not retrieve a matching vector from the allowed moves
             *      return false;
             * }*/

            // If the piece can jump, it doesn't matter if something is in the way
            if (startPiece.CanJump)
            {
                return(true);
            }

            return(isPathClear(startPosition, endPosition));
        }
        private void testCatchDraws()
        {
            // simulate for white and black side for each ally and target chess pieces
            for (int colorValues = 0; colorValues < 4; colorValues++)
            {
                // TODO: try to figure out why the code crashes in third loop (ally=black, target=white)

                var allyColor   = (ChessColor)(colorValues / 2);
                var targetColor = (ChessColor)(colorValues % 2);

                // check for all rows on the chess board
                for (int rowDiff = 0; rowDiff < 6; rowDiff++)
                {
                    int allyRow = (allyColor == ChessColor.White) ? (1 + rowDiff) : (6 - rowDiff);
                    int nextRow = (allyColor == ChessColor.White) ? (allyRow + 1) : (allyRow - 1);

                    // get the column where the peasant is moving foreward
                    for (int allyCol = 0; allyCol < 8; allyCol++)
                    {
                        var oldPos = new ChessPosition(allyRow, allyCol);

                        for (int targetColMiddle = 1; targetColMiddle < 7; targetColMiddle++)
                        {
                            var targetPosLeft  = new ChessPosition(nextRow, targetColMiddle - 1);
                            var targetPosRight = new ChessPosition(nextRow, targetColMiddle + 1);

                            var allyPeasant  = new ChessPiece(ChessPieceType.Peasant, allyColor, true);
                            var enemyPeasant = new ChessPiece(ChessPieceType.Peasant, targetColor, true);
                            int kingsRow     = (allyColor == ChessColor.White) ? 0 : 7;

                            var pieces = new List <ChessPieceAtPos>()
                            {
                                new ChessPieceAtPos(oldPos, allyPeasant),
                                new ChessPieceAtPos(targetPosLeft, enemyPeasant),
                                new ChessPieceAtPos(targetPosRight, enemyPeasant),
                                new ChessPieceAtPos(new ChessPosition(kingsRow, 0), new ChessPiece(ChessPieceType.King, ChessColor.White, false)),
                                new ChessPieceAtPos(new ChessPosition(kingsRow, 7), new ChessPiece(ChessPieceType.King, ChessColor.Black, false)),
                            };

                            //output.WriteLine($"current constellation: allyColor={allyColor}, targetColor={targetColor}, allyRow={allyRow}, allyCol={allyCol}, targetColMiddle={targetColMiddle}");

                            var board      = new ChessBitboard(new ChessBoard(pieces));
                            var catchDraws = board.GetAllDraws(allyColor, null, true).Where(x => x.OldPosition == oldPos && x.OldPosition.Column != x.NewPosition.Column);

                            // get the expected draws count (for catch draw onto level 8, there are 4 draws instead of just 1 due to the peasant promotion)
                            int expectedCatchDrawsCount = (targetColor == allyColor) ? 0 : (targetColMiddle == allyCol) ? 2 : ((Math.Abs(targetColMiddle - allyCol) == 2) ? 1 : 0);
                            expectedCatchDrawsCount = ((rowDiff == 5) ? 4 : 1) * expectedCatchDrawsCount;

                            Assert.True(catchDraws.Count() == expectedCatchDrawsCount);

                            // check if the draws are correctly applied to the chess board
                            foreach (var draw in catchDraws)
                            {
                                var simBoard = board.ApplyDraw(draw);
                                var pieceCmp = new ChessPiece(ChessPieceType.Peasant, allyColor, true);
                                Assert.True(!simBoard.IsCapturedAt(draw.OldPosition) && (simBoard.GetPieceAt(draw.NewPosition) == pieceCmp || (rowDiff == 5)));
                            }
                        }
                    }
                }
            }
        }
Beispiel #58
0
        public bool IsCheckMoveValid(Point2D startPoint, Point2D endPoint)
        {
            // Get piece at input location
            ChessPiece startPiece = board.PieceAt(startPoint);
            ChessPiece endPiece   = board.PieceAt(endPoint);

            // If there is no piece at the requested start position, return false
            if (startPiece == null)
            {
                return(false);
            }

            IReadOnlyList <Vector2D> pieceMovementVectors;

            if (endPiece == null)
            {
                pieceMovementVectors = startPiece.GetAllowedMotionVectors();
            }
            else
            {
                // If there is a piece in the way and it is a friendly piece, then we can't move there
                if (endPiece.Team == startPiece.Team)
                {
                    return(false);
                }
                pieceMovementVectors = startPiece.GetAttackMotionVectors();
            }

            var requestedMoveVector = endPoint - startPoint;

            bool matchingVector = false;                // true if requested MoveVector matches a movement vector in pieceMovementVectors

            foreach (var moveVector in pieceMovementVectors)
            {
                if (requestedMoveVector == moveVector)
                {
                    matchingVector = true;
                    break;
                }
            }
            if (!matchingVector)
            {
                System.Diagnostics.Debug.WriteLine("Move illegal because it no piece vectors match that vector");
                return(false);
            }

            /*try
             * {
             *      var matchingMove = pieceMovementVectors.Single(v => v == requestedMoveVector);
             * }
             * catch (InvalidOperationException)
             * {
             *      // Could not retrieve a matching vector from the allowed moves
             *      return false;
             * }*///TODO: Remove this code

            // If the piece can jump, it doesn't matter if something is in the way
            if (startPiece.CanJump)
            {
                return(true);
            }

            return(isPathClear(startPoint, endPoint));
        }
Beispiel #59
0
 public void setPiece(ChessPiece piece)
 {
     this.piece = piece;
 }
Beispiel #60
0
        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            spriteBatch.Begin();

            //Draw Squares and Pieces
            Color squareColor = Color.White;

            for (byte i = 0; i < boardInfo.pieces.Length; ++i)
            {
                if ((int)(i / Constants.NumberOfRanks) % 2 == 0)
                {
                    if (i % 2 == 0)
                    {
                        squareColor = Color.White;
                    }
                    else
                    {
                        squareColor = Color.Gray;
                    }
                }
                else
                {
                    if (i % 2 == 0)
                    {
                        squareColor = Color.Gray;
                    }
                    else
                    {
                        squareColor = Color.White;
                    }
                }

                ChessPiece piece = boardInfo.pieces[i];

                if (piece != null)
                {
                    if (piece.isSelected)
                    {
                        squareColor = Color.Blue;
                    }

                    spriteBatch.Draw(dummyTexture, new Rectangle((i % Constants.NumberOfFiles) * Constants.SquareSize, (int)(i / Constants.NumberOfRanks) * Constants.SquareSize, Constants.SquareSize, Constants.SquareSize), squareColor);

                    Texture2D textureToDraw;
                    if (piece.PieceColor == ChessPieceColor.White)
                    {
                        textureToDraw = textureArray[(int)piece.Identifier];
                    }
                    else
                    {
                        textureToDraw = textureArray[(int)ChessPieceType.None + (int)piece.Identifier];
                    }

                    spriteBatch.Draw(textureToDraw, new Rectangle((i % Constants.NumberOfFiles) * Constants.SquareSize, (int)(i / Constants.NumberOfRanks) * Constants.SquareSize, Constants.SquareSize, Constants.SquareSize), Color.White);
                }
                else
                {
                    spriteBatch.Draw(dummyTexture, new Rectangle((i % Constants.NumberOfFiles) * Constants.SquareSize, (int)(i / Constants.NumberOfRanks) * Constants.SquareSize, Constants.SquareSize, Constants.SquareSize), squareColor);
                }
            }

            spriteBatch.End();

            base.Draw(gameTime);
        }