void rookThreatenHighlight(Piece.Colour colour, int row, int col, List<int[]> threatened, Piece[,] board)
 {
     int i = 1;
     //check down
     while (addThreatened(colour, row, col, i, 0, threatened))
     {
         if (board[row + i, col].Exists)
             break;
         i++;
     }
     //check up
     i = 1;
     while (addThreatened(colour, row, col, -i, 0, threatened))
     {
         if (board[row - i, col].Exists)
             break;
         i++;
     }
     //check right
     i = 1;
     while (addThreatened(colour, row, col, 0, i, threatened))
     {
         if (board[row, col + i].Exists)
             break;
         i++;
     }
     //check left
     i = 1;
     while (addThreatened(colour, row, col, 0, -i, threatened))
     {
         if (board[row, col - i].Exists)
             break;
         i++;
     }
 }
        BitboardLayer[] pieceLocations; //0 is white, 1 is black

        #endregion Fields

        #region Constructors

        public AttackedSquaresGetter(ChessBoard c)
        {
            lastUpdated = new int[64];
            this.c = c;
            pieceLocations = new BitboardLayer[2];
            currAttackedSquares = new BitboardLayer[2][];
            kingAttackedSquares = new BitboardLayer[2];
            allAttackedSq = new BitboardLayer[2];
            allValidMoves = new BitboardLayer[2];
            currValidMoves = new BitboardLayer[2][];
            currPinnedPcs = new List<int[]>[2];
            currCheckers = new List<int[]>[2];
            canCastle = new bool[2][];
            for (int i = 0; i < 2; i++)
            {
                pieceLocations[i] = new BitboardLayer();
                currAttackedSquares[i] = new BitboardLayer[64];
                kingAttackedSquares[i] = new BitboardLayer();
                currValidMoves[i] = new BitboardLayer[64];
                allValidMoves[i] = new BitboardLayer();
                allAttackedSq[i] = new BitboardLayer();
                currPinnedPcs[i] = new List<int[]>();
                canCastle[i] = new bool[] { false, false };
                currCheckers[i] = new List<int[]>();

                for (int j = 0; j < 64; j++)
                {
                    currAttackedSquares[i][j] = new BitboardLayer();
                    currValidMoves[i][j] = new BitboardLayer();
                }
            }
            numIterations = 0;
            updatePosition(true, new int[] { 63, 63 });
            updatePosition(false, new int[] { 0, 0 });
        }
 void bishopThreatenHighlight(string colour, int row, int col, List<int[]> threatened, Piece[,] board)
 {
     int i = 1;
     //check down right
     while (addThreatened(colour, row, col, i, i, threatened))
     {
         if (board[row + i, col + i].Exists)
             break;
         i++;
     }
     //check up right
     i = 1;
     while (addThreatened(colour, row, col, -i, i, threatened))
     {
         if (board[row - i, col + i].Exists)
             break;
         i++;
     }
     //check up left
     i = 1;
     while (addThreatened(colour, row, col, -i, -i, threatened))
     {
         if (board[row - i, col - i].Exists)
             break;
         i++;
     }
     //check down left
     i = 1;
     while (addThreatened(colour, row, col, i, -i, threatened))
     {
         if (board[row + i, col - i].Exists)
             break;
         i++;
     }
 }
 void pawnThreatenHighlight(Piece piece, int row, int col, List<int[]> threatened, Piece[,] board, List<int[]> enPassant)
 {
     //capturing
     if (piece.PieceColour == Piece.Colour.Black)
     {
         addThreatened(piece.PieceColour, piece.Row, piece.Col, 1, 1, threatened);
         addThreatened(piece.PieceColour, piece.Row, piece.Col, 1, -1, threatened);
     }
     if (piece.PieceColour == Piece.Colour.White)
     {
         addThreatened(piece.PieceColour, piece.Row, piece.Col, -1, 1, threatened);
         addThreatened(piece.PieceColour, piece.Row, piece.Col, -1, -1, threatened);
     }
     //en passant
     if (piece.PieceColour == Piece.Colour.Black)
     {
         addEnPassant(piece.PieceColour, piece.Row, piece.Col, 1, 1, enPassant, board);
         addEnPassant(piece.PieceColour, piece.Row, piece.Col, 1, -1, enPassant, board);
     }
     if (piece.PieceColour == Piece.Colour.White)
     {
         addEnPassant(piece.PieceColour, piece.Row, piece.Col, -1, 1, enPassant, board);
         addEnPassant(piece.PieceColour, piece.Row, piece.Col, -1, -1, enPassant, board);
     }
 }
