Hi, I need help with this assignment: ANSWER NEEDS TO USE THE SHELL PROGRAMS BEL
ID: 3871965 • Letter: H
Question
Hi, I need help with this assignment:
ANSWER NEEDS TO USE THE SHELL PROGRAMS BELOW:
THERE NEEDS TO BE 5 PROGRAMS, THE 4 SHELLS COMPLETED PLUS THE TESTER PROGRAM
WE ARE IN BASIC JAVA SO WE NEED TO FOLLOW THE INSTRUCTIONS AND NOT ADVANCED TECHNIQUES
you must use the declared arrays in the NumberTile, Hand, and Board classes as the principal data structure of each class
all instance variables in every class must be declared private
you must not use Arrays.copyOf or any other methods of the Arrays class
you must use the counter provided in each class as the upper bound on all loops that traverse the array
write a Java program to simulate playing a number tile game
Number tiles are squares with a number from 1 to 9 at each side. A “board” for the game is a sequence of number tiles satisfying this property:
The right side of each tile (except the last) = the left side of the next tile on the board
There are 2 players in the game, both of which are the computer. Each player starts with a "hand" of 5 number tiles. A move is made by a player removing tile from the hand and placing it on the board, if possible. A tile may be placed on the board in any of 3 ways:
As the new first tile
Between two adjacent tiles
As the new last tile
A number tile in the players hand can be rotated 90 degrees but once placed on the board its position is fixed
If none of the tiles in the hand can be placed on the board, then one random tile is added to the player's hand
A round is when player1 makes a move and then player2 makes a move (to make the game fair)
The game ends when all tiles are removed from one (or both) player's hand(s). If one player's hand is empty and the other player's hand still contains tiles, then the player with the empty hand is the winner. If both players’ hands are empty, then the game ends in a tie
III. Specifications
Your program will consist of 5 classes
The NumberTile class – models a number tile
The Hand class – models a player’s hand of number tiles
The Board class – models the board where tiles are inserted from the hands
The TileGame class – conducts the game
Test class with main method Use the skeletons of the NumberTile, Hand, Board, and TileGame classes, available online. Do not add or remove any methods, and do not modify any of the method declarations. Simply code the bodies of the method “stubs” where necessaryYour main method will do this and only this: Create a TileGame object, call the play() method, and then print the results returned by thetoString()method. After each game, ask whether the user wants to see another.
These are the classes:
NumberTile.java
Hand.java
Board.java
TileGame.java
Explanation / Answer
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
/**
* A NumberTile is a square tile with an int between 1 and 9, inclusive, on
* each side
*/
public class NumberTile implements Cloneable
{
private ArrayList<Integer> tile ;
/**
* Create a NumberTile object using 4 random ints in the range 1..9
*/
public NumberTile()
{
Random r = new Random();
Set<Integer> set = new HashSet<>();
while(set.size() < 4) {
set.add(r.nextInt(9) + 1);
}
tile = new ArrayList<>(set);
}
/**
* Rotate this tile 90 degrees clockwise
*/
public void rotate()
{
// remove from last position
int n = tile.remove(3);
// insert at first position
tile.add(0, n);
}
/**
* Get the number on the left side of this tile
* @return the number on the left side of this tile
*/
public int getLeft()
{
// DO NOT MODIFY THIS METHOD!
// =========================
return tile.get(0) ;
}
/**
* Get the number on the right side of this tile
* @return the number on the right side of this tile
*/
public int getRight()
{
// DO NOT MODIFY THIS METHOD!
// =========================
return tile.get(2) ;
}
/**
* Return a String representation of this tile in the form
*
* 4
* 5 7
* 1
*
* @return the tile as a multi-line String
*/
public String toString()
{
return String.format(" %5s %s%8s %5s ", tile.get(1), tile.get(0), tile.get(2), tile.get(3));
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
} // end of NumberTile class
Hand.java:
import java.util.ArrayList;
/**
* A Hand is a collection of NumberTiles. Tiles may be removed from
* the Hand and new tiles added to it
*/
public class Hand
{
private ArrayList<NumberTile> hand ;
private static int HAND_SIZE = 5 ; // starting hand size
/**
* Create a new Hand of HAND_SIZE tiles
*/
public Hand()
{
hand = new ArrayList<>();
for(int i=0; i<HAND_SIZE; i++) {
hand.add(new NumberTile());
}
}
/**
* Create a new Hand as an exact duplicate (i.e. a "deep copy") of another
* @param toBeCopied the Hand to be copied
* @throws CloneNotSupportedException
*/
public Hand(Hand toBeCopied) throws CloneNotSupportedException
{
hand = new ArrayList<>();
int size = toBeCopied.getSize();
for(int i=0; i<size; i++) {
hand.add((NumberTile) toBeCopied.get(i).clone());
}
}
/**
* Get the tile at a specified index in this Hand
* @param index the index (position) of the tile to be returned
* @return the NumberTile at the specified index
*/
public NumberTile get(int index)
{
return hand.get(index);
}
/**
* Get the size of this Hand
* @return the number of tiles in the Hand
*/
public int getSize()
{
// temporary return statement so skeleton will compile and run
return hand.size() ;
}
/**
* Add a new tile to this Hand
*/
public void addTile()
{
hand.add(new NumberTile());
}
/**
* Remove the tile at a specified index (position) from this Hand
* @param index the index (position) of the tile to be removed
*
*/
public void removeTile(int index)
{
hand.remove(index);
}
/**
* Is this Hand empty?
* @return true if this Hand is empty (contains no tiles); otherwise false
*
*/
public boolean isEmpty()
{
return hand.isEmpty() ;
}
/**
* Get a String representation of this Hand
* @return the NumberTiles in this Hand as a multi-line String
*/
public String toString()
{
// DO NOT MODIFY THIS METHOD!
// ==========================
return hand.toString() ; // call toString of ArrayList class
}
}
Board.java:
import java.util.ArrayList;
/**
* A Board is a collection of Number Tiles
*/
public class Board
{
private ArrayList<NumberTile> board ;
/**
* Create a new Board with one NumberTile
*/
public Board()
{
board = new ArrayList<>();
board.add(new NumberTile());
}
/**
* Get the tile at a specified index on this Board
* @param index the index (position) of the tile to be returned
* @return the NumberTile at the specified index
*/
public NumberTile getTile (int index)
{
return board.get(index);
}
/**
* Get the size of this Board
* @return the number of tiles on the Board
*/
public int getSize()
{
return board.size();
}
/**
* Add a new tile to this Board at a specified index (position)
* @param index the index (position) at which to insert the tile
* @param tile the tile to be inserted
*/
public void addTile(int index, NumberTile tile)
{
board.add(index, tile);
}
/**
* Get a String representation of this Board
* @return the NumberTiles on the Board as a multi-line String
*/
public String toString()
{
// DO NOT MODIFY THIS METHOD!
// ==========================
return board.toString() ; // call toString of ArrayList class
}
}
TileGame.java:
public class TileGame
{
// instance variable declarations go here
private Hand player1, player2;
private Board board;
private int turn = 1;
// Create a Tilegame object
public TileGame()
{
player1 = new Hand();
player2 = new Hand();
board = new Board();
}
// Play the game
public void play()
{
while(gameStatus() == -1) {
System.out.println(this + " ");
if(turn == 1) {
System.out.println("Turn: Player 1");
makeMove(player1);
} else {
System.out.println("Turn: Player 2");
makeMove(player2);
}
turn++;
if(turn == 3) {
turn = 1;
}
}
System.out.println(this + " ");
int status = gameStatus();
if(status == 0) {
System.out.println(" Its a Tie!!!");
} else if(status == 1) {
System.out.println(" Player1 won!!!");
} else if(status == 2) {
System.out.println(" Player2 won!!!");
}
System.out.println();
}
// If the current tile fits in the board, returns the index at which
// it will be inserted. If the tile does not fit, returns -1
private int getIndexForFit(NumberTile tile)
{
int size = board.getSize();
for(int i=0; i<size; i++) {
if(i==0) {
if(tile.getRight()==board.getTile(0).getLeft()) {
return i;
}
}
if(i==size-1) {
if(tile.getLeft()==board.getTile(size-1).getRight()) {
return size;
}
} else if(tile.getLeft()==board.getTile(i).getRight() && tile.getRight()==board.getTile(i+1).getLeft()) {
return i;
}
}
return -1;
}
// Make a move from a hand. If a tile in the hand fits on the board
// then remove it from the hand and place it in the board. The tile may
// be rotated up to 3 times. If no tile from the hand fits, then add
// another tile to the hand
private void makeMove(Hand hand)
{
for(int i=0; i<hand.getSize(); i++) {
NumberTile tile = hand.get(i);
int index = getIndexForFit(tile);
int count = 0;
while(count < 3) {
if(index != -1) {
board.addTile(index, tile);
hand.removeTile(i);
return;
}
tile.rotate();
index = getIndexForFit(tile);
count++;
}
}
// No tile was able to be adjusted
hand.addTile();
}
/*
* Returns 0 on tie, 1 for player 1 s winner, 2 for player 2 as winner
* -1 for no results till now
*/
int gameStatus(){
if(player1.getSize()==0 && player2.getSize()==0) {
return 0; // tie
} else if(player1.getSize()==0){
return 1;
} else if(player2.getSize()==0) {
return 2;
} else {
return -1;
}
}
// Get the results of the game as a humongous multi-line String containing
// both starting hands, the final board, both final hands, and a message
// indicating the winner
// HINT: call the toString methods of the Hand and Board classes
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("Player 1 Hands: ");
sb.append(player1 + " ");
sb.append("Player 2 Hands: ");
sb.append(player2 + " ");
sb.append("Board: ");
sb.append(board + " ");
return sb.toString();
}
public static void main(String args[]) {
TileGame tileGame = new TileGame();
tileGame.play();
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.