I need help with my assignment package mines; /** * minesweeper class provides t

ID: 3824545 • Letter: I

Question

I need help with my assignment

package mines;

/**
* minesweeper class provides the data 
* and methods for a minesweper game 
* 
* Level 1 - data & methods to implement 
* Mines, Clues, Tiles, basic Board characters, 
* and opening/marking tiles
* Level 2 - Additional data & methods to support game status 
* and extended Board characters 
* 
* minesweeper.java 
* spring 2004 
* 
*/
public class Minesweeper {

   /** mine and clue values, 9 - mine, 0-8 clue values
   *
   */
   public int[][] mines;

/** tile values 0 - open, 1 - closed, 
 * 2 - question, 3 - mine
 */
 public int[][] tiles;

   /** Level 2 - game status win, lose, play
   */
   private String status;

/** default constructor 
 * board size 9 x 9 
 * create mines and tile arrays 
 * place mines 
 * calculate clues 
 * (*)set game status to play 
 */
 public minesweeper() {
 initGame(9, 9);
 }

/** alternate constructor
 * use specifies board size 
 * create mines and tile arrays 
 * place mines 
 * calculate clues 
 * (*)set game status to play 
 * @param newRows number of rows for grid 
 * @param newCols number of columns for grid 
 */
 public minesweeper(int newRows, int newCols) {
 initGame(newRows, newCols);
 }

   /** Level 2 - game status
   * @return "play", "win", or "lose"
   */
   public String getStatus() {
       return status;
   }

   /** number of rows for board
   * @return number of rows
   */
   public int getRows() {
       return mines.length;
   }

   /** number of columns for board
   * @return number of columns
   */
   public int getCols() {
       return mines[0].length;
   }

/** value of the mines array at r,c 
 * -1 is returned if invalid r,c
 * @param r row index
 * @param c column index
 * @return value of mines array, -1 if invalid
 */
 public int getMines(int r, int c) {
 if (validIndex(r, c)) {
 return mines[r][c];
 } else {
 return -1;
 }
 }

/** value of the tiles array at r,c
 * -1 is returned if invalid r,c 
 * @param r row index
 * @param c column index
 * @return value of tiles array, -1 if invalid
 */
 public int getTiles(int r, int c) {
 if (validIndex(r, c)) {
 return tiles[r][c];
 } else {
 return -1;
 }
 }

/** mark tile - open tile, close tile, 
 * flag tile as mine, set tile as question mark, close tile 
 * 
 * Level 1 - Requirements 
 * - invalid r,c values must be ignored 
 * - a tile that is opened must stay open 
 * - a tile that is marked as a flag (ie. tile[][] value 3) can not be opened 
 * 
 * Level 2 - Requirements 
 * - tile values can only change when game status is "play" 
 * - game status must be updated after a tile is opened 
 * 
 * @param r row index 
 * @param c column index 
 * @param t 0 - open, 1 - close, 2 - question, 3 - mine 
 */
 public void markTile(int r, int c, int t) {
 // add your code here
 }

   /** mines array as String
   * @return mines array as a String
   */
   public String toStringMines() {
       String result = " ";

for (int r = 0; r < mines.length; r++) {
 for (int c = 0; c < mines[r].length; c++)
 result = result + mines[r][c];

result += " ";
}

return result;
}

   /** tiles array as String
       * @return mines array as a String
       */
   public String toStringTiles() {
       String result = " ";

for (int r = 0; r < mines.length; r++) {
 for (int c = 0; c < mines[r].length; c++)
 result = result + tiles[r][c];

result += " ";
}

return result;
}

