public void PrintBoard(Piece selectedPiece = null) { Console.Clear(); var roundFlag = true; for (int i = _board.GetLength(0) - 1; i >= 0; i--) { Console.WriteLine("---------------------------------------------"); Console.Write($" {i + 1} |"); for (int j = 0; j < _board.GetLength(1); j++) { var piece = _board[i, j].OccupyingPiece; var pos = new PiecePosition(i, j); if (roundFlag) { Console.BackgroundColor = ConsoleColor.Gray; } else { Console.BackgroundColor = ConsoleColor.DarkGray; } roundFlag = !roundFlag; if (selectedPiece != null && selectedPiece.GetMoves().Any(m => m.GetMovePos().Position == pos)) { Console.BackgroundColor = ConsoleColor.Magenta; } if (piece == null) { Console.ForegroundColor = ConsoleColor.Black; Console.Write(" "); continue; } Console.ForegroundColor = piece.PieceOwner.Side == "bottom" ? ConsoleColor.DarkBlue : ConsoleColor.DarkRed; Console.Write($" {piece.VisualID} "); } // offset for checker board pattern. roundFlag = !roundFlag; Console.ResetColor(); Console.WriteLine(); } Console.WriteLine("---------------------------------------------"); for (int i = 0; i < _board.GetLength(1) + 1; i++) { Console.Write($"| {i} |"); } Console.WriteLine("\n---------------------------------------------"); }
void ListPossibleMoves() { board = null; pieces.Clear(); board = Board.instance.GetBoard(); listAvaliableMoves = new List <AIMoviment>(); //checking dark pieces for (int i = 0; i < board.GetLength(0); i++) { for (int j = 0; j < board.GetLength(1); j++) { if (board[i, j].currentPiece == null) { continue; } if (board[i, j].currentPiece.CheckPieceType(PieceTypes.Black)) { pieces.Add(board[i, j].currentPiece); } } } //list possible piece moves for (int i = 0; i < pieces.Count; i++) { //getting piece tile coordinates int actualRow = pieces[i].currentTile.row; int actualCol = pieces[i].currentTile.column; if (pieces[i].IsKing()) //if the actual piece is a king { //checking diagonals bool downRight = AIKingTile(pieces[i], actualRow + 1, actualCol + 1, 1, 1, PieceTypes.Black); bool downLeft = AIKingTile(pieces[i], actualRow + 1, actualCol - 1, 1, -1, PieceTypes.Black); bool upRight = AIKingTile(pieces[i], actualRow - 1, actualCol + 1, -1, 1, PieceTypes.Black); bool upLeft = AIKingTile(pieces[i], actualRow - 1, actualCol - 1, -1, -1, PieceTypes.Black); } else { if (pieces[i].IsDownMoviment()) { bool upRight = AIBoardTile(pieces[i], actualRow - 1, actualCol + 1, -1, 1, PieceTypes.Black); bool upLeft = AIBoardTile(pieces[i], actualRow - 1, actualCol - 1, -1, -1, PieceTypes.Black); } else { bool downRight = AIBoardTile(pieces[i], actualRow + 1, actualCol + 1, 1, 1, PieceTypes.Black); bool downLeft = AIBoardTile(pieces[i], actualRow + 1, actualCol - 1, 1, -1, PieceTypes.Black); } } } }
private void UpdateScores(int val, int row, int col) { RowsEval[row] += val; ColsEval[col] += val; if (row == col) { DiagsEval[0] += val; } if (row + col == BoardState.GetLength(0) - 1) { DiagsEval[1] += val; } }
bool OnBoardLimits(int row, int column) { if (row < 0 || row >= board.GetLength(0)) { return(false); } if (column < 0 || column >= board.GetLength(1)) { return(false); } return(true); }
/// <summary> /// Transposes an array (turns rows to columns and columns to rows). /// </summary> /// <param name="boardArray">Original untransposed array.</param> /// <returns></returns> public BoardTile[,] Transpose2DArray(BoardTile[,] boardArray) { int w = boardArray.GetLength(0); int h = boardArray.GetLength(1); BoardTile[,] result = new BoardTile[h, w]; for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { result[j, i] = boardArray[i, j]; } } return(result); }
//Updates the visual board private void UpdateBoard() { //Loop over each label for (int i = 0; i < bdtBoard.GetLength(0); i++) { for (int j = 0; j < bdtBoard.GetLength(1); j++) { //Get the current tile and its corresponding label BoardTile bdtCurTile = bdtBoard[i, j]; Label lblCurTile = lblTiles[i, j]; //Update the label's text and colors to reflect the symbol that it has lblCurTile.Text = bdtCurTile.GetDescription(); lblCurTile.BackColor = SystemColors.Control; lblCurTile.ForeColor = bdtCurTile.GetCorrespondingColor(); } } }
public GeneratedMove(bool isHorizontal, int startIndex, int endIndex, int[] anchor, Dictionary <BoardTile, CharTile> tilesUsed, BoardTile[,] boardBeforeMove, Rack rack) { IsHorizontal = isHorizontal; StartIndex = startIndex; EndIndex = endIndex; Anchor = anchor; TilesUsed = tilesUsed; Word = GetWord(); BoardBeforeMove = new BoardTile[boardBeforeMove.GetLength(0), boardBeforeMove.GetLength(1)]; RackTilesUsedCoordinates = new List <int[]>(); ExtraWordsPlayed = new List <List <BoardTile> >(); //Creates a copy of the original board before move generation //Used to get the scores of it and words connected. for (int i = 0; i < BoardBeforeMove.GetLength(0); i++) { for (int j = 0; j < BoardBeforeMove.GetLength(1); j++) { BoardBeforeMove[i, j] = new BoardTile { BoardLocationX = boardBeforeMove[i, j].BoardLocationX, BoardLocationY = boardBeforeMove[i, j].BoardLocationY, BoardTileType = boardBeforeMove[i, j].BoardTileType, CharTile = boardBeforeMove[i, j].CharTile, IsFilled = boardBeforeMove[i, j].IsFilled }; foreach (var tileUsed in TilesUsed) { if (BoardBeforeMove[i, j].BoardLocationX == tileUsed.Key.BoardLocationX && BoardBeforeMove[i, j].BoardLocationY == tileUsed.Key.BoardLocationY && BoardBeforeMove[i, j].CharTile == null) { RackTilesUsedCoordinates.Add(new int[] { i, j }); BoardBeforeMove[i, j].CharTile = tileUsed.Value; } } } } BoardAfterMove = BoardBeforeMove; Score = GetScore(); Rack = new Rack { Rack_CharTiles = new List <Rack_CharTile>(rack.Rack_CharTiles) }; RackScore = GetRackScore(Rack); }
public bool TileExists(Vector2 coords) { if (coords.X >= 0 && coords.X < boardTiles.GetLength(0) && coords.Y >= 0 && coords.Y < boardTiles.GetLength(1)) { return(Tile(coords) != null); } else { return(false); } }
public ChessBoard() { grid = new BoardTile[8, 8]; bool flag = true; for (int i = 0; i < grid.GetLength(0); i++) { for (int j = 0; j < grid.GetLength(1); j++) { Label temp; temp = new Label(); temp.AutoSize = false; Color tempColor; if (flag) { tempColor = Color.PeachPuff; } else { tempColor = Color.Peru; } temp.Size = new Size(50, 50); temp.Location = new Point((i * 50) + 120, ((j * 50) + 70)); temp.Visible = true; temp.BorderStyle = BorderStyle.Fixed3D; temp.Name = "Square"; grid[i, j] = new BoardTile(temp, tempColor); //GridArea(grid[i, j]); flag = !flag; } flag = !flag; } }
public void OriginalColorSquare() { for (int i = 0; i < grid.GetLength(0); i++) { for (int j = 0; j < grid.GetLength(1); j++) { grid[i, j].GetSquare().BackColor = grid[i, j].GetColor(); } } }
private void GenerateBoard() { if (board == null) { return; } float x = position.x, y = position.y, z = position.z; for (int i = 0; i < board.GetLength(0); i++) { for (int j = 0; j < board.GetLength(1); j++) { BoardTile tile = board[i, j]; z = position.z + j * posOffset; if (tile.type == BoardTileType.Target) { Instantiate(padTarget, new Vector3(x, y, z), Quaternion.identity); } else if (tile.type == BoardTileType.Path) { Instantiate(pad, new Vector3(x, y, z), Quaternion.identity); } else { continue; } // Check right path if (i < board.GetLength(0) - 1) { if (tile.rightPath) { Instantiate(path, new Vector3(x + 3, y, z), Quaternion.identity); } } // Check upper path if (j < board.GetLength(1) - 1) { if (tile.upPath) { Instantiate(path, new Vector3(x, y, z + 3), Quaternion.Euler(0, 90, 0)); } } } x += posOffset; } }
//public static bool IsRackPlayOneWayAndConnected(string[] rackTiles) //{ // HashSet<int> rowsUsed = new HashSet<int>(); // HashSet<int> columnsUsed = new HashSet<int>(); // foreach (var tile in rackTiles) // { // string[] tileDetails = GetTileDetails(tile); // rowsUsed.Add(Int32.Parse(tileDetails[0])); // columnsUsed.Add(Int32.Parse(tileDetails[1])); // } // if (rowsUsed.Count > 1 && columnsUsed.Count > 1) // { // return false; // } // return true; //} //public static bool ValidateStart(BoardTile[,] boardAsArray, string[] playedRackTiles) //{ // int[] startBoardTileCoordinates = null; // for (int i = 0; i < boardAsArray.GetLength(0); i++) // { // for (int j = 0; j < boardAsArray.GetLength(1); j++) // { // if (boardAsArray[i, j].BoardTileType.Type == "Start") // { // startBoardTileCoordinates = new int[] { i, j }; // } // if (boardAsArray[i, j].CharTile != null) return true; // } // } // bool startTileIsFilled = false; // bool tilesBeforeStartFilled = false; // foreach (var tile in playedRackTiles) // { // var tileDetails = GetTileDetails(tile); // var rowIndex = Int32.Parse(tileDetails[0]); // var columnIndex = Int32.Parse(tileDetails[1]); // if (rowIndex == startBoardTileCoordinates[0] && columnIndex == startBoardTileCoordinates[1]) // { // startTileIsFilled = true; // } // if (rowIndex < startBoardTileCoordinates[0] || columnIndex < startBoardTileCoordinates[1]) // { // tilesBeforeStartFilled = true; // } // } // if (startTileIsFilled && !tilesBeforeStartFilled) // { // return true; // } // return false; //} //public static bool IsRackPlayConnected(BoardTile[,] boardAsArray, string[] rackTiles) //{ // HashSet<int> rowsUsed = new HashSet<int>(); // HashSet<int> columnsUsed = new HashSet<int>(); // foreach (var tile in rackTiles) // { // var tileDetails = GetTileDetails(tile); // var rowIndex = Int32.Parse(tileDetails[0]); // var columnIndex = Int32.Parse(tileDetails[1]); // rowsUsed.Add(rowIndex); // columnsUsed.Add(columnIndex); // } // if (rowsUsed.Count > 1 && columnsUsed.Count > 1) // { // return false; // } // if (rowsUsed.Count == 1 && columnsUsed.Count == 1) // { // var tileIsConnected = false; // var rowIndex = rowsUsed.FirstOrDefault(); // var columnIndex = columnsUsed.FirstOrDefault(); // if ((boardAsArray[rowIndex + 1, columnIndex] != null && boardAsArray[rowIndex + 1, columnIndex].CharTile != null) // || (boardAsArray[rowIndex - 1, columnIndex] != null && boardAsArray[rowIndex - 1, columnIndex].CharTile != null) // || (boardAsArray[rowIndex, columnIndex + 1] != null && boardAsArray[rowIndex, columnIndex + 1].CharTile != null) // || (boardAsArray[rowIndex, columnIndex - 1] != null && boardAsArray[rowIndex, columnIndex - 1].CharTile != null)) // { // tileIsConnected = true; // } // if (!tileIsConnected) // { // return false; // } // } // var directionOfPlay = ""; // var rowsUsedSorted = rowsUsed.ToList(); // rowsUsedSorted.Sort(); // var columnsUsedSorted = columnsUsed.ToList(); // columnsUsedSorted.Sort(); // var multipleIndexes = rowsUsedSorted.Count > columnsUsedSorted.Count ? rowsUsedSorted : columnsUsedSorted; // var secondaryIndex = rowsUsedSorted.Count > columnsUsedSorted.Count ? columnsUsedSorted : rowsUsedSorted; // directionOfPlay = rowsUsedSorted.Count > columnsUsedSorted.Count ? "transposed" : "untransposed"; // for (var i = multipleIndexes[0]; i < multipleIndexes[multipleIndexes.Count - 1]; i++) // { // var checkedTile = directionOfPlay == "untransposed" ? boardAsArray[secondaryIndex[0], i] : boardAsArray[i, secondaryIndex[0]]; // if (checkedTile.CharTile == null) // { // var boardTileHasTemporaryPlacedRackTile = false; // foreach (var rackTile in rackTiles) // { // var tileDetails = GetTileDetails(rackTile); // var rowIndex = Int32.Parse(tileDetails[0]); // var columnIndex = Int32.Parse(tileDetails[1]); // if (rowIndex == checkedTile.BoardLocationX && columnIndex == checkedTile.BoardLocationY) // { // boardTileHasTemporaryPlacedRackTile = true; // break; // } // } // if (!boardTileHasTemporaryPlacedRackTile) // { // return false; // } // } // } // return true; //} /// <summary> /// Given a tile, checks the vertical word that it forms /// </summary> /// <param name="board">Board to scan</param> /// <param name="rackTileCoordinates">Coordinates of rack tile played</param> /// <returns></returns> public static List <BoardTile> GetVerticalPlays(BoardTile[,] board, int[] rackTileCoordinates) { var word = new List <BoardTile>(); var upIndexCounter = rackTileCoordinates[0]; var downIndexCounter = rackTileCoordinates[0]; var columnIndex = rackTileCoordinates[1]; while (upIndexCounter > 0 && board[upIndexCounter - 1, columnIndex].CharTile != null) { word.Insert(0, board[upIndexCounter - 1, columnIndex]); upIndexCounter--; } word.Add(board[rackTileCoordinates[0], rackTileCoordinates[1]]); while (downIndexCounter < board.GetLength(0) - 1 && board[downIndexCounter + 1, columnIndex].CharTile != null) { word.Add(board[downIndexCounter + 1, columnIndex]); downIndexCounter++; } if (word.Count < 2) { return(null); } return(word); }
/// <summary> /// Builds all possible right parts for given anchor /// </summary> /// <param name="partialWord">Word preceding right part</param> /// <param name="anchor">Tile from which to build up right part</param> /// <param name="boardArray">Board to work with</param> /// <param name="validCrossChecks">List of valid cross checks for all empty tiles</param> /// <param name="validMovesList">List of valid moves that gets updated</param> /// <param name="boardIsHorizontal">Board is untransposed or transposed</param> /// <param name="boardBeforeMove">Board before any moves were generated</param> /// <param name="tileExtendedWith">Tile that was used to extend the right part</param> public void ExtendRight(string partialWord, int[] anchor, BoardTile[,] boardArray, Dictionary <BoardTile, List <CharTile> > validCrossChecks, HashSet <GeneratedMove> validMovesList, bool boardIsHorizontal, BoardTile[,] boardBeforeMove, CharTile tileExtendedWith = null) { //If no tile is present.. if (boardArray[anchor[0], anchor[1]].CharTile == null) { //If word up until current tile is valid.. if (Helper.CheckWordValidity(Dawg, partialWord)) { //If the move (word, row and column indexes) has not been added already.. if (!Moves.Any(m => m.Word.Equals(partialWord))) { //Adds generated move to list of valid moves Dictionary <BoardTile, CharTile> tilesUsed = new Dictionary <BoardTile, CharTile>(); //Adds tiles that were used in move for (int i = 0; i < partialWord.Length; i++) { var letter = partialWord[i]; var boardTile = boardArray[anchor[0], anchor[1] - partialWord.Length + i]; if (boardTile.CharTile != null) { tilesUsed.Add(boardTile, boardTile.CharTile); } else { tilesUsed.Add(boardTile, tileExtendedWith); } } validMovesList.Add(new GeneratedMove(boardIsHorizontal, anchor[1] - partialWord.Length, anchor[1] - 1, anchor, tilesUsed, boardBeforeMove, RackOfCurrentPlayer)); } } //GEts all letters that can follow current right part word HashSet <string> labelsOfDawgEdges = new HashSet <string>(new DawgEdgeEqualityComparer()); var wordsWithCommonPreffix = Dawg.MatchPrefix(partialWord); foreach (var word in wordsWithCommonPreffix) { labelsOfDawgEdges.Add(word.Key.Substring(partialWord.Length)); } foreach (var label in labelsOfDawgEdges) { //If the valid letter is in our rack and can be played on the board tile, places it and extends right again //with the newly filled board tile used as anchor if board limit is not reached if (label == "") { continue; } if (RackOfCurrentPlayer.CheckIfTileIsInRack(label[0], true) && (!validCrossChecks.Any(c => c.Key == boardArray[anchor[0], anchor[1]]) || validCrossChecks.Any(c => c.Key == boardArray[anchor[0], anchor[1]] && c.Value.Any(x => x.Letter == label[0])))) { CharTile tileToWorkWith = null; if (RackOfCurrentPlayer.CheckIfTileIsInRack(label[0], false)) { tileToWorkWith = Dictionary.CharTiles.Where(c => c.Letter == label[0] && c.Score != 0).FirstOrDefault(); } else { tileToWorkWith = Dictionary.CharTiles.Where(c => c.Letter == '*').FirstOrDefault(); } RackOfCurrentPlayer.SubstractFromRack(tileToWorkWith); boardArray[anchor[0], anchor[1]].CharTile = Dictionary.CharTiles.Where(c => c.Letter == label[0] && c.Score == tileToWorkWith.Score).FirstOrDefault(); if (anchor[1] < boardArray.GetLength(1) - 1) { ExtendRight(partialWord + label[0], new int[] { anchor[0], anchor[1] + 1 }, boardArray, validCrossChecks, validMovesList, boardIsHorizontal, boardBeforeMove, tileToWorkWith); } //Otherwise places the tile on the last empty square of the board, checks if its valid and doesn't attempt to extend anymore else { var finalWord = partialWord + boardArray[anchor[0], anchor[1]].CharTile.Letter; if (Helper.CheckWordValidity(Dawg, finalWord)) { if (!Moves.Any(m => m.Word.Equals(finalWord))) { Dictionary <BoardTile, CharTile> tilesUsed = new Dictionary <BoardTile, CharTile>(); for (int i = 0; i < finalWord.Length; i++) { var letter = finalWord[i]; var boardTile = boardArray[anchor[0], anchor[1] - finalWord.Length + 1 + i]; if (boardTile.CharTile != null) { tilesUsed.Add(boardTile, boardTile.CharTile); } else { tilesUsed.Add(boardTile, tileToWorkWith); } } validMovesList.Add(new GeneratedMove(boardIsHorizontal, anchor[1] - finalWord.Length + 1, anchor[1], anchor, tilesUsed, boardBeforeMove, RackOfCurrentPlayer)); } } } RackOfCurrentPlayer.AddToRack(tileToWorkWith); boardArray[anchor[0], anchor[1]].CharTile = null; } } } //Otherwise if the current tile is already taken and not empty, used letter from board tile to build to the right again else { var tile = boardArray[anchor[0], anchor[1]].CharTile; HashSet <string> labelsOfDawgEdges = new HashSet <string>(new DawgEdgeEqualityComparer()); var wordsWithCommonPreffix = Dawg.MatchPrefix(partialWord + tile.Letter); foreach (var word in wordsWithCommonPreffix) { labelsOfDawgEdges.Add(word.Key.Substring((partialWord + tile.Letter).Length)); } //Extends right if any letters can follow the current right part if (labelsOfDawgEdges.Any() && anchor[1] < boardArray.GetLength(1) - 1) { ExtendRight(partialWord + tile.Letter, new int[] { anchor[0], anchor[1] + 1 }, boardArray, validCrossChecks, validMovesList, boardIsHorizontal, boardBeforeMove, tile); } } }
//public static Dictionary<BoardTile, List<CharTile>> GetValidCrossChecksOneWay(BoardTile[,] boardArray, WordDictionary dictionary) //{ // var dawg = LoadDawg(dictionary.GameLanguage); // Dictionary<BoardTile, List<CharTile>> validCrossChecks = new Dictionary<BoardTile, List<CharTile>>(); // List<int[]> tilesAlreadyChecked = new List<int[]>(); // StringBuilder sb = new StringBuilder(); // for (int i = 0; i < boardArray.GetLength(0); i++) // { // for (int j = 0; j < boardArray.GetLength(1); j++) // { // sb.Clear(); // if (boardArray[i, j].CharTile == null) // { // var upIndexCounter = i; // var downIndexCounter = i; // while (upIndexCounter > 0 && boardArray[upIndexCounter - 1, j].CharTile != null) // { // sb.Insert(0, boardArray[upIndexCounter - 1, j].CharTile.Letter); // upIndexCounter--; // } // sb.Append("_"); // while (downIndexCounter < boardArray.GetLength(0) - 1 && boardArray[downIndexCounter + 1, j].CharTile != null) // { // sb.Append(boardArray[downIndexCounter + 1, j].CharTile.Letter); // downIndexCounter++; // } // if (sb.Length == 1) // { // continue; // } // else // { // var wordWithUnderscore = sb.ToString(); // var sbTemp = new StringBuilder(wordWithUnderscore); // if (!validCrossChecks.ContainsKey(boardArray[i, j])) // { // validCrossChecks.Add(boardArray[i, j], new List<CharTile>()); // } // foreach (var c in dictionary.CharTiles) // { // if (c.Score == 0) continue; // sbTemp.Replace('_', c.Letter); // if (CheckWordValidity(dawg, sbTemp.ToString())) // { // if (validCrossChecks.ContainsKey(boardArray[i, j])) // { // if (!validCrossChecks[boardArray[i, j]].Contains(c)) // { // validCrossChecks[boardArray[i, j]].Add(c); // } // } // } // sbTemp.Clear(); // sbTemp.Append(wordWithUnderscore); // } // } // } // } // } // return validCrossChecks; //} /// <summary> /// Goes through a board and gets all anchors and crosschecks for board tiles /// </summary> /// <param name="boardArray">Array to go over. May be untransposed or transposed</param> /// <param name="dictionary">Collection of CharTiles to look up to</param> /// <param name="validCrossChecks">List of valid cross checks to update</param> /// <param name="anchors">List of anchors to update</param> public static void GetValidCrossChecksAndAnchors(BoardTile[,] boardArray, WordDictionary dictionary, Dictionary <BoardTile, List <CharTile> > validCrossChecks, List <int[]> anchors) { var dawg = LoadDawg(dictionary.GameLanguage); StringBuilder sb = new StringBuilder(); var noMovesMadeYet = false; var startTileRow = 0; var startTileColumn = 0; for (int i = 0; i < boardArray.GetLength(0); i++) { for (int j = 0; j < boardArray.GetLength(1); j++) { ///If board tile has been played on the Start tile, the game hasn't started if (boardArray[i, j].CharTile == null) { if (boardArray[i, j].BoardTileTypeID == BoardTileTypeEnum.Start) { startTileRow = i; startTileColumn = j; noMovesMadeYet = true; } ///Gets letters from above and below current tile to form a word with a gap from the currently iterated board tile sb.Clear(); var upIndexCounter = i; var downIndexCounter = i; while (upIndexCounter > 0 && boardArray[upIndexCounter - 1, j].CharTile != null) { sb.Insert(0, boardArray[upIndexCounter - 1, j].CharTile.Letter); upIndexCounter--; } sb.Append("_"); while (downIndexCounter < boardArray.GetLength(0) - 1 && boardArray[downIndexCounter + 1, j].CharTile != null) { sb.Append(boardArray[downIndexCounter + 1, j].CharTile.Letter); downIndexCounter++; } //If no word is formed, continue to next board tile if (sb.Length == 1) { continue; } //Else section replaces gap with all letters in alphabet to see which letters would fit to make a valid word //Letters form the valid cross check set //Cross check is stored as a dictionary object of board tile and a collection of char tiles //This means for a given board tile, the following letters from the char tiles are valid //If the collection is empty, no letter is a valid fit for the board tile //If board tile (key) entry doesn't exist in the list, all letters are valid for that board tile (for now) else { var wordWithUnderscore = sb.ToString(); var sbTemp = new StringBuilder(wordWithUnderscore); if (!validCrossChecks.ContainsKey(boardArray[i, j])) { validCrossChecks.Add(boardArray[i, j], new List <CharTile>()); } foreach (var c in dictionary.CharTiles) { if (c.Score == 0) { continue; } sbTemp.Replace('_', c.Letter); if (CheckWordValidity(dawg, sbTemp.ToString())) { if (validCrossChecks.ContainsKey(boardArray[i, j])) { if (!validCrossChecks[boardArray[i, j]].Contains(c)) { validCrossChecks[boardArray[i, j]].Add(c); } } } sbTemp.Clear(); sbTemp.Append(wordWithUnderscore); } } //Checks surrounding tiles if they can be used as anchors } else { if (i > 0 && boardArray[i - 1, j].CharTile == null) { if (anchors != null) { var coordinates = new int[] { i - 1, j }; if (!anchors.Any(c => c[0] == coordinates[0] && c[1] == coordinates[1])) { anchors.Add(coordinates); } } } if (i < boardArray.GetLength(0) - 1 && boardArray[i + 1, j].CharTile == null) { if (anchors != null) { var coordinates = new int[] { i + 1, j }; if (!anchors.Any(c => c[0] == coordinates[0] && c[1] == coordinates[1])) { anchors.Add(coordinates); } } } if (j > 0 && boardArray[i, j - 1].CharTile == null) { { var coordinates = new int[] { i, j - 1 }; if (!anchors.Any(c => c[0] == coordinates[0] && c[1] == coordinates[1])) { anchors.Add(coordinates); } } } if (j < boardArray.GetLength(1) - 1 && boardArray[i, j + 1].CharTile == null) { var coordinates = new int[] { i, j + 1 }; if (!anchors.Any(c => c[0] == coordinates[0] && c[1] == coordinates[1])) { anchors.Add(coordinates); } } } } } if (noMovesMadeYet) { anchors.Clear(); anchors.Add(new int[] { startTileRow, startTileColumn }); } return; }