Example #5
0
        public List<KomaBase> KomaCreate()
        {
            if (komaList != null)
            {
                return komaList;
            }
            komaList = new List<KomaBase>();
            foreach (KomaKind komaKind in Enum.GetValues(typeof(KomaKind)))
            {
                int index = 0;
                while(true)
                {
                    var komaKuro = createKoma(komaKind, PlayerNo.Two, index);
                    komaKuro.SetDefaultPoint();
                    var komaShiro = createKoma(komaKind, PlayerNo.One, index);
                    komaShiro.SetDefaultPoint();
                    komaList.AddRange(new[] { komaKuro, komaShiro });

                    if (komaShiro.GetMaxCount() == index + 1)
                        break;
                    ++index;

                   
                }
            }


            return komaList;

        }
Example #6
0
        //create new board
        public Board()
        {
            //Initiate Pawns
            for (int i = 0; i < 8; i++)
            {
                WhitePieces.Add(new Pawn(true, this));
                BlackPieces.Add(new Pawn(false, this));
            }

            //Initiate Knights/Bishops/Rooks
            for (int i = 0; i < 2; i++)
            {
                WhitePieces.Add(new Knight(true, this));
                BlackPieces.Add(new Knight(false, this));
                WhitePieces.Add(new Bishop(true, this));
                BlackPieces.Add(new Bishop(false, this));
                WhitePieces.Add(new Rook(true, this));
                BlackPieces.Add(new Rook(false, this));
            }
            //Intiate Kings/Queens
            WhitePieces.Add(new King(true, this));
            WhitePieces.Add(new Queen(true, this));

            BlackPieces.Add(new Queen(false, this));
            BlackPieces.Add(new King(false, this));

            AllPieces = WhitePieces;
            AllPieces.AddRange(BlackPieces);
        }
Example #7
0
 public bool isThreatened(int row, int col, Piece.Colour threatenedBy, Piece[,] board)
 {
     bool threatened = false;
     List<int[]> covered = new List<int[]>();
     List<int[]> filler = new List<int[]>();
     for (int rows = 0; rows < Board.Rows; rows++)
     {
         for (int cols = 0; cols < Board.Cols; cols++)
         {
             if (board[rows, cols].PieceColour == threatenedBy)
             {
                 thm.highlightThreatened(board[rows, cols], rows, cols, covered, filler, board, false);
             }
         }
     }
     foreach (int[] pair in covered)
     {
         if (pair[0] == row && pair[1] == col)
         {
             threatened = true;
             break;
         }
     }
     return threatened;
 }
Example #8
0
        public List<Tuple<int, int>> Rules(Piece currentPiece, Gameboard gameboard)
        {
            this.moves_dia = get_diagonal.Rules(currentPiece, gameboard);
            this.moves_str = get_straight.Rules(currentPiece, gameboard);

            moves_str = moves_str.Concat(moves_dia).ToList();

            return moves_str;
        }
 void addEnPassant(string colour, int row, int col, int rowOffset, int colOffset, List<int[]> enPassant, Piece[,] board)
 {
     int destinationRow = row + rowOffset;
     int destinationCol = col + colOffset;
     if (destinationRow >= 0 && destinationRow <= 7 && destinationCol >= 0 && destinationCol <= 7 && board[row, col + colOffset].EnPassant)
     {
         enPassant.Add(new int[] { destinationRow, destinationCol });
     }
 }
Example #10
0
        public override List<Tuple<MoveType, int, int>> GetMovableLoacation()
        {
            int h = Player == PlayerNo.Two ? -1 : 1;
            var list = new List<Tuple<MoveType, int, int>>();
            list.Add(new Tuple<MoveType, int, int>(MoveType.NotExistAny, Left, Height+h));
            list.Add(new Tuple<MoveType, int, int>(MoveType.ExistsEnemy, Left - 1, Height + h));
            list.Add(new Tuple<MoveType, int, int>(MoveType.ExistsEnemy, Left + 1, Height + h));

            return list;
        }
Example #11
0
        private coord tileSize; // Size of tile

        #endregion Fields

        #region Constructors

        // Constructor
        public SidebarWidget(List<Figure> removedFigures, string color, int scale)
        {
            this.removedFigures = removedFigures;
              this.color = color;                       // Color of the sidebar's admitted figures

              updateSidebar ();

              this.WidthRequest = 5 * scale;
              this.tileSize = new coord (5 * scale, 5 * scale);
        }