   /** game board array as String
   * @return game board as String
   */
   public String toStringBoard() {
       String result = "";

for (int r = 0; r < tiles.length; r++) {
 for (int c = 0; c < tiles[r].length; c++) {
 result += this.getBoard(r, c);
 }
 result += " "; //advance to next line
 }

return result;
}

/** getBoard - determines current game board character for r,c position 
 * using the value of the mines[][] and tiles[][]array 
 * Note: Level 2 values are returned when 
 * game is over (ie. status is "win" or "lose") 
 * 
 * Level 1 values 
 * '1'-'8' opened tile showing clue value 
 * ' ' opened tile blank 
 * 'X' tile closed 
 * '?' tile closed marked with ? 
 * 'F' tile closed marked with flag 
 * '*' mine 
 * 
 * Level 2 values 
 * '-' if game lost, mine that was incorrectly flagged 
 * '!' if game lost, mine that ended game 
 * 'F' if game won, all mines returned with F
 * 
 * @return char representing game board at r,c
 */
 public char getBoard(int r, int c) {
 // add your code here
 return 'X'; //this line must be modified
 }

/** create mines & tiles array
 * place mines 
 * update clues 
 * @param newRows number of rows for grid
 * @param newCols number of columns for grid
 */
 private void initGame(int newRows, int newCols) {
 //allocate space for mines and tiles array
 if ((newRows >= 1) && (newCols >= 1)) {
 mines = new int[newRows][newCols];
 tiles = new int[newRows][newCols];

//init tiles array
resetTiles();

//place mines
placeMines();

//update clues
calculateClues();

           //set game status
           status = "play";
       }
   }

   /** Sets all tiles to 1 - closed
   */
   private void resetTiles() {
       //       add your code here
   }

/** places mines randomly on grid
 * integer value 9 represents a mine 
 * number of mines = (1 + number of columns * number rows) / 10 
 * minimum number of mines = 1 
 */
 private void placeMines() {
 // add your code here
 }

/** calculates clue values and updates
 * clue values in mines array 
 * integer value 9 represents a mine 
 * clue values will be 0 ... 8 
 */
 private void calculateClues() {
 // add your code here
 }

   /** determines if x,y is valid position
   * @param x row index
   * @param y column index
   * @return true if valid position on board,
   * false if not valid board position
   */
   private boolean validIndex(int x, int y) {
       //add your code here

return true; //this line must be modified
}

   /** Level 2 - game won status
   * @return true if game won
   * false if game not won
   */
   private boolean gameWon() {
       //add your code here
       return false; //this line must be modified
   }

}

Explanation / Answer

As far as i can understand the code.... i have tried implementing it.. Plese forgive, in case if i missed something..

import java.util.HashSet;
import java.util.Random;

/**
* minesweeper class provides the data 
* and methods for a minesweper game 
* 
* Level 1 - data & methods to implement 
* Mines, Clues, Tiles, basic Board characters, 
* and opening/marking tiles
* 
* Level 2 - Additional data & methods to support game status 
* and extended Board characters 
* 
* minesweeper.java 
* spring 2004 
* 
*/
public class Minesweeper {
 /**
 * mine and clue values, 9 - mine, 0-8 clue values
 *
 */
 public int[][] mines;

/**
 * tile values 0 - open, 1 - closed, 
 * 2 - question, 3 - mine
 */
 public int[][] tiles;

   /**
   * Level 2 - game status win, lose, play
   */
   private String status;

/**
 * default constructor 
 * board size 9 x 9 
 * create mines and tile arrays 
 * place mines 
 * calculate clues 
 * (*)set game status to play 
 */
 public Minesweeper() {
 initGame(9, 9);
 }

/**
 * alternate constructor use specifies board size 
 * create mines and tile arrays 
 * place mines 
 * calculate clues 
 * (*)set game status to play 
 *
 * @param newRows
 * number of rows for grid 
 * @param newCols
 * number of columns for grid 
 */
 public Minesweeper(int newRows, int newCols) {
 initGame(newRows, newCols);
 }

   /**
   * Level 2 - game status
   *
   * @return "play", "win", or "lose"
   */
   public String getStatus() {
       return status;
   }

   /**
   * number of rows for board
   *
   * @return number of rows
   */
   public int getRows() {
       return mines.length;
   }

