Exemplo n.º 1
0
        public BoardSpace(BoardSpace fromSpace)
        {
            position = fromSpace.position;
            piece    = null;

            if (fromSpace.piece != null)
            {
                if (fromSpace.piece.GetType() == typeof(Pawn))
                {
                    piece = new Pawn(fromSpace.piece, this);
                }
                else if (fromSpace.piece.GetType() == typeof(Knight))
                {
                    piece = new Knight(fromSpace.piece, this);
                }
                else if (fromSpace.piece.GetType() == typeof(Bishop))
                {
                    piece = new Bishop(fromSpace.piece, this);
                }
                else if (fromSpace.piece.GetType() == typeof(Rook))
                {
                    piece = new Rook(fromSpace.piece, this);
                }
                else if (fromSpace.piece.GetType() == typeof(Queen))
                {
                    piece = new Queen(fromSpace.piece, this);
                }
                else if (fromSpace.piece.GetType() == typeof(King))
                {
                    piece = new King(fromSpace.piece, this);
                }
            }
        }
Exemplo n.º 2
0
 public Move(Chessman piece, BoardSpace fromSpace, BoardSpace toSpace, Board context, int score = 0)
 {
     contextBoard   = context;
     this.toSpace   = toSpace;
     this.fromSpace = fromSpace;
     this.score     = score; // AI Weight
 }
Exemplo n.º 3
0
 public Knight(BoardSpace initPos, ChessmanColor color)
 {
     score      = AIWeights.knightScore;
     position   = initPos;
     this.color = color;
     whiteImage = Properties.Resources.WhiteKnight;
     blackImage = Properties.Resources.BlackKnight;
 }
Exemplo n.º 4
0
 public Bishop(BoardSpace initPos, ChessmanColor color)
 {
     score      = AIWeights.bishopScore;
     position   = initPos;
     this.color = color;
     whiteImage = Properties.Resources.WhiteBishop;
     blackImage = Properties.Resources.BlackBishop;
 }
Exemplo n.º 5
0
 public Pawn(BoardSpace initPos, ChessmanColor color)
 {
     score      = AIWeights.pawnScore;
     position   = initPos;
     this.color = color;
     whiteImage = Properties.Resources.WhitePawn;
     blackImage = Properties.Resources.BlackPawn;
 }
Exemplo n.º 6
0
 public Move(Move other, Board newBoard) // copy Using New Reference Board
 {
     contextBoard   = newBoard;
     this.toSpace   = new BoardSpace(other.toSpace);
     this.fromSpace = new BoardSpace(other.fromSpace);
     this.score     = other.score; // AI Weight
     piece          = other.toSpace.piece;
 }
Exemplo n.º 7
0
 public Move(Move other) // Copy using using Same Reference Board
 {
     contextBoard   = other.contextBoard;
     this.toSpace   = other.toSpace;
     this.fromSpace = other.fromSpace;
     this.score     = other.score; // AI Weight
     piece          = other.piece;
 }
Exemplo n.º 8
0
 public King(BoardSpace initPos, ChessmanColor color)
 {
     score      = AIWeights.queenScore;
     position   = initPos;
     this.color = color;
     whiteImage = Properties.Resources.WhiteKing;
     blackImage = Properties.Resources.BlackKing;
 }
Exemplo n.º 9
0
 public Rook(BoardSpace initPos, ChessmanColor color)
 {
     score      = AIWeights.rookScore;
     position   = initPos;
     this.color = color;
     whiteImage = Properties.Resources.WhiteRook;
     blackImage = Properties.Resources.BlackRook;
 }
Exemplo n.º 10
0
        public override bool Equals(object obj)
        {
            bool rv = false;

            if (obj != null || GetType() == obj.GetType())
            {
                BoardSpace passedSpace = (BoardSpace)obj;
                if (position.Item1 == passedSpace.position.Item1 && position.Item2 == passedSpace.position.Item2)
                {
                    rv = true;
                }
            }

            return(rv);
        }