Example #12
0
 internal static List<Peice> getPeices(Peice[,] board, PSide side)
 {
     List<Peice> sideList = new List<Peice>();
     foreach (Peice peice in board)
     {
         if (peice != null && peice.MySide == side)
         { sideList.Add(peice); }
     }
     return sideList;
 }
 bool addThreatened(string colour, int row, int col, int rowOffset, int colOffset, List<int[]> threatened)
 {
     bool added = false;
     int destinationRow = row + rowOffset;
     int destinationCol = col + colOffset;
     if (uf.IsInBounds(destinationRow, destinationCol))
     {
         threatened.Add(new int[] { destinationRow, destinationCol });
         added = true;
     }
     return added;
 }
Example #14
0
 //doenst include king
 public List<Pair> GetBlackPosistions()
 {
     List<Pair> Positions = new List<Pair>();
     foreach (ChessPiece piece in WhitePieces)
     {
         if (piece.InPlay)
         {
             Positions.Add(piece.Position);
         }
     }
     return Positions;
 }
Example #15
0
        public void InitializePlayfield(ref bool isWhiteTurn, ref bool isGameDone, 
            List<int[]> highlight, Piece[,] playfield, Piece[,] whiteTaken, 
            Piece[,] blackTaken, ref int[] whiteTakenIndeces, ref int[] blackTakenIndeces)
        {
            //reseting parameters
            df.Clear();
            isWhiteTurn = true;
            isGameDone = false;
            highlight.Clear();
            whiteTakenIndeces = new int[] { 0, 0 };
            blackTakenIndeces = new int[] { 0, 0 };
            for (int row = 0; row < Board.Rows; row++)
            {
                for (int col = 0; col < Board.Cols; col++)
                {
                    //set piece type
                    playfield[row, col] = new Piece() { Row = row, Col = col };
                    if (row == Board.FirstRow || row == Board.LastRow)
                    {
                        if (col == Board.FirstCol || col == Board.LastCol)
                            playfield[row, col].PieceType = Piece.Type.Rook;
                        if (col == Board.FirstCol + 1 || col == Board.LastCol - 1)
                            playfield[row, col].PieceType = Piece.Type.Knight;
                        if (col == Board.FirstCol + 2 || col == Board.LastCol - 2)
                            playfield[row, col].PieceType = Piece.Type.Bishop;
                        if (col == Board.FirstCol + 3)
                            playfield[row, col].PieceType = Piece.Type.Queen;
                        if (col == Board.FirstCol + 4)
                            playfield[row, col].PieceType = Piece.Type.King;
                    }
                    if (row == Board.FirstRow + 1 || row == Board.LastRow - 1)
                        playfield[row, col].PieceType = Piece.Type.Pawn;
                    //set piece color
                    //all pieces in the top two rows are black
                    if (row <= Board.FirstRow + 1)
                        playfield[row, col].PieceColour = Piece.Colour.Black;
                    //all pieces in the bottom two rows are white
                    if (row >= Board.LastRow - 1)
                        playfield[row, col].PieceColour = Piece.Colour.White;
                    //set those pieces to existing
                    if (row <= Board.FirstRow + 1 || row >= Board.LastRow - 1)
                        playfield[row, col].Exists = true;
                }

                //Reset the taken grids
                for (int col = 0; col < 2; col++)
                {
                    whiteTaken[row, col] = new Piece();
                    blackTaken[row, col] = new Piece();
                }
            }
        }
Example #16
0
 public override List<Tuple<MoveType, int, int>> GetMovableLoacation()
 {
     var list = new List<Tuple<MoveType, int, int>>();
     foreach (var l in new[] { -2,-1, 1,2 })
     {
         foreach (var h in new[] { -2, -1, 1, 2 })
         {
             if (l != h && h+l != 0)
                 list.Add(new Tuple<MoveType, int, int>(MoveType.Normal, Left + l, Height + h));
         }
     }
     return list;
 }
Example #17
0
        public override List<Tuple<MoveType, int, int>> GetMovableLoacation()
        {
            var list = new List<Tuple<MoveType, int, int>>();
            foreach (int l in new[] { -1, 1 })
            {
                foreach (int h in new[] { -1, 1 })
                {
                    list.Add(new Tuple<MoveType, int, int>(MoveType.Direction, l+this.Left, h+this.Height));
                }
            }

            return list;
        }
