Untitled
unknown
plain_text
4 years ago
8.7 kB
3
Indexable
public ArrayList<ArrayList<Tile>> board;
/**
* 5 marks (Pass level)
*
* Constructor: create a board of size rows x columns
* containing Tiles of different colours using the
* random number generator as discussed in the assignment
* specification.
*
* Both rows and columns are going to be an integer > 0 and <= 1000.
* You can assume that rgen is going to be a valid Random object
* (rgen won't be null)
*
* You can look at the constructor for SimpleSameGame to get
* some ideas. To construct a Tile with a random colour, you
* can use.
*
* Tile random = new Tile(colors.get(rgen.nextInt(colors.size())),1);
*
* Remember that row 0 is the bottom-most row.
*
* @param rgen - the random number generator (non null)
* @param rows - the number of rows on the board, 0 < rows <= 1000
* @param columns - the number of columns on the board, 0 < columns <= 1000
*/
public SameGame(Random rgen, int rows, int columns) {
// do not modify the code involving the ArrayList colors
ArrayList<Color> colors = new ArrayList<Color>();
colors.add(Color.decode(ColorDef.BLUE));
colors.add(Color.decode(ColorDef.PURPLE));
colors.add(Color.decode(ColorDef.YELLOW));
colors.add(Color.decode(ColorDef.GREEN));
// start writing your code here
board = new ArrayList<ArrayList<Tile>>();
for(int i = 0; i < rows; i++) {
ArrayList<Tile> board2 = new ArrayList<>();
for(int k=0; k<columns; k++) {
int current = rgen.nextInt(colors.size());
board2.add(new Tile(colors.get(current),1));
}
board.add(board2);
}
}
/**
* 5 marks (Pass level)
*
* Computes the score obtained by the user at the end of the
* game. The score for the game is the number of tiles that
* the player manages to remove, so if the player removes 10
* tiles, then the player should receive a score of 10.
*
* The ideal way to complete this method is by completing the
* removeTile() method (e.g. by adding a point for each tile removed),
* but you should be able to obtain full marks even if you cannot
* implement removeTile() (see the JUnit test)
*
* @return the score obtained by the user
*/
public int calculateScore() {
// to be completed
return 0;
}
/**
* 5 marks (Pass level)
*
* Returns an instance copy of the board. Do not return a reference
* copy since the calling method may modify the returned ArrayList.
*
* @return an instance copy of the board
*/
public ArrayList<ArrayList<Tile>> getBoard() {
// to be completed
ArrayList<ArrayList<Tile>> instance = new ArrayList<ArrayList<Tile>>();
for(int i=0; i<board.size();i++) {
ArrayList<Tile> columns = new ArrayList<Tile>();
for(int j=0; j<board.get(i).size(); j++) {
columns.add(board.get(i).get(j));
}
instance.add(columns);
}
return instance;
}
/**
* 5 marks (Pass level)
*
* Checks if row i column j is a valid index, that is, if there is a
* tile on that location. Return false if i and j does not
* correspond to a valid index, or if a null value is found at
* that location.
*
* @param i - the row index
* @param j - the column index
* @return true if row i column j is a valid location that contains a Tile,
* false otherwise
*/
public boolean isValidIndex(int i, int j) {
if (i <0|| i>=board.size()) {
return false;
}else {
ArrayList<Tile> _board = board.get(i);
if(j <0|| j>=_board.size()) {
return false;
}
}
return true;
}
/**
* 10 marks (Pass level)
*
* Checks if it is legal to remove a tile on row i column j. A tile
* can be removed if there is an adjacent tile with the same colour
* (please see the assignment specification for more information).
* Return false if the location given is invalid.
*
* @param i - the row index
* @param j - the column index
* @return true if it is legal to remove the tile at row i column j,
* false otherwise
*/
public boolean isValidMove(int i, int j) {
if(!isValidIndex(i,j))
return false;
Tile c = board.get(i).get(j);
Tile up=null, down=null, next=null, prev=null;
if(i==0||i+1<board.size())
down = board.get(i+1).get(j);
if(i==board.size()-1||i-1>=0)
up = board.get(i-1).get(j);
if(j==0||j+1<board.get(i).size())
next = board.get(i).get(j+1);
if(j==board.get(i).size()-1||j-1>=0)
prev = board.get(i).get(j-1);
if (c==null) {
return false;
}
if (prev!=null) {
if (c.getColor()==prev.getColor())
return true;
}
if (next!=null) {
if (c.getColor() == next.getColor()) {
return true;
}
}
if (down!=null) {
if (c.getColor()==down.getColor())
return true;
}
if (up!=null) {
if (c.getColor() == up.getColor()) {
return true;
}
}
return false;
}
/**
* 5 marks (Pass level)
*
* Checks if the player has run out of moves, that is, if it is not possible
* to remove any more tiles from the board. Return true if there are no more
* tiles on the board.
*
* @return true if there are no more valid moves, false otherwise
*/
public boolean noMoreValidMoves() {
// to be completed
int count=0;
for(int i=0; i<board.size();i++) {
for(int j=0; j<board.get(i).size();j++) {
if(isValidMove(i,j))
count++;
}
}
return count==0;
}
/**
* 5 marks (Credit Level)
*
* Imagine two rows of Tiles, 'bottom' and 'top', with 'top' placed on top of 'bottom'.
*
* This method rearranges the two rows such that if there is an empty (i.e. null)
* slot in the 'bottom' row and there is a tile at the same index in the 'top' row,
* then it will move the tile down to 'bottom' row (effectively you are copying
* the tile into 'bottom', and set the index to null in 'top').
* You are basically moving tiles downward, but only between two rows.
*
* Don't do anything if the sizes of the two ArrayLists are not the same,
* or if one of them is null
*
* @param bottom - the bottom row of Tiles
* @param top - the top row of Tiles
*/
public void trickleDown(ArrayList<Tile> bottom, ArrayList<Tile> top) {
// to be completed
}
/** 5 marks (Credit Level)
*
* Rearranges the board so that all tiles are moved downwards and all empty columns are
* removed.
*
* You do not need to complete the deleteEmptyColumns() method to receive full
* marks for this method as it will not be tested in the JUnit test for this method,
* that is, the JUnit test for rearrangeBoard() will NOT test if your implementation
* of rearrangeBoard() removes the empty columns.
*
* However, a proper implementation of rearrangeBoard() SHOULD call deleteEmptyColumns()
* (after you move the tiles downwards), so if you manage to implement
* deleteEmptyColumns(), you need to call that method in rearrangeBoard().
*
* Hint: use the trickleDown() method (although you can also do it without
* calling trickleDown(), but calling trickleDown() will make the code simpler,
* albeit less efficient).
*
* @param board
*/
public void rearrangeBoard() {
// to be completed
}
/** 10 marks (Distinction Level)
*
* The following method removes all empty columns in the board.
* You MUST PASS testRearrangeBoard() before attempting deleteEmptyColumns,
* because the JUnit test will NOT directly test deleteEmptyColumns().
* The JUnit test will call rearrangeBoard(), assuming that you have
* implemented deleteEmptyColumns() properly and call it from rearrangeBoard().
*
*/
public void deleteEmptyColumns() {
// to be completed
}
/** 16 marks (High Distinction Level)
*
* The following method removes a tile at row i column j from the board
* and all adjacent tiles of the same colour, as per the game rules
* (as discussed in the assignment specification).
*
* The JUnit test suite will include one test that tries a large board
* (1000 x 1000) --- see testRemoveTileLarge. The removeTile method
* must finish within 10 seconds for you to pass this test (it is
* worth 5 marks)
*
* Do nothing if the given row and column index is not valid, or if it
* is not legal to move the tile.
*
* @param i - the row index of the tile to be removed
* @param j - the column index of the tile to be removed
*/
public void removeTile(int i, int j) {
// to be completed
}
}Editor is loading...