Exemplo n.º 11
0
 public Move(String move, Board context, int score = 0, bool postMove = false)
 {
     if (Regex.IsMatch(move, "[A-Za-z][0-9][A-Za-z][0-9].*"))
     {
         contextBoard = context;
         toSpace      = contextBoard.getSpace(move.Substring(0, 1).ToString().ToUpper()[0], int.Parse(move.Substring(1, 1)));
         fromSpace    = contextBoard.getSpace(move.Substring(2, 1).ToString().ToUpper()[0], int.Parse(move.Substring(3, 1)));
         this.score   = score; // AI Weight
         piece        = (postMove) ? toSpace.piece : fromSpace.piece;
     }
     else
     {
         throw new Exception("Supplied Move is not UCI Formatted.");
     }
 }
Exemplo n.º 12
0
 public Queen(Chessman fromPiece, BoardSpace initPos)
 {
     if (fromPiece.GetType() == typeof(Queen))
     {
         Queen from = (Queen)fromPiece;
         score      = from.score;
         position   = initPos;
         this.color = from.color;
         whiteImage = from.whiteImage;
         blackImage = from.blackImage;
     }
     else
     {
         throw new Exception($"Cant Create Copy of Piece becasue it is the wrong type");
     }
 }
Exemplo n.º 13
0
        public BoardSpace getSpace(char col, int row)
        {
            BoardSpace rv = null;

            try
            {
                if (col >= 'A' && col <= 'H' && row >= 1 && row <= 8)
                {
                    rv = boardState[BoardSpace.getIndexForBoardRow(row), BoardSpace.getIndexForBoardColumn(col)];
                }
            }
            catch
            {
            }

            return(rv);
        }
