/* Modified July 2004 by Robert H. Sloan <sloan@uic.edu> for a CS 202 * assignment at University of Illinois at Chicago; modfied by * Robert H. Sloan January 2007 for a CS 201 assignment. This program * remains free software under the GNU GPL. */import java.awt.*;import javax.swing.*;import javax.swing.border.*;import java.util.*;import java.awt.event.*;import java.io.*;/** A GUI for the game of Boggle. * * BoggleGUI defines and implements methods to do these things: * * 1. Draw the boggle board * 2. Manage the computer and human players' word lists * 3. Update the scoreboard * * BoggleGUI requires class BogglePlayer, to define these instance methods: * <PRE> * REMOVED BY SLOAN public void buildLexicon(Set wordList) * public void setBoard(String[] letterArray) * public SortedSet getAllValidWords(Lexicon words, int minimumWordLength) * REMOVED BY SLOAN: public boolean isInLexicon(String wordToCheck) * public java.util.List isOnBoard(String wordToCheck) * public String[] getCustomBoard() * </PRE> * * @author Michael Green * @author Paul Kube * * Copyright (C) 2002 Michael Green <mtgreen@cs.ucsd.edu> * Copyright (C) 2002 Paul Kube <kube@cs.ucsd.edu> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. See * http://www.gnu.org/copyleft/gpl.html */public class BoggleGUI extends JFrame { public static String WORDLISTFILENAME = "enable1.txt"; // default public static int DICEROWS = 4; // default public static int DICECOLS = 4; // default public static int MINIMUMWORDLENGTH = 3; // default private BogglePlayer computerPlayer; private BoggleBoard theBoard; private ScoreArea humanArea, computerArea; private WordEntryField wordEntryField; public Lexicon gameDictionary; // Sloan mod--don't make students do this public BoggleGUI() { super( "Welcome to CS201-OGLE!"); // create a BogglePlayer computer player to use computerPlayer = new BogglePlayer(); // Read word list from file and initialize computerPlayer's Lexicon initLexicon(); // Intialize graphics panels initPanels(); // Establish menu bar options and listeners for them setUpMenuBar(); // WindowClosing listener: for JDK 1.2 compatibility addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); }}); // Trust contained components to set their sizes; top level frame packs pack(); } /** * Get ready for a new game, given a letter list specification of * the Boggle board. */ public void newGame(String[] letterList) { // Tell theBoard about the board layout theBoard.setBoard(letterList); // Tell computerPlayer about the board layout computerPlayer.setBoard(letterList); // Prepare score areas humanArea.setReady(); computerArea.setReady(); // Clear board highlighting theBoard.unHighlightAllDice(); // Allow edits to text area and set focus wordEntryField.setReady(); // redraw the whole thing so it looks as nice as can be repaint(); } /** * Consider a word entered by the human player. */ public void checkAndAddWordHuman(String wordToCheck) { // clear any board highlighting theBoard.unHighlightAllDice(); // if empty word, the computer gets to take its turn if(wordToCheck.length() == 0) { wordEntryField.setUnready(); computerPlay(); return; } // check that word is: // (1) at least minimum length, (2) on the board, (3) in the lexicon, // (4) not already entered by the player if(wordToCheck.length() < MINIMUMWORDLENGTH) { chideUser(wordToCheck, "Less Than " + MINIMUMWORDLENGTH + " Letters"); return; } java.util.List letterLocations; // letterLocations = theBoard.getLocationsForWord(wordToCheck); // String wordOnBoard = theBoard.getWordFromLocations(letterLocations); // if(!wordToCheck.equalsIgnoreCase(wordOnBoard)) { // double check // we just trust the computer player to check this letterLocations = computerPlayer.isOnBoard(wordToCheck); if(letterLocations == null) { chideUser(wordToCheck, "Not On Board"); return; } if(!gameDictionary.contains(wordToCheck)) { chideUser(wordToCheck, "Not In Lexicon"); return; } if(humanArea.containsWord(wordToCheck)) { chideUser(wordToCheck, "Duplicate Word"); return; } // OK, this word passed our rigorous suite of tests. Add it humanArea.addWord(wordToCheck); // Highlight locations on board theBoard.highlightDice(letterLocations); wordEntryField.clear(); //clear the wordEntryField text } public void chideUser(String attemptedWord, String complaint) { JOptionPane.showMessageDialog(this, attemptedWord + ": " + complaint + "!!!", complaint, JOptionPane.ERROR_MESSAGE); wordEntryField.clear(); //clear the wordEntryField text } /** * Let the computer player take its turn. */ public void computerPlay() { computerArea.setName("Thinking!"); computerArea.paintImmediately(computerArea.getVisibleRect()); SortedSet allWords = computerPlayer.getAllValidWords(gameDictionary, MINIMUMWORDLENGTH); Iterator allWordsIterator = allWords.iterator(); computerArea.setName("Computer"); while(allWordsIterator.hasNext()) { String newWord = (String) allWordsIterator.next(); /* Computer doesn't get word if human has it */ if (!humanArea.containsWord(newWord)) { java.util.List wordPath = computerPlayer.isOnBoard(newWord); // Add word to appropriate score area & highlight appropriate dice computerArea.addWord(newWord); theBoard.highlightDice(wordPath); // pause for a tenth of a second // try {Thread.sleep(100); } catch (Exception e) {} } } theBoard.unHighlightAllDice(); // leave board unhighlighted when done } /** * Read word list from file with name WORDLISTFILENAME, and pass a Set * containing those words to the computer player to intialize its lexicon. */ private void initLexicon() { boolean EOF = false; HashSet<String> wordsFromFile = new HashSet(); System.err.print("Reading word list from file " + WORDLISTFILENAME + "..."); try { // Open File BufferedReader input = new BufferedReader( new FileReader(WORDLISTFILENAME)); String nextWord; while((nextWord = input.readLine()) != null) // there is a contract that words are all lowercase; but // we'll just assume it here for speed wordsFromFile.add(nextWord); //Close the file input.close(); } catch (FileNotFoundException fnfex ) { JOptionPane.showMessageDialog(null, "Unable to find word list file " + WORDLISTFILENAME, "Error", JOptionPane.ERROR_MESSAGE); } catch( IOException e) { JOptionPane.showMessageDialog(null, "Error Opening File", "Error", JOptionPane.ERROR_MESSAGE); } System.err.println(" Read " + wordsFromFile.size() + " words."); System.err.print("Building this game's lexicon... "); gameDictionary = new Lexicon(wordsFromFile); System.err.println("done."); } private void initPanels() { Container contentPane = getContentPane(); humanArea = new ScoreArea("Me"); computerArea = new ScoreArea("Computer"); theBoard = new BoggleBoard(DICEROWS,DICECOLS,computerPlayer); wordEntryField = new WordEntryField(); contentPane.add(wordEntryField,BorderLayout.SOUTH); contentPane.add(humanArea, BorderLayout.WEST); contentPane.add(theBoard, BorderLayout.CENTER); contentPane.add(computerArea, BorderLayout.EAST); } private void setUpMenuBar() { //Set Up Menu Bar JMenuBar menu = new JMenuBar(); // Game Menu JMenu gameMenu = new JMenu("Game"); gameMenu.setMnemonic('G'); menu.add(gameMenu); JMenuItem newRandom = new JMenuItem("New Random"); gameMenu.add(newRandom); newRandom.setMnemonic('N'); newRandom.addActionListener(new ActionListener() { public void actionPerformed( ActionEvent e) { newGame(theBoard.getRandomBoard()); }}); JMenuItem customGame = new JMenuItem("New Custom"); gameMenu.add(customGame); customGame.setMnemonic('C'); customGame.addActionListener(new ActionListener() { public void actionPerformed( ActionEvent e) { newGame(computerPlayer.getCustomBoard()); }}); JMenuItem quitGame = new JMenuItem("Quit"); gameMenu.add(quitGame); quitGame.setMnemonic('Q'); quitGame.addActionListener( new ActionListener() { public void actionPerformed( ActionEvent e) { System.exit(0); }}); // Help menu JMenu helpMenu = new JMenu("Help"); menu.add(helpMenu); helpMenu.setMnemonic('H'); JMenuItem aboutGame = new JMenuItem("About..."); helpMenu.add(aboutGame); aboutGame.setMnemonic('A'); aboutGame.addActionListener(new ActionListener() { public void actionPerformed( ActionEvent e) { JOptionPane.showMessageDialog(BoggleGUI.this, "It's ABOUT time you got to work", "About Game", JOptionPane.PLAIN_MESSAGE); }}); setJMenuBar(menu); } /** * A class defining the visual appearance of a Boggle board, and * defining some related methods. */ static class BoggleBoard extends JPanel { public static final Color BACKGROUNDCOLOR = new Color(255, 219, 13); private DiePanel theDice[][]; private Vector diceBag; // used for drawing dice for a random game private int rows, cols; private BogglePlayer theComputer; BoggleBoard(int rows, int cols, BogglePlayer theComputer ) { this.rows = rows; this.cols = cols; this.theComputer = theComputer; // create some dice to use when getting a random game initDiceBag(); // create a JPanel with rowsXcols GridLayout to hold the DiePanels JPanel innerPanel = new JPanel(); innerPanel.setLayout(new GridLayout(rows,cols,1,1)); innerPanel.setBackground(BACKGROUNDCOLOR); // Create Individual DiePanels, and add them theDice = new DiePanel[rows][cols]; for (int row = 0; row < rows; row++) { for (int col = 0; col < cols; col++) { theDice[row][col] = new DiePanel(); innerPanel.add(theDice[row][col]); } } innerPanel.setBorder(BorderFactory.createMatteBorder(10,10,10,10, BACKGROUNDCOLOR)); this.add(innerPanel); } // fill the diceBag with the 16 "official" Boggle dice for the 4X4 game private void initDiceBag() { diceBag = new Vector(16); diceBag.add(new Die("A", "O", "B", "B", "O", "J")); diceBag.add(new Die("W", "H", "G", "E", "E", "N")); diceBag.add(new Die("N", "R", "N", "Z", "H", "L")); diceBag.add(new Die("N", "A", "E", "A", "G", "E")); diceBag.add(new Die("D", "I", "Y", "S", "T", "T")); diceBag.add(new Die("I", "E", "S", "T", "S", "O")); diceBag.add(new Die("A", "O", "T", "T", "W", "O")); diceBag.add(new Die("H", "Qu", "U", "M", "N", "I")); diceBag.add(new Die("R", "Y", "T", "L", "T", "E")); diceBag.add(new Die("P", "O", "H", "C", "S", "A")); diceBag.add(new Die("L", "R", "E", "V", "Y", "D")); diceBag.add(new Die("E", "X", "L", "D", "I", "R")); diceBag.add(new Die("I", "E", "N", "S", "U", "E")); diceBag.add(new Die("S", "F", "F", "K", "A", "P")); diceBag.add(new Die("I", "O", "T", "M", "U", "C")); diceBag.add(new Die("E", "H", "W", "V", "T", "R")); } /** * Return an array of Strings showing the sequence of faces on * a randomly generated board. */ public String[] getRandomBoard() { // Get random faces from randomy selected dice to fill the letterList int diceBagSize = diceBag.size(); int boardSize = rows * cols; String[] letterList = new String[(rows * cols)]; // we try to handle any size board with a fixed diceBag for (int i = 0; i<boardSize; i++) { if(i % diceBagSize == 0 ) Collections.shuffle(diceBag); Die d = (Die) diceBag.elementAt(i % diceBagSize); letterList[i] = d.getRandomFace(); } // set the corresponding DiePanels, and return the result return letterList; } /** * Non-randomly reset the board according to * an array of Strings showing the sequence of faces on * the new board. Return the array. */ public void setBoard(String[] letterList) { if(letterList == null || letterList.length != rows*cols) { throw new IllegalArgumentException("setBoard(): String array length is not " + rows*cols); } //Set the DiePanels with given letters for (int row = 0; row < rows; row++) { for (int col = 0; col < cols; col++) { theDice[row][col].setFace(letterList[(row*cols) + col]); } } } public java.util.List getLocationsForWord(String word) { // we use the computer player for this return theComputer.isOnBoard(word); } public String getWordFromLocations(java.util.List locations) { int loc; int row,col; if (locations==null) return null; String result = ""; for(int i = 0; i < locations.size(); i++) { loc = ((Integer)locations.get(i)).intValue(); row = loc / rows; col = loc % cols; result += theDice[row][col].getFace(); } return result; } public void highlightDice(java.util.List locations) { if(locations == null) return; Integer loc; int row, col; unHighlightAllDice(); for(int i = 0; i < locations.size(); i++) { highlightDie((Integer) locations.get(i)); } this.paintImmediately(this.getVisibleRect()); } /** * Highlight the specified die, given row and column. */ public void highlightDie(int row, int column) { theDice[row][column].highlight(); } /** * Highlight the specified die, given Integer offset * from upper-left-hand corner, using left-to-right, * top-to-bottom ordering of dice. */ public void highlightDie(Integer indx) { int i = indx.intValue(); int row = i / theDice[0].length; int col = i % theDice[0].length; highlightDie(row, col); } /** * Unhighlight all dice. */ public void unHighlightAllDice() { for (int row = 0; row < theDice.length; row++) { for (int col = 0; col < theDice[row].length; col++) { theDice[row][col].unHighlight(); } } this.paintImmediately(this.getVisibleRect()); } static class Die { private String[] sides; private int currentSideUp; public Random randomizer = new Random(); public Die(String side1, String side2, String side3, String side4, String side5, String side6) { sides = new String[] {side1,side2,side3,side4,side5,side6}; randomize(); } public String getLetter() { return sides[currentSideUp]; } public String getRandomFace() { randomize(); return sides[currentSideUp]; } private void randomize() { currentSideUp = randomizer.nextInt(6); } } // For displaying one Die on the board static class DiePanel extends JPanel { private String face; private boolean isHighlighted; private JLabel faceLabel; private final Color DIECOLOR = new Color(230, 230, 230); private final Color FACECOLOR = new Color(3, 51, 217); private final Font FACEFONT = new Font("SansSerif", Font.PLAIN, 24); private final int DIESIZE = 50; public DiePanel() { face = new String(""); faceLabel = new JLabel("", SwingConstants.CENTER); setLayout(new BorderLayout()); add(faceLabel, BorderLayout.CENTER); setBackground(BoggleBoard.BACKGROUNDCOLOR); setSize(DIESIZE, DIESIZE); } public Dimension getPreferredSize() { return (new Dimension (DIESIZE+1, DIESIZE+1)); } public Dimension getMinimumSize() { return (getPreferredSize()); } public void setFace( String chars ) { face = chars; } public String getFace() { return face; } /** * Draw one die including the letter centered in the middle of the die. * If highlight is true, we * reverse the background and letter colors to highlight the die. */ public void paintComponent(Graphics g) { super.paintComponent(g); int centeredXOffset, centeredYOffset; // Draw the blank die g.setColor( (isHighlighted) ? FACECOLOR : DIECOLOR); g.fillRoundRect( 0, 0, DIESIZE, DIESIZE, DIESIZE/2, DIESIZE/2); // Outline the die with black g.setColor(Color.black); g.drawRoundRect( 0, 0, DIESIZE, DIESIZE, DIESIZE/2, DIESIZE/2); Graphics faceGraphics = faceLabel.getGraphics(); faceGraphics.setColor( isHighlighted ? DIECOLOR : FACECOLOR); Color myColor = isHighlighted ? DIECOLOR : FACECOLOR; faceLabel.setForeground(myColor); faceLabel.setFont(FACEFONT); faceLabel.setText(face); } public void unHighlight() { isHighlighted = false; } public void highlight() { isHighlighted = true; } } } // class BoggeBoard // Maintains name, score, and word list information for one player class ScoreArea extends JPanel { private final int WORDAREALINES = 16; private String playerName; private int playerScore, dimensionX, dimensionY; private HashSet wordList; private final Font ScoreFont = new Font("SansSerif", Font.PLAIN, 18); private final Font WordFont = new Font("Geneva", Font.PLAIN, 9); private final Font LabelFont = new Font("Helvitica", Font.PLAIN, 9); private final Color WordColor = new Color(3, 128, 77); private final Color LabelColor = new Color(3, 115, 64); private JPanel topPanel, wordPanel, namePanel, scorePanel; private JTextArea wordArea; private JLabel nameText, scoreText; public ScoreArea(String player) { playerName = new String(player); playerScore = 0; wordList = new HashSet(); // Set-Up Top of Score Area namePanel = new JPanel(); nameText = new JLabel(player); nameText.setFont(ScoreFont); namePanel.setLayout( new BorderLayout() ); namePanel.add(nameText, BorderLayout.CENTER); scorePanel = new JPanel(); scoreText = new JLabel(" 0"); scoreText.setFont(ScoreFont); scorePanel.setLayout( new BorderLayout() ); scorePanel.add(scoreText, BorderLayout.CENTER); topPanel = new JPanel(); topPanel.setLayout( new BorderLayout()); topPanel.add(namePanel, BorderLayout.WEST); topPanel.add(scorePanel, BorderLayout.EAST); // Create bordering for top panel Border raisedBevel, loweredBevel, compound; raisedBevel = BorderFactory.createRaisedBevelBorder(); loweredBevel = BorderFactory.createLoweredBevelBorder(); compound = BorderFactory.createCompoundBorder(raisedBevel, loweredBevel); topPanel.setBorder(compound); // Set-Up area to display word list wordPanel = new JPanel(); Border etched = BorderFactory.createEtchedBorder(); TitledBorder etchedTitle = BorderFactory.createTitledBorder(etched, "Word List"); etchedTitle.setTitleJustification(TitledBorder.RIGHT); wordPanel.setBorder(etchedTitle); wordArea = new JTextArea(WORDAREALINES, // 2/3 of max word len is a good # of columns BoggleGUI.DICEROWS*BoggleGUI.DICECOLS*2/3); wordArea.addMouseListener(new MouseAdapter() { public void mouseClicked(MouseEvent e) { // if double-click, highlight the selection on the board if(e.getClickCount() == 2) { String word = wordArea.getSelectedText().trim(); theBoard.highlightDice(theBoard.getLocationsForWord(word)); } }}); wordArea.setEditable(false); // for now wordPanel.add(new JScrollPane(wordArea, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)); setLayout(new BorderLayout()); add(topPanel, BorderLayout.NORTH); add(wordPanel, BorderLayout.CENTER); } public void setReady() { resetScore(); // zero out score wordList.clear(); // remove words from HashSet // remove words from TextArea wordArea.setEditable(true); wordArea.selectAll(); wordArea.cut(); wordArea.setEditable(false); paintImmediately(getVisibleRect()); } public void setName(String newName) { playerName = newName; nameText.setText(playerName); repaint(); } public boolean containsWord(String word) { return wordList.contains(word); } public void addWord(String word) { if (containsWord(word)) return; wordList.add(word); wordArea.append(" " +word+"\n"); addPoints(pointsForWord(word)); wordArea.paintImmediately(wordArea.getVisibleRect()); } /** * Define how many points a player gets for a given word. */ public int pointsForWord(String word) { return word.length() - BoggleGUI.MINIMUMWORDLENGTH + 1; } public void addPoints(int points) { playerScore += points; scoreText.setText(playerScore+""); scoreText.paintImmediately(scoreText.getVisibleRect()); } public void resetScore() { playerScore = 0; scoreText.setText(playerScore+""); scoreText.paintImmediately(scoreText.getVisibleRect()); } } // class ScoreArea class WordEntryField extends JPanel { private JTextField textField; public WordEntryField() { //Set up for human player's Text Entry Field textField = new JTextField(30); //Add listener to text entry field textField.addActionListener( new ActionListener() { public void actionPerformed( ActionEvent e) { checkAndAddWordHuman(textField.getText()); }}); this.add(new JLabel("Enter word: ")); this.add(textField); setUnready(); } public void clear() { textField.setText(""); } public void setUnready() { clear(); textField.setEditable(false); paintImmediately(getVisibleRect()); // attempt to give up focus to top-level frame BoggleGUI.this.requestFocus(); } public void setReady() { textField.setEditable(true); textField.requestFocus(); } } // class WordEntryField /** * The entry point for the BoggleGUI application. * Usage: * java BoggleGUI [ wordfile [ rows [ columns [ minwordlength ]]]] */ public static void main(String args[] ) { if(args.length > 0) WORDLISTFILENAME = args[0]; if(args.length > 1) DICECOLS = DICEROWS = Integer.parseInt(args[1]); /* if(args.length > 2) DICECOLS = Integer.parseInt(args[2]); */ if(args.length > 2) MINIMUMWORDLENGTH = Integer.parseInt(args[2]); System.err.println("Starting " + DICEROWS + "x" + DICECOLS + " game," + " words from " + WORDLISTFILENAME + ", min word length " + MINIMUMWORDLENGTH + "."); (new BoggleGUI()).setVisible(true); }}________________________________import java.util.ArrayList;import java.util.List;public class b0ggleLayout { private String[][] Grid; private String[] Board; private boolean[][] SelectedSquare; List<String> IntRepofStringOnBoard; List<Integer> LocationsInOrder = new ArrayList<Integer>(); //sets up the boggle board for use //this method works for sure public String[][] AssignGrid(String[] letterArray){ Board = letterArray; SelectedSquare = new boolean[Board.length][Board.length]; double sideLengthdbl = Math.sqrt(letterArray.length); int sideLengthint = (int)sideLengthdbl; Grid = new String[sideLengthint][sideLengthint]; for (int x = 0; x < letterArray.length; x++){ int row=x/4; int col=x%4; Grid[row][col]=letterArray[x]; } return Grid; } public List FindWord(String wordToCheck, int StringPos, int NextCenter, int BoardPosition, int row, int col){ System.out.println(" "); System.out.println("Stringpos " + StringPos); System.out.println("word to check: " + wordToCheck); System.out.println("wordToCheck.length " + wordToCheck.length()); System.out.println(" Cur Center: " + NextCenter); for(int x = 0; x < BoardPosition; x++){ System.out.println(" "); //finding the first letter linearly if(wordToCheck.length()+1<StringPos ){ //base case when the StringPosition to be checked is beyond the length of the Word To Check. System.out.println("Base Case!: "); for(int y = 0; y < LocationsInOrder.size(); y++){ /* simple loop to see * if the int representations * of the string locations are * being added in the 'correct * order * */ System.out.println("List with Locations in order: " + LocationsInOrder.get(y)); } System.out.println("locaTions in order " + LocationsInOrder.get(StringPos)); System.out.println("WordToCheck " + wordToCheck); System.out.println(" "); return LocationsInOrder; } else{ System.out.println("NotABaseCase: "); System.out.println(" "); System.out.println("Stringpos " + StringPos); System.out.println("word to check: " + wordToCheck); System.out.println("Looking for letter : " + wordToCheck.charAt(StringPos)); System.out.println("wordToCheck.length " + wordToCheck.length()); System.out.println(" Cur Center: " + NextCenter); System.out.println(" X is : " + x); System.out.println(" "); System.out.println(" row is: " + row); System.out.println(" col is: " + col); // I beleive the problem lays somewhere here int oldrow = row; // I can't quite think the recursion out correctly here int oldcol = col; String LetterToCheck = wordToCheck.charAt(StringPos)+""; row = x/Grid.length; col = x%Grid.length; System.out.println("row: " + row + " and col: " + col); System.out.println(" row is: " + row); System.out.println(" col is: " + col); System.out.println("Grid[row][col] " + Grid[row][col]); System.out.println(" "); System.out.println("SelectedSquare[row][col] == unselected if false" + SelectedSquare[row][col] ); System.out.println(" "); if (LetterToCheck.equalsIgnoreCase(Grid[row][col]) == true && SelectedSquare[row][col] == false ){ //found letter & not previously selected System.out.println(" row is: " + row); System.out.println(" col is: " + col); System.out.println("Found & not selected"); int CurrentPosition = row * Grid.length+col; int nextrow = CurrentPosition/Grid.length; // trying to work some magic int nextcol = CurrentPosition%Grid.length; System.out.println(" Next row: " + nextrow); System.out.println("Next col " + nextcol); System.out.println(" "); System.out.println("Looking for Letter To Check " + LetterToCheck); System.out.println("Found letter at " + CurrentPosition); System.out.println("Found letter at row: " + row + " and col: " + col); LocationsInOrder.add(CurrentPosition); // add spot to List of ints to be returned System.out.println(" "); SelectedSquare[oldrow][oldcol]=true; // mark unselectable System.out.println(" "); if (wordToCheck.charAt(StringPos+1)+""!=null){ String NextLetterToCheck = wordToCheck.charAt(StringPos+1)+""; // get the next letter to check NextCenter = FindAround(CurrentPosition, NextLetterToCheck, nextrow, nextcol) ; //next center is the next center to } //check around for the next letter System.out.println("next center: " + NextCenter); if (NextCenter < -50){ // failure case System.out.println("Not Found Around!"); // the next letter is not around this value LocationsInOrder.remove(LocationsInOrder.size()-1); } else{ System.out.println("List with Locations in order -_-__-_-== "); for(int y = 0; y < LocationsInOrder.size(); y++){ // same loop as earlier to check for validity System.out.println("List with Locations in order: " + LocationsInOrder.get(y)); } System.out.println("locaTions in order " + LocationsInOrder.get(StringPos)); System.out.println("WordToCheck " + wordToCheck); System.out.println(" "); FindWord(wordToCheck, StringPos+1, NextCenter, BoardPosition, oldrow, oldcol); // recursive search for finding the next value } } } } return LocationsInOrder; } public int FindAround(int CenterTile, String NextLetter, int row, int col){ System.out.println("Selected squre should be true: " + SelectedSquare[row][col]); System.out.println("At Spot " + Board[CenterTile]); System.out.println("Next Letter is: " + NextLetter); /*positions to test * 1 row,col-1 left * 2 row-1,col-1 left & up * 3 row-1,col up * 4 row-1,col+1 up & right * 5 row,col+1 right * 6 row+1,col+1 right & down * 7 row+1,col down * 8 row+1,col-1 down & left * */ System.out.println("Current Row and Column : " + row + " " + col); if(row<0 || row > 3 || col <0 || col > 3 ){ System.out.println("not on board"); return -101; } if( ((row >= 0) && (col-1 >=0)) && NextLetter.equalsIgnoreCase(Grid[row][col-1])==true){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row-1) >=0 && (col-1 >=0)) && NextLetter.equalsIgnoreCase(Grid[row-1][col-1])==true){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row-1) >= 0 && (col <= 3)) && NextLetter.equalsIgnoreCase(Grid[row-1][col])==true){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row-1) >= 0 && (col+1 <=3 )) && NextLetter.equalsIgnoreCase(Grid[row-1][col+1])==true){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row >= 0) && (col+1 <= 3)) && NextLetter.equalsIgnoreCase(Grid[row][col+1])==true){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row+1 <=3 ) && (col >=0 )) && NextLetter.equalsIgnoreCase(Grid[row+1][col])==true){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row+1 <= 3) && (col-1 >= 0)) && Grid[row+1][col-1]==NextLetter){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } if( ((row+1 <= 3) && (col+1 <= 3)) && Grid[row+1][col+1]==NextLetter){ System.out.println("Found lettertocheck: " + NextLetter); System.out.println("Found it at: " + row * Grid.length+col); return row * Grid.length+col; } else System.out.println("LetterToCheck: " + NextLetter); System.out.println("LetterToCheck is not found In FindAround"); return -100; }}___________________import java.util.ArrayList;import java.util.List;import java.util.SortedSet;public class BogglePlayer extends b0ggleLayout{ public BogglePlayer(){ } String[] theBoard; String[][] theGrid; List<Integer> boardIntLoc; b0ggleLayout NewBoard = new b0ggleLayout(); List<Integer> LocationsInOrder = new ArrayList<Integer>(); public void setBoard(String[] letterArray){ theBoard = letterArray; theGrid = NewBoard.AssignGrid(letterArray); } public List isOnBoard(String wordToCheck){ List<Integer> LocationsInOrder = new ArrayList<Integer>(); //returns list of integers of the word being checked LocationsInOrder = NewBoard.FindWord(wordToCheck, 0, 0, theBoard.length, 0, 0); return LocationsInOrder; } public SortedSet getAllValidWords(Lexicon words, int minimumWordLength){ // put here so it would compile & run SortedSet AllWords = null; return AllWords; } public String[] getCustomBoard(){ //put here so it would compile & run String[] aCustomBoard = {"hab" , "bah"}; return aCustomBoard; }}