Example #18
0
 public ChessBoard(ChessBoard c)
 {
     for (int i = 0; i <= pieceIndex.FLAGS; i++)
     {
         white[i] = new BitboardLayer(c.getDict(true)[i]);
         black[i] = new BitboardLayer(c.getDict(false)[i]);
     }
     white_ep = c.getEP(true);
     black_ep = c.getEP(false);
     moveList = new List<int[]>(c.getMoveList());
     moveNum = c.getMoveNum();
     ASG = c.getASG();
 }
Example #19
0
 public override List<Tuple<MoveType, int, int>> GetMovableLoacation()
 {
     var list = new List<Tuple<MoveType, int, int>>();
     foreach (var l in new[] { -1, 0, 1 })
     {
         foreach (var h in new[] { -1, 0, 1 })
         {
             if (h != 0 || l != 0)
                 list.Add(new Tuple<MoveType, int, int>(MoveType.Direction, Left + l, Height + h));
         }
     }
     return list;
 }
Example #20
0
		/// <summary>
		/// Standard Constructor. Initializes AllCells, CellLinkStrategyList, History and GraveYard
		/// </summary>
		public Board()
		{
			AllCells = new List<CellViewModel>(64);

			CellLinkStrategyList = new List<ICellLinkStrategy>
			{
				new DefaultCellLinkStrategy()
			};

			History = new ObservableCollection<HistoryViewModel>();

			_graveYard = new ObservableCollection<IChessPiece>();
		}
Example #21
0
 public void SelectOrMove(int row, int col, List<int[]> moveable, List<int[]> threatened, List<int[]> enPassant, ref bool promote, ref bool moved)
 {
     bool doSelect = true;
     //enforce turn order for move
     if ((WhiteTurn && selectedPiece.Colour == white) || (!WhiteTurn && selectedPiece.Colour == black))
         foreach (int[] pair in Highlight)
             if (pair[0] == row && pair[1] == col)
             {
                 move(row, col, ref promote, ref doSelect, ref moved);
                 break;
             }
     if (doSelect)
         select(row, col, moveable, threatened, enPassant);
 }
Example #22
0
        private List<Tuple< int, int>> getCanMove(
            IEnumerable<Tuple<MoveType, int, int>> locateInfos,
            KomaBase koma)
        {
            var inBoardLocates = this.getInBoardLocate(locateInfos);
            var canMoveLocates = new List<Tuple< int, int>>();

            canMoveLocates.AddRange(this.getNotExistsAny(inBoardLocates));
            canMoveLocates.AddRange(this.getExistsEnemy(inBoardLocates));
            canMoveLocates.AddRange(this.getDirection(inBoardLocates, koma));
            canMoveLocates.AddRange(this.getNormal(inBoardLocates));

            return canMoveLocates;

        }
 bool addMoveable(int row, int col, int rowOffset, int colOffset, List<int[]> moveable, Piece[,] board)
 {
     bool added = false;
     int destinationRow = row + rowOffset;
     int destinationCol = col + colOffset;
     if (uf.IsInBounds(destinationRow, destinationCol))
     {
         if (board[destinationRow, destinationCol].Colour != board[row, col].Colour && !cf.createCheck(row, col, destinationRow, destinationCol, board))
         {
             moveable.Add(new int[] { destinationRow, destinationCol });
             added = true;
         }
     }
     return added;
 }
 void pawnMoveHighlight(Piece piece, int row, int col, List<int[]> moveable, Piece[,] board)
 {
     //moving
     if (piece.PieceColour == Piece.Colour.Black && !board[row + 1, col].Exists)
     {
         addMoveable(piece.Row, piece.Col, 1, 0, moveable, board);
         if (!piece.HasMoved && !board[piece.Row + 2, piece.Col].Exists)
             addMoveable(piece.Row, piece.Col, 2, 0, moveable, board);
     }
     if (piece.PieceColour == Piece.Colour.White && !board[row - 1, col].Exists)
     {
         addMoveable(piece.Row, piece.Col, -1, 0, moveable, board);
         if (!piece.HasMoved && !board[piece.Row - 2, piece.Col].Exists)
             addMoveable(piece.Row, piece.Col, -2, 0, moveable, board);
     }
 }