Exemplo n.º 14
0
        private void updateValidSquaresForSelectedCB(MyCheckBox cb)
        {
            if (cb.Checked)
            {
                //cb.Image = ResizeImage(Properties.Resources.BlackKnight,  cb.Size.Width/2, cb.Size.Height/2);
                cb.BackColor = MyCheckBox.chessBoardSelectedColor;
            }
            else
            {
                cb.BackColor = cb.checkerBoardColor;
            }
            //Disable All Invalid moves
            Game       currGame = ((Game)gamesListBox.SelectedItem);
            Board      board    = currGame.gameBoard;
            BoardSpace boardPos = cb.getLinkedBoardSpace();

            if (boardPos.piece != null && boardPos.piece.color == currGame.color)
            {
                List <Move> validMoves = boardPos.piece.getAvailableMoves(board);

                foreach (Move mv in validMoves)
                {
                    // Highlight valid Moves
                    bool found = false;
                    for (int row = 1; row <= 8; row++)
                    {
                        for (Char col = 'A'; col <= 'H'; col++)
                        {
                            MyCheckBox itCB = chessBoardList[row - 1, col - 'A'];
                            if (itCB.getLinkedBoardSpace().position.Item2 == mv.toSpace.position.Item2 && itCB.getLinkedBoardSpace().position.Item1 == mv.toSpace.position.Item1)
                            {
                                itCB.BackColor = MyCheckBox.chessBoardValidMoveColor;
                                found          = true;
                                break;;
                            }
                            if (found)
                            {
                                break;
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 15
0
        public override List <Move> getAvailableMoves(Board boardState)
        {
            List <Move> validMoveList = new List <Move>();
            // Get Valid Moves

            BoardSpace toPos = null;


            // The King Has the Same Moveset whether it is in check or not

            // First Move
            for (int x = -1; x <= 1; x++)
            {
                for (int y = -1; y <= 1; y++)
                {
                    if (!(x == 0 && y == 0))
                    {
                        toPos = boardState.getSpace(Convert.ToChar(position.position.Item1 + x), position.position.Item2 + y);

                        if (toPos != null)
                        {
                            if (toPos.piece == null || toPos.piece.color != color)
                            {
                                Move  newMove           = new Move(this, position, toPos, boardState, (toPos.piece == null) ? 0 : toPos.piece.score);
                                Board newBoardAfterMove = new Board(boardState);
                                newBoardAfterMove.updateBoardForMove(newMove);

                                if (!newBoardAfterMove.isKingInCheck(color)) // Check if New Move is in Check
                                {
                                    validMoveList.Add(newMove);
                                }
                            }
                        }
                    }
                }
            }

            // Amend Scores for Pieces that Are now attacking this piece
            // Handle Castle

            return(validMoveList);
        }
Exemplo n.º 16
0
        public Board(Board fromBoard)
        {
            // Copy BoardState Array

            for (int row = 0; row < 8; row++)
            {
                for (int col = 0; col < 8; col++)
                {
                    boardState[row, col] = new BoardSpace(fromBoard.boardState[row, col]);
                }
            }

            // Recalculate moves on King
            updateAttacksOnKing(ChessmanColor.white);
            updateAttacksOnKing(ChessmanColor.black);

            // update attacks arrays
            whiteKingPos = this.getSpace(fromBoard.whiteKingPos.position.Item1, fromBoard.whiteKingPos.position.Item2);
            blackKingPos = this.getSpace(fromBoard.blackKingPos.position.Item1, fromBoard.blackKingPos.position.Item2);
        }
Exemplo n.º 17
0
        public override List <Move> getAvailableMoves(Board boardState)
        {
            List <Move> validMoveList = new List <Move>();

            // Get Valid Moves
            BoardSpace toPos = null;

            for (int x = -2; x <= 2; x++)
            {
                for (int y = -2; y <= 2; y++)
                {
                    if (x != 0 && y != 0 && (Math.Abs(x) != Math.Abs(y)))
                    {
                        toPos = boardState.getSpace(Convert.ToChar(position.position.Item1 + x), position.position.Item2 + y);

                        if (toPos != null)
                        {
                            if (toPos.piece == null || toPos.piece.color != color)
                            {
                                Move newMove = new Move(this, position, toPos, boardState, (toPos.piece == null) ? 0 : toPos.piece.score);
                                validMoveList.Add(newMove);
                            }
                        }
                    }
                }
            }

            // Amend Scores for Pieces that Are now attacking this piece
            if (boardState.isKingInCheck(color))
            {
                List <Move> afterCheckMoveList = getCheckBlockingMoves(boardState, validMoveList, color);
                validMoveList.Clear();
                validMoveList.AddRange(afterCheckMoveList);
            }


            return(validMoveList);
        }
Exemplo n.º 18
0
        public Board(String fen = "")
        {
            // A1 is Bottom Left Corner, H8 is top Right Corner
            for (int row = 0; row < 8; row++)
            {
                for (int col = 0; col < 8; col++)
                {
                    Char tmp          = (Char)('A' + col);
                    int  effectiveRow = 8 - row;
                    boardState[row, col] = new BoardSpace(tmp, effectiveRow);

                    if (fen != "")
                    {
                        // Process FEN
                        boardState[row, col].generatePieceFromFen(fen);
                    }
                    else
                    {
                        if (effectiveRow == 2 || effectiveRow == 7)
                        {
                            boardState[row, col].piece = new Pawn(boardState[row, col], (effectiveRow == 2) ? ChessmanColor.white : ChessmanColor.black);
                        }
                        else if (effectiveRow == 1 || effectiveRow == 8)
                        {
                            // Setup White BackRow
                            switch (tmp)
                            {
                            case 'A':
                                boardState[row, col].piece = new Rook(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;

                            case 'B':
                                boardState[row, col].piece = new Knight(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;

                            case 'C':
                                boardState[row, col].piece = new Bishop(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;

                            case 'D':
                                boardState[row, col].piece = new Queen(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;

                            case 'E':
                                boardState[row, col].piece = new King(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                if (effectiveRow == 1)
                                {
                                    whiteKingPos = boardState[row, col];
                                }
                                else
                                {
                                    blackKingPos = boardState[row, col];
                                }
                                break;

                            case 'F':
                                boardState[row, col].piece = new Bishop(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;

                            case 'G':
                                boardState[row, col].piece = new Knight(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;

                            case 'H':
                                boardState[row, col].piece = new Rook(boardState[row, col], ((effectiveRow == 1) ? ChessmanColor.white : ChessmanColor.black));
                                break;
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 19
0
        private Chessman movePieceOnBoard(BoardSpace fromSpace, BoardSpace toSpace, String extraArgs = "")
        {
            // This is kust updating the data model. Validation Should occur prior to this
            // This function Assumes that the moves are valid.

            Chessman fromPiece   = fromSpace.piece;
            Chessman killedPiece = null;

            if (toSpace.piece != null)
            {
                // We killed piece remove it.
                killedPiece = toSpace.piece;
            }
            fromPiece.position = toSpace;
            toSpace.piece      = fromPiece;
            fromSpace.piece    = null;

            if (toSpace.piece.GetType() == typeof(King))
            {
                King kp = (King)toSpace.piece;
                if (kp.canCastle)
                {
                    kp.canCastle = false;
                }
                if (kp.color == ChessmanColor.white)
                {
                    whiteKingPos = toSpace;
                }
                else
                {
                    blackKingPos = toSpace;
                }
            }
            else if (toSpace.piece.GetType() == typeof(Rook))
            {
                Rook rp = (Rook)toSpace.piece;
                if (rp.canCastle)
                {
                    rp.canCastle = false;
                }
            }
            else if (toSpace.piece.GetType() == typeof(Pawn))
            {
                ((Pawn)toSpace.piece).canMoveTwice = false;  // Pawns Can only Move Twice on the first move
                if ((toSpace.piece.color == ChessmanColor.black && toSpace.position.Item2 == 1) || (toSpace.piece.color == ChessmanColor.white && toSpace.position.Item2 == 8))
                {
                    Char promotionType = 'q';
                    if (extraArgs.Length > 0)
                    {
                        promotionType = extraArgs.ToLower()[0];
                    }

                    switch (promotionType)
                    {
                    case 'q':
                        // Promote to Queen
                        Queen q = new Queen(toSpace, toSpace.piece.color);
                        toSpace.piece = q;
                        break;

                    case 'b':
                        // Promote to Queen
                        Bishop b = new Bishop(toSpace, toSpace.piece.color);
                        toSpace.piece = b;
                        break;

                    case 'n':
                        // Promote to Queen
                        Knight kn = new Knight(toSpace, toSpace.piece.color);
                        toSpace.piece = kn;
                        break;

                    case 'r':
                        // Promote to Queen
                        Rook r = new Rook(toSpace, toSpace.piece.color);
                        toSpace.piece = r;
                        break;
                    }
                }
            }

            updateAttacksOnKing(toSpace.piece.color);

            return(killedPiece);
        }
Exemplo n.º 20
0
        public bool updateBoardForMove(String move)
        {
            bool   moveValid = false;
            String fromPos   = move.Substring(0, 2).ToUpper();
            String toPos     = move.Substring(2, 2).ToUpper();
            String extraArgs = "";

            if (move.Length > 4)
            {
                extraArgs = move.Substring(4, move.Length - 4);
            }

            try
            {
                BoardSpace fromSpace = getSpace(fromPos[0], int.Parse(new String(new char[] { fromPos[1] })));
                BoardSpace toSpace   = getSpace(toPos[0], int.Parse(new String(new char[] { toPos[1] })));

                if (fromSpace.piece != null)
                {
                    Chessman fromPiece = fromSpace.piece;

                    if (true) // Do check if move is valid for piece type
                    {
                        if (fromPiece.GetType() == typeof(King) && ((King)fromPiece).canCastle && ((fromPiece.color == ChessmanColor.white && fromSpace.position.Item1 == 'E' && fromSpace.position.Item2 == 1 && (toSpace.position.Item1 == 'G' && toSpace.position.Item2 == 1) || (toSpace.position.Item1 == 'C' && toSpace.position.Item2 == 1)) || (fromPiece.color == ChessmanColor.black && fromSpace.position.Item1 == 'E' && fromSpace.position.Item2 == 8 && (toSpace.position.Item1 == 'G' && toSpace.position.Item2 == 8) || (toSpace.position.Item1 == 'C' && toSpace.position.Item2 == 8))))
                        {
                            King kingPiece = ((King)fromPiece);

                            //Attempting a castle VAlidate it
                            BoardSpace rookSpace = null;

                            if (kingPiece.color == ChessmanColor.white && (toSpace.position.Item1 == 'G' && toSpace.position.Item2 == 1))
                            {
                                // White King Side Castle
                                rookSpace = getSpace('H', 1);

                                if (rookSpace.piece.GetType() == typeof(Rook) && ((Rook)rookSpace.piece).canCastle) // Was the King Side Rook moved before now
                                {
                                    if (getSpace('F', 1).piece == null && getSpace('G', 1).piece == null)           // Are all the spaces between the Rook and Knight Clear
                                    {
                                        if (true)                                                                   // Are any Spaces the King Must Move Under Attack. (E1(Check),F1, G1) (Skipping for now until we can check this)
                                        {
                                            movePieceOnBoard(fromSpace, toSpace, extraArgs);                        // Move King
                                            movePieceOnBoard(rookSpace, getSpace('F', 1), extraArgs);               // Move Rook
                                            moveValid = true;
                                        }
                                    }
                                }
                            }
                            else if (kingPiece.color == ChessmanColor.white && (toSpace.position.Item1 == 'C' && toSpace.position.Item2 == 1))
                            {
                                // White Queen Side Castle
                                rookSpace = getSpace('A', 1);

                                if (rookSpace.piece.GetType() == typeof(Rook) && ((Rook)rookSpace.piece).canCastle)                         // Was the King Side Rook moved before now
                                {
                                    if (getSpace('B', 1).piece == null && getSpace('C', 1).piece == null && getSpace('D', 1).piece == null) // Are all the spaces between the Rook and Knight Clear
                                    {
                                        if (true)                                                                                           // Are any Spaces the King Must Move Under Attack. (E1(Check), D1, C1) (Skipping for now until we can check this)
                                        {
                                            movePieceOnBoard(fromSpace, toSpace, extraArgs);                                                // Move King
                                            movePieceOnBoard(rookSpace, getSpace('D', 1), extraArgs);                                       // Move Rook
                                            moveValid = true;
                                        }
                                    }
                                }
                            }
                            else if (kingPiece.color == ChessmanColor.black && (toSpace.position.Item1 == 'G' && toSpace.position.Item2 == 8))
                            {
                                // White King Side Castle
                                rookSpace = getSpace('H', 8);

                                if (rookSpace.piece.GetType() == typeof(Rook) && ((Rook)rookSpace.piece).canCastle) // Was the King Side Rook moved before now
                                {
                                    if (getSpace('F', 8).piece == null && getSpace('G', 8).piece == null)           // Are all the spaces between the Rook and Knight Clear
                                    {
                                        if (true)                                                                   // Are any Spaces the King Must Move Under Attack. (E8(Check),F8, G8) (Skipping for now until we can check this)
                                        {
                                            movePieceOnBoard(fromSpace, toSpace, extraArgs);                        // Move King
                                            movePieceOnBoard(rookSpace, getSpace('F', 8), extraArgs);               // Move Rook
                                            moveValid = true;
                                        }
                                    }
                                }
                            }
                            else if (kingPiece.color == ChessmanColor.black && (toSpace.position.Item1 == 'C' && toSpace.position.Item2 == 8))
                            {
                                // White Queen Side Castle
                                rookSpace = getSpace('A', 8);

                                if (rookSpace.piece.GetType() == typeof(Rook) && ((Rook)rookSpace.piece).canCastle)                         // Was the King Side Rook moved before now
                                {
                                    if (getSpace('B', 8).piece == null && getSpace('C', 8).piece == null && getSpace('D', 8).piece == null) // Are all the spaces between the Rook and Knight Clear
                                    {
                                        if (true)                                                                                           // Are any Spaces the King Must Move Under Attack. (E1(Check), D1, C1) (Skipping for now until we can check this)
                                        {
                                            movePieceOnBoard(fromSpace, toSpace, extraArgs);                                                // Move King
                                            movePieceOnBoard(rookSpace, getSpace('D', 8), extraArgs);                                       // Move Rook
                                            moveValid = true;
                                        }
                                    }
                                }
                            }

                            if (moveValid)
                            {
                                // Grab All King and Rooks for the color and disable castling
                                foreach (BoardSpace s in boardState)
                                {
                                    if (s.piece != null && s.piece.color == fromPiece.color)
                                    {
                                        if (s.piece.GetType() == typeof(Rook))
                                        {
                                            ((Rook)s.piece).canCastle = false;
                                        }
                                        else if (s.piece.GetType() == typeof(King))
                                        {
                                            ((King)s.piece).canCastle = false;
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            movePieceOnBoard(fromSpace, toSpace, extraArgs);
                            moveValid = true;
                        }
                    }
                }
                else
                {
                    // There should always be a piece in the from Space
                }
            }
            catch
            {
            }

            return(moveValid);
        }
Exemplo n.º 21
0
        public static List <Move> getMovesForBishop(Board boardState, ChessmanColor color, BoardSpace position)
        {
            List <Move> validMoveList = new List <Move>();

            //Starting At Inital Position moves the 4 directions until the board is gone or a piece is reached
            char col = Convert.ToChar(position.position.Item1 + 1);
            int  row = position.position.Item2 + 1;

            for (; row <= 8 && col <= 'H'; row++, col++)
            {
                // increasing Diagonal
                BoardSpace moveSpace = boardState.getSpace(col, row);
                if (moveSpace != null)
                {
                    if (moveSpace.piece == null)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, 0));
                    }
                    else if (moveSpace.piece.color != color)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, moveSpace.piece.score));
                        break;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            col = Convert.ToChar(position.position.Item1 - 1);
            row = position.position.Item2 - 1;
            for (; row >= 1 && col >= 'A'; row--, col--)
            {
                // increasing Diagonal
                BoardSpace moveSpace = boardState.getSpace(col, row);
                if (moveSpace != null)
                {
                    if (moveSpace.piece == null)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, 0));
                    }
                    else if (moveSpace.piece.color != color)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, moveSpace.piece.score));
                        break;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            col = Convert.ToChar(position.position.Item1 + 1);
            row = position.position.Item2 - 1;
            for (; row >= 1 && col <= 'H'; row--, col++)
            {
                // increasing Diagonal
                BoardSpace moveSpace = boardState.getSpace(col, row);
                if (moveSpace != null)
                {
                    if (moveSpace.piece == null)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, 0));
                    }
                    else if (moveSpace.piece.color != color)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, moveSpace.piece.score));
                        break;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            col = Convert.ToChar(position.position.Item1 - 1);
            row = position.position.Item2 + 1;
            for (; row <= 8 && col >= 'A'; row++, col--)
            {
                // increasing Diagonal
                BoardSpace moveSpace = boardState.getSpace(col, row);
                if (moveSpace != null)
                {
                    if (moveSpace.piece == null)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, 0));
                    }
                    else if (moveSpace.piece.color != color)
                    {
                        validMoveList.Add(new Move(position.piece, position, moveSpace, boardState, moveSpace.piece.score));
                        break;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            // Amend Scores for Pieces that Are now attacking this piece
            if (boardState.isKingInCheck(color))
            {
                List <Move> afterCheckMoveList = getCheckBlockingMoves(boardState, validMoveList, color);
                validMoveList.Clear();
                validMoveList.AddRange(afterCheckMoveList);
            }


            return(validMoveList);
        }
Exemplo n.º 22
0
        public override List <Move> getAvailableMoves(Board boardState)
        {
            List <Move> validMoveList = new List <Move>();
            // Get Valid Moves

            int        numMoves = (canMoveTwice) ? 2 : 1;
            BoardSpace toPos    = null;

            // Normal Moves

            // First Move
            for (int i = 1; i <= numMoves; i++)
            {
                toPos = boardState.getSpace(Convert.ToChar(position.position.Item1), (color == ChessmanColor.white) ? position.position.Item2 + i : position.position.Item2 - i);

                if (toPos != null)
                {
                    if (toPos.piece == null)
                    {
                        Move newMove = new Move(this, position, toPos, boardState, 0);

                        // Is A Promoting Move
                        if ((color == ChessmanColor.white) ? (toPos.position.Item2 == 8) : (toPos.position.Item2 == 1))
                        {
                            newMove.score = AIWeights.queenScore;
                        }

                        validMoveList.Add(newMove);
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    continue;
                }
            }

            // Attacking Moves
            toPos = boardState.getSpace(Convert.ToChar(position.position.Item1 + 1), (color == ChessmanColor.white) ? position.position.Item2 + 1 : position.position.Item2 - 1);
            BoardSpace        toPos2        = boardState.getSpace(Convert.ToChar(position.position.Item1 - 1), (color == ChessmanColor.white) ? position.position.Item2 + 1 : position.position.Item2 - 1);
            List <BoardSpace> possibleMoves = new List <BoardSpace>()
            {
                toPos, toPos2
            };

            foreach (BoardSpace space in possibleMoves)
            {
                if (space != null)
                {
                    if (space != null && space.piece != null && space.piece.color == Helper.getOpponentColor(color))
                    {
                        validMoveList.Add(new Move(this, position, space, boardState, ((space.piece.color == Helper.getOpponentColor(color)) ? space.piece.score : 0)));
                    }
                }
                else
                {
                    continue;
                }
            }

            // Amend Scores for Pieces that Are now attacking this piece

            if (boardState.isKingInCheck(color))
            {
                List <Move> afterCheckMoveList = getCheckBlockingMoves(boardState, validMoveList, color);
                validMoveList.Clear();
                validMoveList.AddRange(afterCheckMoveList);
            }

            return(validMoveList);
        }