   /**
   * number of columns for board
   *
   * @return number of columns
   */
   public int getCols() {
       return mines[0].length;
   }

/**
 * value of the mines array at r,c 
 * -1 is returned if invalid r,c
 *
 * @param r
 * row index
 * @param c
 * column index
 * @return value of mines array, -1 if invalid
 */
 public int getMines(int r, int c) {
 if (validIndex(r, c)) {
 return mines[r][c];
 } else {
 return -1;
 }
 }

/**
 * value of the tiles array at r,c -1 is returned if invalid r,c 
 *
 * @param r
 * row index
 * @param c
 * column index
 * @return value of tiles array, -1 if invalid
 */
 public int getTiles(int r, int c) {
 if (validIndex(r, c)) {
 return tiles[r][c];
 } else {
 return -1;
 }
 }

/**
 * mark tile - open tile, close tile, 
 * flag tile as mine, set tile as question mark, close tile 
 * 
 * Level 1 - Requirements 
 * - invalid r,c values must be ignored 
 * - a tile that is opened must stay open 
 * - a tile that is marked as a flag (ie. tile[][] value 3) can not be
 * opened 
 * 
 * Level 2 - Requirements 
 * - tile values can only change when game status is "play" 
 * - game status must be updated after a tile is opened 
 * 
 *
 * @param r
 * row index 
 * @param c
 * column index 
 * @param t
 * 0 - open, 1 - close, 2 - question, 3 - mine 
 */
 public void markTile(int r, int c, int t) {
 // add your code here
 if (validIndex(r, c)) {
 if ((tiles[r][c] == 0) || (t == 0 && tiles[r][c] == 3)) {
 return;
 }

 // no tile can be closed
 if(t == 1)
 return;

 if (!status.equals("play")) {
 tiles[r][c] = t;

 // if we try to open a mine
 if(mines[r][c] == 9 && t==0) {
 status = "lose";
 return;
 }
 // recalculate status
 gameWon();
 }
 }
 }

/**
 * mines array as String
 *
 * @return mines array as a String
 */
 public String toStringMines() {
 String result = " ";
 for (int r = 0; r < mines.length; r++) {
 for (int c = 0; c < mines[r].length; c++)
 result = result + mines[r][c];
 result += " ";
 }
 return result;
 }

/**
 * tiles array as String
 *
 * @return mines array as a String
 */
 public String toStringTiles() {
 String result = " ";
 for (int r = 0; r < mines.length; r++) {
 for (int c = 0; c < mines[r].length; c++)
 result = result + tiles[r][c];
 result += " ";
 }
 return result;
 }

/**
 * game board array as String
 *
 * @return game board as String
 */
 public String toStringBoard() {
 String result = "";
 for (int r = 0; r < tiles.length; r++) {
 for (int c = 0; c < tiles[r].length; c++) {
 result += this.getBoard(r, c);
 }
 result += " "; // advance to next line
 }
 return result;
 }

/**
 * getBoard - determines current game board character for r,c position 
 * using the value of the mines[][] and tiles[][]array 
 * Note: Level 2 values are returned when 
 * game is over (ie. status is "win" or "lose") 
 * 
 * 
 * Level 1 values 
 * '1'-'8' opened tile showing clue value 
 * ' ' opened tile blank 
 * 'X' tile closed 
 * '?' tile closed marked with ? 
 * 'F' tile closed marked with flag 
 * '*' mine 
 * 
 * 
 * Level 2 values 
 * '-' if game lost, mine that was incorrectly flagged 
 * '!' if game lost, mine that ended game 
 * 'F' if game won, all mines returned with F 
 *
 * @return char representing game board at r,c
 */
 public char getBoard(int r, int c) {
 if (status.equals("win")) {
 // level 2
 if(mines[r][c] == 9) {
 return 'F';
 }
 } else if (status.equals("lose")) {
 // level 2
 if(mines[r][c] != 9 && tiles[r][c] == 3)
 return '-';
 if(mines[r][c] != 9 && tiles[r][c] == 0)
 return '!';

 } else {
 // level 1
 if (tiles[r][c] == 0) {
 if (mines[r][c] == 0)
 return ' ';
 else if (mines[r][c] == 9)
 return '*';
 else
 return numToChar(mines[r][c]);
 } else if (tiles[r][c] == 1) {
 return 'X';
 } else if (tiles[r][c] == 2) {
 return '?';
 } else {
 return 'F';
 }
 }
 return ' ';
 }

/**
 * create mines & tiles array place mines 
 * update clues 
 *
 * @param newRows
 * number of rows for grid
 * @param newCols
 * number of columns for grid
 */
 private void initGame(int newRows, int newCols) {
 // allocate space for mines and tiles array
 if ((newRows >= 1) && (newCols >= 1)) {
 mines = new int[newRows][newCols];
 tiles = new int[newRows][newCols];
 // init tiles array
 resetTiles();
 // place mines
 placeMines();
 // update clues
 calculateClues();
 // set game status
 status = "play";
 }
 }

/**
 * Sets all tiles to 1 - closed
 */
 private void resetTiles() {
 for (int i = 0; i < tiles.length; i++) {
 for (int j = 0; j < tiles[i].length; j++) {
 tiles[i][j] = 1;
 }
 }
 }

/**
 * places mines randomly on grid integer value 9 represents a mine 
 * number of mines = (1 + number of columns * number rows) / 10 
 * minimum number of mines = 1 
 */
 private void placeMines() {
 int n = (1 + tiles.length * tiles[0].length) / 10;
 HashSet<Integer> set = getUniqueRandom(n, tiles.length
 * tiles[0].length);
 for (Integer i : set) {
 int r = i / tiles[0].length;
 int c = i % tiles[0].length;

           mines[r][c] = 9;
       }
   }

private HashSet<Integer> getUniqueRandom(int n, int range) {
 Random r = new Random();
 HashSet<Integer> set = new HashSet<>();
 while (set.size() < n) {
 set.add(r.nextInt(range));
 }
 return set;
 }

/**
 * calculates clue values and updates clue values in mines array 
 * integer value 9 represents a mine 
 * clue values will be 0 ... 8 
 */
 private void calculateClues() {
 for (int i = 0; i < mines.length; i++) {
 for (int j = 0; j < mines[i].length; j++) {
 if(mines[i][j] != 9) {
 int count = 0;
 if(validIndex(i+1, j + 1) && mines[i+1][j+1] == 9)
 count++;
 if(validIndex(i, j + 1) && mines[i][j+1] == 9)
 count++;
 if(validIndex(i-1, j + 1) && mines[i-1][j+1] == 9)
 count++;
 if(validIndex(i-1, j) && mines[i-1][j] == 9)
 count++;
 if(validIndex(i+1, j) && mines[i+1][j] == 9)
 count++;
 if(validIndex(i-1, j - 1) && mines[i-1][j-1] == 9)
 count++;
 if(validIndex(i, j - 1) && mines[i][j-1] == 9)
 count++;
 if(validIndex(i+1, j - 1) && mines[i+1][j-1] == 9)
 count++;

 mines[i][j] = count;
 }
 }
 }
 }

/**
 * determines if x,y is valid position
 *
 * @param x
 * row index
 * @param y
 * column index
 * @return true if valid position on board, false if not valid board
 * position
 */
 private boolean validIndex(int x, int y) {
 if(x < 0 || x>= tiles.length || y<0 || y >= tiles[0].length)
 return false;
 return true;
 }

/**
 * Level 2 - game won status
 *
 * @return true if game won false if game not won
 */
 private boolean gameWon() {
 int mines = 0;
 for (int i = 0; i < tiles.length; i++) {
 for (int j = 0; j < tiles[i].length; j++) {
 if(tiles[i][j] == 1 || tiles[i][j] == 2) {
 return false;
 }
 if(tiles[i][j] == 3) {
 mines++;
 }
 }
 }
 if(mines == (1 + tiles.length * tiles[0].length) / 10) {
 status = "win";
 return true;
 } else {
 return false;
 }
 }

   /*
   * Given num between 0 and 9, return the character representation of the
   * number
   */
   private char numToChar(int num) {
       return (char) ((char) num + '0');
   }
}

Navigate

I need help with my assignment I am supposed to use command prompt and sequel fo

I need help with my assignment please! In order to see the results of program pl

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

I need help with my assignment package mines; /** * minesweeper class provides t

Question

Explanation / Answer

Related Questions

Navigate