Example #25
0
        private void cleanUp()
        {
            Gameboard copyOfGameboard = new Gameboard(gameboard);
            Rulebook rulebook = new Rulebook();
            List<Tuple<int, int>> copyOfValids = new List<Tuple<int, int>>();
            bool foundIllegalMove = false;

            Piece originalCurrentPiece;

            int currentTeam = copyOfCurrentPiece.team;
            int opponentTeam = info.getOpponent(currentTeam);

            foreach (Tuple<int, int> validMove in validDestinations) // För varje möjligt drag för markerad Piece
            {
                copyOfGameboard = new Gameboard(gameboard);
                originalCurrentPiece = copyOfGameboard.getPiece(copyOfCurrentPiece.row, copyOfCurrentPiece.column);
                Piece destination = copyOfGameboard.getPiece(validMove.Item1, validMove.Item2);

                copyOfGameboard.Move(originalCurrentPiece, destination); // Gör temporärt move
                foundIllegalMove = false;

                    foreach (Piece opponent in copyOfGameboard.getTeam(opponentTeam)) // För varje Piece i team OPPONENT
                    {
                        List<Tuple<int,int>> validDest = rulebook.getValidMoves(opponent, copyOfGameboard, false); // Hämta valid moves för Piece i OPPONENT (Utan hänsyn till möjliga drag som sätter kungen i schack..)
                        foreach (Tuple<int,int> coordinate in validDest) // För varje möjligt drag för Piece i OPPONENT
                        {
                            if (copyOfGameboard.getPiece(coordinate.Item1, coordinate.Item2).type == (int)type.king) // Om Piece i OPPONENT kan ta kungen i CURRENT
                            {
                                foundIllegalMove = true;
                                break;
                            }
                            if (foundIllegalMove)
                                break;
                        }
                        if (foundIllegalMove)
                            break;
                    }

                if (!foundIllegalMove)
                    copyOfValids.Add(new Tuple<int, int>(validMove.Item1, validMove.Item2));

                copyOfGameboard.setPiece(originalCurrentPiece);
                copyOfGameboard.setPiece(destination);
            }

            validDestinations = copyOfValids;
        }
Example #26
0
 public Gameboard(Gameboard originalGameboard)
 {
     for (int row = 0; row<8; ++row)
     {
         List<Piece> copyOfRow = new List<Piece>();
         foreach (Piece piece in originalGameboard.getRow(row))
         {
             Piece copyOfPiece = new Piece(piece);
             copyOfRow.Add(copyOfPiece);
             if (copyOfPiece.team == (int)team.black)
                 this.blackTeam.Add(copyOfPiece);
             else if (copyOfPiece.team == (int)team.white)
                 this.whiteTeam.Add(copyOfPiece);
         }
         this.gameboard.Add(copyOfRow);
     }
 }
Example #27
0
        public List<Tuple<int, int>> getValidMoves(Piece currentPiece, Gameboard gameboard, bool doRecurse = true)
        {
            this.copyOfCurrentPiece = new Piece(currentPiece);
            this.gameboard = new Gameboard(gameboard);

            switch (currentPiece.type)
            {
                case (int)type.rock: // tower
                    Rock rock = new Rock();
                    this.validDestinations = rock.Rules(currentPiece, gameboard);
                    if (doRecurse)
                        cleanUp();
                    return validDestinations;
                case (int)type.knight: // horsie
                    Knight knight = new Knight();
                    this.validDestinations = knight.Rules(currentPiece, gameboard);
                    if (doRecurse)
                        cleanUp();
                    return validDestinations;
                case (int)type.bishop: // springare
                    Bishop bishop = new Bishop();
                    this.validDestinations = bishop.Rules(currentPiece, gameboard);
                    if (doRecurse)
                        cleanUp();
                    return validDestinations;
                case (int)type.queen: //los quuenos
                    Queen queen = new Queen();
                    this.validDestinations = queen.Rules(currentPiece, gameboard);
                    if (doRecurse)
                        cleanUp();
                    return validDestinations;
                case (int)type.king: // los kingos
                    King king = new King();
                    this.validDestinations = king.Rules(currentPiece, gameboard);
                    if (doRecurse)
                        cleanUp();
                    return validDestinations;
                case (int)type.pawn: // los farmeros
                    Pawn pawn = new Pawn();
                    this.validDestinations = pawn.Rules(currentPiece, gameboard);
                    if (doRecurse)
                        cleanUp();
                    return validDestinations;
            }
            return new List<Tuple<int,int>>();
        }
Example #28
0
 public void InitializePlayfield(ref bool whiteTurn, ref bool gameDone, List<int[]> highlight, Piece[,] playfield, Piece[,] whiteTaken, Piece[,] blackTaken, ref int[] whiteTakenIndeces, ref int[] blackTakenIndeces)
 {
     //reseting parameters
     df.Clear();
     whiteTurn = true;
     gameDone = false;
     highlight.Clear();
     whiteTakenIndeces = new int[] { 0, 0 };
     blackTakenIndeces = new int[] { 0, 0 };
     for (int row = 0; row < 8; row++)
     {
         for (int col = 0; col < 8; col++)
         {
             //set piece type
             playfield[row, col] = new Piece() { Row = row, Col = col };
             if (row == 0 || row == 7)
             {
                 if (col == 0 || col == 7)
                     playfield[row, col].Type = rook;
                 if (col == 1 || col == 6)
                     playfield[row, col].Type = knight;
                 if (col == 2 || col == 5)
                     playfield[row, col].Type = bishop;
                 if (col == 3)
                     playfield[row, col].Type = queen;
                 if (col == 4)
                     playfield[row, col].Type = king;
             }
             if (row == 1 || row == 6)
                 playfield[row, col].Type = pawn;
             //set piece color
             if (row <= 1)
                 playfield[row, col].Colour = black;
             if (row >= 6)
                 playfield[row, col].Colour = white;
             if (row <= 1 || row >= 6)
                 playfield[row, col].Exists = true;
         }
         for (int col = 0; col < 2; col++)
         {
             whiteTaken[row, col] = new Piece();
             blackTaken[row, col] = new Piece();
         }
     }
 }
 void rookMoveHighlight(Piece.Colour colour, int row, int col, List<int[]> moveable, Piece[,] board)
 {
     bool canContinue = true;
     int i = 1;
     //check down
     while (canContinue)
     {
         addMoveable(row, col, i, 0, moveable, board);
         if (!uf.IsInBounds(row + i) || (uf.IsInBounds(row + i) && board[row + i, col].Exists))
             canContinue = false;
         i++;
     }
     //check up
     i = 1;
     canContinue = true;
     while (canContinue)
     {
         addMoveable(row, col, -i, 0, moveable, board);
         if (!uf.IsInBounds(row - i) || (uf.IsInBounds(row - i) && board[row - i, col].Exists))
             canContinue = false;
         i++;
     }
     //check right
     i = 1;
     canContinue = true;
     while (canContinue)
     {
         addMoveable(row, col, 0, i, moveable, board);
         if (!uf.IsInBounds(col + i) || (uf.IsInBounds(col + i) && board[row, col + i].Exists))
             canContinue = false;
         i++;
     }
     //check left
     i = 1;
     canContinue = true;
     while (canContinue)
     {
         addMoveable(row, col, 0, -i, moveable, board);
         if (!uf.IsInBounds(col - i) || (uf.IsInBounds(col - i) && board[row, col - i].Exists))
             canContinue = false;
         i++;
     }
 }
 void bishopMoveHighlight(string colour, int row, int col, List<int[]> moveable, Piece[,] board)
 {
     int i = 1;
     bool canContinue = true;
     //check down right
     while (canContinue)
     {
         addMoveable(row, col, i, i, moveable, board);
         if (!uf.IsInBounds(row + i, col + i) || (uf.IsInBounds(row + i, col + i) && board[row + i, col + i].Exists))
             canContinue = false;
         i++;
     }
     //check up right
     i = 1;
     canContinue = true;
     while (canContinue)
     {
         addMoveable(row, col, -i, i, moveable, board);
         if (!uf.IsInBounds(row - i, col + i) || (uf.IsInBounds(row - i, col + i) && board[row - i, col + i].Exists))
             canContinue = false;
         i++;
     }
     //check up left
     i = 1;
     canContinue = true;
     while (canContinue)
     {
         addMoveable(row, col, -i, -i, moveable, board);
         if (!uf.IsInBounds(row - i, col - i) || (uf.IsInBounds(row - i, col - i) && board[row - i, col - i].Exists))
             canContinue = false;
         i++;
     }
     //check down left
     i = 1;
     canContinue = true;
     while (canContinue)
     {
         addMoveable(row, col, i, -i, moveable, board);
         if (!uf.IsInBounds(row + i, col - i) || (uf.IsInBounds(row + i, col - i) && board[row + i, col - i].Exists))
             canContinue = false;
         i++;
     }
 }